Rework LuCI build system
[project/luci.git] / libs / luci-lib-px5g / src / library / x509write.c
1 /*
2  *  X.509 certificate and private key writing
3  *
4  *  Copyright (C) 2006-2007  Pascal Vizeli <pvizeli@yahoo.de>
5  *  Modifications (C) 2009 Steven Barth <steven@midlink.org>
6  *
7  *  This library is free software; you can redistribute it and/or
8  *  modify it under the terms of the GNU Lesser General Public
9  *  License, version 2.1 as published by the Free Software Foundation.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19  *  MA  02110-1301  USA
20  */
21 /*
22  *  The ITU-T X.509 standard defines a certificat format for PKI.
23  *
24  *  http://www.ietf.org/rfc/rfc2459.txt
25  *  http://www.ietf.org/rfc/rfc3279.txt
26  *
27  *  ftp://ftp.rsasecurity.com/pub/pkcs/ascii/pkcs-1v2.asc
28  *
29  *  http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
30  *  http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
31  *
32  *  For CRS:
33  *  http://www.faqs.org/rfcs/rfc2314.html
34  */
35 #include "polarssl/config.h"
36 #include "polarssl/x509.h"
37 /* #include "polarssl/base64.h" */
38 #include "polarssl/sha1.h"
39
40 #include <string.h>
41 #include <stdlib.h>
42 #include <stdio.h>
43 #include <stdarg.h>
44 #include <time.h>
45
46 #define and &&
47 #define or ||
48
49 #if defined _MSC_VER && !defined snprintf
50 #define snprintf _snprintf
51 #endif
52
53 static int x509write_realloc_node(x509_node *node, size_t larger);
54 static int x509write_file(x509_node *node, char *path, int format, const char* pem_prolog, const char* pem_epilog);
55
56 /*
57  * evaluate how mani octet have this integer
58  */
59 static int asn1_eval_octet(unsigned int digit)
60 {
61     int i, byte;
62
63     for (byte = 4, i = 24; i >= 0; i -= 8, --byte)
64         if (((digit >> i) & 0xFF) != 0)
65             return byte;
66
67     return 0;
68 }
69
70 /*
71  * write the asn.1 lenght form into p
72  */
73 static int asn1_add_len(unsigned int size, x509_node *node)
74 {
75     if (size > 127) {
76
77         /* long size */
78         int byte = asn1_eval_octet(size);
79         int i = 0;
80
81         *(node->p) = (0x80 | byte) & 0xFF;
82         ++node->p;
83
84         for (i = byte; i > 0; --i) {
85
86             *(node->p) = (size >> ((i - 1) * 8)) & 0xFF;
87             ++node->p;
88         }
89
90     } else {
91
92         /* short size */
93         *(node->p) = size & 0xFF;
94         if (size != 0)
95             ++node->p;
96     }
97
98     return 0;
99 }
100
101 /*
102  * write a ans.1 object into p
103  */
104 static int asn1_add_obj(unsigned char *value, unsigned int size, int tag,
105         x509_node *node)
106 {
107     int tl = 2;
108
109     if (tag == ASN1_BIT_STRING)
110         ++tl;
111
112     if (size > 127)
113         x509write_realloc_node(node, (size_t) size + tl +
114                 asn1_eval_octet(size));
115     else
116         x509write_realloc_node(node, (size_t) size + tl);
117
118     if (node->data == NULL)
119         return 1;
120
121     /* tag */
122     *(node->p) = tag & 0xFF;
123     ++node->p;
124
125     /* len */
126     if (tag == ASN1_BIT_STRING) {
127         asn1_add_len((unsigned int) size + 1, node);
128         *(node->p) = 0x00;
129         ++node->p;
130     } else {
131         asn1_add_len((unsigned int) size, node);
132     }
133
134     /* value */
135     if (size > 0) {
136
137         memcpy(node->p, value, (size_t) size);
138         if ((node->p += size -1) != node->end)
139             return POLARSSL_ERR_X509_POINT_ERROR;
140     } else {
141         /* make nothing -> NULL */
142     }
143
144     return 0;
145 }
146
147 /*
148  * write a asn.1 conform integer object
149  */
150 static int asn1_add_int(signed int value, x509_node *node)
151 {
152     signed int i = 0, neg = 1;
153     unsigned int byte, u_val = 0, tmp_val = 0;
154
155     /* if negate? */
156     if (value < 0) {
157         neg = -1;
158         u_val = ~value;
159     } else {
160         u_val = value;
161     }
162
163     byte = asn1_eval_octet(u_val);
164     /* 0 isn't NULL */
165     if (byte == 0)
166         byte = 1;
167
168     /* ASN.1 integer is signed! */
169     if (byte < 4 and ((u_val >> ((byte -1) * 8)) & 0xFF) == 0x80)
170         byte += 1;
171
172     if (x509write_realloc_node(node, (size_t) byte + 2) != 0)
173         return 1;
174
175     /* tag */
176     *(node->p) = ASN1_INTEGER;
177     ++node->p;
178
179     /* len */
180     asn1_add_len(byte, node);
181
182     /* value */
183     for (i = byte; i > 0; --i) {
184
185         tmp_val = (u_val >> ((i - 1) * 8)) & 0xFF;
186         if (neg == 1)
187             *(node->p) = tmp_val;
188         else
189             *(node->p) = ~tmp_val;
190
191         if (i > 1)
192           ++node->p;
193     }
194
195     if (node->p != node->end)
196         return POLARSSL_ERR_X509_POINT_ERROR;
197
198     return 0;
199 }
200
201 /*
202  * write a asn.1 conform mpi object
203  */
204 static int asn1_add_mpi(mpi *value, int tag, x509_node *node)
205 {
206     size_t size = (mpi_msb(value) / 8) + 1;
207     unsigned char *buf;
208     int buf_len = (int) size, tl = 2;
209
210     if (tag == ASN1_BIT_STRING)
211         ++tl;
212
213     if (size > 127)
214         x509write_realloc_node(node, size + (size_t) tl +
215             asn1_eval_octet((unsigned int)size));
216     else
217         x509write_realloc_node(node, size + (size_t) tl);
218
219     if (node->data == NULL)
220         return 1;
221
222     buf = (unsigned char*) malloc(size);
223     if (mpi_write_binary(value, buf, buf_len) != 0)
224         return POLARSSL_ERR_MPI_BUFFER_TOO_SMALL;
225
226     /* tag */
227     *(node->p) = tag & 0xFF;
228     ++node->p;
229
230     /* len */
231     if (tag == ASN1_BIT_STRING) {
232         asn1_add_len((unsigned int) size + 1, node);
233         *(node->p) = 0x00;
234         ++node->p;
235     } else {
236         asn1_add_len((unsigned int) size, node);
237     }
238
239     /* value */
240     memcpy(node->p, buf, size);
241     free(buf);
242
243     if ((node->p += (int) size -1) != node->end)
244         return POLARSSL_ERR_X509_POINT_ERROR;
245
246     return 0;
247 }
248
249 /*
250  * write a node into asn.1 conform object
251  */
252 static int asn1_append_tag(x509_node *node, int tag)
253 {
254     int tl = 2;
255
256     x509_node tmp;
257     x509write_init_node(&tmp);
258
259     if (tag == ASN1_BIT_STRING)
260         ++tl;
261
262     if (node->len > 127)
263         x509write_realloc_node(&tmp, node->len + (size_t) tl +
264             asn1_eval_octet((unsigned int)node->len));
265     else
266         x509write_realloc_node(&tmp, node->len + (size_t) tl);
267
268     if (tmp.data == NULL) {
269         x509write_free_node(&tmp);
270         return 1;
271     }
272
273     /* tag */
274     *(tmp.p) = tag & 0xFF;
275     ++tmp.p;
276
277     /* len */
278     if (tag == ASN1_BIT_STRING) {
279         asn1_add_len((unsigned int) node->len + 1, &tmp);
280         *(tmp.p) = 0x00;
281         ++tmp.p;
282     } else {
283         asn1_add_len((unsigned int) node->len, &tmp);
284     }
285
286     /* value */
287     memcpy(tmp.p, node->data, node->len);
288
289     /* good? */
290     if ((tmp.p += (int) node->len -1) != tmp.end) {
291         x509write_free_node(&tmp);
292         return POLARSSL_ERR_X509_POINT_ERROR;
293     }
294
295     free(node->data);
296     node->data = tmp.data;
297     node->p = tmp.p;
298     node->end = tmp.end;
299     node->len = tmp.len;
300
301     return 0;
302 }
303
304 /*
305  * write nodes into a asn.1 object
306  */
307 static int asn1_append_nodes(x509_node *node, int tag, int anz, ...)
308 {
309     va_list ap;
310     size_t size = 0;
311     x509_node *tmp;
312     int count;
313
314     va_start(ap, anz);
315     count = anz;
316
317     while (count--) {
318
319         tmp = va_arg(ap, x509_node*);
320         if (tmp->data != NULL)
321             size += tmp->len;
322     }
323
324     if ( size > 127) {
325         if (x509write_realloc_node(node, size + (size_t) 2 +
326                     asn1_eval_octet(size)) != 0)
327             return 1;
328     } else {
329         if (x509write_realloc_node(node, size + (size_t) 2) != 0)
330             return 1;
331     }
332
333     /* tag */
334     *(node->p) = tag & 0xFF;
335     ++node->p;
336
337     /* len */
338     asn1_add_len(size, node);
339
340     /* value */
341     va_start(ap, anz);
342     count = anz;
343
344     while (count--) {
345
346         tmp = va_arg(ap, x509_node*);
347         if (tmp->data != NULL) {
348
349             memcpy(node->p, tmp->data, tmp->len);
350             if ((node->p += (int) tmp->len -1) != node->end)
351                 ++node->p;
352         }
353     }
354
355     va_end(ap);
356     return 0;
357 }
358
359 /*
360  * write a ASN.1 conform object identifiere include a "tag"
361  */
362 static int asn1_add_oid(x509_node *node, unsigned char *oid, size_t len,
363         int tag, int tag_val, unsigned char *value, size_t val_len)
364 {
365     int ret;
366     x509_node tmp;
367
368     x509write_init_node(&tmp);
369
370     /* OBJECT IDENTIFIER */
371     if ((ret = asn1_add_obj(oid, len, ASN1_OID, &tmp)) != 0) {
372         x509write_free_node(&tmp);
373         return ret;
374     }
375
376     /* value */
377     if ((ret = asn1_add_obj(value, val_len, tag_val, &tmp)) != 0) {
378         x509write_free_node(&tmp);
379         return ret;
380     }
381
382     /* SET/SEQUENCE */
383     if ((ret = asn1_append_nodes(node, tag, 1, &tmp)) != 0) {
384         x509write_free_node(&tmp);
385         return ret;
386     }
387
388     x509write_free_node(&tmp);
389     return 0;
390 }
391
392 /*
393  *  utcTime        UTCTime
394  */
395 static int asn1_add_date_utc(unsigned char *time, x509_node *node)
396 {
397     unsigned char date[13], *sp;
398     x509_time xtime;
399     int ret;
400
401     sscanf((char*)time, "%d-%d-%d %d:%d:%d", &xtime.year, &xtime.mon,
402         &xtime.day, &xtime.hour, &xtime.min, &xtime.sec);
403
404     /* convert to YY */
405     if (xtime.year > 2000)
406         xtime.year -= 2000;
407     else
408         xtime.year -= 1900;
409
410     snprintf((char*)date, 13, "%2d%2d%2d%2d%2d%2d", xtime.year, xtime.mon, xtime.day,
411         xtime.hour, xtime.min, xtime.sec);
412
413     /* replace ' ' to '0' */
414     for (sp = date; *sp != '\0'; ++sp)
415         if (*sp == '\x20')
416             *sp = '\x30';
417
418     date[12] = 'Z';
419
420     if ((ret = asn1_add_obj(date, 13, ASN1_UTC_TIME, node)) != 0)
421         return ret;
422
423     return 0;
424 }
425
426 /*
427  * serialize an rsa key into DER
428  */
429
430 int x509write_serialize_key(rsa_context *rsa, x509_node *node)
431 {
432     int ret = 0;
433     x509write_init_node(node);
434
435     /*┬ávers, n, e, d, p, q, dp, dq, pq */
436     if ((ret = asn1_add_int(rsa->ver, node)) != 0)
437         return ret;
438     if ((ret = asn1_add_mpi(&rsa->N, ASN1_INTEGER, node)) != 0)
439         return ret;
440     if ((ret = asn1_add_mpi(&rsa->E, ASN1_INTEGER, node)) != 0)
441         return ret;
442     if ((ret = asn1_add_mpi(&rsa->D, ASN1_INTEGER, node)) != 0)
443         return ret;
444     if ((ret = asn1_add_mpi(&rsa->P, ASN1_INTEGER, node)) != 0)
445         return ret;
446     if ((ret = asn1_add_mpi(&rsa->Q, ASN1_INTEGER, node)) != 0)
447         return ret;
448     if ((ret = asn1_add_mpi(&rsa->DP, ASN1_INTEGER, node)) != 0)
449         return ret;
450     if ((ret = asn1_add_mpi(&rsa->DQ, ASN1_INTEGER, node)) != 0)
451         return ret;
452     if ((ret = asn1_add_mpi(&rsa->QP, ASN1_INTEGER, node)) != 0)
453         return ret;
454     if ((ret = asn1_append_tag(node, ASN1_CONSTRUCTED | ASN1_SEQUENCE)) != 0)
455         return ret;
456
457     return 0;
458 }
459
460 /*
461  * write a der/pem encoded rsa private key into a file
462  */
463 int x509write_keyfile(rsa_context *rsa, char *path, int out_flag)
464 {
465     int ret = 0;
466     const char  key_beg[] = "-----BEGIN RSA PRIVATE KEY-----\n",
467                 key_end[] = "-----END RSA PRIVATE KEY-----\n";
468     x509_node node;
469
470     x509write_init_node(&node);
471     if ((ret = x509write_serialize_key(rsa,&node)) != 0) {
472         x509write_free_node(&node);
473               return ret;
474     }
475
476     ret = x509write_file(&node,path,out_flag,key_beg,key_end);
477     x509write_free_node(&node);
478
479     return ret;
480 }
481
482
483 /*
484  * reasize the memory for node
485  */
486 static int x509write_realloc_node(x509_node *node, size_t larger)
487 {
488     /* init len */
489     if (node->data == NULL) {
490         node->len = 0;
491         node->data = malloc(larger);
492         if(node->data == NULL)
493             return 1;
494     } else {
495         /* realloc memory */
496         if ((node->data = realloc(node->data, node->len + larger)) == NULL)
497             return 1;
498     }
499
500     /* init pointer */
501     node->p = &node->data[node->len];
502     node->len += larger;
503     node->end = &node->data[node->len -1];
504
505     return 0;
506 }
507
508 /*
509  * init node
510  */
511 void x509write_init_node(x509_node *node)
512 {
513     memset(node, 0, sizeof(x509_node));
514 }
515
516 /*
517  * clean memory
518  */
519 void x509write_free_node(x509_node *node)
520 {
521     if (node->data != NULL)
522         free(node->data);
523     node->p = NULL;
524     node->end = NULL;
525     node->len = 0;
526 }
527
528 /*
529  * write a x509 certificate into file
530  */
531 int x509write_crtfile(x509_raw *chain, unsigned char *path, int out_flag)
532 {
533     const char  cer_beg[] = "-----BEGIN CERTIFICATE-----\n",
534                 cer_end[] = "-----END CERTIFICATE-----\n";
535
536     return x509write_file(&chain->raw, (char*)path, out_flag, cer_beg, cer_end);
537 }
538
539 /*
540  * write a x509 certificate into file
541  */
542 int x509write_csrfile(x509_raw *chain, unsigned char *path, int out_flag)
543 {
544     const char  cer_beg[] = "-----BEGIN CERTIFICATE REQUEST-----\n",
545                 cer_end[] = "-----END CERTIFICATE REQUEST-----\n";
546
547     return x509write_file(&chain->raw, (char*)path, out_flag, cer_beg, cer_end);
548 }
549
550 /*
551  * write an x509 file
552  */
553 static int x509write_file(x509_node *node, char *path, int format,
554         const char* pem_prolog, const char* pem_epilog)
555 {
556     FILE *ofstream;
557     int is_err = 1/*, buf_len, i, n*/;
558     /* char* base_buf; */
559
560     if ((ofstream = fopen(path, "wb")) == NULL)
561         return 1;
562
563     switch (format) {
564         case X509_OUTPUT_DER:
565             if (fwrite(node->data, 1, node->len, ofstream)
566                 != node->len)
567                 is_err = -1;
568             break;
569 /*
570         case X509_OUTPUT_PEM:
571             if (fprintf(ofstream,pem_prolog)<0) {
572                 is_err = -1;
573                 break;
574             }
575
576             buf_len = node->len << 1;
577             base_buf = (char*) malloc((size_t)buf_len);
578             memset(base_buf,0,buf_len);
579             if (base64_encode(base_buf, &buf_len, node->data,
580                         (int) node->len) != 0) {
581                 is_err = -1;
582                 break;
583             }
584
585             n=strlen(base_buf);
586             for(i=0;i<n;i+=64) {
587                 fprintf(ofstream,"%.64s\n",&base_buf[i]);
588             }
589
590             if (fprintf(ofstream, pem_epilog)<0) {
591                 is_err = -1;
592                 break;
593             }
594
595             free(base_buf); */
596     }
597
598     fclose(ofstream);
599
600     if (is_err == -1)
601         return 1;
602
603     return 0;
604 }
605
606
607 /*
608  * add the owner public key to x509 certificate
609  */
610 int x509write_add_pubkey(x509_raw *chain, rsa_context *pubkey)
611 {
612     x509_node n_tmp, n_tmp2, *node;
613     int ret;
614
615     node = &chain->subpubkey;
616
617     x509write_init_node(&n_tmp);
618     x509write_init_node(&n_tmp2);
619
620     /*
621     *  RSAPublicKey ::= SEQUENCE {
622     *      modulus           INTEGER,  -- n
623     *      publicExponent    INTEGER   -- e
624     *  }
625     */
626     if ((ret = asn1_add_mpi(&pubkey->N, ASN1_INTEGER, &n_tmp)) != 0) {
627         x509write_free_node(&n_tmp);
628         x509write_free_node(&n_tmp2);
629         return ret;
630     }
631     if ((ret = asn1_add_mpi(&pubkey->E, ASN1_INTEGER, &n_tmp)) != 0) {
632         x509write_free_node(&n_tmp);
633         x509write_free_node(&n_tmp2);
634         return ret;
635     }
636     if ((ret = asn1_append_tag(&n_tmp, ASN1_CONSTRUCTED | ASN1_SEQUENCE))
637             != 0) {
638         x509write_free_node(&n_tmp);
639         x509write_free_node(&n_tmp2);
640         return ret;
641     }
642
643     /*
644      *  SubjectPublicKeyInfo  ::=  SEQUENCE  {
645      *       algorithm            AlgorithmIdentifier,
646      *       subjectPublicKey     BIT STRING }
647      */
648     if ((ret = asn1_append_tag(&n_tmp, ASN1_BIT_STRING)) != 0) {
649         x509write_free_node(&n_tmp);
650         x509write_free_node(&n_tmp2);
651        return ret;
652     }
653     if ((ret = asn1_add_oid(&n_tmp2, (unsigned char*)OID_PKCS1_RSA, 9,
654                   ASN1_CONSTRUCTED | ASN1_SEQUENCE, ASN1_NULL,
655                   (unsigned char *)"", 0)) != 0) {
656         x509write_free_node(&n_tmp);
657         x509write_free_node(&n_tmp2);
658         return ret;
659     }
660
661     if ((ret = asn1_append_nodes(node, ASN1_CONSTRUCTED | ASN1_SEQUENCE, 2,
662                    &n_tmp2, &n_tmp))) {
663         x509write_free_node(&n_tmp);
664         x509write_free_node(&n_tmp2);
665         return ret;
666     }
667
668     x509write_free_node(&n_tmp);
669     x509write_free_node(&n_tmp2);
670     return 0;
671 }
672
673 /*
674  *  RelativeDistinguishedName ::=
675  *    SET OF AttributeTypeAndValue
676  *
677  *  AttributeTypeAndValue ::= SEQUENCE {
678  *    type     AttributeType,
679  *    value    AttributeValue }
680  */
681 static int x509write_add_name(x509_node *node, unsigned char *oid,
682         unsigned int oid_len, unsigned char *value, int len, int value_tag)
683 {
684     int ret;
685     x509_node n_tmp;
686
687     x509write_init_node(&n_tmp);
688
689     if ((ret = asn1_add_oid(&n_tmp, oid, oid_len,
690                 ASN1_CONSTRUCTED | ASN1_SEQUENCE, value_tag,
691                 value, len))) {
692         x509write_free_node(&n_tmp);
693         return ret;
694     }
695
696     if ((asn1_append_nodes(node, ASN1_CONSTRUCTED | ASN1_SET, 1, &n_tmp))
697             != 0) {
698         x509write_free_node(&n_tmp);
699         return ret;
700     }
701
702     x509write_free_node(&n_tmp);
703     return 0;
704 }
705
706 /*
707  * Parse the name string and add to node
708  */
709 static int x509write_parse_names(x509_node *node, unsigned char *names)
710 {
711     unsigned char *sp, *begin = NULL;
712     unsigned char oid[3] = OID_X520, tag[4], *tag_sp = tag;
713     unsigned char *C = NULL, *CN = NULL, *O = NULL, *OU = NULL,
714                   *ST = NULL, *L = NULL, *R = NULL;
715     int C_len = 0, CN_len = 0, O_len = 0, OU_len = 0, ST_len = 0,
716                 L_len = 0, R_len = 0;
717     int ret = 0, is_tag = 1, is_begin = -1, len = 0;
718
719
720     for (sp = names; ; ++sp) {
721
722         /* filter tag */
723         if (is_tag == 1) {
724
725             if (tag_sp == &tag[3])
726                 return POLARSSL_ERR_X509_VALUE_TO_LENGTH;
727
728             /* is tag end? */
729             if (*sp == '=') {
730                 is_tag = -1;
731                 *tag_sp = '\0';
732                 is_begin = 1;
733                 /* set len 0 (reset) */
734                 len = 0;
735             } else {
736                 /* tag hasn't ' '! */
737                 if (*sp != ' ') {
738                     *tag_sp = *sp;
739                     ++tag_sp;
740                 }
741             }
742         /* filter value */
743         } else {
744
745             /* set pointer of value begin */
746             if (is_begin == 1) {
747                 begin = sp;
748                 is_begin = -1;
749             }
750
751             /* is value at end? */
752             if (*sp == ';' or *sp == '\0') {
753                 is_tag = 1;
754
755                 /* common name */
756                 if (tag[0] == 'C' and tag[1] == 'N') {
757                     CN = begin;
758                     CN_len = len;
759
760                 /* organization */
761                 } else if (tag[0] == 'O' and tag[1] == '\0') {
762                     O = begin;
763                     O_len = len;
764
765                 /* country */
766                 } else if (tag[0] == 'C' and tag[1] == '\0') {
767                     C = begin;
768                     C_len = len;
769
770                 /* organisation unit */
771                 } else if (tag[0] == 'O' and tag[1] == 'U') {
772                     OU = begin;
773                     OU_len = len;
774
775                 /* state */
776                 } else if (tag[0] == 'S' and tag[1] == 'T') {
777                     ST = begin;
778                     ST_len = len;
779
780                 /* locality */
781                 } else if (tag[0] == 'L' and tag[1] == '\0') {
782                     L = begin;
783                     L_len = len;
784
785                 /* email */
786                 } else if (tag[0] == 'R' and tag[1] == '\0') {
787                     R = begin;
788                     R_len = len;
789                 }
790
791                 /* set tag poiner to begin */
792                 tag_sp = tag;
793
794                 /* is at end? */
795                 if (*sp == '\0' or *(sp +1) == '\0')
796                     break;
797             } else {
798                 ++len;
799             }
800         }
801
802         /* make saver */
803         if (*sp == '\0')
804           break;
805     } /* end for */
806
807     /* country */
808     if (C != NULL) {
809         oid[2] = X520_COUNTRY;
810         if ((ret = x509write_add_name(node, oid, 3, C, C_len,
811                         ASN1_PRINTABLE_STRING)) != 0)
812             return ret;
813     }
814
815     /* state */
816     if (ST != NULL) {
817         oid[2] = X520_STATE;
818         if ((ret = x509write_add_name(node, oid, 3, ST, ST_len,
819                         ASN1_PRINTABLE_STRING)) != 0)
820             return ret;
821     }
822
823     /* locality */
824     if (L != NULL) {
825         oid[2] = X520_LOCALITY;
826         if ((ret = x509write_add_name(node, oid, 3, L, L_len,
827                         ASN1_PRINTABLE_STRING)) != 0)
828             return ret;
829     }
830
831     /* organization */
832     if (O != NULL) {
833         oid[2] = X520_ORGANIZATION;
834         if ((ret = x509write_add_name(node, oid, 3, O, O_len,
835                         ASN1_PRINTABLE_STRING)) != 0)
836             return ret;
837     }
838
839     /* organisation unit */
840     if (OU != NULL) {
841         oid[2] = X520_ORG_UNIT;
842         if ((ret = x509write_add_name(node, oid, 3, OU, OU_len,
843                         ASN1_PRINTABLE_STRING)) != 0)
844             return ret;
845     }
846
847     /* common name */
848     if (CN != NULL) {
849         oid[2] = X520_COMMON_NAME;
850         if ((ret = x509write_add_name(node, oid, 3, CN, CN_len,
851                         ASN1_PRINTABLE_STRING)) != 0)
852             return ret;
853     }
854
855     /* email */
856     if (R != NULL) {
857         if ((ret = x509write_add_name(node, (unsigned char*)OID_PKCS9_EMAIL,
858                         9, R, R_len, ASN1_IA5_STRING)) != 0)
859             return ret;
860     }
861
862     if ((asn1_append_tag(node, ASN1_CONSTRUCTED | ASN1_SEQUENCE)) != 0)
863         return ret;
864
865     return 0;
866 }
867
868 /*
869  * Copy raw data from orginal ca to node
870  */
871 static int x509write_copy_from_raw(x509_node *node, x509_buf *raw)
872 {
873     if (x509write_realloc_node(node, raw->len) != 0)
874         return 1;
875
876     memcpy(node->p, raw->p, (size_t)raw->len);
877     if ((node->p += raw->len -1) != node->end)
878         return POLARSSL_ERR_X509_POINT_ERROR;
879
880     return 0;
881 }
882
883 /*
884  * Add the issuer
885  */
886
887 int x509write_add_issuer(x509_raw *crt, unsigned char *issuer)
888 {
889     return x509write_parse_names(&crt->issuer, issuer);
890 }
891
892 /*
893  * Add the subject
894  */
895 int x509write_add_subject(x509_raw *crt, unsigned char *subject)
896 {
897     return x509write_parse_names(&crt->subject, subject);
898 }
899
900 /*
901  * Copy issuer line from another cert to issuer
902  */
903 int x509write_copy_issuer(x509_raw *crt, x509_cert *from_crt)
904 {
905     return x509write_copy_from_raw(&crt->issuer, &from_crt->issuer_raw);
906 }
907
908 /*
909  * Copy subject line from another cert
910  */
911 int x509write_copy_subject(x509_raw *crt, x509_cert *from_crt)
912 {
913     return x509write_copy_from_raw(&crt->subject, &from_crt->subject_raw);
914 }
915
916 /*
917  * Copy subject line form antoher cert into issuer
918  */
919 int x509write_copy_issuer_form_subject(x509_raw *crt,
920         x509_cert *from_crt)
921 {
922     return x509write_copy_from_raw(&crt->issuer, &from_crt->subject_raw);
923 }
924
925 /*
926  * Copy issuer line from another cert into subject
927  */
928 int x509write_copy_subject_from_issuer(x509_raw *crt,
929         x509_cert * from_crt)
930 {
931     return x509write_copy_from_raw(&crt->subject, &from_crt->issuer_raw);
932 }
933
934 /*
935  *  Validity ::= SEQUENCE {
936  *       notBefore      Time,
937  *       notAfter       Time }
938  *
939  *  Time ::= CHOICE {
940  *       utcTime        UTCTime,
941  *       generalTime    GeneralizedTime }
942  */
943 /* TODO: No handle GeneralizedTime! */
944 int x509write_add_validity(x509_raw *chain, unsigned char *befor,
945         unsigned char *after)
946 {
947     int ret;
948
949     x509_node *node = &chain->validity;
950
951     /* notBefore */
952     if ((ret = asn1_add_date_utc(befor, node)) != 0)
953         return ret;
954
955     /* notAfter */
956     if ((ret = asn1_add_date_utc(after, node)) != 0)
957         return ret;
958
959     if ((ret = asn1_append_tag(node, ASN1_CONSTRUCTED | ASN1_SEQUENCE)) != 0)
960         return ret;
961
962     return 0;
963 }
964
965 /*
966  * make hash from tbs and sign that with private key
967  */
968 static int x509write_make_sign(x509_raw *chain, rsa_context *privkey)
969 {
970     int ret;
971     unsigned char hash[20], *sign;
972     size_t sign_len = (size_t) mpi_size(&privkey->N);
973
974     /* make hash */
975     sha1(chain->tbs.data, chain->tbs.len, hash);
976
977     /* create sign */
978     sign = (unsigned char *) malloc(sign_len);
979     if (sign == NULL)
980         return 1;
981
982     if ((ret = rsa_pkcs1_sign(privkey, RSA_PRIVATE, RSA_SHA1, 20, hash,
983                     sign)) != 0)
984         return ret;
985
986     if ((ret = asn1_add_obj(sign, sign_len, ASN1_BIT_STRING,
987                     &chain->sign)) != 0)
988         return ret;
989
990     /*
991      *  AlgorithmIdentifier  ::=  SEQUENCE  {
992      *       algorithm               OBJECT IDENTIFIER,
993      *       parameters              ANY DEFINED BY algorithm OPTIONAL  }
994      */
995     return asn1_add_oid(&chain->signalg, (unsigned char*)OID_PKCS1_RSA_SHA, 9,
996                   ASN1_CONSTRUCTED | ASN1_SEQUENCE, ASN1_NULL,
997                   (unsigned char*)"", 0);
998 }
999
1000 /*
1001  * Create a self signed certificate
1002  */
1003 int x509write_create_sign(x509_raw *chain, rsa_context *privkey)
1004 {
1005     int ret, serial;
1006
1007     /*
1008      *  Version  ::=  INTEGER  {  v1(0), v2(1), v3(2)  }
1009      */
1010     if ((ret = asn1_add_int(2, &chain->version)) != 0)
1011         return ret;
1012
1013     if ((ret = asn1_append_tag(&chain->version, ASN1_CONTEXT_SPECIFIC |
1014                     ASN1_CONSTRUCTED)) != 0)
1015         return ret;
1016
1017
1018     /*
1019      *  CertificateSerialNumber  ::=  INTEGER
1020      */
1021     srand((unsigned int) time(NULL));
1022     serial = rand();
1023     if ((ret = asn1_add_int(serial, &chain->serial)) != 0)
1024         return ret;
1025
1026     /*
1027      *  AlgorithmIdentifier  ::=  SEQUENCE  {
1028      *       algorithm               OBJECT IDENTIFIER,
1029      *       parameters              ANY DEFINED BY algorithm OPTIONAL  }
1030      */
1031     if ((ret = asn1_add_oid(&chain->tbs_signalg,
1032                                 (unsigned char*)OID_PKCS1_RSA_SHA, 9, ASN1_CONSTRUCTED |
1033                                 ASN1_SEQUENCE, ASN1_NULL, (unsigned char*)"", 0)) != 0)
1034         return ret;
1035
1036    /*
1037     *  Create the tbs
1038     */
1039     if ((ret = asn1_append_nodes(&chain->tbs, ASN1_CONSTRUCTED |
1040                     ASN1_SEQUENCE, 7, &chain->version, &chain->serial,
1041                     &chain->tbs_signalg, &chain->issuer, &chain->validity,
1042                     &chain->subject, &chain->subpubkey)) != 0)
1043         return ret;
1044
1045     /* make signing */
1046     if ((ret = x509write_make_sign(chain, privkey)) != 0)
1047         return ret;
1048
1049     /* finishing */
1050     if ((ret = asn1_append_nodes(&chain->raw, ASN1_CONSTRUCTED |
1051                     ASN1_SEQUENCE, 3, &chain->tbs, &chain->signalg,
1052                     &chain->sign)) != 0)
1053         return ret;
1054
1055     return 0;
1056 }
1057
1058 int x509write_create_selfsign(x509_raw *chain, rsa_context *privkey)
1059 {
1060     /*
1061      * On self signed certificate are subject and issuer the same
1062      */
1063     x509write_free_node(&chain->issuer);
1064     chain->issuer = chain->subject;
1065     return x509write_create_sign(chain, privkey);
1066 }
1067
1068 /*
1069  * CertificationRequestInfo ::= SEQUENCE                    {
1070  *    version                       Version,
1071  *    subject                       Name,
1072  *    subjectPublicKeyInfo          SubjectPublicKeyInfo,
1073  *    attributes                    [0] IMPLICIT Attributes }
1074  *
1075  * CertificationRequest ::=   SEQUENCE                      {
1076  *    certificationRequestInfo  CertificationRequestInfo,
1077  *    signatureAlgorithm        SignatureAlgorithmIdentifier,
1078  *    signature                 Signature                   }
1079  *
1080  * It use chain.serail for attributes!
1081  *
1082  */
1083 int x509write_create_csr(x509_raw *chain, rsa_context *privkey)
1084 {
1085     int ret;
1086
1087     /* version ::= INTEGER */
1088     if ((ret = asn1_add_int(0, &chain->version)) != 0)
1089         return ret;
1090
1091     /* write attributes */
1092     if ((ret = asn1_add_obj((unsigned char*)"", 0, ASN1_CONTEXT_SPECIFIC |
1093                     ASN1_CONSTRUCTED, &chain->serial)) != 0)
1094         return ret;
1095
1096     /* create CertificationRequestInfo */
1097     if ((ret = asn1_append_nodes(&chain->tbs, ASN1_CONSTRUCTED |
1098                     ASN1_SEQUENCE, 4, &chain->version, &chain->subject,
1099                     &chain->subpubkey, &chain->serial)) != 0)
1100         return ret;
1101
1102     /* make signing */
1103     if ((ret = x509write_make_sign(chain, privkey)) != 0)
1104         return ret;
1105
1106     /* finish */
1107     if ((ret = asn1_append_nodes(&chain->raw, ASN1_CONSTRUCTED | ASN1_SEQUENCE,
1108                     3, &chain->tbs, &chain->signalg, &chain->sign)) != 0)
1109         return ret;
1110
1111     return ret;
1112 }
1113
1114 /*
1115  * Free memory
1116  */
1117 void x509write_free_raw(x509_raw *chain)
1118 {
1119     x509write_free_node(&chain->raw);
1120     x509write_free_node(&chain->tbs);
1121     x509write_free_node(&chain->version);
1122     x509write_free_node(&chain->serial);
1123     x509write_free_node(&chain->tbs_signalg);
1124     x509write_free_node(&chain->issuer);
1125     x509write_free_node(&chain->validity);
1126     if (chain->subject.data != chain->issuer.data)
1127         x509write_free_node(&chain->subject);
1128     x509write_free_node(&chain->subpubkey);
1129     x509write_free_node(&chain->signalg);
1130     x509write_free_node(&chain->sign);
1131 }
1132
1133 void x509write_init_raw(x509_raw *chain)
1134 {
1135     memset((void *) chain, 0, sizeof(x509_raw));
1136 }
1137