blob: 849ea7bd9cc01575c8947347aa2bdc8d9cc09217 [file] [log] [blame]
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001/*
Manuel Pégourié-Gonnard1c082f32014-06-12 22:34:55 +02002 * X.509 certificate parsing and verification
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003 *
Manuel Pégourié-Gonnarda658a402015-01-23 09:45:19 +00004 * Copyright (C) 2006-2014, ARM Limited, All Rights Reserved
Paul Bakker7c6b2c32013-09-16 13:49:26 +02005 *
Manuel Pégourié-Gonnardfe446432015-03-06 13:17:10 +00006 * This file is part of mbed TLS (https://tls.mbed.org)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02007 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +02008 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22/*
23 * The ITU-T X.509 standard defines a certificate format for PKI.
24 *
Manuel Pégourié-Gonnard1c082f32014-06-12 22:34:55 +020025 * http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)
26 * http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)
27 * http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020028 *
29 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
30 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
31 */
32
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020033#if !defined(MBEDTLS_CONFIG_FILE)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000034#include "mbedtls/config.h"
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020035#else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020036#include MBEDTLS_CONFIG_FILE
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020037#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +020038
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020039#if defined(MBEDTLS_X509_CRT_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020040
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000041#include "mbedtls/x509_crt.h"
42#include "mbedtls/oid.h"
Rich Evans00ab4702015-02-06 13:43:58 +000043
44#include <stdio.h>
45#include <string.h>
46
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020047#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000048#include "mbedtls/pem.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020049#endif
50
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020051#if defined(MBEDTLS_PLATFORM_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000052#include "mbedtls/platform.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020053#else
Rich Evans00ab4702015-02-06 13:43:58 +000054#include <stdlib.h>
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020055#define mbedtls_free free
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +020056#define mbedtls_calloc calloc
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020057#define mbedtls_snprintf snprintf
Paul Bakker7c6b2c32013-09-16 13:49:26 +020058#endif
59
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020060#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000061#include "mbedtls/threading.h"
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +010062#endif
63
Paul Bakkerfa6a6202013-10-28 18:48:30 +010064#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020065#include <windows.h>
66#else
67#include <time.h>
68#endif
69
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020070#if defined(MBEDTLS_FS_IO)
Rich Evans00ab4702015-02-06 13:43:58 +000071#include <stdio.h>
Paul Bakker5ff3f912014-04-04 15:08:20 +020072#if !defined(_WIN32) || defined(EFIX64) || defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020073#include <sys/types.h>
74#include <sys/stat.h>
75#include <dirent.h>
Rich Evans00ab4702015-02-06 13:43:58 +000076#endif /* !_WIN32 || EFIX64 || EFI32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +020077#endif
78
Paul Bakker34617722014-06-13 17:20:13 +020079/* Implementation that should never be optimized out by the compiler */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020080static void mbedtls_zeroize( void *v, size_t n ) {
Paul Bakker34617722014-06-13 17:20:13 +020081 volatile unsigned char *p = v; while( n-- ) *p++ = 0;
82}
83
Paul Bakker7c6b2c32013-09-16 13:49:26 +020084/*
85 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
86 */
87static int x509_get_version( unsigned char **p,
88 const unsigned char *end,
89 int *ver )
90{
91 int ret;
92 size_t len;
93
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020094 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
95 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +020096 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020097 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +020098 {
99 *ver = 0;
100 return( 0 );
101 }
102
103 return( ret );
104 }
105
106 end = *p + len;
107
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200108 if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
109 return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200110
111 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200112 return( MBEDTLS_ERR_X509_INVALID_VERSION +
113 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200114
115 return( 0 );
116}
117
118/*
119 * Validity ::= SEQUENCE {
120 * notBefore Time,
121 * notAfter Time }
122 */
123static int x509_get_dates( unsigned char **p,
124 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200125 mbedtls_x509_time *from,
126 mbedtls_x509_time *to )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200127{
128 int ret;
129 size_t len;
130
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200131 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
132 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
133 return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200134
135 end = *p + len;
136
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200137 if( ( ret = mbedtls_x509_get_time( p, end, from ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200138 return( ret );
139
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200140 if( ( ret = mbedtls_x509_get_time( p, end, to ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200141 return( ret );
142
143 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200144 return( MBEDTLS_ERR_X509_INVALID_DATE +
145 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200146
147 return( 0 );
148}
149
150/*
151 * X.509 v2/v3 unique identifier (not parsed)
152 */
153static int x509_get_uid( unsigned char **p,
154 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200155 mbedtls_x509_buf *uid, int n )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200156{
157 int ret;
158
159 if( *p == end )
160 return( 0 );
161
162 uid->tag = **p;
163
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200164 if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
165 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200166 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200167 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200168 return( 0 );
169
170 return( ret );
171 }
172
173 uid->p = *p;
174 *p += uid->len;
175
176 return( 0 );
177}
178
179static int x509_get_basic_constraints( unsigned char **p,
180 const unsigned char *end,
181 int *ca_istrue,
182 int *max_pathlen )
183{
184 int ret;
185 size_t len;
186
187 /*
188 * BasicConstraints ::= SEQUENCE {
189 * cA BOOLEAN DEFAULT FALSE,
190 * pathLenConstraint INTEGER (0..MAX) OPTIONAL }
191 */
192 *ca_istrue = 0; /* DEFAULT FALSE */
193 *max_pathlen = 0; /* endless */
194
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200195 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
196 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
197 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200198
199 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200200 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200201
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200202 if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200203 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200204 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
205 ret = mbedtls_asn1_get_int( p, end, ca_istrue );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200206
207 if( ret != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200208 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200209
210 if( *ca_istrue != 0 )
211 *ca_istrue = 1;
212 }
213
214 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200215 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200216
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200217 if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) != 0 )
218 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200219
220 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200221 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
222 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200223
224 (*max_pathlen)++;
225
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200226 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200227}
228
229static int x509_get_ns_cert_type( unsigned char **p,
230 const unsigned char *end,
231 unsigned char *ns_cert_type)
232{
233 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200234 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200235
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200236 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
237 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200238
239 if( bs.len != 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200240 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
241 MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200242
243 /* Get actual bitstring */
244 *ns_cert_type = *bs.p;
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200245 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200246}
247
248static int x509_get_key_usage( unsigned char **p,
249 const unsigned char *end,
Manuel Pégourié-Gonnard1d0ca1a2015-03-27 16:50:00 +0100250 unsigned int *key_usage)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200251{
252 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200253 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200254
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200255 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
256 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200257
258 if( bs.len < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200259 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
260 MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200261
262 /* Get actual bitstring */
263 *key_usage = *bs.p;
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200264 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200265}
266
267/*
268 * ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
269 *
270 * KeyPurposeId ::= OBJECT IDENTIFIER
271 */
272static int x509_get_ext_key_usage( unsigned char **p,
273 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200274 mbedtls_x509_sequence *ext_key_usage)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200275{
276 int ret;
277
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200278 if( ( ret = mbedtls_asn1_get_sequence_of( p, end, ext_key_usage, MBEDTLS_ASN1_OID ) ) != 0 )
279 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200280
281 /* Sequence length must be >= 1 */
282 if( ext_key_usage->buf.p == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200283 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
284 MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200285
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200286 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200287}
288
289/*
290 * SubjectAltName ::= GeneralNames
291 *
292 * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
293 *
294 * GeneralName ::= CHOICE {
295 * otherName [0] OtherName,
296 * rfc822Name [1] IA5String,
297 * dNSName [2] IA5String,
298 * x400Address [3] ORAddress,
299 * directoryName [4] Name,
300 * ediPartyName [5] EDIPartyName,
301 * uniformResourceIdentifier [6] IA5String,
302 * iPAddress [7] OCTET STRING,
303 * registeredID [8] OBJECT IDENTIFIER }
304 *
305 * OtherName ::= SEQUENCE {
306 * type-id OBJECT IDENTIFIER,
307 * value [0] EXPLICIT ANY DEFINED BY type-id }
308 *
309 * EDIPartyName ::= SEQUENCE {
310 * nameAssigner [0] DirectoryString OPTIONAL,
311 * partyName [1] DirectoryString }
312 *
Manuel Pégourié-Gonnardb4fe3cb2015-01-22 16:11:05 +0000313 * NOTE: we only parse and use dNSName at this point.
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200314 */
315static int x509_get_subject_alt_name( unsigned char **p,
316 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200317 mbedtls_x509_sequence *subject_alt_name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200318{
319 int ret;
320 size_t len, tag_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200321 mbedtls_asn1_buf *buf;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200322 unsigned char tag;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200323 mbedtls_asn1_sequence *cur = subject_alt_name;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200324
325 /* Get main sequence tag */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200326 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
327 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
328 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200329
330 if( *p + len != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200331 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
332 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200333
334 while( *p < end )
335 {
336 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200337 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
338 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200339
340 tag = **p;
341 (*p)++;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200342 if( ( ret = mbedtls_asn1_get_len( p, end, &tag_len ) ) != 0 )
343 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200344
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200345 if( ( tag & MBEDTLS_ASN1_CONTEXT_SPECIFIC ) != MBEDTLS_ASN1_CONTEXT_SPECIFIC )
346 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
347 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200348
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +0200349 /* Skip everything but DNS name */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200350 if( tag != ( MBEDTLS_ASN1_CONTEXT_SPECIFIC | 2 ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200351 {
352 *p += tag_len;
353 continue;
354 }
355
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200356 /* Allocate and assign next pointer */
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +0200357 if( cur->buf.p != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200358 {
Manuel Pégourié-Gonnardb1340602014-11-11 23:11:16 +0100359 if( cur->next != NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200360 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
Manuel Pégourié-Gonnardb1340602014-11-11 23:11:16 +0100361
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200362 cur->next = mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200363
364 if( cur->next == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200365 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
366 MBEDTLS_ERR_ASN1_MALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200367
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200368 memset( cur->next, 0, sizeof( mbedtls_asn1_sequence ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200369 cur = cur->next;
370 }
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +0200371
372 buf = &(cur->buf);
373 buf->tag = tag;
374 buf->p = *p;
375 buf->len = tag_len;
376 *p += buf->len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200377 }
378
379 /* Set final sequence entry's next pointer to NULL */
380 cur->next = NULL;
381
382 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200383 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
384 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200385
386 return( 0 );
387}
388
389/*
390 * X.509 v3 extensions
391 *
392 * TODO: Perform all of the basic constraints tests required by the RFC
393 * TODO: Set values for undetected extensions to a sane default?
394 *
395 */
396static int x509_get_crt_ext( unsigned char **p,
397 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200398 mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200399{
400 int ret;
401 size_t len;
402 unsigned char *end_ext_data, *end_ext_octet;
403
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200404 if( ( ret = mbedtls_x509_get_ext( p, end, &crt->v3_ext, 3 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200405 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200406 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200407 return( 0 );
408
409 return( ret );
410 }
411
412 while( *p < end )
413 {
414 /*
415 * Extension ::= SEQUENCE {
416 * extnID OBJECT IDENTIFIER,
417 * critical BOOLEAN DEFAULT FALSE,
418 * extnValue OCTET STRING }
419 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200420 mbedtls_x509_buf extn_oid = {0, 0, NULL};
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200421 int is_critical = 0; /* DEFAULT FALSE */
422 int ext_type = 0;
423
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200424 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
425 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
426 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200427
428 end_ext_data = *p + len;
429
430 /* Get extension ID */
431 extn_oid.tag = **p;
432
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200433 if( ( ret = mbedtls_asn1_get_tag( p, end, &extn_oid.len, MBEDTLS_ASN1_OID ) ) != 0 )
434 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200435
436 extn_oid.p = *p;
437 *p += extn_oid.len;
438
439 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200440 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
441 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200442
443 /* Get optional critical */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200444 if( ( ret = mbedtls_asn1_get_bool( p, end_ext_data, &is_critical ) ) != 0 &&
445 ( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
446 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200447
448 /* Data should be octet string type */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200449 if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,
450 MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
451 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200452
453 end_ext_octet = *p + len;
454
455 if( end_ext_octet != end_ext_data )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200456 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
457 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200458
459 /*
460 * Detect supported extensions
461 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200462 ret = mbedtls_oid_get_x509_ext_type( &extn_oid, &ext_type );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200463
464 if( ret != 0 )
465 {
466 /* No parser found, skip extension */
467 *p = end_ext_octet;
468
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200469#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200470 if( is_critical )
471 {
472 /* Data is marked as critical: fail */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200473 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
474 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200475 }
476#endif
477 continue;
478 }
479
Manuel Pégourié-Gonnard8a5e3d42014-11-12 17:47:28 +0100480 /* Forbid repeated extensions */
481 if( ( crt->ext_types & ext_type ) != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200482 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
Manuel Pégourié-Gonnard8a5e3d42014-11-12 17:47:28 +0100483
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200484 crt->ext_types |= ext_type;
485
486 switch( ext_type )
487 {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +0100488 case MBEDTLS_X509_EXT_BASIC_CONSTRAINTS:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200489 /* Parse basic constraints */
490 if( ( ret = x509_get_basic_constraints( p, end_ext_octet,
491 &crt->ca_istrue, &crt->max_pathlen ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200492 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200493 break;
494
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200495 case MBEDTLS_X509_EXT_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200496 /* Parse key usage */
497 if( ( ret = x509_get_key_usage( p, end_ext_octet,
498 &crt->key_usage ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200499 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200500 break;
501
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200502 case MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200503 /* Parse extended key usage */
504 if( ( ret = x509_get_ext_key_usage( p, end_ext_octet,
505 &crt->ext_key_usage ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200506 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200507 break;
508
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +0100509 case MBEDTLS_X509_EXT_SUBJECT_ALT_NAME:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200510 /* Parse subject alt name */
511 if( ( ret = x509_get_subject_alt_name( p, end_ext_octet,
512 &crt->subject_alt_names ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200513 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200514 break;
515
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200516 case MBEDTLS_X509_EXT_NS_CERT_TYPE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200517 /* Parse netscape certificate type */
518 if( ( ret = x509_get_ns_cert_type( p, end_ext_octet,
519 &crt->ns_cert_type ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200520 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200521 break;
522
523 default:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200524 return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200525 }
526 }
527
528 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200529 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
530 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200531
532 return( 0 );
533}
534
535/*
536 * Parse and fill a single X.509 certificate in DER format
537 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200538static int x509_crt_parse_der_core( mbedtls_x509_crt *crt, const unsigned char *buf,
Paul Bakkerddf26b42013-09-18 13:46:23 +0200539 size_t buflen )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200540{
541 int ret;
542 size_t len;
543 unsigned char *p, *end, *crt_end;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200544 mbedtls_x509_buf sig_params1, sig_params2, sig_oid2;
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100545
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200546 memset( &sig_params1, 0, sizeof( mbedtls_x509_buf ) );
547 memset( &sig_params2, 0, sizeof( mbedtls_x509_buf ) );
548 memset( &sig_oid2, 0, sizeof( mbedtls_x509_buf ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200549
550 /*
551 * Check for valid input
552 */
553 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200554 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200555
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200556 p = mbedtls_calloc( 1, len = buflen );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200557 if( p == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200558 return( MBEDTLS_ERR_X509_MALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200559
560 memcpy( p, buf, buflen );
561
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200562 crt->raw.p = p;
563 crt->raw.len = len;
564 end = p + len;
565
566 /*
567 * Certificate ::= SEQUENCE {
568 * tbsCertificate TBSCertificate,
569 * signatureAlgorithm AlgorithmIdentifier,
570 * signatureValue BIT STRING }
571 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200572 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
573 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200574 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200575 mbedtls_x509_crt_free( crt );
576 return( MBEDTLS_ERR_X509_INVALID_FORMAT );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200577 }
578
579 if( len > (size_t) ( end - p ) )
580 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200581 mbedtls_x509_crt_free( crt );
582 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
583 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200584 }
585 crt_end = p + len;
586
587 /*
588 * TBSCertificate ::= SEQUENCE {
589 */
590 crt->tbs.p = p;
591
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200592 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
593 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200594 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200595 mbedtls_x509_crt_free( crt );
596 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200597 }
598
599 end = p + len;
600 crt->tbs.len = end - crt->tbs.p;
601
602 /*
603 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
604 *
605 * CertificateSerialNumber ::= INTEGER
606 *
607 * signature AlgorithmIdentifier
608 */
609 if( ( ret = x509_get_version( &p, end, &crt->version ) ) != 0 ||
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200610 ( ret = mbedtls_x509_get_serial( &p, end, &crt->serial ) ) != 0 ||
611 ( ret = mbedtls_x509_get_alg( &p, end, &crt->sig_oid,
Manuel Pégourié-Gonnarddddbb1d2014-06-05 17:02:24 +0200612 &sig_params1 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200613 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200614 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200615 return( ret );
616 }
617
618 crt->version++;
619
620 if( crt->version > 3 )
621 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200622 mbedtls_x509_crt_free( crt );
623 return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200624 }
625
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200626 if( ( ret = mbedtls_x509_get_sig_alg( &crt->sig_oid, &sig_params1,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200627 &crt->sig_md, &crt->sig_pk,
628 &crt->sig_opts ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200629 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200630 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200631 return( ret );
632 }
633
634 /*
635 * issuer Name
636 */
637 crt->issuer_raw.p = p;
638
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200639 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
640 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200641 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200642 mbedtls_x509_crt_free( crt );
643 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200644 }
645
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200646 if( ( ret = mbedtls_x509_get_name( &p, p + len, &crt->issuer ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200647 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200648 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200649 return( ret );
650 }
651
652 crt->issuer_raw.len = p - crt->issuer_raw.p;
653
654 /*
655 * Validity ::= SEQUENCE {
656 * notBefore Time,
657 * notAfter Time }
658 *
659 */
660 if( ( ret = x509_get_dates( &p, end, &crt->valid_from,
661 &crt->valid_to ) ) != 0 )
662 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200663 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200664 return( ret );
665 }
666
667 /*
668 * subject Name
669 */
670 crt->subject_raw.p = p;
671
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200672 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
673 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200674 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200675 mbedtls_x509_crt_free( crt );
676 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200677 }
678
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200679 if( len && ( ret = mbedtls_x509_get_name( &p, p + len, &crt->subject ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200680 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200681 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200682 return( ret );
683 }
684
685 crt->subject_raw.len = p - crt->subject_raw.p;
686
687 /*
688 * SubjectPublicKeyInfo
689 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200690 if( ( ret = mbedtls_pk_parse_subpubkey( &p, end, &crt->pk ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200691 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200692 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200693 return( ret );
694 }
695
696 /*
697 * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
698 * -- If present, version shall be v2 or v3
699 * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
700 * -- If present, version shall be v2 or v3
701 * extensions [3] EXPLICIT Extensions OPTIONAL
702 * -- If present, version shall be v3
703 */
704 if( crt->version == 2 || crt->version == 3 )
705 {
706 ret = x509_get_uid( &p, end, &crt->issuer_id, 1 );
707 if( ret != 0 )
708 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200709 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200710 return( ret );
711 }
712 }
713
714 if( crt->version == 2 || crt->version == 3 )
715 {
716 ret = x509_get_uid( &p, end, &crt->subject_id, 2 );
717 if( ret != 0 )
718 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200719 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200720 return( ret );
721 }
722 }
723
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200724#if !defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200725 if( crt->version == 3 )
Paul Bakkerc27c4e22013-09-23 15:01:36 +0200726#endif
Manuel Pégourié-Gonnarda252af72015-03-27 16:15:55 +0100727 {
Paul Bakker66d5d072014-06-17 16:39:18 +0200728 ret = x509_get_crt_ext( &p, end, crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200729 if( ret != 0 )
730 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200731 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200732 return( ret );
733 }
734 }
735
736 if( p != end )
737 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200738 mbedtls_x509_crt_free( crt );
739 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
740 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200741 }
742
743 end = crt_end;
744
745 /*
746 * }
747 * -- end of TBSCertificate
748 *
749 * signatureAlgorithm AlgorithmIdentifier,
750 * signatureValue BIT STRING
751 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200752 if( ( ret = mbedtls_x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200753 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200754 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200755 return( ret );
756 }
757
Manuel Pégourié-Gonnard1022fed2015-03-27 16:30:47 +0100758 if( crt->sig_oid.len != sig_oid2.len ||
759 memcmp( crt->sig_oid.p, sig_oid2.p, crt->sig_oid.len ) != 0 ||
Manuel Pégourié-Gonnarddddbb1d2014-06-05 17:02:24 +0200760 sig_params1.len != sig_params2.len ||
Manuel Pégourié-Gonnard159c5242015-04-30 11:15:22 +0200761 ( sig_params1.len != 0 &&
762 memcmp( sig_params1.p, sig_params2.p, sig_params1.len ) != 0 ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200763 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200764 mbedtls_x509_crt_free( crt );
765 return( MBEDTLS_ERR_X509_SIG_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200766 }
767
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200768 if( ( ret = mbedtls_x509_get_sig( &p, end, &crt->sig ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200769 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200770 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200771 return( ret );
772 }
773
774 if( p != end )
775 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200776 mbedtls_x509_crt_free( crt );
777 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
778 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200779 }
780
781 return( 0 );
782}
783
784/*
785 * Parse one X.509 certificate in DER format from a buffer and add them to a
786 * chained list
787 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200788int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain, const unsigned char *buf,
Paul Bakkerddf26b42013-09-18 13:46:23 +0200789 size_t buflen )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200790{
791 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200792 mbedtls_x509_crt *crt = chain, *prev = NULL;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200793
794 /*
795 * Check for valid input
796 */
797 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200798 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200799
800 while( crt->version != 0 && crt->next != NULL )
801 {
802 prev = crt;
803 crt = crt->next;
804 }
805
806 /*
807 * Add new certificate on the end of the chain if needed.
808 */
Paul Bakker66d5d072014-06-17 16:39:18 +0200809 if( crt->version != 0 && crt->next == NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200810 {
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200811 crt->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200812
813 if( crt->next == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200814 return( MBEDTLS_ERR_X509_MALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200815
816 prev = crt;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200817 mbedtls_x509_crt_init( crt->next );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200818 crt = crt->next;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200819 }
820
Paul Bakkerddf26b42013-09-18 13:46:23 +0200821 if( ( ret = x509_crt_parse_der_core( crt, buf, buflen ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200822 {
823 if( prev )
824 prev->next = NULL;
825
826 if( crt != chain )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200827 mbedtls_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200828
829 return( ret );
830 }
831
832 return( 0 );
833}
834
835/*
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +0200836 * Parse one or more PEM certificates from a buffer and add them to the chained
837 * list
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200838 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200839int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain, const unsigned char *buf, size_t buflen )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200840{
841 int success = 0, first_error = 0, total_failed = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200842 int buf_format = MBEDTLS_X509_FORMAT_DER;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200843
844 /*
845 * Check for valid input
846 */
847 if( chain == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200848 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200849
850 /*
851 * Determine buffer content. Buffer contains either one DER certificate or
852 * one or more PEM certificates.
853 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200854#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard0ece0f92015-05-12 12:43:54 +0200855 if( buflen != 0 && buf[buflen - 1] == '\0' &&
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +0200856 strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
857 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200858 buf_format = MBEDTLS_X509_FORMAT_PEM;
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +0200859 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200860#endif
861
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200862 if( buf_format == MBEDTLS_X509_FORMAT_DER )
863 return mbedtls_x509_crt_parse_der( chain, buf, buflen );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200864
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200865#if defined(MBEDTLS_PEM_PARSE_C)
866 if( buf_format == MBEDTLS_X509_FORMAT_PEM )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200867 {
868 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200869 mbedtls_pem_context pem;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200870
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +0200871 /* 1 rather than 0 since the terminating NULL byte is counted in */
872 while( buflen > 1 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200873 {
874 size_t use_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200875 mbedtls_pem_init( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200876
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +0200877 /* If we get there, we know the string is null-terminated */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200878 ret = mbedtls_pem_read_buffer( &pem,
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200879 "-----BEGIN CERTIFICATE-----",
880 "-----END CERTIFICATE-----",
881 buf, NULL, 0, &use_len );
882
883 if( ret == 0 )
884 {
885 /*
886 * Was PEM encoded
887 */
888 buflen -= use_len;
889 buf += use_len;
890 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200891 else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200892 {
893 return( ret );
894 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200895 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200896 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200897 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200898
899 /*
900 * PEM header and footer were found
901 */
902 buflen -= use_len;
903 buf += use_len;
904
905 if( first_error == 0 )
906 first_error = ret;
907
Paul Bakker5a5fa922014-09-26 14:53:04 +0200908 total_failed++;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200909 continue;
910 }
911 else
912 break;
913
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200914 ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200915
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200916 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200917
918 if( ret != 0 )
919 {
920 /*
921 * Quit parsing on a memory error
922 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200923 if( ret == MBEDTLS_ERR_X509_MALLOC_FAILED )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200924 return( ret );
925
926 if( first_error == 0 )
927 first_error = ret;
928
929 total_failed++;
930 continue;
931 }
932
933 success = 1;
934 }
935 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200936#endif /* MBEDTLS_PEM_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200937
938 if( success )
939 return( total_failed );
940 else if( first_error )
941 return( first_error );
942 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200943 return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200944}
945
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200946#if defined(MBEDTLS_FS_IO)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200947/*
948 * Load one or more certificates and add them to the chained list
949 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200950int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200951{
952 int ret;
953 size_t n;
954 unsigned char *buf;
955
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200956 if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200957 return( ret );
958
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200959 ret = mbedtls_x509_crt_parse( chain, buf, n );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200960
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +0200961 mbedtls_zeroize( buf, n );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200962 mbedtls_free( buf );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200963
964 return( ret );
965}
966
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200967#if defined(MBEDTLS_THREADING_PTHREAD)
Manuel Pégourié-Gonnard1e2eae02015-04-29 01:26:03 +0200968static mbedtls_threading_mutex_t readdir_mutex = {
969 PTHREAD_MUTEX_INITIALIZER,
970 1
971};
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +0100972#endif
973
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200974int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200975{
976 int ret = 0;
Paul Bakkerfa6a6202013-10-28 18:48:30 +0100977#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200978 int w_ret;
979 WCHAR szDir[MAX_PATH];
980 char filename[MAX_PATH];
Paul Bakker9af723c2014-05-01 13:03:14 +0200981 char *p;
Paul Bakkerb9cfaa02013-10-11 18:58:55 +0200982 int len = (int) strlen( path );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200983
Paul Bakker9af723c2014-05-01 13:03:14 +0200984 WIN32_FIND_DATAW file_data;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200985 HANDLE hFind;
986
987 if( len > MAX_PATH - 3 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200988 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200989
Paul Bakker9af723c2014-05-01 13:03:14 +0200990 memset( szDir, 0, sizeof(szDir) );
991 memset( filename, 0, MAX_PATH );
992 memcpy( filename, path, len );
993 filename[len++] = '\\';
994 p = filename + len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200995 filename[len++] = '*';
996
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +0200997 w_ret = MultiByteToWideChar( CP_ACP, 0, filename, len, szDir,
998 MAX_PATH - 3 );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +0000999 if( w_ret == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001000 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001001
1002 hFind = FindFirstFileW( szDir, &file_data );
Paul Bakker66d5d072014-06-17 16:39:18 +02001003 if( hFind == INVALID_HANDLE_VALUE )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001004 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001005
1006 len = MAX_PATH - len;
1007 do
1008 {
Paul Bakker9af723c2014-05-01 13:03:14 +02001009 memset( p, 0, len );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001010
1011 if( file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
1012 continue;
1013
Paul Bakker9af723c2014-05-01 13:03:14 +02001014 w_ret = WideCharToMultiByte( CP_ACP, 0, file_data.cFileName,
Paul Bakker66d5d072014-06-17 16:39:18 +02001015 lstrlenW( file_data.cFileName ),
Paul Bakker9af723c2014-05-01 13:03:14 +02001016 p, len - 1,
1017 NULL, NULL );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +00001018 if( w_ret == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001019 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001020
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001021 w_ret = mbedtls_x509_crt_parse_file( chain, filename );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001022 if( w_ret < 0 )
1023 ret++;
1024 else
1025 ret += w_ret;
1026 }
1027 while( FindNextFileW( hFind, &file_data ) != 0 );
1028
Paul Bakker66d5d072014-06-17 16:39:18 +02001029 if( GetLastError() != ERROR_NO_MORE_FILES )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001030 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001031
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001032 FindClose( hFind );
Paul Bakkerbe089b02013-10-14 15:51:50 +02001033#else /* _WIN32 */
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001034 int t_ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001035 struct stat sb;
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001036 struct dirent *entry;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001037 char entry_name[255];
1038 DIR *dir = opendir( path );
1039
Paul Bakker66d5d072014-06-17 16:39:18 +02001040 if( dir == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001041 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001042
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001043#if defined(MBEDTLS_THREADING_PTHREAD)
1044 if( ( ret = mbedtls_mutex_lock( &readdir_mutex ) ) != 0 )
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001045 return( ret );
1046#endif
1047
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001048 while( ( entry = readdir( dir ) ) != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001049 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001050 mbedtls_snprintf( entry_name, sizeof entry_name, "%s/%s", path, entry->d_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001051
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001052 if( stat( entry_name, &sb ) == -1 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001053 {
1054 closedir( dir );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001055 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001056 goto cleanup;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001057 }
1058
1059 if( !S_ISREG( sb.st_mode ) )
1060 continue;
1061
1062 // Ignore parse errors
1063 //
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001064 t_ret = mbedtls_x509_crt_parse_file( chain, entry_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001065 if( t_ret < 0 )
1066 ret++;
1067 else
1068 ret += t_ret;
1069 }
1070 closedir( dir );
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001071
1072cleanup:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001073#if defined(MBEDTLS_THREADING_PTHREAD)
1074 if( mbedtls_mutex_unlock( &readdir_mutex ) != 0 )
1075 ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001076#endif
1077
Paul Bakkerbe089b02013-10-14 15:51:50 +02001078#endif /* _WIN32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001079
1080 return( ret );
1081}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001082#endif /* MBEDTLS_FS_IO */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001083
Paul Bakker6edcd412013-10-29 15:22:54 +01001084#if defined(_MSC_VER) && !defined snprintf && !defined(EFIX64) && \
1085 !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001086#include <stdarg.h>
1087
1088#if !defined vsnprintf
1089#define vsnprintf _vsnprintf
1090#endif // vsnprintf
1091
1092/*
1093 * Windows _snprintf and _vsnprintf are not compatible to linux versions.
1094 * Result value is not size of buffer needed, but -1 if no fit is possible.
1095 *
1096 * This fuction tries to 'fix' this by at least suggesting enlarging the
1097 * size by 20.
1098 */
Paul Bakker66d5d072014-06-17 16:39:18 +02001099static int compat_snprintf( char *str, size_t size, const char *format, ... )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001100{
1101 va_list ap;
1102 int res = -1;
1103
1104 va_start( ap, format );
1105
1106 res = vsnprintf( str, size, format, ap );
1107
1108 va_end( ap );
1109
1110 // No quick fix possible
Paul Bakker66d5d072014-06-17 16:39:18 +02001111 if( res < 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001112 return( (int) size + 20 );
1113
Paul Bakkerd8bb8262014-06-17 14:06:49 +02001114 return( res );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001115}
1116
1117#define snprintf compat_snprintf
Paul Bakker9af723c2014-05-01 13:03:14 +02001118#endif /* _MSC_VER && !snprintf && !EFIX64 && !EFI32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001119
Manuel Pégourié-Gonnard8408a942015-04-09 12:14:31 +02001120#define ERR_BUF_TOO_SMALL -2
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001121
Paul Bakkerd8bb8262014-06-17 14:06:49 +02001122#define SAFE_SNPRINTF() \
1123{ \
1124 if( ret == -1 ) \
1125 return( -1 ); \
1126 \
Paul Bakker66d5d072014-06-17 16:39:18 +02001127 if( (unsigned int) ret > n ) { \
Paul Bakkerd8bb8262014-06-17 14:06:49 +02001128 p[n - 1] = '\0'; \
Manuel Pégourié-Gonnard8408a942015-04-09 12:14:31 +02001129 return( ERR_BUF_TOO_SMALL ); \
Paul Bakkerd8bb8262014-06-17 14:06:49 +02001130 } \
1131 \
1132 n -= (unsigned int) ret; \
1133 p += (unsigned int) ret; \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001134}
1135
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001136static int x509_info_subject_alt_name( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001137 const mbedtls_x509_sequence *subject_alt_name )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001138{
1139 size_t i;
1140 size_t n = *size;
1141 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001142 const mbedtls_x509_sequence *cur = subject_alt_name;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001143 const char *sep = "";
1144 size_t sep_len = 0;
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001145
1146 while( cur != NULL )
1147 {
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001148 if( cur->buf.len + sep_len >= n )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001149 {
1150 *p = '\0';
Manuel Pégourié-Gonnard8408a942015-04-09 12:14:31 +02001151 return( ERR_BUF_TOO_SMALL );
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001152 }
1153
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001154 n -= cur->buf.len + sep_len;
1155 for( i = 0; i < sep_len; i++ )
1156 *p++ = sep[i];
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001157 for( i = 0; i < cur->buf.len; i++ )
1158 *p++ = cur->buf.p[i];
1159
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001160 sep = ", ";
1161 sep_len = 2;
1162
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001163 cur = cur->next;
1164 }
1165
1166 *p = '\0';
1167
1168 *size = n;
1169 *buf = p;
1170
1171 return( 0 );
1172}
1173
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001174#define PRINT_ITEM(i) \
1175 { \
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001176 ret = mbedtls_snprintf( p, n, "%s" i, sep ); \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001177 SAFE_SNPRINTF(); \
1178 sep = ", "; \
1179 }
1180
1181#define CERT_TYPE(type,name) \
1182 if( ns_cert_type & type ) \
1183 PRINT_ITEM( name );
1184
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001185static int x509_info_cert_type( char **buf, size_t *size,
1186 unsigned char ns_cert_type )
1187{
1188 int ret;
1189 size_t n = *size;
1190 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001191 const char *sep = "";
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001192
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001193 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001194 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001195 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL, "Email" );
1196 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
1197 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_RESERVED, "Reserved" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001198 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CA, "SSL CA" );
1199 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL_CA, "Email CA" );
1200 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001201
1202 *size = n;
1203 *buf = p;
1204
1205 return( 0 );
1206}
1207
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001208#define KEY_USAGE(code,name) \
1209 if( key_usage & code ) \
1210 PRINT_ITEM( name );
1211
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001212static int x509_info_key_usage( char **buf, size_t *size,
1213 unsigned char key_usage )
1214{
1215 int ret;
1216 size_t n = *size;
1217 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001218 const char *sep = "";
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001219
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001220 KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
1221 KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001222 KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
1223 KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
1224 KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001225 KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
1226 KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001227
1228 *size = n;
1229 *buf = p;
1230
1231 return( 0 );
1232}
1233
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001234static int x509_info_ext_key_usage( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001235 const mbedtls_x509_sequence *extended_key_usage )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001236{
1237 int ret;
1238 const char *desc;
1239 size_t n = *size;
1240 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001241 const mbedtls_x509_sequence *cur = extended_key_usage;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001242 const char *sep = "";
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001243
1244 while( cur != NULL )
1245 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001246 if( mbedtls_oid_get_extended_key_usage( &cur->buf, &desc ) != 0 )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001247 desc = "???";
1248
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001249 ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001250 SAFE_SNPRINTF();
1251
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001252 sep = ", ";
1253
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001254 cur = cur->next;
1255 }
1256
1257 *size = n;
1258 *buf = p;
1259
1260 return( 0 );
1261}
1262
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001263/*
1264 * Return an informational string about the certificate.
1265 */
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001266#define BEFORE_COLON 18
1267#define BC "18"
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001268int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
1269 const mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001270{
1271 int ret;
1272 size_t n;
1273 char *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001274 char key_size_str[BEFORE_COLON];
1275
1276 p = buf;
1277 n = size;
1278
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001279 ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001280 prefix, crt->version );
1281 SAFE_SNPRINTF();
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001282 ret = mbedtls_snprintf( p, n, "%sserial number : ",
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001283 prefix );
1284 SAFE_SNPRINTF();
1285
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001286 ret = mbedtls_x509_serial_gets( p, n, &crt->serial );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001287 SAFE_SNPRINTF();
1288
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001289 ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001290 SAFE_SNPRINTF();
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001291 ret = mbedtls_x509_dn_gets( p, n, &crt->issuer );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001292 SAFE_SNPRINTF();
1293
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001294 ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001295 SAFE_SNPRINTF();
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001296 ret = mbedtls_x509_dn_gets( p, n, &crt->subject );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001297 SAFE_SNPRINTF();
1298
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001299 ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001300 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
1301 crt->valid_from.year, crt->valid_from.mon,
1302 crt->valid_from.day, crt->valid_from.hour,
1303 crt->valid_from.min, crt->valid_from.sec );
1304 SAFE_SNPRINTF();
1305
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001306 ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001307 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
1308 crt->valid_to.year, crt->valid_to.mon,
1309 crt->valid_to.day, crt->valid_to.hour,
1310 crt->valid_to.min, crt->valid_to.sec );
1311 SAFE_SNPRINTF();
1312
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001313 ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001314 SAFE_SNPRINTF();
1315
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001316 ret = mbedtls_x509_sig_alg_gets( p, n, &crt->sig_oid, crt->sig_pk,
Manuel Pégourié-Gonnardbf696d02014-06-05 17:07:30 +02001317 crt->sig_md, crt->sig_opts );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001318 SAFE_SNPRINTF();
1319
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001320 /* Key size */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001321 if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
1322 mbedtls_pk_get_name( &crt->pk ) ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001323 {
1324 return( ret );
1325 }
1326
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001327 ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
1328 (int) mbedtls_pk_get_size( &crt->pk ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001329 SAFE_SNPRINTF();
1330
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001331 /*
1332 * Optional extensions
1333 */
1334
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001335 if( crt->ext_types & MBEDTLS_X509_EXT_BASIC_CONSTRAINTS )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001336 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001337 ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001338 crt->ca_istrue ? "true" : "false" );
1339 SAFE_SNPRINTF();
1340
1341 if( crt->max_pathlen > 0 )
1342 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001343 ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", crt->max_pathlen - 1 );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001344 SAFE_SNPRINTF();
1345 }
1346 }
1347
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001348 if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001349 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001350 ret = mbedtls_snprintf( p, n, "\n%ssubject alt name : ", prefix );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001351 SAFE_SNPRINTF();
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001352
1353 if( ( ret = x509_info_subject_alt_name( &p, &n,
1354 &crt->subject_alt_names ) ) != 0 )
1355 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001356 }
1357
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001358 if( crt->ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001359 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001360 ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001361 SAFE_SNPRINTF();
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001362
1363 if( ( ret = x509_info_cert_type( &p, &n, crt->ns_cert_type ) ) != 0 )
1364 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001365 }
1366
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001367 if( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001368 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001369 ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001370 SAFE_SNPRINTF();
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001371
1372 if( ( ret = x509_info_key_usage( &p, &n, crt->key_usage ) ) != 0 )
1373 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001374 }
1375
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001376 if( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001377 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001378 ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001379 SAFE_SNPRINTF();
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001380
1381 if( ( ret = x509_info_ext_key_usage( &p, &n,
1382 &crt->ext_key_usage ) ) != 0 )
1383 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001384 }
1385
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001386 ret = mbedtls_snprintf( p, n, "\n" );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001387 SAFE_SNPRINTF();
1388
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001389 return( (int) ( size - n ) );
1390}
1391
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001392struct x509_crt_verify_string {
1393 int code;
1394 const char *string;
1395};
1396
1397static const struct x509_crt_verify_string x509_crt_verify_strings[] = {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001398 { MBEDTLS_X509_BADCERT_EXPIRED, "The certificate validity has expired" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001399 { MBEDTLS_X509_BADCERT_REVOKED, "The certificate has been revoked (is on a CRL)" },
1400 { MBEDTLS_X509_BADCERT_CN_MISMATCH, "The certificate Common Name (CN) does not match with the expected CN" },
1401 { MBEDTLS_X509_BADCERT_NOT_TRUSTED, "The certificate is not correctly signed by the trusted CA" },
1402 { MBEDTLS_X509_BADCRL_NOT_TRUSTED, "The CRL is not correctly signed by the trusted CA" },
1403 { MBEDTLS_X509_BADCRL_EXPIRED, "The CRL is expired" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001404 { MBEDTLS_X509_BADCERT_MISSING, "Certificate was missing" },
1405 { MBEDTLS_X509_BADCERT_SKIP_VERIFY, "Certificate verification was skipped" },
1406 { MBEDTLS_X509_BADCERT_OTHER, "Other reason (can be used by verify callback)" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001407 { MBEDTLS_X509_BADCERT_FUTURE, "The certificate validity starts in the future" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001408 { MBEDTLS_X509_BADCRL_FUTURE, "The CRL is from the future" },
1409 { MBEDTLS_X509_BADCERT_KEY_USAGE, "Usage does not match the keyUsage extension" },
1410 { MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, "Usage does not match the extendedKeyUsage extension" },
1411 { MBEDTLS_X509_BADCERT_NS_CERT_TYPE, "Usage does not match the nsCertType extension" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001412 { 0, NULL }
1413};
1414
1415int mbedtls_x509_crt_verify_info( char *buf, size_t size, const char *prefix,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001416 uint32_t flags )
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001417{
1418 int ret;
1419 const struct x509_crt_verify_string *cur;
1420 char *p = buf;
1421 size_t n = size;
1422
1423 for( cur = x509_crt_verify_strings; cur->string != NULL ; cur++ )
1424 {
1425 if( ( flags & cur->code ) == 0 )
1426 continue;
1427
1428 ret = mbedtls_snprintf( p, n, "%s%s\n", prefix, cur->string );
1429 SAFE_SNPRINTF();
1430 flags ^= cur->code;
1431 }
1432
1433 if( flags != 0 )
1434 {
1435 ret = mbedtls_snprintf( p, n, "%sUnknown reason "
1436 "(this should not happen)\n", prefix );
1437 SAFE_SNPRINTF();
1438 }
1439
1440 return( (int) ( size - n ) );
1441}
1442
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001443#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
1444int mbedtls_x509_crt_check_key_usage( const mbedtls_x509_crt *crt, unsigned int usage )
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02001445{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001446 if( ( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE ) != 0 &&
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02001447 ( crt->key_usage & usage ) != usage )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001448 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02001449
1450 return( 0 );
1451}
1452#endif
1453
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001454#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
1455int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001456 const char *usage_oid,
1457 size_t usage_len )
1458{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001459 const mbedtls_x509_sequence *cur;
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001460
1461 /* Extension is not mandatory, absent means no restriction */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001462 if( ( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001463 return( 0 );
1464
1465 /*
1466 * Look for the requested usage (or wildcard ANY) in our list
1467 */
1468 for( cur = &crt->ext_key_usage; cur != NULL; cur = cur->next )
1469 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001470 const mbedtls_x509_buf *cur_oid = &cur->buf;
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001471
1472 if( cur_oid->len == usage_len &&
1473 memcmp( cur_oid->p, usage_oid, usage_len ) == 0 )
1474 {
1475 return( 0 );
1476 }
1477
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001478 if( MBEDTLS_OID_CMP( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE, cur_oid ) == 0 )
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001479 return( 0 );
1480 }
1481
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001482 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001483}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001484#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001485
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001486#if defined(MBEDTLS_X509_CRL_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001487/*
1488 * Return 1 if the certificate is revoked, or 0 otherwise.
1489 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001490int mbedtls_x509_crt_revoked( const mbedtls_x509_crt *crt, const mbedtls_x509_crl *crl )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001491{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001492 const mbedtls_x509_crl_entry *cur = &crl->entry;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001493
1494 while( cur != NULL && cur->serial.len != 0 )
1495 {
1496 if( crt->serial.len == cur->serial.len &&
1497 memcmp( crt->serial.p, cur->serial.p, crt->serial.len ) == 0 )
1498 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001499 if( mbedtls_x509_time_expired( &cur->revocation_date ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001500 return( 1 );
1501 }
1502
1503 cur = cur->next;
1504 }
1505
1506 return( 0 );
1507}
1508
1509/*
Paul Bakker60b1d102013-10-29 10:02:51 +01001510 * Check that the given certificate is valid according to the CRL.
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001511 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001512static int x509_crt_verifycrl( mbedtls_x509_crt *crt, mbedtls_x509_crt *ca,
1513 mbedtls_x509_crl *crl_list)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001514{
1515 int flags = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001516 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
1517 const mbedtls_md_info_t *md_info;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001518
1519 if( ca == NULL )
1520 return( flags );
1521
1522 /*
1523 * TODO: What happens if no CRL is present?
1524 * Suggestion: Revocation state should be unknown if no CRL is present.
1525 * For backwards compatibility this is not yet implemented.
1526 */
1527
1528 while( crl_list != NULL )
1529 {
1530 if( crl_list->version == 0 ||
1531 crl_list->issuer_raw.len != ca->subject_raw.len ||
1532 memcmp( crl_list->issuer_raw.p, ca->subject_raw.p,
1533 crl_list->issuer_raw.len ) != 0 )
1534 {
1535 crl_list = crl_list->next;
1536 continue;
1537 }
1538
1539 /*
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02001540 * Check if the CA is configured to sign CRLs
1541 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001542#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
1543 if( mbedtls_x509_crt_check_key_usage( ca, MBEDTLS_X509_KU_CRL_SIGN ) != 0 )
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02001544 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001545 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02001546 break;
1547 }
1548#endif
1549
1550 /*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001551 * Check if CRL is correctly signed by the trusted CA
1552 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001553 md_info = mbedtls_md_info_from_type( crl_list->sig_md );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001554 if( md_info == NULL )
1555 {
1556 /*
1557 * Cannot check 'unknown' hash
1558 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001559 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001560 break;
1561 }
1562
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001563 mbedtls_md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001564
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001565 if( mbedtls_pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, &ca->pk,
1566 crl_list->sig_md, hash, mbedtls_md_get_size( md_info ),
Manuel Pégourié-Gonnard53882022014-06-05 17:53:52 +02001567 crl_list->sig.p, crl_list->sig.len ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001568 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001569 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001570 break;
1571 }
1572
1573 /*
1574 * Check for validity of CRL (Do not drop out)
1575 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001576 if( mbedtls_x509_time_expired( &crl_list->next_update ) )
1577 flags |= MBEDTLS_X509_BADCRL_EXPIRED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001578
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001579 if( mbedtls_x509_time_future( &crl_list->this_update ) )
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001580 flags |= MBEDTLS_X509_BADCRL_FUTURE;
Manuel Pégourié-Gonnard95337652014-03-10 13:15:18 +01001581
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001582 /*
1583 * Check if certificate is revoked
1584 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001585 if( mbedtls_x509_crt_revoked( crt, crl_list ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001586 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001587 flags |= MBEDTLS_X509_BADCERT_REVOKED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001588 break;
1589 }
1590
1591 crl_list = crl_list->next;
1592 }
Paul Bakkerd8bb8262014-06-17 14:06:49 +02001593 return( flags );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001594}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001595#endif /* MBEDTLS_X509_CRL_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001596
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02001597/*
1598 * Like memcmp, but case-insensitive and always returns -1 if different
1599 */
1600static int x509_memcasecmp( const void *s1, const void *s2, size_t len )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001601{
1602 size_t i;
1603 unsigned char diff;
1604 const unsigned char *n1 = s1, *n2 = s2;
1605
1606 for( i = 0; i < len; i++ )
1607 {
1608 diff = n1[i] ^ n2[i];
1609
Paul Bakkerf2b4d862013-11-20 17:23:53 +01001610 if( diff == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001611 continue;
1612
Paul Bakkerf2b4d862013-11-20 17:23:53 +01001613 if( diff == 32 &&
1614 ( ( n1[i] >= 'a' && n1[i] <= 'z' ) ||
1615 ( n1[i] >= 'A' && n1[i] <= 'Z' ) ) )
1616 {
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001617 continue;
Paul Bakkerf2b4d862013-11-20 17:23:53 +01001618 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001619
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02001620 return( -1 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001621 }
1622
1623 return( 0 );
1624}
1625
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02001626/*
1627 * Return 1 if match, 0 if not
1628 * TODO: inverted return value!
1629 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001630static int x509_wildcard_verify( const char *cn, mbedtls_x509_buf *name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001631{
1632 size_t i;
Paul Bakker14b16c62014-05-28 11:33:54 +02001633 size_t cn_idx = 0, cn_len = strlen( cn );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001634
1635 if( name->len < 3 || name->p[0] != '*' || name->p[1] != '.' )
1636 return( 0 );
1637
Paul Bakker14b16c62014-05-28 11:33:54 +02001638 for( i = 0; i < cn_len; ++i )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001639 {
1640 if( cn[i] == '.' )
1641 {
1642 cn_idx = i;
1643 break;
1644 }
1645 }
1646
1647 if( cn_idx == 0 )
1648 return( 0 );
1649
Paul Bakker14b16c62014-05-28 11:33:54 +02001650 if( cn_len - cn_idx == name->len - 1 &&
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02001651 x509_memcasecmp( name->p + 1, cn + cn_idx, name->len - 1 ) == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001652 {
1653 return( 1 );
1654 }
1655
1656 return( 0 );
1657}
1658
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001659/*
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001660 * Compare two X.509 strings, case-insensitive, and allowing for some encoding
1661 * variations (but not all).
1662 *
1663 * Return 0 if equal, -1 otherwise.
1664 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001665static int x509_string_cmp( const mbedtls_x509_buf *a, const mbedtls_x509_buf *b )
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001666{
1667 if( a->tag == b->tag &&
1668 a->len == b->len &&
1669 memcmp( a->p, b->p, b->len ) == 0 )
1670 {
1671 return( 0 );
1672 }
1673
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001674 if( ( a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
1675 ( b->tag == MBEDTLS_ASN1_UTF8_STRING || b->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001676 a->len == b->len &&
1677 x509_memcasecmp( a->p, b->p, b->len ) == 0 )
1678 {
1679 return( 0 );
1680 }
1681
1682 return( -1 );
1683}
1684
1685/*
1686 * Compare two X.509 Names (aka rdnSequence).
1687 *
1688 * See RFC 5280 section 7.1, though we don't implement the whole algorithm:
1689 * we sometimes return unequal when the full algorithm would return equal,
1690 * but never the other way. (In particular, we don't do Unicode normalisation
1691 * or space folding.)
1692 *
1693 * Return 0 if equal, -1 otherwise.
1694 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001695static int x509_name_cmp( const mbedtls_x509_name *a, const mbedtls_x509_name *b )
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001696{
Manuel Pégourié-Gonnardf631bbc2014-11-12 18:35:31 +01001697 /* Avoid recursion, it might not be optimised by the compiler */
1698 while( a != NULL || b != NULL )
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001699 {
Manuel Pégourié-Gonnardf631bbc2014-11-12 18:35:31 +01001700 if( a == NULL || b == NULL )
1701 return( -1 );
1702
1703 /* type */
1704 if( a->oid.tag != b->oid.tag ||
1705 a->oid.len != b->oid.len ||
1706 memcmp( a->oid.p, b->oid.p, b->oid.len ) != 0 )
1707 {
1708 return( -1 );
1709 }
1710
1711 /* value */
1712 if( x509_string_cmp( &a->val, &b->val ) != 0 )
1713 return( -1 );
1714
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +00001715 /* structure of the list of sets */
1716 if( a->next_merged != b->next_merged )
1717 return( -1 );
1718
Manuel Pégourié-Gonnardf631bbc2014-11-12 18:35:31 +01001719 a = a->next;
1720 b = b->next;
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001721 }
1722
Manuel Pégourié-Gonnardf631bbc2014-11-12 18:35:31 +01001723 /* a == NULL == b */
1724 return( 0 );
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001725}
1726
1727/*
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001728 * Check if 'parent' is a suitable parent (signing CA) for 'child'.
1729 * Return 0 if yes, -1 if not.
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001730 *
1731 * top means parent is a locally-trusted certificate
1732 * bottom means child is the end entity cert
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001733 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001734static int x509_crt_check_parent( const mbedtls_x509_crt *child,
1735 const mbedtls_x509_crt *parent,
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001736 int top, int bottom )
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001737{
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001738 int need_ca_bit;
1739
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02001740 /* Parent must be the issuer */
Manuel Pégourié-Gonnardef9a6ae2014-10-17 12:25:12 +02001741 if( x509_name_cmp( &child->issuer, &parent->subject ) != 0 )
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001742 return( -1 );
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001743
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001744 /* Parent must have the basicConstraints CA bit set as a general rule */
1745 need_ca_bit = 1;
1746
1747 /* Exception: v1/v2 certificates that are locally trusted. */
1748 if( top && parent->version < 3 )
1749 need_ca_bit = 0;
1750
1751 /* Exception: self-signed end-entity certs that are locally trusted. */
1752 if( top && bottom &&
1753 child->raw.len == parent->raw.len &&
1754 memcmp( child->raw.p, parent->raw.p, child->raw.len ) == 0 )
1755 {
1756 need_ca_bit = 0;
1757 }
1758
1759 if( need_ca_bit && ! parent->ca_istrue )
1760 return( -1 );
1761
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001762#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001763 if( need_ca_bit &&
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001764 mbedtls_x509_crt_check_key_usage( parent, MBEDTLS_X509_KU_KEY_CERT_SIGN ) != 0 )
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02001765 {
1766 return( -1 );
1767 }
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001768#endif
1769
1770 return( 0 );
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001771}
1772
Paul Bakkerddf26b42013-09-18 13:46:23 +02001773static int x509_crt_verify_top(
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001774 mbedtls_x509_crt *child, mbedtls_x509_crt *trust_ca,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001775 mbedtls_x509_crl *ca_crl, int path_cnt, uint32_t *flags,
1776 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001777 void *p_vrfy )
1778{
1779 int ret;
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001780 uint32_t ca_flags = 0;
1781 int check_path_cnt = path_cnt + 1;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001782 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
1783 const mbedtls_md_info_t *md_info;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001784
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001785 if( mbedtls_x509_time_expired( &child->valid_to ) )
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001786 *flags |= MBEDTLS_X509_BADCERT_EXPIRED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001787
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001788 if( mbedtls_x509_time_future( &child->valid_from ) )
1789 *flags |= MBEDTLS_X509_BADCERT_FUTURE;
Manuel Pégourié-Gonnard95337652014-03-10 13:15:18 +01001790
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001791 /*
1792 * Child is the top of the chain. Check against the trust_ca list.
1793 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001794 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001795
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001796 md_info = mbedtls_md_info_from_type( child->sig_md );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001797 if( md_info == NULL )
1798 {
1799 /*
1800 * Cannot check 'unknown', no need to try any CA
1801 */
1802 trust_ca = NULL;
1803 }
1804 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001805 mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001806
Manuel Pégourié-Gonnard490047c2014-04-09 14:30:45 +02001807 for( /* trust_ca */ ; trust_ca != NULL; trust_ca = trust_ca->next )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001808 {
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001809 if( x509_crt_check_parent( child, trust_ca, 1, path_cnt == 0 ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001810 continue;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001811
1812 /*
1813 * Reduce path_len to check against if top of the chain is
1814 * the same as the trusted CA
1815 */
1816 if( child->subject_raw.len == trust_ca->subject_raw.len &&
1817 memcmp( child->subject_raw.p, trust_ca->subject_raw.p,
1818 child->issuer_raw.len ) == 0 )
1819 {
1820 check_path_cnt--;
1821 }
1822
1823 if( trust_ca->max_pathlen > 0 &&
1824 trust_ca->max_pathlen < check_path_cnt )
1825 {
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001826 continue;
1827 }
1828
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001829 if( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &trust_ca->pk,
1830 child->sig_md, hash, mbedtls_md_get_size( md_info ),
Manuel Pégourié-Gonnard46db4b02014-06-05 16:34:18 +02001831 child->sig.p, child->sig.len ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001832 {
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001833 continue;
1834 }
1835
1836 /*
1837 * Top of chain is signed by a trusted CA
1838 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001839 *flags &= ~MBEDTLS_X509_BADCERT_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001840 break;
1841 }
1842
1843 /*
1844 * If top of chain is not the same as the trusted CA send a verify request
1845 * to the callback for any issues with validity and CRL presence for the
1846 * trusted CA certificate.
1847 */
1848 if( trust_ca != NULL &&
1849 ( child->subject_raw.len != trust_ca->subject_raw.len ||
1850 memcmp( child->subject_raw.p, trust_ca->subject_raw.p,
1851 child->issuer_raw.len ) != 0 ) )
1852 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001853#if defined(MBEDTLS_X509_CRL_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001854 /* Check trusted CA's CRL for the chain's top crt */
Paul Bakkerddf26b42013-09-18 13:46:23 +02001855 *flags |= x509_crt_verifycrl( child, trust_ca, ca_crl );
Manuel Pégourié-Gonnardcbf3ef32013-09-23 12:20:02 +02001856#else
1857 ((void) ca_crl);
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001858#endif
1859
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001860 if( mbedtls_x509_time_expired( &trust_ca->valid_to ) )
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001861 ca_flags |= MBEDTLS_X509_BADCERT_EXPIRED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001862
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001863 if( mbedtls_x509_time_future( &trust_ca->valid_from ) )
1864 ca_flags |= MBEDTLS_X509_BADCERT_FUTURE;
Manuel Pégourié-Gonnard95337652014-03-10 13:15:18 +01001865
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001866 if( NULL != f_vrfy )
1867 {
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001868 if( ( ret = f_vrfy( p_vrfy, trust_ca, path_cnt + 1,
1869 &ca_flags ) ) != 0 )
1870 {
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001871 return( ret );
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001872 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001873 }
1874 }
1875
1876 /* Call callback on top cert */
1877 if( NULL != f_vrfy )
1878 {
Paul Bakker66d5d072014-06-17 16:39:18 +02001879 if( ( ret = f_vrfy( p_vrfy, child, path_cnt, flags ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001880 return( ret );
1881 }
1882
1883 *flags |= ca_flags;
1884
1885 return( 0 );
1886}
1887
Paul Bakkerddf26b42013-09-18 13:46:23 +02001888static int x509_crt_verify_child(
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001889 mbedtls_x509_crt *child, mbedtls_x509_crt *parent, mbedtls_x509_crt *trust_ca,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001890 mbedtls_x509_crl *ca_crl, int path_cnt, uint32_t *flags,
1891 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001892 void *p_vrfy )
1893{
1894 int ret;
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001895 uint32_t parent_flags = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001896 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
1897 mbedtls_x509_crt *grandparent;
1898 const mbedtls_md_info_t *md_info;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001899
Manuel Pégourié-Gonnardfd6c85c2014-11-20 16:34:20 +01001900 /* path_cnt is 0 for the first intermediate CA */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001901 if( 1 + path_cnt > MBEDTLS_X509_MAX_INTERMEDIATE_CA )
Manuel Pégourié-Gonnardfd6c85c2014-11-20 16:34:20 +01001902 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001903 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
1904 return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
Manuel Pégourié-Gonnardfd6c85c2014-11-20 16:34:20 +01001905 }
1906
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001907 if( mbedtls_x509_time_expired( &child->valid_to ) )
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001908 *flags |= MBEDTLS_X509_BADCERT_EXPIRED;
Manuel Pégourié-Gonnard8c045ef2014-04-08 11:55:03 +02001909
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001910 if( mbedtls_x509_time_future( &child->valid_from ) )
1911 *flags |= MBEDTLS_X509_BADCERT_FUTURE;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001912
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001913 md_info = mbedtls_md_info_from_type( child->sig_md );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001914 if( md_info == NULL )
1915 {
1916 /*
1917 * Cannot check 'unknown' hash
1918 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001919 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001920 }
1921 else
1922 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001923 mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001924
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001925 if( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &parent->pk,
1926 child->sig_md, hash, mbedtls_md_get_size( md_info ),
Manuel Pégourié-Gonnard46db4b02014-06-05 16:34:18 +02001927 child->sig.p, child->sig.len ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001928 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001929 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001930 }
1931 }
1932
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001933#if defined(MBEDTLS_X509_CRL_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001934 /* Check trusted CA's CRL for the given crt */
Paul Bakkerddf26b42013-09-18 13:46:23 +02001935 *flags |= x509_crt_verifycrl(child, parent, ca_crl);
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001936#endif
1937
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001938 /* Look for a grandparent upwards the chain */
1939 for( grandparent = parent->next;
1940 grandparent != NULL;
1941 grandparent = grandparent->next )
1942 {
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001943 if( x509_crt_check_parent( parent, grandparent,
1944 0, path_cnt == 0 ) == 0 )
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001945 break;
1946 }
1947
1948 /* Is our parent part of the chain or at the top? */
1949 if( grandparent != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001950 {
Manuel Pégourié-Gonnard490047c2014-04-09 14:30:45 +02001951 ret = x509_crt_verify_child( parent, grandparent, trust_ca, ca_crl,
1952 path_cnt + 1, &parent_flags, f_vrfy, p_vrfy );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001953 if( ret != 0 )
1954 return( ret );
1955 }
1956 else
1957 {
Manuel Pégourié-Gonnard490047c2014-04-09 14:30:45 +02001958 ret = x509_crt_verify_top( parent, trust_ca, ca_crl,
1959 path_cnt + 1, &parent_flags, f_vrfy, p_vrfy );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001960 if( ret != 0 )
1961 return( ret );
1962 }
1963
1964 /* child is verified to be a child of the parent, call verify callback */
1965 if( NULL != f_vrfy )
1966 if( ( ret = f_vrfy( p_vrfy, child, path_cnt, flags ) ) != 0 )
1967 return( ret );
1968
1969 *flags |= parent_flags;
1970
1971 return( 0 );
1972}
1973
1974/*
1975 * Verify the certificate validity
1976 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001977int mbedtls_x509_crt_verify( mbedtls_x509_crt *crt,
1978 mbedtls_x509_crt *trust_ca,
1979 mbedtls_x509_crl *ca_crl,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001980 const char *cn, uint32_t *flags,
1981 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Paul Bakkerddf26b42013-09-18 13:46:23 +02001982 void *p_vrfy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001983{
1984 size_t cn_len;
1985 int ret;
1986 int pathlen = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001987 mbedtls_x509_crt *parent;
1988 mbedtls_x509_name *name;
1989 mbedtls_x509_sequence *cur = NULL;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001990
1991 *flags = 0;
1992
1993 if( cn != NULL )
1994 {
1995 name = &crt->subject;
1996 cn_len = strlen( cn );
1997
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001998 if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001999 {
2000 cur = &crt->subject_alt_names;
2001
2002 while( cur != NULL )
2003 {
2004 if( cur->buf.len == cn_len &&
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02002005 x509_memcasecmp( cn, cur->buf.p, cn_len ) == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002006 break;
2007
2008 if( cur->buf.len > 2 &&
2009 memcmp( cur->buf.p, "*.", 2 ) == 0 &&
2010 x509_wildcard_verify( cn, &cur->buf ) )
2011 break;
2012
2013 cur = cur->next;
2014 }
2015
2016 if( cur == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002017 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002018 }
2019 else
2020 {
2021 while( name != NULL )
2022 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002023 if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, &name->oid ) == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002024 {
2025 if( name->val.len == cn_len &&
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02002026 x509_memcasecmp( name->val.p, cn, cn_len ) == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002027 break;
2028
2029 if( name->val.len > 2 &&
2030 memcmp( name->val.p, "*.", 2 ) == 0 &&
2031 x509_wildcard_verify( cn, &name->val ) )
2032 break;
2033 }
2034
2035 name = name->next;
2036 }
2037
2038 if( name == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002039 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002040 }
2041 }
2042
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002043 /* Look for a parent upwards the chain */
2044 for( parent = crt->next; parent != NULL; parent = parent->next )
2045 {
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002046 if( x509_crt_check_parent( crt, parent, 0, pathlen == 0 ) == 0 )
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002047 break;
2048 }
2049
2050 /* Are we part of the chain or at the top? */
2051 if( parent != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002052 {
Manuel Pégourié-Gonnard490047c2014-04-09 14:30:45 +02002053 ret = x509_crt_verify_child( crt, parent, trust_ca, ca_crl,
2054 pathlen, flags, f_vrfy, p_vrfy );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002055 if( ret != 0 )
2056 return( ret );
2057 }
2058 else
2059 {
Manuel Pégourié-Gonnard490047c2014-04-09 14:30:45 +02002060 ret = x509_crt_verify_top( crt, trust_ca, ca_crl,
2061 pathlen, flags, f_vrfy, p_vrfy );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002062 if( ret != 0 )
2063 return( ret );
2064 }
2065
2066 if( *flags != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002067 return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002068
2069 return( 0 );
2070}
2071
2072/*
Paul Bakker369d2eb2013-09-18 11:58:25 +02002073 * Initialize a certificate chain
2074 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002075void mbedtls_x509_crt_init( mbedtls_x509_crt *crt )
Paul Bakker369d2eb2013-09-18 11:58:25 +02002076{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002077 memset( crt, 0, sizeof(mbedtls_x509_crt) );
Paul Bakker369d2eb2013-09-18 11:58:25 +02002078}
2079
2080/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002081 * Unallocate all certificate data
2082 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002083void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002084{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002085 mbedtls_x509_crt *cert_cur = crt;
2086 mbedtls_x509_crt *cert_prv;
2087 mbedtls_x509_name *name_cur;
2088 mbedtls_x509_name *name_prv;
2089 mbedtls_x509_sequence *seq_cur;
2090 mbedtls_x509_sequence *seq_prv;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002091
2092 if( crt == NULL )
2093 return;
2094
2095 do
2096 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002097 mbedtls_pk_free( &cert_cur->pk );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002098
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002099#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
2100 mbedtls_free( cert_cur->sig_opts );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +02002101#endif
2102
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002103 name_cur = cert_cur->issuer.next;
2104 while( name_cur != NULL )
2105 {
2106 name_prv = name_cur;
2107 name_cur = name_cur->next;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002108 mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
2109 mbedtls_free( name_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002110 }
2111
2112 name_cur = cert_cur->subject.next;
2113 while( name_cur != NULL )
2114 {
2115 name_prv = name_cur;
2116 name_cur = name_cur->next;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002117 mbedtls_zeroize( name_prv, sizeof( mbedtls_x509_name ) );
2118 mbedtls_free( name_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002119 }
2120
2121 seq_cur = cert_cur->ext_key_usage.next;
2122 while( seq_cur != NULL )
2123 {
2124 seq_prv = seq_cur;
2125 seq_cur = seq_cur->next;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002126 mbedtls_zeroize( seq_prv, sizeof( mbedtls_x509_sequence ) );
2127 mbedtls_free( seq_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002128 }
2129
2130 seq_cur = cert_cur->subject_alt_names.next;
2131 while( seq_cur != NULL )
2132 {
2133 seq_prv = seq_cur;
2134 seq_cur = seq_cur->next;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002135 mbedtls_zeroize( seq_prv, sizeof( mbedtls_x509_sequence ) );
2136 mbedtls_free( seq_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002137 }
2138
2139 if( cert_cur->raw.p != NULL )
2140 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002141 mbedtls_zeroize( cert_cur->raw.p, cert_cur->raw.len );
2142 mbedtls_free( cert_cur->raw.p );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002143 }
2144
2145 cert_cur = cert_cur->next;
2146 }
2147 while( cert_cur != NULL );
2148
2149 cert_cur = crt;
2150 do
2151 {
2152 cert_prv = cert_cur;
2153 cert_cur = cert_cur->next;
2154
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002155 mbedtls_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002156 if( cert_prv != crt )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002157 mbedtls_free( cert_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002158 }
2159 while( cert_cur != NULL );
2160}
2161
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002162#endif /* MBEDTLS_X509_CRT_PARSE_C */