PolarSSL v1.1.3
|
00001 /* 00002 * X.509 certificate and private key decoding 00003 * 00004 * Copyright (C) 2006-2011, Brainspark B.V. 00005 * 00006 * This file is part of PolarSSL (http://www.polarssl.org) 00007 * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org> 00008 * 00009 * All rights reserved. 00010 * 00011 * This program is free software; you can redistribute it and/or modify 00012 * it under the terms of the GNU General Public License as published by 00013 * the Free Software Foundation; either version 2 of the License, or 00014 * (at your option) any later version. 00015 * 00016 * This program is distributed in the hope that it will be useful, 00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00019 * GNU General Public License for more details. 00020 * 00021 * You should have received a copy of the GNU General Public License along 00022 * with this program; if not, write to the Free Software Foundation, Inc., 00023 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 00024 */ 00025 /* 00026 * The ITU-T X.509 standard defines a certificat format for PKI. 00027 * 00028 * http://www.ietf.org/rfc/rfc2459.txt 00029 * http://www.ietf.org/rfc/rfc3279.txt 00030 * 00031 * ftp://ftp.rsasecurity.com/pub/pkcs/ascii/pkcs-1v2.asc 00032 * 00033 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf 00034 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf 00035 */ 00036 00037 #include "polarssl/config.h" 00038 00039 #if defined(POLARSSL_X509_PARSE_C) 00040 00041 #include "polarssl/x509.h" 00042 #include "polarssl/asn1.h" 00043 #include "polarssl/pem.h" 00044 #include "polarssl/des.h" 00045 #include "polarssl/md2.h" 00046 #include "polarssl/md4.h" 00047 #include "polarssl/md5.h" 00048 #include "polarssl/sha1.h" 00049 #include "polarssl/sha2.h" 00050 #include "polarssl/sha4.h" 00051 #include "polarssl/dhm.h" 00052 00053 #include <string.h> 00054 #include <stdlib.h> 00055 #if defined(_WIN32) 00056 #include <windows.h> 00057 #else 00058 #include <time.h> 00059 #endif 00060 00061 #if defined(POLARSSL_FS_IO) 00062 #include <stdio.h> 00063 #endif 00064 00065 /* 00066 * Version ::= INTEGER { v1(0), v2(1), v3(2) } 00067 */ 00068 static int x509_get_version( unsigned char **p, 00069 const unsigned char *end, 00070 int *ver ) 00071 { 00072 int ret; 00073 size_t len; 00074 00075 if( ( ret = asn1_get_tag( p, end, &len, 00076 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ) != 0 ) 00077 { 00078 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00079 { 00080 *ver = 0; 00081 return( 0 ); 00082 } 00083 00084 return( ret ); 00085 } 00086 00087 end = *p + len; 00088 00089 if( ( ret = asn1_get_int( p, end, ver ) ) != 0 ) 00090 return( POLARSSL_ERR_X509_CERT_INVALID_VERSION + ret ); 00091 00092 if( *p != end ) 00093 return( POLARSSL_ERR_X509_CERT_INVALID_VERSION + 00094 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00095 00096 return( 0 ); 00097 } 00098 00099 /* 00100 * Version ::= INTEGER { v1(0), v2(1) } 00101 */ 00102 static int x509_crl_get_version( unsigned char **p, 00103 const unsigned char *end, 00104 int *ver ) 00105 { 00106 int ret; 00107 00108 if( ( ret = asn1_get_int( p, end, ver ) ) != 0 ) 00109 { 00110 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00111 { 00112 *ver = 0; 00113 return( 0 ); 00114 } 00115 00116 return( POLARSSL_ERR_X509_CERT_INVALID_VERSION + ret ); 00117 } 00118 00119 return( 0 ); 00120 } 00121 00122 /* 00123 * CertificateSerialNumber ::= INTEGER 00124 */ 00125 static int x509_get_serial( unsigned char **p, 00126 const unsigned char *end, 00127 x509_buf *serial ) 00128 { 00129 int ret; 00130 00131 if( ( end - *p ) < 1 ) 00132 return( POLARSSL_ERR_X509_CERT_INVALID_SERIAL + 00133 POLARSSL_ERR_ASN1_OUT_OF_DATA ); 00134 00135 if( **p != ( ASN1_CONTEXT_SPECIFIC | ASN1_PRIMITIVE | 2 ) && 00136 **p != ASN1_INTEGER ) 00137 return( POLARSSL_ERR_X509_CERT_INVALID_SERIAL + 00138 POLARSSL_ERR_ASN1_UNEXPECTED_TAG ); 00139 00140 serial->tag = *(*p)++; 00141 00142 if( ( ret = asn1_get_len( p, end, &serial->len ) ) != 0 ) 00143 return( POLARSSL_ERR_X509_CERT_INVALID_SERIAL + ret ); 00144 00145 serial->p = *p; 00146 *p += serial->len; 00147 00148 return( 0 ); 00149 } 00150 00151 /* 00152 * AlgorithmIdentifier ::= SEQUENCE { 00153 * algorithm OBJECT IDENTIFIER, 00154 * parameters ANY DEFINED BY algorithm OPTIONAL } 00155 */ 00156 static int x509_get_alg( unsigned char **p, 00157 const unsigned char *end, 00158 x509_buf *alg ) 00159 { 00160 int ret; 00161 size_t len; 00162 00163 if( ( ret = asn1_get_tag( p, end, &len, 00164 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00165 return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret ); 00166 00167 end = *p + len; 00168 alg->tag = **p; 00169 00170 if( ( ret = asn1_get_tag( p, end, &alg->len, ASN1_OID ) ) != 0 ) 00171 return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret ); 00172 00173 alg->p = *p; 00174 *p += alg->len; 00175 00176 if( *p == end ) 00177 return( 0 ); 00178 00179 /* 00180 * assume the algorithm parameters must be NULL 00181 */ 00182 if( ( ret = asn1_get_tag( p, end, &len, ASN1_NULL ) ) != 0 ) 00183 return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret ); 00184 00185 if( *p != end ) 00186 return( POLARSSL_ERR_X509_CERT_INVALID_ALG + 00187 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00188 00189 return( 0 ); 00190 } 00191 00192 /* 00193 * AttributeTypeAndValue ::= SEQUENCE { 00194 * type AttributeType, 00195 * value AttributeValue } 00196 * 00197 * AttributeType ::= OBJECT IDENTIFIER 00198 * 00199 * AttributeValue ::= ANY DEFINED BY AttributeType 00200 */ 00201 static int x509_get_attr_type_value( unsigned char **p, 00202 const unsigned char *end, 00203 x509_name *cur ) 00204 { 00205 int ret; 00206 size_t len; 00207 x509_buf *oid; 00208 x509_buf *val; 00209 00210 if( ( ret = asn1_get_tag( p, end, &len, 00211 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00212 return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret ); 00213 00214 oid = &cur->oid; 00215 oid->tag = **p; 00216 00217 if( ( ret = asn1_get_tag( p, end, &oid->len, ASN1_OID ) ) != 0 ) 00218 return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret ); 00219 00220 oid->p = *p; 00221 *p += oid->len; 00222 00223 if( ( end - *p ) < 1 ) 00224 return( POLARSSL_ERR_X509_CERT_INVALID_NAME + 00225 POLARSSL_ERR_ASN1_OUT_OF_DATA ); 00226 00227 if( **p != ASN1_BMP_STRING && **p != ASN1_UTF8_STRING && 00228 **p != ASN1_T61_STRING && **p != ASN1_PRINTABLE_STRING && 00229 **p != ASN1_IA5_STRING && **p != ASN1_UNIVERSAL_STRING ) 00230 return( POLARSSL_ERR_X509_CERT_INVALID_NAME + 00231 POLARSSL_ERR_ASN1_UNEXPECTED_TAG ); 00232 00233 val = &cur->val; 00234 val->tag = *(*p)++; 00235 00236 if( ( ret = asn1_get_len( p, end, &val->len ) ) != 0 ) 00237 return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret ); 00238 00239 val->p = *p; 00240 *p += val->len; 00241 00242 cur->next = NULL; 00243 00244 return( 0 ); 00245 } 00246 00247 /* 00248 * RelativeDistinguishedName ::= 00249 * SET OF AttributeTypeAndValue 00250 * 00251 * AttributeTypeAndValue ::= SEQUENCE { 00252 * type AttributeType, 00253 * value AttributeValue } 00254 * 00255 * AttributeType ::= OBJECT IDENTIFIER 00256 * 00257 * AttributeValue ::= ANY DEFINED BY AttributeType 00258 */ 00259 static int x509_get_name( unsigned char **p, 00260 const unsigned char *end, 00261 x509_name *cur ) 00262 { 00263 int ret; 00264 size_t len; 00265 const unsigned char *end2; 00266 x509_name *use; 00267 00268 if( ( ret = asn1_get_tag( p, end, &len, 00269 ASN1_CONSTRUCTED | ASN1_SET ) ) != 0 ) 00270 return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret ); 00271 00272 end2 = end; 00273 end = *p + len; 00274 use = cur; 00275 00276 do 00277 { 00278 if( ( ret = x509_get_attr_type_value( p, end, use ) ) != 0 ) 00279 return( ret ); 00280 00281 if( *p != end ) 00282 { 00283 use->next = (x509_name *) malloc( 00284 sizeof( x509_name ) ); 00285 00286 if( use->next == NULL ) 00287 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 00288 00289 memset( use->next, 0, sizeof( x509_name ) ); 00290 00291 use = use->next; 00292 } 00293 } 00294 while( *p != end ); 00295 00296 /* 00297 * recurse until end of SEQUENCE is reached 00298 */ 00299 if( *p == end2 ) 00300 return( 0 ); 00301 00302 cur->next = (x509_name *) malloc( 00303 sizeof( x509_name ) ); 00304 00305 if( cur->next == NULL ) 00306 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 00307 00308 return( x509_get_name( p, end2, cur->next ) ); 00309 } 00310 00311 /* 00312 * Time ::= CHOICE { 00313 * utcTime UTCTime, 00314 * generalTime GeneralizedTime } 00315 */ 00316 static int x509_get_time( unsigned char **p, 00317 const unsigned char *end, 00318 x509_time *time ) 00319 { 00320 int ret; 00321 size_t len; 00322 char date[64]; 00323 unsigned char tag; 00324 00325 if( ( end - *p ) < 1 ) 00326 return( POLARSSL_ERR_X509_CERT_INVALID_DATE + 00327 POLARSSL_ERR_ASN1_OUT_OF_DATA ); 00328 00329 tag = **p; 00330 00331 if ( tag == ASN1_UTC_TIME ) 00332 { 00333 (*p)++; 00334 ret = asn1_get_len( p, end, &len ); 00335 00336 if( ret != 0 ) 00337 return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret ); 00338 00339 memset( date, 0, sizeof( date ) ); 00340 memcpy( date, *p, ( len < sizeof( date ) - 1 ) ? 00341 len : sizeof( date ) - 1 ); 00342 00343 if( sscanf( date, "%2d%2d%2d%2d%2d%2d", 00344 &time->year, &time->mon, &time->day, 00345 &time->hour, &time->min, &time->sec ) < 5 ) 00346 return( POLARSSL_ERR_X509_CERT_INVALID_DATE ); 00347 00348 time->year += 100 * ( time->year < 50 ); 00349 time->year += 1900; 00350 00351 *p += len; 00352 00353 return( 0 ); 00354 } 00355 else if ( tag == ASN1_GENERALIZED_TIME ) 00356 { 00357 (*p)++; 00358 ret = asn1_get_len( p, end, &len ); 00359 00360 if( ret != 0 ) 00361 return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret ); 00362 00363 memset( date, 0, sizeof( date ) ); 00364 memcpy( date, *p, ( len < sizeof( date ) - 1 ) ? 00365 len : sizeof( date ) - 1 ); 00366 00367 if( sscanf( date, "%4d%2d%2d%2d%2d%2d", 00368 &time->year, &time->mon, &time->day, 00369 &time->hour, &time->min, &time->sec ) < 5 ) 00370 return( POLARSSL_ERR_X509_CERT_INVALID_DATE ); 00371 00372 *p += len; 00373 00374 return( 0 ); 00375 } 00376 else 00377 return( POLARSSL_ERR_X509_CERT_INVALID_DATE + POLARSSL_ERR_ASN1_UNEXPECTED_TAG ); 00378 } 00379 00380 00381 /* 00382 * Validity ::= SEQUENCE { 00383 * notBefore Time, 00384 * notAfter Time } 00385 */ 00386 static int x509_get_dates( unsigned char **p, 00387 const unsigned char *end, 00388 x509_time *from, 00389 x509_time *to ) 00390 { 00391 int ret; 00392 size_t len; 00393 00394 if( ( ret = asn1_get_tag( p, end, &len, 00395 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00396 return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret ); 00397 00398 end = *p + len; 00399 00400 if( ( ret = x509_get_time( p, end, from ) ) != 0 ) 00401 return( ret ); 00402 00403 if( ( ret = x509_get_time( p, end, to ) ) != 0 ) 00404 return( ret ); 00405 00406 if( *p != end ) 00407 return( POLARSSL_ERR_X509_CERT_INVALID_DATE + 00408 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00409 00410 return( 0 ); 00411 } 00412 00413 /* 00414 * SubjectPublicKeyInfo ::= SEQUENCE { 00415 * algorithm AlgorithmIdentifier, 00416 * subjectPublicKey BIT STRING } 00417 */ 00418 static int x509_get_pubkey( unsigned char **p, 00419 const unsigned char *end, 00420 x509_buf *pk_alg_oid, 00421 mpi *N, mpi *E ) 00422 { 00423 int ret, can_handle; 00424 size_t len; 00425 unsigned char *end2; 00426 00427 if( ( ret = x509_get_alg( p, end, pk_alg_oid ) ) != 0 ) 00428 return( ret ); 00429 00430 /* 00431 * only RSA public keys handled at this time 00432 */ 00433 can_handle = 0; 00434 00435 if( pk_alg_oid->len == 9 && 00436 memcmp( pk_alg_oid->p, OID_PKCS1_RSA, 9 ) == 0 ) 00437 can_handle = 1; 00438 00439 if( pk_alg_oid->len == 9 && 00440 memcmp( pk_alg_oid->p, OID_PKCS1, 8 ) == 0 ) 00441 { 00442 if( pk_alg_oid->p[8] >= 2 && pk_alg_oid->p[8] <= 5 ) 00443 can_handle = 1; 00444 00445 if ( pk_alg_oid->p[8] >= 11 && pk_alg_oid->p[8] <= 14 ) 00446 can_handle = 1; 00447 } 00448 00449 if( pk_alg_oid->len == 5 && 00450 memcmp( pk_alg_oid->p, OID_RSA_SHA_OBS, 5 ) == 0 ) 00451 can_handle = 1; 00452 00453 if( can_handle == 0 ) 00454 return( POLARSSL_ERR_X509_UNKNOWN_PK_ALG ); 00455 00456 if( ( ret = asn1_get_tag( p, end, &len, ASN1_BIT_STRING ) ) != 0 ) 00457 return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + ret ); 00458 00459 if( ( end - *p ) < 1 ) 00460 return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + 00461 POLARSSL_ERR_ASN1_OUT_OF_DATA ); 00462 00463 end2 = *p + len; 00464 00465 if( *(*p)++ != 0 ) 00466 return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY ); 00467 00468 /* 00469 * RSAPublicKey ::= SEQUENCE { 00470 * modulus INTEGER, -- n 00471 * publicExponent INTEGER -- e 00472 * } 00473 */ 00474 if( ( ret = asn1_get_tag( p, end2, &len, 00475 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00476 return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + ret ); 00477 00478 if( *p + len != end2 ) 00479 return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + 00480 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00481 00482 if( ( ret = asn1_get_mpi( p, end2, N ) ) != 0 || 00483 ( ret = asn1_get_mpi( p, end2, E ) ) != 0 ) 00484 return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + ret ); 00485 00486 if( *p != end ) 00487 return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + 00488 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00489 00490 return( 0 ); 00491 } 00492 00493 static int x509_get_sig( unsigned char **p, 00494 const unsigned char *end, 00495 x509_buf *sig ) 00496 { 00497 int ret; 00498 size_t len; 00499 00500 sig->tag = **p; 00501 00502 if( ( ret = asn1_get_tag( p, end, &len, ASN1_BIT_STRING ) ) != 0 ) 00503 return( POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE + ret ); 00504 00505 00506 if( --len < 1 || *(*p)++ != 0 ) 00507 return( POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE ); 00508 00509 sig->len = len; 00510 sig->p = *p; 00511 00512 *p += len; 00513 00514 return( 0 ); 00515 } 00516 00517 /* 00518 * X.509 v2/v3 unique identifier (not parsed) 00519 */ 00520 static int x509_get_uid( unsigned char **p, 00521 const unsigned char *end, 00522 x509_buf *uid, int n ) 00523 { 00524 int ret; 00525 00526 if( *p == end ) 00527 return( 0 ); 00528 00529 uid->tag = **p; 00530 00531 if( ( ret = asn1_get_tag( p, end, &uid->len, 00532 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | n ) ) != 0 ) 00533 { 00534 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00535 return( 0 ); 00536 00537 return( ret ); 00538 } 00539 00540 uid->p = *p; 00541 *p += uid->len; 00542 00543 return( 0 ); 00544 } 00545 00546 /* 00547 * X.509 Extensions (No parsing of extensions, pointer should 00548 * be either manually updated or extensions should be parsed! 00549 */ 00550 static int x509_get_ext( unsigned char **p, 00551 const unsigned char *end, 00552 x509_buf *ext, int tag ) 00553 { 00554 int ret; 00555 size_t len; 00556 00557 if( *p == end ) 00558 return( 0 ); 00559 00560 ext->tag = **p; 00561 00562 if( ( ret = asn1_get_tag( p, end, &ext->len, 00563 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | tag ) ) != 0 ) 00564 return( ret ); 00565 00566 ext->p = *p; 00567 end = *p + ext->len; 00568 00569 /* 00570 * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension 00571 * 00572 * Extension ::= SEQUENCE { 00573 * extnID OBJECT IDENTIFIER, 00574 * critical BOOLEAN DEFAULT FALSE, 00575 * extnValue OCTET STRING } 00576 */ 00577 if( ( ret = asn1_get_tag( p, end, &len, 00578 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00579 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00580 00581 if( end != *p + len ) 00582 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00583 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00584 00585 return( 0 ); 00586 } 00587 00588 /* 00589 * X.509 CRL v2 extensions (no extensions parsed yet.) 00590 */ 00591 static int x509_get_crl_ext( unsigned char **p, 00592 const unsigned char *end, 00593 x509_buf *ext ) 00594 { 00595 int ret; 00596 size_t len = 0; 00597 00598 /* Get explicit tag */ 00599 if( ( ret = x509_get_ext( p, end, ext, 0) ) != 0 ) 00600 { 00601 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00602 return( 0 ); 00603 00604 return( ret ); 00605 } 00606 00607 while( *p < end ) 00608 { 00609 if( ( ret = asn1_get_tag( p, end, &len, 00610 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00611 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00612 00613 *p += len; 00614 } 00615 00616 if( *p != end ) 00617 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00618 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00619 00620 return( 0 ); 00621 } 00622 00623 /* 00624 * X.509 CRL v2 entry extensions (no extensions parsed yet.) 00625 */ 00626 static int x509_get_crl_entry_ext( unsigned char **p, 00627 const unsigned char *end, 00628 x509_buf *ext ) 00629 { 00630 int ret; 00631 size_t len = 0; 00632 00633 /* OPTIONAL */ 00634 if (end <= *p) 00635 return( 0 ); 00636 00637 ext->tag = **p; 00638 ext->p = *p; 00639 00640 /* 00641 * Get CRL-entry extension sequence header 00642 * crlEntryExtensions Extensions OPTIONAL -- if present, MUST be v2 00643 */ 00644 if( ( ret = asn1_get_tag( p, end, &ext->len, 00645 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00646 { 00647 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00648 { 00649 ext->p = NULL; 00650 return( 0 ); 00651 } 00652 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00653 } 00654 00655 end = *p + ext->len; 00656 00657 if( end != *p + ext->len ) 00658 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00659 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00660 00661 while( *p < end ) 00662 { 00663 if( ( ret = asn1_get_tag( p, end, &len, 00664 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00665 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00666 00667 *p += len; 00668 } 00669 00670 if( *p != end ) 00671 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00672 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00673 00674 return( 0 ); 00675 } 00676 00677 static int x509_get_basic_constraints( unsigned char **p, 00678 const unsigned char *end, 00679 int *ca_istrue, 00680 int *max_pathlen ) 00681 { 00682 int ret; 00683 size_t len; 00684 00685 /* 00686 * BasicConstraints ::= SEQUENCE { 00687 * cA BOOLEAN DEFAULT FALSE, 00688 * pathLenConstraint INTEGER (0..MAX) OPTIONAL } 00689 */ 00690 *ca_istrue = 0; /* DEFAULT FALSE */ 00691 *max_pathlen = 0; /* endless */ 00692 00693 if( ( ret = asn1_get_tag( p, end, &len, 00694 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00695 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00696 00697 if( *p == end ) 00698 return 0; 00699 00700 if( ( ret = asn1_get_bool( p, end, ca_istrue ) ) != 0 ) 00701 { 00702 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00703 ret = asn1_get_int( p, end, ca_istrue ); 00704 00705 if( ret != 0 ) 00706 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00707 00708 if( *ca_istrue != 0 ) 00709 *ca_istrue = 1; 00710 } 00711 00712 if( *p == end ) 00713 return 0; 00714 00715 if( ( ret = asn1_get_int( p, end, max_pathlen ) ) != 0 ) 00716 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00717 00718 if( *p != end ) 00719 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00720 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00721 00722 (*max_pathlen)++; 00723 00724 return 0; 00725 } 00726 00727 static int x509_get_ns_cert_type( unsigned char **p, 00728 const unsigned char *end, 00729 unsigned char *ns_cert_type) 00730 { 00731 int ret; 00732 x509_bitstring bs = { 0, 0, NULL }; 00733 00734 if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 ) 00735 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00736 00737 if( bs.len != 1 ) 00738 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00739 POLARSSL_ERR_ASN1_INVALID_LENGTH ); 00740 00741 /* Get actual bitstring */ 00742 *ns_cert_type = *bs.p; 00743 return 0; 00744 } 00745 00746 static int x509_get_key_usage( unsigned char **p, 00747 const unsigned char *end, 00748 unsigned char *key_usage) 00749 { 00750 int ret; 00751 x509_bitstring bs = { 0, 0, NULL }; 00752 00753 if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 ) 00754 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00755 00756 if( bs.len > 1 ) 00757 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00758 POLARSSL_ERR_ASN1_INVALID_LENGTH ); 00759 00760 /* Get actual bitstring */ 00761 *key_usage = *bs.p; 00762 return 0; 00763 } 00764 00765 /* 00766 * ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId 00767 * 00768 * KeyPurposeId ::= OBJECT IDENTIFIER 00769 */ 00770 static int x509_get_ext_key_usage( unsigned char **p, 00771 const unsigned char *end, 00772 x509_sequence *ext_key_usage) 00773 { 00774 int ret; 00775 00776 if( ( ret = asn1_get_sequence_of( p, end, ext_key_usage, ASN1_OID ) ) != 0 ) 00777 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00778 00779 /* Sequence length must be >= 1 */ 00780 if( ext_key_usage->buf.p == NULL ) 00781 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00782 POLARSSL_ERR_ASN1_INVALID_LENGTH ); 00783 00784 return 0; 00785 } 00786 00787 /* 00788 * X.509 v3 extensions 00789 * 00790 * TODO: Perform all of the basic constraints tests required by the RFC 00791 * TODO: Set values for undetected extensions to a sane default? 00792 * 00793 */ 00794 static int x509_get_crt_ext( unsigned char **p, 00795 const unsigned char *end, 00796 x509_cert *crt ) 00797 { 00798 int ret; 00799 size_t len; 00800 unsigned char *end_ext_data, *end_ext_octet; 00801 00802 if( ( ret = x509_get_ext( p, end, &crt->v3_ext, 3 ) ) != 0 ) 00803 { 00804 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00805 return( 0 ); 00806 00807 return( ret ); 00808 } 00809 00810 while( *p < end ) 00811 { 00812 /* 00813 * Extension ::= SEQUENCE { 00814 * extnID OBJECT IDENTIFIER, 00815 * critical BOOLEAN DEFAULT FALSE, 00816 * extnValue OCTET STRING } 00817 */ 00818 x509_buf extn_oid = {0, 0, NULL}; 00819 int is_critical = 0; /* DEFAULT FALSE */ 00820 00821 if( ( ret = asn1_get_tag( p, end, &len, 00822 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 00823 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00824 00825 end_ext_data = *p + len; 00826 00827 /* Get extension ID */ 00828 extn_oid.tag = **p; 00829 00830 if( ( ret = asn1_get_tag( p, end, &extn_oid.len, ASN1_OID ) ) != 0 ) 00831 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00832 00833 extn_oid.p = *p; 00834 *p += extn_oid.len; 00835 00836 if( ( end - *p ) < 1 ) 00837 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00838 POLARSSL_ERR_ASN1_OUT_OF_DATA ); 00839 00840 /* Get optional critical */ 00841 if( ( ret = asn1_get_bool( p, end_ext_data, &is_critical ) ) != 0 && 00842 ( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) ) 00843 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00844 00845 /* Data should be octet string type */ 00846 if( ( ret = asn1_get_tag( p, end_ext_data, &len, 00847 ASN1_OCTET_STRING ) ) != 0 ) 00848 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret ); 00849 00850 end_ext_octet = *p + len; 00851 00852 if( end_ext_octet != end_ext_data ) 00853 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00854 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00855 00856 /* 00857 * Detect supported extensions 00858 */ 00859 if( ( OID_SIZE( OID_BASIC_CONSTRAINTS ) == extn_oid.len ) && 00860 memcmp( extn_oid.p, OID_BASIC_CONSTRAINTS, extn_oid.len ) == 0 ) 00861 { 00862 /* Parse basic constraints */ 00863 if( ( ret = x509_get_basic_constraints( p, end_ext_octet, 00864 &crt->ca_istrue, &crt->max_pathlen ) ) != 0 ) 00865 return ( ret ); 00866 crt->ext_types |= EXT_BASIC_CONSTRAINTS; 00867 } 00868 else if( ( OID_SIZE( OID_NS_CERT_TYPE ) == extn_oid.len ) && 00869 memcmp( extn_oid.p, OID_NS_CERT_TYPE, extn_oid.len ) == 0 ) 00870 { 00871 /* Parse netscape certificate type */ 00872 if( ( ret = x509_get_ns_cert_type( p, end_ext_octet, 00873 &crt->ns_cert_type ) ) != 0 ) 00874 return ( ret ); 00875 crt->ext_types |= EXT_NS_CERT_TYPE; 00876 } 00877 else if( ( OID_SIZE( OID_KEY_USAGE ) == extn_oid.len ) && 00878 memcmp( extn_oid.p, OID_KEY_USAGE, extn_oid.len ) == 0 ) 00879 { 00880 /* Parse key usage */ 00881 if( ( ret = x509_get_key_usage( p, end_ext_octet, 00882 &crt->key_usage ) ) != 0 ) 00883 return ( ret ); 00884 crt->ext_types |= EXT_KEY_USAGE; 00885 } 00886 else if( ( OID_SIZE( OID_EXTENDED_KEY_USAGE ) == extn_oid.len ) && 00887 memcmp( extn_oid.p, OID_EXTENDED_KEY_USAGE, extn_oid.len ) == 0 ) 00888 { 00889 /* Parse extended key usage */ 00890 if( ( ret = x509_get_ext_key_usage( p, end_ext_octet, 00891 &crt->ext_key_usage ) ) != 0 ) 00892 return ( ret ); 00893 crt->ext_types |= EXT_EXTENDED_KEY_USAGE; 00894 } 00895 else 00896 { 00897 /* No parser found, skip extension */ 00898 *p = end_ext_octet; 00899 00900 #if !defined(POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION) 00901 if( is_critical ) 00902 { 00903 /* Data is marked as critical: fail */ 00904 return ( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00905 POLARSSL_ERR_ASN1_UNEXPECTED_TAG ); 00906 } 00907 #endif 00908 } 00909 } 00910 00911 if( *p != end ) 00912 return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + 00913 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 00914 00915 return( 0 ); 00916 } 00917 00918 /* 00919 * X.509 CRL Entries 00920 */ 00921 static int x509_get_entries( unsigned char **p, 00922 const unsigned char *end, 00923 x509_crl_entry *entry ) 00924 { 00925 int ret; 00926 size_t entry_len; 00927 x509_crl_entry *cur_entry = entry; 00928 00929 if( *p == end ) 00930 return( 0 ); 00931 00932 if( ( ret = asn1_get_tag( p, end, &entry_len, 00933 ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 ) 00934 { 00935 if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 00936 return( 0 ); 00937 00938 return( ret ); 00939 } 00940 00941 end = *p + entry_len; 00942 00943 while( *p < end ) 00944 { 00945 size_t len2; 00946 const unsigned char *end2; 00947 00948 if( ( ret = asn1_get_tag( p, end, &len2, 00949 ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 ) 00950 { 00951 return( ret ); 00952 } 00953 00954 cur_entry->raw.tag = **p; 00955 cur_entry->raw.p = *p; 00956 cur_entry->raw.len = len2; 00957 end2 = *p + len2; 00958 00959 if( ( ret = x509_get_serial( p, end2, &cur_entry->serial ) ) != 0 ) 00960 return( ret ); 00961 00962 if( ( ret = x509_get_time( p, end2, &cur_entry->revocation_date ) ) != 0 ) 00963 return( ret ); 00964 00965 if( ( ret = x509_get_crl_entry_ext( p, end2, &cur_entry->entry_ext ) ) != 0 ) 00966 return( ret ); 00967 00968 if ( *p < end ) 00969 { 00970 cur_entry->next = malloc( sizeof( x509_crl_entry ) ); 00971 00972 if( cur_entry->next == NULL ) 00973 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 00974 00975 cur_entry = cur_entry->next; 00976 memset( cur_entry, 0, sizeof( x509_crl_entry ) ); 00977 } 00978 } 00979 00980 return( 0 ); 00981 } 00982 00983 static int x509_get_sig_alg( const x509_buf *sig_oid, int *sig_alg ) 00984 { 00985 if( sig_oid->len == 9 && 00986 memcmp( sig_oid->p, OID_PKCS1, 8 ) == 0 ) 00987 { 00988 if( sig_oid->p[8] >= 2 && sig_oid->p[8] <= 5 ) 00989 { 00990 *sig_alg = sig_oid->p[8]; 00991 return( 0 ); 00992 } 00993 00994 if ( sig_oid->p[8] >= 11 && sig_oid->p[8] <= 14 ) 00995 { 00996 *sig_alg = sig_oid->p[8]; 00997 return( 0 ); 00998 } 00999 01000 return( POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG ); 01001 } 01002 if( sig_oid->len == 5 && 01003 memcmp( sig_oid->p, OID_RSA_SHA_OBS, 5 ) == 0 ) 01004 { 01005 *sig_alg = SIG_RSA_SHA1; 01006 return( 0 ); 01007 } 01008 01009 return( POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG ); 01010 } 01011 01012 /* 01013 * Parse and fill a single X.509 certificate in DER format 01014 */ 01015 int x509parse_crt_der( x509_cert *crt, const unsigned char *buf, size_t buflen ) 01016 { 01017 int ret; 01018 size_t len; 01019 unsigned char *p, *end; 01020 01021 /* 01022 * Check for valid input 01023 */ 01024 if( crt == NULL || buf == NULL ) 01025 return( POLARSSL_ERR_X509_INVALID_INPUT ); 01026 01027 p = (unsigned char *) malloc( len = buflen ); 01028 01029 if( p == NULL ) 01030 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01031 01032 memcpy( p, buf, buflen ); 01033 01034 buflen = 0; 01035 01036 crt->raw.p = p; 01037 crt->raw.len = len; 01038 end = p + len; 01039 01040 /* 01041 * Certificate ::= SEQUENCE { 01042 * tbsCertificate TBSCertificate, 01043 * signatureAlgorithm AlgorithmIdentifier, 01044 * signatureValue BIT STRING } 01045 */ 01046 if( ( ret = asn1_get_tag( &p, end, &len, 01047 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01048 { 01049 x509_free( crt ); 01050 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT ); 01051 } 01052 01053 if( len != (size_t) ( end - p ) ) 01054 { 01055 x509_free( crt ); 01056 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + 01057 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 01058 } 01059 01060 /* 01061 * TBSCertificate ::= SEQUENCE { 01062 */ 01063 crt->tbs.p = p; 01064 01065 if( ( ret = asn1_get_tag( &p, end, &len, 01066 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01067 { 01068 x509_free( crt ); 01069 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret ); 01070 } 01071 01072 end = p + len; 01073 crt->tbs.len = end - crt->tbs.p; 01074 01075 /* 01076 * Version ::= INTEGER { v1(0), v2(1), v3(2) } 01077 * 01078 * CertificateSerialNumber ::= INTEGER 01079 * 01080 * signature AlgorithmIdentifier 01081 */ 01082 if( ( ret = x509_get_version( &p, end, &crt->version ) ) != 0 || 01083 ( ret = x509_get_serial( &p, end, &crt->serial ) ) != 0 || 01084 ( ret = x509_get_alg( &p, end, &crt->sig_oid1 ) ) != 0 ) 01085 { 01086 x509_free( crt ); 01087 return( ret ); 01088 } 01089 01090 crt->version++; 01091 01092 if( crt->version > 3 ) 01093 { 01094 x509_free( crt ); 01095 return( POLARSSL_ERR_X509_CERT_UNKNOWN_VERSION ); 01096 } 01097 01098 if( ( ret = x509_get_sig_alg( &crt->sig_oid1, &crt->sig_alg ) ) != 0 ) 01099 { 01100 x509_free( crt ); 01101 return( ret ); 01102 } 01103 01104 /* 01105 * issuer Name 01106 */ 01107 crt->issuer_raw.p = p; 01108 01109 if( ( ret = asn1_get_tag( &p, end, &len, 01110 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01111 { 01112 x509_free( crt ); 01113 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret ); 01114 } 01115 01116 if( ( ret = x509_get_name( &p, p + len, &crt->issuer ) ) != 0 ) 01117 { 01118 x509_free( crt ); 01119 return( ret ); 01120 } 01121 01122 crt->issuer_raw.len = p - crt->issuer_raw.p; 01123 01124 /* 01125 * Validity ::= SEQUENCE { 01126 * notBefore Time, 01127 * notAfter Time } 01128 * 01129 */ 01130 if( ( ret = x509_get_dates( &p, end, &crt->valid_from, 01131 &crt->valid_to ) ) != 0 ) 01132 { 01133 x509_free( crt ); 01134 return( ret ); 01135 } 01136 01137 /* 01138 * subject Name 01139 */ 01140 crt->subject_raw.p = p; 01141 01142 if( ( ret = asn1_get_tag( &p, end, &len, 01143 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01144 { 01145 x509_free( crt ); 01146 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret ); 01147 } 01148 01149 if( ( ret = x509_get_name( &p, p + len, &crt->subject ) ) != 0 ) 01150 { 01151 x509_free( crt ); 01152 return( ret ); 01153 } 01154 01155 crt->subject_raw.len = p - crt->subject_raw.p; 01156 01157 /* 01158 * SubjectPublicKeyInfo ::= SEQUENCE 01159 * algorithm AlgorithmIdentifier, 01160 * subjectPublicKey BIT STRING } 01161 */ 01162 if( ( ret = asn1_get_tag( &p, end, &len, 01163 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01164 { 01165 x509_free( crt ); 01166 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret ); 01167 } 01168 01169 if( ( ret = x509_get_pubkey( &p, p + len, &crt->pk_oid, 01170 &crt->rsa.N, &crt->rsa.E ) ) != 0 ) 01171 { 01172 x509_free( crt ); 01173 return( ret ); 01174 } 01175 01176 if( ( ret = rsa_check_pubkey( &crt->rsa ) ) != 0 ) 01177 { 01178 x509_free( crt ); 01179 return( ret ); 01180 } 01181 01182 crt->rsa.len = mpi_size( &crt->rsa.N ); 01183 01184 /* 01185 * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL, 01186 * -- If present, version shall be v2 or v3 01187 * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL, 01188 * -- If present, version shall be v2 or v3 01189 * extensions [3] EXPLICIT Extensions OPTIONAL 01190 * -- If present, version shall be v3 01191 */ 01192 if( crt->version == 2 || crt->version == 3 ) 01193 { 01194 ret = x509_get_uid( &p, end, &crt->issuer_id, 1 ); 01195 if( ret != 0 ) 01196 { 01197 x509_free( crt ); 01198 return( ret ); 01199 } 01200 } 01201 01202 if( crt->version == 2 || crt->version == 3 ) 01203 { 01204 ret = x509_get_uid( &p, end, &crt->subject_id, 2 ); 01205 if( ret != 0 ) 01206 { 01207 x509_free( crt ); 01208 return( ret ); 01209 } 01210 } 01211 01212 if( crt->version == 3 ) 01213 { 01214 ret = x509_get_crt_ext( &p, end, crt); 01215 if( ret != 0 ) 01216 { 01217 x509_free( crt ); 01218 return( ret ); 01219 } 01220 } 01221 01222 if( p != end ) 01223 { 01224 x509_free( crt ); 01225 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + 01226 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 01227 } 01228 01229 end = crt->raw.p + crt->raw.len; 01230 01231 /* 01232 * signatureAlgorithm AlgorithmIdentifier, 01233 * signatureValue BIT STRING 01234 */ 01235 if( ( ret = x509_get_alg( &p, end, &crt->sig_oid2 ) ) != 0 ) 01236 { 01237 x509_free( crt ); 01238 return( ret ); 01239 } 01240 01241 if( memcmp( crt->sig_oid1.p, crt->sig_oid2.p, crt->sig_oid1.len ) != 0 ) 01242 { 01243 x509_free( crt ); 01244 return( POLARSSL_ERR_X509_CERT_SIG_MISMATCH ); 01245 } 01246 01247 if( ( ret = x509_get_sig( &p, end, &crt->sig ) ) != 0 ) 01248 { 01249 x509_free( crt ); 01250 return( ret ); 01251 } 01252 01253 if( p != end ) 01254 { 01255 x509_free( crt ); 01256 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + 01257 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 01258 } 01259 01260 return( 0 ); 01261 } 01262 01263 /* 01264 * Parse one or more PEM certificates from a buffer and add them to the chained list 01265 */ 01266 int x509parse_crt( x509_cert *chain, const unsigned char *buf, size_t buflen ) 01267 { 01268 int ret, success = 0, first_error = 0, total_failed = 0; 01269 x509_cert *crt, *prev = NULL; 01270 int buf_format = X509_FORMAT_DER; 01271 01272 crt = chain; 01273 01274 /* 01275 * Check for valid input 01276 */ 01277 if( crt == NULL || buf == NULL ) 01278 return( POLARSSL_ERR_X509_INVALID_INPUT ); 01279 01280 while( crt->version != 0 && crt->next != NULL ) 01281 { 01282 prev = crt; 01283 crt = crt->next; 01284 } 01285 01286 /* 01287 * Add new certificate on the end of the chain if needed. 01288 */ 01289 if ( crt->version != 0 && crt->next == NULL) 01290 { 01291 crt->next = (x509_cert *) malloc( sizeof( x509_cert ) ); 01292 01293 if( crt->next == NULL ) 01294 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01295 01296 prev = crt; 01297 crt = crt->next; 01298 memset( crt, 0, sizeof( x509_cert ) ); 01299 } 01300 01301 /* 01302 * Determine buffer content. Buffer contains either one DER certificate or 01303 * one or more PEM certificates. 01304 */ 01305 #if defined(POLARSSL_PEM_C) 01306 if( strstr( (char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL ) 01307 buf_format = X509_FORMAT_PEM; 01308 #endif 01309 01310 if( buf_format == X509_FORMAT_DER ) 01311 return x509parse_crt_der( crt, buf, buflen ); 01312 01313 #if defined(POLARSSL_PEM_C) 01314 if( buf_format == X509_FORMAT_PEM ) 01315 { 01316 pem_context pem; 01317 01318 while( buflen > 0 ) 01319 { 01320 size_t use_len; 01321 pem_init( &pem ); 01322 01323 ret = pem_read_buffer( &pem, 01324 "-----BEGIN CERTIFICATE-----", 01325 "-----END CERTIFICATE-----", 01326 buf, NULL, 0, &use_len ); 01327 01328 if( ret == 0 ) 01329 { 01330 /* 01331 * Was PEM encoded 01332 */ 01333 buflen -= use_len; 01334 buf += use_len; 01335 } 01336 else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT ) 01337 { 01338 pem_free( &pem ); 01339 01340 if( first_error == 0 ) 01341 first_error = ret; 01342 01343 continue; 01344 } 01345 else 01346 break; 01347 01348 ret = x509parse_crt_der( crt, pem.buf, pem.buflen ); 01349 01350 pem_free( &pem ); 01351 01352 if( ret != 0 ) 01353 { 01354 /* 01355 * quit parsing on a memory error 01356 */ 01357 if( ret == POLARSSL_ERR_X509_MALLOC_FAILED ) 01358 { 01359 if( prev ) 01360 prev->next = NULL; 01361 01362 if( crt != chain ) 01363 free( crt ); 01364 01365 return( ret ); 01366 } 01367 01368 if( first_error == 0 ) 01369 first_error = ret; 01370 01371 total_failed++; 01372 01373 memset( crt, 0, sizeof( x509_cert ) ); 01374 continue; 01375 } 01376 01377 success = 1; 01378 01379 /* 01380 * Add new certificate to the list 01381 */ 01382 crt->next = (x509_cert *) malloc( sizeof( x509_cert ) ); 01383 01384 if( crt->next == NULL ) 01385 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01386 01387 prev = crt; 01388 crt = crt->next; 01389 memset( crt, 0, sizeof( x509_cert ) ); 01390 } 01391 } 01392 #endif 01393 01394 if( crt->version == 0 ) 01395 { 01396 if( prev ) 01397 prev->next = NULL; 01398 01399 if( crt != chain ) 01400 free( crt ); 01401 } 01402 01403 if( success ) 01404 return( total_failed ); 01405 else if( first_error ) 01406 return( first_error ); 01407 else 01408 return( POLARSSL_ERR_X509_CERT_UNKNOWN_FORMAT ); 01409 } 01410 01411 /* 01412 * Parse one or more CRLs and add them to the chained list 01413 */ 01414 int x509parse_crl( x509_crl *chain, const unsigned char *buf, size_t buflen ) 01415 { 01416 int ret; 01417 size_t len; 01418 unsigned char *p, *end; 01419 x509_crl *crl; 01420 #if defined(POLARSSL_PEM_C) 01421 size_t use_len; 01422 pem_context pem; 01423 #endif 01424 01425 crl = chain; 01426 01427 /* 01428 * Check for valid input 01429 */ 01430 if( crl == NULL || buf == NULL ) 01431 return( POLARSSL_ERR_X509_INVALID_INPUT ); 01432 01433 while( crl->version != 0 && crl->next != NULL ) 01434 crl = crl->next; 01435 01436 /* 01437 * Add new CRL on the end of the chain if needed. 01438 */ 01439 if ( crl->version != 0 && crl->next == NULL) 01440 { 01441 crl->next = (x509_crl *) malloc( sizeof( x509_crl ) ); 01442 01443 if( crl->next == NULL ) 01444 { 01445 x509_crl_free( crl ); 01446 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01447 } 01448 01449 crl = crl->next; 01450 memset( crl, 0, sizeof( x509_crl ) ); 01451 } 01452 01453 #if defined(POLARSSL_PEM_C) 01454 pem_init( &pem ); 01455 ret = pem_read_buffer( &pem, 01456 "-----BEGIN X509 CRL-----", 01457 "-----END X509 CRL-----", 01458 buf, NULL, 0, &use_len ); 01459 01460 if( ret == 0 ) 01461 { 01462 /* 01463 * Was PEM encoded 01464 */ 01465 buflen -= use_len; 01466 buf += use_len; 01467 01468 /* 01469 * Steal PEM buffer 01470 */ 01471 p = pem.buf; 01472 pem.buf = NULL; 01473 len = pem.buflen; 01474 pem_free( &pem ); 01475 } 01476 else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT ) 01477 { 01478 pem_free( &pem ); 01479 return( ret ); 01480 } 01481 else 01482 { 01483 /* 01484 * nope, copy the raw DER data 01485 */ 01486 p = (unsigned char *) malloc( len = buflen ); 01487 01488 if( p == NULL ) 01489 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01490 01491 memcpy( p, buf, buflen ); 01492 01493 buflen = 0; 01494 } 01495 #else 01496 p = (unsigned char *) malloc( len = buflen ); 01497 01498 if( p == NULL ) 01499 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01500 01501 memcpy( p, buf, buflen ); 01502 01503 buflen = 0; 01504 #endif 01505 01506 crl->raw.p = p; 01507 crl->raw.len = len; 01508 end = p + len; 01509 01510 /* 01511 * CertificateList ::= SEQUENCE { 01512 * tbsCertList TBSCertList, 01513 * signatureAlgorithm AlgorithmIdentifier, 01514 * signatureValue BIT STRING } 01515 */ 01516 if( ( ret = asn1_get_tag( &p, end, &len, 01517 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01518 { 01519 x509_crl_free( crl ); 01520 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT ); 01521 } 01522 01523 if( len != (size_t) ( end - p ) ) 01524 { 01525 x509_crl_free( crl ); 01526 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + 01527 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 01528 } 01529 01530 /* 01531 * TBSCertList ::= SEQUENCE { 01532 */ 01533 crl->tbs.p = p; 01534 01535 if( ( ret = asn1_get_tag( &p, end, &len, 01536 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01537 { 01538 x509_crl_free( crl ); 01539 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret ); 01540 } 01541 01542 end = p + len; 01543 crl->tbs.len = end - crl->tbs.p; 01544 01545 /* 01546 * Version ::= INTEGER OPTIONAL { v1(0), v2(1) } 01547 * -- if present, MUST be v2 01548 * 01549 * signature AlgorithmIdentifier 01550 */ 01551 if( ( ret = x509_crl_get_version( &p, end, &crl->version ) ) != 0 || 01552 ( ret = x509_get_alg( &p, end, &crl->sig_oid1 ) ) != 0 ) 01553 { 01554 x509_crl_free( crl ); 01555 return( ret ); 01556 } 01557 01558 crl->version++; 01559 01560 if( crl->version > 2 ) 01561 { 01562 x509_crl_free( crl ); 01563 return( POLARSSL_ERR_X509_CERT_UNKNOWN_VERSION ); 01564 } 01565 01566 if( ( ret = x509_get_sig_alg( &crl->sig_oid1, &crl->sig_alg ) ) != 0 ) 01567 { 01568 x509_crl_free( crl ); 01569 return( POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG ); 01570 } 01571 01572 /* 01573 * issuer Name 01574 */ 01575 crl->issuer_raw.p = p; 01576 01577 if( ( ret = asn1_get_tag( &p, end, &len, 01578 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01579 { 01580 x509_crl_free( crl ); 01581 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret ); 01582 } 01583 01584 if( ( ret = x509_get_name( &p, p + len, &crl->issuer ) ) != 0 ) 01585 { 01586 x509_crl_free( crl ); 01587 return( ret ); 01588 } 01589 01590 crl->issuer_raw.len = p - crl->issuer_raw.p; 01591 01592 /* 01593 * thisUpdate Time 01594 * nextUpdate Time OPTIONAL 01595 */ 01596 if( ( ret = x509_get_time( &p, end, &crl->this_update ) ) != 0 ) 01597 { 01598 x509_crl_free( crl ); 01599 return( ret ); 01600 } 01601 01602 if( ( ret = x509_get_time( &p, end, &crl->next_update ) ) != 0 ) 01603 { 01604 if ( ret != ( POLARSSL_ERR_X509_CERT_INVALID_DATE + 01605 POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) && 01606 ret != ( POLARSSL_ERR_X509_CERT_INVALID_DATE + 01607 POLARSSL_ERR_ASN1_OUT_OF_DATA ) ) 01608 { 01609 x509_crl_free( crl ); 01610 return( ret ); 01611 } 01612 } 01613 01614 /* 01615 * revokedCertificates SEQUENCE OF SEQUENCE { 01616 * userCertificate CertificateSerialNumber, 01617 * revocationDate Time, 01618 * crlEntryExtensions Extensions OPTIONAL 01619 * -- if present, MUST be v2 01620 * } OPTIONAL 01621 */ 01622 if( ( ret = x509_get_entries( &p, end, &crl->entry ) ) != 0 ) 01623 { 01624 x509_crl_free( crl ); 01625 return( ret ); 01626 } 01627 01628 /* 01629 * crlExtensions EXPLICIT Extensions OPTIONAL 01630 * -- if present, MUST be v2 01631 */ 01632 if( crl->version == 2 ) 01633 { 01634 ret = x509_get_crl_ext( &p, end, &crl->crl_ext ); 01635 01636 if( ret != 0 ) 01637 { 01638 x509_crl_free( crl ); 01639 return( ret ); 01640 } 01641 } 01642 01643 if( p != end ) 01644 { 01645 x509_crl_free( crl ); 01646 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + 01647 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 01648 } 01649 01650 end = crl->raw.p + crl->raw.len; 01651 01652 /* 01653 * signatureAlgorithm AlgorithmIdentifier, 01654 * signatureValue BIT STRING 01655 */ 01656 if( ( ret = x509_get_alg( &p, end, &crl->sig_oid2 ) ) != 0 ) 01657 { 01658 x509_crl_free( crl ); 01659 return( ret ); 01660 } 01661 01662 if( memcmp( crl->sig_oid1.p, crl->sig_oid2.p, crl->sig_oid1.len ) != 0 ) 01663 { 01664 x509_crl_free( crl ); 01665 return( POLARSSL_ERR_X509_CERT_SIG_MISMATCH ); 01666 } 01667 01668 if( ( ret = x509_get_sig( &p, end, &crl->sig ) ) != 0 ) 01669 { 01670 x509_crl_free( crl ); 01671 return( ret ); 01672 } 01673 01674 if( p != end ) 01675 { 01676 x509_crl_free( crl ); 01677 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + 01678 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 01679 } 01680 01681 if( buflen > 0 ) 01682 { 01683 crl->next = (x509_crl *) malloc( sizeof( x509_crl ) ); 01684 01685 if( crl->next == NULL ) 01686 { 01687 x509_crl_free( crl ); 01688 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01689 } 01690 01691 crl = crl->next; 01692 memset( crl, 0, sizeof( x509_crl ) ); 01693 01694 return( x509parse_crl( crl, buf, buflen ) ); 01695 } 01696 01697 return( 0 ); 01698 } 01699 01700 #if defined(POLARSSL_FS_IO) 01701 /* 01702 * Load all data from a file into a given buffer. 01703 */ 01704 int load_file( const char *path, unsigned char **buf, size_t *n ) 01705 { 01706 FILE *f; 01707 01708 if( ( f = fopen( path, "rb" ) ) == NULL ) 01709 return( POLARSSL_ERR_X509_FILE_IO_ERROR ); 01710 01711 fseek( f, 0, SEEK_END ); 01712 *n = (size_t) ftell( f ); 01713 fseek( f, 0, SEEK_SET ); 01714 01715 if( ( *buf = (unsigned char *) malloc( *n + 1 ) ) == NULL ) 01716 return( POLARSSL_ERR_X509_MALLOC_FAILED ); 01717 01718 if( fread( *buf, 1, *n, f ) != *n ) 01719 { 01720 fclose( f ); 01721 free( *buf ); 01722 return( POLARSSL_ERR_X509_FILE_IO_ERROR ); 01723 } 01724 01725 fclose( f ); 01726 01727 (*buf)[*n] = '\0'; 01728 01729 return( 0 ); 01730 } 01731 01732 /* 01733 * Load one or more certificates and add them to the chained list 01734 */ 01735 int x509parse_crtfile( x509_cert *chain, const char *path ) 01736 { 01737 int ret; 01738 size_t n; 01739 unsigned char *buf; 01740 01741 if ( (ret = load_file( path, &buf, &n ) ) != 0 ) 01742 return( ret ); 01743 01744 ret = x509parse_crt( chain, buf, n ); 01745 01746 memset( buf, 0, n + 1 ); 01747 free( buf ); 01748 01749 return( ret ); 01750 } 01751 01752 /* 01753 * Load one or more CRLs and add them to the chained list 01754 */ 01755 int x509parse_crlfile( x509_crl *chain, const char *path ) 01756 { 01757 int ret; 01758 size_t n; 01759 unsigned char *buf; 01760 01761 if ( (ret = load_file( path, &buf, &n ) ) != 0 ) 01762 return( ret ); 01763 01764 ret = x509parse_crl( chain, buf, n ); 01765 01766 memset( buf, 0, n + 1 ); 01767 free( buf ); 01768 01769 return( ret ); 01770 } 01771 01772 /* 01773 * Load and parse a private RSA key 01774 */ 01775 int x509parse_keyfile( rsa_context *rsa, const char *path, const char *pwd ) 01776 { 01777 int ret; 01778 size_t n; 01779 unsigned char *buf; 01780 01781 if ( (ret = load_file( path, &buf, &n ) ) != 0 ) 01782 return( ret ); 01783 01784 if( pwd == NULL ) 01785 ret = x509parse_key( rsa, buf, n, NULL, 0 ); 01786 else 01787 ret = x509parse_key( rsa, buf, n, 01788 (unsigned char *) pwd, strlen( pwd ) ); 01789 01790 memset( buf, 0, n + 1 ); 01791 free( buf ); 01792 01793 return( ret ); 01794 } 01795 01796 /* 01797 * Load and parse a public RSA key 01798 */ 01799 int x509parse_public_keyfile( rsa_context *rsa, const char *path ) 01800 { 01801 int ret; 01802 size_t n; 01803 unsigned char *buf; 01804 01805 if ( (ret = load_file( path, &buf, &n ) ) != 0 ) 01806 return( ret ); 01807 01808 ret = x509parse_public_key( rsa, buf, n ); 01809 01810 memset( buf, 0, n + 1 ); 01811 free( buf ); 01812 01813 return( ret ); 01814 } 01815 #endif /* POLARSSL_FS_IO */ 01816 01817 /* 01818 * Parse a private RSA key 01819 */ 01820 int x509parse_key( rsa_context *rsa, const unsigned char *key, size_t keylen, 01821 const unsigned char *pwd, size_t pwdlen ) 01822 { 01823 int ret; 01824 size_t len; 01825 unsigned char *p, *end; 01826 unsigned char *p_alt; 01827 x509_buf pk_alg_oid; 01828 01829 #if defined(POLARSSL_PEM_C) 01830 pem_context pem; 01831 01832 pem_init( &pem ); 01833 ret = pem_read_buffer( &pem, 01834 "-----BEGIN RSA PRIVATE KEY-----", 01835 "-----END RSA PRIVATE KEY-----", 01836 key, pwd, pwdlen, &len ); 01837 01838 if( ret == POLARSSL_ERR_PEM_NO_HEADER_PRESENT ) 01839 { 01840 ret = pem_read_buffer( &pem, 01841 "-----BEGIN PRIVATE KEY-----", 01842 "-----END PRIVATE KEY-----", 01843 key, pwd, pwdlen, &len ); 01844 } 01845 01846 if( ret == 0 ) 01847 { 01848 /* 01849 * Was PEM encoded 01850 */ 01851 keylen = pem.buflen; 01852 } 01853 else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT ) 01854 { 01855 pem_free( &pem ); 01856 return( ret ); 01857 } 01858 01859 p = ( ret == 0 ) ? pem.buf : (unsigned char *) key; 01860 #else 01861 ((void) pwd); 01862 ((void) pwdlen); 01863 p = (unsigned char *) key; 01864 #endif 01865 end = p + keylen; 01866 01867 /* 01868 * Note: Depending on the type of private key file one can expect either a 01869 * PrivatKeyInfo object (PKCS#8) or a RSAPrivateKey (PKCS#1) directly. 01870 * 01871 * PrivateKeyInfo ::= SEQUENCE { 01872 * version Version, 01873 * algorithm AlgorithmIdentifier, 01874 * PrivateKey BIT STRING 01875 * } 01876 * 01877 * AlgorithmIdentifier ::= SEQUENCE { 01878 * algorithm OBJECT IDENTIFIER, 01879 * parameters ANY DEFINED BY algorithm OPTIONAL 01880 * } 01881 * 01882 * RSAPrivateKey ::= SEQUENCE { 01883 * version Version, 01884 * modulus INTEGER, -- n 01885 * publicExponent INTEGER, -- e 01886 * privateExponent INTEGER, -- d 01887 * prime1 INTEGER, -- p 01888 * prime2 INTEGER, -- q 01889 * exponent1 INTEGER, -- d mod (p-1) 01890 * exponent2 INTEGER, -- d mod (q-1) 01891 * coefficient INTEGER, -- (inverse of q) mod p 01892 * otherPrimeInfos OtherPrimeInfos OPTIONAL 01893 * } 01894 */ 01895 if( ( ret = asn1_get_tag( &p, end, &len, 01896 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 01897 { 01898 #if defined(POLARSSL_PEM_C) 01899 pem_free( &pem ); 01900 #endif 01901 rsa_free( rsa ); 01902 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 01903 } 01904 01905 end = p + len; 01906 01907 if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 ) 01908 { 01909 #if defined(POLARSSL_PEM_C) 01910 pem_free( &pem ); 01911 #endif 01912 rsa_free( rsa ); 01913 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 01914 } 01915 01916 if( rsa->ver != 0 ) 01917 { 01918 #if defined(POLARSSL_PEM_C) 01919 pem_free( &pem ); 01920 #endif 01921 rsa_free( rsa ); 01922 return( POLARSSL_ERR_X509_KEY_INVALID_VERSION + ret ); 01923 } 01924 01925 p_alt = p; 01926 01927 if( ( ret = x509_get_alg( &p_alt, end, &pk_alg_oid ) ) != 0 ) 01928 { 01929 // Assume that we have the PKCS#1 format if wrong 01930 // tag was encountered 01931 // 01932 if( ret != POLARSSL_ERR_X509_CERT_INVALID_ALG + 01933 POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) 01934 { 01935 #if defined(POLARSSL_PEM_C) 01936 pem_free( &pem ); 01937 #endif 01938 rsa_free( rsa ); 01939 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT ); 01940 } 01941 } 01942 else 01943 { 01944 int can_handle; 01945 01946 /* 01947 * only RSA keys handled at this time 01948 */ 01949 can_handle = 0; 01950 01951 if( pk_alg_oid.len == 9 && 01952 memcmp( pk_alg_oid.p, OID_PKCS1_RSA, 9 ) == 0 ) 01953 can_handle = 1; 01954 01955 if( pk_alg_oid.len == 9 && 01956 memcmp( pk_alg_oid.p, OID_PKCS1, 8 ) == 0 ) 01957 { 01958 if( pk_alg_oid.p[8] >= 2 && pk_alg_oid.p[8] <= 5 ) 01959 can_handle = 1; 01960 01961 if ( pk_alg_oid.p[8] >= 11 && pk_alg_oid.p[8] <= 14 ) 01962 can_handle = 1; 01963 } 01964 01965 if( pk_alg_oid.len == 5 && 01966 memcmp( pk_alg_oid.p, OID_RSA_SHA_OBS, 5 ) == 0 ) 01967 can_handle = 1; 01968 01969 if( can_handle == 0 ) 01970 return( POLARSSL_ERR_X509_UNKNOWN_PK_ALG ); 01971 01972 /* 01973 * Parse the PKCS#8 format 01974 */ 01975 01976 p = p_alt; 01977 if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 ) 01978 { 01979 #if defined(POLARSSL_PEM_C) 01980 pem_free( &pem ); 01981 #endif 01982 rsa_free( rsa ); 01983 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 01984 } 01985 01986 if( ( end - p ) < 1 ) 01987 { 01988 #if defined(POLARSSL_PEM_C) 01989 pem_free( &pem ); 01990 #endif 01991 rsa_free( rsa ); 01992 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + 01993 POLARSSL_ERR_ASN1_OUT_OF_DATA ); 01994 } 01995 01996 end = p + len; 01997 01998 if( ( ret = asn1_get_tag( &p, end, &len, 01999 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 02000 { 02001 #if defined(POLARSSL_PEM_C) 02002 pem_free( &pem ); 02003 #endif 02004 rsa_free( rsa ); 02005 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 02006 } 02007 02008 end = p + len; 02009 02010 if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 ) 02011 { 02012 #if defined(POLARSSL_PEM_C) 02013 pem_free( &pem ); 02014 #endif 02015 rsa_free( rsa ); 02016 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 02017 } 02018 02019 if( rsa->ver != 0 ) 02020 { 02021 #if defined(POLARSSL_PEM_C) 02022 pem_free( &pem ); 02023 #endif 02024 rsa_free( rsa ); 02025 return( POLARSSL_ERR_X509_KEY_INVALID_VERSION + ret ); 02026 } 02027 } 02028 02029 if( ( ret = asn1_get_mpi( &p, end, &rsa->N ) ) != 0 || 02030 ( ret = asn1_get_mpi( &p, end, &rsa->E ) ) != 0 || 02031 ( ret = asn1_get_mpi( &p, end, &rsa->D ) ) != 0 || 02032 ( ret = asn1_get_mpi( &p, end, &rsa->P ) ) != 0 || 02033 ( ret = asn1_get_mpi( &p, end, &rsa->Q ) ) != 0 || 02034 ( ret = asn1_get_mpi( &p, end, &rsa->DP ) ) != 0 || 02035 ( ret = asn1_get_mpi( &p, end, &rsa->DQ ) ) != 0 || 02036 ( ret = asn1_get_mpi( &p, end, &rsa->QP ) ) != 0 ) 02037 { 02038 #if defined(POLARSSL_PEM_C) 02039 pem_free( &pem ); 02040 #endif 02041 rsa_free( rsa ); 02042 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 02043 } 02044 02045 rsa->len = mpi_size( &rsa->N ); 02046 02047 if( p != end ) 02048 { 02049 #if defined(POLARSSL_PEM_C) 02050 pem_free( &pem ); 02051 #endif 02052 rsa_free( rsa ); 02053 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + 02054 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 02055 } 02056 02057 if( ( ret = rsa_check_privkey( rsa ) ) != 0 ) 02058 { 02059 #if defined(POLARSSL_PEM_C) 02060 pem_free( &pem ); 02061 #endif 02062 rsa_free( rsa ); 02063 return( ret ); 02064 } 02065 02066 #if defined(POLARSSL_PEM_C) 02067 pem_free( &pem ); 02068 #endif 02069 02070 return( 0 ); 02071 } 02072 02073 /* 02074 * Parse a public RSA key 02075 */ 02076 int x509parse_public_key( rsa_context *rsa, const unsigned char *key, size_t keylen ) 02077 { 02078 int ret; 02079 size_t len; 02080 unsigned char *p, *end; 02081 x509_buf alg_oid; 02082 #if defined(POLARSSL_PEM_C) 02083 pem_context pem; 02084 02085 pem_init( &pem ); 02086 ret = pem_read_buffer( &pem, 02087 "-----BEGIN PUBLIC KEY-----", 02088 "-----END PUBLIC KEY-----", 02089 key, NULL, 0, &len ); 02090 02091 if( ret == 0 ) 02092 { 02093 /* 02094 * Was PEM encoded 02095 */ 02096 keylen = pem.buflen; 02097 } 02098 else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT ) 02099 { 02100 pem_free( &pem ); 02101 return( ret ); 02102 } 02103 02104 p = ( ret == 0 ) ? pem.buf : (unsigned char *) key; 02105 #else 02106 p = (unsigned char *) key; 02107 #endif 02108 end = p + keylen; 02109 02110 /* 02111 * PublicKeyInfo ::= SEQUENCE { 02112 * algorithm AlgorithmIdentifier, 02113 * PublicKey BIT STRING 02114 * } 02115 * 02116 * AlgorithmIdentifier ::= SEQUENCE { 02117 * algorithm OBJECT IDENTIFIER, 02118 * parameters ANY DEFINED BY algorithm OPTIONAL 02119 * } 02120 * 02121 * RSAPublicKey ::= SEQUENCE { 02122 * modulus INTEGER, -- n 02123 * publicExponent INTEGER -- e 02124 * } 02125 */ 02126 02127 if( ( ret = asn1_get_tag( &p, end, &len, 02128 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 02129 { 02130 #if defined(POLARSSL_PEM_C) 02131 pem_free( &pem ); 02132 #endif 02133 rsa_free( rsa ); 02134 return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret ); 02135 } 02136 02137 if( ( ret = x509_get_pubkey( &p, end, &alg_oid, &rsa->N, &rsa->E ) ) != 0 ) 02138 { 02139 #if defined(POLARSSL_PEM_C) 02140 pem_free( &pem ); 02141 #endif 02142 rsa_free( rsa ); 02143 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 02144 } 02145 02146 if( ( ret = rsa_check_pubkey( rsa ) ) != 0 ) 02147 { 02148 #if defined(POLARSSL_PEM_C) 02149 pem_free( &pem ); 02150 #endif 02151 rsa_free( rsa ); 02152 return( ret ); 02153 } 02154 02155 rsa->len = mpi_size( &rsa->N ); 02156 02157 #if defined(POLARSSL_PEM_C) 02158 pem_free( &pem ); 02159 #endif 02160 02161 return( 0 ); 02162 } 02163 02164 #if defined(POLARSSL_DHM_C) 02165 /* 02166 * Parse DHM parameters 02167 */ 02168 int x509parse_dhm( dhm_context *dhm, const unsigned char *dhmin, size_t dhminlen ) 02169 { 02170 int ret; 02171 size_t len; 02172 unsigned char *p, *end; 02173 #if defined(POLARSSL_PEM_C) 02174 pem_context pem; 02175 02176 pem_init( &pem ); 02177 02178 ret = pem_read_buffer( &pem, 02179 "-----BEGIN DH PARAMETERS-----", 02180 "-----END DH PARAMETERS-----", 02181 dhmin, NULL, 0, &dhminlen ); 02182 02183 if( ret == 0 ) 02184 { 02185 /* 02186 * Was PEM encoded 02187 */ 02188 dhminlen = pem.buflen; 02189 } 02190 else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT ) 02191 { 02192 pem_free( &pem ); 02193 return( ret ); 02194 } 02195 02196 p = ( ret == 0 ) ? pem.buf : (unsigned char *) dhmin; 02197 #else 02198 p = (unsigned char *) dhmin; 02199 #endif 02200 end = p + dhminlen; 02201 02202 memset( dhm, 0, sizeof( dhm_context ) ); 02203 02204 /* 02205 * DHParams ::= SEQUENCE { 02206 * prime INTEGER, -- P 02207 * generator INTEGER, -- g 02208 * } 02209 */ 02210 if( ( ret = asn1_get_tag( &p, end, &len, 02211 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 ) 02212 { 02213 #if defined(POLARSSL_PEM_C) 02214 pem_free( &pem ); 02215 #endif 02216 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 02217 } 02218 02219 end = p + len; 02220 02221 if( ( ret = asn1_get_mpi( &p, end, &dhm->P ) ) != 0 || 02222 ( ret = asn1_get_mpi( &p, end, &dhm->G ) ) != 0 ) 02223 { 02224 #if defined(POLARSSL_PEM_C) 02225 pem_free( &pem ); 02226 #endif 02227 dhm_free( dhm ); 02228 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret ); 02229 } 02230 02231 if( p != end ) 02232 { 02233 #if defined(POLARSSL_PEM_C) 02234 pem_free( &pem ); 02235 #endif 02236 dhm_free( dhm ); 02237 return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + 02238 POLARSSL_ERR_ASN1_LENGTH_MISMATCH ); 02239 } 02240 02241 #if defined(POLARSSL_PEM_C) 02242 pem_free( &pem ); 02243 #endif 02244 02245 return( 0 ); 02246 } 02247 02248 #if defined(POLARSSL_FS_IO) 02249 /* 02250 * Load and parse a private RSA key 02251 */ 02252 int x509parse_dhmfile( dhm_context *dhm, const char *path ) 02253 { 02254 int ret; 02255 size_t n; 02256 unsigned char *buf; 02257 02258 if ( ( ret = load_file( path, &buf, &n ) ) != 0 ) 02259 return( ret ); 02260 02261 ret = x509parse_dhm( dhm, buf, n ); 02262 02263 memset( buf, 0, n + 1 ); 02264 free( buf ); 02265 02266 return( ret ); 02267 } 02268 #endif /* POLARSSL_FS_IO */ 02269 #endif /* POLARSSL_DHM_C */ 02270 02271 #if defined _MSC_VER && !defined snprintf 02272 #include <stdarg.h> 02273 02274 #if !defined vsnprintf 02275 #define vsnprintf _vsnprintf 02276 #endif // vsnprintf 02277 02278 /* 02279 * Windows _snprintf and _vsnprintf are not compatible to linux versions. 02280 * Result value is not size of buffer needed, but -1 if no fit is possible. 02281 * 02282 * This fuction tries to 'fix' this by at least suggesting enlarging the 02283 * size by 20. 02284 */ 02285 int compat_snprintf(char *str, size_t size, const char *format, ...) 02286 { 02287 va_list ap; 02288 int res = -1; 02289 02290 va_start( ap, format ); 02291 02292 res = vsnprintf( str, size, format, ap ); 02293 02294 va_end( ap ); 02295 02296 // No quick fix possible 02297 if ( res < 0 ) 02298 return( (int) size + 20 ); 02299 02300 return res; 02301 } 02302 02303 #define snprintf compat_snprintf 02304 #endif 02305 02306 #define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2 02307 02308 #define SAFE_SNPRINTF() \ 02309 { \ 02310 if( ret == -1 ) \ 02311 return( -1 ); \ 02312 \ 02313 if ( (unsigned int) ret > n ) { \ 02314 p[n - 1] = '\0'; \ 02315 return POLARSSL_ERR_DEBUG_BUF_TOO_SMALL;\ 02316 } \ 02317 \ 02318 n -= (unsigned int) ret; \ 02319 p += (unsigned int) ret; \ 02320 } 02321 02322 /* 02323 * Store the name in printable form into buf; no more 02324 * than size characters will be written 02325 */ 02326 int x509parse_dn_gets( char *buf, size_t size, const x509_name *dn ) 02327 { 02328 int ret; 02329 size_t i, n; 02330 unsigned char c; 02331 const x509_name *name; 02332 char s[128], *p; 02333 02334 memset( s, 0, sizeof( s ) ); 02335 02336 name = dn; 02337 p = buf; 02338 n = size; 02339 02340 while( name != NULL ) 02341 { 02342 if( name != dn ) 02343 { 02344 ret = snprintf( p, n, ", " ); 02345 SAFE_SNPRINTF(); 02346 } 02347 02348 if( memcmp( name->oid.p, OID_X520, 2 ) == 0 ) 02349 { 02350 switch( name->oid.p[2] ) 02351 { 02352 case X520_COMMON_NAME: 02353 ret = snprintf( p, n, "CN=" ); break; 02354 02355 case X520_COUNTRY: 02356 ret = snprintf( p, n, "C=" ); break; 02357 02358 case X520_LOCALITY: 02359 ret = snprintf( p, n, "L=" ); break; 02360 02361 case X520_STATE: 02362 ret = snprintf( p, n, "ST=" ); break; 02363 02364 case X520_ORGANIZATION: 02365 ret = snprintf( p, n, "O=" ); break; 02366 02367 case X520_ORG_UNIT: 02368 ret = snprintf( p, n, "OU=" ); break; 02369 02370 default: 02371 ret = snprintf( p, n, "0x%02X=", 02372 name->oid.p[2] ); 02373 break; 02374 } 02375 SAFE_SNPRINTF(); 02376 } 02377 else if( memcmp( name->oid.p, OID_PKCS9, 8 ) == 0 ) 02378 { 02379 switch( name->oid.p[8] ) 02380 { 02381 case PKCS9_EMAIL: 02382 ret = snprintf( p, n, "emailAddress=" ); break; 02383 02384 default: 02385 ret = snprintf( p, n, "0x%02X=", 02386 name->oid.p[8] ); 02387 break; 02388 } 02389 SAFE_SNPRINTF(); 02390 } 02391 else 02392 { 02393 ret = snprintf( p, n, "\?\?=" ); 02394 SAFE_SNPRINTF(); 02395 } 02396 02397 for( i = 0; i < name->val.len; i++ ) 02398 { 02399 if( i >= sizeof( s ) - 1 ) 02400 break; 02401 02402 c = name->val.p[i]; 02403 if( c < 32 || c == 127 || ( c > 128 && c < 160 ) ) 02404 s[i] = '?'; 02405 else s[i] = c; 02406 } 02407 s[i] = '\0'; 02408 ret = snprintf( p, n, "%s", s ); 02409 SAFE_SNPRINTF(); 02410 name = name->next; 02411 } 02412 02413 return( (int) ( size - n ) ); 02414 } 02415 02416 /* 02417 * Store the serial in printable form into buf; no more 02418 * than size characters will be written 02419 */ 02420 int x509parse_serial_gets( char *buf, size_t size, const x509_buf *serial ) 02421 { 02422 int ret; 02423 size_t i, n, nr; 02424 char *p; 02425 02426 p = buf; 02427 n = size; 02428 02429 nr = ( serial->len <= 32 ) 02430 ? serial->len : 28; 02431 02432 for( i = 0; i < nr; i++ ) 02433 { 02434 if( i == 0 && nr > 1 && serial->p[i] == 0x0 ) 02435 continue; 02436 02437 ret = snprintf( p, n, "%02X%s", 02438 serial->p[i], ( i < nr - 1 ) ? ":" : "" ); 02439 SAFE_SNPRINTF(); 02440 } 02441 02442 if( nr != serial->len ) 02443 { 02444 ret = snprintf( p, n, "...." ); 02445 SAFE_SNPRINTF(); 02446 } 02447 02448 return( (int) ( size - n ) ); 02449 } 02450 02451 /* 02452 * Return an informational string about the certificate. 02453 */ 02454 int x509parse_cert_info( char *buf, size_t size, const char *prefix, 02455 const x509_cert *crt ) 02456 { 02457 int ret; 02458 size_t n; 02459 char *p; 02460 02461 p = buf; 02462 n = size; 02463 02464 ret = snprintf( p, n, "%scert. version : %d\n", 02465 prefix, crt->version ); 02466 SAFE_SNPRINTF(); 02467 ret = snprintf( p, n, "%sserial number : ", 02468 prefix ); 02469 SAFE_SNPRINTF(); 02470 02471 ret = x509parse_serial_gets( p, n, &crt->serial); 02472 SAFE_SNPRINTF(); 02473 02474 ret = snprintf( p, n, "\n%sissuer name : ", prefix ); 02475 SAFE_SNPRINTF(); 02476 ret = x509parse_dn_gets( p, n, &crt->issuer ); 02477 SAFE_SNPRINTF(); 02478 02479 ret = snprintf( p, n, "\n%ssubject name : ", prefix ); 02480 SAFE_SNPRINTF(); 02481 ret = x509parse_dn_gets( p, n, &crt->subject ); 02482 SAFE_SNPRINTF(); 02483 02484 ret = snprintf( p, n, "\n%sissued on : " \ 02485 "%04d-%02d-%02d %02d:%02d:%02d", prefix, 02486 crt->valid_from.year, crt->valid_from.mon, 02487 crt->valid_from.day, crt->valid_from.hour, 02488 crt->valid_from.min, crt->valid_from.sec ); 02489 SAFE_SNPRINTF(); 02490 02491 ret = snprintf( p, n, "\n%sexpires on : " \ 02492 "%04d-%02d-%02d %02d:%02d:%02d", prefix, 02493 crt->valid_to.year, crt->valid_to.mon, 02494 crt->valid_to.day, crt->valid_to.hour, 02495 crt->valid_to.min, crt->valid_to.sec ); 02496 SAFE_SNPRINTF(); 02497 02498 ret = snprintf( p, n, "\n%ssigned using : RSA+", prefix ); 02499 SAFE_SNPRINTF(); 02500 02501 switch( crt->sig_alg ) 02502 { 02503 case SIG_RSA_MD2 : ret = snprintf( p, n, "MD2" ); break; 02504 case SIG_RSA_MD4 : ret = snprintf( p, n, "MD4" ); break; 02505 case SIG_RSA_MD5 : ret = snprintf( p, n, "MD5" ); break; 02506 case SIG_RSA_SHA1 : ret = snprintf( p, n, "SHA1" ); break; 02507 case SIG_RSA_SHA224 : ret = snprintf( p, n, "SHA224" ); break; 02508 case SIG_RSA_SHA256 : ret = snprintf( p, n, "SHA256" ); break; 02509 case SIG_RSA_SHA384 : ret = snprintf( p, n, "SHA384" ); break; 02510 case SIG_RSA_SHA512 : ret = snprintf( p, n, "SHA512" ); break; 02511 default: ret = snprintf( p, n, "???" ); break; 02512 } 02513 SAFE_SNPRINTF(); 02514 02515 ret = snprintf( p, n, "\n%sRSA key size : %d bits\n", prefix, 02516 (int) crt->rsa.N.n * (int) sizeof( unsigned long ) * 8 ); 02517 SAFE_SNPRINTF(); 02518 02519 return( (int) ( size - n ) ); 02520 } 02521 02522 /* Compare a given OID string with an OID x509_buf * */ 02523 #define OID_CMP(oid_str, oid_buf) \ 02524 ( ( OID_SIZE(oid_str) == (oid_buf)->len ) && \ 02525 memcmp( (oid_str), (oid_buf)->p, (oid_buf)->len) == 0) 02526 02527 /* 02528 * Return an informational string describing the given OID 02529 */ 02530 const char *x509_oid_get_description( x509_buf *oid ) 02531 { 02532 if ( oid == NULL ) 02533 return ( NULL ); 02534 02535 else if( OID_CMP( OID_SERVER_AUTH, oid ) ) 02536 return( STRING_SERVER_AUTH ); 02537 02538 else if( OID_CMP( OID_CLIENT_AUTH, oid ) ) 02539 return( STRING_CLIENT_AUTH ); 02540 02541 else if( OID_CMP( OID_CODE_SIGNING, oid ) ) 02542 return( STRING_CODE_SIGNING ); 02543 02544 else if( OID_CMP( OID_EMAIL_PROTECTION, oid ) ) 02545 return( STRING_EMAIL_PROTECTION ); 02546 02547 else if( OID_CMP( OID_TIME_STAMPING, oid ) ) 02548 return( STRING_TIME_STAMPING ); 02549 02550 else if( OID_CMP( OID_OCSP_SIGNING, oid ) ) 02551 return( STRING_OCSP_SIGNING ); 02552 02553 return( NULL ); 02554 } 02555 02556 /* Return the x.y.z.... style numeric string for the given OID */ 02557 int x509_oid_get_numeric_string( char *buf, size_t size, x509_buf *oid ) 02558 { 02559 int ret; 02560 size_t i, n; 02561 unsigned int value; 02562 char *p; 02563 02564 p = buf; 02565 n = size; 02566 02567 /* First byte contains first two dots */ 02568 if( oid->len > 0 ) 02569 { 02570 ret = snprintf( p, n, "%d.%d", oid->p[0]/40, oid->p[0]%40 ); 02571 SAFE_SNPRINTF(); 02572 } 02573 02574 /* TODO: value can overflow in value. */ 02575 value = 0; 02576 for( i = 1; i < oid->len; i++ ) 02577 { 02578 value <<= 7; 02579 value += oid->p[i] & 0x7F; 02580 02581 if( !( oid->p[i] & 0x80 ) ) 02582 { 02583 /* Last byte */ 02584 ret = snprintf( p, n, ".%d", value ); 02585 SAFE_SNPRINTF(); 02586 value = 0; 02587 } 02588 } 02589 02590 return( (int) ( size - n ) ); 02591 } 02592 02593 /* 02594 * Return an informational string about the CRL. 02595 */ 02596 int x509parse_crl_info( char *buf, size_t size, const char *prefix, 02597 const x509_crl *crl ) 02598 { 02599 int ret; 02600 size_t n; 02601 char *p; 02602 const x509_crl_entry *entry; 02603 02604 p = buf; 02605 n = size; 02606 02607 ret = snprintf( p, n, "%sCRL version : %d", 02608 prefix, crl->version ); 02609 SAFE_SNPRINTF(); 02610 02611 ret = snprintf( p, n, "\n%sissuer name : ", prefix ); 02612 SAFE_SNPRINTF(); 02613 ret = x509parse_dn_gets( p, n, &crl->issuer ); 02614 SAFE_SNPRINTF(); 02615 02616 ret = snprintf( p, n, "\n%sthis update : " \ 02617 "%04d-%02d-%02d %02d:%02d:%02d", prefix, 02618 crl->this_update.year, crl->this_update.mon, 02619 crl->this_update.day, crl->this_update.hour, 02620 crl->this_update.min, crl->this_update.sec ); 02621 SAFE_SNPRINTF(); 02622 02623 ret = snprintf( p, n, "\n%snext update : " \ 02624 "%04d-%02d-%02d %02d:%02d:%02d", prefix, 02625 crl->next_update.year, crl->next_update.mon, 02626 crl->next_update.day, crl->next_update.hour, 02627 crl->next_update.min, crl->next_update.sec ); 02628 SAFE_SNPRINTF(); 02629 02630 entry = &crl->entry; 02631 02632 ret = snprintf( p, n, "\n%sRevoked certificates:", 02633 prefix ); 02634 SAFE_SNPRINTF(); 02635 02636 while( entry != NULL && entry->raw.len != 0 ) 02637 { 02638 ret = snprintf( p, n, "\n%sserial number: ", 02639 prefix ); 02640 SAFE_SNPRINTF(); 02641 02642 ret = x509parse_serial_gets( p, n, &entry->serial); 02643 SAFE_SNPRINTF(); 02644 02645 ret = snprintf( p, n, " revocation date: " \ 02646 "%04d-%02d-%02d %02d:%02d:%02d", 02647 entry->revocation_date.year, entry->revocation_date.mon, 02648 entry->revocation_date.day, entry->revocation_date.hour, 02649 entry->revocation_date.min, entry->revocation_date.sec ); 02650 SAFE_SNPRINTF(); 02651 02652 entry = entry->next; 02653 } 02654 02655 ret = snprintf( p, n, "\n%ssigned using : RSA+", prefix ); 02656 SAFE_SNPRINTF(); 02657 02658 switch( crl->sig_alg ) 02659 { 02660 case SIG_RSA_MD2 : ret = snprintf( p, n, "MD2" ); break; 02661 case SIG_RSA_MD4 : ret = snprintf( p, n, "MD4" ); break; 02662 case SIG_RSA_MD5 : ret = snprintf( p, n, "MD5" ); break; 02663 case SIG_RSA_SHA1 : ret = snprintf( p, n, "SHA1" ); break; 02664 case SIG_RSA_SHA224 : ret = snprintf( p, n, "SHA224" ); break; 02665 case SIG_RSA_SHA256 : ret = snprintf( p, n, "SHA256" ); break; 02666 case SIG_RSA_SHA384 : ret = snprintf( p, n, "SHA384" ); break; 02667 case SIG_RSA_SHA512 : ret = snprintf( p, n, "SHA512" ); break; 02668 default: ret = snprintf( p, n, "???" ); break; 02669 } 02670 SAFE_SNPRINTF(); 02671 02672 ret = snprintf( p, n, "\n" ); 02673 SAFE_SNPRINTF(); 02674 02675 return( (int) ( size - n ) ); 02676 } 02677 02678 /* 02679 * Return 0 if the x509_time is still valid, or 1 otherwise. 02680 */ 02681 int x509parse_time_expired( const x509_time *to ) 02682 { 02683 int year, mon, day; 02684 int hour, min, sec; 02685 02686 #if defined(_WIN32) 02687 SYSTEMTIME st; 02688 02689 GetLocalTime(&st); 02690 02691 year = st.wYear; 02692 mon = st.wMonth; 02693 day = st.wDay; 02694 hour = st.wHour; 02695 min = st.wMinute; 02696 sec = st.wSecond; 02697 #else 02698 struct tm *lt; 02699 time_t tt; 02700 02701 tt = time( NULL ); 02702 lt = localtime( &tt ); 02703 02704 year = lt->tm_year + 1900; 02705 mon = lt->tm_mon + 1; 02706 day = lt->tm_mday; 02707 hour = lt->tm_hour; 02708 min = lt->tm_min; 02709 sec = lt->tm_sec; 02710 #endif 02711 02712 if( year > to->year ) 02713 return( 1 ); 02714 02715 if( year == to->year && 02716 mon > to->mon ) 02717 return( 1 ); 02718 02719 if( year == to->year && 02720 mon == to->mon && 02721 day > to->day ) 02722 return( 1 ); 02723 02724 if( year == to->year && 02725 mon == to->mon && 02726 day == to->day && 02727 hour > to->hour ) 02728 return( 1 ); 02729 02730 if( year == to->year && 02731 mon == to->mon && 02732 day == to->day && 02733 hour == to->hour && 02734 min > to->min ) 02735 return( 1 ); 02736 02737 if( year == to->year && 02738 mon == to->mon && 02739 day == to->day && 02740 hour == to->hour && 02741 min == to->min && 02742 sec > to->sec ) 02743 return( 1 ); 02744 02745 return( 0 ); 02746 } 02747 02748 /* 02749 * Return 1 if the certificate is revoked, or 0 otherwise. 02750 */ 02751 int x509parse_revoked( const x509_cert *crt, const x509_crl *crl ) 02752 { 02753 const x509_crl_entry *cur = &crl->entry; 02754 02755 while( cur != NULL && cur->serial.len != 0 ) 02756 { 02757 if( crt->serial.len == cur->serial.len && 02758 memcmp( crt->serial.p, cur->serial.p, crt->serial.len ) == 0 ) 02759 { 02760 if( x509parse_time_expired( &cur->revocation_date ) ) 02761 return( 1 ); 02762 } 02763 02764 cur = cur->next; 02765 } 02766 02767 return( 0 ); 02768 } 02769 02770 /* 02771 * Wrapper for x509 hashes. 02772 * 02773 * \param out Buffer to receive the hash (Should be at least 64 bytes) 02774 */ 02775 static void x509_hash( const unsigned char *in, size_t len, int alg, 02776 unsigned char *out ) 02777 { 02778 switch( alg ) 02779 { 02780 #if defined(POLARSSL_MD2_C) 02781 case SIG_RSA_MD2 : md2( in, len, out ); break; 02782 #endif 02783 #if defined(POLARSSL_MD4_C) 02784 case SIG_RSA_MD4 : md4( in, len, out ); break; 02785 #endif 02786 #if defined(POLARSSL_MD5_C) 02787 case SIG_RSA_MD5 : md5( in, len, out ); break; 02788 #endif 02789 #if defined(POLARSSL_SHA1_C) 02790 case SIG_RSA_SHA1 : sha1( in, len, out ); break; 02791 #endif 02792 #if defined(POLARSSL_SHA2_C) 02793 case SIG_RSA_SHA224 : sha2( in, len, out, 1 ); break; 02794 case SIG_RSA_SHA256 : sha2( in, len, out, 0 ); break; 02795 #endif 02796 #if defined(POLARSSL_SHA4_C) 02797 case SIG_RSA_SHA384 : sha4( in, len, out, 1 ); break; 02798 case SIG_RSA_SHA512 : sha4( in, len, out, 0 ); break; 02799 #endif 02800 default: 02801 memset( out, '\xFF', 64 ); 02802 break; 02803 } 02804 } 02805 02806 /* 02807 * Check that the given certificate is valid accoring to the CRL. 02808 */ 02809 static int x509parse_verifycrl(x509_cert *crt, x509_cert *ca, 02810 x509_crl *crl_list) 02811 { 02812 int flags = 0; 02813 int hash_id; 02814 unsigned char hash[64]; 02815 02816 /* 02817 * TODO: What happens if no CRL is present? 02818 * Suggestion: Revocation state should be unknown if no CRL is present. 02819 * For backwards compatibility this is not yet implemented. 02820 */ 02821 02822 while( ca != NULL && crl_list != NULL && crl_list->version != 0 ) 02823 { 02824 if( crl_list->issuer_raw.len != ca->subject_raw.len || 02825 memcmp( crl_list->issuer_raw.p, ca->subject_raw.p, 02826 crl_list->issuer_raw.len ) != 0 ) 02827 { 02828 crl_list = crl_list->next; 02829 continue; 02830 } 02831 02832 /* 02833 * Check if CRL is correctly signed by the trusted CA 02834 */ 02835 hash_id = crl_list->sig_alg; 02836 02837 x509_hash( crl_list->tbs.p, crl_list->tbs.len, hash_id, hash ); 02838 02839 if( !rsa_pkcs1_verify( &ca->rsa, RSA_PUBLIC, hash_id, 02840 0, hash, crl_list->sig.p ) == 0 ) 02841 { 02842 /* 02843 * CRL is not trusted 02844 */ 02845 flags |= BADCRL_NOT_TRUSTED; 02846 break; 02847 } 02848 02849 /* 02850 * Check for validity of CRL (Do not drop out) 02851 */ 02852 if( x509parse_time_expired( &crl_list->next_update ) ) 02853 flags |= BADCRL_EXPIRED; 02854 02855 /* 02856 * Check if certificate is revoked 02857 */ 02858 if( x509parse_revoked(crt, crl_list) ) 02859 { 02860 flags |= BADCERT_REVOKED; 02861 break; 02862 } 02863 02864 crl_list = crl_list->next; 02865 } 02866 return flags; 02867 } 02868 02869 /* 02870 * Verify the certificate validity 02871 */ 02872 int x509parse_verify( x509_cert *crt, 02873 x509_cert *trust_ca, 02874 x509_crl *ca_crl, 02875 const char *cn, int *flags, 02876 int (*f_vrfy)(void *, x509_cert *, int, int), 02877 void *p_vrfy ) 02878 { 02879 size_t cn_len; 02880 int hash_id; 02881 int pathlen; 02882 x509_cert *parent; 02883 x509_name *name; 02884 unsigned char hash[64]; 02885 02886 *flags = 0; 02887 02888 if( x509parse_time_expired( &crt->valid_to ) ) 02889 *flags = BADCERT_EXPIRED; 02890 02891 if( cn != NULL ) 02892 { 02893 name = &crt->subject; 02894 cn_len = strlen( cn ); 02895 02896 while( name != NULL ) 02897 { 02898 if( memcmp( name->oid.p, OID_CN, 3 ) == 0 && 02899 memcmp( name->val.p, cn, cn_len ) == 0 && 02900 name->val.len == cn_len ) 02901 break; 02902 02903 name = name->next; 02904 } 02905 02906 if( name == NULL ) 02907 *flags |= BADCERT_CN_MISMATCH; 02908 } 02909 02910 /* 02911 * Iterate upwards in the given cert chain, 02912 * ignoring any upper cert with CA != TRUE. 02913 */ 02914 parent = crt->next; 02915 02916 pathlen = 1; 02917 02918 while( parent != NULL && parent->version != 0 ) 02919 { 02920 if( parent->ca_istrue == 0 || 02921 crt->issuer_raw.len != parent->subject_raw.len || 02922 memcmp( crt->issuer_raw.p, parent->subject_raw.p, 02923 crt->issuer_raw.len ) != 0 ) 02924 { 02925 parent = parent->next; 02926 continue; 02927 } 02928 02929 hash_id = crt->sig_alg; 02930 02931 x509_hash( crt->tbs.p, crt->tbs.len, hash_id, hash ); 02932 02933 if( rsa_pkcs1_verify( &parent->rsa, RSA_PUBLIC, hash_id, 0, hash, 02934 crt->sig.p ) != 0 ) 02935 *flags |= BADCERT_NOT_TRUSTED; 02936 02937 /* Check trusted CA's CRL for the given crt */ 02938 *flags |= x509parse_verifycrl(crt, parent, ca_crl); 02939 02940 /* crt is verified to be a child of the parent cur, call verify callback */ 02941 if( NULL != f_vrfy ) 02942 { 02943 if( f_vrfy( p_vrfy, crt, pathlen - 1, ( *flags == 0 ) ) != 0 ) 02944 return( POLARSSL_ERR_X509_CERT_VERIFY_FAILED ); 02945 else 02946 *flags = 0; 02947 } 02948 else if( *flags != 0 ) 02949 return( POLARSSL_ERR_X509_CERT_VERIFY_FAILED ); 02950 02951 pathlen++; 02952 02953 crt = parent; 02954 parent = crt->next; 02955 } 02956 02957 /* 02958 * Attempt to validate topmost cert with our CA chain. 02959 */ 02960 *flags |= BADCERT_NOT_TRUSTED; 02961 02962 while( trust_ca != NULL && trust_ca->version != 0 ) 02963 { 02964 if( crt->issuer_raw.len != trust_ca->subject_raw.len || 02965 memcmp( crt->issuer_raw.p, trust_ca->subject_raw.p, 02966 crt->issuer_raw.len ) != 0 ) 02967 { 02968 trust_ca = trust_ca->next; 02969 continue; 02970 } 02971 02972 if( trust_ca->max_pathlen > 0 && 02973 trust_ca->max_pathlen < pathlen ) 02974 break; 02975 02976 hash_id = crt->sig_alg; 02977 02978 x509_hash( crt->tbs.p, crt->tbs.len, hash_id, hash ); 02979 02980 if( rsa_pkcs1_verify( &trust_ca->rsa, RSA_PUBLIC, hash_id, 02981 0, hash, crt->sig.p ) == 0 ) 02982 { 02983 /* 02984 * cert. is signed by a trusted CA 02985 */ 02986 *flags &= ~BADCERT_NOT_TRUSTED; 02987 break; 02988 } 02989 02990 trust_ca = trust_ca->next; 02991 } 02992 02993 /* Check trusted CA's CRL for the given crt */ 02994 *flags |= x509parse_verifycrl( crt, trust_ca, ca_crl ); 02995 02996 /* Verification succeeded, call callback on top cert */ 02997 if( NULL != f_vrfy ) 02998 { 02999 if( f_vrfy(p_vrfy, crt, pathlen-1, ( *flags == 0 ) ) != 0 ) 03000 return( POLARSSL_ERR_X509_CERT_VERIFY_FAILED ); 03001 else 03002 *flags = 0; 03003 } 03004 else if( *flags != 0 ) 03005 return( POLARSSL_ERR_X509_CERT_VERIFY_FAILED ); 03006 03007 return( 0 ); 03008 } 03009 03010 /* 03011 * Unallocate all certificate data 03012 */ 03013 void x509_free( x509_cert *crt ) 03014 { 03015 x509_cert *cert_cur = crt; 03016 x509_cert *cert_prv; 03017 x509_name *name_cur; 03018 x509_name *name_prv; 03019 x509_sequence *seq_cur; 03020 x509_sequence *seq_prv; 03021 03022 if( crt == NULL ) 03023 return; 03024 03025 do 03026 { 03027 rsa_free( &cert_cur->rsa ); 03028 03029 name_cur = cert_cur->issuer.next; 03030 while( name_cur != NULL ) 03031 { 03032 name_prv = name_cur; 03033 name_cur = name_cur->next; 03034 memset( name_prv, 0, sizeof( x509_name ) ); 03035 free( name_prv ); 03036 } 03037 03038 name_cur = cert_cur->subject.next; 03039 while( name_cur != NULL ) 03040 { 03041 name_prv = name_cur; 03042 name_cur = name_cur->next; 03043 memset( name_prv, 0, sizeof( x509_name ) ); 03044 free( name_prv ); 03045 } 03046 03047 seq_cur = cert_cur->ext_key_usage.next; 03048 while( seq_cur != NULL ) 03049 { 03050 seq_prv = seq_cur; 03051 seq_cur = seq_cur->next; 03052 memset( seq_prv, 0, sizeof( x509_sequence ) ); 03053 free( seq_prv ); 03054 } 03055 03056 if( cert_cur->raw.p != NULL ) 03057 { 03058 memset( cert_cur->raw.p, 0, cert_cur->raw.len ); 03059 free( cert_cur->raw.p ); 03060 } 03061 03062 cert_cur = cert_cur->next; 03063 } 03064 while( cert_cur != NULL ); 03065 03066 cert_cur = crt; 03067 do 03068 { 03069 cert_prv = cert_cur; 03070 cert_cur = cert_cur->next; 03071 03072 memset( cert_prv, 0, sizeof( x509_cert ) ); 03073 if( cert_prv != crt ) 03074 free( cert_prv ); 03075 } 03076 while( cert_cur != NULL ); 03077 } 03078 03079 /* 03080 * Unallocate all CRL data 03081 */ 03082 void x509_crl_free( x509_crl *crl ) 03083 { 03084 x509_crl *crl_cur = crl; 03085 x509_crl *crl_prv; 03086 x509_name *name_cur; 03087 x509_name *name_prv; 03088 x509_crl_entry *entry_cur; 03089 x509_crl_entry *entry_prv; 03090 03091 if( crl == NULL ) 03092 return; 03093 03094 do 03095 { 03096 name_cur = crl_cur->issuer.next; 03097 while( name_cur != NULL ) 03098 { 03099 name_prv = name_cur; 03100 name_cur = name_cur->next; 03101 memset( name_prv, 0, sizeof( x509_name ) ); 03102 free( name_prv ); 03103 } 03104 03105 entry_cur = crl_cur->entry.next; 03106 while( entry_cur != NULL ) 03107 { 03108 entry_prv = entry_cur; 03109 entry_cur = entry_cur->next; 03110 memset( entry_prv, 0, sizeof( x509_crl_entry ) ); 03111 free( entry_prv ); 03112 } 03113 03114 if( crl_cur->raw.p != NULL ) 03115 { 03116 memset( crl_cur->raw.p, 0, crl_cur->raw.len ); 03117 free( crl_cur->raw.p ); 03118 } 03119 03120 crl_cur = crl_cur->next; 03121 } 03122 while( crl_cur != NULL ); 03123 03124 crl_cur = crl; 03125 do 03126 { 03127 crl_prv = crl_cur; 03128 crl_cur = crl_cur->next; 03129 03130 memset( crl_prv, 0, sizeof( x509_crl ) ); 03131 if( crl_prv != crl ) 03132 free( crl_prv ); 03133 } 03134 while( crl_cur != NULL ); 03135 } 03136 03137 #if defined(POLARSSL_SELF_TEST) 03138 03139 #include "polarssl/certs.h" 03140 03141 /* 03142 * Checkup routine 03143 */ 03144 int x509_self_test( int verbose ) 03145 { 03146 #if defined(POLARSSL_CERTS_C) && defined(POLARSSL_MD5_C) 03147 int ret; 03148 int flags; 03149 size_t i, j; 03150 x509_cert cacert; 03151 x509_cert clicert; 03152 rsa_context rsa; 03153 #if defined(POLARSSL_DHM_C) 03154 dhm_context dhm; 03155 #endif 03156 03157 if( verbose != 0 ) 03158 printf( " X.509 certificate load: " ); 03159 03160 memset( &clicert, 0, sizeof( x509_cert ) ); 03161 03162 ret = x509parse_crt( &clicert, (unsigned char *) test_cli_crt, 03163 strlen( test_cli_crt ) ); 03164 if( ret != 0 ) 03165 { 03166 if( verbose != 0 ) 03167 printf( "failed\n" ); 03168 03169 return( ret ); 03170 } 03171 03172 memset( &cacert, 0, sizeof( x509_cert ) ); 03173 03174 ret = x509parse_crt( &cacert, (unsigned char *) test_ca_crt, 03175 strlen( test_ca_crt ) ); 03176 if( ret != 0 ) 03177 { 03178 if( verbose != 0 ) 03179 printf( "failed\n" ); 03180 03181 return( ret ); 03182 } 03183 03184 if( verbose != 0 ) 03185 printf( "passed\n X.509 private key load: " ); 03186 03187 i = strlen( test_ca_key ); 03188 j = strlen( test_ca_pwd ); 03189 03190 rsa_init( &rsa, RSA_PKCS_V15, 0 ); 03191 03192 if( ( ret = x509parse_key( &rsa, 03193 (unsigned char *) test_ca_key, i, 03194 (unsigned char *) test_ca_pwd, j ) ) != 0 ) 03195 { 03196 if( verbose != 0 ) 03197 printf( "failed\n" ); 03198 03199 return( ret ); 03200 } 03201 03202 if( verbose != 0 ) 03203 printf( "passed\n X.509 signature verify: "); 03204 03205 ret = x509parse_verify( &clicert, &cacert, NULL, "PolarSSL Client 2", &flags, NULL, NULL ); 03206 if( ret != 0 ) 03207 { 03208 printf("%02x", flags); 03209 if( verbose != 0 ) 03210 printf( "failed\n" ); 03211 03212 return( ret ); 03213 } 03214 03215 #if defined(POLARSSL_DHM_C) 03216 if( verbose != 0 ) 03217 printf( "passed\n X.509 DHM parameter load: " ); 03218 03219 i = strlen( test_dhm_params ); 03220 j = strlen( test_ca_pwd ); 03221 03222 if( ( ret = x509parse_dhm( &dhm, (unsigned char *) test_dhm_params, i ) ) != 0 ) 03223 { 03224 if( verbose != 0 ) 03225 printf( "failed\n" ); 03226 03227 return( ret ); 03228 } 03229 03230 if( verbose != 0 ) 03231 printf( "passed\n\n" ); 03232 #endif 03233 03234 x509_free( &cacert ); 03235 x509_free( &clicert ); 03236 rsa_free( &rsa ); 03237 #if defined(POLARSSL_DHM_C) 03238 dhm_free( &dhm ); 03239 #endif 03240 03241 return( 0 ); 03242 #else 03243 ((void) verbose); 03244 return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE ); 03245 #endif 03246 } 03247 03248 #endif 03249 03250 #endif