PolarSSL v1.1.3
x509parse.c
Go to the documentation of this file.
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