blob: c628e812a25ea190035faf8470b01140776256f4 [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é-Gonnard6fb81872015-07-27 11:11:48 +02004 * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
Manuel Pégourié-Gonnard37ff1402015-09-04 14:21:07 +02005 * SPDX-License-Identifier: Apache-2.0
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License"); you may
8 * not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
15 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
Paul Bakker7c6b2c32013-09-16 13:49:26 +020018 *
Manuel Pégourié-Gonnardfe446432015-03-06 13:17:10 +000019 * This file is part of mbed TLS (https://tls.mbed.org)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020020 */
21/*
22 * The ITU-T X.509 standard defines a certificate format for PKI.
23 *
Manuel Pégourié-Gonnard1c082f32014-06-12 22:34:55 +020024 * http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)
25 * http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)
26 * http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020027 *
28 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
29 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +020030 *
31 * [SIRO] https://cabforum.org/wp-content/uploads/Chunghwatelecom201503cabforumV4.pdf
Paul Bakker7c6b2c32013-09-16 13:49:26 +020032 */
33
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020034#if !defined(MBEDTLS_CONFIG_FILE)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000035#include "mbedtls/config.h"
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020036#else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020037#include MBEDTLS_CONFIG_FILE
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020038#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +020039
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020040#if defined(MBEDTLS_X509_CRT_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020041
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000042#include "mbedtls/x509_crt.h"
43#include "mbedtls/oid.h"
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -050044#include "mbedtls/platform_util.h"
Rich Evans00ab4702015-02-06 13:43:58 +000045
Rich Evans00ab4702015-02-06 13:43:58 +000046#include <string.h>
47
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020048#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000049#include "mbedtls/pem.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020050#endif
51
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020052#if defined(MBEDTLS_PLATFORM_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000053#include "mbedtls/platform.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020054#else
Simon Butcherd2642582018-10-03 15:11:19 +010055#include <stdio.h>
Rich Evans00ab4702015-02-06 13:43:58 +000056#include <stdlib.h>
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020057#define mbedtls_free free
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +020058#define mbedtls_calloc calloc
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020059#define mbedtls_snprintf snprintf
Paul Bakker7c6b2c32013-09-16 13:49:26 +020060#endif
61
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020062#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000063#include "mbedtls/threading.h"
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +010064#endif
65
Paul Bakkerfa6a6202013-10-28 18:48:30 +010066#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020067#include <windows.h>
68#else
69#include <time.h>
70#endif
71
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020072#if defined(MBEDTLS_FS_IO)
Rich Evans00ab4702015-02-06 13:43:58 +000073#include <stdio.h>
Paul Bakker5ff3f912014-04-04 15:08:20 +020074#if !defined(_WIN32) || defined(EFIX64) || defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020075#include <sys/types.h>
76#include <sys/stat.h>
77#include <dirent.h>
Rich Evans00ab4702015-02-06 13:43:58 +000078#endif /* !_WIN32 || EFIX64 || EFI32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +020079#endif
80
Manuel Pégourié-Gonnardc547d1a2017-07-05 13:28:45 +020081/*
82 * Item in a verification chain: cert and flags for it
83 */
84typedef struct {
85 mbedtls_x509_crt *crt;
86 uint32_t flags;
87} x509_crt_verify_chain_item;
88
89/*
90 * Max size of verification chain: end-entity + intermediates + trusted root
91 */
92#define X509_MAX_VERIFY_CHAIN_SIZE ( MBEDTLS_X509_MAX_INTERMEDIATE_CA + 2 )
Paul Bakker34617722014-06-13 17:20:13 +020093
Paul Bakker7c6b2c32013-09-16 13:49:26 +020094/*
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +020095 * Default profile
96 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +020097const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_default =
98{
Gilles Peskine5d2511c2017-05-12 13:16:40 +020099#if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES)
Gilles Peskine5e79cb32017-05-04 16:17:21 +0200100 /* Allow SHA-1 (weak, but still safe in controlled environments) */
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200101 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 ) |
Gilles Peskine5e79cb32017-05-04 16:17:21 +0200102#endif
103 /* Only SHA-2 hashes */
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200104 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA224 ) |
105 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
106 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
107 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
108 0xFFFFFFF, /* Any PK alg */
109 0xFFFFFFF, /* Any curve */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200110 2048,
111};
112
113/*
114 * Next-default profile
115 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200116const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_next =
117{
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200118 /* Hashes from SHA-256 and above */
119 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
120 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
121 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
122 0xFFFFFFF, /* Any PK alg */
123#if defined(MBEDTLS_ECP_C)
124 /* Curves at or above 128-bit security level */
125 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
126 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ) |
127 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP521R1 ) |
128 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP256R1 ) |
129 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP384R1 ) |
130 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP512R1 ) |
131 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256K1 ),
132#else
133 0,
134#endif
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200135 2048,
136};
137
138/*
139 * NSA Suite B Profile
140 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200141const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_suiteb =
142{
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200143 /* Only SHA-256 and 384 */
144 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
145 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ),
146 /* Only ECDSA */
Ron Eldor85e1dcf2018-02-06 15:59:38 +0200147 MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECDSA ) |
148 MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECKEY ),
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200149#if defined(MBEDTLS_ECP_C)
150 /* Only NIST P-256 and P-384 */
151 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
152 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ),
153#else
154 0,
155#endif
156 0,
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200157};
158
159/*
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200160 * Check md_alg against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200161 * Return 0 if md_alg is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200162 */
163static int x509_profile_check_md_alg( const mbedtls_x509_crt_profile *profile,
164 mbedtls_md_type_t md_alg )
165{
Philippe Antoineb5b25432018-05-11 11:06:29 +0200166 if( md_alg == MBEDTLS_MD_NONE )
167 return( -1 );
168
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200169 if( ( profile->allowed_mds & MBEDTLS_X509_ID_FLAG( md_alg ) ) != 0 )
170 return( 0 );
171
172 return( -1 );
173}
174
175/*
176 * Check pk_alg against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200177 * Return 0 if pk_alg is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200178 */
179static int x509_profile_check_pk_alg( const mbedtls_x509_crt_profile *profile,
180 mbedtls_pk_type_t pk_alg )
181{
Philippe Antoineb5b25432018-05-11 11:06:29 +0200182 if( pk_alg == MBEDTLS_PK_NONE )
183 return( -1 );
184
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200185 if( ( profile->allowed_pks & MBEDTLS_X509_ID_FLAG( pk_alg ) ) != 0 )
186 return( 0 );
187
188 return( -1 );
189}
190
191/*
192 * Check key against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200193 * Return 0 if pk is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200194 */
195static int x509_profile_check_key( const mbedtls_x509_crt_profile *profile,
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200196 const mbedtls_pk_context *pk )
197{
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200198 const mbedtls_pk_type_t pk_alg = mbedtls_pk_get_type( pk );
Manuel Pégourié-Gonnard19773ff2017-10-24 10:51:26 +0200199
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200200#if defined(MBEDTLS_RSA_C)
201 if( pk_alg == MBEDTLS_PK_RSA || pk_alg == MBEDTLS_PK_RSASSA_PSS )
202 {
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +0200203 if( mbedtls_pk_get_bitlen( pk ) >= profile->rsa_min_bitlen )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200204 return( 0 );
205
206 return( -1 );
207 }
208#endif
209
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +0200210#if defined(MBEDTLS_ECP_C)
211 if( pk_alg == MBEDTLS_PK_ECDSA ||
212 pk_alg == MBEDTLS_PK_ECKEY ||
213 pk_alg == MBEDTLS_PK_ECKEY_DH )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200214 {
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200215 const mbedtls_ecp_group_id gid = mbedtls_pk_ec( *pk )->grp.id;
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200216
Philippe Antoineb5b25432018-05-11 11:06:29 +0200217 if( gid == MBEDTLS_ECP_DP_NONE )
218 return( -1 );
219
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200220 if( ( profile->allowed_curves & MBEDTLS_X509_ID_FLAG( gid ) ) != 0 )
221 return( 0 );
222
223 return( -1 );
224 }
225#endif
226
227 return( -1 );
228}
229
230/*
Hanno Becker1f8527f2018-11-02 09:19:16 +0000231 * Return 0 if name matches wildcard, -1 otherwise
232 */
Hanno Becker24926222019-02-21 13:10:55 +0000233static int x509_check_wildcard( char const *cn,
234 size_t cn_len,
235 unsigned char const *buf,
236 size_t buf_len )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000237{
238 size_t i;
Hanno Becker24926222019-02-21 13:10:55 +0000239 size_t cn_idx = 0;
Hanno Becker1f8527f2018-11-02 09:19:16 +0000240
241 /* We can't have a match if there is no wildcard to match */
Hanno Becker24926222019-02-21 13:10:55 +0000242 if( buf_len < 3 || buf[0] != '*' || buf[1] != '.' )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000243 return( -1 );
244
245 for( i = 0; i < cn_len; ++i )
246 {
247 if( cn[i] == '.' )
248 {
249 cn_idx = i;
250 break;
251 }
252 }
253
254 if( cn_idx == 0 )
255 return( -1 );
256
Hanno Becker24926222019-02-21 13:10:55 +0000257 if( cn_len - cn_idx == buf_len - 1 &&
258 mbedtls_x509_memcasecmp( buf + 1, cn + cn_idx, buf_len - 1 ) == 0 )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000259 {
260 return( 0 );
261 }
262
263 return( -1 );
264}
265
266/*
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +0200267 * Reset (init or clear) a verify_chain
268 */
269static void x509_crt_verify_chain_reset(
270 mbedtls_x509_crt_verify_chain *ver_chain )
271{
272 size_t i;
273
274 for( i = 0; i < MBEDTLS_X509_MAX_VERIFY_CHAIN_SIZE; i++ )
275 {
276 ver_chain->items[i].crt = NULL;
Hanno Beckerd6ddcd62019-01-10 09:19:26 +0000277 ver_chain->items[i].flags = (uint32_t) -1;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +0200278 }
279
280 ver_chain->len = 0;
281}
282
283/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200284 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
285 */
286static int x509_get_version( unsigned char **p,
287 const unsigned char *end,
288 int *ver )
289{
290 int ret;
291 size_t len;
292
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200293 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
294 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200295 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200296 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200297 {
298 *ver = 0;
299 return( 0 );
300 }
301
Hanno Becker2f472142019-02-12 11:52:10 +0000302 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200303 }
304
305 end = *p + len;
306
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200307 if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
308 return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200309
310 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200311 return( MBEDTLS_ERR_X509_INVALID_VERSION +
312 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200313
314 return( 0 );
315}
316
317/*
318 * Validity ::= SEQUENCE {
319 * notBefore Time,
320 * notAfter Time }
321 */
322static int x509_get_dates( unsigned char **p,
323 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200324 mbedtls_x509_time *from,
325 mbedtls_x509_time *to )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200326{
327 int ret;
328 size_t len;
329
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200330 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
331 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
332 return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200333
334 end = *p + len;
335
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200336 if( ( ret = mbedtls_x509_get_time( p, end, from ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200337 return( ret );
338
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200339 if( ( ret = mbedtls_x509_get_time( p, end, to ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200340 return( ret );
341
342 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200343 return( MBEDTLS_ERR_X509_INVALID_DATE +
344 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200345
346 return( 0 );
347}
348
349/*
350 * X.509 v2/v3 unique identifier (not parsed)
351 */
352static int x509_get_uid( unsigned char **p,
353 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200354 mbedtls_x509_buf *uid, int n )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200355{
356 int ret;
357
358 if( *p == end )
359 return( 0 );
360
361 uid->tag = **p;
362
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200363 if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
364 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200365 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200366 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200367 return( 0 );
368
Hanno Becker2f472142019-02-12 11:52:10 +0000369 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200370 }
371
372 uid->p = *p;
373 *p += uid->len;
374
375 return( 0 );
376}
377
378static int x509_get_basic_constraints( unsigned char **p,
379 const unsigned char *end,
380 int *ca_istrue,
381 int *max_pathlen )
382{
383 int ret;
384 size_t len;
385
386 /*
387 * BasicConstraints ::= SEQUENCE {
388 * cA BOOLEAN DEFAULT FALSE,
389 * pathLenConstraint INTEGER (0..MAX) OPTIONAL }
390 */
391 *ca_istrue = 0; /* DEFAULT FALSE */
392 *max_pathlen = 0; /* endless */
393
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200394 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
395 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
396 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200397
398 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200399 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200400
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200401 if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200402 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200403 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
404 ret = mbedtls_asn1_get_int( p, end, ca_istrue );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200405
406 if( ret != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200407 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200408
409 if( *ca_istrue != 0 )
410 *ca_istrue = 1;
411 }
412
413 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200414 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200415
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200416 if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) != 0 )
417 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200418
419 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200420 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
421 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200422
423 (*max_pathlen)++;
424
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200425 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200426}
427
428static int x509_get_ns_cert_type( unsigned char **p,
429 const unsigned char *end,
430 unsigned char *ns_cert_type)
431{
432 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200433 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200434
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200435 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
436 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200437
438 if( bs.len != 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200439 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
440 MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200441
442 /* Get actual bitstring */
443 *ns_cert_type = *bs.p;
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200444 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200445}
446
447static int x509_get_key_usage( unsigned char **p,
448 const unsigned char *end,
Manuel Pégourié-Gonnard1d0ca1a2015-03-27 16:50:00 +0100449 unsigned int *key_usage)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200450{
451 int ret;
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200452 size_t i;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200453 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200454
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200455 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
456 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200457
458 if( bs.len < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200459 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
460 MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200461
462 /* Get actual bitstring */
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200463 *key_usage = 0;
464 for( i = 0; i < bs.len && i < sizeof( unsigned int ); i++ )
465 {
466 *key_usage |= (unsigned int) bs.p[i] << (8*i);
467 }
468
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200469 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200470}
471
472/*
473 * ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
474 *
475 * KeyPurposeId ::= OBJECT IDENTIFIER
476 */
477static int x509_get_ext_key_usage( unsigned char **p,
478 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200479 mbedtls_x509_sequence *ext_key_usage)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200480{
481 int ret;
482
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200483 if( ( ret = mbedtls_asn1_get_sequence_of( p, end, ext_key_usage, MBEDTLS_ASN1_OID ) ) != 0 )
484 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200485
486 /* Sequence length must be >= 1 */
487 if( ext_key_usage->buf.p == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200488 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
489 MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200490
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200491 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200492}
493
494/*
495 * SubjectAltName ::= GeneralNames
496 *
497 * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
498 *
499 * GeneralName ::= CHOICE {
500 * otherName [0] OtherName,
501 * rfc822Name [1] IA5String,
502 * dNSName [2] IA5String,
503 * x400Address [3] ORAddress,
504 * directoryName [4] Name,
505 * ediPartyName [5] EDIPartyName,
506 * uniformResourceIdentifier [6] IA5String,
507 * iPAddress [7] OCTET STRING,
508 * registeredID [8] OBJECT IDENTIFIER }
509 *
510 * OtherName ::= SEQUENCE {
511 * type-id OBJECT IDENTIFIER,
512 * value [0] EXPLICIT ANY DEFINED BY type-id }
513 *
514 * EDIPartyName ::= SEQUENCE {
515 * nameAssigner [0] DirectoryString OPTIONAL,
516 * partyName [1] DirectoryString }
517 *
Manuel Pégourié-Gonnardb4fe3cb2015-01-22 16:11:05 +0000518 * NOTE: we only parse and use dNSName at this point.
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200519 */
520static int x509_get_subject_alt_name( unsigned char **p,
521 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200522 mbedtls_x509_sequence *subject_alt_name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200523{
524 int ret;
525 size_t len, tag_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200526 mbedtls_asn1_buf *buf;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200527 unsigned char tag;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200528 mbedtls_asn1_sequence *cur = subject_alt_name;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200529
530 /* Get main sequence tag */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200531 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
532 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
533 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200534
535 if( *p + len != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200536 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
537 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200538
539 while( *p < end )
540 {
541 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200542 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
543 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200544
545 tag = **p;
546 (*p)++;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200547 if( ( ret = mbedtls_asn1_get_len( p, end, &tag_len ) ) != 0 )
548 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200549
Andres Amaya Garcia849bc652017-08-25 17:13:12 +0100550 if( ( tag & MBEDTLS_ASN1_TAG_CLASS_MASK ) !=
551 MBEDTLS_ASN1_CONTEXT_SPECIFIC )
552 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200553 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
554 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Andres Amaya Garcia849bc652017-08-25 17:13:12 +0100555 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200556
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +0200557 /* Skip everything but DNS name */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200558 if( tag != ( MBEDTLS_ASN1_CONTEXT_SPECIFIC | 2 ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200559 {
560 *p += tag_len;
561 continue;
562 }
563
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200564 /* Allocate and assign next pointer */
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +0200565 if( cur->buf.p != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200566 {
Manuel Pégourié-Gonnardb1340602014-11-11 23:11:16 +0100567 if( cur->next != NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200568 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
Manuel Pégourié-Gonnardb1340602014-11-11 23:11:16 +0100569
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200570 cur->next = mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200571
572 if( cur->next == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200573 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +0200574 MBEDTLS_ERR_ASN1_ALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200575
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200576 cur = cur->next;
577 }
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +0200578
579 buf = &(cur->buf);
580 buf->tag = tag;
581 buf->p = *p;
582 buf->len = tag_len;
583 *p += buf->len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200584 }
585
586 /* Set final sequence entry's next pointer to NULL */
587 cur->next = NULL;
588
589 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200590 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
591 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200592
593 return( 0 );
594}
595
596/*
597 * X.509 v3 extensions
598 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200599 */
600static int x509_get_crt_ext( unsigned char **p,
601 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200602 mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200603{
604 int ret;
605 size_t len;
606 unsigned char *end_ext_data, *end_ext_octet;
607
Hanno Becker4e1bfc12019-02-12 17:22:36 +0000608 if( *p == end )
609 return( 0 );
610
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200611 if( ( ret = mbedtls_x509_get_ext( p, end, &crt->v3_ext, 3 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200612 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200613
Hanno Becker4e1bfc12019-02-12 17:22:36 +0000614 end = crt->v3_ext.p + crt->v3_ext.len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200615 while( *p < end )
616 {
617 /*
618 * Extension ::= SEQUENCE {
619 * extnID OBJECT IDENTIFIER,
620 * critical BOOLEAN DEFAULT FALSE,
621 * extnValue OCTET STRING }
622 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200623 mbedtls_x509_buf extn_oid = {0, 0, NULL};
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200624 int is_critical = 0; /* DEFAULT FALSE */
625 int ext_type = 0;
626
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200627 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
628 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
629 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200630
631 end_ext_data = *p + len;
632
633 /* Get extension ID */
k-stachowiakdcae78a2018-06-28 16:32:54 +0200634 if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &extn_oid.len,
k-stachowiak463928a2018-07-24 12:50:59 +0200635 MBEDTLS_ASN1_OID ) ) != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200636 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200637
k-stachowiak463928a2018-07-24 12:50:59 +0200638 extn_oid.tag = MBEDTLS_ASN1_OID;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200639 extn_oid.p = *p;
640 *p += extn_oid.len;
641
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200642 /* Get optional critical */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200643 if( ( ret = mbedtls_asn1_get_bool( p, end_ext_data, &is_critical ) ) != 0 &&
644 ( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
645 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200646
647 /* Data should be octet string type */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200648 if( ( ret = mbedtls_asn1_get_tag( p, end_ext_data, &len,
649 MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
650 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200651
652 end_ext_octet = *p + len;
653
654 if( end_ext_octet != end_ext_data )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200655 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
656 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200657
658 /*
659 * Detect supported extensions
660 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200661 ret = mbedtls_oid_get_x509_ext_type( &extn_oid, &ext_type );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200662
663 if( ret != 0 )
664 {
665 /* No parser found, skip extension */
666 *p = end_ext_octet;
667
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200668#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200669 if( is_critical )
670 {
671 /* Data is marked as critical: fail */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200672 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
673 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200674 }
675#endif
676 continue;
677 }
678
Manuel Pégourié-Gonnard8a5e3d42014-11-12 17:47:28 +0100679 /* Forbid repeated extensions */
680 if( ( crt->ext_types & ext_type ) != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200681 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
Manuel Pégourié-Gonnard8a5e3d42014-11-12 17:47:28 +0100682
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200683 crt->ext_types |= ext_type;
684
685 switch( ext_type )
686 {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +0100687 case MBEDTLS_X509_EXT_BASIC_CONSTRAINTS:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200688 /* Parse basic constraints */
689 if( ( ret = x509_get_basic_constraints( p, end_ext_octet,
690 &crt->ca_istrue, &crt->max_pathlen ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200691 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200692 break;
693
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200694 case MBEDTLS_X509_EXT_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200695 /* Parse key usage */
696 if( ( ret = x509_get_key_usage( p, end_ext_octet,
697 &crt->key_usage ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200698 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200699 break;
700
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200701 case MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200702 /* Parse extended key usage */
Hanno Becker7ec9c362019-02-21 14:24:05 +0000703 crt->ext_key_usage_raw.p = *p;
704 crt->ext_key_usage_raw.len = end_ext_octet - *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200705 if( ( ret = x509_get_ext_key_usage( p, end_ext_octet,
706 &crt->ext_key_usage ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200707 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200708 break;
709
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +0100710 case MBEDTLS_X509_EXT_SUBJECT_ALT_NAME:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200711 /* Parse subject alt name */
Hanno Beckerded167e2019-02-21 14:34:46 +0000712 crt->subject_alt_raw.p = *p;
713 crt->subject_alt_raw.len = end_ext_octet - *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200714 if( ( ret = x509_get_subject_alt_name( p, end_ext_octet,
715 &crt->subject_alt_names ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200716 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200717 break;
718
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200719 case MBEDTLS_X509_EXT_NS_CERT_TYPE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200720 /* Parse netscape certificate type */
721 if( ( ret = x509_get_ns_cert_type( p, end_ext_octet,
722 &crt->ns_cert_type ) ) != 0 )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200723 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200724 break;
725
726 default:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200727 return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200728 }
729 }
730
731 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200732 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
733 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200734
735 return( 0 );
736}
737
738/*
739 * Parse and fill a single X.509 certificate in DER format
740 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +0000741static int x509_crt_parse_der_core( mbedtls_x509_crt *crt,
742 const unsigned char *buf,
743 size_t buflen,
744 int make_copy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200745{
746 int ret;
747 size_t len;
748 unsigned char *p, *end, *crt_end;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200749 mbedtls_x509_buf sig_params1, sig_params2, sig_oid2;
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100750
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200751 memset( &sig_params1, 0, sizeof( mbedtls_x509_buf ) );
752 memset( &sig_params2, 0, sizeof( mbedtls_x509_buf ) );
753 memset( &sig_oid2, 0, sizeof( mbedtls_x509_buf ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200754
755 /*
756 * Check for valid input
757 */
758 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200759 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200760
Hanno Beckeraa8665a2019-01-31 08:57:44 +0000761 /* Use the original buffer until we figure out actual length. */
Janos Follathcc0e49d2016-02-17 14:34:12 +0000762 p = (unsigned char*) buf;
763 len = buflen;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200764 end = p + len;
765
766 /*
767 * Certificate ::= SEQUENCE {
768 * tbsCertificate TBSCertificate,
769 * signatureAlgorithm AlgorithmIdentifier,
770 * signatureValue BIT STRING }
771 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200772 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
773 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200774 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200775 mbedtls_x509_crt_free( crt );
776 return( MBEDTLS_ERR_X509_INVALID_FORMAT );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200777 }
778
Janos Follathcc0e49d2016-02-17 14:34:12 +0000779 end = crt_end = p + len;
Hanno Beckeraa8665a2019-01-31 08:57:44 +0000780 crt->raw.len = crt_end - buf;
781 if( make_copy != 0 )
782 {
783 /* Create and populate a new buffer for the raw field. */
784 crt->raw.p = p = mbedtls_calloc( 1, crt->raw.len );
785 if( crt->raw.p == NULL )
786 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
787
788 memcpy( crt->raw.p, buf, crt->raw.len );
789 crt->own_buffer = 1;
790
791 p += crt->raw.len - len;
792 end = crt_end = p + len;
793 }
794 else
795 {
796 crt->raw.p = (unsigned char*) buf;
797 crt->own_buffer = 0;
798 }
Janos Follathcc0e49d2016-02-17 14:34:12 +0000799
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200800 /*
801 * TBSCertificate ::= SEQUENCE {
802 */
803 crt->tbs.p = p;
804
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200805 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
806 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200807 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200808 mbedtls_x509_crt_free( crt );
809 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200810 }
811
812 end = p + len;
813 crt->tbs.len = end - crt->tbs.p;
814
815 /*
816 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
817 *
818 * CertificateSerialNumber ::= INTEGER
819 *
820 * signature AlgorithmIdentifier
821 */
822 if( ( ret = x509_get_version( &p, end, &crt->version ) ) != 0 ||
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200823 ( ret = mbedtls_x509_get_serial( &p, end, &crt->serial ) ) != 0 ||
824 ( ret = mbedtls_x509_get_alg( &p, end, &crt->sig_oid,
Manuel Pégourié-Gonnarddddbb1d2014-06-05 17:02:24 +0200825 &sig_params1 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200826 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200827 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200828 return( ret );
829 }
830
Andres AG7ca4a032017-03-09 16:16:11 +0000831 if( crt->version < 0 || crt->version > 2 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200832 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200833 mbedtls_x509_crt_free( crt );
834 return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200835 }
836
Andres AG7ca4a032017-03-09 16:16:11 +0000837 crt->version++;
838
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200839 if( ( ret = mbedtls_x509_get_sig_alg( &crt->sig_oid, &sig_params1,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200840 &crt->sig_md, &crt->sig_pk,
841 &crt->sig_opts ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200842 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200843 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200844 return( ret );
845 }
846
847 /*
848 * issuer Name
849 */
850 crt->issuer_raw.p = p;
851
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200852 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
853 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200854 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200855 mbedtls_x509_crt_free( crt );
856 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200857 }
Hanno Beckerf8a42862019-02-20 13:45:16 +0000858 crt->issuer_raw_no_hdr.p = p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200859
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200860 if( ( ret = mbedtls_x509_get_name( &p, p + len, &crt->issuer ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200861 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200862 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200863 return( ret );
864 }
865
Hanno Beckerf8a42862019-02-20 13:45:16 +0000866 crt->issuer_raw_no_hdr.len = p - crt->issuer_raw_no_hdr.p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200867 crt->issuer_raw.len = p - crt->issuer_raw.p;
868
869 /*
870 * Validity ::= SEQUENCE {
871 * notBefore Time,
872 * notAfter Time }
873 *
874 */
875 if( ( ret = x509_get_dates( &p, end, &crt->valid_from,
876 &crt->valid_to ) ) != 0 )
877 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200878 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200879 return( ret );
880 }
881
882 /*
883 * subject Name
884 */
885 crt->subject_raw.p = p;
886
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200887 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
888 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200889 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200890 mbedtls_x509_crt_free( crt );
891 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200892 }
893
Hanno Beckerf8a42862019-02-20 13:45:16 +0000894 crt->subject_raw_no_hdr.p = p;
895
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200896 if( len && ( ret = mbedtls_x509_get_name( &p, p + len, &crt->subject ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200897 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200898 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200899 return( ret );
900 }
901
Hanno Beckerf8a42862019-02-20 13:45:16 +0000902 crt->subject_raw_no_hdr.len = p - crt->subject_raw_no_hdr.p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200903 crt->subject_raw.len = p - crt->subject_raw.p;
904
905 /*
906 * SubjectPublicKeyInfo
907 */
Hanno Becker32c530e2019-02-06 16:13:41 +0000908 crt->pk_raw.p = p;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200909 if( ( ret = mbedtls_pk_parse_subpubkey( &p, end, &crt->pk ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200910 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200911 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200912 return( ret );
913 }
Hanno Becker32c530e2019-02-06 16:13:41 +0000914 crt->pk_raw.len = p - crt->pk_raw.p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200915
916 /*
917 * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
918 * -- If present, version shall be v2 or v3
919 * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
920 * -- If present, version shall be v2 or v3
921 * extensions [3] EXPLICIT Extensions OPTIONAL
922 * -- If present, version shall be v3
923 */
924 if( crt->version == 2 || crt->version == 3 )
925 {
926 ret = x509_get_uid( &p, end, &crt->issuer_id, 1 );
927 if( ret != 0 )
928 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200929 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200930 return( ret );
931 }
932 }
933
934 if( crt->version == 2 || crt->version == 3 )
935 {
936 ret = x509_get_uid( &p, end, &crt->subject_id, 2 );
937 if( ret != 0 )
938 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200939 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200940 return( ret );
941 }
942 }
943
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200944#if !defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200945 if( crt->version == 3 )
Paul Bakkerc27c4e22013-09-23 15:01:36 +0200946#endif
Manuel Pégourié-Gonnarda252af72015-03-27 16:15:55 +0100947 {
Paul Bakker66d5d072014-06-17 16:39:18 +0200948 ret = x509_get_crt_ext( &p, end, crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200949 if( ret != 0 )
950 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200951 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200952 return( ret );
953 }
954 }
955
956 if( p != end )
957 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200958 mbedtls_x509_crt_free( crt );
959 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
960 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200961 }
962
963 end = crt_end;
964
965 /*
966 * }
967 * -- end of TBSCertificate
968 *
969 * signatureAlgorithm AlgorithmIdentifier,
970 * signatureValue BIT STRING
971 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200972 if( ( ret = mbedtls_x509_get_alg( &p, end, &sig_oid2, &sig_params2 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200973 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200974 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200975 return( ret );
976 }
977
Manuel Pégourié-Gonnard1022fed2015-03-27 16:30:47 +0100978 if( crt->sig_oid.len != sig_oid2.len ||
979 memcmp( crt->sig_oid.p, sig_oid2.p, crt->sig_oid.len ) != 0 ||
Manuel Pégourié-Gonnarddddbb1d2014-06-05 17:02:24 +0200980 sig_params1.len != sig_params2.len ||
Manuel Pégourié-Gonnard159c5242015-04-30 11:15:22 +0200981 ( sig_params1.len != 0 &&
982 memcmp( sig_params1.p, sig_params2.p, sig_params1.len ) != 0 ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200983 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200984 mbedtls_x509_crt_free( crt );
985 return( MBEDTLS_ERR_X509_SIG_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200986 }
987
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200988 if( ( ret = mbedtls_x509_get_sig( &p, end, &crt->sig ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200989 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200990 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200991 return( ret );
992 }
993
994 if( p != end )
995 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200996 mbedtls_x509_crt_free( crt );
997 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
998 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200999 }
1000
1001 return( 0 );
1002}
1003
1004/*
1005 * Parse one X.509 certificate in DER format from a buffer and add them to a
1006 * chained list
1007 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001008static int mbedtls_x509_crt_parse_der_internal( mbedtls_x509_crt *chain,
1009 const unsigned char *buf,
1010 size_t buflen,
1011 int make_copy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001012{
1013 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001014 mbedtls_x509_crt *crt = chain, *prev = NULL;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001015
1016 /*
1017 * Check for valid input
1018 */
1019 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001020 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001021
1022 while( crt->version != 0 && crt->next != NULL )
1023 {
1024 prev = crt;
1025 crt = crt->next;
1026 }
1027
1028 /*
1029 * Add new certificate on the end of the chain if needed.
1030 */
Paul Bakker66d5d072014-06-17 16:39:18 +02001031 if( crt->version != 0 && crt->next == NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001032 {
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +02001033 crt->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001034
1035 if( crt->next == NULL )
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02001036 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001037
1038 prev = crt;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001039 mbedtls_x509_crt_init( crt->next );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001040 crt = crt->next;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001041 }
1042
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001043 if( ( ret = x509_crt_parse_der_core( crt, buf, buflen, make_copy ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001044 {
1045 if( prev )
1046 prev->next = NULL;
1047
1048 if( crt != chain )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001049 mbedtls_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001050
1051 return( ret );
1052 }
1053
1054 return( 0 );
1055}
1056
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001057int mbedtls_x509_crt_parse_der_nocopy( mbedtls_x509_crt *chain,
1058 const unsigned char *buf,
1059 size_t buflen )
1060{
1061 return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 0 ) );
1062}
1063
1064int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain,
1065 const unsigned char *buf,
1066 size_t buflen )
1067{
1068 return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 1 ) );
1069}
1070
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001071/*
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001072 * Parse one or more PEM certificates from a buffer and add them to the chained
1073 * list
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001074 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001075int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain,
1076 const unsigned char *buf,
1077 size_t buflen )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001078{
Janos Follath98e28a72016-05-31 14:03:54 +01001079#if defined(MBEDTLS_PEM_PARSE_C)
Andres AGc0db5112016-12-07 15:05:53 +00001080 int success = 0, first_error = 0, total_failed = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001081 int buf_format = MBEDTLS_X509_FORMAT_DER;
Janos Follath98e28a72016-05-31 14:03:54 +01001082#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001083
1084 /*
1085 * Check for valid input
1086 */
1087 if( chain == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001088 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001089
1090 /*
1091 * Determine buffer content. Buffer contains either one DER certificate or
1092 * one or more PEM certificates.
1093 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001094#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard0ece0f92015-05-12 12:43:54 +02001095 if( buflen != 0 && buf[buflen - 1] == '\0' &&
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001096 strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
1097 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001098 buf_format = MBEDTLS_X509_FORMAT_PEM;
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001099 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001100
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001101 if( buf_format == MBEDTLS_X509_FORMAT_DER )
1102 return mbedtls_x509_crt_parse_der( chain, buf, buflen );
Janos Follath98e28a72016-05-31 14:03:54 +01001103#else
1104 return mbedtls_x509_crt_parse_der( chain, buf, buflen );
1105#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001106
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001107#if defined(MBEDTLS_PEM_PARSE_C)
1108 if( buf_format == MBEDTLS_X509_FORMAT_PEM )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001109 {
1110 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001111 mbedtls_pem_context pem;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001112
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001113 /* 1 rather than 0 since the terminating NULL byte is counted in */
1114 while( buflen > 1 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001115 {
1116 size_t use_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001117 mbedtls_pem_init( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001118
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001119 /* If we get there, we know the string is null-terminated */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001120 ret = mbedtls_pem_read_buffer( &pem,
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001121 "-----BEGIN CERTIFICATE-----",
1122 "-----END CERTIFICATE-----",
1123 buf, NULL, 0, &use_len );
1124
1125 if( ret == 0 )
1126 {
1127 /*
1128 * Was PEM encoded
1129 */
1130 buflen -= use_len;
1131 buf += use_len;
1132 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001133 else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001134 {
1135 return( ret );
1136 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001137 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001138 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001139 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001140
1141 /*
1142 * PEM header and footer were found
1143 */
1144 buflen -= use_len;
1145 buf += use_len;
1146
1147 if( first_error == 0 )
1148 first_error = ret;
1149
Paul Bakker5a5fa922014-09-26 14:53:04 +02001150 total_failed++;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001151 continue;
1152 }
1153 else
1154 break;
1155
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001156 ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001157
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001158 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001159
1160 if( ret != 0 )
1161 {
1162 /*
1163 * Quit parsing on a memory error
1164 */
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02001165 if( ret == MBEDTLS_ERR_X509_ALLOC_FAILED )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001166 return( ret );
1167
1168 if( first_error == 0 )
1169 first_error = ret;
1170
1171 total_failed++;
1172 continue;
1173 }
1174
1175 success = 1;
1176 }
1177 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001178
1179 if( success )
1180 return( total_failed );
1181 else if( first_error )
1182 return( first_error );
1183 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001184 return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
Janos Follath98e28a72016-05-31 14:03:54 +01001185#endif /* MBEDTLS_PEM_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001186}
1187
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001188#if defined(MBEDTLS_FS_IO)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001189/*
1190 * Load one or more certificates and add them to the chained list
1191 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001192int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001193{
1194 int ret;
1195 size_t n;
1196 unsigned char *buf;
1197
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001198 if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001199 return( ret );
1200
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001201 ret = mbedtls_x509_crt_parse( chain, buf, n );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001202
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05001203 mbedtls_platform_zeroize( buf, n );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001204 mbedtls_free( buf );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001205
1206 return( ret );
1207}
1208
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001209int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001210{
1211 int ret = 0;
Paul Bakkerfa6a6202013-10-28 18:48:30 +01001212#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001213 int w_ret;
1214 WCHAR szDir[MAX_PATH];
1215 char filename[MAX_PATH];
Paul Bakker9af723c2014-05-01 13:03:14 +02001216 char *p;
Manuel Pégourié-Gonnard261faed2015-10-21 10:16:29 +02001217 size_t len = strlen( path );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001218
Paul Bakker9af723c2014-05-01 13:03:14 +02001219 WIN32_FIND_DATAW file_data;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001220 HANDLE hFind;
1221
1222 if( len > MAX_PATH - 3 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001223 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001224
Paul Bakker9af723c2014-05-01 13:03:14 +02001225 memset( szDir, 0, sizeof(szDir) );
1226 memset( filename, 0, MAX_PATH );
1227 memcpy( filename, path, len );
1228 filename[len++] = '\\';
1229 p = filename + len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001230 filename[len++] = '*';
1231
Simon B3c6b18d2016-11-03 01:11:37 +00001232 w_ret = MultiByteToWideChar( CP_ACP, 0, filename, (int)len, szDir,
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001233 MAX_PATH - 3 );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +00001234 if( w_ret == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001235 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001236
1237 hFind = FindFirstFileW( szDir, &file_data );
Paul Bakker66d5d072014-06-17 16:39:18 +02001238 if( hFind == INVALID_HANDLE_VALUE )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001239 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001240
1241 len = MAX_PATH - len;
1242 do
1243 {
Paul Bakker9af723c2014-05-01 13:03:14 +02001244 memset( p, 0, len );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001245
1246 if( file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
1247 continue;
1248
Paul Bakker9af723c2014-05-01 13:03:14 +02001249 w_ret = WideCharToMultiByte( CP_ACP, 0, file_data.cFileName,
Paul Bakker66d5d072014-06-17 16:39:18 +02001250 lstrlenW( file_data.cFileName ),
Manuel Pégourié-Gonnard261faed2015-10-21 10:16:29 +02001251 p, (int) len - 1,
Paul Bakker9af723c2014-05-01 13:03:14 +02001252 NULL, NULL );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +00001253 if( w_ret == 0 )
Ron Eldor36d90422017-01-09 15:09:16 +02001254 {
1255 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
1256 goto cleanup;
1257 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001258
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001259 w_ret = mbedtls_x509_crt_parse_file( chain, filename );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001260 if( w_ret < 0 )
1261 ret++;
1262 else
1263 ret += w_ret;
1264 }
1265 while( FindNextFileW( hFind, &file_data ) != 0 );
1266
Paul Bakker66d5d072014-06-17 16:39:18 +02001267 if( GetLastError() != ERROR_NO_MORE_FILES )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001268 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001269
Ron Eldor36d90422017-01-09 15:09:16 +02001270cleanup:
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001271 FindClose( hFind );
Paul Bakkerbe089b02013-10-14 15:51:50 +02001272#else /* _WIN32 */
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001273 int t_ret;
Andres AGf9113192016-09-02 14:06:04 +01001274 int snp_ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001275 struct stat sb;
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001276 struct dirent *entry;
Andres AGf9113192016-09-02 14:06:04 +01001277 char entry_name[MBEDTLS_X509_MAX_FILE_PATH_LEN];
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001278 DIR *dir = opendir( path );
1279
Paul Bakker66d5d072014-06-17 16:39:18 +02001280 if( dir == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001281 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001282
Ron Eldor63140682017-01-09 19:27:59 +02001283#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard944cfe82015-05-27 20:07:18 +02001284 if( ( ret = mbedtls_mutex_lock( &mbedtls_threading_readdir_mutex ) ) != 0 )
Manuel Pégourié-Gonnardf9b85d92015-06-22 18:39:57 +02001285 {
1286 closedir( dir );
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001287 return( ret );
Manuel Pégourié-Gonnardf9b85d92015-06-22 18:39:57 +02001288 }
Ron Eldor63140682017-01-09 19:27:59 +02001289#endif /* MBEDTLS_THREADING_C */
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001290
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001291 while( ( entry = readdir( dir ) ) != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001292 {
Andres AGf9113192016-09-02 14:06:04 +01001293 snp_ret = mbedtls_snprintf( entry_name, sizeof entry_name,
1294 "%s/%s", path, entry->d_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001295
Andres AGf9113192016-09-02 14:06:04 +01001296 if( snp_ret < 0 || (size_t)snp_ret >= sizeof entry_name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001297 {
Andres AGf9113192016-09-02 14:06:04 +01001298 ret = MBEDTLS_ERR_X509_BUFFER_TOO_SMALL;
1299 goto cleanup;
1300 }
1301 else if( stat( entry_name, &sb ) == -1 )
1302 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001303 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001304 goto cleanup;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001305 }
1306
1307 if( !S_ISREG( sb.st_mode ) )
1308 continue;
1309
1310 // Ignore parse errors
1311 //
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001312 t_ret = mbedtls_x509_crt_parse_file( chain, entry_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001313 if( t_ret < 0 )
1314 ret++;
1315 else
1316 ret += t_ret;
1317 }
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001318
1319cleanup:
Andres AGf9113192016-09-02 14:06:04 +01001320 closedir( dir );
1321
Ron Eldor63140682017-01-09 19:27:59 +02001322#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard944cfe82015-05-27 20:07:18 +02001323 if( mbedtls_mutex_unlock( &mbedtls_threading_readdir_mutex ) != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001324 ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
Ron Eldor63140682017-01-09 19:27:59 +02001325#endif /* MBEDTLS_THREADING_C */
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001326
Paul Bakkerbe089b02013-10-14 15:51:50 +02001327#endif /* _WIN32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001328
1329 return( ret );
1330}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001331#endif /* MBEDTLS_FS_IO */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001332
Hanno Becker02a21932019-06-10 15:08:43 +01001333#if !defined(MBEDTLS_X509_REMOVE_INFO)
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001334static int x509_info_subject_alt_name( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001335 const mbedtls_x509_sequence *subject_alt_name )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001336{
1337 size_t i;
1338 size_t n = *size;
1339 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001340 const mbedtls_x509_sequence *cur = subject_alt_name;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001341 const char *sep = "";
1342 size_t sep_len = 0;
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001343
1344 while( cur != NULL )
1345 {
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001346 if( cur->buf.len + sep_len >= n )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001347 {
1348 *p = '\0';
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001349 return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001350 }
1351
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001352 n -= cur->buf.len + sep_len;
1353 for( i = 0; i < sep_len; i++ )
1354 *p++ = sep[i];
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001355 for( i = 0; i < cur->buf.len; i++ )
1356 *p++ = cur->buf.p[i];
1357
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001358 sep = ", ";
1359 sep_len = 2;
1360
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001361 cur = cur->next;
1362 }
1363
1364 *p = '\0';
1365
1366 *size = n;
1367 *buf = p;
1368
1369 return( 0 );
1370}
1371
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001372#define PRINT_ITEM(i) \
1373 { \
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001374 ret = mbedtls_snprintf( p, n, "%s" i, sep ); \
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001375 MBEDTLS_X509_SAFE_SNPRINTF; \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001376 sep = ", "; \
1377 }
1378
1379#define CERT_TYPE(type,name) \
Hanno Beckerd6028a12018-10-15 12:01:35 +01001380 if( ns_cert_type & (type) ) \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001381 PRINT_ITEM( name );
1382
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001383static int x509_info_cert_type( char **buf, size_t *size,
1384 unsigned char ns_cert_type )
1385{
1386 int ret;
1387 size_t n = *size;
1388 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001389 const char *sep = "";
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001390
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001391 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001392 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001393 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL, "Email" );
1394 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
1395 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_RESERVED, "Reserved" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001396 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CA, "SSL CA" );
1397 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL_CA, "Email CA" );
1398 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001399
1400 *size = n;
1401 *buf = p;
1402
1403 return( 0 );
1404}
1405
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001406#define KEY_USAGE(code,name) \
Hanno Beckerd6028a12018-10-15 12:01:35 +01001407 if( key_usage & (code) ) \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001408 PRINT_ITEM( name );
1409
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001410static int x509_info_key_usage( char **buf, size_t *size,
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +02001411 unsigned int key_usage )
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001412{
1413 int ret;
1414 size_t n = *size;
1415 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001416 const char *sep = "";
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001417
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001418 KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
1419 KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001420 KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
1421 KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
1422 KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001423 KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
1424 KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +02001425 KEY_USAGE( MBEDTLS_X509_KU_ENCIPHER_ONLY, "Encipher Only" );
1426 KEY_USAGE( MBEDTLS_X509_KU_DECIPHER_ONLY, "Decipher Only" );
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001427
1428 *size = n;
1429 *buf = p;
1430
1431 return( 0 );
1432}
1433
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001434static int x509_info_ext_key_usage( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001435 const mbedtls_x509_sequence *extended_key_usage )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001436{
1437 int ret;
1438 const char *desc;
1439 size_t n = *size;
1440 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001441 const mbedtls_x509_sequence *cur = extended_key_usage;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001442 const char *sep = "";
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001443
1444 while( cur != NULL )
1445 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001446 if( mbedtls_oid_get_extended_key_usage( &cur->buf, &desc ) != 0 )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001447 desc = "???";
1448
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001449 ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001450 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001451
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001452 sep = ", ";
1453
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001454 cur = cur->next;
1455 }
1456
1457 *size = n;
1458 *buf = p;
1459
1460 return( 0 );
1461}
1462
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001463/*
1464 * Return an informational string about the certificate.
1465 */
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001466#define BEFORE_COLON 18
1467#define BC "18"
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001468int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
1469 const mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001470{
1471 int ret;
1472 size_t n;
1473 char *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001474 char key_size_str[BEFORE_COLON];
1475
1476 p = buf;
1477 n = size;
1478
Janos Follath98e28a72016-05-31 14:03:54 +01001479 if( NULL == crt )
1480 {
1481 ret = mbedtls_snprintf( p, n, "\nCertificate is uninitialised!\n" );
1482 MBEDTLS_X509_SAFE_SNPRINTF;
1483
1484 return( (int) ( size - n ) );
1485 }
1486
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001487 ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001488 prefix, crt->version );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001489 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001490 ret = mbedtls_snprintf( p, n, "%sserial number : ",
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001491 prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001492 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001493
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001494 ret = mbedtls_x509_serial_gets( p, n, &crt->serial );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001495 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001496
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001497 ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001498 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001499 ret = mbedtls_x509_dn_gets( p, n, &crt->issuer );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001500 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001501
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001502 ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001503 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001504 ret = mbedtls_x509_dn_gets( p, n, &crt->subject );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001505 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001506
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001507 ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001508 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
1509 crt->valid_from.year, crt->valid_from.mon,
1510 crt->valid_from.day, crt->valid_from.hour,
1511 crt->valid_from.min, crt->valid_from.sec );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001512 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001513
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001514 ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001515 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
1516 crt->valid_to.year, crt->valid_to.mon,
1517 crt->valid_to.day, crt->valid_to.hour,
1518 crt->valid_to.min, crt->valid_to.sec );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001519 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001520
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001521 ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001522 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001523
Hanno Becker83cd8672019-02-21 17:13:46 +00001524 ret = mbedtls_x509_sig_alg_gets( p, n, sig_info.sig_pk,
1525 sig_info.sig_md, sig_info.sig_opts );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001526 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001527
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001528 /* Key size */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001529 if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
1530 mbedtls_pk_get_name( &crt->pk ) ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001531 {
1532 return( ret );
1533 }
1534
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001535 ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +02001536 (int) mbedtls_pk_get_bitlen( &crt->pk ) );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001537 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001538
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001539 /*
1540 * Optional extensions
1541 */
1542
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001543 if( crt->ext_types & MBEDTLS_X509_EXT_BASIC_CONSTRAINTS )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001544 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001545 ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001546 crt->ca_istrue ? "true" : "false" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001547 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001548
1549 if( crt->max_pathlen > 0 )
1550 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001551 ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", crt->max_pathlen - 1 );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001552 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001553 }
1554 }
1555
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001556 if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001557 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001558 ret = mbedtls_snprintf( p, n, "\n%ssubject alt name : ", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001559 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001560
1561 if( ( ret = x509_info_subject_alt_name( &p, &n,
1562 &crt->subject_alt_names ) ) != 0 )
1563 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001564 }
1565
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001566 if( crt->ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001567 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001568 ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001569 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001570
1571 if( ( ret = x509_info_cert_type( &p, &n, crt->ns_cert_type ) ) != 0 )
1572 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001573 }
1574
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001575 if( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001576 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001577 ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001578 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001579
1580 if( ( ret = x509_info_key_usage( &p, &n, crt->key_usage ) ) != 0 )
1581 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001582 }
1583
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001584 if( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001585 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001586 ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001587 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001588
1589 if( ( ret = x509_info_ext_key_usage( &p, &n,
1590 &crt->ext_key_usage ) ) != 0 )
1591 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001592 }
1593
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001594 ret = mbedtls_snprintf( p, n, "\n" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001595 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001596
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001597 return( (int) ( size - n ) );
1598}
1599
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001600struct x509_crt_verify_string {
1601 int code;
1602 const char *string;
1603};
1604
1605static const struct x509_crt_verify_string x509_crt_verify_strings[] = {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001606 { MBEDTLS_X509_BADCERT_EXPIRED, "The certificate validity has expired" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001607 { MBEDTLS_X509_BADCERT_REVOKED, "The certificate has been revoked (is on a CRL)" },
1608 { MBEDTLS_X509_BADCERT_CN_MISMATCH, "The certificate Common Name (CN) does not match with the expected CN" },
1609 { MBEDTLS_X509_BADCERT_NOT_TRUSTED, "The certificate is not correctly signed by the trusted CA" },
1610 { MBEDTLS_X509_BADCRL_NOT_TRUSTED, "The CRL is not correctly signed by the trusted CA" },
1611 { MBEDTLS_X509_BADCRL_EXPIRED, "The CRL is expired" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001612 { MBEDTLS_X509_BADCERT_MISSING, "Certificate was missing" },
1613 { MBEDTLS_X509_BADCERT_SKIP_VERIFY, "Certificate verification was skipped" },
1614 { MBEDTLS_X509_BADCERT_OTHER, "Other reason (can be used by verify callback)" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001615 { MBEDTLS_X509_BADCERT_FUTURE, "The certificate validity starts in the future" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001616 { MBEDTLS_X509_BADCRL_FUTURE, "The CRL is from the future" },
1617 { MBEDTLS_X509_BADCERT_KEY_USAGE, "Usage does not match the keyUsage extension" },
1618 { MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, "Usage does not match the extendedKeyUsage extension" },
1619 { MBEDTLS_X509_BADCERT_NS_CERT_TYPE, "Usage does not match the nsCertType extension" },
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02001620 { MBEDTLS_X509_BADCERT_BAD_MD, "The certificate is signed with an unacceptable hash." },
1621 { MBEDTLS_X509_BADCERT_BAD_PK, "The certificate is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
1622 { MBEDTLS_X509_BADCERT_BAD_KEY, "The certificate is signed with an unacceptable key (eg bad curve, RSA too short)." },
1623 { MBEDTLS_X509_BADCRL_BAD_MD, "The CRL is signed with an unacceptable hash." },
1624 { MBEDTLS_X509_BADCRL_BAD_PK, "The CRL is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
1625 { MBEDTLS_X509_BADCRL_BAD_KEY, "The CRL is signed with an unacceptable key (eg bad curve, RSA too short)." },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001626 { 0, NULL }
1627};
1628
1629int mbedtls_x509_crt_verify_info( char *buf, size_t size, const char *prefix,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001630 uint32_t flags )
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001631{
1632 int ret;
1633 const struct x509_crt_verify_string *cur;
1634 char *p = buf;
1635 size_t n = size;
1636
1637 for( cur = x509_crt_verify_strings; cur->string != NULL ; cur++ )
1638 {
1639 if( ( flags & cur->code ) == 0 )
1640 continue;
1641
1642 ret = mbedtls_snprintf( p, n, "%s%s\n", prefix, cur->string );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001643 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001644 flags ^= cur->code;
1645 }
1646
1647 if( flags != 0 )
1648 {
1649 ret = mbedtls_snprintf( p, n, "%sUnknown reason "
1650 "(this should not happen)\n", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001651 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001652 }
1653
1654 return( (int) ( size - n ) );
1655}
Hanno Becker02a21932019-06-10 15:08:43 +01001656#endif /* !MBEDTLS_X509_REMOVE_INFO */
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01001657
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001658#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Manuel Pégourié-Gonnard655a9642015-06-23 10:48:44 +02001659int mbedtls_x509_crt_check_key_usage( const mbedtls_x509_crt *crt,
1660 unsigned int usage )
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02001661{
Manuel Pégourié-Gonnard655a9642015-06-23 10:48:44 +02001662 unsigned int usage_must, usage_may;
1663 unsigned int may_mask = MBEDTLS_X509_KU_ENCIPHER_ONLY
1664 | MBEDTLS_X509_KU_DECIPHER_ONLY;
1665
1666 if( ( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE ) == 0 )
1667 return( 0 );
1668
1669 usage_must = usage & ~may_mask;
1670
1671 if( ( ( crt->key_usage & ~may_mask ) & usage_must ) != usage_must )
1672 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
1673
1674 usage_may = usage & may_mask;
1675
1676 if( ( ( crt->key_usage & may_mask ) | usage_may ) != usage_may )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001677 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02001678
1679 return( 0 );
1680}
1681#endif
1682
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001683#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
1684int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
Hanno Beckere1956af2019-02-21 14:28:12 +00001685 const char *usage_oid,
1686 size_t usage_len )
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001687{
Hanno Beckere1956af2019-02-21 14:28:12 +00001688 int ret;
1689 size_t len;
1690 unsigned ext_types;
1691 unsigned char *p, *end;
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001692
1693 /* Extension is not mandatory, absent means no restriction */
Hanno Beckere1956af2019-02-21 14:28:12 +00001694 ext_types = crt->ext_types;
1695 if( ( ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001696 return( 0 );
1697
Hanno Beckere1956af2019-02-21 14:28:12 +00001698 p = crt->ext_key_usage_raw.p;
1699 end = p + crt->ext_key_usage_raw.len;
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001700
Hanno Beckere1956af2019-02-21 14:28:12 +00001701 ret = mbedtls_asn1_get_tag( &p, end, &len,
1702 MBEDTLS_ASN1_CONSTRUCTED |
1703 MBEDTLS_ASN1_SEQUENCE );
1704 if( ret != 0 )
1705 goto exit;
1706
1707 if( end != p + len )
1708 {
1709 ret = MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
1710 goto exit;
1711 }
1712
1713 if( len == 0 )
1714 {
1715 ret = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
1716 goto exit;
1717 }
1718
1719 while( p < end )
1720 {
1721 ret = mbedtls_asn1_get_tag( &p, end, &len,
1722 MBEDTLS_ASN1_OID );
1723 if( ret != 0 )
1724 goto exit;
1725
1726 if( usage_oid != NULL )
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001727 {
Hanno Beckere1956af2019-02-21 14:28:12 +00001728 if( len == usage_len && memcmp( p, usage_oid, len ) == 0 )
1729 return( 0 );
1730
1731 if( MBEDTLS_OID_CMP_RAW( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE,
1732 p, len ) == 0 )
1733 {
1734 return( 0 );
1735 }
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001736 }
1737
Hanno Beckere1956af2019-02-21 14:28:12 +00001738 p += len;
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001739 }
1740
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001741 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Hanno Beckere1956af2019-02-21 14:28:12 +00001742
1743exit:
1744 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001745}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001746#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02001747
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001748#if defined(MBEDTLS_X509_CRL_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001749/*
1750 * Return 1 if the certificate is revoked, or 0 otherwise.
1751 */
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001752int mbedtls_x509_crt_is_revoked( const mbedtls_x509_crt *crt, const mbedtls_x509_crl *crl )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001753{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001754 const mbedtls_x509_crl_entry *cur = &crl->entry;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001755
1756 while( cur != NULL && cur->serial.len != 0 )
1757 {
1758 if( crt->serial.len == cur->serial.len &&
1759 memcmp( crt->serial.p, cur->serial.p, crt->serial.len ) == 0 )
1760 {
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001761 if( mbedtls_x509_time_is_past( &cur->revocation_date ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001762 return( 1 );
1763 }
1764
1765 cur = cur->next;
1766 }
1767
1768 return( 0 );
1769}
1770
1771/*
Manuel Pégourié-Gonnardeeef9472016-02-22 11:36:55 +01001772 * Check that the given certificate is not revoked according to the CRL.
Manuel Pégourié-Gonnard08eacec2017-10-18 14:20:24 +02001773 * Skip validation if no CRL for the given CA is present.
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001774 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001775static int x509_crt_verifycrl( mbedtls_x509_crt *crt, mbedtls_x509_crt *ca,
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02001776 mbedtls_x509_crl *crl_list,
1777 const mbedtls_x509_crt_profile *profile )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001778{
1779 int flags = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001780 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
1781 const mbedtls_md_info_t *md_info;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001782
1783 if( ca == NULL )
1784 return( flags );
1785
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001786 while( crl_list != NULL )
1787 {
1788 if( crl_list->version == 0 ||
Hanno Becker7dee12a2019-02-21 13:58:38 +00001789 mbedtls_x509_name_cmp_raw( &crl_list->issuer_raw_no_hdr,
Hanno Becker67284cc2019-02-21 14:31:51 +00001790 &ca->subject_raw_no_hdr,
1791 NULL, NULL ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001792 {
1793 crl_list = crl_list->next;
1794 continue;
1795 }
1796
1797 /*
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02001798 * Check if the CA is configured to sign CRLs
1799 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001800#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Hanno Beckerb75ffb52018-11-02 09:19:54 +00001801 if( mbedtls_x509_crt_check_key_usage( ca,
1802 MBEDTLS_X509_KU_CRL_SIGN ) != 0 )
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02001803 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001804 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02001805 break;
1806 }
1807#endif
1808
1809 /*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001810 * Check if CRL is correctly signed by the trusted CA
1811 */
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02001812 if( x509_profile_check_md_alg( profile, crl_list->sig_md ) != 0 )
1813 flags |= MBEDTLS_X509_BADCRL_BAD_MD;
1814
1815 if( x509_profile_check_pk_alg( profile, crl_list->sig_pk ) != 0 )
1816 flags |= MBEDTLS_X509_BADCRL_BAD_PK;
1817
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001818 md_info = mbedtls_md_info_from_type( crl_list->sig_md );
Manuel Pégourié-Gonnard329e78c2017-06-26 12:22:17 +02001819 if( mbedtls_md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001820 {
Manuel Pégourié-Gonnard329e78c2017-06-26 12:22:17 +02001821 /* Note: this can't happen except after an internal error */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001822 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001823 break;
1824 }
1825
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +02001826 if( x509_profile_check_key( profile, &ca->pk ) != 0 )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02001827 flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02001828
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001829 if( mbedtls_pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, &ca->pk,
1830 crl_list->sig_md, hash, mbedtls_md_get_size( md_info ),
Manuel Pégourié-Gonnard53882022014-06-05 17:53:52 +02001831 crl_list->sig.p, crl_list->sig.len ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001832 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001833 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001834 break;
1835 }
1836
1837 /*
1838 * Check for validity of CRL (Do not drop out)
1839 */
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001840 if( mbedtls_x509_time_is_past( &crl_list->next_update ) )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001841 flags |= MBEDTLS_X509_BADCRL_EXPIRED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001842
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001843 if( mbedtls_x509_time_is_future( &crl_list->this_update ) )
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001844 flags |= MBEDTLS_X509_BADCRL_FUTURE;
Manuel Pégourié-Gonnard95337652014-03-10 13:15:18 +01001845
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001846 /*
1847 * Check if certificate is revoked
1848 */
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001849 if( mbedtls_x509_crt_is_revoked( crt, crl_list ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001850 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001851 flags |= MBEDTLS_X509_BADCERT_REVOKED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001852 break;
1853 }
1854
1855 crl_list = crl_list->next;
1856 }
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02001857
Paul Bakkerd8bb8262014-06-17 14:06:49 +02001858 return( flags );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001859}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001860#endif /* MBEDTLS_X509_CRL_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001861
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02001862/*
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02001863 * Check the signature of a certificate by its parent
1864 */
1865static int x509_crt_check_signature( const mbedtls_x509_crt *child,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02001866 mbedtls_x509_crt *parent,
1867 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02001868{
1869 const mbedtls_md_info_t *md_info;
1870 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
1871
1872 md_info = mbedtls_md_info_from_type( child->sig_md );
1873 if( mbedtls_md( md_info, child->tbs.p, child->tbs.len, hash ) != 0 )
1874 {
1875 /* Note: this can't happen except after an internal error */
1876 return( -1 );
1877 }
1878
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02001879 /* Skip expensive computation on obvious mismatch */
1880 if( ! mbedtls_pk_can_do( &parent->pk, child->sig_pk ) )
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02001881 return( -1 );
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02001882
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02001883#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02001884 if( rs_ctx != NULL && child->sig_pk == MBEDTLS_PK_ECDSA )
1885 {
1886 return( mbedtls_pk_verify_restartable( &parent->pk,
1887 child->sig_md, hash, mbedtls_md_get_size( md_info ),
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02001888 child->sig.p, child->sig.len, &rs_ctx->pk ) );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02001889 }
1890#else
1891 (void) rs_ctx;
1892#endif
1893
1894 return( mbedtls_pk_verify_ext( child->sig_pk, child->sig_opts, &parent->pk,
1895 child->sig_md, hash, mbedtls_md_get_size( md_info ),
1896 child->sig.p, child->sig.len ) );
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02001897}
1898
1899/*
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001900 * Check if 'parent' is a suitable parent (signing CA) for 'child'.
1901 * Return 0 if yes, -1 if not.
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001902 *
1903 * top means parent is a locally-trusted certificate
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001904 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001905static int x509_crt_check_parent( const mbedtls_x509_crt *child,
1906 const mbedtls_x509_crt *parent,
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02001907 int top )
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001908{
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001909 int need_ca_bit;
1910
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02001911 /* Parent must be the issuer */
Hanno Becker7dee12a2019-02-21 13:58:38 +00001912 if( mbedtls_x509_name_cmp_raw( &child->issuer_raw_no_hdr,
Hanno Becker67284cc2019-02-21 14:31:51 +00001913 &parent->subject_raw_no_hdr,
1914 NULL, NULL ) != 0 )
Hanno Becker7dee12a2019-02-21 13:58:38 +00001915 {
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001916 return( -1 );
Hanno Becker7dee12a2019-02-21 13:58:38 +00001917 }
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001918
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001919 /* Parent must have the basicConstraints CA bit set as a general rule */
1920 need_ca_bit = 1;
1921
1922 /* Exception: v1/v2 certificates that are locally trusted. */
1923 if( top && parent->version < 3 )
1924 need_ca_bit = 0;
1925
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001926 if( need_ca_bit && ! parent->ca_istrue )
1927 return( -1 );
1928
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001929#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02001930 if( need_ca_bit &&
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001931 mbedtls_x509_crt_check_key_usage( parent, MBEDTLS_X509_KU_KEY_CERT_SIGN ) != 0 )
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02001932 {
1933 return( -1 );
1934 }
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02001935#endif
1936
1937 return( 0 );
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02001938}
1939
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02001940/*
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02001941 * Find a suitable parent for child in candidates, or return NULL.
1942 *
1943 * Here suitable is defined as:
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02001944 * 1. subject name matches child's issuer
1945 * 2. if necessary, the CA bit is set and key usage allows signing certs
1946 * 3. for trusted roots, the signature is correct
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02001947 * (for intermediates, the signature is checked and the result reported)
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02001948 * 4. pathlen constraints are satisfied
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02001949 *
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02001950 * If there's a suitable candidate which is also time-valid, return the first
1951 * such. Otherwise, return the first suitable candidate (or NULL if there is
1952 * none).
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02001953 *
1954 * The rationale for this rule is that someone could have a list of trusted
1955 * roots with two versions on the same root with different validity periods.
1956 * (At least one user reported having such a list and wanted it to just work.)
1957 * The reason we don't just require time-validity is that generally there is
1958 * only one version, and if it's expired we want the flags to state that
1959 * rather than NOT_TRUSTED, as would be the case if we required it here.
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02001960 *
1961 * The rationale for rule 3 (signature for trusted roots) is that users might
1962 * have two versions of the same CA with different keys in their list, and the
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02001963 * way we select the correct one is by checking the signature (as we don't
1964 * rely on key identifier extensions). (This is one way users might choose to
1965 * handle key rollover, another relies on self-issued certs, see [SIRO].)
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02001966 *
1967 * Arguments:
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01001968 * - [in] child: certificate for which we're looking for a parent
1969 * - [in] candidates: chained list of potential parents
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02001970 * - [out] r_parent: parent found (or NULL)
1971 * - [out] r_signature_is_good: 1 if child signature by parent is valid, or 0
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01001972 * - [in] top: 1 if candidates consists of trusted roots, ie we're at the top
1973 * of the chain, 0 otherwise
1974 * - [in] path_cnt: number of intermediates seen so far
1975 * - [in] self_cnt: number of self-signed intermediates seen so far
1976 * (will never be greater than path_cnt)
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02001977 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01001978 *
1979 * Return value:
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02001980 * - 0 on success
1981 * - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02001982 */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02001983static int x509_crt_find_parent_in(
1984 mbedtls_x509_crt *child,
1985 mbedtls_x509_crt *candidates,
1986 mbedtls_x509_crt **r_parent,
1987 int *r_signature_is_good,
1988 int top,
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02001989 unsigned path_cnt,
1990 unsigned self_cnt,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02001991 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02001992{
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02001993 int ret;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02001994 mbedtls_x509_crt *parent, *fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02001995 int signature_is_good, fallback_signature_is_good;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02001996
1997#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02001998 /* did we have something in progress? */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02001999 if( rs_ctx != NULL && rs_ctx->parent != NULL )
2000 {
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002001 /* restore saved state */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002002 parent = rs_ctx->parent;
2003 fallback_parent = rs_ctx->fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002004 fallback_signature_is_good = rs_ctx->fallback_signature_is_good;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002005
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002006 /* clear saved state */
2007 rs_ctx->parent = NULL;
2008 rs_ctx->fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002009 rs_ctx->fallback_signature_is_good = 0;
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002010
2011 /* resume where we left */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002012 goto check_signature;
2013 }
2014#endif
2015
2016 fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002017 fallback_signature_is_good = 0;
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002018
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002019 for( parent = candidates; parent != NULL; parent = parent->next )
2020 {
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002021 /* basic parenting skills (name, CA bit, key usage) */
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002022 if( x509_crt_check_parent( child, parent, top ) != 0 )
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002023 continue;
2024
Manuel Pégourié-Gonnard9c6118c2017-06-29 12:38:42 +02002025 /* +1 because stored max_pathlen is 1 higher that the actual value */
2026 if( parent->max_pathlen > 0 &&
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002027 (size_t) parent->max_pathlen < 1 + path_cnt - self_cnt )
Manuel Pégourié-Gonnard9c6118c2017-06-29 12:38:42 +02002028 {
2029 continue;
2030 }
2031
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002032 /* Signature */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002033#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2034check_signature:
2035#endif
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002036 ret = x509_crt_check_signature( child, parent, rs_ctx );
2037
2038#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002039 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
2040 {
2041 /* save state */
2042 rs_ctx->parent = parent;
2043 rs_ctx->fallback_parent = fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002044 rs_ctx->fallback_signature_is_good = fallback_signature_is_good;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002045
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002046 return( ret );
2047 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002048#else
2049 (void) ret;
2050#endif
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002051
2052 signature_is_good = ret == 0;
2053 if( top && ! signature_is_good )
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002054 continue;
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002055
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02002056 /* optional time check */
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002057 if( mbedtls_x509_time_is_past( &parent->valid_to ) ||
2058 mbedtls_x509_time_is_future( &parent->valid_from ) )
2059 {
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002060 if( fallback_parent == NULL )
2061 {
2062 fallback_parent = parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002063 fallback_signature_is_good = signature_is_good;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002064 }
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002065
2066 continue;
2067 }
2068
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002069 break;
2070 }
2071
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002072 if( parent != NULL )
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002073 {
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002074 *r_parent = parent;
2075 *r_signature_is_good = signature_is_good;
2076 }
2077 else
2078 {
2079 *r_parent = fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002080 *r_signature_is_good = fallback_signature_is_good;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002081 }
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002082
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002083 return( 0 );
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002084}
2085
2086/*
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002087 * Find a parent in trusted CAs or the provided chain, or return NULL.
2088 *
2089 * Searches in trusted CAs first, and return the first suitable parent found
2090 * (see find_parent_in() for definition of suitable).
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02002091 *
2092 * Arguments:
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002093 * - [in] child: certificate for which we're looking for a parent, followed
2094 * by a chain of possible intermediates
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002095 * - [in] trust_ca: list of locally trusted certificates
2096 * - [out] parent: parent found (or NULL)
2097 * - [out] parent_is_trusted: 1 if returned `parent` is trusted, or 0
2098 * - [out] signature_is_good: 1 if child signature by parent is valid, or 0
2099 * - [in] path_cnt: number of links in the chain so far (EE -> ... -> child)
2100 * - [in] self_cnt: number of self-signed certs in the chain so far
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002101 * (will always be no greater than path_cnt)
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002102 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002103 *
2104 * Return value:
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002105 * - 0 on success
2106 * - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002107 */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002108static int x509_crt_find_parent(
2109 mbedtls_x509_crt *child,
2110 mbedtls_x509_crt *trust_ca,
2111 mbedtls_x509_crt **parent,
2112 int *parent_is_trusted,
2113 int *signature_is_good,
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002114 unsigned path_cnt,
2115 unsigned self_cnt,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002116 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002117{
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002118 int ret;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002119 mbedtls_x509_crt *search_list;
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002120
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002121 *parent_is_trusted = 1;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002122
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002123#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002124 /* restore then clear saved state if we have some stored */
2125 if( rs_ctx != NULL && rs_ctx->parent_is_trusted != -1 )
2126 {
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002127 *parent_is_trusted = rs_ctx->parent_is_trusted;
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002128 rs_ctx->parent_is_trusted = -1;
2129 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002130#endif
2131
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002132 while( 1 ) {
2133 search_list = *parent_is_trusted ? trust_ca : child->next;
2134
2135 ret = x509_crt_find_parent_in( child, search_list,
2136 parent, signature_is_good,
2137 *parent_is_trusted,
2138 path_cnt, self_cnt, rs_ctx );
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002139
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002140#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002141 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
2142 {
2143 /* save state */
2144 rs_ctx->parent_is_trusted = *parent_is_trusted;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002145 return( ret );
2146 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002147#else
2148 (void) ret;
2149#endif
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002150
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002151 /* stop here if found or already in second iteration */
2152 if( *parent != NULL || *parent_is_trusted == 0 )
2153 break;
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002154
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002155 /* prepare second iteration */
2156 *parent_is_trusted = 0;
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002157 }
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002158
2159 /* extra precaution against mistakes in the caller */
Krzysztof Stachowiakc388a8c2018-10-31 16:49:20 +01002160 if( *parent == NULL )
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002161 {
Manuel Pégourié-Gonnarda5a3e402018-10-16 11:27:23 +02002162 *parent_is_trusted = 0;
2163 *signature_is_good = 0;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002164 }
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002165
2166 return( 0 );
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002167}
2168
2169/*
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002170 * Check if an end-entity certificate is locally trusted
2171 *
2172 * Currently we require such certificates to be self-signed (actually only
2173 * check for self-issued as self-signatures are not checked)
2174 */
2175static int x509_crt_check_ee_locally_trusted(
2176 mbedtls_x509_crt *crt,
2177 mbedtls_x509_crt *trust_ca )
2178{
2179 mbedtls_x509_crt *cur;
2180
2181 /* must be self-issued */
Hanno Becker7dee12a2019-02-21 13:58:38 +00002182 if( mbedtls_x509_name_cmp_raw( &crt->issuer_raw_no_hdr,
Hanno Becker67284cc2019-02-21 14:31:51 +00002183 &crt->subject_raw_no_hdr,
2184 NULL, NULL ) != 0 )
Hanno Becker7dee12a2019-02-21 13:58:38 +00002185 {
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002186 return( -1 );
Hanno Becker7dee12a2019-02-21 13:58:38 +00002187 }
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002188
2189 /* look for an exact match with trusted cert */
2190 for( cur = trust_ca; cur != NULL; cur = cur->next )
2191 {
2192 if( crt->raw.len == cur->raw.len &&
2193 memcmp( crt->raw.p, cur->raw.p, crt->raw.len ) == 0 )
2194 {
2195 return( 0 );
2196 }
2197 }
2198
2199 /* too bad */
2200 return( -1 );
2201}
2202
2203/*
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002204 * Build and verify a certificate chain
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02002205 *
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002206 * Given a peer-provided list of certificates EE, C1, ..., Cn and
2207 * a list of trusted certs R1, ... Rp, try to build and verify a chain
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02002208 * EE, Ci1, ... Ciq [, Rj]
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002209 * such that every cert in the chain is a child of the next one,
2210 * jumping to a trusted root as early as possible.
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002211 *
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002212 * Verify that chain and return it with flags for all issues found.
2213 *
2214 * Special cases:
2215 * - EE == Rj -> return a one-element list containing it
2216 * - EE, Ci1, ..., Ciq cannot be continued with a trusted root
2217 * -> return that chain with NOT_TRUSTED set on Ciq
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002218 *
Manuel Pégourié-Gonnardd19a41d2017-07-14 11:05:59 +02002219 * Tests for (aspects of) this function should include at least:
2220 * - trusted EE
2221 * - EE -> trusted root
2222 * - EE -> intermedate CA -> trusted root
2223 * - if relevant: EE untrusted
2224 * - if relevant: EE -> intermediate, untrusted
2225 * with the aspect under test checked at each relevant level (EE, int, root).
2226 * For some aspects longer chains are required, but usually length 2 is
2227 * enough (but length 1 is not in general).
2228 *
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002229 * Arguments:
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002230 * - [in] crt: the cert list EE, C1, ..., Cn
2231 * - [in] trust_ca: the trusted list R1, ..., Rp
2232 * - [in] ca_crl, profile: as in verify_with_profile()
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002233 * - [out] ver_chain: the built and verified chain
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02002234 * Only valid when return value is 0, may contain garbage otherwise!
2235 * Restart note: need not be the same when calling again to resume.
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02002236 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002237 *
2238 * Return value:
2239 * - non-zero if the chain could not be fully built and examined
2240 * - 0 is the chain was successfully built and examined,
2241 * even if it was found to be invalid
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02002242 */
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002243static int x509_crt_verify_chain(
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002244 mbedtls_x509_crt *crt,
2245 mbedtls_x509_crt *trust_ca,
2246 mbedtls_x509_crl *ca_crl,
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002247 const mbedtls_x509_crt_profile *profile,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002248 mbedtls_x509_crt_verify_chain *ver_chain,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002249 mbedtls_x509_crt_restart_ctx *rs_ctx )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002250{
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02002251 /* Don't initialize any of those variables here, so that the compiler can
2252 * catch potential issues with jumping ahead when restarting */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002253 int ret;
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002254 uint32_t *flags;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002255 mbedtls_x509_crt_verify_chain_item *cur;
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002256 mbedtls_x509_crt *child;
Manuel Pégourié-Gonnard58dcd2d2017-07-03 21:35:04 +02002257 mbedtls_x509_crt *parent;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002258 int parent_is_trusted;
2259 int child_is_trusted;
2260 int signature_is_good;
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002261 unsigned self_cnt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002262
2263#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2264 /* resume if we had an operation in progress */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002265 if( rs_ctx != NULL && rs_ctx->in_progress == x509_crt_rs_find_parent )
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002266 {
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002267 /* restore saved state */
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02002268 *ver_chain = rs_ctx->ver_chain; /* struct copy */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002269 self_cnt = rs_ctx->self_cnt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002270
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002271 /* restore derived state */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002272 cur = &ver_chain->items[ver_chain->len - 1];
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002273 child = cur->crt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002274 flags = &cur->flags;
2275
2276 goto find_parent;
2277 }
2278#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
Manuel Pégourié-Gonnard8f8c2822017-07-03 21:25:10 +02002279
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002280 child = crt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002281 self_cnt = 0;
2282 parent_is_trusted = 0;
2283 child_is_trusted = 0;
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002284
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002285 while( 1 ) {
2286 /* Add certificate to the verification chain */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002287 cur = &ver_chain->items[ver_chain->len];
2288 cur->crt = child;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002289 cur->flags = 0;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002290 ver_chain->len++;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002291 flags = &cur->flags;
Manuel Pégourié-Gonnard66fac752017-07-03 21:39:21 +02002292
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002293 /* Check time-validity (all certificates) */
2294 if( mbedtls_x509_time_is_past( &child->valid_to ) )
2295 *flags |= MBEDTLS_X509_BADCERT_EXPIRED;
Manuel Pégourié-Gonnard66fac752017-07-03 21:39:21 +02002296
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002297 if( mbedtls_x509_time_is_future( &child->valid_from ) )
2298 *flags |= MBEDTLS_X509_BADCERT_FUTURE;
Manuel Pégourié-Gonnardcb396102017-07-04 00:00:24 +02002299
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002300 /* Stop here for trusted roots (but not for trusted EE certs) */
2301 if( child_is_trusted )
2302 return( 0 );
Manuel Pégourié-Gonnard66fac752017-07-03 21:39:21 +02002303
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002304 /* Check signature algorithm: MD & PK algs */
2305 if( x509_profile_check_md_alg( profile, child->sig_md ) != 0 )
2306 *flags |= MBEDTLS_X509_BADCERT_BAD_MD;
Manuel Pégourié-Gonnard66fac752017-07-03 21:39:21 +02002307
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002308 if( x509_profile_check_pk_alg( profile, child->sig_pk ) != 0 )
2309 *flags |= MBEDTLS_X509_BADCERT_BAD_PK;
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002310
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002311 /* Special case: EE certs that are locally trusted */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002312 if( ver_chain->len == 1 &&
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002313 x509_crt_check_ee_locally_trusted( child, trust_ca ) == 0 )
2314 {
2315 return( 0 );
2316 }
Manuel Pégourié-Gonnard8f8c2822017-07-03 21:25:10 +02002317
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002318#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2319find_parent:
2320#endif
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002321 /* Look for a parent in trusted CAs or up the chain */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002322 ret = x509_crt_find_parent( child, trust_ca, &parent,
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002323 &parent_is_trusted, &signature_is_good,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002324 ver_chain->len - 1, self_cnt, rs_ctx );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002325
2326#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002327 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
2328 {
2329 /* save state */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002330 rs_ctx->in_progress = x509_crt_rs_find_parent;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002331 rs_ctx->self_cnt = self_cnt;
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02002332 rs_ctx->ver_chain = *ver_chain; /* struct copy */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002333
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002334 return( ret );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002335 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002336#else
2337 (void) ret;
2338#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002339
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002340 /* No parent? We're done here */
2341 if( parent == NULL )
2342 {
2343 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
2344 return( 0 );
2345 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002346
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002347 /* Count intermediate self-issued (not necessarily self-signed) certs.
2348 * These can occur with some strategies for key rollover, see [SIRO],
2349 * and should be excluded from max_pathlen checks. */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002350 if( ver_chain->len != 1 &&
Hanno Becker7dee12a2019-02-21 13:58:38 +00002351 mbedtls_x509_name_cmp_raw( &child->issuer_raw_no_hdr,
Hanno Becker67284cc2019-02-21 14:31:51 +00002352 &child->subject_raw_no_hdr,
2353 NULL, NULL ) == 0 )
Manuel Pégourié-Gonnard24611f92017-08-09 10:28:07 +02002354 {
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002355 self_cnt++;
Manuel Pégourié-Gonnard24611f92017-08-09 10:28:07 +02002356 }
Manuel Pégourié-Gonnardfd6c85c2014-11-20 16:34:20 +01002357
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002358 /* path_cnt is 0 for the first intermediate CA,
2359 * and if parent is trusted it's not an intermediate CA */
2360 if( ! parent_is_trusted &&
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002361 ver_chain->len > MBEDTLS_X509_MAX_INTERMEDIATE_CA )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002362 {
2363 /* return immediately to avoid overflow the chain array */
2364 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2365 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002366
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02002367 /* signature was checked while searching parent */
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002368 if( ! signature_is_good )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002369 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
2370
2371 /* check size of signing key */
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +02002372 if( x509_profile_check_key( profile, &parent->pk ) != 0 )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002373 *flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002374
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002375#if defined(MBEDTLS_X509_CRL_PARSE_C)
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002376 /* Check trusted CA's CRL for the given crt */
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02002377 *flags |= x509_crt_verifycrl( child, parent, ca_crl, profile );
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002378#else
2379 (void) ca_crl;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002380#endif
2381
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002382 /* prepare for next iteration */
2383 child = parent;
2384 parent = NULL;
2385 child_is_trusted = parent_is_trusted;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002386 signature_is_good = 0;
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002387 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002388}
2389
2390/*
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002391 * Check for CN match
2392 */
Hanno Becker24926222019-02-21 13:10:55 +00002393static int x509_crt_check_cn( unsigned char const *buf,
2394 size_t buflen,
2395 const char *cn,
2396 size_t cn_len )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002397{
Hanno Becker24926222019-02-21 13:10:55 +00002398 /* Try exact match */
2399 if( buflen == cn_len &&
2400 mbedtls_x509_memcasecmp( cn, buf, cn_len ) == 0 )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002401 {
2402 return( 0 );
2403 }
2404
2405 /* try wildcard match */
Hanno Becker24926222019-02-21 13:10:55 +00002406 if( x509_check_wildcard( cn, cn_len, buf, buflen ) == 0 )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002407 {
2408 return( 0 );
2409 }
2410
2411 return( -1 );
2412}
2413
Hanno Becker8b543b32019-02-21 11:50:44 +00002414/* Returns 1 on a match and 0 on a mismatch.
2415 * This is because this function is used as a callback for
2416 * mbedtls_x509_name_cmp_raw(), which continues the name
2417 * traversal as long as the callback returns 0. */
2418static int x509_crt_check_name( void *ctx,
2419 mbedtls_x509_buf *oid,
2420 mbedtls_x509_buf *val )
2421{
2422 char const *cn = (char const*) ctx;
2423 size_t cn_len = strlen( cn );
2424
2425 if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, oid ) == 0 &&
Hanno Becker24926222019-02-21 13:10:55 +00002426 x509_crt_check_cn( val->p, val->len, cn, cn_len ) == 0 )
Hanno Becker8b543b32019-02-21 11:50:44 +00002427 {
2428 return( 1 );
2429 }
2430
2431 return( 0 );
2432}
2433
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002434/*
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002435 * Verify the requested CN - only call this if cn is not NULL!
2436 */
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002437static void x509_crt_verify_name( const mbedtls_x509_crt *crt,
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002438 const char *cn,
2439 uint32_t *flags )
2440{
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002441 const mbedtls_x509_sequence *cur;
2442 size_t cn_len = strlen( cn );
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002443
2444 if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
2445 {
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02002446 for( cur = &crt->subject_alt_names; cur != NULL; cur = cur->next )
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002447 {
Hanno Becker24926222019-02-21 13:10:55 +00002448 if( x509_crt_check_cn( cur->buf.p, cur->buf.len,
2449 cn, cn_len ) == 0 )
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002450 break;
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002451 }
2452
2453 if( cur == NULL )
2454 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
2455 }
2456 else
2457 {
Hanno Becker8b543b32019-02-21 11:50:44 +00002458 int ret;
2459 ret = mbedtls_x509_name_cmp_raw( &crt->subject_raw_no_hdr,
2460 &crt->subject_raw_no_hdr,
2461 x509_crt_check_name, (void*) cn );
2462 if( ret != 1 )
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002463 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
2464 }
2465}
2466
2467/*
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002468 * Merge the flags for all certs in the chain, after calling callback
2469 */
2470static int x509_crt_merge_flags_with_cb(
2471 uint32_t *flags,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002472 const mbedtls_x509_crt_verify_chain *ver_chain,
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002473 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
2474 void *p_vrfy )
2475{
2476 int ret;
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002477 unsigned i;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002478 uint32_t cur_flags;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002479 const mbedtls_x509_crt_verify_chain_item *cur;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002480
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002481 for( i = ver_chain->len; i != 0; --i )
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002482 {
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002483 cur = &ver_chain->items[i-1];
2484 cur_flags = cur->flags;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002485
2486 if( NULL != f_vrfy )
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002487 if( ( ret = f_vrfy( p_vrfy, cur->crt, (int) i-1, &cur_flags ) ) != 0 )
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002488 return( ret );
2489
2490 *flags |= cur_flags;
2491 }
2492
2493 return( 0 );
2494}
2495
2496/*
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02002497 * Verify the certificate validity (default profile, not restartable)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002498 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002499int mbedtls_x509_crt_verify( mbedtls_x509_crt *crt,
2500 mbedtls_x509_crt *trust_ca,
2501 mbedtls_x509_crl *ca_crl,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02002502 const char *cn, uint32_t *flags,
2503 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Paul Bakkerddf26b42013-09-18 13:46:23 +02002504 void *p_vrfy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002505{
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02002506 return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
2507 &mbedtls_x509_crt_profile_default, cn, flags,
2508 f_vrfy, p_vrfy, NULL ) );
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002509}
2510
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002511/*
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02002512 * Verify the certificate validity (user-chosen profile, not restartable)
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002513 */
2514int mbedtls_x509_crt_verify_with_profile( mbedtls_x509_crt *crt,
2515 mbedtls_x509_crt *trust_ca,
2516 mbedtls_x509_crl *ca_crl,
2517 const mbedtls_x509_crt_profile *profile,
2518 const char *cn, uint32_t *flags,
2519 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
2520 void *p_vrfy )
2521{
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02002522 return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
2523 profile, cn, flags, f_vrfy, p_vrfy, NULL ) );
2524}
2525
2526/*
2527 * Verify the certificate validity, with profile, restartable version
2528 *
2529 * This function:
2530 * - checks the requested CN (if any)
2531 * - checks the type and size of the EE cert's key,
2532 * as that isn't done as part of chain building/verification currently
2533 * - builds and verifies the chain
2534 * - then calls the callback and merges the flags
2535 */
2536int mbedtls_x509_crt_verify_restartable( mbedtls_x509_crt *crt,
2537 mbedtls_x509_crt *trust_ca,
2538 mbedtls_x509_crl *ca_crl,
2539 const mbedtls_x509_crt_profile *profile,
2540 const char *cn, uint32_t *flags,
2541 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
2542 void *p_vrfy,
2543 mbedtls_x509_crt_restart_ctx *rs_ctx )
2544{
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002545 int ret;
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02002546 mbedtls_pk_type_t pk_type;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002547 mbedtls_x509_crt_verify_chain ver_chain;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002548 uint32_t ee_flags;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002549
2550 *flags = 0;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002551 ee_flags = 0;
2552 x509_crt_verify_chain_reset( &ver_chain );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002553
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02002554 if( profile == NULL )
2555 {
2556 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
2557 goto exit;
2558 }
2559
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02002560 /* check name if requested */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002561 if( cn != NULL )
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002562 x509_crt_verify_name( crt, cn, &ee_flags );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002563
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02002564 /* Check the type and size of the key */
2565 pk_type = mbedtls_pk_get_type( &crt->pk );
2566
2567 if( x509_profile_check_pk_alg( profile, pk_type ) != 0 )
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002568 ee_flags |= MBEDTLS_X509_BADCERT_BAD_PK;
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02002569
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +02002570 if( x509_profile_check_key( profile, &crt->pk ) != 0 )
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002571 ee_flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02002572
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002573 /* Check the chain */
Manuel Pégourié-Gonnard505c3952017-07-05 17:36:47 +02002574 ret = x509_crt_verify_chain( crt, trust_ca, ca_crl, profile,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002575 &ver_chain, rs_ctx );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002576
Manuel Pégourié-Gonnardc547d1a2017-07-05 13:28:45 +02002577 if( ret != 0 )
2578 goto exit;
2579
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002580 /* Merge end-entity flags */
2581 ver_chain.items[0].flags |= ee_flags;
2582
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02002583 /* Build final flags, calling callback on the way if any */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002584 ret = x509_crt_merge_flags_with_cb( flags, &ver_chain, f_vrfy, p_vrfy );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002585
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02002586exit:
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002587#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2588 if( rs_ctx != NULL && ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
2589 mbedtls_x509_crt_restart_free( rs_ctx );
2590#endif
2591
Manuel Pégourié-Gonnard9107b5f2017-07-06 12:16:25 +02002592 /* prevent misuse of the vrfy callback - VERIFY_FAILED would be ignored by
2593 * the SSL module for authmode optional, but non-zero return from the
2594 * callback means a fatal error so it shouldn't be ignored */
Manuel Pégourié-Gonnard31458a12017-06-26 10:11:49 +02002595 if( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
2596 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2597
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02002598 if( ret != 0 )
2599 {
2600 *flags = (uint32_t) -1;
2601 return( ret );
2602 }
2603
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002604 if( *flags != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002605 return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002606
2607 return( 0 );
2608}
2609
2610/*
Paul Bakker369d2eb2013-09-18 11:58:25 +02002611 * Initialize a certificate chain
2612 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002613void mbedtls_x509_crt_init( mbedtls_x509_crt *crt )
Paul Bakker369d2eb2013-09-18 11:58:25 +02002614{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002615 memset( crt, 0, sizeof(mbedtls_x509_crt) );
Paul Bakker369d2eb2013-09-18 11:58:25 +02002616}
2617
2618/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002619 * Unallocate all certificate data
2620 */
Hanno Beckercd03bb22019-02-15 17:15:53 +00002621
2622static void x509_free_sequence( mbedtls_x509_sequence *seq )
2623{
2624 while( seq != NULL )
2625 {
2626 mbedtls_x509_sequence *next = seq->next;
2627 mbedtls_platform_zeroize( seq, sizeof( *seq ) );
2628 mbedtls_free( seq );
2629 seq = next;
2630 }
2631}
2632
2633static void x509_free_name( mbedtls_x509_name *name )
2634{
2635 while( name != NULL )
2636 {
2637 mbedtls_x509_name *next = name->next;
2638 mbedtls_platform_zeroize( name, sizeof( *name ) );
2639 mbedtls_free( name );
2640 name = next;
2641 }
2642}
2643
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002644void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002645{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002646 mbedtls_x509_crt *cert_cur = crt;
2647 mbedtls_x509_crt *cert_prv;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002648
2649 if( crt == NULL )
2650 return;
2651
2652 do
2653 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002654 mbedtls_pk_free( &cert_cur->pk );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002655
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002656#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
2657 mbedtls_free( cert_cur->sig_opts );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +02002658#endif
2659
Hanno Beckercd03bb22019-02-15 17:15:53 +00002660 x509_free_name( cert_cur->issuer.next );
2661 x509_free_name( cert_cur->subject.next );
2662 x509_free_sequence( cert_cur->ext_key_usage.next );
2663 x509_free_sequence( cert_cur->subject_alt_names.next );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002664
Hanno Beckeraa8665a2019-01-31 08:57:44 +00002665 if( cert_cur->raw.p != NULL && cert_cur->own_buffer )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002666 {
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05002667 mbedtls_platform_zeroize( cert_cur->raw.p, cert_cur->raw.len );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002668 mbedtls_free( cert_cur->raw.p );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002669 }
2670
2671 cert_cur = cert_cur->next;
2672 }
2673 while( cert_cur != NULL );
2674
2675 cert_cur = crt;
2676 do
2677 {
2678 cert_prv = cert_cur;
2679 cert_cur = cert_cur->next;
2680
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05002681 mbedtls_platform_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002682 if( cert_prv != crt )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002683 mbedtls_free( cert_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002684 }
2685 while( cert_cur != NULL );
2686}
2687
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02002688#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2689/*
2690 * Initialize a restart context
2691 */
2692void mbedtls_x509_crt_restart_init( mbedtls_x509_crt_restart_ctx *ctx )
2693{
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02002694 mbedtls_pk_restart_init( &ctx->pk );
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002695
2696 ctx->parent = NULL;
2697 ctx->fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002698 ctx->fallback_signature_is_good = 0;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002699
2700 ctx->parent_is_trusted = -1;
2701
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002702 ctx->in_progress = x509_crt_rs_none;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002703 ctx->self_cnt = 0;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002704 x509_crt_verify_chain_reset( &ctx->ver_chain );
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02002705}
2706
2707/*
2708 * Free the components of a restart context
2709 */
2710void mbedtls_x509_crt_restart_free( mbedtls_x509_crt_restart_ctx *ctx )
2711{
2712 if( ctx == NULL )
2713 return;
2714
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02002715 mbedtls_pk_restart_free( &ctx->pk );
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002716 mbedtls_x509_crt_restart_init( ctx );
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02002717}
2718#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
2719
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002720#endif /* MBEDTLS_X509_CRT_PARSE_C */