PolarSSL v1.2.8
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 certificate format for PKI.
27  *
28  * http://www.ietf.org/rfc/rfc3279.txt
29  * http://www.ietf.org/rfc/rfc3280.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 #if defined(POLARSSL_MD2_C)
46 #include "polarssl/md2.h"
47 #endif
48 #if defined(POLARSSL_MD4_C)
49 #include "polarssl/md4.h"
50 #endif
51 #if defined(POLARSSL_MD5_C)
52 #include "polarssl/md5.h"
53 #endif
54 #if defined(POLARSSL_SHA1_C)
55 #include "polarssl/sha1.h"
56 #endif
57 #if defined(POLARSSL_SHA2_C)
58 #include "polarssl/sha2.h"
59 #endif
60 #if defined(POLARSSL_SHA4_C)
61 #include "polarssl/sha4.h"
62 #endif
63 #include "polarssl/dhm.h"
64 #if defined(POLARSSL_PKCS5_C)
65 #include "polarssl/pkcs5.h"
66 #endif
67 #if defined(POLARSSL_PKCS12_C)
68 #include "polarssl/pkcs12.h"
69 #endif
70 
71 #include <string.h>
72 #include <stdlib.h>
73 #if defined(_WIN32)
74 #include <windows.h>
75 #else
76 #include <time.h>
77 #endif
78 
79 #if defined(POLARSSL_FS_IO)
80 #include <stdio.h>
81 #if !defined(_WIN32)
82 #include <sys/types.h>
83 #include <sys/stat.h>
84 #include <dirent.h>
85 #endif
86 #endif
87 
88 /* Compare a given OID string with an OID x509_buf * */
89 #define OID_CMP(oid_str, oid_buf) \
90  ( ( OID_SIZE(oid_str) == (oid_buf)->len ) && \
91  memcmp( (oid_str), (oid_buf)->p, (oid_buf)->len) == 0)
92 
93 /*
94  * Version ::= INTEGER { v1(0), v2(1), v3(2) }
95  */
96 static int x509_get_version( unsigned char **p,
97  const unsigned char *end,
98  int *ver )
99 {
100  int ret;
101  size_t len;
102 
103  if( ( ret = asn1_get_tag( p, end, &len,
104  ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ) != 0 )
105  {
106  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
107  {
108  *ver = 0;
109  return( 0 );
110  }
111 
112  return( ret );
113  }
114 
115  end = *p + len;
116 
117  if( ( ret = asn1_get_int( p, end, ver ) ) != 0 )
118  return( POLARSSL_ERR_X509_CERT_INVALID_VERSION + ret );
119 
120  if( *p != end )
121  return( POLARSSL_ERR_X509_CERT_INVALID_VERSION +
122  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
123 
124  return( 0 );
125 }
126 
127 /*
128  * Version ::= INTEGER { v1(0), v2(1) }
129  */
130 static int x509_crl_get_version( unsigned char **p,
131  const unsigned char *end,
132  int *ver )
133 {
134  int ret;
135 
136  if( ( ret = asn1_get_int( p, end, ver ) ) != 0 )
137  {
138  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
139  {
140  *ver = 0;
141  return( 0 );
142  }
143 
144  return( POLARSSL_ERR_X509_CERT_INVALID_VERSION + ret );
145  }
146 
147  return( 0 );
148 }
149 
150 /*
151  * CertificateSerialNumber ::= INTEGER
152  */
153 static int x509_get_serial( unsigned char **p,
154  const unsigned char *end,
155  x509_buf *serial )
156 {
157  int ret;
158 
159  if( ( end - *p ) < 1 )
160  return( POLARSSL_ERR_X509_CERT_INVALID_SERIAL +
161  POLARSSL_ERR_ASN1_OUT_OF_DATA );
162 
163  if( **p != ( ASN1_CONTEXT_SPECIFIC | ASN1_PRIMITIVE | 2 ) &&
164  **p != ASN1_INTEGER )
165  return( POLARSSL_ERR_X509_CERT_INVALID_SERIAL +
166  POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
167 
168  serial->tag = *(*p)++;
169 
170  if( ( ret = asn1_get_len( p, end, &serial->len ) ) != 0 )
171  return( POLARSSL_ERR_X509_CERT_INVALID_SERIAL + ret );
172 
173  serial->p = *p;
174  *p += serial->len;
175 
176  return( 0 );
177 }
178 
179 /*
180  * AlgorithmIdentifier ::= SEQUENCE {
181  * algorithm OBJECT IDENTIFIER,
182  * parameters ANY DEFINED BY algorithm OPTIONAL }
183  */
184 static int x509_get_alg( unsigned char **p,
185  const unsigned char *end,
186  x509_buf *alg )
187 {
188  int ret;
189  size_t len;
190 
191  if( ( ret = asn1_get_tag( p, end, &len,
192  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
193  return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret );
194 
195  end = *p + len;
196  alg->tag = **p;
197 
198  if( ( ret = asn1_get_tag( p, end, &alg->len, ASN1_OID ) ) != 0 )
199  return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret );
200 
201  alg->p = *p;
202  *p += alg->len;
203 
204  if( *p == end )
205  return( 0 );
206 
207  /*
208  * assume the algorithm parameters must be NULL
209  */
210  if( ( ret = asn1_get_tag( p, end, &len, ASN1_NULL ) ) != 0 )
211  return( POLARSSL_ERR_X509_CERT_INVALID_ALG + ret );
212 
213  if( *p != end )
214  return( POLARSSL_ERR_X509_CERT_INVALID_ALG +
215  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
216 
217  return( 0 );
218 }
219 
220 /*
221  * AttributeTypeAndValue ::= SEQUENCE {
222  * type AttributeType,
223  * value AttributeValue }
224  *
225  * AttributeType ::= OBJECT IDENTIFIER
226  *
227  * AttributeValue ::= ANY DEFINED BY AttributeType
228  */
229 static int x509_get_attr_type_value( unsigned char **p,
230  const unsigned char *end,
231  x509_name *cur )
232 {
233  int ret;
234  size_t len;
235  x509_buf *oid;
236  x509_buf *val;
237 
238  if( ( ret = asn1_get_tag( p, end, &len,
239  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
240  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
241 
242  oid = &cur->oid;
243  oid->tag = **p;
244 
245  if( ( ret = asn1_get_tag( p, end, &oid->len, ASN1_OID ) ) != 0 )
246  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
247 
248  oid->p = *p;
249  *p += oid->len;
250 
251  if( ( end - *p ) < 1 )
252  return( POLARSSL_ERR_X509_CERT_INVALID_NAME +
253  POLARSSL_ERR_ASN1_OUT_OF_DATA );
254 
255  if( **p != ASN1_BMP_STRING && **p != ASN1_UTF8_STRING &&
256  **p != ASN1_T61_STRING && **p != ASN1_PRINTABLE_STRING &&
257  **p != ASN1_IA5_STRING && **p != ASN1_UNIVERSAL_STRING )
258  return( POLARSSL_ERR_X509_CERT_INVALID_NAME +
259  POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
260 
261  val = &cur->val;
262  val->tag = *(*p)++;
263 
264  if( ( ret = asn1_get_len( p, end, &val->len ) ) != 0 )
265  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
266 
267  val->p = *p;
268  *p += val->len;
269 
270  cur->next = NULL;
271 
272  return( 0 );
273 }
274 
275 /*
276  * RelativeDistinguishedName ::=
277  * SET OF AttributeTypeAndValue
278  *
279  * AttributeTypeAndValue ::= SEQUENCE {
280  * type AttributeType,
281  * value AttributeValue }
282  *
283  * AttributeType ::= OBJECT IDENTIFIER
284  *
285  * AttributeValue ::= ANY DEFINED BY AttributeType
286  */
287 static int x509_get_name( unsigned char **p,
288  const unsigned char *end,
289  x509_name *cur )
290 {
291  int ret;
292  size_t len;
293  const unsigned char *end2;
294  x509_name *use;
295 
296  if( ( ret = asn1_get_tag( p, end, &len,
297  ASN1_CONSTRUCTED | ASN1_SET ) ) != 0 )
298  return( POLARSSL_ERR_X509_CERT_INVALID_NAME + ret );
299 
300  end2 = end;
301  end = *p + len;
302  use = cur;
303 
304  do
305  {
306  if( ( ret = x509_get_attr_type_value( p, end, use ) ) != 0 )
307  return( ret );
308 
309  if( *p != end )
310  {
311  use->next = (x509_name *) malloc(
312  sizeof( x509_name ) );
313 
314  if( use->next == NULL )
315  return( POLARSSL_ERR_X509_MALLOC_FAILED );
316 
317  memset( use->next, 0, sizeof( x509_name ) );
318 
319  use = use->next;
320  }
321  }
322  while( *p != end );
323 
324  /*
325  * recurse until end of SEQUENCE is reached
326  */
327  if( *p == end2 )
328  return( 0 );
329 
330  cur->next = (x509_name *) malloc(
331  sizeof( x509_name ) );
332 
333  if( cur->next == NULL )
334  return( POLARSSL_ERR_X509_MALLOC_FAILED );
335 
336  memset( cur->next, 0, sizeof( x509_name ) );
337 
338  return( x509_get_name( p, end2, cur->next ) );
339 }
340 
341 /*
342  * Time ::= CHOICE {
343  * utcTime UTCTime,
344  * generalTime GeneralizedTime }
345  */
346 static int x509_get_time( unsigned char **p,
347  const unsigned char *end,
348  x509_time *time )
349 {
350  int ret;
351  size_t len;
352  char date[64];
353  unsigned char tag;
354 
355  if( ( end - *p ) < 1 )
356  return( POLARSSL_ERR_X509_CERT_INVALID_DATE +
357  POLARSSL_ERR_ASN1_OUT_OF_DATA );
358 
359  tag = **p;
360 
361  if ( tag == ASN1_UTC_TIME )
362  {
363  (*p)++;
364  ret = asn1_get_len( p, end, &len );
365 
366  if( ret != 0 )
367  return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret );
368 
369  memset( date, 0, sizeof( date ) );
370  memcpy( date, *p, ( len < sizeof( date ) - 1 ) ?
371  len : sizeof( date ) - 1 );
372 
373  if( sscanf( date, "%2d%2d%2d%2d%2d%2d",
374  &time->year, &time->mon, &time->day,
375  &time->hour, &time->min, &time->sec ) < 5 )
376  return( POLARSSL_ERR_X509_CERT_INVALID_DATE );
377 
378  time->year += 100 * ( time->year < 50 );
379  time->year += 1900;
380 
381  *p += len;
382 
383  return( 0 );
384  }
385  else if ( tag == ASN1_GENERALIZED_TIME )
386  {
387  (*p)++;
388  ret = asn1_get_len( p, end, &len );
389 
390  if( ret != 0 )
391  return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret );
392 
393  memset( date, 0, sizeof( date ) );
394  memcpy( date, *p, ( len < sizeof( date ) - 1 ) ?
395  len : sizeof( date ) - 1 );
396 
397  if( sscanf( date, "%4d%2d%2d%2d%2d%2d",
398  &time->year, &time->mon, &time->day,
399  &time->hour, &time->min, &time->sec ) < 5 )
400  return( POLARSSL_ERR_X509_CERT_INVALID_DATE );
401 
402  *p += len;
403 
404  return( 0 );
405  }
406  else
407  return( POLARSSL_ERR_X509_CERT_INVALID_DATE + POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
408 }
409 
410 
411 /*
412  * Validity ::= SEQUENCE {
413  * notBefore Time,
414  * notAfter Time }
415  */
416 static int x509_get_dates( unsigned char **p,
417  const unsigned char *end,
418  x509_time *from,
419  x509_time *to )
420 {
421  int ret;
422  size_t len;
423 
424  if( ( ret = asn1_get_tag( p, end, &len,
425  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
426  return( POLARSSL_ERR_X509_CERT_INVALID_DATE + ret );
427 
428  end = *p + len;
429 
430  if( ( ret = x509_get_time( p, end, from ) ) != 0 )
431  return( ret );
432 
433  if( ( ret = x509_get_time( p, end, to ) ) != 0 )
434  return( ret );
435 
436  if( *p != end )
437  return( POLARSSL_ERR_X509_CERT_INVALID_DATE +
438  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
439 
440  return( 0 );
441 }
442 
443 /*
444  * SubjectPublicKeyInfo ::= SEQUENCE {
445  * algorithm AlgorithmIdentifier,
446  * subjectPublicKey BIT STRING }
447  */
448 static int x509_get_pubkey( unsigned char **p,
449  const unsigned char *end,
450  x509_buf *pk_alg_oid,
451  mpi *N, mpi *E )
452 {
453  int ret;
454  size_t len;
455  unsigned char *end2;
456 
457  if( ( ret = x509_get_alg( p, end, pk_alg_oid ) ) != 0 )
458  return( ret );
459 
460  /*
461  * only RSA public keys handled at this time
462  */
463  if( pk_alg_oid->len != 9 ||
464  memcmp( pk_alg_oid->p, OID_PKCS1_RSA, 9 ) != 0 )
465  {
466  return( POLARSSL_ERR_X509_UNKNOWN_PK_ALG );
467  }
468 
469  if( ( ret = asn1_get_tag( p, end, &len, ASN1_BIT_STRING ) ) != 0 )
470  return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + ret );
471 
472  if( ( end - *p ) < 1 )
473  return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY +
474  POLARSSL_ERR_ASN1_OUT_OF_DATA );
475 
476  end2 = *p + len;
477 
478  if( *(*p)++ != 0 )
479  return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY );
480 
481  /*
482  * RSAPublicKey ::= SEQUENCE {
483  * modulus INTEGER, -- n
484  * publicExponent INTEGER -- e
485  * }
486  */
487  if( ( ret = asn1_get_tag( p, end2, &len,
488  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
489  return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + ret );
490 
491  if( *p + len != end2 )
492  return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY +
493  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
494 
495  if( ( ret = asn1_get_mpi( p, end2, N ) ) != 0 ||
496  ( ret = asn1_get_mpi( p, end2, E ) ) != 0 )
497  return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY + ret );
498 
499  if( *p != end )
500  return( POLARSSL_ERR_X509_CERT_INVALID_PUBKEY +
501  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
502 
503  return( 0 );
504 }
505 
506 static int x509_get_sig( unsigned char **p,
507  const unsigned char *end,
508  x509_buf *sig )
509 {
510  int ret;
511  size_t len;
512 
513  if( ( end - *p ) < 1 )
514  return( POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE +
515  POLARSSL_ERR_ASN1_OUT_OF_DATA );
516 
517  sig->tag = **p;
518 
519  if( ( ret = asn1_get_tag( p, end, &len, ASN1_BIT_STRING ) ) != 0 )
520  return( POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE + ret );
521 
522 
523  if( --len < 1 || *(*p)++ != 0 )
524  return( POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE );
525 
526  sig->len = len;
527  sig->p = *p;
528 
529  *p += len;
530 
531  return( 0 );
532 }
533 
534 /*
535  * X.509 v2/v3 unique identifier (not parsed)
536  */
537 static int x509_get_uid( unsigned char **p,
538  const unsigned char *end,
539  x509_buf *uid, int n )
540 {
541  int ret;
542 
543  if( *p == end )
544  return( 0 );
545 
546  uid->tag = **p;
547 
548  if( ( ret = asn1_get_tag( p, end, &uid->len,
549  ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | n ) ) != 0 )
550  {
551  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
552  return( 0 );
553 
554  return( ret );
555  }
556 
557  uid->p = *p;
558  *p += uid->len;
559 
560  return( 0 );
561 }
562 
563 /*
564  * X.509 Extensions (No parsing of extensions, pointer should
565  * be either manually updated or extensions should be parsed!
566  */
567 static int x509_get_ext( unsigned char **p,
568  const unsigned char *end,
569  x509_buf *ext, int tag )
570 {
571  int ret;
572  size_t len;
573 
574  if( *p == end )
575  return( 0 );
576 
577  ext->tag = **p;
578 
579  if( ( ret = asn1_get_tag( p, end, &ext->len,
580  ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | tag ) ) != 0 )
581  return( ret );
582 
583  ext->p = *p;
584  end = *p + ext->len;
585 
586  /*
587  * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
588  *
589  * Extension ::= SEQUENCE {
590  * extnID OBJECT IDENTIFIER,
591  * critical BOOLEAN DEFAULT FALSE,
592  * extnValue OCTET STRING }
593  */
594  if( ( ret = asn1_get_tag( p, end, &len,
595  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
596  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
597 
598  if( end != *p + len )
599  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
600  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
601 
602  return( 0 );
603 }
604 
605 /*
606  * X.509 CRL v2 extensions (no extensions parsed yet.)
607  */
608 static int x509_get_crl_ext( unsigned char **p,
609  const unsigned char *end,
610  x509_buf *ext )
611 {
612  int ret;
613  size_t len = 0;
614 
615  /* Get explicit tag */
616  if( ( ret = x509_get_ext( p, end, ext, 0) ) != 0 )
617  {
618  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
619  return( 0 );
620 
621  return( ret );
622  }
623 
624  while( *p < end )
625  {
626  if( ( ret = asn1_get_tag( p, end, &len,
627  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
628  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
629 
630  *p += len;
631  }
632 
633  if( *p != end )
634  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
635  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
636 
637  return( 0 );
638 }
639 
640 /*
641  * X.509 CRL v2 entry extensions (no extensions parsed yet.)
642  */
643 static int x509_get_crl_entry_ext( unsigned char **p,
644  const unsigned char *end,
645  x509_buf *ext )
646 {
647  int ret;
648  size_t len = 0;
649 
650  /* OPTIONAL */
651  if (end <= *p)
652  return( 0 );
653 
654  ext->tag = **p;
655  ext->p = *p;
656 
657  /*
658  * Get CRL-entry extension sequence header
659  * crlEntryExtensions Extensions OPTIONAL -- if present, MUST be v2
660  */
661  if( ( ret = asn1_get_tag( p, end, &ext->len,
662  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
663  {
664  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
665  {
666  ext->p = NULL;
667  return( 0 );
668  }
669  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
670  }
671 
672  end = *p + ext->len;
673 
674  if( end != *p + ext->len )
675  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
676  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
677 
678  while( *p < end )
679  {
680  if( ( ret = asn1_get_tag( p, end, &len,
681  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
682  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
683 
684  *p += len;
685  }
686 
687  if( *p != end )
688  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
689  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
690 
691  return( 0 );
692 }
693 
694 static int x509_get_basic_constraints( unsigned char **p,
695  const unsigned char *end,
696  int *ca_istrue,
697  int *max_pathlen )
698 {
699  int ret;
700  size_t len;
701 
702  /*
703  * BasicConstraints ::= SEQUENCE {
704  * cA BOOLEAN DEFAULT FALSE,
705  * pathLenConstraint INTEGER (0..MAX) OPTIONAL }
706  */
707  *ca_istrue = 0; /* DEFAULT FALSE */
708  *max_pathlen = 0; /* endless */
709 
710  if( ( ret = asn1_get_tag( p, end, &len,
711  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
712  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
713 
714  if( *p == end )
715  return 0;
716 
717  if( ( ret = asn1_get_bool( p, end, ca_istrue ) ) != 0 )
718  {
719  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
720  ret = asn1_get_int( p, end, ca_istrue );
721 
722  if( ret != 0 )
723  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
724 
725  if( *ca_istrue != 0 )
726  *ca_istrue = 1;
727  }
728 
729  if( *p == end )
730  return 0;
731 
732  if( ( ret = asn1_get_int( p, end, max_pathlen ) ) != 0 )
733  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
734 
735  if( *p != end )
736  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
737  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
738 
739  (*max_pathlen)++;
740 
741  return 0;
742 }
743 
744 static int x509_get_ns_cert_type( unsigned char **p,
745  const unsigned char *end,
746  unsigned char *ns_cert_type)
747 {
748  int ret;
749  x509_bitstring bs = { 0, 0, NULL };
750 
751  if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 )
752  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
753 
754  if( bs.len != 1 )
755  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
756  POLARSSL_ERR_ASN1_INVALID_LENGTH );
757 
758  /* Get actual bitstring */
759  *ns_cert_type = *bs.p;
760  return 0;
761 }
762 
763 static int x509_get_key_usage( unsigned char **p,
764  const unsigned char *end,
765  unsigned char *key_usage)
766 {
767  int ret;
768  x509_bitstring bs = { 0, 0, NULL };
769 
770  if( ( ret = asn1_get_bitstring( p, end, &bs ) ) != 0 )
771  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
772 
773  if( bs.len < 1 )
774  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
775  POLARSSL_ERR_ASN1_INVALID_LENGTH );
776 
777  /* Get actual bitstring */
778  *key_usage = *bs.p;
779  return 0;
780 }
781 
782 /*
783  * ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
784  *
785  * KeyPurposeId ::= OBJECT IDENTIFIER
786  */
787 static int x509_get_ext_key_usage( unsigned char **p,
788  const unsigned char *end,
789  x509_sequence *ext_key_usage)
790 {
791  int ret;
792 
793  if( ( ret = asn1_get_sequence_of( p, end, ext_key_usage, ASN1_OID ) ) != 0 )
794  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
795 
796  /* Sequence length must be >= 1 */
797  if( ext_key_usage->buf.p == NULL )
798  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
799  POLARSSL_ERR_ASN1_INVALID_LENGTH );
800 
801  return 0;
802 }
803 
804 /*
805  * SubjectAltName ::= GeneralNames
806  *
807  * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
808  *
809  * GeneralName ::= CHOICE {
810  * otherName [0] OtherName,
811  * rfc822Name [1] IA5String,
812  * dNSName [2] IA5String,
813  * x400Address [3] ORAddress,
814  * directoryName [4] Name,
815  * ediPartyName [5] EDIPartyName,
816  * uniformResourceIdentifier [6] IA5String,
817  * iPAddress [7] OCTET STRING,
818  * registeredID [8] OBJECT IDENTIFIER }
819  *
820  * OtherName ::= SEQUENCE {
821  * type-id OBJECT IDENTIFIER,
822  * value [0] EXPLICIT ANY DEFINED BY type-id }
823  *
824  * EDIPartyName ::= SEQUENCE {
825  * nameAssigner [0] DirectoryString OPTIONAL,
826  * partyName [1] DirectoryString }
827  *
828  * NOTE: PolarSSL only parses and uses dNSName at this point.
829  */
830 static int x509_get_subject_alt_name( unsigned char **p,
831  const unsigned char *end,
832  x509_sequence *subject_alt_name )
833 {
834  int ret;
835  size_t len, tag_len;
836  asn1_buf *buf;
837  unsigned char tag;
838  asn1_sequence *cur = subject_alt_name;
839 
840  /* Get main sequence tag */
841  if( ( ret = asn1_get_tag( p, end, &len,
842  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
843  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
844 
845  if( *p + len != end )
846  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
847  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
848 
849  while( *p < end )
850  {
851  if( ( end - *p ) < 1 )
852  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
853  POLARSSL_ERR_ASN1_OUT_OF_DATA );
854 
855  tag = **p;
856  (*p)++;
857  if( ( ret = asn1_get_len( p, end, &tag_len ) ) != 0 )
858  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
859 
860  if( ( tag & ASN1_CONTEXT_SPECIFIC ) != ASN1_CONTEXT_SPECIFIC )
861  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
862  POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
863 
864  if( tag != ( ASN1_CONTEXT_SPECIFIC | 2 ) )
865  {
866  *p += tag_len;
867  continue;
868  }
869 
870  buf = &(cur->buf);
871  buf->tag = tag;
872  buf->p = *p;
873  buf->len = tag_len;
874  *p += buf->len;
875 
876  /* Allocate and assign next pointer */
877  if (*p < end)
878  {
879  cur->next = (asn1_sequence *) malloc(
880  sizeof( asn1_sequence ) );
881 
882  if( cur->next == NULL )
883  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
884  POLARSSL_ERR_ASN1_MALLOC_FAILED );
885 
886  memset( cur->next, 0, sizeof( asn1_sequence ) );
887  cur = cur->next;
888  }
889  }
890 
891  /* Set final sequence entry's next pointer to NULL */
892  cur->next = NULL;
893 
894  if( *p != end )
895  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
896  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
897 
898  return( 0 );
899 }
900 
901 /*
902  * X.509 v3 extensions
903  *
904  * TODO: Perform all of the basic constraints tests required by the RFC
905  * TODO: Set values for undetected extensions to a sane default?
906  *
907  */
908 static int x509_get_crt_ext( unsigned char **p,
909  const unsigned char *end,
910  x509_cert *crt )
911 {
912  int ret;
913  size_t len;
914  unsigned char *end_ext_data, *end_ext_octet;
915 
916  if( ( ret = x509_get_ext( p, end, &crt->v3_ext, 3 ) ) != 0 )
917  {
918  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
919  return( 0 );
920 
921  return( ret );
922  }
923 
924  while( *p < end )
925  {
926  /*
927  * Extension ::= SEQUENCE {
928  * extnID OBJECT IDENTIFIER,
929  * critical BOOLEAN DEFAULT FALSE,
930  * extnValue OCTET STRING }
931  */
932  x509_buf extn_oid = {0, 0, NULL};
933  int is_critical = 0; /* DEFAULT FALSE */
934 
935  if( ( ret = asn1_get_tag( p, end, &len,
936  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
937  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
938 
939  end_ext_data = *p + len;
940 
941  /* Get extension ID */
942  extn_oid.tag = **p;
943 
944  if( ( ret = asn1_get_tag( p, end, &extn_oid.len, ASN1_OID ) ) != 0 )
945  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
946 
947  extn_oid.p = *p;
948  *p += extn_oid.len;
949 
950  if( ( end - *p ) < 1 )
951  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
952  POLARSSL_ERR_ASN1_OUT_OF_DATA );
953 
954  /* Get optional critical */
955  if( ( ret = asn1_get_bool( p, end_ext_data, &is_critical ) ) != 0 &&
956  ( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) )
957  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
958 
959  /* Data should be octet string type */
960  if( ( ret = asn1_get_tag( p, end_ext_data, &len,
961  ASN1_OCTET_STRING ) ) != 0 )
962  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS + ret );
963 
964  end_ext_octet = *p + len;
965 
966  if( end_ext_octet != end_ext_data )
967  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
968  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
969 
970  /*
971  * Detect supported extensions
972  */
973  if( ( OID_SIZE( OID_BASIC_CONSTRAINTS ) == extn_oid.len ) &&
974  memcmp( extn_oid.p, OID_BASIC_CONSTRAINTS, extn_oid.len ) == 0 )
975  {
976  /* Parse basic constraints */
977  if( ( ret = x509_get_basic_constraints( p, end_ext_octet,
978  &crt->ca_istrue, &crt->max_pathlen ) ) != 0 )
979  return ( ret );
980  crt->ext_types |= EXT_BASIC_CONSTRAINTS;
981  }
982  else if( ( OID_SIZE( OID_NS_CERT_TYPE ) == extn_oid.len ) &&
983  memcmp( extn_oid.p, OID_NS_CERT_TYPE, extn_oid.len ) == 0 )
984  {
985  /* Parse netscape certificate type */
986  if( ( ret = x509_get_ns_cert_type( p, end_ext_octet,
987  &crt->ns_cert_type ) ) != 0 )
988  return ( ret );
989  crt->ext_types |= EXT_NS_CERT_TYPE;
990  }
991  else if( ( OID_SIZE( OID_KEY_USAGE ) == extn_oid.len ) &&
992  memcmp( extn_oid.p, OID_KEY_USAGE, extn_oid.len ) == 0 )
993  {
994  /* Parse key usage */
995  if( ( ret = x509_get_key_usage( p, end_ext_octet,
996  &crt->key_usage ) ) != 0 )
997  return ( ret );
998  crt->ext_types |= EXT_KEY_USAGE;
999  }
1000  else if( ( OID_SIZE( OID_EXTENDED_KEY_USAGE ) == extn_oid.len ) &&
1001  memcmp( extn_oid.p, OID_EXTENDED_KEY_USAGE, extn_oid.len ) == 0 )
1002  {
1003  /* Parse extended key usage */
1004  if( ( ret = x509_get_ext_key_usage( p, end_ext_octet,
1005  &crt->ext_key_usage ) ) != 0 )
1006  return ( ret );
1007  crt->ext_types |= EXT_EXTENDED_KEY_USAGE;
1008  }
1009  else if( ( OID_SIZE( OID_SUBJECT_ALT_NAME ) == extn_oid.len ) &&
1010  memcmp( extn_oid.p, OID_SUBJECT_ALT_NAME, extn_oid.len ) == 0 )
1011  {
1012  /* Parse extended key usage */
1013  if( ( ret = x509_get_subject_alt_name( p, end_ext_octet,
1014  &crt->subject_alt_names ) ) != 0 )
1015  return ( ret );
1016  crt->ext_types |= EXT_SUBJECT_ALT_NAME;
1017  }
1018  else
1019  {
1020  /* No parser found, skip extension */
1021  *p = end_ext_octet;
1022 
1023 #if !defined(POLARSSL_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
1024  if( is_critical )
1025  {
1026  /* Data is marked as critical: fail */
1027  return ( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
1028  POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
1029  }
1030 #endif
1031  }
1032  }
1033 
1034  if( *p != end )
1035  return( POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS +
1036  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
1037 
1038  return( 0 );
1039 }
1040 
1041 /*
1042  * X.509 CRL Entries
1043  */
1044 static int x509_get_entries( unsigned char **p,
1045  const unsigned char *end,
1046  x509_crl_entry *entry )
1047 {
1048  int ret;
1049  size_t entry_len;
1050  x509_crl_entry *cur_entry = entry;
1051 
1052  if( *p == end )
1053  return( 0 );
1054 
1055  if( ( ret = asn1_get_tag( p, end, &entry_len,
1056  ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 )
1057  {
1058  if( ret == POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
1059  return( 0 );
1060 
1061  return( ret );
1062  }
1063 
1064  end = *p + entry_len;
1065 
1066  while( *p < end )
1067  {
1068  size_t len2;
1069  const unsigned char *end2;
1070 
1071  if( ( ret = asn1_get_tag( p, end, &len2,
1072  ASN1_SEQUENCE | ASN1_CONSTRUCTED ) ) != 0 )
1073  {
1074  return( ret );
1075  }
1076 
1077  cur_entry->raw.tag = **p;
1078  cur_entry->raw.p = *p;
1079  cur_entry->raw.len = len2;
1080  end2 = *p + len2;
1081 
1082  if( ( ret = x509_get_serial( p, end2, &cur_entry->serial ) ) != 0 )
1083  return( ret );
1084 
1085  if( ( ret = x509_get_time( p, end2, &cur_entry->revocation_date ) ) != 0 )
1086  return( ret );
1087 
1088  if( ( ret = x509_get_crl_entry_ext( p, end2, &cur_entry->entry_ext ) ) != 0 )
1089  return( ret );
1090 
1091  if ( *p < end )
1092  {
1093  cur_entry->next = malloc( sizeof( x509_crl_entry ) );
1094 
1095  if( cur_entry->next == NULL )
1096  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1097 
1098  cur_entry = cur_entry->next;
1099  memset( cur_entry, 0, sizeof( x509_crl_entry ) );
1100  }
1101  }
1102 
1103  return( 0 );
1104 }
1105 
1106 static int x509_get_sig_alg( const x509_buf *sig_oid, int *sig_alg )
1107 {
1108  if( sig_oid->len == 9 &&
1109  memcmp( sig_oid->p, OID_PKCS1, 8 ) == 0 )
1110  {
1111  if( sig_oid->p[8] >= 2 && sig_oid->p[8] <= 5 )
1112  {
1113  *sig_alg = sig_oid->p[8];
1114  return( 0 );
1115  }
1116 
1117  if ( sig_oid->p[8] >= 11 && sig_oid->p[8] <= 14 )
1118  {
1119  *sig_alg = sig_oid->p[8];
1120  return( 0 );
1121  }
1122 
1123  return( POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG );
1124  }
1125  if( sig_oid->len == 5 &&
1126  memcmp( sig_oid->p, OID_RSA_SHA_OBS, 5 ) == 0 )
1127  {
1128  *sig_alg = SIG_RSA_SHA1;
1129  return( 0 );
1130  }
1131 
1132  return( POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG );
1133 }
1134 
1135 /*
1136  * Parse and fill a single X.509 certificate in DER format
1137  */
1138 int x509parse_crt_der_core( x509_cert *crt, const unsigned char *buf,
1139  size_t buflen )
1140 {
1141  int ret;
1142  size_t len;
1143  unsigned char *p, *end, *crt_end;
1144 
1145  /*
1146  * Check for valid input
1147  */
1148  if( crt == NULL || buf == NULL )
1149  return( POLARSSL_ERR_X509_INVALID_INPUT );
1150 
1151  p = (unsigned char *) malloc( len = buflen );
1152 
1153  if( p == NULL )
1154  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1155 
1156  memcpy( p, buf, buflen );
1157 
1158  buflen = 0;
1159 
1160  crt->raw.p = p;
1161  crt->raw.len = len;
1162  end = p + len;
1163 
1164  /*
1165  * Certificate ::= SEQUENCE {
1166  * tbsCertificate TBSCertificate,
1167  * signatureAlgorithm AlgorithmIdentifier,
1168  * signatureValue BIT STRING }
1169  */
1170  if( ( ret = asn1_get_tag( &p, end, &len,
1171  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1172  {
1173  x509_free( crt );
1174  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT );
1175  }
1176 
1177  if( len > (size_t) ( end - p ) )
1178  {
1179  x509_free( crt );
1180  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT +
1181  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
1182  }
1183  crt_end = p + len;
1184 
1185  /*
1186  * TBSCertificate ::= SEQUENCE {
1187  */
1188  crt->tbs.p = p;
1189 
1190  if( ( ret = asn1_get_tag( &p, end, &len,
1191  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1192  {
1193  x509_free( crt );
1194  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1195  }
1196 
1197  end = p + len;
1198  crt->tbs.len = end - crt->tbs.p;
1199 
1200  /*
1201  * Version ::= INTEGER { v1(0), v2(1), v3(2) }
1202  *
1203  * CertificateSerialNumber ::= INTEGER
1204  *
1205  * signature AlgorithmIdentifier
1206  */
1207  if( ( ret = x509_get_version( &p, end, &crt->version ) ) != 0 ||
1208  ( ret = x509_get_serial( &p, end, &crt->serial ) ) != 0 ||
1209  ( ret = x509_get_alg( &p, end, &crt->sig_oid1 ) ) != 0 )
1210  {
1211  x509_free( crt );
1212  return( ret );
1213  }
1214 
1215  crt->version++;
1216 
1217  if( crt->version > 3 )
1218  {
1219  x509_free( crt );
1220  return( POLARSSL_ERR_X509_CERT_UNKNOWN_VERSION );
1221  }
1222 
1223  if( ( ret = x509_get_sig_alg( &crt->sig_oid1, &crt->sig_alg ) ) != 0 )
1224  {
1225  x509_free( crt );
1226  return( ret );
1227  }
1228 
1229  /*
1230  * issuer Name
1231  */
1232  crt->issuer_raw.p = p;
1233 
1234  if( ( ret = asn1_get_tag( &p, end, &len,
1235  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1236  {
1237  x509_free( crt );
1238  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1239  }
1240 
1241  if( ( ret = x509_get_name( &p, p + len, &crt->issuer ) ) != 0 )
1242  {
1243  x509_free( crt );
1244  return( ret );
1245  }
1246 
1247  crt->issuer_raw.len = p - crt->issuer_raw.p;
1248 
1249  /*
1250  * Validity ::= SEQUENCE {
1251  * notBefore Time,
1252  * notAfter Time }
1253  *
1254  */
1255  if( ( ret = x509_get_dates( &p, end, &crt->valid_from,
1256  &crt->valid_to ) ) != 0 )
1257  {
1258  x509_free( crt );
1259  return( ret );
1260  }
1261 
1262  /*
1263  * subject Name
1264  */
1265  crt->subject_raw.p = p;
1266 
1267  if( ( ret = asn1_get_tag( &p, end, &len,
1268  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1269  {
1270  x509_free( crt );
1271  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1272  }
1273 
1274  if( len && ( ret = x509_get_name( &p, p + len, &crt->subject ) ) != 0 )
1275  {
1276  x509_free( crt );
1277  return( ret );
1278  }
1279 
1280  crt->subject_raw.len = p - crt->subject_raw.p;
1281 
1282  /*
1283  * SubjectPublicKeyInfo ::= SEQUENCE
1284  * algorithm AlgorithmIdentifier,
1285  * subjectPublicKey BIT STRING }
1286  */
1287  if( ( ret = asn1_get_tag( &p, end, &len,
1288  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1289  {
1290  x509_free( crt );
1291  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1292  }
1293 
1294  if( ( ret = x509_get_pubkey( &p, p + len, &crt->pk_oid,
1295  &crt->rsa.N, &crt->rsa.E ) ) != 0 )
1296  {
1297  x509_free( crt );
1298  return( ret );
1299  }
1300 
1301  if( ( ret = rsa_check_pubkey( &crt->rsa ) ) != 0 )
1302  {
1303  x509_free( crt );
1304  return( ret );
1305  }
1306 
1307  crt->rsa.len = mpi_size( &crt->rsa.N );
1308 
1309  /*
1310  * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
1311  * -- If present, version shall be v2 or v3
1312  * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
1313  * -- If present, version shall be v2 or v3
1314  * extensions [3] EXPLICIT Extensions OPTIONAL
1315  * -- If present, version shall be v3
1316  */
1317  if( crt->version == 2 || crt->version == 3 )
1318  {
1319  ret = x509_get_uid( &p, end, &crt->issuer_id, 1 );
1320  if( ret != 0 )
1321  {
1322  x509_free( crt );
1323  return( ret );
1324  }
1325  }
1326 
1327  if( crt->version == 2 || crt->version == 3 )
1328  {
1329  ret = x509_get_uid( &p, end, &crt->subject_id, 2 );
1330  if( ret != 0 )
1331  {
1332  x509_free( crt );
1333  return( ret );
1334  }
1335  }
1336 
1337  if( crt->version == 3 )
1338  {
1339  ret = x509_get_crt_ext( &p, end, crt);
1340  if( ret != 0 )
1341  {
1342  x509_free( crt );
1343  return( ret );
1344  }
1345  }
1346 
1347  if( p != end )
1348  {
1349  x509_free( crt );
1350  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT +
1351  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
1352  }
1353 
1354  end = crt_end;
1355 
1356  /*
1357  * signatureAlgorithm AlgorithmIdentifier,
1358  * signatureValue BIT STRING
1359  */
1360  if( ( ret = x509_get_alg( &p, end, &crt->sig_oid2 ) ) != 0 )
1361  {
1362  x509_free( crt );
1363  return( ret );
1364  }
1365 
1366  if( crt->sig_oid1.len != crt->sig_oid2.len ||
1367  memcmp( crt->sig_oid1.p, crt->sig_oid2.p, crt->sig_oid1.len ) != 0 )
1368  {
1369  x509_free( crt );
1370  return( POLARSSL_ERR_X509_CERT_SIG_MISMATCH );
1371  }
1372 
1373  if( ( ret = x509_get_sig( &p, end, &crt->sig ) ) != 0 )
1374  {
1375  x509_free( crt );
1376  return( ret );
1377  }
1378 
1379  if( p != end )
1380  {
1381  x509_free( crt );
1382  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT +
1383  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
1384  }
1385 
1386  return( 0 );
1387 }
1388 
1389 /*
1390  * Parse one X.509 certificate in DER format from a buffer and add them to a
1391  * chained list
1392  */
1393 int x509parse_crt_der( x509_cert *chain, const unsigned char *buf, size_t buflen )
1394 {
1395  int ret;
1396  x509_cert *crt = chain, *prev = NULL;
1397 
1398  /*
1399  * Check for valid input
1400  */
1401  if( crt == NULL || buf == NULL )
1402  return( POLARSSL_ERR_X509_INVALID_INPUT );
1403 
1404  while( crt->version != 0 && crt->next != NULL )
1405  {
1406  prev = crt;
1407  crt = crt->next;
1408  }
1409 
1410  /*
1411  * Add new certificate on the end of the chain if needed.
1412  */
1413  if ( crt->version != 0 && crt->next == NULL)
1414  {
1415  crt->next = (x509_cert *) malloc( sizeof( x509_cert ) );
1416 
1417  if( crt->next == NULL )
1418  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1419 
1420  prev = crt;
1421  crt = crt->next;
1422  memset( crt, 0, sizeof( x509_cert ) );
1423  }
1424 
1425  if( ( ret = x509parse_crt_der_core( crt, buf, buflen ) ) != 0 )
1426  {
1427  if( prev )
1428  prev->next = NULL;
1429 
1430  if( crt != chain )
1431  free( crt );
1432 
1433  return( ret );
1434  }
1435 
1436  return( 0 );
1437 }
1438 
1439 /*
1440  * Parse one or more PEM certificates from a buffer and add them to the chained list
1441  */
1442 int x509parse_crt( x509_cert *chain, const unsigned char *buf, size_t buflen )
1443 {
1444  int ret, success = 0, first_error = 0, total_failed = 0;
1445  int buf_format = X509_FORMAT_DER;
1446 
1447  /*
1448  * Check for valid input
1449  */
1450  if( chain == NULL || buf == NULL )
1451  return( POLARSSL_ERR_X509_INVALID_INPUT );
1452 
1453  /*
1454  * Determine buffer content. Buffer contains either one DER certificate or
1455  * one or more PEM certificates.
1456  */
1457 #if defined(POLARSSL_PEM_C)
1458  if( strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
1459  buf_format = X509_FORMAT_PEM;
1460 #endif
1461 
1462  if( buf_format == X509_FORMAT_DER )
1463  return x509parse_crt_der( chain, buf, buflen );
1464 
1465 #if defined(POLARSSL_PEM_C)
1466  if( buf_format == X509_FORMAT_PEM )
1467  {
1468  pem_context pem;
1469 
1470  while( buflen > 0 )
1471  {
1472  size_t use_len;
1473  pem_init( &pem );
1474 
1475  ret = pem_read_buffer( &pem,
1476  "-----BEGIN CERTIFICATE-----",
1477  "-----END CERTIFICATE-----",
1478  buf, NULL, 0, &use_len );
1479 
1480  if( ret == 0 )
1481  {
1482  /*
1483  * Was PEM encoded
1484  */
1485  buflen -= use_len;
1486  buf += use_len;
1487  }
1488  else if( ret == POLARSSL_ERR_PEM_BAD_INPUT_DATA )
1489  {
1490  return( ret );
1491  }
1492  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1493  {
1494  pem_free( &pem );
1495 
1496  /*
1497  * PEM header and footer were found
1498  */
1499  buflen -= use_len;
1500  buf += use_len;
1501 
1502  if( first_error == 0 )
1503  first_error = ret;
1504 
1505  continue;
1506  }
1507  else
1508  break;
1509 
1510  ret = x509parse_crt_der( chain, pem.buf, pem.buflen );
1511 
1512  pem_free( &pem );
1513 
1514  if( ret != 0 )
1515  {
1516  /*
1517  * Quit parsing on a memory error
1518  */
1519  if( ret == POLARSSL_ERR_X509_MALLOC_FAILED )
1520  return( ret );
1521 
1522  if( first_error == 0 )
1523  first_error = ret;
1524 
1525  total_failed++;
1526  continue;
1527  }
1528 
1529  success = 1;
1530  }
1531  }
1532 #endif
1533 
1534  if( success )
1535  return( total_failed );
1536  else if( first_error )
1537  return( first_error );
1538  else
1539  return( POLARSSL_ERR_X509_CERT_UNKNOWN_FORMAT );
1540 }
1541 
1542 /*
1543  * Parse one or more CRLs and add them to the chained list
1544  */
1545 int x509parse_crl( x509_crl *chain, const unsigned char *buf, size_t buflen )
1546 {
1547  int ret;
1548  size_t len;
1549  unsigned char *p, *end;
1550  x509_crl *crl;
1551 #if defined(POLARSSL_PEM_C)
1552  size_t use_len;
1553  pem_context pem;
1554 #endif
1555 
1556  crl = chain;
1557 
1558  /*
1559  * Check for valid input
1560  */
1561  if( crl == NULL || buf == NULL )
1562  return( POLARSSL_ERR_X509_INVALID_INPUT );
1563 
1564  while( crl->version != 0 && crl->next != NULL )
1565  crl = crl->next;
1566 
1567  /*
1568  * Add new CRL on the end of the chain if needed.
1569  */
1570  if ( crl->version != 0 && crl->next == NULL)
1571  {
1572  crl->next = (x509_crl *) malloc( sizeof( x509_crl ) );
1573 
1574  if( crl->next == NULL )
1575  {
1576  x509_crl_free( crl );
1577  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1578  }
1579 
1580  crl = crl->next;
1581  memset( crl, 0, sizeof( x509_crl ) );
1582  }
1583 
1584 #if defined(POLARSSL_PEM_C)
1585  pem_init( &pem );
1586  ret = pem_read_buffer( &pem,
1587  "-----BEGIN X509 CRL-----",
1588  "-----END X509 CRL-----",
1589  buf, NULL, 0, &use_len );
1590 
1591  if( ret == 0 )
1592  {
1593  /*
1594  * Was PEM encoded
1595  */
1596  buflen -= use_len;
1597  buf += use_len;
1598 
1599  /*
1600  * Steal PEM buffer
1601  */
1602  p = pem.buf;
1603  pem.buf = NULL;
1604  len = pem.buflen;
1605  pem_free( &pem );
1606  }
1607  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
1608  {
1609  pem_free( &pem );
1610  return( ret );
1611  }
1612  else
1613  {
1614  /*
1615  * nope, copy the raw DER data
1616  */
1617  p = (unsigned char *) malloc( len = buflen );
1618 
1619  if( p == NULL )
1620  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1621 
1622  memcpy( p, buf, buflen );
1623 
1624  buflen = 0;
1625  }
1626 #else
1627  p = (unsigned char *) malloc( len = buflen );
1628 
1629  if( p == NULL )
1630  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1631 
1632  memcpy( p, buf, buflen );
1633 
1634  buflen = 0;
1635 #endif
1636 
1637  crl->raw.p = p;
1638  crl->raw.len = len;
1639  end = p + len;
1640 
1641  /*
1642  * CertificateList ::= SEQUENCE {
1643  * tbsCertList TBSCertList,
1644  * signatureAlgorithm AlgorithmIdentifier,
1645  * signatureValue BIT STRING }
1646  */
1647  if( ( ret = asn1_get_tag( &p, end, &len,
1648  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1649  {
1650  x509_crl_free( crl );
1651  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT );
1652  }
1653 
1654  if( len != (size_t) ( end - p ) )
1655  {
1656  x509_crl_free( crl );
1657  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT +
1658  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
1659  }
1660 
1661  /*
1662  * TBSCertList ::= SEQUENCE {
1663  */
1664  crl->tbs.p = p;
1665 
1666  if( ( ret = asn1_get_tag( &p, end, &len,
1667  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1668  {
1669  x509_crl_free( crl );
1670  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1671  }
1672 
1673  end = p + len;
1674  crl->tbs.len = end - crl->tbs.p;
1675 
1676  /*
1677  * Version ::= INTEGER OPTIONAL { v1(0), v2(1) }
1678  * -- if present, MUST be v2
1679  *
1680  * signature AlgorithmIdentifier
1681  */
1682  if( ( ret = x509_crl_get_version( &p, end, &crl->version ) ) != 0 ||
1683  ( ret = x509_get_alg( &p, end, &crl->sig_oid1 ) ) != 0 )
1684  {
1685  x509_crl_free( crl );
1686  return( ret );
1687  }
1688 
1689  crl->version++;
1690 
1691  if( crl->version > 2 )
1692  {
1693  x509_crl_free( crl );
1694  return( POLARSSL_ERR_X509_CERT_UNKNOWN_VERSION );
1695  }
1696 
1697  if( ( ret = x509_get_sig_alg( &crl->sig_oid1, &crl->sig_alg ) ) != 0 )
1698  {
1699  x509_crl_free( crl );
1700  return( POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG );
1701  }
1702 
1703  /*
1704  * issuer Name
1705  */
1706  crl->issuer_raw.p = p;
1707 
1708  if( ( ret = asn1_get_tag( &p, end, &len,
1709  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
1710  {
1711  x509_crl_free( crl );
1712  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
1713  }
1714 
1715  if( ( ret = x509_get_name( &p, p + len, &crl->issuer ) ) != 0 )
1716  {
1717  x509_crl_free( crl );
1718  return( ret );
1719  }
1720 
1721  crl->issuer_raw.len = p - crl->issuer_raw.p;
1722 
1723  /*
1724  * thisUpdate Time
1725  * nextUpdate Time OPTIONAL
1726  */
1727  if( ( ret = x509_get_time( &p, end, &crl->this_update ) ) != 0 )
1728  {
1729  x509_crl_free( crl );
1730  return( ret );
1731  }
1732 
1733  if( ( ret = x509_get_time( &p, end, &crl->next_update ) ) != 0 )
1734  {
1735  if ( ret != ( POLARSSL_ERR_X509_CERT_INVALID_DATE +
1736  POLARSSL_ERR_ASN1_UNEXPECTED_TAG ) &&
1737  ret != ( POLARSSL_ERR_X509_CERT_INVALID_DATE +
1738  POLARSSL_ERR_ASN1_OUT_OF_DATA ) )
1739  {
1740  x509_crl_free( crl );
1741  return( ret );
1742  }
1743  }
1744 
1745  /*
1746  * revokedCertificates SEQUENCE OF SEQUENCE {
1747  * userCertificate CertificateSerialNumber,
1748  * revocationDate Time,
1749  * crlEntryExtensions Extensions OPTIONAL
1750  * -- if present, MUST be v2
1751  * } OPTIONAL
1752  */
1753  if( ( ret = x509_get_entries( &p, end, &crl->entry ) ) != 0 )
1754  {
1755  x509_crl_free( crl );
1756  return( ret );
1757  }
1758 
1759  /*
1760  * crlExtensions EXPLICIT Extensions OPTIONAL
1761  * -- if present, MUST be v2
1762  */
1763  if( crl->version == 2 )
1764  {
1765  ret = x509_get_crl_ext( &p, end, &crl->crl_ext );
1766 
1767  if( ret != 0 )
1768  {
1769  x509_crl_free( crl );
1770  return( ret );
1771  }
1772  }
1773 
1774  if( p != end )
1775  {
1776  x509_crl_free( crl );
1777  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT +
1778  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
1779  }
1780 
1781  end = crl->raw.p + crl->raw.len;
1782 
1783  /*
1784  * signatureAlgorithm AlgorithmIdentifier,
1785  * signatureValue BIT STRING
1786  */
1787  if( ( ret = x509_get_alg( &p, end, &crl->sig_oid2 ) ) != 0 )
1788  {
1789  x509_crl_free( crl );
1790  return( ret );
1791  }
1792 
1793  if( crl->sig_oid1.len != crl->sig_oid2.len ||
1794  memcmp( crl->sig_oid1.p, crl->sig_oid2.p, crl->sig_oid1.len ) != 0 )
1795  {
1796  x509_crl_free( crl );
1797  return( POLARSSL_ERR_X509_CERT_SIG_MISMATCH );
1798  }
1799 
1800  if( ( ret = x509_get_sig( &p, end, &crl->sig ) ) != 0 )
1801  {
1802  x509_crl_free( crl );
1803  return( ret );
1804  }
1805 
1806  if( p != end )
1807  {
1808  x509_crl_free( crl );
1809  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT +
1810  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
1811  }
1812 
1813  if( buflen > 0 )
1814  {
1815  crl->next = (x509_crl *) malloc( sizeof( x509_crl ) );
1816 
1817  if( crl->next == NULL )
1818  {
1819  x509_crl_free( crl );
1820  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1821  }
1822 
1823  crl = crl->next;
1824  memset( crl, 0, sizeof( x509_crl ) );
1825 
1826  return( x509parse_crl( crl, buf, buflen ) );
1827  }
1828 
1829  return( 0 );
1830 }
1831 
1832 #if defined(POLARSSL_FS_IO)
1833 /*
1834  * Load all data from a file into a given buffer.
1835  */
1836 int load_file( const char *path, unsigned char **buf, size_t *n )
1837 {
1838  FILE *f;
1839 
1840  if( ( f = fopen( path, "rb" ) ) == NULL )
1841  return( POLARSSL_ERR_X509_FILE_IO_ERROR );
1842 
1843  fseek( f, 0, SEEK_END );
1844  *n = (size_t) ftell( f );
1845  fseek( f, 0, SEEK_SET );
1846 
1847  if( ( *buf = (unsigned char *) malloc( *n + 1 ) ) == NULL )
1848  return( POLARSSL_ERR_X509_MALLOC_FAILED );
1849 
1850  if( fread( *buf, 1, *n, f ) != *n )
1851  {
1852  fclose( f );
1853  free( *buf );
1854  return( POLARSSL_ERR_X509_FILE_IO_ERROR );
1855  }
1856 
1857  fclose( f );
1858 
1859  (*buf)[*n] = '\0';
1860 
1861  return( 0 );
1862 }
1863 
1864 /*
1865  * Load one or more certificates and add them to the chained list
1866  */
1867 int x509parse_crtfile( x509_cert *chain, const char *path )
1868 {
1869  int ret;
1870  size_t n;
1871  unsigned char *buf;
1872 
1873  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
1874  return( ret );
1875 
1876  ret = x509parse_crt( chain, buf, n );
1877 
1878  memset( buf, 0, n + 1 );
1879  free( buf );
1880 
1881  return( ret );
1882 }
1883 
1884 int x509parse_crtpath( x509_cert *chain, const char *path )
1885 {
1886  int ret = 0;
1887 #if defined(_WIN32)
1888  int w_ret;
1889  WCHAR szDir[MAX_PATH];
1890  char filename[MAX_PATH];
1891  char *p;
1892  int len = strlen( path );
1893 
1894  WIN32_FIND_DATAW file_data;
1895  HANDLE hFind;
1896 
1897  if( len > MAX_PATH - 3 )
1898  return( POLARSSL_ERR_X509_INVALID_INPUT );
1899 
1900  memset( szDir, 0, sizeof(szDir) );
1901  memset( filename, 0, MAX_PATH );
1902  memcpy( filename, path, len );
1903  filename[len++] = '\\';
1904  p = filename + len;
1905  filename[len++] = '*';
1906 
1907  w_ret = MultiByteToWideChar( CP_ACP, 0, path, len, szDir, MAX_PATH - 3 );
1908 
1909  hFind = FindFirstFileW( szDir, &file_data );
1910  if (hFind == INVALID_HANDLE_VALUE)
1911  return( POLARSSL_ERR_X509_FILE_IO_ERROR );
1912 
1913  len = MAX_PATH - len;
1914  do
1915  {
1916  memset( p, 0, len );
1917 
1918  if( file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
1919  continue;
1920 
1921  w_ret = WideCharToMultiByte( CP_ACP, 0, file_data.cFileName,
1922  lstrlenW(file_data.cFileName),
1923  p, len - 1,
1924  NULL, NULL );
1925 
1926  w_ret = x509parse_crtfile( chain, filename );
1927  if( w_ret < 0 )
1928  ret++;
1929  else
1930  ret += w_ret;
1931  }
1932  while( FindNextFileW( hFind, &file_data ) != 0 );
1933 
1934  if (GetLastError() != ERROR_NO_MORE_FILES)
1935  ret = POLARSSL_ERR_X509_FILE_IO_ERROR;
1936 
1937 cleanup:
1938  FindClose( hFind );
1939 #else
1940  int t_ret, i;
1941  struct stat sb;
1942  struct dirent entry, *result = NULL;
1943  char entry_name[255];
1944  DIR *dir = opendir( path );
1945 
1946  if( dir == NULL)
1947  return( POLARSSL_ERR_X509_FILE_IO_ERROR );
1948 
1949  while( ( t_ret = readdir_r( dir, &entry, &result ) ) == 0 )
1950  {
1951  if( result == NULL )
1952  break;
1953 
1954  snprintf( entry_name, sizeof(entry_name), "%s/%s", path, entry.d_name );
1955 
1956  i = stat( entry_name, &sb );
1957 
1958  if( i == -1 )
1959  return( POLARSSL_ERR_X509_FILE_IO_ERROR );
1960 
1961  if( !S_ISREG( sb.st_mode ) )
1962  continue;
1963 
1964  // Ignore parse errors
1965  //
1966  t_ret = x509parse_crtfile( chain, entry_name );
1967  if( t_ret < 0 )
1968  ret++;
1969  else
1970  ret += t_ret;
1971  }
1972  closedir( dir );
1973 #endif
1974 
1975  return( ret );
1976 }
1977 
1978 /*
1979  * Load one or more CRLs and add them to the chained list
1980  */
1981 int x509parse_crlfile( x509_crl *chain, const char *path )
1982 {
1983  int ret;
1984  size_t n;
1985  unsigned char *buf;
1986 
1987  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
1988  return( ret );
1989 
1990  ret = x509parse_crl( chain, buf, n );
1991 
1992  memset( buf, 0, n + 1 );
1993  free( buf );
1994 
1995  return( ret );
1996 }
1997 
1998 /*
1999  * Load and parse a private RSA key
2000  */
2001 int x509parse_keyfile( rsa_context *rsa, const char *path, const char *pwd )
2002 {
2003  int ret;
2004  size_t n;
2005  unsigned char *buf;
2006 
2007  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
2008  return( ret );
2009 
2010  if( pwd == NULL )
2011  ret = x509parse_key( rsa, buf, n, NULL, 0 );
2012  else
2013  ret = x509parse_key( rsa, buf, n,
2014  (unsigned char *) pwd, strlen( pwd ) );
2015 
2016  memset( buf, 0, n + 1 );
2017  free( buf );
2018 
2019  return( ret );
2020 }
2021 
2022 /*
2023  * Load and parse a public RSA key
2024  */
2025 int x509parse_public_keyfile( rsa_context *rsa, const char *path )
2026 {
2027  int ret;
2028  size_t n;
2029  unsigned char *buf;
2030 
2031  if ( (ret = load_file( path, &buf, &n ) ) != 0 )
2032  return( ret );
2033 
2034  ret = x509parse_public_key( rsa, buf, n );
2035 
2036  memset( buf, 0, n + 1 );
2037  free( buf );
2038 
2039  return( ret );
2040 }
2041 #endif /* POLARSSL_FS_IO */
2042 
2043 /*
2044  * Parse a PKCS#1 encoded private RSA key
2045  */
2046 static int x509parse_key_pkcs1_der( rsa_context *rsa,
2047  const unsigned char *key,
2048  size_t keylen )
2049 {
2050  int ret;
2051  size_t len;
2052  unsigned char *p, *end;
2053 
2054  p = (unsigned char *) key;
2055  end = p + keylen;
2056 
2057  /*
2058  * This function parses the RSAPrivateKey (PKCS#1)
2059  *
2060  * RSAPrivateKey ::= SEQUENCE {
2061  * version Version,
2062  * modulus INTEGER, -- n
2063  * publicExponent INTEGER, -- e
2064  * privateExponent INTEGER, -- d
2065  * prime1 INTEGER, -- p
2066  * prime2 INTEGER, -- q
2067  * exponent1 INTEGER, -- d mod (p-1)
2068  * exponent2 INTEGER, -- d mod (q-1)
2069  * coefficient INTEGER, -- (inverse of q) mod p
2070  * otherPrimeInfos OtherPrimeInfos OPTIONAL
2071  * }
2072  */
2073  if( ( ret = asn1_get_tag( &p, end, &len,
2074  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2075  {
2076  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2077  }
2078 
2079  end = p + len;
2080 
2081  if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 )
2082  {
2083  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2084  }
2085 
2086  if( rsa->ver != 0 )
2087  {
2088  return( POLARSSL_ERR_X509_KEY_INVALID_VERSION + ret );
2089  }
2090 
2091  if( ( ret = asn1_get_mpi( &p, end, &rsa->N ) ) != 0 ||
2092  ( ret = asn1_get_mpi( &p, end, &rsa->E ) ) != 0 ||
2093  ( ret = asn1_get_mpi( &p, end, &rsa->D ) ) != 0 ||
2094  ( ret = asn1_get_mpi( &p, end, &rsa->P ) ) != 0 ||
2095  ( ret = asn1_get_mpi( &p, end, &rsa->Q ) ) != 0 ||
2096  ( ret = asn1_get_mpi( &p, end, &rsa->DP ) ) != 0 ||
2097  ( ret = asn1_get_mpi( &p, end, &rsa->DQ ) ) != 0 ||
2098  ( ret = asn1_get_mpi( &p, end, &rsa->QP ) ) != 0 )
2099  {
2100  rsa_free( rsa );
2101  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2102  }
2103 
2104  rsa->len = mpi_size( &rsa->N );
2105 
2106  if( p != end )
2107  {
2108  rsa_free( rsa );
2109  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT +
2110  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
2111  }
2112 
2113  if( ( ret = rsa_check_privkey( rsa ) ) != 0 )
2114  {
2115  rsa_free( rsa );
2116  return( ret );
2117  }
2118 
2119  return( 0 );
2120 }
2121 
2122 /*
2123  * Parse an unencrypted PKCS#8 encoded private RSA key
2124  */
2125 static int x509parse_key_pkcs8_unencrypted_der(
2126  rsa_context *rsa,
2127  const unsigned char *key,
2128  size_t keylen )
2129 {
2130  int ret;
2131  size_t len;
2132  unsigned char *p, *end;
2133  x509_buf pk_alg_oid;
2134 
2135  p = (unsigned char *) key;
2136  end = p + keylen;
2137 
2138  /*
2139  * This function parses the PrivatKeyInfo object (PKCS#8)
2140  *
2141  * PrivateKeyInfo ::= SEQUENCE {
2142  * version Version,
2143  * algorithm AlgorithmIdentifier,
2144  * PrivateKey BIT STRING
2145  * }
2146  *
2147  * AlgorithmIdentifier ::= SEQUENCE {
2148  * algorithm OBJECT IDENTIFIER,
2149  * parameters ANY DEFINED BY algorithm OPTIONAL
2150  * }
2151  *
2152  * The PrivateKey BIT STRING is a PKCS#1 RSAPrivateKey
2153  */
2154  if( ( ret = asn1_get_tag( &p, end, &len,
2155  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2156  {
2157  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2158  }
2159 
2160  end = p + len;
2161 
2162  if( ( ret = asn1_get_int( &p, end, &rsa->ver ) ) != 0 )
2163  {
2164  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2165  }
2166 
2167  if( rsa->ver != 0 )
2168  {
2169  return( POLARSSL_ERR_X509_KEY_INVALID_VERSION + ret );
2170  }
2171 
2172  if( ( ret = x509_get_alg( &p, end, &pk_alg_oid ) ) != 0 )
2173  {
2174  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2175  }
2176 
2177  /*
2178  * only RSA keys handled at this time
2179  */
2180  if( pk_alg_oid.len != 9 ||
2181  memcmp( pk_alg_oid.p, OID_PKCS1_RSA, 9 ) != 0 )
2182  {
2183  return( POLARSSL_ERR_X509_UNKNOWN_PK_ALG );
2184  }
2185 
2186  /*
2187  * Get the OCTET STRING and parse the PKCS#1 format inside
2188  */
2189  if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 )
2190  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2191 
2192  if( ( end - p ) < 1 )
2193  {
2194  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT +
2195  POLARSSL_ERR_ASN1_OUT_OF_DATA );
2196  }
2197 
2198  end = p + len;
2199 
2200  if( ( ret = x509parse_key_pkcs1_der( rsa, p, end - p ) ) != 0 )
2201  return( ret );
2202 
2203  return( 0 );
2204 }
2205 
2206 /*
2207  * Parse an encrypted PKCS#8 encoded private RSA key
2208  */
2209 static int x509parse_key_pkcs8_encrypted_der(
2210  rsa_context *rsa,
2211  const unsigned char *key,
2212  size_t keylen,
2213  const unsigned char *pwd,
2214  size_t pwdlen )
2215 {
2216  int ret;
2217  size_t len;
2218  unsigned char *p, *end, *end2;
2219  x509_buf pbe_alg_oid, pbe_params;
2220  unsigned char buf[2048];
2221 
2222  memset(buf, 0, 2048);
2223 
2224  p = (unsigned char *) key;
2225  end = p + keylen;
2226 
2227  if( pwdlen == 0 )
2228  return( POLARSSL_ERR_X509_PASSWORD_REQUIRED );
2229 
2230  /*
2231  * This function parses the EncryptedPrivatKeyInfo object (PKCS#8)
2232  *
2233  * EncryptedPrivateKeyInfo ::= SEQUENCE {
2234  * encryptionAlgorithm EncryptionAlgorithmIdentifier,
2235  * encryptedData EncryptedData
2236  * }
2237  *
2238  * EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
2239  *
2240  * EncryptedData ::= OCTET STRING
2241  *
2242  * The EncryptedData OCTET STRING is a PKCS#8 PrivateKeyInfo
2243  */
2244  if( ( ret = asn1_get_tag( &p, end, &len,
2245  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2246  {
2247  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2248  }
2249 
2250  end = p + len;
2251 
2252  if( ( ret = asn1_get_tag( &p, end, &len,
2253  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2254  {
2255  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2256  }
2257 
2258  end2 = p + len;
2259 
2260  if( ( ret = asn1_get_tag( &p, end, &pbe_alg_oid.len, ASN1_OID ) ) != 0 )
2261  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2262 
2263  pbe_alg_oid.p = p;
2264  p += pbe_alg_oid.len;
2265 
2266  /*
2267  * Store the algorithm parameters
2268  */
2269  pbe_params.p = p;
2270  pbe_params.len = end2 - p;
2271  p += pbe_params.len;
2272 
2273  if( ( ret = asn1_get_tag( &p, end, &len, ASN1_OCTET_STRING ) ) != 0 )
2274  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2275 
2276  // buf has been sized to 2048 bytes
2277  if( len > 2048 )
2278  return( POLARSSL_ERR_X509_INVALID_INPUT );
2279 
2280  /*
2281  * Decrypt EncryptedData with appropriate PDE
2282  */
2283 #if defined(POLARSSL_PKCS12_C)
2284  if( OID_CMP( OID_PKCS12_PBE_SHA1_DES3_EDE_CBC, &pbe_alg_oid ) )
2285  {
2286  if( ( ret = pkcs12_pbe( &pbe_params, PKCS12_PBE_DECRYPT,
2287  POLARSSL_CIPHER_DES_EDE3_CBC, POLARSSL_MD_SHA1,
2288  pwd, pwdlen, p, len, buf ) ) != 0 )
2289  {
2290  if( ret == POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH )
2291  return( POLARSSL_ERR_X509_PASSWORD_MISMATCH );
2292 
2293  return( ret );
2294  }
2295  }
2296  else if( OID_CMP( OID_PKCS12_PBE_SHA1_DES2_EDE_CBC, &pbe_alg_oid ) )
2297  {
2298  if( ( ret = pkcs12_pbe( &pbe_params, PKCS12_PBE_DECRYPT,
2299  POLARSSL_CIPHER_DES_EDE_CBC, POLARSSL_MD_SHA1,
2300  pwd, pwdlen, p, len, buf ) ) != 0 )
2301  {
2302  if( ret == POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH )
2303  return( POLARSSL_ERR_X509_PASSWORD_MISMATCH );
2304 
2305  return( ret );
2306  }
2307  }
2308  else if( OID_CMP( OID_PKCS12_PBE_SHA1_RC4_128, &pbe_alg_oid ) )
2309  {
2310  if( ( ret = pkcs12_pbe_sha1_rc4_128( &pbe_params,
2311  PKCS12_PBE_DECRYPT,
2312  pwd, pwdlen,
2313  p, len, buf ) ) != 0 )
2314  {
2315  return( ret );
2316  }
2317 
2318  // Best guess for password mismatch when using RC4. If first tag is
2319  // not ASN1_CONSTRUCTED | ASN1_SEQUENCE
2320  //
2321  if( *buf != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
2322  return( POLARSSL_ERR_X509_PASSWORD_MISMATCH );
2323  }
2324  else
2325 #endif /* POLARSSL_PKCS12_C */
2326 #if defined(POLARSSL_PKCS5_C)
2327  if( OID_CMP( OID_PKCS5_PBES2, &pbe_alg_oid ) )
2328  {
2329  if( ( ret = pkcs5_pbes2( &pbe_params, PKCS5_DECRYPT, pwd, pwdlen,
2330  p, len, buf ) ) != 0 )
2331  {
2332  if( ret == POLARSSL_ERR_PKCS5_PASSWORD_MISMATCH )
2333  return( POLARSSL_ERR_X509_PASSWORD_MISMATCH );
2334 
2335  return( ret );
2336  }
2337  }
2338  else
2339 #endif /* POLARSSL_PKCS5_C */
2340  return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE );
2341 
2342  return x509parse_key_pkcs8_unencrypted_der( rsa, buf, len );
2343 }
2344 
2345 /*
2346  * Parse a private RSA key
2347  */
2348 int x509parse_key( rsa_context *rsa, const unsigned char *key, size_t keylen,
2349  const unsigned char *pwd, size_t pwdlen )
2350 {
2351  int ret;
2352 
2353 #if defined(POLARSSL_PEM_C)
2354  size_t len;
2355  pem_context pem;
2356 
2357  pem_init( &pem );
2358  ret = pem_read_buffer( &pem,
2359  "-----BEGIN RSA PRIVATE KEY-----",
2360  "-----END RSA PRIVATE KEY-----",
2361  key, pwd, pwdlen, &len );
2362  if( ret == 0 )
2363  {
2364  if( ( ret = x509parse_key_pkcs1_der( rsa, pem.buf, pem.buflen ) ) != 0 )
2365  {
2366  rsa_free( rsa );
2367  }
2368 
2369  pem_free( &pem );
2370  return( ret );
2371  }
2372  else if( ret == POLARSSL_ERR_PEM_PASSWORD_MISMATCH )
2373  return( POLARSSL_ERR_X509_PASSWORD_MISMATCH );
2374  else if( ret == POLARSSL_ERR_PEM_PASSWORD_REQUIRED )
2375  return( POLARSSL_ERR_X509_PASSWORD_REQUIRED );
2376  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
2377  return( ret );
2378 
2379  ret = pem_read_buffer( &pem,
2380  "-----BEGIN PRIVATE KEY-----",
2381  "-----END PRIVATE KEY-----",
2382  key, NULL, 0, &len );
2383  if( ret == 0 )
2384  {
2385  if( ( ret = x509parse_key_pkcs8_unencrypted_der( rsa,
2386  pem.buf, pem.buflen ) ) != 0 )
2387  {
2388  rsa_free( rsa );
2389  }
2390 
2391  pem_free( &pem );
2392  return( ret );
2393  }
2394  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
2395  return( ret );
2396 
2397  ret = pem_read_buffer( &pem,
2398  "-----BEGIN ENCRYPTED PRIVATE KEY-----",
2399  "-----END ENCRYPTED PRIVATE KEY-----",
2400  key, NULL, 0, &len );
2401  if( ret == 0 )
2402  {
2403  if( ( ret = x509parse_key_pkcs8_encrypted_der( rsa,
2404  pem.buf, pem.buflen,
2405  pwd, pwdlen ) ) != 0 )
2406  {
2407  rsa_free( rsa );
2408  }
2409 
2410  pem_free( &pem );
2411  return( ret );
2412  }
2413  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
2414  return( ret );
2415 #else
2416  ((void) pwd);
2417  ((void) pwdlen);
2418 #endif /* POLARSSL_PEM_C */
2419 
2420  // At this point we only know it's not a PEM formatted key. Could be any
2421  // of the known DER encoded private key formats
2422  //
2423  // We try the different DER format parsers to see if one passes without
2424  // error
2425  //
2426  if( ( ret = x509parse_key_pkcs8_encrypted_der( rsa, key, keylen,
2427  pwd, pwdlen ) ) == 0 )
2428  {
2429  return( 0 );
2430  }
2431 
2432  rsa_free( rsa );
2433 
2434  if( ret == POLARSSL_ERR_X509_PASSWORD_MISMATCH )
2435  {
2436  return( ret );
2437  }
2438 
2439  if( ( ret = x509parse_key_pkcs8_unencrypted_der( rsa, key, keylen ) ) == 0 )
2440  return( 0 );
2441 
2442  rsa_free( rsa );
2443 
2444  if( ( ret = x509parse_key_pkcs1_der( rsa, key, keylen ) ) == 0 )
2445  return( 0 );
2446 
2447  rsa_free( rsa );
2448 
2449  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT );
2450 }
2451 
2452 /*
2453  * Parse a public RSA key
2454  */
2455 int x509parse_public_key( rsa_context *rsa, const unsigned char *key, size_t keylen )
2456 {
2457  int ret;
2458  size_t len;
2459  unsigned char *p, *end;
2460  x509_buf alg_oid;
2461 #if defined(POLARSSL_PEM_C)
2462  pem_context pem;
2463 
2464  pem_init( &pem );
2465  ret = pem_read_buffer( &pem,
2466  "-----BEGIN PUBLIC KEY-----",
2467  "-----END PUBLIC KEY-----",
2468  key, NULL, 0, &len );
2469 
2470  if( ret == 0 )
2471  {
2472  /*
2473  * Was PEM encoded
2474  */
2475  keylen = pem.buflen;
2476  }
2477  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
2478  {
2479  pem_free( &pem );
2480  return( ret );
2481  }
2482 
2483  p = ( ret == 0 ) ? pem.buf : (unsigned char *) key;
2484 #else
2485  p = (unsigned char *) key;
2486 #endif
2487  end = p + keylen;
2488 
2489  /*
2490  * PublicKeyInfo ::= SEQUENCE {
2491  * algorithm AlgorithmIdentifier,
2492  * PublicKey BIT STRING
2493  * }
2494  *
2495  * AlgorithmIdentifier ::= SEQUENCE {
2496  * algorithm OBJECT IDENTIFIER,
2497  * parameters ANY DEFINED BY algorithm OPTIONAL
2498  * }
2499  *
2500  * RSAPublicKey ::= SEQUENCE {
2501  * modulus INTEGER, -- n
2502  * publicExponent INTEGER -- e
2503  * }
2504  */
2505 
2506  if( ( ret = asn1_get_tag( &p, end, &len,
2507  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2508  {
2509 #if defined(POLARSSL_PEM_C)
2510  pem_free( &pem );
2511 #endif
2512  rsa_free( rsa );
2513  return( POLARSSL_ERR_X509_CERT_INVALID_FORMAT + ret );
2514  }
2515 
2516  if( ( ret = x509_get_pubkey( &p, end, &alg_oid, &rsa->N, &rsa->E ) ) != 0 )
2517  {
2518 #if defined(POLARSSL_PEM_C)
2519  pem_free( &pem );
2520 #endif
2521  rsa_free( rsa );
2522  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2523  }
2524 
2525  if( ( ret = rsa_check_pubkey( rsa ) ) != 0 )
2526  {
2527 #if defined(POLARSSL_PEM_C)
2528  pem_free( &pem );
2529 #endif
2530  rsa_free( rsa );
2531  return( ret );
2532  }
2533 
2534  rsa->len = mpi_size( &rsa->N );
2535 
2536 #if defined(POLARSSL_PEM_C)
2537  pem_free( &pem );
2538 #endif
2539 
2540  return( 0 );
2541 }
2542 
2543 #if defined(POLARSSL_DHM_C)
2544 /*
2545  * Parse DHM parameters
2546  */
2547 int x509parse_dhm( dhm_context *dhm, const unsigned char *dhmin, size_t dhminlen )
2548 {
2549  int ret;
2550  size_t len;
2551  unsigned char *p, *end;
2552 #if defined(POLARSSL_PEM_C)
2553  pem_context pem;
2554 
2555  pem_init( &pem );
2556 
2557  ret = pem_read_buffer( &pem,
2558  "-----BEGIN DH PARAMETERS-----",
2559  "-----END DH PARAMETERS-----",
2560  dhmin, NULL, 0, &dhminlen );
2561 
2562  if( ret == 0 )
2563  {
2564  /*
2565  * Was PEM encoded
2566  */
2567  dhminlen = pem.buflen;
2568  }
2569  else if( ret != POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
2570  {
2571  pem_free( &pem );
2572  return( ret );
2573  }
2574 
2575  p = ( ret == 0 ) ? pem.buf : (unsigned char *) dhmin;
2576 #else
2577  p = (unsigned char *) dhmin;
2578 #endif
2579  end = p + dhminlen;
2580 
2581  memset( dhm, 0, sizeof( dhm_context ) );
2582 
2583  /*
2584  * DHParams ::= SEQUENCE {
2585  * prime INTEGER, -- P
2586  * generator INTEGER, -- g
2587  * }
2588  */
2589  if( ( ret = asn1_get_tag( &p, end, &len,
2590  ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
2591  {
2592 #if defined(POLARSSL_PEM_C)
2593  pem_free( &pem );
2594 #endif
2595  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2596  }
2597 
2598  end = p + len;
2599 
2600  if( ( ret = asn1_get_mpi( &p, end, &dhm->P ) ) != 0 ||
2601  ( ret = asn1_get_mpi( &p, end, &dhm->G ) ) != 0 )
2602  {
2603 #if defined(POLARSSL_PEM_C)
2604  pem_free( &pem );
2605 #endif
2606  dhm_free( dhm );
2607  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT + ret );
2608  }
2609 
2610  if( p != end )
2611  {
2612 #if defined(POLARSSL_PEM_C)
2613  pem_free( &pem );
2614 #endif
2615  dhm_free( dhm );
2616  return( POLARSSL_ERR_X509_KEY_INVALID_FORMAT +
2617  POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
2618  }
2619 
2620 #if defined(POLARSSL_PEM_C)
2621  pem_free( &pem );
2622 #endif
2623 
2624  return( 0 );
2625 }
2626 
2627 #if defined(POLARSSL_FS_IO)
2628 /*
2629  * Load and parse a private RSA key
2630  */
2631 int x509parse_dhmfile( dhm_context *dhm, const char *path )
2632 {
2633  int ret;
2634  size_t n;
2635  unsigned char *buf;
2636 
2637  if ( ( ret = load_file( path, &buf, &n ) ) != 0 )
2638  return( ret );
2639 
2640  ret = x509parse_dhm( dhm, buf, n );
2641 
2642  memset( buf, 0, n + 1 );
2643  free( buf );
2644 
2645  return( ret );
2646 }
2647 #endif /* POLARSSL_FS_IO */
2648 #endif /* POLARSSL_DHM_C */
2649 
2650 #if defined _MSC_VER && !defined snprintf
2651 #include <stdarg.h>
2652 
2653 #if !defined vsnprintf
2654 #define vsnprintf _vsnprintf
2655 #endif // vsnprintf
2656 
2657 /*
2658  * Windows _snprintf and _vsnprintf are not compatible to linux versions.
2659  * Result value is not size of buffer needed, but -1 if no fit is possible.
2660  *
2661  * This fuction tries to 'fix' this by at least suggesting enlarging the
2662  * size by 20.
2663  */
2664 int compat_snprintf(char *str, size_t size, const char *format, ...)
2665 {
2666  va_list ap;
2667  int res = -1;
2668 
2669  va_start( ap, format );
2670 
2671  res = vsnprintf( str, size, format, ap );
2672 
2673  va_end( ap );
2674 
2675  // No quick fix possible
2676  if ( res < 0 )
2677  return( (int) size + 20 );
2678 
2679  return res;
2680 }
2681 
2682 #define snprintf compat_snprintf
2683 #endif
2684 
2685 #define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2
2686 
2687 #define SAFE_SNPRINTF() \
2688 { \
2689  if( ret == -1 ) \
2690  return( -1 ); \
2691  \
2692  if ( (unsigned int) ret > n ) { \
2693  p[n - 1] = '\0'; \
2694  return POLARSSL_ERR_DEBUG_BUF_TOO_SMALL;\
2695  } \
2696  \
2697  n -= (unsigned int) ret; \
2698  p += (unsigned int) ret; \
2699 }
2700 
2701 /*
2702  * Store the name in printable form into buf; no more
2703  * than size characters will be written
2704  */
2705 int x509parse_dn_gets( char *buf, size_t size, const x509_name *dn )
2706 {
2707  int ret;
2708  size_t i, n;
2709  unsigned char c;
2710  const x509_name *name;
2711  char s[128], *p;
2712 
2713  memset( s, 0, sizeof( s ) );
2714 
2715  name = dn;
2716  p = buf;
2717  n = size;
2718 
2719  while( name != NULL )
2720  {
2721  if( !name->oid.p )
2722  {
2723  name = name->next;
2724  continue;
2725  }
2726 
2727  if( name != dn )
2728  {
2729  ret = snprintf( p, n, ", " );
2730  SAFE_SNPRINTF();
2731  }
2732 
2733  if( name->oid.len == 3 &&
2734  memcmp( name->oid.p, OID_X520, 2 ) == 0 )
2735  {
2736  switch( name->oid.p[2] )
2737  {
2738  case X520_COMMON_NAME:
2739  ret = snprintf( p, n, "CN=" ); break;
2740 
2741  case X520_COUNTRY:
2742  ret = snprintf( p, n, "C=" ); break;
2743 
2744  case X520_LOCALITY:
2745  ret = snprintf( p, n, "L=" ); break;
2746 
2747  case X520_STATE:
2748  ret = snprintf( p, n, "ST=" ); break;
2749 
2750  case X520_ORGANIZATION:
2751  ret = snprintf( p, n, "O=" ); break;
2752 
2753  case X520_ORG_UNIT:
2754  ret = snprintf( p, n, "OU=" ); break;
2755 
2756  default:
2757  ret = snprintf( p, n, "0x%02X=",
2758  name->oid.p[2] );
2759  break;
2760  }
2761  SAFE_SNPRINTF();
2762  }
2763  else if( name->oid.len == 9 &&
2764  memcmp( name->oid.p, OID_PKCS9, 8 ) == 0 )
2765  {
2766  switch( name->oid.p[8] )
2767  {
2768  case PKCS9_EMAIL:
2769  ret = snprintf( p, n, "emailAddress=" ); break;
2770 
2771  default:
2772  ret = snprintf( p, n, "0x%02X=",
2773  name->oid.p[8] );
2774  break;
2775  }
2776  SAFE_SNPRINTF();
2777  }
2778  else
2779  {
2780  ret = snprintf( p, n, "\?\?=" );
2781  SAFE_SNPRINTF();
2782  }
2783 
2784  for( i = 0; i < name->val.len; i++ )
2785  {
2786  if( i >= sizeof( s ) - 1 )
2787  break;
2788 
2789  c = name->val.p[i];
2790  if( c < 32 || c == 127 || ( c > 128 && c < 160 ) )
2791  s[i] = '?';
2792  else s[i] = c;
2793  }
2794  s[i] = '\0';
2795  ret = snprintf( p, n, "%s", s );
2796  SAFE_SNPRINTF();
2797  name = name->next;
2798  }
2799 
2800  return( (int) ( size - n ) );
2801 }
2802 
2803 /*
2804  * Store the serial in printable form into buf; no more
2805  * than size characters will be written
2806  */
2807 int x509parse_serial_gets( char *buf, size_t size, const x509_buf *serial )
2808 {
2809  int ret;
2810  size_t i, n, nr;
2811  char *p;
2812 
2813  p = buf;
2814  n = size;
2815 
2816  nr = ( serial->len <= 32 )
2817  ? serial->len : 28;
2818 
2819  for( i = 0; i < nr; i++ )
2820  {
2821  if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
2822  continue;
2823 
2824  ret = snprintf( p, n, "%02X%s",
2825  serial->p[i], ( i < nr - 1 ) ? ":" : "" );
2826  SAFE_SNPRINTF();
2827  }
2828 
2829  if( nr != serial->len )
2830  {
2831  ret = snprintf( p, n, "...." );
2832  SAFE_SNPRINTF();
2833  }
2834 
2835  return( (int) ( size - n ) );
2836 }
2837 
2838 /*
2839  * Return an informational string about the certificate.
2840  */
2841 int x509parse_cert_info( char *buf, size_t size, const char *prefix,
2842  const x509_cert *crt )
2843 {
2844  int ret;
2845  size_t n;
2846  char *p;
2847 
2848  p = buf;
2849  n = size;
2850 
2851  ret = snprintf( p, n, "%scert. version : %d\n",
2852  prefix, crt->version );
2853  SAFE_SNPRINTF();
2854  ret = snprintf( p, n, "%sserial number : ",
2855  prefix );
2856  SAFE_SNPRINTF();
2857 
2858  ret = x509parse_serial_gets( p, n, &crt->serial);
2859  SAFE_SNPRINTF();
2860 
2861  ret = snprintf( p, n, "\n%sissuer name : ", prefix );
2862  SAFE_SNPRINTF();
2863  ret = x509parse_dn_gets( p, n, &crt->issuer );
2864  SAFE_SNPRINTF();
2865 
2866  ret = snprintf( p, n, "\n%ssubject name : ", prefix );
2867  SAFE_SNPRINTF();
2868  ret = x509parse_dn_gets( p, n, &crt->subject );
2869  SAFE_SNPRINTF();
2870 
2871  ret = snprintf( p, n, "\n%sissued on : " \
2872  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2873  crt->valid_from.year, crt->valid_from.mon,
2874  crt->valid_from.day, crt->valid_from.hour,
2875  crt->valid_from.min, crt->valid_from.sec );
2876  SAFE_SNPRINTF();
2877 
2878  ret = snprintf( p, n, "\n%sexpires on : " \
2879  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2880  crt->valid_to.year, crt->valid_to.mon,
2881  crt->valid_to.day, crt->valid_to.hour,
2882  crt->valid_to.min, crt->valid_to.sec );
2883  SAFE_SNPRINTF();
2884 
2885  ret = snprintf( p, n, "\n%ssigned using : RSA+", prefix );
2886  SAFE_SNPRINTF();
2887 
2888  switch( crt->sig_alg )
2889  {
2890  case SIG_RSA_MD2 : ret = snprintf( p, n, "MD2" ); break;
2891  case SIG_RSA_MD4 : ret = snprintf( p, n, "MD4" ); break;
2892  case SIG_RSA_MD5 : ret = snprintf( p, n, "MD5" ); break;
2893  case SIG_RSA_SHA1 : ret = snprintf( p, n, "SHA1" ); break;
2894  case SIG_RSA_SHA224 : ret = snprintf( p, n, "SHA224" ); break;
2895  case SIG_RSA_SHA256 : ret = snprintf( p, n, "SHA256" ); break;
2896  case SIG_RSA_SHA384 : ret = snprintf( p, n, "SHA384" ); break;
2897  case SIG_RSA_SHA512 : ret = snprintf( p, n, "SHA512" ); break;
2898  default: ret = snprintf( p, n, "???" ); break;
2899  }
2900  SAFE_SNPRINTF();
2901 
2902  ret = snprintf( p, n, "\n%sRSA key size : %d bits\n", prefix,
2903  (int) crt->rsa.N.n * (int) sizeof( t_uint ) * 8 );
2904  SAFE_SNPRINTF();
2905 
2906  return( (int) ( size - n ) );
2907 }
2908 
2909 /*
2910  * Return an informational string describing the given OID
2911  */
2912 const char *x509_oid_get_description( x509_buf *oid )
2913 {
2914  if ( oid == NULL )
2915  return ( NULL );
2916 
2917  else if( OID_CMP( OID_SERVER_AUTH, oid ) )
2918  return( STRING_SERVER_AUTH );
2919 
2920  else if( OID_CMP( OID_CLIENT_AUTH, oid ) )
2921  return( STRING_CLIENT_AUTH );
2922 
2923  else if( OID_CMP( OID_CODE_SIGNING, oid ) )
2924  return( STRING_CODE_SIGNING );
2925 
2926  else if( OID_CMP( OID_EMAIL_PROTECTION, oid ) )
2927  return( STRING_EMAIL_PROTECTION );
2928 
2929  else if( OID_CMP( OID_TIME_STAMPING, oid ) )
2930  return( STRING_TIME_STAMPING );
2931 
2932  else if( OID_CMP( OID_OCSP_SIGNING, oid ) )
2933  return( STRING_OCSP_SIGNING );
2934 
2935  return( NULL );
2936 }
2937 
2938 /* Return the x.y.z.... style numeric string for the given OID */
2939 int x509_oid_get_numeric_string( char *buf, size_t size, x509_buf *oid )
2940 {
2941  int ret;
2942  size_t i, n;
2943  unsigned int value;
2944  char *p;
2945 
2946  p = buf;
2947  n = size;
2948 
2949  /* First byte contains first two dots */
2950  if( oid->len > 0 )
2951  {
2952  ret = snprintf( p, n, "%d.%d", oid->p[0]/40, oid->p[0]%40 );
2953  SAFE_SNPRINTF();
2954  }
2955 
2956  /* TODO: value can overflow in value. */
2957  value = 0;
2958  for( i = 1; i < oid->len; i++ )
2959  {
2960  value <<= 7;
2961  value += oid->p[i] & 0x7F;
2962 
2963  if( !( oid->p[i] & 0x80 ) )
2964  {
2965  /* Last byte */
2966  ret = snprintf( p, n, ".%d", value );
2967  SAFE_SNPRINTF();
2968  value = 0;
2969  }
2970  }
2971 
2972  return( (int) ( size - n ) );
2973 }
2974 
2975 /*
2976  * Return an informational string about the CRL.
2977  */
2978 int x509parse_crl_info( char *buf, size_t size, const char *prefix,
2979  const x509_crl *crl )
2980 {
2981  int ret;
2982  size_t n;
2983  char *p;
2984  const x509_crl_entry *entry;
2985 
2986  p = buf;
2987  n = size;
2988 
2989  ret = snprintf( p, n, "%sCRL version : %d",
2990  prefix, crl->version );
2991  SAFE_SNPRINTF();
2992 
2993  ret = snprintf( p, n, "\n%sissuer name : ", prefix );
2994  SAFE_SNPRINTF();
2995  ret = x509parse_dn_gets( p, n, &crl->issuer );
2996  SAFE_SNPRINTF();
2997 
2998  ret = snprintf( p, n, "\n%sthis update : " \
2999  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
3000  crl->this_update.year, crl->this_update.mon,
3001  crl->this_update.day, crl->this_update.hour,
3002  crl->this_update.min, crl->this_update.sec );
3003  SAFE_SNPRINTF();
3004 
3005  ret = snprintf( p, n, "\n%snext update : " \
3006  "%04d-%02d-%02d %02d:%02d:%02d", prefix,
3007  crl->next_update.year, crl->next_update.mon,
3008  crl->next_update.day, crl->next_update.hour,
3009  crl->next_update.min, crl->next_update.sec );
3010  SAFE_SNPRINTF();
3011 
3012  entry = &crl->entry;
3013 
3014  ret = snprintf( p, n, "\n%sRevoked certificates:",
3015  prefix );
3016  SAFE_SNPRINTF();
3017 
3018  while( entry != NULL && entry->raw.len != 0 )
3019  {
3020  ret = snprintf( p, n, "\n%sserial number: ",
3021  prefix );
3022  SAFE_SNPRINTF();
3023 
3024  ret = x509parse_serial_gets( p, n, &entry->serial);
3025  SAFE_SNPRINTF();
3026 
3027  ret = snprintf( p, n, " revocation date: " \
3028  "%04d-%02d-%02d %02d:%02d:%02d",
3029  entry->revocation_date.year, entry->revocation_date.mon,
3030  entry->revocation_date.day, entry->revocation_date.hour,
3031  entry->revocation_date.min, entry->revocation_date.sec );
3032  SAFE_SNPRINTF();
3033 
3034  entry = entry->next;
3035  }
3036 
3037  ret = snprintf( p, n, "\n%ssigned using : RSA+", prefix );
3038  SAFE_SNPRINTF();
3039 
3040  switch( crl->sig_alg )
3041  {
3042  case SIG_RSA_MD2 : ret = snprintf( p, n, "MD2" ); break;
3043  case SIG_RSA_MD4 : ret = snprintf( p, n, "MD4" ); break;
3044  case SIG_RSA_MD5 : ret = snprintf( p, n, "MD5" ); break;
3045  case SIG_RSA_SHA1 : ret = snprintf( p, n, "SHA1" ); break;
3046  case SIG_RSA_SHA224 : ret = snprintf( p, n, "SHA224" ); break;
3047  case SIG_RSA_SHA256 : ret = snprintf( p, n, "SHA256" ); break;
3048  case SIG_RSA_SHA384 : ret = snprintf( p, n, "SHA384" ); break;
3049  case SIG_RSA_SHA512 : ret = snprintf( p, n, "SHA512" ); break;
3050  default: ret = snprintf( p, n, "???" ); break;
3051  }
3052  SAFE_SNPRINTF();
3053 
3054  ret = snprintf( p, n, "\n" );
3055  SAFE_SNPRINTF();
3056 
3057  return( (int) ( size - n ) );
3058 }
3059 
3060 /*
3061  * Return 0 if the x509_time is still valid, or 1 otherwise.
3062  */
3063 int x509parse_time_expired( const x509_time *to )
3064 {
3065  int year, mon, day;
3066  int hour, min, sec;
3067 
3068 #if defined(_WIN32)
3069  SYSTEMTIME st;
3070 
3071  GetLocalTime(&st);
3072 
3073  year = st.wYear;
3074  mon = st.wMonth;
3075  day = st.wDay;
3076  hour = st.wHour;
3077  min = st.wMinute;
3078  sec = st.wSecond;
3079 #else
3080  struct tm *lt;
3081  time_t tt;
3082 
3083  tt = time( NULL );
3084  lt = localtime( &tt );
3085 
3086  year = lt->tm_year + 1900;
3087  mon = lt->tm_mon + 1;
3088  day = lt->tm_mday;
3089  hour = lt->tm_hour;
3090  min = lt->tm_min;
3091  sec = lt->tm_sec;
3092 #endif
3093 
3094  if( year > to->year )
3095  return( 1 );
3096 
3097  if( year == to->year &&
3098  mon > to->mon )
3099  return( 1 );
3100 
3101  if( year == to->year &&
3102  mon == to->mon &&
3103  day > to->day )
3104  return( 1 );
3105 
3106  if( year == to->year &&
3107  mon == to->mon &&
3108  day == to->day &&
3109  hour > to->hour )
3110  return( 1 );
3111 
3112  if( year == to->year &&
3113  mon == to->mon &&
3114  day == to->day &&
3115  hour == to->hour &&
3116  min > to->min )
3117  return( 1 );
3118 
3119  if( year == to->year &&
3120  mon == to->mon &&
3121  day == to->day &&
3122  hour == to->hour &&
3123  min == to->min &&
3124  sec > to->sec )
3125  return( 1 );
3126 
3127  return( 0 );
3128 }
3129 
3130 /*
3131  * Return 1 if the certificate is revoked, or 0 otherwise.
3132  */
3133 int x509parse_revoked( const x509_cert *crt, const x509_crl *crl )
3134 {
3135  const x509_crl_entry *cur = &crl->entry;
3136 
3137  while( cur != NULL && cur->serial.len != 0 )
3138  {
3139  if( crt->serial.len == cur->serial.len &&
3140  memcmp( crt->serial.p, cur->serial.p, crt->serial.len ) == 0 )
3141  {
3142  if( x509parse_time_expired( &cur->revocation_date ) )
3143  return( 1 );
3144  }
3145 
3146  cur = cur->next;
3147  }
3148 
3149  return( 0 );
3150 }
3151 
3152 /*
3153  * Wrapper for x509 hashes.
3154  */
3155 static void x509_hash( const unsigned char *in, size_t len, int alg,
3156  unsigned char *out )
3157 {
3158  switch( alg )
3159  {
3160 #if defined(POLARSSL_MD2_C)
3161  case SIG_RSA_MD2 : md2( in, len, out ); break;
3162 #endif
3163 #if defined(POLARSSL_MD4_C)
3164  case SIG_RSA_MD4 : md4( in, len, out ); break;
3165 #endif
3166 #if defined(POLARSSL_MD5_C)
3167  case SIG_RSA_MD5 : md5( in, len, out ); break;
3168 #endif
3169 #if defined(POLARSSL_SHA1_C)
3170  case SIG_RSA_SHA1 : sha1( in, len, out ); break;
3171 #endif
3172 #if defined(POLARSSL_SHA2_C)
3173  case SIG_RSA_SHA224 : sha2( in, len, out, 1 ); break;
3174  case SIG_RSA_SHA256 : sha2( in, len, out, 0 ); break;
3175 #endif
3176 #if defined(POLARSSL_SHA4_C)
3177  case SIG_RSA_SHA384 : sha4( in, len, out, 1 ); break;
3178  case SIG_RSA_SHA512 : sha4( in, len, out, 0 ); break;
3179 #endif
3180  default:
3181  memset( out, '\xFF', 64 );
3182  break;
3183  }
3184 }
3185 
3186 /*
3187  * Check that the given certificate is valid accoring to the CRL.
3188  */
3189 static int x509parse_verifycrl(x509_cert *crt, x509_cert *ca,
3190  x509_crl *crl_list)
3191 {
3192  int flags = 0;
3193  int hash_id;
3194  unsigned char hash[64];
3195 
3196  if( ca == NULL )
3197  return( flags );
3198 
3199  /*
3200  * TODO: What happens if no CRL is present?
3201  * Suggestion: Revocation state should be unknown if no CRL is present.
3202  * For backwards compatibility this is not yet implemented.
3203  */
3204 
3205  while( crl_list != NULL )
3206  {
3207  if( crl_list->version == 0 ||
3208  crl_list->issuer_raw.len != ca->subject_raw.len ||
3209  memcmp( crl_list->issuer_raw.p, ca->subject_raw.p,
3210  crl_list->issuer_raw.len ) != 0 )
3211  {
3212  crl_list = crl_list->next;
3213  continue;
3214  }
3215 
3216  /*
3217  * Check if CRL is correctly signed by the trusted CA
3218  */
3219  hash_id = crl_list->sig_alg;
3220 
3221  x509_hash( crl_list->tbs.p, crl_list->tbs.len, hash_id, hash );
3222 
3223  if( !rsa_pkcs1_verify( &ca->rsa, RSA_PUBLIC, hash_id,
3224  0, hash, crl_list->sig.p ) == 0 )
3225  {
3226  /*
3227  * CRL is not trusted
3228  */
3229  flags |= BADCRL_NOT_TRUSTED;
3230  break;
3231  }
3232 
3233  /*
3234  * Check for validity of CRL (Do not drop out)
3235  */
3236  if( x509parse_time_expired( &crl_list->next_update ) )
3237  flags |= BADCRL_EXPIRED;
3238 
3239  /*
3240  * Check if certificate is revoked
3241  */
3242  if( x509parse_revoked(crt, crl_list) )
3243  {
3244  flags |= BADCERT_REVOKED;
3245  break;
3246  }
3247 
3248  crl_list = crl_list->next;
3249  }
3250  return flags;
3251 }
3252 
3253 int x509_wildcard_verify( const char *cn, x509_buf *name )
3254 {
3255  size_t i;
3256  size_t cn_idx = 0;
3257 
3258  if( name->len < 3 || name->p[0] != '*' || name->p[1] != '.' )
3259  return( 0 );
3260 
3261  for( i = 0; i < strlen( cn ); ++i )
3262  {
3263  if( cn[i] == '.' )
3264  {
3265  cn_idx = i;
3266  break;
3267  }
3268  }
3269 
3270  if( cn_idx == 0 )
3271  return( 0 );
3272 
3273  if( strlen( cn ) - cn_idx == name->len - 1 &&
3274  memcmp( name->p + 1, cn + cn_idx, name->len - 1 ) == 0 )
3275  {
3276  return( 1 );
3277  }
3278 
3279  return( 0 );
3280 }
3281 
3282 static int x509parse_verify_top(
3283  x509_cert *child, x509_cert *trust_ca,
3284  x509_crl *ca_crl, int path_cnt, int *flags,
3285  int (*f_vrfy)(void *, x509_cert *, int, int *),
3286  void *p_vrfy )
3287 {
3288  int hash_id, ret;
3289  int ca_flags = 0, check_path_cnt = path_cnt + 1;
3290  unsigned char hash[64];
3291 
3292  if( x509parse_time_expired( &child->valid_to ) )
3293  *flags |= BADCERT_EXPIRED;
3294 
3295  /*
3296  * Child is the top of the chain. Check against the trust_ca list.
3297  */
3298  *flags |= BADCERT_NOT_TRUSTED;
3299 
3300  while( trust_ca != NULL )
3301  {
3302  if( trust_ca->version == 0 ||
3303  child->issuer_raw.len != trust_ca->subject_raw.len ||
3304  memcmp( child->issuer_raw.p, trust_ca->subject_raw.p,
3305  child->issuer_raw.len ) != 0 )
3306  {
3307  trust_ca = trust_ca->next;
3308  continue;
3309  }
3310 
3311  /*
3312  * Reduce path_len to check against if top of the chain is
3313  * the same as the trusted CA
3314  */
3315  if( child->subject_raw.len == trust_ca->subject_raw.len &&
3316  memcmp( child->subject_raw.p, trust_ca->subject_raw.p,
3317  child->issuer_raw.len ) == 0 )
3318  {
3319  check_path_cnt--;
3320  }
3321 
3322  if( trust_ca->max_pathlen > 0 &&
3323  trust_ca->max_pathlen < check_path_cnt )
3324  {
3325  trust_ca = trust_ca->next;
3326  continue;
3327  }
3328 
3329  hash_id = child->sig_alg;
3330 
3331  x509_hash( child->tbs.p, child->tbs.len, hash_id, hash );
3332 
3333  if( rsa_pkcs1_verify( &trust_ca->rsa, RSA_PUBLIC, hash_id,
3334  0, hash, child->sig.p ) != 0 )
3335  {
3336  trust_ca = trust_ca->next;
3337  continue;
3338  }
3339 
3340  /*
3341  * Top of chain is signed by a trusted CA
3342  */
3343  *flags &= ~BADCERT_NOT_TRUSTED;
3344  break;
3345  }
3346 
3347  /*
3348  * If top of chain is not the same as the trusted CA send a verify request
3349  * to the callback for any issues with validity and CRL presence for the
3350  * trusted CA certificate.
3351  */
3352  if( trust_ca != NULL &&
3353  ( child->subject_raw.len != trust_ca->subject_raw.len ||
3354  memcmp( child->subject_raw.p, trust_ca->subject_raw.p,
3355  child->issuer_raw.len ) != 0 ) )
3356  {
3357  /* Check trusted CA's CRL for then chain's top crt */
3358  *flags |= x509parse_verifycrl( child, trust_ca, ca_crl );
3359 
3360  if( x509parse_time_expired( &trust_ca->valid_to ) )
3361  ca_flags |= BADCERT_EXPIRED;
3362 
3363  if( NULL != f_vrfy )
3364  {
3365  if( ( ret = f_vrfy( p_vrfy, trust_ca, path_cnt + 1, &ca_flags ) ) != 0 )
3366  return( ret );
3367  }
3368  }
3369 
3370  /* Call callback on top cert */
3371  if( NULL != f_vrfy )
3372  {
3373  if( ( ret = f_vrfy(p_vrfy, child, path_cnt, flags ) ) != 0 )
3374  return( ret );
3375  }
3376 
3377  *flags |= ca_flags;
3378 
3379  return( 0 );
3380 }
3381 
3382 static int x509parse_verify_child(
3383  x509_cert *child, x509_cert *parent, x509_cert *trust_ca,
3384  x509_crl *ca_crl, int path_cnt, int *flags,
3385  int (*f_vrfy)(void *, x509_cert *, int, int *),
3386  void *p_vrfy )
3387 {
3388  int hash_id, ret;
3389  int parent_flags = 0;
3390  unsigned char hash[64];
3391  x509_cert *grandparent;
3392 
3393  if( x509parse_time_expired( &child->valid_to ) )
3394  *flags |= BADCERT_EXPIRED;
3395 
3396  hash_id = child->sig_alg;
3397 
3398  x509_hash( child->tbs.p, child->tbs.len, hash_id, hash );
3399 
3400  if( rsa_pkcs1_verify( &parent->rsa, RSA_PUBLIC, hash_id, 0, hash,
3401  child->sig.p ) != 0 )
3402  *flags |= BADCERT_NOT_TRUSTED;
3403 
3404  /* Check trusted CA's CRL for the given crt */
3405  *flags |= x509parse_verifycrl(child, parent, ca_crl);
3406 
3407  grandparent = parent->next;
3408 
3409  while( grandparent != NULL )
3410  {
3411  if( grandparent->version == 0 ||
3412  grandparent->ca_istrue == 0 ||
3413  parent->issuer_raw.len != grandparent->subject_raw.len ||
3414  memcmp( parent->issuer_raw.p, grandparent->subject_raw.p,
3415  parent->issuer_raw.len ) != 0 )
3416  {
3417  grandparent = grandparent->next;
3418  continue;
3419  }
3420  break;
3421  }
3422 
3423  if( grandparent != NULL )
3424  {
3425  /*
3426  * Part of the chain
3427  */
3428  ret = x509parse_verify_child( parent, grandparent, trust_ca, ca_crl, path_cnt + 1, &parent_flags, f_vrfy, p_vrfy );
3429  if( ret != 0 )
3430  return( ret );
3431  }
3432  else
3433  {
3434  ret = x509parse_verify_top( parent, trust_ca, ca_crl, path_cnt + 1, &parent_flags, f_vrfy, p_vrfy );
3435  if( ret != 0 )
3436  return( ret );
3437  }
3438 
3439  /* child is verified to be a child of the parent, call verify callback */
3440  if( NULL != f_vrfy )
3441  if( ( ret = f_vrfy( p_vrfy, child, path_cnt, flags ) ) != 0 )
3442  return( ret );
3443 
3444  *flags |= parent_flags;
3445 
3446  return( 0 );
3447 }
3448 
3449 /*
3450  * Verify the certificate validity
3451  */
3452 int x509parse_verify( x509_cert *crt,
3453  x509_cert *trust_ca,
3454  x509_crl *ca_crl,
3455  const char *cn, int *flags,
3456  int (*f_vrfy)(void *, x509_cert *, int, int *),
3457  void *p_vrfy )
3458 {
3459  size_t cn_len;
3460  int ret;
3461  int pathlen = 0;
3462  x509_cert *parent;
3463  x509_name *name;
3464  x509_sequence *cur = NULL;
3465 
3466  *flags = 0;
3467 
3468  if( cn != NULL )
3469  {
3470  name = &crt->subject;
3471  cn_len = strlen( cn );
3472 
3473  if( crt->ext_types & EXT_SUBJECT_ALT_NAME )
3474  {
3475  cur = &crt->subject_alt_names;
3476 
3477  while( cur != NULL )
3478  {
3479  if( cur->buf.len == cn_len &&
3480  memcmp( cn, cur->buf.p, cn_len ) == 0 )
3481  break;
3482 
3483  if( cur->buf.len > 2 &&
3484  memcmp( cur->buf.p, "*.", 2 ) == 0 &&
3485  x509_wildcard_verify( cn, &cur->buf ) )
3486  break;
3487 
3488  cur = cur->next;
3489  }
3490 
3491  if( cur == NULL )
3492  *flags |= BADCERT_CN_MISMATCH;
3493  }
3494  else
3495  {
3496  while( name != NULL )
3497  {
3498  if( name->oid.len == 3 &&
3499  memcmp( name->oid.p, OID_CN, 3 ) == 0 )
3500  {
3501  if( name->val.len == cn_len &&
3502  memcmp( name->val.p, cn, cn_len ) == 0 )
3503  break;
3504 
3505  if( name->val.len > 2 &&
3506  memcmp( name->val.p, "*.", 2 ) == 0 &&
3507  x509_wildcard_verify( cn, &name->val ) )
3508  break;
3509  }
3510 
3511  name = name->next;
3512  }
3513 
3514  if( name == NULL )
3515  *flags |= BADCERT_CN_MISMATCH;
3516  }
3517  }
3518 
3519  /*
3520  * Iterate upwards in the given cert chain, to find our crt parent.
3521  * Ignore any upper cert with CA != TRUE.
3522  */
3523  parent = crt->next;
3524 
3525  while( parent != NULL && parent->version != 0 )
3526  {
3527  if( parent->ca_istrue == 0 ||
3528  crt->issuer_raw.len != parent->subject_raw.len ||
3529  memcmp( crt->issuer_raw.p, parent->subject_raw.p,
3530  crt->issuer_raw.len ) != 0 )
3531  {
3532  parent = parent->next;
3533  continue;
3534  }
3535  break;
3536  }
3537 
3538  if( parent != NULL )
3539  {
3540  /*
3541  * Part of the chain
3542  */
3543  ret = x509parse_verify_child( crt, parent, trust_ca, ca_crl, pathlen, flags, f_vrfy, p_vrfy );
3544  if( ret != 0 )
3545  return( ret );
3546  }
3547  else
3548  {
3549  ret = x509parse_verify_top( crt, trust_ca, ca_crl, pathlen, flags, f_vrfy, p_vrfy );
3550  if( ret != 0 )
3551  return( ret );
3552  }
3553 
3554  if( *flags != 0 )
3555  return( POLARSSL_ERR_X509_CERT_VERIFY_FAILED );
3556 
3557  return( 0 );
3558 }
3559 
3560 /*
3561  * Unallocate all certificate data
3562  */
3563 void x509_free( x509_cert *crt )
3564 {
3565  x509_cert *cert_cur = crt;
3566  x509_cert *cert_prv;
3567  x509_name *name_cur;
3568  x509_name *name_prv;
3569  x509_sequence *seq_cur;
3570  x509_sequence *seq_prv;
3571 
3572  if( crt == NULL )
3573  return;
3574 
3575  do
3576  {
3577  rsa_free( &cert_cur->rsa );
3578 
3579  name_cur = cert_cur->issuer.next;
3580  while( name_cur != NULL )
3581  {
3582  name_prv = name_cur;
3583  name_cur = name_cur->next;
3584  memset( name_prv, 0, sizeof( x509_name ) );
3585  free( name_prv );
3586  }
3587 
3588  name_cur = cert_cur->subject.next;
3589  while( name_cur != NULL )
3590  {
3591  name_prv = name_cur;
3592  name_cur = name_cur->next;
3593  memset( name_prv, 0, sizeof( x509_name ) );
3594  free( name_prv );
3595  }
3596 
3597  seq_cur = cert_cur->ext_key_usage.next;
3598  while( seq_cur != NULL )
3599  {
3600  seq_prv = seq_cur;
3601  seq_cur = seq_cur->next;
3602  memset( seq_prv, 0, sizeof( x509_sequence ) );
3603  free( seq_prv );
3604  }
3605 
3606  seq_cur = cert_cur->subject_alt_names.next;
3607  while( seq_cur != NULL )
3608  {
3609  seq_prv = seq_cur;
3610  seq_cur = seq_cur->next;
3611  memset( seq_prv, 0, sizeof( x509_sequence ) );
3612  free( seq_prv );
3613  }
3614 
3615  if( cert_cur->raw.p != NULL )
3616  {
3617  memset( cert_cur->raw.p, 0, cert_cur->raw.len );
3618  free( cert_cur->raw.p );
3619  }
3620 
3621  cert_cur = cert_cur->next;
3622  }
3623  while( cert_cur != NULL );
3624 
3625  cert_cur = crt;
3626  do
3627  {
3628  cert_prv = cert_cur;
3629  cert_cur = cert_cur->next;
3630 
3631  memset( cert_prv, 0, sizeof( x509_cert ) );
3632  if( cert_prv != crt )
3633  free( cert_prv );
3634  }
3635  while( cert_cur != NULL );
3636 }
3637 
3638 /*
3639  * Unallocate all CRL data
3640  */
3641 void x509_crl_free( x509_crl *crl )
3642 {
3643  x509_crl *crl_cur = crl;
3644  x509_crl *crl_prv;
3645  x509_name *name_cur;
3646  x509_name *name_prv;
3647  x509_crl_entry *entry_cur;
3648  x509_crl_entry *entry_prv;
3649 
3650  if( crl == NULL )
3651  return;
3652 
3653  do
3654  {
3655  name_cur = crl_cur->issuer.next;
3656  while( name_cur != NULL )
3657  {
3658  name_prv = name_cur;
3659  name_cur = name_cur->next;
3660  memset( name_prv, 0, sizeof( x509_name ) );
3661  free( name_prv );
3662  }
3663 
3664  entry_cur = crl_cur->entry.next;
3665  while( entry_cur != NULL )
3666  {
3667  entry_prv = entry_cur;
3668  entry_cur = entry_cur->next;
3669  memset( entry_prv, 0, sizeof( x509_crl_entry ) );
3670  free( entry_prv );
3671  }
3672 
3673  if( crl_cur->raw.p != NULL )
3674  {
3675  memset( crl_cur->raw.p, 0, crl_cur->raw.len );
3676  free( crl_cur->raw.p );
3677  }
3678 
3679  crl_cur = crl_cur->next;
3680  }
3681  while( crl_cur != NULL );
3682 
3683  crl_cur = crl;
3684  do
3685  {
3686  crl_prv = crl_cur;
3687  crl_cur = crl_cur->next;
3688 
3689  memset( crl_prv, 0, sizeof( x509_crl ) );
3690  if( crl_prv != crl )
3691  free( crl_prv );
3692  }
3693  while( crl_cur != NULL );
3694 }
3695 
3696 #if defined(POLARSSL_SELF_TEST)
3697 
3698 #include "polarssl/certs.h"
3699 
3700 /*
3701  * Checkup routine
3702  */
3703 int x509_self_test( int verbose )
3704 {
3705 #if defined(POLARSSL_CERTS_C) && defined(POLARSSL_MD5_C)
3706  int ret;
3707  int flags;
3708  size_t i, j;
3709  x509_cert cacert;
3710  x509_cert clicert;
3711  rsa_context rsa;
3712 #if defined(POLARSSL_DHM_C)
3713  dhm_context dhm;
3714 #endif
3715 
3716  if( verbose != 0 )
3717  printf( " X.509 certificate load: " );
3718 
3719  memset( &clicert, 0, sizeof( x509_cert ) );
3720 
3721  ret = x509parse_crt( &clicert, (const unsigned char *) test_cli_crt,
3722  strlen( test_cli_crt ) );
3723  if( ret != 0 )
3724  {
3725  if( verbose != 0 )
3726  printf( "failed\n" );
3727 
3728  return( ret );
3729  }
3730 
3731  memset( &cacert, 0, sizeof( x509_cert ) );
3732 
3733  ret = x509parse_crt( &cacert, (const unsigned char *) test_ca_crt,
3734  strlen( test_ca_crt ) );
3735  if( ret != 0 )
3736  {
3737  if( verbose != 0 )
3738  printf( "failed\n" );
3739 
3740  return( ret );
3741  }
3742 
3743  if( verbose != 0 )
3744  printf( "passed\n X.509 private key load: " );
3745 
3746  i = strlen( test_ca_key );
3747  j = strlen( test_ca_pwd );
3748 
3749  rsa_init( &rsa, RSA_PKCS_V15, 0 );
3750 
3751  if( ( ret = x509parse_key( &rsa,
3752  (const unsigned char *) test_ca_key, i,
3753  (const unsigned char *) test_ca_pwd, j ) ) != 0 )
3754  {
3755  if( verbose != 0 )
3756  printf( "failed\n" );
3757 
3758  return( ret );
3759  }
3760 
3761  if( verbose != 0 )
3762  printf( "passed\n X.509 signature verify: ");
3763 
3764  ret = x509parse_verify( &clicert, &cacert, NULL, "PolarSSL Client 2", &flags, NULL, NULL );
3765  if( ret != 0 )
3766  {
3767  printf("%02x", flags);
3768  if( verbose != 0 )
3769  printf( "failed\n" );
3770 
3771  return( ret );
3772  }
3773 
3774 #if defined(POLARSSL_DHM_C)
3775  if( verbose != 0 )
3776  printf( "passed\n X.509 DHM parameter load: " );
3777 
3778  i = strlen( test_dhm_params );
3779  j = strlen( test_ca_pwd );
3780 
3781  if( ( ret = x509parse_dhm( &dhm, (const unsigned char *) test_dhm_params, i ) ) != 0 )
3782  {
3783  if( verbose != 0 )
3784  printf( "failed\n" );
3785 
3786  return( ret );
3787  }
3788 
3789  if( verbose != 0 )
3790  printf( "passed\n\n" );
3791 #endif
3792 
3793  x509_free( &cacert );
3794  x509_free( &clicert );
3795  rsa_free( &rsa );
3796 #if defined(POLARSSL_DHM_C)
3797  dhm_free( &dhm );
3798 #endif
3799 
3800  return( 0 );
3801 #else
3802  ((void) verbose);
3803  return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE );
3804 #endif
3805 }
3806 
3807 #endif
3808 
3809 #endif
_x509_cert::valid_to
x509_time valid_to
End time of certificate validity.
Definition: x509.h:304
OID_CLIENT_AUTH
#define OID_CLIENT_AUTH
id-kp-clientAuth OBJECT IDENTIFIER ::= { id-kp 2 }
Definition: x509.h:167
POLARSSL_ERR_X509_KEY_INVALID_FORMAT
#define POLARSSL_ERR_X509_KEY_INVALID_FORMAT
Invalid RSA key tag or value.
Definition: x509.h:60
_x509_crl::sig
x509_buf sig
Definition: x509.h:374
SIG_RSA_MD5
#define SIG_RSA_MD5
Definition: rsa.h:51
dhm_context::P
mpi P
Definition: dhm.h:139
_x509_cert::issuer_raw
x509_buf issuer_raw
The raw issuer data (DER).
Definition: x509.h:297
ASN1_NULL
#define ASN1_NULL
Definition: asn1.h:75
ASN1_PRINTABLE_STRING
#define ASN1_PRINTABLE_STRING
Definition: asn1.h:80
x509parse_crt_der
int x509parse_crt_der(x509_cert *chain, const unsigned char *buf, size_t buflen)
Parse a single DER formatted certificate and add it to the chained list.
STRING_SERVER_AUTH
#define STRING_SERVER_AUTH
Definition: x509.h:173
_x509_cert::issuer
x509_name issuer
The parsed issuer data (named information object).
Definition: x509.h:300
_x509_cert::tbs
x509_buf tbs
The raw certificate body (DER).
Definition: x509.h:291
_x509_name::val
x509_buf val
The named value.
Definition: x509.h:267
ASN1_UTC_TIME
#define ASN1_UTC_TIME
Definition: asn1.h:83
asn1_get_sequence_of
int asn1_get_sequence_of(unsigned char **p, const unsigned char *end, asn1_sequence *cur, int tag)
Parses and splits an ASN.1 "SEQUENCE OF " Updated the pointer to immediately behind the full seq...
X509_FORMAT_DER
#define X509_FORMAT_DER
Definition: x509.h:238
SIG_RSA_MD4
#define SIG_RSA_MD4
Definition: rsa.h:50
_x509_cert::max_pathlen
int max_pathlen
Optional Basic Constraint extension value: The maximum path length to the root certificate.
Definition: x509.h:316
ASN1_OID
#define ASN1_OID
Definition: asn1.h:76
OID_PKCS9
#define OID_PKCS9
Definition: x509.h:117
EXT_KEY_USAGE
#define EXT_KEY_USAGE
Definition: x509.h:218
ASN1_GENERALIZED_TIME
#define ASN1_GENERALIZED_TIME
Definition: asn1.h:84
_x509_cert::ns_cert_type
unsigned char ns_cert_type
Optional Netscape certificate type extension value: See the values below.
Definition: x509.h:322
_x509_time::sec
int sec
Time.
Definition: x509.h:281
t_uint
uint32_t t_uint
Definition: bignum.h:146
_x509_crl::version
int version
Definition: x509.h:359
rsa_check_privkey
int rsa_check_privkey(const rsa_context *ctx)
Check a private RSA key.
_asn1_sequence::buf
asn1_buf buf
Buffer containing the given ASN.1 item.
Definition: asn1.h:132
POLARSSL_ERR_X509_PASSWORD_REQUIRED
#define POLARSSL_ERR_X509_PASSWORD_REQUIRED
Private key password can't be empty.
Definition: x509.h:65
_x509_crl::next_update
x509_time next_update
Definition: x509.h:367
POLARSSL_ERR_ASN1_LENGTH_MISMATCH
#define POLARSSL_ERR_ASN1_LENGTH_MISMATCH
Actual length differs from expected length.
Definition: asn1.h:53
pkcs12_pbe
int pkcs12_pbe(asn1_buf *pbe_params, int mode, cipher_type_t cipher_type, md_type_t md_type, const unsigned char *pwd, size_t pwdlen, const unsigned char *input, size_t len, unsigned char *output)
PKCS12 Password Based function (encryption / decryption) for cipher-based and md-based PBE's...
x509parse_crtfile
int x509parse_crtfile(x509_cert *chain, const char *path)
Load one or more certificates and add them to the chained list.
sha1
void sha1(const unsigned char *input, size_t ilen, unsigned char output[20])
Output = SHA-1( input buffer )
dhm_context
DHM context structure.
Definition: dhm.h:136
_x509_crl_entry
Certificate revocation list entry.
Definition: x509.h:336
POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS
#define POLARSSL_ERR_X509_CERT_INVALID_EXTENSIONS
The extension tag or value is invalid.
Definition: x509.h:53
_x509_cert::sig
x509_buf sig
Signature: hash of the tbs part signed with the private key.
Definition: x509.h:325
POLARSSL_ERR_X509_INVALID_INPUT
#define POLARSSL_ERR_X509_INVALID_INPUT
Input invalid.
Definition: x509.h:62
POLARSSL_ERR_X509_CERT_UNKNOWN_FORMAT
#define POLARSSL_ERR_X509_CERT_UNKNOWN_FORMAT
Format not recognized as DER or PEM.
Definition: x509.h:61
EXT_BASIC_CONSTRAINTS
#define EXT_BASIC_CONSTRAINTS
Definition: x509.h:224
_x509_cert::subject
x509_name subject
The parsed subject data (named information object).
Definition: x509.h:301
X520_STATE
#define X520_STATE
Definition: x509.h:92
OID_SERVER_AUTH
#define OID_SERVER_AUTH
id-kp-serverAuth OBJECT IDENTIFIER ::= { id-kp 1 }
Definition: x509.h:166
_x509_crl::next
struct _x509_crl * next
Definition: x509.h:377
asn1_get_int
int asn1_get_int(unsigned char **p, const unsigned char *end, int *val)
Retrieve an integer ASN.1 tag and its value.
_asn1_bitstring::len
size_t len
ASN1 length, e.g.
Definition: asn1.h:121
_x509_cert::raw
x509_buf raw
The raw certificate data (DER).
Definition: x509.h:290
POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG
#define POLARSSL_ERR_X509_CERT_UNKNOWN_SIG_ALG
Signature algorithm (oid) is unsupported.
Definition: x509.h:55
x509_oid_get_description
const char * x509_oid_get_description(x509_buf *oid)
Give an known OID, return its descriptive string.
RSA_PUBLIC
#define RSA_PUBLIC
Definition: rsa.h:58
_x509_time
Container for date and time (precision in seconds).
Definition: x509.h:278
STRING_EMAIL_PROTECTION
#define STRING_EMAIL_PROTECTION
Definition: x509.h:176
POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH
#define POLARSSL_ERR_PKCS12_PASSWORD_MISMATCH
Given private key password does not allow for correct decryption.
Definition: pkcs12.h:39
POLARSSL_ERR_X509_CERT_INVALID_VERSION
#define POLARSSL_ERR_X509_CERT_INVALID_VERSION
The certificate version element is invalid.
Definition: x509.h:46
ASN1_SEQUENCE
#define ASN1_SEQUENCE
Definition: asn1.h:78
x509_free
void x509_free(x509_cert *crt)
Unallocate all certificate data.
rsa_context::DQ
mpi DQ
Definition: rsa.h:147
_x509_cert::ext_key_usage
x509_sequence ext_key_usage
Optional list of extended key usage OIDs.
Definition: x509.h:320
config.h
Configuration options (set of defines)
rsa_check_pubkey
int rsa_check_pubkey(const rsa_context *ctx)
Check a public RSA key.
md2
void md2(const unsigned char *input, size_t ilen, unsigned char output[16])
Output = MD2( input buffer )
pem_read_buffer
int pem_read_buffer(pem_context *ctx, char *header, char *footer, const unsigned char *data, const unsigned char *pwd, size_t pwdlen, size_t *use_len)
Read a buffer for PEM information and store the resulting data into the specified context buffers...
ASN1_CONSTRUCTED
#define ASN1_CONSTRUCTED
Definition: asn1.h:88
POLARSSL_ERR_X509_UNKNOWN_PK_ALG
#define POLARSSL_ERR_X509_UNKNOWN_PK_ALG
Key algorithm is unsupported (only RSA is supported).
Definition: x509.h:56
OID_CN
#define OID_CN
Definition: x509.h:104
_x509_name
Container for ASN1 named information objects.
Definition: x509.h:264
x509parse_cert_info
int x509parse_cert_info(char *buf, size_t size, const char *prefix, const x509_cert *crt)
Returns an informational string about the certificate.
mpi
MPI structure.
Definition: bignum.h:164
_x509_crl::sig_oid2
x509_buf sig_oid2
Definition: x509.h:373
test_ca_pwd
const char test_ca_pwd[]
rsa_pkcs1_verify
int rsa_pkcs1_verify(rsa_context *ctx, int mode, int hash_id, unsigned int hashlen, const unsigned char *hash, unsigned char *sig)
Generic wrapper to perform a PKCS#1 verification using the mode from the context. ...
STRING_TIME_STAMPING
#define STRING_TIME_STAMPING
Definition: x509.h:177
_x509_cert
Container for an X.509 certificate.
Definition: x509.h:288
x509parse_dhmfile
int x509parse_dhmfile(dhm_context *dhm, const char *path)
Load and parse DHM parameters.
OID_PKCS5_PBES2
#define OID_PKCS5_PBES2
Definition: pkcs5.h:56
BADCRL_NOT_TRUSTED
#define BADCRL_NOT_TRUSTED
CRL is not correctly signed by the trusted CA.
Definition: x509.h:78
test_ca_crt
const char test_ca_crt[]
md4
void md4(const unsigned char *input, size_t ilen, unsigned char output[16])
Output = MD4( input buffer )
POLARSSL_ERR_ASN1_INVALID_LENGTH
#define POLARSSL_ERR_ASN1_INVALID_LENGTH
Error when trying to determine the length or invalid length.
Definition: asn1.h:52
_asn1_bitstring
Container for ASN1 bit strings.
Definition: asn1.h:119
POLARSSL_ERR_X509_CERT_INVALID_SERIAL
#define POLARSSL_ERR_X509_CERT_INVALID_SERIAL
The serial tag or value is invalid.
Definition: x509.h:47
_x509_crl::issuer
x509_name issuer
The parsed issuer data (named information object).
Definition: x509.h:364
_x509_crl_entry::serial
x509_buf serial
Definition: x509.h:340
OID_PKCS1_RSA
#define OID_PKCS1_RSA
Definition: x509.h:112
POLARSSL_ERR_X509_KEY_INVALID_VERSION
#define POLARSSL_ERR_X509_KEY_INVALID_VERSION
Unsupported RSA key version.
Definition: x509.h:59
OID_SIZE
#define OID_SIZE(x)
Returns the size of the binary string, without the trailing \0.
Definition: asn1.h:94
rsa_context::len
size_t len
Definition: rsa.h:138
OID_KEY_USAGE
#define OID_KEY_USAGE
id-ce-keyUsage OBJECT IDENTIFIER ::= { id-ce 15 }
Definition: x509.h:135
rsa_context::P
mpi P
Definition: rsa.h:144
_x509_crl::entry
x509_crl_entry entry
The CRL entries containing the certificate revocation times for this CA.
Definition: x509.h:369
OID_PKCS12_PBE_SHA1_DES3_EDE_CBC
#define OID_PKCS12_PBE_SHA1_DES3_EDE_CBC
Definition: pkcs12.h:53
_x509_cert::sig_oid2
x509_buf sig_oid2
Signature algorithm.
Definition: x509.h:324
POLARSSL_ERR_X509_CERT_SIG_MISMATCH
#define POLARSSL_ERR_X509_CERT_SIG_MISMATCH
Certificate signature algorithms do not match.
Definition: x509.h:57
ASN1_SET
#define ASN1_SET
Definition: asn1.h:79
_x509_time::hour
int hour
Definition: x509.h:281
rsa_context::Q
mpi Q
Definition: rsa.h:145
ASN1_PRIMITIVE
#define ASN1_PRIMITIVE
Definition: asn1.h:87
POLARSSL_ERR_PKCS5_PASSWORD_MISMATCH
#define POLARSSL_ERR_PKCS5_PASSWORD_MISMATCH
Given private key password does not allow for correct decryption.
Definition: pkcs5.h:47
_x509_time::mon
int mon
Definition: x509.h:280
_asn1_sequence
Container for a sequence of ASN.1 items.
Definition: asn1.h:130
OID_SUBJECT_ALT_NAME
#define OID_SUBJECT_ALT_NAME
id-ce-subjectAltName OBJECT IDENTIFIER ::= { id-ce 17 }
Definition: x509.h:138
POLARSSL_ERR_PEM_PASSWORD_REQUIRED
#define POLARSSL_ERR_PEM_PASSWORD_REQUIRED
Private key password can't be empty.
Definition: pem.h:43
BADCERT_EXPIRED
#define BADCERT_EXPIRED
The certificate validity has expired.
Definition: x509.h:74
_x509_crl::sig_oid1
x509_buf sig_oid1
Definition: x509.h:360
rsa_free
void rsa_free(rsa_context *ctx)
Free the components of an RSA key.
_x509_cert::sig_alg
int sig_alg
Internal representation of the signature algorithm, e.g.
Definition: x509.h:326
_asn1_bitstring::p
unsigned char * p
Raw ASN1 data for the bit string.
Definition: asn1.h:123
rsa_context
RSA context structure.
Definition: rsa.h:135
pem_init
void pem_init(pem_context *ctx)
PEM context setup.
x509parse_crt
int x509parse_crt(x509_cert *chain, const unsigned char *buf, size_t buflen)
Parse one or more certificates and add them to the chained list.
asn1.h
Generic ASN.1 parsing.
rsa_context::D
mpi D
Definition: rsa.h:143
SIG_RSA_SHA512
#define SIG_RSA_SHA512
Definition: rsa.h:56
sha4.h
SHA-384 and SHA-512 cryptographic hash function.
POLARSSL_ERR_X509_CERT_VERIFY_FAILED
#define POLARSSL_ERR_X509_CERT_VERIFY_FAILED
Certificate verification failed, e.g.
Definition: x509.h:58
rsa_context::QP
mpi QP
Definition: rsa.h:148
ASN1_BMP_STRING
#define ASN1_BMP_STRING
Definition: asn1.h:86
x509parse_time_expired
int x509parse_time_expired(const x509_time *time)
Check a given x509_time against the system time and check if it is valid.
pem.h
Privacy Enhanced Mail (PEM) decoding.
OID_PKCS1
#define OID_PKCS1
Definition: x509.h:111
RSA_PKCS_V15
#define RSA_PKCS_V15
Definition: rsa.h:61
POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE
#define POLARSSL_ERR_X509_CERT_INVALID_SIGNATURE
The signature tag or value invalid.
Definition: x509.h:52
rsa_context::N
mpi N
Definition: rsa.h:140
pkcs5_pbes2
int pkcs5_pbes2(asn1_buf *pbe_params, int mode, const unsigned char *pwd, size_t pwdlen, const unsigned char *data, size_t datalen, unsigned char *output)
PKCS#5 PBES2 function.
SIG_RSA_SHA1
#define SIG_RSA_SHA1
Definition: rsa.h:52
dhm_context::G
mpi G
Definition: dhm.h:140
OID_EXTENDED_KEY_USAGE
#define OID_EXTENDED_KEY_USAGE
id-ce-extKeyUsage OBJECT IDENTIFIER ::= { id-ce 37 }
Definition: x509.h:144
OID_BASIC_CONSTRAINTS
#define OID_BASIC_CONSTRAINTS
id-ce-basicConstraints OBJECT IDENTIFIER ::= { id-ce 19 }
Definition: x509.h:141
OID_NS_CERT_TYPE
#define OID_NS_CERT_TYPE
Definition: x509.h:191
sha2.h
SHA-224 and SHA-256 cryptographic hash function.
x509_crl_free
void x509_crl_free(x509_crl *crl)
Unallocate all CRL data.
X520_LOCALITY
#define X520_LOCALITY
Definition: x509.h:91
x509parse_dhm
int x509parse_dhm(dhm_context *dhm, const unsigned char *dhmin, size_t dhminlen)
Parse DHM parameters.
ASN1_INTEGER
#define ASN1_INTEGER
Definition: asn1.h:72
_asn1_buf::p
unsigned char * p
ASN1 data, e.g.
Definition: asn1.h:112
POLARSSL_ERR_X509_CERT_INVALID_FORMAT
#define POLARSSL_ERR_X509_CERT_INVALID_FORMAT
The certificate format is invalid, e.g.
Definition: x509.h:45
x509parse_crtpath
int x509parse_crtpath(x509_cert *chain, const char *path)
Load one or more certificate files from a path and add them to the chained list.
x509parse_crl
int x509parse_crl(x509_crl *chain, const unsigned char *buf, size_t buflen)
Parse one or more CRLs and add them to the chained list.
x509parse_dn_gets
int x509parse_dn_gets(char *buf, size_t size, const x509_name *dn)
Store the certificate DN in printable form into buf; no more than size characters will be written...
x509parse_key
int x509parse_key(rsa_context *rsa, const unsigned char *key, size_t keylen, const unsigned char *pwd, size_t pwdlen)
Parse a private RSA key.
EXT_NS_CERT_TYPE
#define EXT_NS_CERT_TYPE
Definition: x509.h:232
POLARSSL_ERR_PEM_PASSWORD_MISMATCH
#define POLARSSL_ERR_PEM_PASSWORD_MISMATCH
Given private key password does not allow for correct decryption.
Definition: pem.h:44
x509_oid_get_numeric_string
int x509_oid_get_numeric_string(char *buf, size_t size, x509_buf *oid)
Give an OID, return a string version of its OID number.
X520_COMMON_NAME
#define X520_COMMON_NAME
Definition: x509.h:89
pem_free
void pem_free(pem_context *ctx)
PEM context memory freeing.
_x509_crl::tbs
x509_buf tbs
The raw certificate body (DER).
Definition: x509.h:357
asn1_get_bool
int asn1_get_bool(unsigned char **p, const unsigned char *end, int *val)
Retrieve a boolean ASN.1 tag and its value.
STRING_OCSP_SIGNING
#define STRING_OCSP_SIGNING
Definition: x509.h:178
x509parse_public_keyfile
int x509parse_public_keyfile(rsa_context *rsa, const char *path)
Load and parse a public RSA key.
_x509_cert::serial
x509_buf serial
Unique id for certificate issued by a specific CA.
Definition: x509.h:294
_x509_crl_entry::next
struct _x509_crl_entry * next
Definition: x509.h:346
_x509_cert::subject_id
x509_buf subject_id
Optional X.509 v2/v3 subject unique identifier.
Definition: x509.h:310
SIG_RSA_MD2
#define SIG_RSA_MD2
Definition: rsa.h:49
dhm.h
Diffie-Hellman-Merkle key exchange.
_x509_time::day
int day
Date.
Definition: x509.h:280
test_ca_key
const char test_ca_key[]
_x509_cert::valid_from
x509_time valid_from
Start time of certificate validity.
Definition: x509.h:303
rsa_context::E
mpi E
Definition: rsa.h:141
_asn1_buf::tag
int tag
ASN1 type, e.g.
Definition: asn1.h:110
rsa_context::DP
mpi DP
Definition: rsa.h:146
POLARSSL_ERR_ASN1_OUT_OF_DATA
#define POLARSSL_ERR_ASN1_OUT_OF_DATA
Out of data when parsing an ASN1 data structure.
Definition: asn1.h:50
EXT_EXTENDED_KEY_USAGE
#define EXT_EXTENDED_KEY_USAGE
Definition: x509.h:227
_x509_cert::issuer_id
x509_buf issuer_id
Optional X.509 v2/v3 issuer unique identifier.
Definition: x509.h:309
_x509_cert::key_usage
unsigned char key_usage
Optional key usage extension value: See the values below.
Definition: x509.h:318
ASN1_BIT_STRING
#define ASN1_BIT_STRING
Definition: asn1.h:73
x509.h
X.509 certificate and private key decoding.
x509parse_crl_info
int x509parse_crl_info(char *buf, size_t size, const char *prefix, const x509_crl *crl)
Returns an informational string about the CRL.
OID_X520
#define OID_X520
Definition: x509.h:103
x509parse_public_key
int x509parse_public_key(rsa_context *rsa, const unsigned char *key, size_t keylen)
Parse a public RSA key.
POLARSSL_ERR_ASN1_MALLOC_FAILED
#define POLARSSL_ERR_ASN1_MALLOC_FAILED
Memory allocation failed.
Definition: asn1.h:55
ASN1_CONTEXT_SPECIFIC
#define ASN1_CONTEXT_SPECIFIC
Definition: asn1.h:89
BADCERT_NOT_TRUSTED
#define BADCERT_NOT_TRUSTED
The certificate is not correctly signed by the trusted CA.
Definition: x509.h:77
_x509_cert::next
struct _x509_cert * next
Next certificate in the CA-chain.
Definition: x509.h:328
POLARSSL_ERR_X509_FILE_IO_ERROR
#define POLARSSL_ERR_X509_FILE_IO_ERROR
Read/write of file failed.
Definition: x509.h:64
des.h
DES block cipher.
STRING_CODE_SIGNING
#define STRING_CODE_SIGNING
Definition: x509.h:175
pem_context
PEM context structure.
Definition: pem.h:52
OID_PKCS12_PBE_SHA1_DES2_EDE_CBC
#define OID_PKCS12_PBE_SHA1_DES2_EDE_CBC
Definition: pkcs12.h:54
POLARSSL_ERR_X509_CERT_INVALID_DATE
#define POLARSSL_ERR_X509_CERT_INVALID_DATE
The date tag or value is invalid.
Definition: x509.h:50
_x509_crl::this_update
x509_time this_update
Definition: x509.h:366
_asn1_buf
Type-length-value structure that allows for ASN1 using DER.
Definition: asn1.h:108
ASN1_UNIVERSAL_STRING
#define ASN1_UNIVERSAL_STRING
Definition: asn1.h:85
_x509_crl_entry::entry_ext
x509_buf entry_ext
Definition: x509.h:344
POLARSSL_ERR_X509_CERT_UNKNOWN_VERSION
#define POLARSSL_ERR_X509_CERT_UNKNOWN_VERSION
Certificate or CRL has an unsupported version number.
Definition: x509.h:54
pkcs12_pbe_sha1_rc4_128
int pkcs12_pbe_sha1_rc4_128(asn1_buf *pbe_params, int mode, const unsigned char *pwd, size_t pwdlen, const unsigned char *input, size_t len, unsigned char *output)
PKCS12 Password Based function (encryption / decryption) for pbeWithSHAAnd128BitRC4.
_asn1_buf::len
size_t len
ASN1 length, e.g.
Definition: asn1.h:111
X509_FORMAT_PEM
#define X509_FORMAT_PEM
Definition: x509.h:239
sha4
void sha4(const unsigned char *input, size_t ilen, unsigned char output[64], int is384)
Output = SHA-512( input buffer )
certs.h
Sample certificates and DHM parameters for testing.
ASN1_IA5_STRING
#define ASN1_IA5_STRING
Definition: asn1.h:82
POLARSSL_ERR_X509_CERT_INVALID_PUBKEY
#define POLARSSL_ERR_X509_CERT_INVALID_PUBKEY
The pubkey tag or value is invalid (only RSA is supported).
Definition: x509.h:51
SIG_RSA_SHA224
#define SIG_RSA_SHA224
Definition: rsa.h:53
OID_PKCS12_PBE_SHA1_RC4_128
#define OID_PKCS12_PBE_SHA1_RC4_128
Definition: pkcs12.h:52
sha1.h
SHA-1 cryptographic hash function.
_x509_time::year
int year
Definition: x509.h:280
BADCERT_REVOKED
#define BADCERT_REVOKED
The certificate has been revoked (is on a CRL).
Definition: x509.h:75
mpi_size
size_t mpi_size(const mpi *X)
Return the total size in bytes.
x509parse_revoked
int x509parse_revoked(const x509_cert *crt, const x509_crl *crl)
Verify the certificate signature.
ASN1_UTF8_STRING
#define ASN1_UTF8_STRING
Definition: asn1.h:77
_x509_crl_entry::raw
x509_buf raw
Definition: x509.h:338
BADCRL_EXPIRED
#define BADCRL_EXPIRED
CRL is expired.
Definition: x509.h:79
_x509_cert::subject_raw
x509_buf subject_raw
The raw subject data (DER).
Definition: x509.h:298
PKCS5_DECRYPT
#define PKCS5_DECRYPT
Definition: pkcs5.h:49
asn1_get_len
int asn1_get_len(unsigned char **p, const unsigned char *end, size_t *len)
Get the length of an ASN.1 element.
rsa_init
void rsa_init(rsa_context *ctx, int padding, int hash_id)
Initialize an RSA context.
mpi::n
size_t n
Definition: bignum.h:167
POLARSSL_ERR_X509_FEATURE_UNAVAILABLE
#define POLARSSL_ERR_X509_FEATURE_UNAVAILABLE
Unavailable feature, e.g.
Definition: x509.h:43
pem_context::buf
unsigned char * buf
Definition: pem.h:54
asn1_get_tag
int asn1_get_tag(unsigned char **p, const unsigned char *end, size_t *len, int tag)
Get the tag and length of the tag.
X520_ORGANIZATION
#define X520_ORGANIZATION
Definition: x509.h:93
_x509_crl
Certificate revocation list structure.
Definition: x509.h:354
asn1_get_bitstring
int asn1_get_bitstring(unsigned char **p, const unsigned char *end, asn1_bitstring *bs)
Retrieve a bitstring ASN.1 tag and its value.
POLARSSL_ERR_X509_CERT_INVALID_ALG
#define POLARSSL_ERR_X509_CERT_INVALID_ALG
The algorithm tag or value is invalid.
Definition: x509.h:48
_x509_time::min
int min
Definition: x509.h:281
SIG_RSA_SHA256
#define SIG_RSA_SHA256
Definition: rsa.h:54
OID_TIME_STAMPING
#define OID_TIME_STAMPING
id-kp-timeStamping OBJECT IDENTIFIER ::= { id-kp 8 }
Definition: x509.h:170
POLARSSL_ERR_X509_PASSWORD_MISMATCH
#define POLARSSL_ERR_X509_PASSWORD_MISMATCH
Given private key password does not allow for correct decryption.
Definition: x509.h:66
OID_OCSP_SIGNING
#define OID_OCSP_SIGNING
id-kp-OCSPSigning OBJECT IDENTIFIER ::= { id-kp 9 }
Definition: x509.h:171
_x509_cert::subject_alt_names
x509_sequence subject_alt_names
Optional list of Subject Alternative Names (Only dNSName supported).
Definition: x509.h:312
_x509_cert::v3_ext
x509_buf v3_ext
Optional X.509 v3 extensions.
Definition: x509.h:311
dhm_free
void dhm_free(dhm_context *ctx)
Free the components of a DHM key.
OID_EMAIL_PROTECTION
#define OID_EMAIL_PROTECTION
id-kp-emailProtection OBJECT IDENTIFIER ::= { id-kp 4 }
Definition: x509.h:169
_x509_cert::pk_oid
x509_buf pk_oid
Subject public key info.
Definition: x509.h:306
ASN1_OCTET_STRING
#define ASN1_OCTET_STRING
Definition: asn1.h:74
sha2
void sha2(const unsigned char *input, size_t ilen, unsigned char output[32], int is224)
Output = SHA-256( input buffer )
STRING_CLIENT_AUTH
#define STRING_CLIENT_AUTH
Definition: x509.h:174
OID_CODE_SIGNING
#define OID_CODE_SIGNING
id-kp-codeSigning OBJECT IDENTIFIER ::= { id-kp 3 }
Definition: x509.h:168
_x509_crl::raw
x509_buf raw
The raw certificate data (DER).
Definition: x509.h:356
OID_RSA_SHA_OBS
#define OID_RSA_SHA_OBS
Definition: x509.h:115
X520_COUNTRY
#define X520_COUNTRY
Definition: x509.h:90
SIG_RSA_SHA384
#define SIG_RSA_SHA384
Definition: rsa.h:55
BADCERT_CN_MISMATCH
#define BADCERT_CN_MISMATCH
The certificate Common Name (CN) does not match with the expected CN.
Definition: x509.h:76
x509_self_test
int x509_self_test(int verbose)
Checkup routine.
POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT
#define POLARSSL_ERR_PEM_NO_HEADER_FOOTER_PRESENT
No PEM header or footer found.
Definition: pem.h:38
test_dhm_params
const char test_dhm_params[]
md4.h
MD4 message digest algorithm (hash function)
_x509_crl_entry::revocation_date
x509_time revocation_date
Definition: x509.h:342
x509parse_verify
int x509parse_verify(x509_cert *crt, x509_cert *trust_ca, x509_crl *ca_crl, const char *cn, int *flags, int(*f_vrfy)(void *, x509_cert *, int, int *), void *p_vrfy)
Verify the certificate signature.
_x509_crl::issuer_raw
x509_buf issuer_raw
The raw issuer data (DER).
Definition: x509.h:362
test_cli_crt
const char test_cli_crt[]
X520_ORG_UNIT
#define X520_ORG_UNIT
Definition: x509.h:94
pem_context::buflen
size_t buflen
Definition: pem.h:55
asn1_get_mpi
int asn1_get_mpi(unsigned char **p, const unsigned char *end, mpi *X)
Retrieve a MPI value from an integer ASN.1 tag.
_x509_cert::version
int version
The X.509 version.
Definition: x509.h:293
ASN1_T61_STRING
#define ASN1_T61_STRING
Definition: asn1.h:81
_x509_cert::rsa
rsa_context rsa
Container for the RSA context.
Definition: x509.h:307
md5.h
MD5 message digest algorithm (hash function)
PKCS12_PBE_DECRYPT
#define PKCS12_PBE_DECRYPT
Definition: pkcs12.h:45
POLARSSL_ERR_X509_MALLOC_FAILED
#define POLARSSL_ERR_X509_MALLOC_FAILED
Allocation of memory failed.
Definition: x509.h:63
PKCS9_EMAIL
#define PKCS9_EMAIL
Definition: x509.h:95
rsa_context::ver
int ver
Definition: rsa.h:137
POLARSSL_ERR_PEM_BAD_INPUT_DATA
#define POLARSSL_ERR_PEM_BAD_INPUT_DATA
Bad input parameters to function.
Definition: pem.h:46
_x509_crl::crl_ext
x509_buf crl_ext
Definition: x509.h:371
md5
void md5(const unsigned char *input, size_t ilen, unsigned char output[16])
Output = MD5( input buffer )
md2.h
MD2 message digest algorithm (hash function)
POLARSSL_ERR_ASN1_UNEXPECTED_TAG
#define POLARSSL_ERR_ASN1_UNEXPECTED_TAG
ASN1 tag was of an unexpected value.
Definition: asn1.h:51
pkcs12.h
PKCS#12 Personal Information Exchange Syntax.
x509parse_keyfile
int x509parse_keyfile(rsa_context *rsa, const char *path, const char *password)
Load and parse a private RSA key.
x509parse_serial_gets
int x509parse_serial_gets(char *buf, size_t size, const x509_buf *serial)
Store the certificate serial in printable form into buf; no more than size characters will be written...
_asn1_sequence::next
struct _asn1_sequence * next
The next entry in the sequence.
Definition: asn1.h:133
x509parse_crlfile
int x509parse_crlfile(x509_crl *chain, const char *path)
Load one or more CRLs and add them to the chained list.
_x509_crl::sig_alg
int sig_alg
Definition: x509.h:375
_x509_cert::sig_oid1
x509_buf sig_oid1
Signature algorithm, e.g.
Definition: x509.h:295
_x509_cert::ca_istrue
int ca_istrue
Optional Basic Constraint extension value: 1 if this certificate belongs to a CA, 0 otherwise...
Definition: x509.h:315
_x509_name::next
struct _x509_name * next
The next named information object.
Definition: x509.h:268
POLARSSL_ERR_X509_CERT_INVALID_NAME
#define POLARSSL_ERR_X509_CERT_INVALID_NAME
The name tag or value is invalid.
Definition: x509.h:49
EXT_SUBJECT_ALT_NAME
#define EXT_SUBJECT_ALT_NAME
Definition: x509.h:221
_x509_name::oid
x509_buf oid
The object identifier.
Definition: x509.h:266
_x509_cert::ext_types
int ext_types
Bit string containing detected and parsed extensions.
Definition: x509.h:314
Generated on Sat Aug 30 2014 12:19:09 for PolarSSL v1.2.8 by   doxygen 1.8.7