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