PolarSSL v1.1.4
x509parse.c
Go to the documentation of this file.
1 /*
2  * X.509 certificate and private key decoding
3  *
4  * Copyright (C) 2006-2011, Brainspark B.V.
5  *
6  * This file is part of PolarSSL (http://www.polarssl.org)
7  * Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
8  *
9  * All rights reserved.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License along
22  * with this program; if not, write to the Free Software Foundation, Inc.,
23  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24  */
25 /*
26  * The ITU-T X.509 standard defines a certificat format for PKI.
27  *
28  * http://www.ietf.org/rfc/rfc2459.txt
29  * http://www.ietf.org/rfc/rfc3279.txt
30  *
31  * ftp://ftp.rsasecurity.com/pub/pkcs/ascii/pkcs-1v2.asc
32  *
33  * http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
34  * http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
35  */
36 
37 #include "polarssl/config.h"
38 
39 #if defined(POLARSSL_X509_PARSE_C)
40 
41 #include "polarssl/x509.h"
42 #include "polarssl/asn1.h"
43 #include "polarssl/pem.h"
44 #include "polarssl/des.h"
45 #include "polarssl/md2.h"
46 #include "polarssl/md4.h"
47 #include "polarssl/md5.h"
48 #include "polarssl/sha1.h"
49 #include "polarssl/sha2.h"
50 #include "polarssl/sha4.h"
51 #include "polarssl/dhm.h"
52 
53 #include <string.h>
54 #include <stdlib.h>
55 #if defined(_WIN32)
56 #include <windows.h>
57 #else
58 #include <time.h>
59 #endif
60 
61 #if defined(POLARSSL_FS_IO)
62 #include <stdio.h>
63 #endif
64 
65 /*
66  * Version ::= INTEGER { v1(0), v2(1), v3(2) }
67  */
68 static int x509_get_version( unsigned char **p,
69  const unsigned char *end,
70  int *ver )
71 {
72  int ret;
73  size_t len;
74 
75  if( ( ret = asn1_get_tag( p, end, &len,
77  {
79  {
80  *ver = 0;
81  return( 0 );
82  }
83 
84  return( ret );
85  }
86 
87  end = *p + len;
88 
89  if( ( ret = asn1_get_int( p, end, ver ) ) != 0 )
91 
92  if( *p != end )
95 
96  return( 0 );
97 }
98 
99 /*
100  * Version ::= INTEGER { v1(0), v2(1) }
101  */
102 static int x509_crl_get_version( unsigned char **p,
103  const unsigned char *end,
104  int *ver )
105 {
106  int ret;
107 
108  if( ( ret = asn1_get_int( p, end, ver ) ) != 0 )
109  {
111  {
112  *ver = 0;
113  return( 0 );
114  }
115 
117  }
118 
119  return( 0 );
120 }
121 
122 /*
123  * CertificateSerialNumber ::= INTEGER
124  */
125 static int x509_get_serial( unsigned char **p,
126  const unsigned char *end,
127  x509_buf *serial )
128 {
129  int ret;
130 
131  if( ( end - *p ) < 1 )
134 
135  if( **p != ( ASN1_CONTEXT_SPECIFIC | ASN1_PRIMITIVE | 2 ) &&
136  **p != ASN1_INTEGER )
139 
140  serial->tag = *(*p)++;
141 
142  if( ( ret = asn1_get_len( p, end, &serial->len ) ) != 0 )
144 
145  serial->p = *p;
146  *p += serial->len;
147 
148  return( 0 );
149 }
150 
151 /*
152  * AlgorithmIdentifier ::= SEQUENCE {
153  * algorithm OBJECT IDENTIFIER,
154  * parameters ANY DEFINED BY algorithm OPTIONAL }
155  */
156 static int x509_get_alg( unsigned char **p,
157  const unsigned char *end,
158  x509_buf *alg )
159 {
160  int ret;
161  size_t len;
162 
163  if( ( ret = asn1_get_tag( p, end, &len,
164  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
165  return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret );
166 
167  end = *p + len;
168  alg->tag = **p;
169 
170  if( ( ret = asn1_get_tag( p, end, &alg->len, ASN1_OID ) ) != 0 )
171  return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret );
172 
173  alg->p = *p;
174  *p += alg->len;
175 
176  if( *p == end )
177  return( 0 );
178 
179  /*
180  * assume the algorithm parameters must be NULL
181  */
182  if( ( ret = asn1_get_tag( p, end, &len, ASN1_NULL ) ) != 0 )
183  return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret );
184 
185  if( *p != end )
188 
189  return( 0 );
190 }
191 
192 /*
193  * AttributeTypeAndValue ::= SEQUENCE {
194  * type AttributeType,
195  * value AttributeValue }
196  *
197  * AttributeType ::= OBJECT IDENTIFIER
198  *
199  * AttributeValue ::= ANY DEFINED BY AttributeType
200  */
201 static int x509_get_attr_type_value( unsigned char **p,
202  const unsigned char *end,
203  x509_name *cur )
204 {
205  int ret;
206  size_t len;
207  x509_buf *oid;
208  x509_buf *val;
209 
210  if( ( ret = asn1_get_tag( p, end, &len,
211  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
212  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
213 
214  oid = &cur->oid;
215  oid->tag = **p;
216 
217  if( ( ret = asn1_get_tag( p, end, &oid->len, ASN1_OID ) ) != 0 )
218  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
219 
220  oid->p = *p;
221  *p += oid->len;
222 
223  if( ( end - *p ) < 1 )
226 
227  if( **p != ASN1_BMP_STRING && **p != ASN1_UTF8_STRING &&
228  **p != ASN1_T61_STRING && **p != ASN1_PRINTABLE_STRING &&
229  **p != ASN1_IA5_STRING && **p != ASN1_UNIVERSAL_STRING )
232 
233  val = &cur->val;
234  val->tag = *(*p)++;
235 
236  if( ( ret = asn1_get_len( p, end, &val->len ) ) != 0 )
237  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
238 
239  val->p = *p;
240  *p += val->len;
241 
242  cur->next = NULL;
243 
244  return( 0 );
245 }
246 
247 /*
248  * RelativeDistinguishedName ::=
249  * SET OF AttributeTypeAndValue
250  *
251  * AttributeTypeAndValue ::= SEQUENCE {
252  * type AttributeType,
253  * value AttributeValue }
254  *
255  * AttributeType ::= OBJECT IDENTIFIER
256  *
257  * AttributeValue ::= ANY DEFINED BY AttributeType
258  */
259 static int x509_get_name( unsigned char **p,
260  const unsigned char *end,
261  x509_name *cur )
262 {
263  int ret;
264  size_t len;
265  const unsigned char *end2;
266  x509_name *use;
267 
268  if( ( ret = asn1_get_tag( p, end, &len,
269  ASN1_CONSTRUCTED | ASN1_SET ) ) != 0 )
270  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
271 
272  end2 = end;
273  end = *p + len;
274  use = cur;
275 
276  do
277  {
278  if( ( ret = x509_get_attr_type_value( p, end, use ) ) != 0 )
279  return( ret );
280 
281  if( *p != end )
282  {
283  use->next = (x509_name *) malloc(
284  sizeof( x509_name ) );
285 
286  if( use->next == NULL )
288 
289  memset( use->next, 0, sizeof( x509_name ) );
290 
291  use = use->next;
292  }
293  }
294  while( *p != end );
295 
296  /*
297  * recurse until end of SEQUENCE is reached
298  */
299  if( *p == end2 )
300  return( 0 );
301 
302  cur->next = (x509_name *) malloc(
303  sizeof( x509_name ) );
304 
305  if( cur->next == NULL )
307 
308  memset( cur->next, 0, sizeof( x509_name ) );
309 
310  return( x509_get_name( p, end2, cur->next ) );
311 }
312 
313 /*
314  * Time ::= CHOICE {
315  * utcTime UTCTime,
316  * generalTime GeneralizedTime }
317  */
318 static int x509_get_time( unsigned char **p,
319  const unsigned char *end,
320  x509_time *time )
321 {
322  int ret;
323  size_t len;
324  char date[64];
325  unsigned char tag;
326 
327  if( ( end - *p ) < 1 )
330 
331  tag = **p;
332 
333  if ( tag == ASN1_UTC_TIME )
334  {
335  (*p)++;
336  ret = asn1_get_len( p, end, &len );
337 
338  if( ret != 0 )
339  return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret );
340 
341  memset( date, 0, sizeof( date ) );
342  memcpy( date, *p, ( len < sizeof( date ) - 1 ) ?
343  len : sizeof( date ) - 1 );
344 
345  if( sscanf( date, "%2d%2d%2d%2d%2d%2d",
346  &time->year, &time->mon, &time->day,
347  &time->hour, &time->min, &time->sec ) < 5 )
349 
350  time->year += 100 * ( time->year < 50 );
351  time->year += 1900;
352 
353  *p += len;
354 
355  return( 0 );
356  }
357  else if ( tag == ASN1_GENERALIZED_TIME )
358  {
359  (*p)++;
360  ret = asn1_get_len( p, end, &len );
361 
362  if( ret != 0 )
363  return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret );
364 
365  memset( date, 0, sizeof( date ) );
366  memcpy( date, *p, ( len < sizeof( date ) - 1 ) ?
367  len : sizeof( date ) - 1 );
368 
369  if( sscanf( date, "%4d%2d%2d%2d%2d%2d",
370  &time->year, &time->mon, &time->day,
371  &time->hour, &time->min, &time->sec ) < 5 )
373 
374  *p += len;
375 
376  return( 0 );
377  }
378  else
380 }
381 
382 
383 /*
384  * Validity ::= SEQUENCE {
385  * notBefore Time,
386  * notAfter Time }
387  */
388 static int x509_get_dates( unsigned char **p,
389  const unsigned char *end,
390  x509_time *from,
391  x509_time *to )
392 {
393  int ret;
394  size_t len;
395 
396  if( ( ret = asn1_get_tag( p, end, &len,
397  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
398  return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret );
399 
400  end = *p + len;
401 
402  if( ( ret = x509_get_time( p, end, from ) ) != 0 )
403  return( ret );
404 
405  if( ( ret = x509_get_time( p, end, to ) ) != 0 )
406  return( ret );
407 
408  if( *p != end )
411 
412  return( 0 );
413 }
414 
415 /*
416  * SubjectPublicKeyInfo ::= SEQUENCE {
417  * algorithm AlgorithmIdentifier,
418  * subjectPublicKey BIT STRING }
419  */
420 static int x509_get_pubkey( unsigned char **p,
421  const unsigned char *end,
422  x509_buf *pk_alg_oid,
423  mpi *N, mpi *E )
424 {
425  int ret, can_handle;
426  size_t len;
427  unsigned char *end2;
428 
429  if( ( ret = x509_get_alg( p, end, pk_alg_oid ) ) != 0 )
430  return( ret );
431 
432  /*
433  * only RSA public keys handled at this time
434  */
435  can_handle = 0;
436 
437  if( pk_alg_oid->len == 9 &&
438  memcmp( pk_alg_oid->p, OID_PKCS1_RSA, 9 ) == 0 )
439  can_handle = 1;
440 
441  if( pk_alg_oid->len == 9 &&
442  memcmp( pk_alg_oid->p, OID_PKCS1, 8 ) == 0 )
443  {
444  if( pk_alg_oid->p[8] >= 2 && pk_alg_oid->p[8] <= 5 )
445  can_handle = 1;
446 
447  if ( pk_alg_oid->p[8] >= 11 && pk_alg_oid->p[8] <= 14 )
448  can_handle = 1;
449  }
450 
451  if( pk_alg_oid->len == 5 &&
452  memcmp( pk_alg_oid->p, OID_RSA_SHA_OBS, 5 ) == 0 )
453  can_handle = 1;
454 
455  if( can_handle == 0 )
457 
458  if( ( ret = asn1_get_tag( p, end, &len, ASN1_BIT_STRING ) ) != 0 )
460 
461  if( ( end - *p ) < 1 )
464 
465  end2 = *p + len;
466 
467  if( *(*p)++ != 0 )
469 
470  /*
471  * RSAPublicKey ::= SEQUENCE {
472  * modulus INTEGER, -- n
473  * publicExponent INTEGER -- e
474  * }
475  */
476  if( ( ret = asn1_get_tag( p, end2, &len,
477  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
479 
480  if( *p + len != end2 )
483 
484  if( ( ret = asn1_get_mpi( p, end2, N ) ) != 0 ||
485  ( ret = asn1_get_mpi( p, end2, E ) ) != 0 )
487 
488  if( *p != end )
491 
492  return( 0 );
493 }
494 
495 static int x509_get_sig( unsigned char **p,
496  const unsigned char *end,
497  x509_buf *sig )
498 {
499  int ret;
500  size_t len;
501 
502  sig->tag = **p;
503 
504  if( ( ret = asn1_get_tag( p, end, &len, ASN1_BIT_STRING ) ) != 0 )
506 
507 
508  if( --len < 1 || *(*p)++ != 0 )
510 
511  sig->len = len;
512  sig->p = *p;
513 
514  *p += len;
515 
516  return( 0 );
517 }
518 
519 /*
520  * X.509 v2/v3 unique identifier (not parsed)
521  */
522 static int x509_get_uid( unsigned char **p,
523  const unsigned char *end,
524  x509_buf *uid, int n )
525 {
526  int ret;
527 
528  if( *p == end )
529  return( 0 );
530 
531  uid->tag = **p;
532 
533  if( ( ret = asn1_get_tag( p, end, &uid->len,
534  ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | n ) ) != 0 )
535  {
537  return( 0 );
538 
539  return( ret );
540  }
541 
542  uid->p = *p;
543  *p += uid->len;
544 
545  return( 0 );
546 }
547 
548 /*
549  * X.509 Extensions (No parsing of extensions, pointer should
550  * be either manually updated or extensions should be parsed!
551  */
552 static int x509_get_ext( unsigned char **p,
553  const unsigned char *end,
554  x509_buf *ext, int tag )
555 {
556  int ret;
557  size_t len;
558 
559  if( *p == end )
560  return( 0 );
561 
562  ext->tag = **p;
563 
564  if( ( ret = asn1_get_tag( p, end, &ext->len,
565  ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | tag ) ) != 0 )
566  return( ret );
567 
568  ext->p = *p;
569  end = *p + ext->len;
570 
571  /*
572  * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
573  *
574  * Extension ::= SEQUENCE {
575  * extnID OBJECT IDENTIFIER,
576  * critical BOOLEAN DEFAULT FALSE,
577  * extnValue OCTET STRING }
578  */
579  if( ( ret = asn1_get_tag( p, end, &len,
580  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
582 
583  if( end != *p + len )
586 
587  return( 0 );
588 }
589 
590 /*
591  * X.509 CRL v2 extensions (no extensions parsed yet.)
592  */
593 static int x509_get_crl_ext( unsigned char **p,
594  const unsigned char *end,
595  x509_buf *ext )
596 {
597  int ret;
598  size_t len = 0;
599 
600  /* Get explicit tag */
601  if( ( ret = x509_get_ext( p, end, ext, 0) ) != 0 )
602  {
604  return( 0 );
605 
606  return( ret );
607  }
608 
609  while( *p < end )
610  {
611  if( ( ret = asn1_get_tag( p, end, &len,
612  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
614 
615  *p += len;
616  }
617 
618  if( *p != end )
621 
622  return( 0 );
623 }
624 
625 /*
626  * X.509 CRL v2 entry extensions (no extensions parsed yet.)
627  */
628 static int x509_get_crl_entry_ext( unsigned char **p,
629  const unsigned char *end,
630  x509_buf *ext )
631 {
632  int ret;
633  size_t len = 0;
634 
635  /* OPTIONAL */
636  if (end <= *p)
637  return( 0 );
638 
639  ext->tag = **p;
640  ext->p = *p;
641 
642  /*
643  * Get CRL-entry extension sequence header
644  * crlEntryExtensions Extensions OPTIONAL -- if present, MUST be v2
645  */
646  if( ( ret = asn1_get_tag( p, end, &ext->len,
647  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
648  {
650  {
651  ext->p = NULL;
652  return( 0 );
653  }
655  }
656 
657  end = *p + ext->len;
658 
659  if( end != *p + ext->len )
662 
663  while( *p < end )
664  {
665  if( ( ret = asn1_get_tag( p, end, &len,
666  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
668 
669  *p += len;
670  }
671 
672  if( *p != end )
675 
676  return( 0 );
677 }
678 
679 static int x509_get_basic_constraints( unsigned char **p,
680  const unsigned char *end,
681  int *ca_istrue,
682  int *max_pathlen )
683 {
684  int ret;
685  size_t len;
686 
687  /*
688  * BasicConstraints ::= SEQUENCE {
689  * cA BOOLEAN DEFAULT FALSE,
690  * pathLenConstraint INTEGER (0..MAX) OPTIONAL }
691  */
692  *ca_istrue = 0; /* DEFAULT FALSE */
693  *max_pathlen = 0; /* endless */
694 
695  if( ( ret = asn1_get_tag( p, end, &len,
696  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
698 
699  if( *p == end )
700  return 0;
701 
702  if( ( ret = asn1_get_bool( p, end, ca_istrue ) ) != 0 )
703  {
705  ret = asn1_get_int( p, end, ca_istrue );
706 
707  if( ret != 0 )
709 
710  if( *ca_istrue != 0 )
711  *ca_istrue = 1;
712  }
713 
714  if( *p == end )
715  return 0;
716 
717  if( ( ret = asn1_get_int( p, end, max_pathlen ) ) != 0 )
719 
720  if( *p != end )
723 
724  (*max_pathlen)++;
725 
726  return 0;
727 }
728 
729 static int x509_get_ns_cert_type( unsigned char **p,
730  const unsigned char *end,
731  unsigned char *ns_cert_type)
732 {
733  int ret;
734  x509_bitstring bs = { 0, 0, NULL };
735 
736  if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 )
738 
739  if( bs.len != 1 )
742 
743  /* Get actual bitstring */
744  *ns_cert_type = *bs.p;
745  return 0;
746 }
747 
748 static int x509_get_key_usage( unsigned char **p,
749  const unsigned char *end,
750  unsigned char *key_usage)
751 {
752  int ret;
753  x509_bitstring bs = { 0, 0, NULL };
754 
755  if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 )
757 
758  if( bs.len > 1 )
761 
762  /* Get actual bitstring */
763  *key_usage = *bs.p;
764  return 0;
765 }
766 
767 /*
768  * ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
769  *
770  * KeyPurposeId ::= OBJECT IDENTIFIER
771  */
772 static int x509_get_ext_key_usage( unsigned char **p,
773  const unsigned char *end,
774  x509_sequence *ext_key_usage)
775 {
776  int ret;
777 
778  if( ( ret = asn1_get_sequence_of( p, end, ext_key_usage, ASN1_OID ) ) != 0 )
780 
781  /* Sequence length must be >= 1 */
782  if( ext_key_usage->buf.p == NULL )
785 
786  return 0;
787 }
788 
789 /*
790  * X.509 v3 extensions
791  *
792  * TODO: Perform all of the basic constraints tests required by the RFC
793  * TODO: Set values for undetected extensions to a sane default?
794  *
795  */
796 static int x509_get_crt_ext( unsigned char **p,
797  const unsigned char *end,
798  x509_cert *crt )
799 {
800  int ret;
801  size_t len;
802  unsigned char *end_ext_data, *end_ext_octet;
803 
804  if( ( ret = x509_get_ext( p, end, &crt->v3_ext, 3 ) ) != 0 )
805  {
807  return( 0 );
808 
809  return( ret );
810  }
811 
812  while( *p < end )
813  {
814  /*
815  * Extension ::= SEQUENCE {
816  * extnID OBJECT IDENTIFIER,
817  * critical BOOLEAN DEFAULT FALSE,
818  * extnValue OCTET STRING }
819  */
820  x509_buf extn_oid = {0, 0, NULL};
821  int is_critical = 0; /* DEFAULT FALSE */
822 
823  if( ( ret = asn1_get_tag( p, end, &len,
824  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
826 
827  end_ext_data = *p + len;
828 
829  /* Get extension ID */
830  extn_oid.tag = **p;
831 
832  if( ( ret = asn1_get_tag( p, end, &extn_oid.len, ASN1_OID ) ) != 0 )
834 
835  extn_oid.p = *p;
836  *p += extn_oid.len;
837 
838  if( ( end - *p ) < 1 )
841 
842  /* Get optional critical */
843  if( ( ret = asn1_get_bool( p, end_ext_data, &is_critical ) ) != 0 &&
846 
847  /* Data should be octet string type */
848  if( ( ret = asn1_get_tag( p, end_ext_data, &len,
849  ASN1_OCTET_STRING ) ) != 0 )
851 
852  end_ext_octet = *p + len;
853 
854  if( end_ext_octet != end_ext_data )
857 
858  /*
859  * Detect supported extensions
860  */
861  if( ( OID_SIZE( OID_BASIC_CONSTRAINTS ) == extn_oid.len ) &&
862  memcmp( extn_oid.p, OID_BASIC_CONSTRAINTS, extn_oid.len ) == 0 )
863  {
864  /* Parse basic constraints */
865  if( ( ret = x509_get_basic_constraints( p, end_ext_octet,
866  &crt->ca_istrue, &crt->max_pathlen ) ) != 0 )
867  return ( ret );
869  }
870  else if( ( OID_SIZE( OID_NS_CERT_TYPE ) == extn_oid.len ) &&
871  memcmp( extn_oid.p, OID_NS_CERT_TYPE, extn_oid.len ) == 0 )
872  {
873  /* Parse netscape certificate type */
874  if( ( ret = x509_get_ns_cert_type( p, end_ext_octet,
875  &crt->ns_cert_type ) ) != 0 )
876  return ( ret );
877  crt->ext_types |= EXT_NS_CERT_TYPE;
878  }
879  else if( ( OID_SIZE( OID_KEY_USAGE ) == extn_oid.len ) &&
880  memcmp( extn_oid.p, OID_KEY_USAGE, extn_oid.len ) == 0 )
881  {
882  /* Parse key usage */
883  if( ( ret = x509_get_key_usage( p, end_ext_octet,
884  &crt->key_usage ) ) != 0 )
885  return ( ret );
886  crt->ext_types |= EXT_KEY_USAGE;
887  }
888  else if( ( OID_SIZE( OID_EXTENDED_KEY_USAGE ) == extn_oid.len ) &&
889  memcmp( extn_oid.p, OID_EXTENDED_KEY_USAGE, extn_oid.len ) == 0 )
890  {
891  /* Parse extended key usage */
892  if( ( ret = x509_get_ext_key_usage( p, end_ext_octet,
893  &crt->ext_key_usage ) ) != 0 )
894  return ( ret );
896  }
897  else
898  {
899  /* No parser found, skip extension */
900  *p = end_ext_octet;
901 
902 #if !defined(POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
903  if( is_critical )
904  {
905  /* Data is marked as critical: fail */
908  }
909 #endif
910  }
911  }
912 
913  if( *p != end )
916 
917  return( 0 );
918 }
919 
920 /*
921  * X.509 CRL Entries
922  */
923 static int x509_get_entries( unsigned char **p,
924  const unsigned char *end,
926 {
927  int ret;
928  size_t entry_len;
929  x509_crl_entry *cur_entry = entry;
930 
931  if( *p == end )
932  return( 0 );
933 
934  if( ( ret = asn1_get_tag( p, end, &entry_len,
935  ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 )
936  {
938  return( 0 );
939 
940  return( ret );
941  }
942 
943  end = *p + entry_len;
944 
945  while( *p < end )
946  {
947  size_t len2;
948  const unsigned char *end2;
949 
950  if( ( ret = asn1_get_tag( p, end, &len2,
951  ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 )
952  {
953  return( ret );
954  }
955 
956  cur_entry->raw.tag = **p;
957  cur_entry->raw.p = *p;
958  cur_entry->raw.len = len2;
959  end2 = *p + len2;
960 
961  if( ( ret = x509_get_serial( p, end2, &cur_entry->serial ) ) != 0 )
962  return( ret );
963 
964  if( ( ret = x509_get_time( p, end2, &cur_entry->revocation_date ) ) != 0 )
965  return( ret );
966 
967  if( ( ret = x509_get_crl_entry_ext( p, end2, &cur_entry->entry_ext ) ) != 0 )
968  return( ret );
969 
970  if ( *p < end )
971  {
972  cur_entry->next = malloc( sizeof( x509_crl_entry ) );
973 
974  if( cur_entry->next == NULL )
976 
977  cur_entry = cur_entry->next;
978  memset( cur_entry, 0, sizeof( x509_crl_entry ) );
979  }
980  }
981 
982  return( 0 );
983 }
984 
985 static int x509_get_sig_alg( const x509_buf *sig_oid, int *sig_alg )
986 {
987  if( sig_oid->len == 9 &&
988  memcmp( sig_oid->p, OID_PKCS1, 8 ) == 0 )
989  {
990  if( sig_oid->p[8] >= 2 && sig_oid->p[8] <= 5 )
991  {
992  *sig_alg = sig_oid->p[8];
993  return( 0 );
994  }
995 
996  if ( sig_oid->p[8] >= 11 && sig_oid->p[8] <= 14 )
997  {
998  *sig_alg = sig_oid->p[8];
999  return( 0 );
1000  }
1001 
1003  }
1004  if( sig_oid->len == 5 &&
1005  memcmp( sig_oid->p, OID_RSA_SHA_OBS, 5 ) == 0 )
1006  {
1007  *sig_alg = SIG_RSA_SHA1;
1008  return( 0 );
1009  }
1010 
1012 }
1013 
1014 /*
1015  * Parse and fill a single X.509 certificate in DER format
1016  */
1017 int x509parse_crt_der( x509_cert *crt, const unsigned char *buf, size_t buflen )
1018 {
1019  int ret;
1020  size_t len;
1021  unsigned char *p, *end;
1022 
1023  /*
1024  * Check for valid input
1025  */
1026  if( crt == NULL || buf == NULL )
1028 
1029  p = (unsigned char *) malloc( len = buflen );
1030 
1031  if( p == NULL )
1033 
1034  memcpy( p, buf, buflen );
1035 
1036  buflen = 0;
1037 
1038  crt->raw.p = p;
1039  crt->raw.len = len;
1040  end = p + len;
1041 
1042  /*
1043  * Certificate ::= SEQUENCE {
1044  * tbsCertificate TBSCertificate,
1045  * signatureAlgorithm AlgorithmIdentifier,
1046  * signatureValue BIT STRING }
1047  */
1048  if( ( ret = asn1_get_tag( &p, end, &len,
1049  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1050  {
1051  x509_free( crt );
1053  }
1054 
1055  if( len != (size_t) ( end - p ) )
1056  {
1057  x509_free( crt );
1060  }
1061 
1062  /*
1063  * TBSCertificate ::= SEQUENCE {
1064  */
1065  crt->tbs.p = p;
1066 
1067  if( ( ret = asn1_get_tag( &p, end, &len,
1068  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1069  {
1070  x509_free( crt );
1071  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1072  }
1073 
1074  end = p + len;
1075  crt->tbs.len = end - crt->tbs.p;
1076 
1077  /*
1078  * Version ::= INTEGER { v1(0), v2(1), v3(2) }
1079  *
1080  * CertificateSerialNumber ::= INTEGER
1081  *
1082  * signature AlgorithmIdentifier
1083  */
1084  if( ( ret = x509_get_version( &p, end, &crt->version ) ) != 0 ||
1085  ( ret = x509_get_serial( &p, end, &crt->serial ) ) != 0 ||
1086  ( ret = x509_get_alg( &p, end, &crt->sig_oid1 ) ) != 0 )
1087  {
1088  x509_free( crt );
1089  return( ret );
1090  }
1091 
1092  crt->version++;
1093 
1094  if( crt->version > 3 )
1095  {
1096  x509_free( crt );
1098  }
1099 
1100  if( ( ret = x509_get_sig_alg( &crt->sig_oid1, &crt->sig_alg ) ) != 0 )
1101  {
1102  x509_free( crt );
1103  return( ret );
1104  }
1105 
1106  /*
1107  * issuer Name
1108  */
1109  crt->issuer_raw.p = p;
1110 
1111  if( ( ret = asn1_get_tag( &p, end, &len,
1112  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1113  {
1114  x509_free( crt );
1115  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1116  }
1117 
1118  if( ( ret = x509_get_name( &p, p + len, &crt->issuer ) ) != 0 )
1119  {
1120  x509_free( crt );
1121  return( ret );
1122  }
1123 
1124  crt->issuer_raw.len = p - crt->issuer_raw.p;
1125 
1126  /*
1127  * Validity ::= SEQUENCE {
1128  * notBefore Time,
1129  * notAfter Time }
1130  *
1131  */
1132  if( ( ret = x509_get_dates( &p, end, &crt->valid_from,
1133  &crt->valid_to ) ) != 0 )
1134  {
1135  x509_free( crt );
1136  return( ret );
1137  }
1138 
1139  /*
1140  * subject Name
1141  */
1142  crt->subject_raw.p = p;
1143 
1144  if( ( ret = asn1_get_tag( &p, end, &len,
1145  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1146  {
1147  x509_free( crt );
1148  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1149  }
1150 
1151  if( ( ret = x509_get_name( &p, p + len, &crt->subject ) ) != 0 )
1152  {
1153  x509_free( crt );
1154  return( ret );
1155  }
1156 
1157  crt->subject_raw.len = p - crt->subject_raw.p;
1158 
1159  /*
1160  * SubjectPublicKeyInfo ::= SEQUENCE
1161  * algorithm AlgorithmIdentifier,
1162  * subjectPublicKey BIT STRING }
1163  */
1164  if( ( ret = asn1_get_tag( &p, end, &len,
1165  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1166  {
1167  x509_free( crt );
1168  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1169  }
1170 
1171  if( ( ret = x509_get_pubkey( &p, p + len, &crt->pk_oid,
1172  &crt->rsa.N, &crt->rsa.E ) ) != 0 )
1173  {
1174  x509_free( crt );
1175  return( ret );
1176  }
1177 
1178  if( ( ret = rsa_check_pubkey( &crt->rsa ) ) != 0 )
1179  {
1180  x509_free( crt );
1181  return( ret );
1182  }
1183 
1184  crt->rsa.len = mpi_size( &crt->rsa.N );
1185 
1186  /*
1187  * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
1188  * -- If present, version shall be v2 or v3
1189  * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
1190  * -- If present, version shall be v2 or v3
1191  * extensions [3] EXPLICIT Extensions OPTIONAL
1192  * -- If present, version shall be v3
1193  */
1194  if( crt->version == 2 || crt->version == 3 )
1195  {
1196  ret = x509_get_uid( &p, end, &crt->issuer_id, 1 );
1197  if( ret != 0 )
1198  {
1199  x509_free( crt );
1200  return( ret );
1201  }
1202  }
1203 
1204  if( crt->version == 2 || crt->version == 3 )
1205  {
1206  ret = x509_get_uid( &p, end, &crt->subject_id, 2 );
1207  if( ret != 0 )
1208  {
1209  x509_free( crt );
1210  return( ret );
1211  }
1212  }
1213 
1214  if( crt->version == 3 )
1215  {
1216  ret = x509_get_crt_ext( &p, end, crt);
1217  if( ret != 0 )
1218  {
1219  x509_free( crt );
1220  return( ret );
1221  }
1222  }
1223 
1224  if( p != end )
1225  {
1226  x509_free( crt );
1229  }
1230 
1231  end = crt->raw.p + crt->raw.len;
1232 
1233  /*
1234  * signatureAlgorithm AlgorithmIdentifier,
1235  * signatureValue BIT STRING
1236  */
1237  if( ( ret = x509_get_alg( &p, end, &crt->sig_oid2 ) ) != 0 )
1238  {
1239  x509_free( crt );
1240  return( ret );
1241  }
1242 
1243  if( memcmp( crt->sig_oid1.p, crt->sig_oid2.p, crt->sig_oid1.len ) != 0 )
1244  {
1245  x509_free( crt );
1247  }
1248 
1249  if( ( ret = x509_get_sig( &p, end, &crt->sig ) ) != 0 )
1250  {
1251  x509_free( crt );
1252  return( ret );
1253  }
1254 
1255  if( p != end )
1256  {
1257  x509_free( crt );
1260  }
1261 
1262  return( 0 );
1263 }
1264 
1265 /*
1266  * Parse one or more PEM certificates from a buffer and add them to the chained list
1267  */
1268 int x509parse_crt( x509_cert *chain, const unsigned char *buf, size_t buflen )
1269 {
1270  int ret, success = 0, first_error = 0, total_failed = 0;
1271  x509_cert *crt, *prev = NULL;
1272  int buf_format = X509_FORMAT_DER;
1273 
1274  crt = chain;
1275 
1276  /*
1277  * Check for valid input
1278  */
1279  if( crt == NULL || buf == NULL )
1281 
1282  while( crt->version != 0 && crt->next != NULL )
1283  {
1284  prev = crt;
1285  crt = crt->next;
1286  }
1287 
1288  /*
1289  * Add new certificate on the end of the chain if needed.
1290  */
1291  if ( crt->version != 0 && crt->next == NULL)
1292  {
1293  crt->next = (x509_cert *) malloc( sizeof( x509_cert ) );
1294 
1295  if( crt->next == NULL )
1297 
1298  prev = crt;
1299  crt = crt->next;
1300  memset( crt, 0, sizeof( x509_cert ) );
1301  }
1302 
1303  /*
1304  * Determine buffer content. Buffer contains either one DER certificate or
1305  * one or more PEM certificates.
1306  */
1307 #if defined(POLARSSL_PEM_C)
1308  if( strstr( (char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
1309  buf_format = X509_FORMAT_PEM;
1310 #endif
1311 
1312  if( buf_format == X509_FORMAT_DER )
1313  return x509parse_crt_der( crt, buf, buflen );
1314 
1315 #if defined(POLARSSL_PEM_C)
1316  if( buf_format == X509_FORMAT_PEM )
1317  {
1318  pem_context pem;
1319 
1320  while( buflen > 0 )
1321  {
1322  size_t use_len;
1323  pem_init( &pem );
1324 
1325  ret = pem_read_buffer( &pem,
1326  "-----BEGIN CERTIFICATE-----",
1327  "-----END CERTIFICATE-----",
1328  buf, NULL, 0, &use_len );
1329 
1330  if( ret == 0 )
1331  {
1332  /*
1333  * Was PEM encoded
1334  */
1335  buflen -= use_len;
1336  buf += use_len;
1337  }
1338  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT )
1339  {
1340  pem_free( &pem );
1341 
1342  if( first_error == 0 )
1343  first_error = ret;
1344 
1345  continue;
1346  }
1347  else
1348  break;
1349 
1350  ret = x509parse_crt_der( crt, pem.buf, pem.buflen );
1351 
1352  pem_free( &pem );
1353 
1354  if( ret != 0 )
1355  {
1356  /*
1357  * quit parsing on a memory error
1358  */
1359  if( ret == POLARSSL_ERR_X509_MALLOC_FAILED )
1360  {
1361  if( prev )
1362  prev->next = NULL;
1363 
1364  if( crt != chain )
1365  free( crt );
1366 
1367  return( ret );
1368  }
1369 
1370  if( first_error == 0 )
1371  first_error = ret;
1372 
1373  total_failed++;
1374 
1375  memset( crt, 0, sizeof( x509_cert ) );
1376  continue;
1377  }
1378 
1379  success = 1;
1380 
1381  /*
1382  * Add new certificate to the list
1383  */
1384  crt->next = (x509_cert *) malloc( sizeof( x509_cert ) );
1385 
1386  if( crt->next == NULL )
1388 
1389  prev = crt;
1390  crt = crt->next;
1391  memset( crt, 0, sizeof( x509_cert ) );
1392  }
1393  }
1394 #endif
1395 
1396  if( crt->version == 0 )
1397  {
1398  if( prev )
1399  prev->next = NULL;
1400 
1401  if( crt != chain )
1402  free( crt );
1403  }
1404 
1405  if( success )
1406  return( total_failed );
1407  else if( first_error )
1408  return( first_error );
1409  else
1411 }
1412 
1413 /*
1414  * Parse one or more CRLs and add them to the chained list
1415  */
1416 int x509parse_crl( x509_crl *chain, const unsigned char *buf, size_t buflen )
1417 {
1418  int ret;
1419  size_t len;
1420  unsigned char *p, *end;
1421  x509_crl *crl;
1422 #if defined(POLARSSL_PEM_C)
1423  size_t use_len;
1424  pem_context pem;
1425 #endif
1426 
1427  crl = chain;
1428 
1429  /*
1430  * Check for valid input
1431  */
1432  if( crl == NULL || buf == NULL )
1434 
1435  while( crl->version != 0 && crl->next != NULL )
1436  crl = crl->next;
1437 
1438  /*
1439  * Add new CRL on the end of the chain if needed.
1440  */
1441  if ( crl->version != 0 && crl->next == NULL)
1442  {
1443  crl->next = (x509_crl *) malloc( sizeof( x509_crl ) );
1444 
1445  if( crl->next == NULL )
1446  {
1447  x509_crl_free( crl );
1449  }
1450 
1451  crl = crl->next;
1452  memset( crl, 0, sizeof( x509_crl ) );
1453  }
1454 
1455 #if defined(POLARSSL_PEM_C)
1456  pem_init( &pem );
1457  ret = pem_read_buffer( &pem,
1458  "-----BEGIN X509 CRL-----",
1459  "-----END X509 CRL-----",
1460  buf, NULL, 0, &use_len );
1461 
1462  if( ret == 0 )
1463  {
1464  /*
1465  * Was PEM encoded
1466  */
1467  buflen -= use_len;
1468  buf += use_len;
1469 
1470  /*
1471  * Steal PEM buffer
1472  */
1473  p = pem.buf;
1474  pem.buf = NULL;
1475  len = pem.buflen;
1476  pem_free( &pem );
1477  }
1478  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT )
1479  {
1480  pem_free( &pem );
1481  return( ret );
1482  }
1483  else
1484  {
1485  /*
1486  * nope, copy the raw DER data
1487  */
1488  p = (unsigned char *) malloc( len = buflen );
1489 
1490  if( p == NULL )
1492 
1493  memcpy( p, buf, buflen );
1494 
1495  buflen = 0;
1496  }
1497 #else
1498  p = (unsigned char *) malloc( len = buflen );
1499 
1500  if( p == NULL )
1502 
1503  memcpy( p, buf, buflen );
1504 
1505  buflen = 0;
1506 #endif
1507 
1508  crl->raw.p = p;
1509  crl->raw.len = len;
1510  end = p + len;
1511 
1512  /*
1513  * CertificateList ::= SEQUENCE {
1514  * tbsCertList TBSCertList,
1515  * signatureAlgorithm AlgorithmIdentifier,
1516  * signatureValue BIT STRING }
1517  */
1518  if( ( ret = asn1_get_tag( &p, end, &len,
1519  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1520  {
1521  x509_crl_free( crl );
1523  }
1524 
1525  if( len != (size_t) ( end - p ) )
1526  {
1527  x509_crl_free( crl );
1530  }
1531 
1532  /*
1533  * TBSCertList ::= SEQUENCE {
1534  */
1535  crl->tbs.p = p;
1536 
1537  if( ( ret = asn1_get_tag( &p, end, &len,
1538  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1539  {
1540  x509_crl_free( crl );
1541  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1542  }
1543 
1544  end = p + len;
1545  crl->tbs.len = end - crl->tbs.p;
1546 
1547  /*
1548  * Version ::= INTEGER OPTIONAL { v1(0), v2(1) }
1549  * -- if present, MUST be v2
1550  *
1551  * signature AlgorithmIdentifier
1552  */
1553  if( ( ret = x509_crl_get_version( &p, end, &crl->version ) ) != 0 ||
1554  ( ret = x509_get_alg( &p, end, &crl->sig_oid1 ) ) != 0 )
1555  {
1556  x509_crl_free( crl );
1557  return( ret );
1558  }
1559 
1560  crl->version++;
1561 
1562  if( crl->version > 2 )
1563  {
1564  x509_crl_free( crl );
1566  }
1567 
1568  if( ( ret = x509_get_sig_alg( &crl->sig_oid1, &crl->sig_alg ) ) != 0 )
1569  {
1570  x509_crl_free( crl );
1572  }
1573 
1574  /*
1575  * issuer Name
1576  */
1577  crl->issuer_raw.p = p;
1578 
1579  if( ( ret = asn1_get_tag( &p, end, &len,
1580  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1581  {
1582  x509_crl_free( crl );
1583  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1584  }
1585 
1586  if( ( ret = x509_get_name( &p, p + len, &crl->issuer ) ) != 0 )
1587  {
1588  x509_crl_free( crl );
1589  return( ret );
1590  }
1591 
1592  crl->issuer_raw.len = p - crl->issuer_raw.p;
1593 
1594  /*
1595  * thisUpdate Time
1596  * nextUpdate Time OPTIONAL
1597  */
1598  if( ( ret = x509_get_time( &p, end, &crl->this_update ) ) != 0 )
1599  {
1600  x509_crl_free( crl );
1601  return( ret );
1602  }
1603 
1604  if( ( ret = x509_get_time( &p, end, &crl->next_update ) ) != 0 )
1605  {
1606  if ( ret != ( POLARSSL_ERR_X509_CERT_INVALID_DATE +
1610  {
1611  x509_crl_free( crl );
1612  return( ret );
1613  }
1614  }
1615 
1616  /*
1617  * revokedCertificates SEQUENCE OF SEQUENCE {
1618  * userCertificate CertificateSerialNumber,
1619  * revocationDate Time,
1620  * crlEntryExtensions Extensions OPTIONAL
1621  * -- if present, MUST be v2
1622  * } OPTIONAL
1623  */
1624  if( ( ret = x509_get_entries( &p, end, &crl->entry ) ) != 0 )
1625  {
1626  x509_crl_free( crl );
1627  return( ret );
1628  }
1629 
1630  /*
1631  * crlExtensions EXPLICIT Extensions OPTIONAL
1632  * -- if present, MUST be v2
1633  */
1634  if( crl->version == 2 )
1635  {
1636  ret = x509_get_crl_ext( &p, end, &crl->crl_ext );
1637 
1638  if( ret != 0 )
1639  {
1640  x509_crl_free( crl );
1641  return( ret );
1642  }
1643  }
1644 
1645  if( p != end )
1646  {
1647  x509_crl_free( crl );
1650  }
1651 
1652  end = crl->raw.p + crl->raw.len;
1653 
1654  /*
1655  * signatureAlgorithm AlgorithmIdentifier,
1656  * signatureValue BIT STRING
1657  */
1658  if( ( ret = x509_get_alg( &p, end, &crl->sig_oid2 ) ) != 0 )
1659  {
1660  x509_crl_free( crl );
1661  return( ret );
1662  }
1663 
1664  if( memcmp( crl->sig_oid1.p, crl->sig_oid2.p, crl->sig_oid1.len ) != 0 )
1665  {
1666  x509_crl_free( crl );
1668  }
1669 
1670  if( ( ret = x509_get_sig( &p, end, &crl->sig ) ) != 0 )
1671  {
1672  x509_crl_free( crl );
1673  return( ret );
1674  }
1675 
1676  if( p != end )
1677  {
1678  x509_crl_free( crl );
1681  }
1682 
1683  if( buflen > 0 )
1684  {
1685  crl->next = (x509_crl *) malloc( sizeof( x509_crl ) );
1686 
1687  if( crl->next == NULL )
1688  {
1689  x509_crl_free( crl );
1691  }
1692 
1693  crl = crl->next;
1694  memset( crl, 0, sizeof( x509_crl ) );
1695 
1696  return( x509parse_crl( crl, buf, buflen ) );
1697  }
1698 
1699  return( 0 );
1700 }
1701 
1702 #if defined(POLARSSL_FS_IO)
1703 /*
1704  * Load all data from a file into a given buffer.
1705  */
1706 int load_file( const char *path, unsigned char **buf, size_t *n )
1707 {
1708  FILE *f;
1709 
1710  if( ( f = fopen( path, "rb" ) ) == NULL )
1712 
1713  fseek( f, 0, SEEK_END );
1714  *n = (size_t) ftell( f );
1715  fseek( f, 0, SEEK_SET );
1716 
1717  if( ( *buf = (unsigned char *) malloc( *n + 1 ) ) == NULL )
1719 
1720  if( fread( *buf, 1, *n, f ) != *n )
1721  {
1722  fclose( f );
1723  free( *buf );
1725  }
1726 
1727  fclose( f );
1728 
1729  (*buf)[*n] = '\0';
1730 
1731  return( 0 );
1732 }
1733 
1734 /*
1735  * Load one or more certificates and add them to the chained list
1736  */
1737 int x509parse_crtfile( x509_cert *chain, const char *path )
1738 {
1739  int ret;
1740  size_t n;
1741  unsigned char *buf;
1742 
1743  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
1744  return( ret );
1745 
1746  ret = x509parse_crt( chain, buf, n );
1747 
1748  memset( buf, 0, n + 1 );
1749  free( buf );
1750 
1751  return( ret );
1752 }
1753 
1754 /*
1755  * Load one or more CRLs and add them to the chained list
1756  */
1757 int x509parse_crlfile( x509_crl *chain, const char *path )
1758 {
1759  int ret;
1760  size_t n;
1761  unsigned char *buf;
1762 
1763  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
1764  return( ret );
1765 
1766  ret = x509parse_crl( chain, buf, n );
1767 
1768  memset( buf, 0, n + 1 );
1769  free( buf );
1770 
1771  return( ret );
1772 }
1773 
1774 /*
1775  * Load and parse a private RSA key
1776  */
1777 int x509parse_keyfile( rsa_context *rsa, const char *path, const char *pwd )
1778 {
1779  int ret;
1780  size_t n;
1781  unsigned char *buf;
1782 
1783  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
1784  return( ret );
1785 
1786  if( pwd == NULL )
1787  ret = x509parse_key( rsa, buf, n, NULL, 0 );
1788  else
1789  ret = x509parse_key( rsa, buf, n,
1790  (unsigned char *) pwd, strlen( pwd ) );
1791 
1792  memset( buf, 0, n + 1 );
1793  free( buf );
1794 
1795  return( ret );
1796 }
1797 
1798 /*
1799  * Load and parse a public RSA key
1800  */
1801 int x509parse_public_keyfile( rsa_context *rsa, const char *path )
1802 {
1803  int ret;
1804  size_t n;
1805  unsigned char *buf;
1806 
1807  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
1808  return( ret );
1809 
1810  ret = x509parse_public_key( rsa, buf, n );
1811 
1812  memset( buf, 0, n + 1 );
1813  free( buf );
1814 
1815  return( ret );
1816 }
1817 #endif /* POLARSSL_FS_IO */
1818 
1819 /*
1820  * Parse a private RSA key
1821  */
1822 int x509parse_key( rsa_context *rsa, const unsigned char *key, size_t keylen,
1823  const unsigned char *pwd, size_t pwdlen )
1824 {
1825  int ret;
1826  size_t len;
1827  unsigned char *p, *end;
1828  unsigned char *p_alt;
1829  x509_buf pk_alg_oid;
1830 
1831 #if defined(POLARSSL_PEM_C)
1832  pem_context pem;
1833 
1834  pem_init( &pem );
1835  ret = pem_read_buffer( &pem,
1836  "-----BEGIN RSA PRIVATE KEY-----",
1837  "-----END RSA PRIVATE KEY-----",
1838  key, pwd, pwdlen, &len );
1839 
1841  {
1842  ret = pem_read_buffer( &pem,
1843  "-----BEGIN PRIVATE KEY-----",
1844  "-----END PRIVATE KEY-----",
1845  key, pwd, pwdlen, &len );
1846  }
1847 
1848  if( ret == 0 )
1849  {
1850  /*
1851  * Was PEM encoded
1852  */
1853  keylen = pem.buflen;
1854  }
1855  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT )
1856  {
1857  pem_free( &pem );
1858  return( ret );
1859  }
1860 
1861  p = ( ret == 0 ) ? pem.buf : (unsigned char *) key;
1862 #else
1863  ((void) pwd);
1864  ((void) pwdlen);
1865  p = (unsigned char *) key;
1866 #endif
1867  end = p + keylen;
1868 
1869  /*
1870  * Note: Depending on the type of private key file one can expect either a
1871  * PrivatKeyInfo object (PKCS#8) or a RSAPrivateKey (PKCS#1) directly.
1872  *
1873  * PrivateKeyInfo ::= SEQUENCE {
1874  * version Version,
1875  * algorithm AlgorithmIdentifier,
1876  * PrivateKey BIT STRING
1877  * }
1878  *
1879  * AlgorithmIdentifier ::= SEQUENCE {
1880  * algorithm OBJECT IDENTIFIER,
1881  * parameters ANY DEFINED BY algorithm OPTIONAL
1882  * }
1883  *
1884  * RSAPrivateKey ::= SEQUENCE {
1885  * version Version,
1886  * modulus INTEGER, -- n
1887  * publicExponent INTEGER, -- e
1888  * privateExponent INTEGER, -- d
1889  * prime1 INTEGER, -- p
1890  * prime2 INTEGER, -- q
1891  * exponent1 INTEGER, -- d mod (p-1)
1892  * exponent2 INTEGER, -- d mod (q-1)
1893  * coefficient INTEGER, -- (inverse of q) mod p
1894  * otherPrimeInfos OtherPrimeInfos OPTIONAL
1895  * }
1896  */
1897  if( ( ret = asn1_get_tag( &p, end, &len,
1898  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1899  {
1900 #if defined(POLARSSL_PEM_C)
1901  pem_free( &pem );
1902 #endif
1903  rsa_free( rsa );
1904  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
1905  }
1906 
1907  end = p + len;
1908 
1909  if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 )
1910  {
1911 #if defined(POLARSSL_PEM_C)
1912  pem_free( &pem );
1913 #endif
1914  rsa_free( rsa );
1915  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
1916  }
1917 
1918  if( rsa->ver != 0 )
1919  {
1920 #if defined(POLARSSL_PEM_C)
1921  pem_free( &pem );
1922 #endif
1923  rsa_free( rsa );
1924  return( POLARSSL_ERR_X509_KEY_INVALID_VERSION + ret );
1925  }
1926 
1927  p_alt = p;
1928 
1929  if( ( ret = x509_get_alg( &p_alt, end, &pk_alg_oid ) ) != 0 )
1930  {
1931  // Assume that we have the PKCS#1 format if wrong
1932  // tag was encountered
1933  //
1936  {
1937 #if defined(POLARSSL_PEM_C)
1938  pem_free( &pem );
1939 #endif
1940  rsa_free( rsa );
1942  }
1943  }
1944  else
1945  {
1946  int can_handle;
1947 
1948  /*
1949  * only RSA keys handled at this time
1950  */
1951  can_handle = 0;
1952 
1953  if( pk_alg_oid.len == 9 &&
1954  memcmp( pk_alg_oid.p, OID_PKCS1_RSA, 9 ) == 0 )
1955  can_handle = 1;
1956 
1957  if( pk_alg_oid.len == 9 &&
1958  memcmp( pk_alg_oid.p, OID_PKCS1, 8 ) == 0 )
1959  {
1960  if( pk_alg_oid.p[8] >= 2 && pk_alg_oid.p[8] <= 5 )
1961  can_handle = 1;
1962 
1963  if ( pk_alg_oid.p[8] >= 11 && pk_alg_oid.p[8] <= 14 )
1964  can_handle = 1;
1965  }
1966 
1967  if( pk_alg_oid.len == 5 &&
1968  memcmp( pk_alg_oid.p, OID_RSA_SHA_OBS, 5 ) == 0 )
1969  can_handle = 1;
1970 
1971  if( can_handle == 0 )
1973 
1974  /*
1975  * Parse the PKCS#8 format
1976  */
1977 
1978  p = p_alt;
1979  if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 )
1980  {
1981 #if defined(POLARSSL_PEM_C)
1982  pem_free( &pem );
1983 #endif
1984  rsa_free( rsa );
1985  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
1986  }
1987 
1988  if( ( end - p ) < 1 )
1989  {
1990 #if defined(POLARSSL_PEM_C)
1991  pem_free( &pem );
1992 #endif
1993  rsa_free( rsa );
1996  }
1997 
1998  end = p + len;
1999 
2000  if( ( ret = asn1_get_tag( &p, end, &len,
2001  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2002  {
2003 #if defined(POLARSSL_PEM_C)
2004  pem_free( &pem );
2005 #endif
2006  rsa_free( rsa );
2007  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2008  }
2009 
2010  end = p + len;
2011 
2012  if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 )
2013  {
2014 #if defined(POLARSSL_PEM_C)
2015  pem_free( &pem );
2016 #endif
2017  rsa_free( rsa );
2018  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2019  }
2020 
2021  if( rsa->ver != 0 )
2022  {
2023 #if defined(POLARSSL_PEM_C)
2024  pem_free( &pem );
2025 #endif
2026  rsa_free( rsa );
2027  return( POLARSSL_ERR_X509_KEY_INVALID_VERSION + ret );
2028  }
2029  }
2030 
2031  if( ( ret = asn1_get_mpi( &p, end, &rsa->N ) ) != 0 ||
2032  ( ret = asn1_get_mpi( &p, end, &rsa->E ) ) != 0 ||
2033  ( ret = asn1_get_mpi( &p, end, &rsa->D ) ) != 0 ||
2034  ( ret = asn1_get_mpi( &p, end, &rsa->P ) ) != 0 ||
2035  ( ret = asn1_get_mpi( &p, end, &rsa->Q ) ) != 0 ||
2036  ( ret = asn1_get_mpi( &p, end, &rsa->DP ) ) != 0 ||
2037  ( ret = asn1_get_mpi( &p, end, &rsa->DQ ) ) != 0 ||
2038  ( ret = asn1_get_mpi( &p, end, &rsa->QP ) ) != 0 )
2039  {
2040 #if defined(POLARSSL_PEM_C)
2041  pem_free( &pem );
2042 #endif
2043  rsa_free( rsa );
2044  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2045  }
2046 
2047  rsa->len = mpi_size( &rsa->N );
2048 
2049  if( p != end )
2050  {
2051 #if defined(POLARSSL_PEM_C)
2052  pem_free( &pem );
2053 #endif
2054  rsa_free( rsa );
2057  }
2058 
2059  if( ( ret = rsa_check_privkey( rsa ) ) != 0 )
2060  {
2061 #if defined(POLARSSL_PEM_C)
2062  pem_free( &pem );
2063 #endif
2064  rsa_free( rsa );
2065  return( ret );
2066  }
2067 
2068 #if defined(POLARSSL_PEM_C)
2069  pem_free( &pem );
2070 #endif
2071 
2072  return( 0 );
2073 }
2074 
2075 /*
2076  * Parse a public RSA key
2077  */
2078 int x509parse_public_key( rsa_context *rsa, const unsigned char *key, size_t keylen )
2079 {
2080  int ret;
2081  size_t len;
2082  unsigned char *p, *end;
2083  x509_buf alg_oid;
2084 #if defined(POLARSSL_PEM_C)
2085  pem_context pem;
2086 
2087  pem_init( &pem );
2088  ret = pem_read_buffer( &pem,
2089  "-----BEGIN PUBLIC KEY-----",
2090  "-----END PUBLIC KEY-----",
2091  key, NULL, 0, &len );
2092 
2093  if( ret == 0 )
2094  {
2095  /*
2096  * Was PEM encoded
2097  */
2098  keylen = pem.buflen;
2099  }
2100  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT )
2101  {
2102  pem_free( &pem );
2103  return( ret );
2104  }
2105 
2106  p = ( ret == 0 ) ? pem.buf : (unsigned char *) key;
2107 #else
2108  p = (unsigned char *) key;
2109 #endif
2110  end = p + keylen;
2111 
2112  /*
2113  * PublicKeyInfo ::= SEQUENCE {
2114  * algorithm AlgorithmIdentifier,
2115  * PublicKey BIT STRING
2116  * }
2117  *
2118  * AlgorithmIdentifier ::= SEQUENCE {
2119  * algorithm OBJECT IDENTIFIER,
2120  * parameters ANY DEFINED BY algorithm OPTIONAL
2121  * }
2122  *
2123  * RSAPublicKey ::= SEQUENCE {
2124  * modulus INTEGER, -- n
2125  * publicExponent INTEGER -- e
2126  * }
2127  */
2128 
2129  if( ( ret = asn1_get_tag( &p, end, &len,
2130  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2131  {
2132 #if defined(POLARSSL_PEM_C)
2133  pem_free( &pem );
2134 #endif
2135  rsa_free( rsa );
2136  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
2137  }
2138 
2139  if( ( ret = x509_get_pubkey( &p, end, &alg_oid, &rsa->N, &rsa->E ) ) != 0 )
2140  {
2141 #if defined(POLARSSL_PEM_C)
2142  pem_free( &pem );
2143 #endif
2144  rsa_free( rsa );
2145  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2146  }
2147 
2148  if( ( ret = rsa_check_pubkey( rsa ) ) != 0 )
2149  {
2150 #if defined(POLARSSL_PEM_C)
2151  pem_free( &pem );
2152 #endif
2153  rsa_free( rsa );
2154  return( ret );
2155  }
2156 
2157  rsa->len = mpi_size( &rsa->N );
2158 
2159 #if defined(POLARSSL_PEM_C)
2160  pem_free( &pem );
2161 #endif
2162 
2163  return( 0 );
2164 }
2165 
2166 #if defined(POLARSSL_DHM_C)
2167 /*
2168  * Parse DHM parameters
2169  */
2170 int x509parse_dhm( dhm_context *dhm, const unsigned char *dhmin, size_t dhminlen )
2171 {
2172  int ret;
2173  size_t len;
2174  unsigned char *p, *end;
2175 #if defined(POLARSSL_PEM_C)
2176  pem_context pem;
2177 
2178  pem_init( &pem );
2179 
2180  ret = pem_read_buffer( &pem,
2181  "-----BEGIN DH PARAMETERS-----",
2182  "-----END DH PARAMETERS-----",
2183  dhmin, NULL, 0, &dhminlen );
2184 
2185  if( ret == 0 )
2186  {
2187  /*
2188  * Was PEM encoded
2189  */
2190  dhminlen = pem.buflen;
2191  }
2192  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_PRESENT )
2193  {
2194  pem_free( &pem );
2195  return( ret );
2196  }
2197 
2198  p = ( ret == 0 ) ? pem.buf : (unsigned char *) dhmin;
2199 #else
2200  p = (unsigned char *) dhmin;
2201 #endif
2202  end = p + dhminlen;
2203 
2204  memset( dhm, 0, sizeof( dhm_context ) );
2205 
2206  /*
2207  * DHParams ::= SEQUENCE {
2208  * prime INTEGER, -- P
2209  * generator INTEGER, -- g
2210  * }
2211  */
2212  if( ( ret = asn1_get_tag( &p, end, &len,
2213  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2214  {
2215 #if defined(POLARSSL_PEM_C)
2216  pem_free( &pem );
2217 #endif
2218  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2219  }
2220 
2221  end = p + len;
2222 
2223  if( ( ret = asn1_get_mpi( &p, end, &dhm->P ) ) != 0 ||
2224  ( ret = asn1_get_mpi( &p, end, &dhm->G ) ) != 0 )
2225  {
2226 #if defined(POLARSSL_PEM_C)
2227  pem_free( &pem );
2228 #endif
2229  dhm_free( dhm );
2230  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2231  }
2232 
2233  if( p != end )
2234  {
2235 #if defined(POLARSSL_PEM_C)
2236  pem_free( &pem );
2237 #endif
2238  dhm_free( dhm );
2241  }
2242 
2243 #if defined(POLARSSL_PEM_C)
2244  pem_free( &pem );
2245 #endif
2246 
2247  return( 0 );
2248 }
2249 
2250 #if defined(POLARSSL_FS_IO)
2251 /*
2252  * Load and parse a private RSA key
2253  */
2254 int x509parse_dhmfile( dhm_context *dhm, const char *path )
2255 {
2256  int ret;
2257  size_t n;
2258  unsigned char *buf;
2259 
2260  if ( ( ret = load_file( path, &buf, &n ) ) != 0 )
2261  return( ret );
2262 
2263  ret = x509parse_dhm( dhm, buf, n );
2264 
2265  memset( buf, 0, n + 1 );
2266  free( buf );
2267 
2268  return( ret );
2269 }
2270 #endif /* POLARSSL_FS_IO */
2271 #endif /* POLARSSL_DHM_C */
2272 
2273 #if defined _MSC_VER && !defined snprintf
2274 #include <stdarg.h>
2275 
2276 #if !defined vsnprintf
2277 #define vsnprintf _vsnprintf
2278 #endif // vsnprintf
2279 
2280 /*
2281  * Windows _snprintf and _vsnprintf are not compatible to linux versions.
2282  * Result value is not size of buffer needed, but -1 if no fit is possible.
2283  *
2284  * This fuction tries to 'fix' this by at least suggesting enlarging the
2285  * size by 20.
2286  */
2287 int compat_snprintf(char *str, size_t size, const char *format, ...)
2288 {
2289  va_list ap;
2290  int res = -1;
2291 
2292  va_start( ap, format );
2293 
2294  res = vsnprintf( str, size, format, ap );
2295 
2296  va_end( ap );
2297 
2298  // No quick fix possible
2299  if ( res < 0 )
2300  return( (int) size + 20 );
2301 
2302  return res;
2303 }
2304 
2305 #define snprintf compat_snprintf
2306 #endif
2307 
2308 #define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2
2309 
2310 #define SAFE_SNPRINTF() \
2311 { \
2312  if( ret == -1 ) \
2313  return( -1 ); \
2314  \
2315  if ( (unsigned int) ret > n ) { \
2316  p[n - 1] = '\0'; \
2317  return POLARSSL_ERR_DEBUG_BUF_TOO_SMALL;\
2318  } \
2319  \
2320  n -= (unsigned int) ret; \
2321  p += (unsigned int) ret; \
2322 }
2323 
2324 /*
2325  * Store the name in printable form into buf; no more
2326  * than size characters will be written
2327  */
2328 int x509parse_dn_gets( char *buf, size_t size, const x509_name *dn )
2329 {
2330  int ret;
2331  size_t i, n;
2332  unsigned char c;
2333  const x509_name *name;
2334  char s[128], *p;
2335 
2336  memset( s, 0, sizeof( s ) );
2337 
2338  name = dn;
2339  p = buf;
2340  n = size;
2341 
2342  while( name != NULL )
2343  {
2344  if( name != dn )
2345  {
2346  ret = snprintf( p, n, ", " );
2347  SAFE_SNPRINTF();
2348  }
2349 
2350  if( memcmp( name->oid.p, OID_X520, 2 ) == 0 )
2351  {
2352  switch( name->oid.p[2] )
2353  {
2354  case X520_COMMON_NAME:
2355  ret = snprintf( p, n, "CN=" ); break;
2356 
2357  case X520_COUNTRY:
2358  ret = snprintf( p, n, "C=" ); break;
2359 
2360  case X520_LOCALITY:
2361  ret = snprintf( p, n, "L=" ); break;
2362 
2363  case X520_STATE:
2364  ret = snprintf( p, n, "ST=" ); break;
2365 
2366  case X520_ORGANIZATION:
2367  ret = snprintf( p, n, "O=" ); break;
2368 
2369  case X520_ORG_UNIT:
2370  ret = snprintf( p, n, "OU=" ); break;
2371 
2372  default:
2373  ret = snprintf( p, n, "0x%02X=",
2374  name->oid.p[2] );
2375  break;
2376  }
2377  SAFE_SNPRINTF();
2378  }
2379  else if( memcmp( name->oid.p, OID_PKCS9, 8 ) == 0 )
2380  {
2381  switch( name->oid.p[8] )
2382  {
2383  case PKCS9_EMAIL:
2384  ret = snprintf( p, n, "emailAddress=" ); break;
2385 
2386  default:
2387  ret = snprintf( p, n, "0x%02X=",
2388  name->oid.p[8] );
2389  break;
2390  }
2391  SAFE_SNPRINTF();
2392  }
2393  else
2394  {
2395  ret = snprintf( p, n, "\?\?=" );
2396  SAFE_SNPRINTF();
2397  }
2398 
2399  for( i = 0; i < name->val.len; i++ )
2400  {
2401  if( i >= sizeof( s ) - 1 )
2402  break;
2403 
2404  c = name->val.p[i];
2405  if( c < 32 || c == 127 || ( c > 128 && c < 160 ) )
2406  s[i] = '?';
2407  else s[i] = c;
2408  }
2409  s[i] = '\0';
2410  ret = snprintf( p, n, "%s", s );
2411  SAFE_SNPRINTF();
2412  name = name->next;
2413  }
2414 
2415  return( (int) ( size - n ) );
2416 }
2417 
2418 /*
2419  * Store the serial in printable form into buf; no more
2420  * than size characters will be written
2421  */
2422 int x509parse_serial_gets( char *buf, size_t size, const x509_buf *serial )
2423 {
2424  int ret;
2425  size_t i, n, nr;
2426  char *p;
2427 
2428  p = buf;
2429  n = size;
2430 
2431  nr = ( serial->len <= 32 )
2432  ? serial->len : 28;
2433 
2434  for( i = 0; i < nr; i++ )
2435  {
2436  if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
2437  continue;
2438 
2439  ret = snprintf( p, n, "%02X%s",
2440  serial->p[i], ( i < nr - 1 ) ? ":" : "" );
2441  SAFE_SNPRINTF();
2442  }
2443 
2444  if( nr != serial->len )
2445  {
2446  ret = snprintf( p, n, "...." );
2447  SAFE_SNPRINTF();
2448  }
2449 
2450  return( (int) ( size - n ) );
2451 }
2452 
2453 /*
2454  * Return an informational string about the certificate.
2455  */
2456 int x509parse_cert_info( char *buf, size_t size, const char *prefix,
2457  const x509_cert *crt )
2458 {
2459  int ret;
2460  size_t n;
2461  char *p;
2462 
2463  p = buf;
2464  n = size;
2465 
2466  ret = snprintf( p, n, "%scert. version : %d\n",
2467  prefix, crt->version );
2468  SAFE_SNPRINTF();
2469  ret = snprintf( p, n, "%sserial number : ",
2470  prefix );
2471  SAFE_SNPRINTF();
2472 
2473  ret = x509parse_serial_gets( p, n, &crt->serial);
2474  SAFE_SNPRINTF();
2475 
2476  ret = snprintf( p, n, "\n%sissuer name : ", prefix );
2477  SAFE_SNPRINTF();
2478  ret = x509parse_dn_gets( p, n, &crt->issuer );
2479  SAFE_SNPRINTF();
2480 
2481  ret = snprintf( p, n, "\n%ssubject name : ", prefix );
2482  SAFE_SNPRINTF();
2483  ret = x509parse_dn_gets( p, n, &crt->subject );
2484  SAFE_SNPRINTF();
2485 
2486  ret = snprintf( p, n, "\n%sissued on : " \
2487  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2488  crt->valid_from.year, crt->valid_from.mon,
2489  crt->valid_from.day, crt->valid_from.hour,
2490  crt->valid_from.min, crt->valid_from.sec );
2491  SAFE_SNPRINTF();
2492 
2493  ret = snprintf( p, n, "\n%sexpires on : " \
2494  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2495  crt->valid_to.year, crt->valid_to.mon,
2496  crt->valid_to.day, crt->valid_to.hour,
2497  crt->valid_to.min, crt->valid_to.sec );
2498  SAFE_SNPRINTF();
2499 
2500  ret = snprintf( p, n, "\n%ssigned using : RSA+", prefix );
2501  SAFE_SNPRINTF();
2502 
2503  switch( crt->sig_alg )
2504  {
2505  case SIG_RSA_MD2 : ret = snprintf( p, n, "MD2" ); break;
2506  case SIG_RSA_MD4 : ret = snprintf( p, n, "MD4" ); break;
2507  case SIG_RSA_MD5 : ret = snprintf( p, n, "MD5" ); break;
2508  case SIG_RSA_SHA1 : ret = snprintf( p, n, "SHA1" ); break;
2509  case SIG_RSA_SHA224 : ret = snprintf( p, n, "SHA224" ); break;
2510  case SIG_RSA_SHA256 : ret = snprintf( p, n, "SHA256" ); break;
2511  case SIG_RSA_SHA384 : ret = snprintf( p, n, "SHA384" ); break;
2512  case SIG_RSA_SHA512 : ret = snprintf( p, n, "SHA512" ); break;
2513  default: ret = snprintf( p, n, "???" ); break;
2514  }
2515  SAFE_SNPRINTF();
2516 
2517  ret = snprintf( p, n, "\n%sRSA key size : %d bits\n", prefix,
2518  (int) crt->rsa.N.n * (int) sizeof( unsigned long ) * 8 );
2519  SAFE_SNPRINTF();
2520 
2521  return( (int) ( size - n ) );
2522 }
2523 
2524 /* Compare a given OID string with an OID x509_buf * */
2525 #define OID_CMP(oid_str, oid_buf) \
2526  ( ( OID_SIZE(oid_str) == (oid_buf)->len ) && \
2527  memcmp( (oid_str), (oid_buf)->p, (oid_buf)->len) == 0)
2528 
2529 /*
2530  * Return an informational string describing the given OID
2531  */
2532 const char *x509_oid_get_description( x509_buf *oid )
2533 {
2534  if ( oid == NULL )
2535  return ( NULL );
2536 
2537  else if( OID_CMP( OID_SERVER_AUTH, oid ) )
2538  return( STRING_SERVER_AUTH );
2539 
2540  else if( OID_CMP( OID_CLIENT_AUTH, oid ) )
2541  return( STRING_CLIENT_AUTH );
2542 
2543  else if( OID_CMP( OID_CODE_SIGNING, oid ) )
2544  return( STRING_CODE_SIGNING );
2545 
2546  else if( OID_CMP( OID_EMAIL_PROTECTION, oid ) )
2547  return( STRING_EMAIL_PROTECTION );
2548 
2549  else if( OID_CMP( OID_TIME_STAMPING, oid ) )
2550  return( STRING_TIME_STAMPING );
2551 
2552  else if( OID_CMP( OID_OCSP_SIGNING, oid ) )
2553  return( STRING_OCSP_SIGNING );
2554 
2555  return( NULL );
2556 }
2557 
2558 /* Return the x.y.z.... style numeric string for the given OID */
2559 int x509_oid_get_numeric_string( char *buf, size_t size, x509_buf *oid )
2560 {
2561  int ret;
2562  size_t i, n;
2563  unsigned int value;
2564  char *p;
2565 
2566  p = buf;
2567  n = size;
2568 
2569  /* First byte contains first two dots */
2570  if( oid->len > 0 )
2571  {
2572  ret = snprintf( p, n, "%d.%d", oid->p[0]/40, oid->p[0]%40 );
2573  SAFE_SNPRINTF();
2574  }
2575 
2576  /* TODO: value can overflow in value. */
2577  value = 0;
2578  for( i = 1; i < oid->len; i++ )
2579  {
2580  value <<= 7;
2581  value += oid->p[i] & 0x7F;
2582 
2583  if( !( oid->p[i] & 0x80 ) )
2584  {
2585  /* Last byte */
2586  ret = snprintf( p, n, ".%d", value );
2587  SAFE_SNPRINTF();
2588  value = 0;
2589  }
2590  }
2591 
2592  return( (int) ( size - n ) );
2593 }
2594 
2595 /*
2596  * Return an informational string about the CRL.
2597  */
2598 int x509parse_crl_info( char *buf, size_t size, const char *prefix,
2599  const x509_crl *crl )
2600 {
2601  int ret;
2602  size_t n;
2603  char *p;
2604  const x509_crl_entry *entry;
2605 
2606  p = buf;
2607  n = size;
2608 
2609  ret = snprintf( p, n, "%sCRL version : %d",
2610  prefix, crl->version );
2611  SAFE_SNPRINTF();
2612 
2613  ret = snprintf( p, n, "\n%sissuer name : ", prefix );
2614  SAFE_SNPRINTF();
2615  ret = x509parse_dn_gets( p, n, &crl->issuer );
2616  SAFE_SNPRINTF();
2617 
2618  ret = snprintf( p, n, "\n%sthis update : " \
2619  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2620  crl->this_update.year, crl->this_update.mon,
2621  crl->this_update.day, crl->this_update.hour,
2622  crl->this_update.min, crl->this_update.sec );
2623  SAFE_SNPRINTF();
2624 
2625  ret = snprintf( p, n, "\n%snext update : " \
2626  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2627  crl->next_update.year, crl->next_update.mon,
2628  crl->next_update.day, crl->next_update.hour,
2629  crl->next_update.min, crl->next_update.sec );
2630  SAFE_SNPRINTF();
2631 
2632  entry = &crl->entry;
2633 
2634  ret = snprintf( p, n, "\n%sRevoked certificates:",
2635  prefix );
2636  SAFE_SNPRINTF();
2637 
2638  while( entry != NULL && entry->raw.len != 0 )
2639  {
2640  ret = snprintf( p, n, "\n%sserial number: ",
2641  prefix );
2642  SAFE_SNPRINTF();
2643 
2644  ret = x509parse_serial_gets( p, n, &entry->serial);
2645  SAFE_SNPRINTF();
2646 
2647  ret = snprintf( p, n, " revocation date: " \
2648  "%04d-%02d-%02d %02d:%02d:%02d",
2649  entry->revocation_date.year, entry->revocation_date.mon,
2650  entry->revocation_date.day, entry->revocation_date.hour,
2651  entry->revocation_date.min, entry->revocation_date.sec );
2652  SAFE_SNPRINTF();
2653 
2654  entry = entry->next;
2655  }
2656 
2657  ret = snprintf( p, n, "\n%ssigned using : RSA+", prefix );
2658  SAFE_SNPRINTF();
2659 
2660  switch( crl->sig_alg )
2661  {
2662  case SIG_RSA_MD2 : ret = snprintf( p, n, "MD2" ); break;
2663  case SIG_RSA_MD4 : ret = snprintf( p, n, "MD4" ); break;
2664  case SIG_RSA_MD5 : ret = snprintf( p, n, "MD5" ); break;
2665  case SIG_RSA_SHA1 : ret = snprintf( p, n, "SHA1" ); break;
2666  case SIG_RSA_SHA224 : ret = snprintf( p, n, "SHA224" ); break;
2667  case SIG_RSA_SHA256 : ret = snprintf( p, n, "SHA256" ); break;
2668  case SIG_RSA_SHA384 : ret = snprintf( p, n, "SHA384" ); break;
2669  case SIG_RSA_SHA512 : ret = snprintf( p, n, "SHA512" ); break;
2670  default: ret = snprintf( p, n, "???" ); break;
2671  }
2672  SAFE_SNPRINTF();
2673 
2674  ret = snprintf( p, n, "\n" );
2675  SAFE_SNPRINTF();
2676 
2677  return( (int) ( size - n ) );
2678 }
2679 
2680 /*
2681  * Return 0 if the x509_time is still valid, or 1 otherwise.
2682  */
2683 int x509parse_time_expired( const x509_time *to )
2684 {
2685  int year, mon, day;
2686  int hour, min, sec;
2687 
2688 #if defined(_WIN32)
2689  SYSTEMTIME st;
2690 
2691  GetLocalTime(&st);
2692 
2693  year = st.wYear;
2694  mon = st.wMonth;
2695  day = st.wDay;
2696  hour = st.wHour;
2697  min = st.wMinute;
2698  sec = st.wSecond;
2699 #else
2700  struct tm *lt;
2701  time_t tt;
2702 
2703  tt = time( NULL );
2704  lt = localtime( &tt );
2705 
2706  year = lt->tm_year + 1900;
2707  mon = lt->tm_mon + 1;
2708  day = lt->tm_mday;
2709  hour = lt->tm_hour;
2710  min = lt->tm_min;
2711  sec = lt->tm_sec;
2712 #endif
2713 
2714  if( year > to->year )
2715  return( 1 );
2716 
2717  if( year == to->year &&
2718  mon > to->mon )
2719  return( 1 );
2720 
2721  if( year == to->year &&
2722  mon == to->mon &&
2723  day > to->day )
2724  return( 1 );
2725 
2726  if( year == to->year &&
2727  mon == to->mon &&
2728  day == to->day &&
2729  hour > to->hour )
2730  return( 1 );
2731 
2732  if( year == to->year &&
2733  mon == to->mon &&
2734  day == to->day &&
2735  hour == to->hour &&
2736  min > to->min )
2737  return( 1 );
2738 
2739  if( year == to->year &&
2740  mon == to->mon &&
2741  day == to->day &&
2742  hour == to->hour &&
2743  min == to->min &&
2744  sec > to->sec )
2745  return( 1 );
2746 
2747  return( 0 );
2748 }
2749 
2750 /*
2751  * Return 1 if the certificate is revoked, or 0 otherwise.
2752  */
2753 int x509parse_revoked( const x509_cert *crt, const x509_crl *crl )
2754 {
2755  const x509_crl_entry *cur = &crl->entry;
2756 
2757  while( cur != NULL && cur->serial.len != 0 )
2758  {
2759  if( crt->serial.len == cur->serial.len &&
2760  memcmp( crt->serial.p, cur->serial.p, crt->serial.len ) == 0 )
2761  {
2763  return( 1 );
2764  }
2765 
2766  cur = cur->next;
2767  }
2768 
2769  return( 0 );
2770 }
2771 
2772 /*
2773  * Wrapper for x509 hashes.
2774  *
2775  * \param out Buffer to receive the hash (Should be at least 64 bytes)
2776  */
2777 static void x509_hash( const unsigned char *in, size_t len, int alg,
2778  unsigned char *out )
2779 {
2780  switch( alg )
2781  {
2782 #if defined(POLARSSL_MD2_C)
2783  case SIG_RSA_MD2 : md2( in, len, out ); break;
2784 #endif
2785 #if defined(POLARSSL_MD4_C)
2786  case SIG_RSA_MD4 : md4( in, len, out ); break;
2787 #endif
2788 #if defined(POLARSSL_MD5_C)
2789  case SIG_RSA_MD5 : md5( in, len, out ); break;
2790 #endif
2791 #if defined(POLARSSL_SHA1_C)
2792  case SIG_RSA_SHA1 : sha1( in, len, out ); break;
2793 #endif
2794 #if defined(POLARSSL_SHA2_C)
2795  case SIG_RSA_SHA224 : sha2( in, len, out, 1 ); break;
2796  case SIG_RSA_SHA256 : sha2( in, len, out, 0 ); break;
2797 #endif
2798 #if defined(POLARSSL_SHA4_C)
2799  case SIG_RSA_SHA384 : sha4( in, len, out, 1 ); break;
2800  case SIG_RSA_SHA512 : sha4( in, len, out, 0 ); break;
2801 #endif
2802  default:
2803  memset( out, '\xFF', 64 );
2804  break;
2805  }
2806 }
2807 
2808 /*
2809  * Check that the given certificate is valid accoring to the CRL.
2810  */
2811 static int x509parse_verifycrl(x509_cert *crt, x509_cert *ca,
2812  x509_crl *crl_list)
2813 {
2814  int flags = 0;
2815  int hash_id;
2816  unsigned char hash[64];
2817 
2818  /*
2819  * TODO: What happens if no CRL is present?
2820  * Suggestion: Revocation state should be unknown if no CRL is present.
2821  * For backwards compatibility this is not yet implemented.
2822  */
2823 
2824  while( ca != NULL && crl_list != NULL && crl_list->version != 0 )
2825  {
2826  if( crl_list->issuer_raw.len != ca->subject_raw.len ||
2827  memcmp( crl_list->issuer_raw.p, ca->subject_raw.p,
2828  crl_list->issuer_raw.len ) != 0 )
2829  {
2830  crl_list = crl_list->next;
2831  continue;
2832  }
2833 
2834  /*
2835  * Check if CRL is correctly signed by the trusted CA
2836  */
2837  hash_id = crl_list->sig_alg;
2838 
2839  x509_hash( crl_list->tbs.p, crl_list->tbs.len, hash_id, hash );
2840 
2841  if( !rsa_pkcs1_verify( &ca->rsa, RSA_PUBLIC, hash_id,
2842  0, hash, crl_list->sig.p ) == 0 )
2843  {
2844  /*
2845  * CRL is not trusted
2846  */
2847  flags |= BADCRL_NOT_TRUSTED;
2848  break;
2849  }
2850 
2851  /*
2852  * Check for validity of CRL (Do not drop out)
2853  */
2854  if( x509parse_time_expired( &crl_list->next_update ) )
2855  flags |= BADCRL_EXPIRED;
2856 
2857  /*
2858  * Check if certificate is revoked
2859  */
2860  if( x509parse_revoked(crt, crl_list) )
2861  {
2862  flags |= BADCERT_REVOKED;
2863  break;
2864  }
2865 
2866  crl_list = crl_list->next;
2867  }
2868  return flags;
2869 }
2870 
2871 /*
2872  * Verify the certificate validity
2873  */
2874 int x509parse_verify( x509_cert *crt,
2875  x509_cert *trust_ca,
2876  x509_crl *ca_crl,
2877  const char *cn, int *flags,
2878  int (*f_vrfy)(void *, x509_cert *, int, int),
2879  void *p_vrfy )
2880 {
2881  size_t cn_len;
2882  int hash_id;
2883  int pathlen;
2884  x509_cert *parent;
2885  x509_name *name;
2886  unsigned char hash[64];
2887 
2888  *flags = 0;
2889 
2890  if( x509parse_time_expired( &crt->valid_to ) )
2891  *flags = BADCERT_EXPIRED;
2892 
2893  if( cn != NULL )
2894  {
2895  name = &crt->subject;
2896  cn_len = strlen( cn );
2897 
2898  while( name != NULL )
2899  {
2900  if( memcmp( name->oid.p, OID_CN, 3 ) == 0 &&
2901  memcmp( name->val.p, cn, cn_len ) == 0 &&
2902  name->val.len == cn_len )
2903  break;
2904 
2905  name = name->next;
2906  }
2907 
2908  if( name == NULL )
2909  *flags |= BADCERT_CN_MISMATCH;
2910  }
2911 
2912  /*
2913  * Iterate upwards in the given cert chain,
2914  * ignoring any upper cert with CA != TRUE.
2915  */
2916  parent = crt->next;
2917 
2918  pathlen = 1;
2919 
2920  while( parent != NULL && parent->version != 0 )
2921  {
2922  if( parent->ca_istrue == 0 ||
2923  crt->issuer_raw.len != parent->subject_raw.len ||
2924  memcmp( crt->issuer_raw.p, parent->subject_raw.p,
2925  crt->issuer_raw.len ) != 0 )
2926  {
2927  parent = parent->next;
2928  continue;
2929  }
2930 
2931  hash_id = crt->sig_alg;
2932 
2933  x509_hash( crt->tbs.p, crt->tbs.len, hash_id, hash );
2934 
2935  if( rsa_pkcs1_verify( &parent->rsa, RSA_PUBLIC, hash_id, 0, hash,
2936  crt->sig.p ) != 0 )
2937  *flags |= BADCERT_NOT_TRUSTED;
2938 
2939  /* Check trusted CA's CRL for the given crt */
2940  *flags |= x509parse_verifycrl(crt, parent, ca_crl);
2941 
2942  /* crt is verified to be a child of the parent cur, call verify callback */
2943  if( NULL != f_vrfy )
2944  {
2945  if( f_vrfy( p_vrfy, crt, pathlen - 1, ( *flags == 0 ) ) != 0 )
2947  else
2948  *flags = 0;
2949  }
2950  else if( *flags != 0 )
2952 
2953  pathlen++;
2954 
2955  crt = parent;
2956  parent = crt->next;
2957  }
2958 
2959  /*
2960  * Attempt to validate topmost cert with our CA chain.
2961  */
2962  *flags |= BADCERT_NOT_TRUSTED;
2963 
2964  while( trust_ca != NULL && trust_ca->version != 0 )
2965  {
2966  if( crt->issuer_raw.len != trust_ca->subject_raw.len ||
2967  memcmp( crt->issuer_raw.p, trust_ca->subject_raw.p,
2968  crt->issuer_raw.len ) != 0 )
2969  {
2970  trust_ca = trust_ca->next;
2971  continue;
2972  }
2973 
2974  if( trust_ca->max_pathlen > 0 &&
2975  trust_ca->max_pathlen < pathlen )
2976  break;
2977 
2978  hash_id = crt->sig_alg;
2979 
2980  x509_hash( crt->tbs.p, crt->tbs.len, hash_id, hash );
2981 
2982  if( rsa_pkcs1_verify( &trust_ca->rsa, RSA_PUBLIC, hash_id,
2983  0, hash, crt->sig.p ) == 0 )
2984  {
2985  /*
2986  * cert. is signed by a trusted CA
2987  */
2988  *flags &= ~BADCERT_NOT_TRUSTED;
2989  break;
2990  }
2991 
2992  trust_ca = trust_ca->next;
2993  }
2994 
2995  /* Check trusted CA's CRL for the given crt */
2996  *flags |= x509parse_verifycrl( crt, trust_ca, ca_crl );
2997 
2998  /* Verification succeeded, call callback on top cert */
2999  if( NULL != f_vrfy )
3000  {
3001  if( f_vrfy(p_vrfy, crt, pathlen-1, ( *flags == 0 ) ) != 0 )
3003  else
3004  *flags = 0;
3005  }
3006  else if( *flags != 0 )
3008 
3009  return( 0 );
3010 }
3011 
3012 /*
3013  * Unallocate all certificate data
3014  */
3015 void x509_free( x509_cert *crt )
3016 {
3017  x509_cert *cert_cur = crt;
3018  x509_cert *cert_prv;
3019  x509_name *name_cur;
3020  x509_name *name_prv;
3021  x509_sequence *seq_cur;
3022  x509_sequence *seq_prv;
3023 
3024  if( crt == NULL )
3025  return;
3026 
3027  do
3028  {
3029  rsa_free( &cert_cur->rsa );
3030 
3031  name_cur = cert_cur->issuer.next;
3032  while( name_cur != NULL )
3033  {
3034  name_prv = name_cur;
3035  name_cur = name_cur->next;
3036  memset( name_prv, 0, sizeof( x509_name ) );
3037  free( name_prv );
3038  }
3039 
3040  name_cur = cert_cur->subject.next;
3041  while( name_cur != NULL )
3042  {
3043  name_prv = name_cur;
3044  name_cur = name_cur->next;
3045  memset( name_prv, 0, sizeof( x509_name ) );
3046  free( name_prv );
3047  }
3048 
3049  seq_cur = cert_cur->ext_key_usage.next;
3050  while( seq_cur != NULL )
3051  {
3052  seq_prv = seq_cur;
3053  seq_cur = seq_cur->next;
3054  memset( seq_prv, 0, sizeof( x509_sequence ) );
3055  free( seq_prv );
3056  }
3057 
3058  if( cert_cur->raw.p != NULL )
3059  {
3060  memset( cert_cur->raw.p, 0, cert_cur->raw.len );
3061  free( cert_cur->raw.p );
3062  }
3063 
3064  cert_cur = cert_cur->next;
3065  }
3066  while( cert_cur != NULL );
3067 
3068  cert_cur = crt;
3069  do
3070  {
3071  cert_prv = cert_cur;
3072  cert_cur = cert_cur->next;
3073 
3074  memset( cert_prv, 0, sizeof( x509_cert ) );
3075  if( cert_prv != crt )
3076  free( cert_prv );
3077  }
3078  while( cert_cur != NULL );
3079 }
3080 
3081 /*
3082  * Unallocate all CRL data
3083  */
3084 void x509_crl_free( x509_crl *crl )
3085 {
3086  x509_crl *crl_cur = crl;
3087  x509_crl *crl_prv;
3088  x509_name *name_cur;
3089  x509_name *name_prv;
3090  x509_crl_entry *entry_cur;
3091  x509_crl_entry *entry_prv;
3092 
3093  if( crl == NULL )
3094  return;
3095 
3096  do
3097  {
3098  name_cur = crl_cur->issuer.next;
3099  while( name_cur != NULL )
3100  {
3101  name_prv = name_cur;
3102  name_cur = name_cur->next;
3103  memset( name_prv, 0, sizeof( x509_name ) );
3104  free( name_prv );
3105  }
3106 
3107  entry_cur = crl_cur->entry.next;
3108  while( entry_cur != NULL )
3109  {
3110  entry_prv = entry_cur;
3111  entry_cur = entry_cur->next;
3112  memset( entry_prv, 0, sizeof( x509_crl_entry ) );
3113  free( entry_prv );
3114  }
3115 
3116  if( crl_cur->raw.p != NULL )
3117  {
3118  memset( crl_cur->raw.p, 0, crl_cur->raw.len );
3119  free( crl_cur->raw.p );
3120  }
3121 
3122  crl_cur = crl_cur->next;
3123  }
3124  while( crl_cur != NULL );
3125 
3126  crl_cur = crl;
3127  do
3128  {
3129  crl_prv = crl_cur;
3130  crl_cur = crl_cur->next;
3131 
3132  memset( crl_prv, 0, sizeof( x509_crl ) );
3133  if( crl_prv != crl )
3134  free( crl_prv );
3135  }
3136  while( crl_cur != NULL );
3137 }
3138 
3139 #if defined(POLARSSL_SELF_TEST)
3140 
3141 #include "polarssl/certs.h"
3142 
3143 /*
3144  * Checkup routine
3145  */
3146 int x509_self_test( int verbose )
3147 {
3148 #if defined(POLARSSL_CERTS_C) && defined(POLARSSL_MD5_C)
3149  int ret;
3150  int flags;
3151  size_t i, j;
3152  x509_cert cacert;
3153  x509_cert clicert;
3154  rsa_context rsa;
3155 #if defined(POLARSSL_DHM_C)
3156  dhm_context dhm;
3157 #endif
3158 
3159  if( verbose != 0 )
3160  printf( " X.509 certificate load: " );
3161 
3162  memset( &clicert, 0, sizeof( x509_cert ) );
3163 
3164  ret = x509parse_crt( &clicert, (unsigned char *) test_cli_crt,
3165  strlen( test_cli_crt ) );
3166  if( ret != 0 )
3167  {
3168  if( verbose != 0 )
3169  printf( "failed\n" );
3170 
3171  return( ret );
3172  }
3173 
3174  memset( &cacert, 0, sizeof( x509_cert ) );
3175 
3176  ret = x509parse_crt( &cacert, (unsigned char *) test_ca_crt,
3177  strlen( test_ca_crt ) );
3178  if( ret != 0 )
3179  {
3180  if( verbose != 0 )
3181  printf( "failed\n" );
3182 
3183  return( ret );
3184  }
3185 
3186  if( verbose != 0 )
3187  printf( "passed\n X.509 private key load: " );
3188 
3189  i = strlen( test_ca_key );
3190  j = strlen( test_ca_pwd );
3191 
3192  rsa_init( &rsa, RSA_PKCS_V15, 0 );
3193 
3194  if( ( ret = x509parse_key( &rsa,
3195  (unsigned char *) test_ca_key, i,
3196  (unsigned char *) test_ca_pwd, j ) ) != 0 )
3197  {
3198  if( verbose != 0 )
3199  printf( "failed\n" );
3200 
3201  return( ret );
3202  }
3203 
3204  if( verbose != 0 )
3205  printf( "passed\n X.509 signature verify: ");
3206 
3207  ret = x509parse_verify( &clicert, &cacert, NULL, "PolarSSL Client 2", &flags, NULL, NULL );
3208  if( ret != 0 )
3209  {
3210  printf("%02x", flags);
3211  if( verbose != 0 )
3212  printf( "failed\n" );
3213 
3214  return( ret );
3215  }
3216 
3217 #if defined(POLARSSL_DHM_C)
3218  if( verbose != 0 )
3219  printf( "passed\n X.509 DHM parameter load: " );
3220 
3221  i = strlen( test_dhm_params );
3222  j = strlen( test_ca_pwd );
3223 
3224  if( ( ret = x509parse_dhm( &dhm, (unsigned char *) test_dhm_params, i ) ) != 0 )
3225  {
3226  if( verbose != 0 )
3227  printf( "failed\n" );
3228 
3229  return( ret );
3230  }
3231 
3232  if( verbose != 0 )
3233  printf( "passed\n\n" );
3234 #endif
3235 
3236  x509_free( &cacert );
3237  x509_free( &clicert );
3238  rsa_free( &rsa );
3239 #if defined(POLARSSL_DHM_C)
3240  dhm_free( &dhm );
3241 #endif
3242 
3243  return( 0 );
3244 #else
3245  ((void) verbose);
3247 #endif
3248 }
3249 
3250 #endif
3251 
3252 #endif