blob: 960296de8b821461f0e6209fb541b89bed53d37e [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
Hanno Becker21f55672019-02-15 15:27:59 +000081static int x509_crt_parse_frame( unsigned char *start,
82 unsigned char *end,
83 mbedtls_x509_crt_frame *frame );
84static int x509_crt_subject_from_frame( mbedtls_x509_crt_frame *frame,
85 mbedtls_x509_name *subject );
86static int x509_crt_issuer_from_frame( mbedtls_x509_crt_frame *frame,
87 mbedtls_x509_name *issuer );
88static int x509_crt_subject_alt_from_frame( mbedtls_x509_crt_frame *frame,
89 mbedtls_x509_sequence *subject_alt );
90static int x509_crt_ext_key_usage_from_frame( mbedtls_x509_crt_frame *frame,
91 mbedtls_x509_sequence *ext_key_usage );
92
Hanno Becker337088a2019-02-25 14:53:14 +000093static void x509_free_sequence( mbedtls_x509_sequence *seq );
94static void x509_free_name( mbedtls_x509_name *name );
95
Hanno Beckerb6c39fc2019-02-25 13:50:14 +000096int mbedtls_x509_crt_cache_provide_frame( mbedtls_x509_crt const *crt )
Hanno Becker337088a2019-02-25 14:53:14 +000097{
Hanno Beckerb6c39fc2019-02-25 13:50:14 +000098 mbedtls_x509_crt_cache *cache = crt->cache;
Hanno Becker337088a2019-02-25 14:53:14 +000099 mbedtls_x509_crt_frame *frame;
100
101 frame = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_frame ) );
102 if( frame == NULL )
103 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000104 cache->frame = frame;
Hanno Becker337088a2019-02-25 14:53:14 +0000105
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000106 return( x509_crt_parse_frame( crt->raw.p,
107 crt->raw.p + crt->raw.len,
108 frame ) );
109}
Hanno Becker337088a2019-02-25 14:53:14 +0000110
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000111int mbedtls_x509_crt_cache_provide_pk( mbedtls_x509_crt const *crt )
112{
113 mbedtls_x509_crt_cache *cache = crt->cache;
114 mbedtls_pk_context *pk;
115
116 pk = mbedtls_calloc( 1, sizeof( mbedtls_pk_context ) );
117 if( pk == NULL )
118 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000119 cache->pk = pk;
Hanno Becker180f7bf2019-02-28 13:23:38 +0000120
121#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
122 *pk = crt->pk;
Hanno Becker337088a2019-02-25 14:53:14 +0000123 return( 0 );
Hanno Becker180f7bf2019-02-28 13:23:38 +0000124#else
125 {
126 mbedtls_x509_buf_raw pk_raw = cache->pk_raw;
127 return( mbedtls_pk_parse_subpubkey( &pk_raw.p,
128 pk_raw.p + pk_raw.len,
129 pk ) );
130 }
131#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Becker337088a2019-02-25 14:53:14 +0000132}
133
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000134static void x509_crt_cache_init( mbedtls_x509_crt_cache *cache )
Hanno Becker337088a2019-02-25 14:53:14 +0000135{
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000136 memset( cache, 0, sizeof( *cache ) );
137#if defined(MBEDTLS_THREADING_C)
138 mbedtls_mutex_init( &cache->frame_mutex );
139 mbedtls_mutex_init( &cache->pk_mutex );
140#endif
141}
142
143static void x509_crt_cache_clear_pk( mbedtls_x509_crt_cache *cache )
144{
Hanno Becker180f7bf2019-02-28 13:23:38 +0000145#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000146 /* The cache holds a shallow copy of the PK context
147 * in the legacy struct, so don't free PK context. */
148 mbedtls_free( cache->pk );
Hanno Becker180f7bf2019-02-28 13:23:38 +0000149#else
150 mbedtls_pk_free( cache->pk );
151 mbedtls_free( cache->pk );
152#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
153
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000154 cache->pk = NULL;
155}
156
157static void x509_crt_cache_clear_frame( mbedtls_x509_crt_cache *cache )
158{
159 mbedtls_free( cache->frame );
160 cache->frame = NULL;
161}
162
163static void x509_crt_cache_free( mbedtls_x509_crt_cache *cache )
164{
165 if( cache == NULL )
Hanno Becker337088a2019-02-25 14:53:14 +0000166 return;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000167
168#if defined(MBEDTLS_THREADING_C)
169 mbedtls_mutex_free( &cache->frame_mutex );
170 mbedtls_mutex_free( &cache->pk_mutex );
171#endif
172
173 x509_crt_cache_clear_frame( cache );
174 x509_crt_cache_clear_pk( cache );
175
176 memset( cache, 0, sizeof( *cache ) );
Hanno Becker337088a2019-02-25 14:53:14 +0000177}
178
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000179int mbedtls_x509_crt_flush_cache( mbedtls_x509_crt const *crt )
Hanno Becker337088a2019-02-25 14:53:14 +0000180{
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000181#if defined(MBEDTLS_THREADING_C)
182 if( mbedtls_mutex_lock( &crt->cache->frame_mutex ) != 0 )
183 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
184 if( mbedtls_mutex_lock( &crt->cache->pk_mutex ) != 0 )
185 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
186#endif
187 x509_crt_cache_clear_frame( crt->cache );
188 x509_crt_cache_clear_pk( crt->cache );
189#if defined(MBEDTLS_THREADING_C)
190 if( mbedtls_mutex_unlock( &crt->cache->frame_mutex ) != 0 )
191 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
192 if( mbedtls_mutex_unlock( &crt->cache->pk_mutex ) != 0 )
193 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
194#endif
195 return( 0 );
Hanno Becker337088a2019-02-25 14:53:14 +0000196}
197
Hanno Becker823efad2019-02-28 13:23:58 +0000198int mbedtls_x509_crt_get_frame( mbedtls_x509_crt const *crt,
199 mbedtls_x509_crt_frame *dst )
200{
201 int ret;
202 mbedtls_x509_crt_frame *frame;
203 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
204 if( ret != 0 )
205 return( ret );
206 *dst = *frame;
207 mbedtls_x509_crt_frame_release( crt, frame );
208 return( 0 );
209}
210
211int mbedtls_x509_crt_get_pk( mbedtls_x509_crt const *crt,
212 mbedtls_pk_context *dst )
213{
214#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
215 mbedtls_x509_buf_raw pk_raw = crt->cache->pk_raw;
216 return( mbedtls_pk_parse_subpubkey( &pk_raw.p,
217 pk_raw.p + pk_raw.len,
218 dst ) );
219#else /* !MBEDTLS_X509_ON_DEMAND_PARSING */
220 int ret;
221 mbedtls_pk_context *pk;
222 ret = mbedtls_x509_crt_pk_acquire( crt, &pk );
223 if( ret != 0 )
224 return( ret );
225
226 /* Move PK from CRT cache to destination pointer
227 * to avoid a copy. */
228 *dst = *pk;
229 mbedtls_free( crt->cache->pk );
230 crt->cache->pk = NULL;
231
232 mbedtls_x509_crt_pk_release( crt, pk );
233 return( 0 );
234#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
235}
236
Manuel Pégourié-Gonnardc547d1a2017-07-05 13:28:45 +0200237/*
238 * Item in a verification chain: cert and flags for it
239 */
240typedef struct {
241 mbedtls_x509_crt *crt;
242 uint32_t flags;
243} x509_crt_verify_chain_item;
244
245/*
246 * Max size of verification chain: end-entity + intermediates + trusted root
247 */
248#define X509_MAX_VERIFY_CHAIN_SIZE ( MBEDTLS_X509_MAX_INTERMEDIATE_CA + 2 )
Paul Bakker34617722014-06-13 17:20:13 +0200249
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200250/*
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200251 * Default profile
252 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200253const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_default =
254{
Gilles Peskine5d2511c2017-05-12 13:16:40 +0200255#if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES)
Gilles Peskine5e79cb32017-05-04 16:17:21 +0200256 /* Allow SHA-1 (weak, but still safe in controlled environments) */
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200257 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 ) |
Gilles Peskine5e79cb32017-05-04 16:17:21 +0200258#endif
259 /* Only SHA-2 hashes */
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200260 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA224 ) |
261 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
262 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
263 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
264 0xFFFFFFF, /* Any PK alg */
265 0xFFFFFFF, /* Any curve */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200266 2048,
267};
268
269/*
270 * Next-default profile
271 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200272const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_next =
273{
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200274 /* Hashes from SHA-256 and above */
275 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
276 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
277 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
278 0xFFFFFFF, /* Any PK alg */
279#if defined(MBEDTLS_ECP_C)
280 /* Curves at or above 128-bit security level */
281 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
282 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ) |
283 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP521R1 ) |
284 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP256R1 ) |
285 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP384R1 ) |
286 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP512R1 ) |
287 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256K1 ),
288#else
289 0,
290#endif
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200291 2048,
292};
293
294/*
295 * NSA Suite B Profile
296 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200297const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_suiteb =
298{
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200299 /* Only SHA-256 and 384 */
300 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
301 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ),
302 /* Only ECDSA */
Ron Eldor85e1dcf2018-02-06 15:59:38 +0200303 MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECDSA ) |
304 MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECKEY ),
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200305#if defined(MBEDTLS_ECP_C)
306 /* Only NIST P-256 and P-384 */
307 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
308 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ),
309#else
310 0,
311#endif
312 0,
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200313};
314
315/*
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200316 * Check md_alg against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200317 * Return 0 if md_alg is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200318 */
319static int x509_profile_check_md_alg( const mbedtls_x509_crt_profile *profile,
320 mbedtls_md_type_t md_alg )
321{
Philippe Antoineb5b25432018-05-11 11:06:29 +0200322 if( md_alg == MBEDTLS_MD_NONE )
323 return( -1 );
324
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200325 if( ( profile->allowed_mds & MBEDTLS_X509_ID_FLAG( md_alg ) ) != 0 )
326 return( 0 );
327
328 return( -1 );
329}
330
331/*
332 * Check pk_alg against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200333 * Return 0 if pk_alg is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200334 */
335static int x509_profile_check_pk_alg( const mbedtls_x509_crt_profile *profile,
336 mbedtls_pk_type_t pk_alg )
337{
Philippe Antoineb5b25432018-05-11 11:06:29 +0200338 if( pk_alg == MBEDTLS_PK_NONE )
339 return( -1 );
340
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200341 if( ( profile->allowed_pks & MBEDTLS_X509_ID_FLAG( pk_alg ) ) != 0 )
342 return( 0 );
343
344 return( -1 );
345}
346
347/*
348 * Check key against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200349 * Return 0 if pk is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200350 */
351static int x509_profile_check_key( const mbedtls_x509_crt_profile *profile,
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200352 const mbedtls_pk_context *pk )
353{
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200354 const mbedtls_pk_type_t pk_alg = mbedtls_pk_get_type( pk );
Manuel Pégourié-Gonnard19773ff2017-10-24 10:51:26 +0200355
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200356#if defined(MBEDTLS_RSA_C)
357 if( pk_alg == MBEDTLS_PK_RSA || pk_alg == MBEDTLS_PK_RSASSA_PSS )
358 {
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +0200359 if( mbedtls_pk_get_bitlen( pk ) >= profile->rsa_min_bitlen )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200360 return( 0 );
361
362 return( -1 );
363 }
364#endif
365
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +0200366#if defined(MBEDTLS_ECP_C)
367 if( pk_alg == MBEDTLS_PK_ECDSA ||
368 pk_alg == MBEDTLS_PK_ECKEY ||
369 pk_alg == MBEDTLS_PK_ECKEY_DH )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200370 {
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200371 const mbedtls_ecp_group_id gid = mbedtls_pk_ec( *pk )->grp.id;
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200372
Philippe Antoineb5b25432018-05-11 11:06:29 +0200373 if( gid == MBEDTLS_ECP_DP_NONE )
374 return( -1 );
375
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200376 if( ( profile->allowed_curves & MBEDTLS_X509_ID_FLAG( gid ) ) != 0 )
377 return( 0 );
378
379 return( -1 );
380 }
381#endif
382
383 return( -1 );
384}
385
386/*
Hanno Becker1f8527f2018-11-02 09:19:16 +0000387 * Return 0 if name matches wildcard, -1 otherwise
388 */
Hanno Becker24926222019-02-21 13:10:55 +0000389static int x509_check_wildcard( char const *cn,
390 size_t cn_len,
391 unsigned char const *buf,
392 size_t buf_len )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000393{
394 size_t i;
Hanno Becker24926222019-02-21 13:10:55 +0000395 size_t cn_idx = 0;
Hanno Becker1f8527f2018-11-02 09:19:16 +0000396
397 /* We can't have a match if there is no wildcard to match */
Hanno Becker24926222019-02-21 13:10:55 +0000398 if( buf_len < 3 || buf[0] != '*' || buf[1] != '.' )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000399 return( -1 );
400
401 for( i = 0; i < cn_len; ++i )
402 {
403 if( cn[i] == '.' )
404 {
405 cn_idx = i;
406 break;
407 }
408 }
409
410 if( cn_idx == 0 )
411 return( -1 );
412
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000413 if( mbedtls_x509_memcasecmp( buf + 1, cn + cn_idx,
414 buf_len - 1, cn_len - cn_idx ) == 0 )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000415 {
416 return( 0 );
417 }
418
419 return( -1 );
420}
421
422/*
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +0200423 * Reset (init or clear) a verify_chain
424 */
425static void x509_crt_verify_chain_reset(
426 mbedtls_x509_crt_verify_chain *ver_chain )
427{
428 size_t i;
429
430 for( i = 0; i < MBEDTLS_X509_MAX_VERIFY_CHAIN_SIZE; i++ )
431 {
432 ver_chain->items[i].crt = NULL;
Hanno Beckerd6ddcd62019-01-10 09:19:26 +0000433 ver_chain->items[i].flags = (uint32_t) -1;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +0200434 }
435
436 ver_chain->len = 0;
437}
438
439/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200440 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
441 */
442static int x509_get_version( unsigned char **p,
443 const unsigned char *end,
444 int *ver )
445{
446 int ret;
447 size_t len;
448
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200449 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
450 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200451 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200452 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200453 {
454 *ver = 0;
455 return( 0 );
456 }
457
Hanno Becker2f472142019-02-12 11:52:10 +0000458 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200459 }
460
461 end = *p + len;
462
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200463 if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
464 return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200465
466 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200467 return( MBEDTLS_ERR_X509_INVALID_VERSION +
468 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200469
470 return( 0 );
471}
472
473/*
474 * Validity ::= SEQUENCE {
475 * notBefore Time,
476 * notAfter Time }
477 */
478static int x509_get_dates( unsigned char **p,
479 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200480 mbedtls_x509_time *from,
481 mbedtls_x509_time *to )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200482{
483 int ret;
484 size_t len;
485
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200486 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
487 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
488 return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200489
490 end = *p + len;
491
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200492 if( ( ret = mbedtls_x509_get_time( p, end, from ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200493 return( ret );
494
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200495 if( ( ret = mbedtls_x509_get_time( p, end, to ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200496 return( ret );
497
498 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200499 return( MBEDTLS_ERR_X509_INVALID_DATE +
500 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200501
502 return( 0 );
503}
504
505/*
506 * X.509 v2/v3 unique identifier (not parsed)
507 */
508static int x509_get_uid( unsigned char **p,
509 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200510 mbedtls_x509_buf *uid, int n )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200511{
512 int ret;
513
514 if( *p == end )
515 return( 0 );
516
517 uid->tag = **p;
518
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200519 if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
520 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200521 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200522 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200523 return( 0 );
524
Hanno Becker2f472142019-02-12 11:52:10 +0000525 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200526 }
527
528 uid->p = *p;
529 *p += uid->len;
530
531 return( 0 );
532}
533
534static int x509_get_basic_constraints( unsigned char **p,
535 const unsigned char *end,
536 int *ca_istrue,
537 int *max_pathlen )
538{
539 int ret;
540 size_t len;
541
542 /*
543 * BasicConstraints ::= SEQUENCE {
544 * cA BOOLEAN DEFAULT FALSE,
545 * pathLenConstraint INTEGER (0..MAX) OPTIONAL }
546 */
547 *ca_istrue = 0; /* DEFAULT FALSE */
548 *max_pathlen = 0; /* endless */
549
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200550 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
551 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000552 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200553
554 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200555 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200556
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200557 if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200558 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200559 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
560 ret = mbedtls_asn1_get_int( p, end, ca_istrue );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200561
562 if( ret != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000563 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200564
565 if( *ca_istrue != 0 )
566 *ca_istrue = 1;
567 }
568
569 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200570 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200571
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200572 if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000573 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200574
575 if( *p != end )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000576 return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200577
578 (*max_pathlen)++;
579
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200580 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200581}
582
583static int x509_get_ns_cert_type( unsigned char **p,
584 const unsigned char *end,
585 unsigned char *ns_cert_type)
586{
587 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200588 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200589
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200590 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000591 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200592
593 if( bs.len != 1 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000594 return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200595
596 /* Get actual bitstring */
597 *ns_cert_type = *bs.p;
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200598 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200599}
600
601static int x509_get_key_usage( unsigned char **p,
602 const unsigned char *end,
Manuel Pégourié-Gonnard1d0ca1a2015-03-27 16:50:00 +0100603 unsigned int *key_usage)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200604{
605 int ret;
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200606 size_t i;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200607 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200608
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200609 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000610 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200611
612 if( bs.len < 1 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000613 return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200614
615 /* Get actual bitstring */
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200616 *key_usage = 0;
617 for( i = 0; i < bs.len && i < sizeof( unsigned int ); i++ )
618 {
619 *key_usage |= (unsigned int) bs.p[i] << (8*i);
620 }
621
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200622 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200623}
624
625/*
626 * ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
627 *
628 * KeyPurposeId ::= OBJECT IDENTIFIER
629 */
630static int x509_get_ext_key_usage( unsigned char **p,
631 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200632 mbedtls_x509_sequence *ext_key_usage)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200633{
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000634 return( mbedtls_asn1_get_sequence_of( p, end, ext_key_usage,
635 MBEDTLS_ASN1_OID ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200636}
637
638/*
639 * SubjectAltName ::= GeneralNames
640 *
641 * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
642 *
643 * GeneralName ::= CHOICE {
644 * otherName [0] OtherName,
645 * rfc822Name [1] IA5String,
646 * dNSName [2] IA5String,
647 * x400Address [3] ORAddress,
648 * directoryName [4] Name,
649 * ediPartyName [5] EDIPartyName,
650 * uniformResourceIdentifier [6] IA5String,
651 * iPAddress [7] OCTET STRING,
652 * registeredID [8] OBJECT IDENTIFIER }
653 *
654 * OtherName ::= SEQUENCE {
655 * type-id OBJECT IDENTIFIER,
656 * value [0] EXPLICIT ANY DEFINED BY type-id }
657 *
658 * EDIPartyName ::= SEQUENCE {
659 * nameAssigner [0] DirectoryString OPTIONAL,
660 * partyName [1] DirectoryString }
661 *
Manuel Pégourié-Gonnardb4fe3cb2015-01-22 16:11:05 +0000662 * NOTE: we only parse and use dNSName at this point.
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200663 */
Hanno Beckerad462192019-02-21 13:32:31 +0000664static int x509_get_subject_alt_name_cb( void *ctx,
665 int tag,
666 unsigned char *data,
667 size_t data_len )
668{
669 mbedtls_asn1_sequence **cur_ptr = (mbedtls_asn1_sequence **) ctx;
670 mbedtls_asn1_sequence *cur = *cur_ptr;
671
Hanno Beckerad462192019-02-21 13:32:31 +0000672 /* Allocate and assign next pointer */
673 if( cur->buf.p != NULL )
674 {
675 cur->next = mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
676 if( cur->next == NULL )
Hanno Becker90b94082019-02-21 21:13:21 +0000677 return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
Hanno Beckerad462192019-02-21 13:32:31 +0000678 cur = cur->next;
679 }
680
681 cur->buf.tag = tag;
682 cur->buf.p = data;
683 cur->buf.len = data_len;
684
685 *cur_ptr = cur;
686 return( 0 );
687}
688
Hanno Becker5984d302019-02-21 14:46:54 +0000689static int x509_get_subject_alt_name( unsigned char *p,
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200690 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200691 mbedtls_x509_sequence *subject_alt_name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200692{
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000693 return( mbedtls_asn1_traverse_sequence_of( &p, end,
694 MBEDTLS_ASN1_TAG_CLASS_MASK,
695 MBEDTLS_ASN1_CONTEXT_SPECIFIC,
696 MBEDTLS_ASN1_TAG_VALUE_MASK,
697 2 /* SubjectAlt DNS */,
698 x509_get_subject_alt_name_cb,
699 (void*) &subject_alt_name ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200700}
701
702/*
703 * X.509 v3 extensions
704 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200705 */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000706static int x509_crt_get_ext_cb( void *ctx,
707 int tag,
708 unsigned char *p,
709 size_t ext_len )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200710{
711 int ret;
Hanno Becker21f55672019-02-15 15:27:59 +0000712 mbedtls_x509_crt_frame *frame = (mbedtls_x509_crt_frame *) ctx;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200713 size_t len;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000714 unsigned char *end, *end_ext_octet;
715 mbedtls_x509_buf extn_oid = { 0, 0, NULL };
716 int is_critical = 0; /* DEFAULT FALSE */
717 int ext_type = 0;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200718
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000719 ((void) tag);
Hanno Becker4e1bfc12019-02-12 17:22:36 +0000720
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000721 /*
722 * Extension ::= SEQUENCE {
723 * extnID OBJECT IDENTIFIER,
724 * critical BOOLEAN DEFAULT FALSE,
725 * extnValue OCTET STRING }
726 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200727
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000728 end = p + ext_len;
729
730 /* Get extension ID */
731 if( ( ret = mbedtls_asn1_get_tag( &p, end, &extn_oid.len,
732 MBEDTLS_ASN1_OID ) ) != 0 )
733 goto err;
734
735 extn_oid.tag = MBEDTLS_ASN1_OID;
736 extn_oid.p = p;
737 p += extn_oid.len;
738
739 /* Get optional critical */
740 if( ( ret = mbedtls_asn1_get_bool( &p, end, &is_critical ) ) != 0 &&
741 ( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
742 goto err;
743
744 /* Data should be octet string type */
745 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
746 MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
747 goto err;
748
749 end_ext_octet = p + len;
750 if( end_ext_octet != end )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200751 {
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000752 ret = MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
753 goto err;
754 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200755
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000756 /*
757 * Detect supported extensions
758 */
759 ret = mbedtls_oid_get_x509_ext_type( &extn_oid, &ext_type );
760 if( ret != 0 )
761 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200762#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000763 if( is_critical )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200764 {
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000765 /* Data is marked as critical: fail */
766 ret = MBEDTLS_ERR_ASN1_UNEXPECTED_TAG;
767 goto err;
768 }
769#endif
770 return( 0 );
771 }
772
773 /* Forbid repeated extensions */
Hanno Becker21f55672019-02-15 15:27:59 +0000774 if( ( frame->ext_types & ext_type ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000775 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
776
Hanno Becker21f55672019-02-15 15:27:59 +0000777 frame->ext_types |= ext_type;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000778 switch( ext_type )
779 {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +0100780 case MBEDTLS_X509_EXT_BASIC_CONSTRAINTS:
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000781 {
782 int ca_istrue;
783 int max_pathlen;
784
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200785 /* Parse basic constraints */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000786 ret = x509_get_basic_constraints( &p, end_ext_octet,
787 &ca_istrue,
788 &max_pathlen );
789 if( ret != 0 )
790 goto err;
791
Hanno Becker21f55672019-02-15 15:27:59 +0000792 frame->ca_istrue = ca_istrue;
793 frame->max_pathlen = max_pathlen;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200794 break;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000795 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200796
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200797 case MBEDTLS_X509_EXT_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200798 /* Parse key usage */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000799 ret = x509_get_key_usage( &p, end_ext_octet,
Hanno Becker21f55672019-02-15 15:27:59 +0000800 &frame->key_usage );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000801 if( ret != 0 )
802 goto err;
803 break;
804
805 case MBEDTLS_X509_EXT_SUBJECT_ALT_NAME:
806 /* Copy reference to raw subject alt name data. */
Hanno Becker21f55672019-02-15 15:27:59 +0000807 frame->subject_alt_raw.p = p;
808 frame->subject_alt_raw.len = end_ext_octet - p;
809
810 ret = mbedtls_asn1_traverse_sequence_of( &p, end_ext_octet,
811 MBEDTLS_ASN1_TAG_CLASS_MASK,
812 MBEDTLS_ASN1_CONTEXT_SPECIFIC,
813 MBEDTLS_ASN1_TAG_VALUE_MASK,
814 2 /* SubjectAlt DNS */,
815 NULL, NULL );
816 if( ret != 0 )
817 goto err;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200818 break;
819
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200820 case MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200821 /* Parse extended key usage */
Hanno Becker21f55672019-02-15 15:27:59 +0000822 frame->ext_key_usage_raw.p = p;
823 frame->ext_key_usage_raw.len = end_ext_octet - p;
824 if( frame->ext_key_usage_raw.len == 0 )
Hanno Becker5984d302019-02-21 14:46:54 +0000825 {
Hanno Becker21f55672019-02-15 15:27:59 +0000826 ret = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
827 goto err;
Hanno Becker5984d302019-02-21 14:46:54 +0000828 }
Hanno Becker21f55672019-02-15 15:27:59 +0000829
830 /* Check structural sanity of extension. */
831 ret = mbedtls_asn1_traverse_sequence_of( &p, end_ext_octet,
832 0xFF, MBEDTLS_ASN1_OID,
833 0, 0, NULL, NULL );
834 if( ret != 0 )
835 goto err;
836
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200837 break;
838
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200839 case MBEDTLS_X509_EXT_NS_CERT_TYPE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200840 /* Parse netscape certificate type */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000841 ret = x509_get_ns_cert_type( &p, end_ext_octet,
Hanno Becker21f55672019-02-15 15:27:59 +0000842 &frame->ns_cert_type );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000843 if( ret != 0 )
844 goto err;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200845 break;
846
847 default:
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000848 /*
849 * If this is a non-critical extension, which the oid layer
850 * supports, but there isn't an X.509 parser for it,
851 * skip the extension.
852 */
853#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
854 if( is_critical )
855 return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
856#endif
857 p = end_ext_octet;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200858 }
859
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200860 return( 0 );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000861
862err:
863 return( ret );
864}
865
Hanno Becker21f55672019-02-15 15:27:59 +0000866static int x509_crt_frame_parse_ext( mbedtls_x509_crt_frame *frame )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000867{
868 int ret;
Hanno Becker21f55672019-02-15 15:27:59 +0000869 unsigned char *p = frame->v3_ext.p;
870 unsigned char *end = p + frame->v3_ext.len;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000871
Hanno Becker21f55672019-02-15 15:27:59 +0000872 if( p == end )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000873 return( 0 );
874
Hanno Becker21f55672019-02-15 15:27:59 +0000875 ret = mbedtls_asn1_traverse_sequence_of( &p, end,
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000876 0xFF, MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED,
Hanno Becker21f55672019-02-15 15:27:59 +0000877 0, 0, x509_crt_get_ext_cb, frame );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000878
879 if( ret == MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE )
880 return( ret );
881 if( ret == MBEDTLS_ERR_X509_INVALID_EXTENSIONS )
882 return( ret );
883
884 if( ret != 0 )
885 ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
886
887 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200888}
889
Hanno Becker21f55672019-02-15 15:27:59 +0000890static int x509_crt_parse_frame( unsigned char *start,
891 unsigned char *end,
892 mbedtls_x509_crt_frame *frame )
893{
894 int ret;
895 unsigned char *p;
896 size_t len;
897
898 mbedtls_x509_buf tmp;
899 unsigned char *tbs_start;
900
901 mbedtls_x509_buf outer_sig_alg;
902 size_t inner_sig_alg_len;
903 unsigned char *inner_sig_alg_start;
904
905 memset( frame, 0, sizeof( *frame ) );
906
907 /*
908 * Certificate ::= SEQUENCE {
909 * tbsCertificate TBSCertificate,
910 * signatureAlgorithm AlgorithmIdentifier,
911 * signatureValue BIT STRING
912 * }
913 *
914 */
915 p = start;
916
917 frame->raw.p = p;
918 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
919 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
920 {
921 return( MBEDTLS_ERR_X509_INVALID_FORMAT );
922 }
923
924 /* NOTE: We are currently not checking that the `Certificate`
925 * structure spans the entire buffer. */
926 end = p + len;
927 frame->raw.len = end - frame->raw.p;
928
929 /*
930 * TBSCertificate ::= SEQUENCE { ...
931 */
932 frame->tbs.p = p;
933 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
934 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
935 {
936 return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
937 }
938 tbs_start = p;
939
940 /* Breadth-first parsing: Jump over TBS for now. */
941 p += len;
942 frame->tbs.len = p - frame->tbs.p;
943
944 /*
945 * AlgorithmIdentifier ::= SEQUENCE { ...
946 */
947 outer_sig_alg.p = p;
948 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
949 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
950 {
951 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
952 }
953 p += len;
954 outer_sig_alg.len = p - outer_sig_alg.p;
955
956 /*
957 * signatureValue BIT STRING
958 */
959 ret = mbedtls_x509_get_sig( &p, end, &tmp );
960 if( ret != 0 )
961 return( ret );
962 frame->sig.p = tmp.p;
963 frame->sig.len = tmp.len;
964
965 /* Check that we consumed the entire `Certificate` structure. */
966 if( p != end )
967 {
968 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
969 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
970 }
971
972 /* Parse TBSCertificate structure
973 *
974 * TBSCertificate ::= SEQUENCE {
975 * version [0] EXPLICIT Version DEFAULT v1,
976 * serialNumber CertificateSerialNumber,
977 * signature AlgorithmIdentifier,
978 * issuer Name,
979 * validity Validity,
980 * subject Name,
981 * subjectPublicKeyInfo SubjectPublicKeyInfo,
982 * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
983 * -- If present, version MUST be v2 or v3
984 * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
985 * -- If present, version MUST be v2 or v3
986 * extensions [3] EXPLICIT Extensions OPTIONAL
987 * -- If present, version MUST be v3
988 * }
989 */
990 end = frame->tbs.p + frame->tbs.len;
991 p = tbs_start;
992
993 /*
994 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
995 */
996 {
997 int version;
998 ret = x509_get_version( &p, end, &version );
999 if( ret != 0 )
1000 return( ret );
1001
1002 if( version < 0 || version > 2 )
1003 return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
1004
1005 frame->version = version + 1;
1006 }
1007
1008 /*
1009 * CertificateSerialNumber ::= INTEGER
1010 */
1011 ret = mbedtls_x509_get_serial( &p, end, &tmp );
1012 if( ret != 0 )
1013 return( ret );
1014
1015 frame->serial.p = tmp.p;
1016 frame->serial.len = tmp.len;
1017
1018 /*
1019 * signature AlgorithmIdentifier
1020 */
1021 inner_sig_alg_start = p;
1022 ret = mbedtls_x509_get_sig_alg_raw( &p, end, &frame->sig_md,
1023 &frame->sig_pk, NULL );
1024 if( ret != 0 )
1025 return( ret );
1026 inner_sig_alg_len = p - inner_sig_alg_start;
1027
1028 frame->sig_alg.p = inner_sig_alg_start;
1029 frame->sig_alg.len = inner_sig_alg_len;
1030
1031 /* Consistency check:
1032 * Inner and outer AlgorithmIdentifier structures must coincide:
1033 *
1034 * Quoting RFC 5280, Section 4.1.1.2:
1035 * This field MUST contain the same algorithm identifier as the
1036 * signature field in the sequence tbsCertificate (Section 4.1.2.3).
1037 */
1038 if( outer_sig_alg.len != inner_sig_alg_len ||
1039 memcmp( outer_sig_alg.p, inner_sig_alg_start, inner_sig_alg_len ) != 0 )
1040 {
1041 return( MBEDTLS_ERR_X509_SIG_MISMATCH );
1042 }
1043
1044 /*
1045 * issuer Name
1046 *
1047 * Name ::= CHOICE { -- only one possibility for now --
1048 * rdnSequence RDNSequence }
1049 *
1050 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
1051 */
1052 frame->issuer_raw_with_hdr.p = p;
1053
1054 ret = mbedtls_asn1_get_tag( &p, end, &len,
1055 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
1056 if( ret != 0 )
1057 return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
1058 frame->issuer_raw.p = p;
1059 frame->issuer_raw.len = len;
1060 p += len;
1061
1062 ret = mbedtls_x509_name_cmp_raw( &frame->issuer_raw,
1063 &frame->issuer_raw,
1064 NULL, NULL );
1065 if( ret != 0 )
1066 return( ret );
1067
1068 frame->issuer_raw_with_hdr.len = p - frame->issuer_raw_with_hdr.p;
1069
1070 /*
1071 * Validity ::= SEQUENCE { ...
1072 */
1073 ret = x509_get_dates( &p, end, &frame->valid_from, &frame->valid_to );
1074 if( ret != 0 )
1075 return( ret );
1076
1077 /*
1078 * subject Name
1079 *
1080 * Name ::= CHOICE { -- only one possibility for now --
1081 * rdnSequence RDNSequence }
1082 *
1083 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
1084 */
1085 frame->subject_raw_with_hdr.p = p;
1086
1087 ret = mbedtls_asn1_get_tag( &p, end, &len,
1088 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
1089 if( ret != 0 )
1090 return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
1091 frame->subject_raw.p = p;
1092 frame->subject_raw.len = len;
1093 p += len;
1094
1095 ret = mbedtls_x509_name_cmp_raw( &frame->subject_raw,
1096 &frame->subject_raw,
1097 NULL, NULL );
1098 if( ret != 0 )
1099 return( ret );
1100
1101 frame->subject_raw_with_hdr.len = p - frame->subject_raw_with_hdr.p;
1102
1103 /*
1104 * SubjectPublicKeyInfo
1105 */
1106 frame->pubkey_raw.p = p;
1107 ret = mbedtls_asn1_get_tag( &p, end, &len,
1108 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
1109 if( ret != 0 )
1110 return( ret + MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
1111 p += len;
1112 frame->pubkey_raw.len = p - frame->pubkey_raw.p;
1113
1114 /*
1115 * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
1116 * -- If present, version shall be v2 or v3
1117 */
1118 if( frame->version == 2 || frame->version == 3 )
1119 {
1120 ret = x509_get_uid( &p, end, &tmp, 1 /* implicit tag */ );
1121 if( ret != 0 )
1122 return( ret );
1123
1124 frame->issuer_id.p = tmp.p;
1125 frame->issuer_id.len = tmp.len;
1126 }
1127
1128 /*
1129 * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
1130 * -- If present, version shall be v2 or v3
1131 */
1132 if( frame->version == 2 || frame->version == 3 )
1133 {
1134 ret = x509_get_uid( &p, end, &tmp, 2 /* implicit tag */ );
1135 if( ret != 0 )
1136 return( ret );
1137
1138 frame->subject_id.p = tmp.p;
1139 frame->subject_id.len = tmp.len;
1140 }
1141
1142 /*
1143 * extensions [3] EXPLICIT Extensions OPTIONAL
1144 * -- If present, version shall be v3
1145 */
1146#if !defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
1147 if( frame->version == 3 )
1148#endif
1149 {
1150 if( p != end )
1151 {
1152 ret = mbedtls_asn1_get_tag( &p, end, &len,
1153 MBEDTLS_ASN1_CONTEXT_SPECIFIC |
1154 MBEDTLS_ASN1_CONSTRUCTED | 3 );
1155 if( len == 0 )
1156 ret = MBEDTLS_ERR_ASN1_OUT_OF_DATA;
1157 if( ret != 0 )
1158 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
1159
1160 frame->v3_ext.p = p;
1161 frame->v3_ext.len = len;
1162
1163 p += len;
1164 }
1165
1166 ret = x509_crt_frame_parse_ext( frame );
1167 if( ret != 0 )
1168 return( ret );
1169 }
1170
1171 /* Wrapup: Check that we consumed the entire `TBSCertificate` structure. */
1172 if( p != end )
1173 {
1174 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
1175 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
1176 }
1177
1178 return( 0 );
1179}
1180
1181static int x509_crt_subject_from_frame( mbedtls_x509_crt_frame *frame,
1182 mbedtls_x509_name *subject )
1183{
1184 unsigned char *p = frame->subject_raw.p;
1185 unsigned char *end = p + frame->subject_raw.len;
1186
1187 return( mbedtls_x509_get_name( &p, end, subject ) );
1188}
1189
1190static int x509_crt_issuer_from_frame( mbedtls_x509_crt_frame *frame,
1191 mbedtls_x509_name *issuer )
1192{
1193 unsigned char *p = frame->issuer_raw.p;
1194 unsigned char *end = p + frame->issuer_raw.len;
1195
1196 return( mbedtls_x509_get_name( &p, end, issuer ) );
1197}
1198
1199static int x509_crt_subject_alt_from_frame( mbedtls_x509_crt_frame *frame,
1200 mbedtls_x509_sequence *subject_alt )
1201{
1202 int ret;
1203 unsigned char *p = frame->subject_alt_raw.p;
1204 unsigned char *end = p + frame->subject_alt_raw.len;
1205
1206 memset( subject_alt, 0, sizeof( *subject_alt ) );
1207
1208 if( ( frame->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME ) == 0 )
1209 return( 0 );
1210
1211 ret = x509_get_subject_alt_name( p, end, subject_alt );
1212 if( ret != 0 )
1213 ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
1214 return( ret );
1215}
1216
1217static int x509_crt_ext_key_usage_from_frame( mbedtls_x509_crt_frame *frame,
1218 mbedtls_x509_sequence *ext_key_usage )
1219{
1220 int ret;
1221 unsigned char *p = frame->ext_key_usage_raw.p;
1222 unsigned char *end = p + frame->ext_key_usage_raw.len;
1223
1224 memset( ext_key_usage, 0, sizeof( *ext_key_usage ) );
1225
1226 if( ( frame->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
1227 return( 0 );
1228
1229 ret = x509_get_ext_key_usage( &p, end, ext_key_usage );
1230 if( ret != 0 )
1231 {
1232 ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
1233 return( ret );
1234 }
1235
1236 return( 0 );
1237}
1238
Hanno Becker180f7bf2019-02-28 13:23:38 +00001239#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Hanno Becker21f55672019-02-15 15:27:59 +00001240static int x509_crt_pk_from_frame( mbedtls_x509_crt_frame *frame,
1241 mbedtls_pk_context *pk )
1242{
1243 unsigned char *p = frame->pubkey_raw.p;
1244 unsigned char *end = p + frame->pubkey_raw.len;
1245 return( mbedtls_pk_parse_subpubkey( &p, end, pk ) );
1246}
Hanno Becker180f7bf2019-02-28 13:23:38 +00001247#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Becker21f55672019-02-15 15:27:59 +00001248
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001249/*
1250 * Parse and fill a single X.509 certificate in DER format
1251 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001252static int x509_crt_parse_der_core( mbedtls_x509_crt *crt,
1253 const unsigned char *buf,
1254 size_t buflen,
1255 int make_copy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001256{
1257 int ret;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001258 mbedtls_x509_crt_frame *frame;
1259 mbedtls_x509_crt_cache *cache;
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +01001260
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001261 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001262 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001263
Hanno Becker21f55672019-02-15 15:27:59 +00001264 if( make_copy == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001265 {
Hanno Becker21f55672019-02-15 15:27:59 +00001266 crt->raw.p = (unsigned char*) buf;
1267 crt->raw.len = buflen;
1268 crt->own_buffer = 0;
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001269 }
1270 else
1271 {
Hanno Becker21f55672019-02-15 15:27:59 +00001272 crt->raw.p = mbedtls_calloc( 1, buflen );
1273 if( crt->raw.p == NULL )
1274 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
1275 crt->raw.len = buflen;
1276 memcpy( crt->raw.p, buf, buflen );
1277
1278 crt->own_buffer = 1;
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001279 }
Janos Follathcc0e49d2016-02-17 14:34:12 +00001280
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001281 cache = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_cache ) );
1282 if( cache == NULL )
1283 {
1284 ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
1285 goto exit;
1286 }
1287 crt->cache = cache;
1288 x509_crt_cache_init( cache );
1289
1290 ret = mbedtls_x509_crt_cache_provide_frame( crt );
Hanno Becker21f55672019-02-15 15:27:59 +00001291 if( ret != 0 )
1292 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001293
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001294 frame = mbedtls_x509_crt_cache_get_frame( crt->cache );
1295
Hanno Becker21f55672019-02-15 15:27:59 +00001296 /* Currently, we accept DER encoded CRTs with trailing garbage
1297 * and promise to not account for the garbage in the `raw` field.
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001298 *
Hanno Becker21f55672019-02-15 15:27:59 +00001299 * Note that this means that `crt->raw.len` is not necessarily the
1300 * full size of the heap buffer allocated at `crt->raw.p` in case
1301 * of copy-mode, but this is not a problem: freeing the buffer doesn't
1302 * need the size, and the garbage data doesn't need zeroization. */
1303 crt->raw.len = frame->raw.len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001304
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001305 cache->pk_raw = frame->pubkey_raw;
1306
Hanno Becker180f7bf2019-02-28 13:23:38 +00001307#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Hanno Becker21f55672019-02-15 15:27:59 +00001308 /* Copy frame to legacy CRT structure -- that's inefficient, but if
1309 * memory matters, the new CRT structure should be used anyway. */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001310 crt->tbs.p = frame->tbs.p;
1311 crt->tbs.len = frame->tbs.len;
1312 crt->serial.p = frame->serial.p;
1313 crt->serial.len = frame->serial.len;
1314 crt->issuer_raw.p = frame->issuer_raw_with_hdr.p;
1315 crt->issuer_raw.len = frame->issuer_raw_with_hdr.len;
1316 crt->subject_raw.p = frame->subject_raw_with_hdr.p;
1317 crt->subject_raw.len = frame->subject_raw_with_hdr.len;
1318 crt->issuer_raw_no_hdr = frame->issuer_raw;
1319 crt->subject_raw_no_hdr = frame->subject_raw;
1320 crt->issuer_id.p = frame->issuer_id.p;
1321 crt->issuer_id.len = frame->issuer_id.len;
1322 crt->subject_id.p = frame->subject_id.p;
1323 crt->subject_id.len = frame->subject_id.len;
1324 crt->pk_raw.p = frame->pubkey_raw.p;
1325 crt->pk_raw.len = frame->pubkey_raw.len;
1326 crt->ext_key_usage_raw = frame->ext_key_usage_raw;
1327 crt->subject_alt_raw = frame->subject_alt_raw;
1328 crt->sig.p = frame->sig.p;
1329 crt->sig.len = frame->sig.len;
1330 crt->valid_from = frame->valid_from;
1331 crt->valid_to = frame->valid_to;
1332 crt->v3_ext.p = frame->v3_ext.p;
1333 crt->v3_ext.len = frame->v3_ext.len;
1334 crt->version = frame->version;
1335 crt->ca_istrue = frame->ca_istrue;
1336 crt->max_pathlen = frame->max_pathlen;
1337 crt->ext_types = frame->ext_types;
1338 crt->key_usage = frame->key_usage;
1339 crt->ns_cert_type = frame->ns_cert_type;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001340
1341 /*
Hanno Becker21f55672019-02-15 15:27:59 +00001342 * Obtain the remaining fields from the frame.
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001343 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001344
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001345 {
Hanno Becker21f55672019-02-15 15:27:59 +00001346 /* sig_oid: Previously, needed for convenience in
1347 * mbedtls_x509_crt_info(), now pure legacy burden. */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001348 unsigned char *tmp = frame->sig_alg.p;
1349 unsigned char *end = tmp + frame->sig_alg.len;
Hanno Becker21f55672019-02-15 15:27:59 +00001350 mbedtls_x509_buf sig_oid, sig_params;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001351
Hanno Becker21f55672019-02-15 15:27:59 +00001352 ret = mbedtls_x509_get_alg( &tmp, end,
1353 &sig_oid, &sig_params );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001354 if( ret != 0 )
1355 {
Hanno Becker21f55672019-02-15 15:27:59 +00001356 /* This should never happen, because we check
1357 * the sanity of the AlgorithmIdentifier structure
1358 * during frame parsing. */
1359 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1360 goto exit;
1361 }
1362 crt->sig_oid = sig_oid;
1363
1364 /* Signature parameters */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001365 tmp = frame->sig_alg.p;
Hanno Becker21f55672019-02-15 15:27:59 +00001366 ret = mbedtls_x509_get_sig_alg_raw( &tmp, end,
1367 &crt->sig_md, &crt->sig_pk,
1368 &crt->sig_opts );
1369 if( ret != 0 )
1370 {
1371 /* Again, this should never happen. */
1372 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1373 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001374 }
1375 }
1376
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001377 ret = x509_crt_pk_from_frame( frame, &crt->pk );
Hanno Becker21f55672019-02-15 15:27:59 +00001378 if( ret != 0 )
1379 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001380
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001381 ret = x509_crt_subject_from_frame( frame, &crt->subject );
Hanno Becker21f55672019-02-15 15:27:59 +00001382 if( ret != 0 )
1383 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001384
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001385 ret = x509_crt_issuer_from_frame( frame, &crt->issuer );
Hanno Becker21f55672019-02-15 15:27:59 +00001386 if( ret != 0 )
1387 goto exit;
1388
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001389 ret = x509_crt_subject_alt_from_frame( frame, &crt->subject_alt_names );
Hanno Becker21f55672019-02-15 15:27:59 +00001390 if( ret != 0 )
1391 goto exit;
1392
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001393 ret = x509_crt_ext_key_usage_from_frame( frame, &crt->ext_key_usage );
1394 if( ret != 0 )
1395 goto exit;
Hanno Becker180f7bf2019-02-28 13:23:38 +00001396#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001397
1398 /* The cache just references the PK structure from the legacy
1399 * implementation, so set up the latter first before setting up
1400 * the cache. */
1401 ret = mbedtls_x509_crt_cache_provide_pk( crt );
Hanno Becker21f55672019-02-15 15:27:59 +00001402 if( ret != 0 )
1403 goto exit;
1404
1405exit:
1406 if( ret != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001407 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001408
Hanno Becker21f55672019-02-15 15:27:59 +00001409 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001410}
1411
1412/*
1413 * Parse one X.509 certificate in DER format from a buffer and add them to a
1414 * chained list
1415 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001416static int mbedtls_x509_crt_parse_der_internal( mbedtls_x509_crt *chain,
1417 const unsigned char *buf,
1418 size_t buflen,
1419 int make_copy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001420{
1421 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001422 mbedtls_x509_crt *crt = chain, *prev = NULL;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001423
1424 /*
1425 * Check for valid input
1426 */
1427 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001428 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001429
Hanno Becker371e0e42019-02-25 18:08:59 +00001430 while( crt->raw.p != NULL && crt->next != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001431 {
1432 prev = crt;
1433 crt = crt->next;
1434 }
1435
1436 /*
1437 * Add new certificate on the end of the chain if needed.
1438 */
Hanno Becker371e0e42019-02-25 18:08:59 +00001439 if( crt->raw.p != NULL && crt->next == NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001440 {
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +02001441 crt->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001442
1443 if( crt->next == NULL )
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02001444 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001445
1446 prev = crt;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001447 mbedtls_x509_crt_init( crt->next );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001448 crt = crt->next;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001449 }
1450
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001451 if( ( ret = x509_crt_parse_der_core( crt, buf, buflen, make_copy ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001452 {
1453 if( prev )
1454 prev->next = NULL;
1455
1456 if( crt != chain )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001457 mbedtls_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001458
1459 return( ret );
1460 }
1461
1462 return( 0 );
1463}
1464
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001465int mbedtls_x509_crt_parse_der_nocopy( mbedtls_x509_crt *chain,
1466 const unsigned char *buf,
1467 size_t buflen )
1468{
1469 return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 0 ) );
1470}
1471
1472int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain,
1473 const unsigned char *buf,
1474 size_t buflen )
1475{
1476 return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 1 ) );
1477}
1478
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001479/*
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001480 * Parse one or more PEM certificates from a buffer and add them to the chained
1481 * list
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001482 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001483int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain,
1484 const unsigned char *buf,
1485 size_t buflen )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001486{
Janos Follath98e28a72016-05-31 14:03:54 +01001487#if defined(MBEDTLS_PEM_PARSE_C)
Andres AGc0db5112016-12-07 15:05:53 +00001488 int success = 0, first_error = 0, total_failed = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001489 int buf_format = MBEDTLS_X509_FORMAT_DER;
Janos Follath98e28a72016-05-31 14:03:54 +01001490#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001491
1492 /*
1493 * Check for valid input
1494 */
1495 if( chain == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001496 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001497
1498 /*
1499 * Determine buffer content. Buffer contains either one DER certificate or
1500 * one or more PEM certificates.
1501 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001502#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard0ece0f92015-05-12 12:43:54 +02001503 if( buflen != 0 && buf[buflen - 1] == '\0' &&
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001504 strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
1505 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001506 buf_format = MBEDTLS_X509_FORMAT_PEM;
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001507 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001508
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001509 if( buf_format == MBEDTLS_X509_FORMAT_DER )
1510 return mbedtls_x509_crt_parse_der( chain, buf, buflen );
Janos Follath98e28a72016-05-31 14:03:54 +01001511#else
1512 return mbedtls_x509_crt_parse_der( chain, buf, buflen );
1513#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001514
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001515#if defined(MBEDTLS_PEM_PARSE_C)
1516 if( buf_format == MBEDTLS_X509_FORMAT_PEM )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001517 {
1518 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001519 mbedtls_pem_context pem;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001520
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001521 /* 1 rather than 0 since the terminating NULL byte is counted in */
1522 while( buflen > 1 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001523 {
1524 size_t use_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001525 mbedtls_pem_init( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001526
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001527 /* If we get there, we know the string is null-terminated */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001528 ret = mbedtls_pem_read_buffer( &pem,
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001529 "-----BEGIN CERTIFICATE-----",
1530 "-----END CERTIFICATE-----",
1531 buf, NULL, 0, &use_len );
1532
1533 if( ret == 0 )
1534 {
1535 /*
1536 * Was PEM encoded
1537 */
1538 buflen -= use_len;
1539 buf += use_len;
1540 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001541 else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001542 {
1543 return( ret );
1544 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001545 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001546 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001547 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001548
1549 /*
1550 * PEM header and footer were found
1551 */
1552 buflen -= use_len;
1553 buf += use_len;
1554
1555 if( first_error == 0 )
1556 first_error = ret;
1557
Paul Bakker5a5fa922014-09-26 14:53:04 +02001558 total_failed++;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001559 continue;
1560 }
1561 else
1562 break;
1563
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001564 ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001565
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001566 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001567
1568 if( ret != 0 )
1569 {
1570 /*
1571 * Quit parsing on a memory error
1572 */
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02001573 if( ret == MBEDTLS_ERR_X509_ALLOC_FAILED )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001574 return( ret );
1575
1576 if( first_error == 0 )
1577 first_error = ret;
1578
1579 total_failed++;
1580 continue;
1581 }
1582
1583 success = 1;
1584 }
1585 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001586
1587 if( success )
1588 return( total_failed );
1589 else if( first_error )
1590 return( first_error );
1591 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001592 return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
Janos Follath98e28a72016-05-31 14:03:54 +01001593#endif /* MBEDTLS_PEM_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001594}
1595
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001596#if defined(MBEDTLS_FS_IO)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001597/*
1598 * Load one or more certificates and add them to the chained list
1599 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001600int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001601{
1602 int ret;
1603 size_t n;
1604 unsigned char *buf;
1605
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001606 if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001607 return( ret );
1608
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001609 ret = mbedtls_x509_crt_parse( chain, buf, n );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001610
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05001611 mbedtls_platform_zeroize( buf, n );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001612 mbedtls_free( buf );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001613
1614 return( ret );
1615}
1616
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001617int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001618{
1619 int ret = 0;
Paul Bakkerfa6a6202013-10-28 18:48:30 +01001620#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001621 int w_ret;
1622 WCHAR szDir[MAX_PATH];
1623 char filename[MAX_PATH];
Paul Bakker9af723c2014-05-01 13:03:14 +02001624 char *p;
Manuel Pégourié-Gonnard261faed2015-10-21 10:16:29 +02001625 size_t len = strlen( path );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001626
Paul Bakker9af723c2014-05-01 13:03:14 +02001627 WIN32_FIND_DATAW file_data;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001628 HANDLE hFind;
1629
1630 if( len > MAX_PATH - 3 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001631 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001632
Paul Bakker9af723c2014-05-01 13:03:14 +02001633 memset( szDir, 0, sizeof(szDir) );
1634 memset( filename, 0, MAX_PATH );
1635 memcpy( filename, path, len );
1636 filename[len++] = '\\';
1637 p = filename + len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001638 filename[len++] = '*';
1639
Simon B3c6b18d2016-11-03 01:11:37 +00001640 w_ret = MultiByteToWideChar( CP_ACP, 0, filename, (int)len, szDir,
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001641 MAX_PATH - 3 );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +00001642 if( w_ret == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001643 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001644
1645 hFind = FindFirstFileW( szDir, &file_data );
Paul Bakker66d5d072014-06-17 16:39:18 +02001646 if( hFind == INVALID_HANDLE_VALUE )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001647 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001648
1649 len = MAX_PATH - len;
1650 do
1651 {
Paul Bakker9af723c2014-05-01 13:03:14 +02001652 memset( p, 0, len );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001653
1654 if( file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
1655 continue;
1656
Paul Bakker9af723c2014-05-01 13:03:14 +02001657 w_ret = WideCharToMultiByte( CP_ACP, 0, file_data.cFileName,
Paul Bakker66d5d072014-06-17 16:39:18 +02001658 lstrlenW( file_data.cFileName ),
Manuel Pégourié-Gonnard261faed2015-10-21 10:16:29 +02001659 p, (int) len - 1,
Paul Bakker9af723c2014-05-01 13:03:14 +02001660 NULL, NULL );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +00001661 if( w_ret == 0 )
Ron Eldor36d90422017-01-09 15:09:16 +02001662 {
1663 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
1664 goto cleanup;
1665 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001666
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001667 w_ret = mbedtls_x509_crt_parse_file( chain, filename );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001668 if( w_ret < 0 )
1669 ret++;
1670 else
1671 ret += w_ret;
1672 }
1673 while( FindNextFileW( hFind, &file_data ) != 0 );
1674
Paul Bakker66d5d072014-06-17 16:39:18 +02001675 if( GetLastError() != ERROR_NO_MORE_FILES )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001676 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001677
Ron Eldor36d90422017-01-09 15:09:16 +02001678cleanup:
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001679 FindClose( hFind );
Paul Bakkerbe089b02013-10-14 15:51:50 +02001680#else /* _WIN32 */
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001681 int t_ret;
Andres AGf9113192016-09-02 14:06:04 +01001682 int snp_ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001683 struct stat sb;
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001684 struct dirent *entry;
Andres AGf9113192016-09-02 14:06:04 +01001685 char entry_name[MBEDTLS_X509_MAX_FILE_PATH_LEN];
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001686 DIR *dir = opendir( path );
1687
Paul Bakker66d5d072014-06-17 16:39:18 +02001688 if( dir == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001689 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001690
Ron Eldor63140682017-01-09 19:27:59 +02001691#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard944cfe82015-05-27 20:07:18 +02001692 if( ( ret = mbedtls_mutex_lock( &mbedtls_threading_readdir_mutex ) ) != 0 )
Manuel Pégourié-Gonnardf9b85d92015-06-22 18:39:57 +02001693 {
1694 closedir( dir );
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001695 return( ret );
Manuel Pégourié-Gonnardf9b85d92015-06-22 18:39:57 +02001696 }
Ron Eldor63140682017-01-09 19:27:59 +02001697#endif /* MBEDTLS_THREADING_C */
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001698
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001699 while( ( entry = readdir( dir ) ) != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001700 {
Andres AGf9113192016-09-02 14:06:04 +01001701 snp_ret = mbedtls_snprintf( entry_name, sizeof entry_name,
1702 "%s/%s", path, entry->d_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001703
Andres AGf9113192016-09-02 14:06:04 +01001704 if( snp_ret < 0 || (size_t)snp_ret >= sizeof entry_name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001705 {
Andres AGf9113192016-09-02 14:06:04 +01001706 ret = MBEDTLS_ERR_X509_BUFFER_TOO_SMALL;
1707 goto cleanup;
1708 }
1709 else if( stat( entry_name, &sb ) == -1 )
1710 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001711 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001712 goto cleanup;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001713 }
1714
1715 if( !S_ISREG( sb.st_mode ) )
1716 continue;
1717
1718 // Ignore parse errors
1719 //
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001720 t_ret = mbedtls_x509_crt_parse_file( chain, entry_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001721 if( t_ret < 0 )
1722 ret++;
1723 else
1724 ret += t_ret;
1725 }
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001726
1727cleanup:
Andres AGf9113192016-09-02 14:06:04 +01001728 closedir( dir );
1729
Ron Eldor63140682017-01-09 19:27:59 +02001730#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard944cfe82015-05-27 20:07:18 +02001731 if( mbedtls_mutex_unlock( &mbedtls_threading_readdir_mutex ) != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001732 ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
Ron Eldor63140682017-01-09 19:27:59 +02001733#endif /* MBEDTLS_THREADING_C */
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01001734
Paul Bakkerbe089b02013-10-14 15:51:50 +02001735#endif /* _WIN32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001736
1737 return( ret );
1738}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001739#endif /* MBEDTLS_FS_IO */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001740
Hanno Becker02a21932019-06-10 15:08:43 +01001741#if !defined(MBEDTLS_X509_REMOVE_INFO)
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001742static int x509_info_subject_alt_name( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001743 const mbedtls_x509_sequence *subject_alt_name )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001744{
1745 size_t i;
1746 size_t n = *size;
1747 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001748 const mbedtls_x509_sequence *cur = subject_alt_name;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001749 const char *sep = "";
1750 size_t sep_len = 0;
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001751
1752 while( cur != NULL )
1753 {
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001754 if( cur->buf.len + sep_len >= n )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001755 {
1756 *p = '\0';
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001757 return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001758 }
1759
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001760 n -= cur->buf.len + sep_len;
1761 for( i = 0; i < sep_len; i++ )
1762 *p++ = sep[i];
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001763 for( i = 0; i < cur->buf.len; i++ )
1764 *p++ = cur->buf.p[i];
1765
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001766 sep = ", ";
1767 sep_len = 2;
1768
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02001769 cur = cur->next;
1770 }
1771
1772 *p = '\0';
1773
1774 *size = n;
1775 *buf = p;
1776
1777 return( 0 );
1778}
1779
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001780#define PRINT_ITEM(i) \
1781 { \
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001782 ret = mbedtls_snprintf( p, n, "%s" i, sep ); \
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001783 MBEDTLS_X509_SAFE_SNPRINTF; \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001784 sep = ", "; \
1785 }
1786
1787#define CERT_TYPE(type,name) \
Hanno Beckerd6028a12018-10-15 12:01:35 +01001788 if( ns_cert_type & (type) ) \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001789 PRINT_ITEM( name );
1790
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001791static int x509_info_cert_type( char **buf, size_t *size,
1792 unsigned char ns_cert_type )
1793{
1794 int ret;
1795 size_t n = *size;
1796 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001797 const char *sep = "";
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001798
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001799 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001800 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001801 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL, "Email" );
1802 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
1803 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_RESERVED, "Reserved" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001804 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CA, "SSL CA" );
1805 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL_CA, "Email CA" );
1806 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02001807
1808 *size = n;
1809 *buf = p;
1810
1811 return( 0 );
1812}
1813
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001814#define KEY_USAGE(code,name) \
Hanno Beckerd6028a12018-10-15 12:01:35 +01001815 if( key_usage & (code) ) \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02001816 PRINT_ITEM( name );
1817
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001818static int x509_info_key_usage( char **buf, size_t *size,
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +02001819 unsigned int key_usage )
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001820{
1821 int ret;
1822 size_t n = *size;
1823 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001824 const char *sep = "";
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001825
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001826 KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
1827 KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001828 KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
1829 KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
1830 KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001831 KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
1832 KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +02001833 KEY_USAGE( MBEDTLS_X509_KU_ENCIPHER_ONLY, "Encipher Only" );
1834 KEY_USAGE( MBEDTLS_X509_KU_DECIPHER_ONLY, "Decipher Only" );
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02001835
1836 *size = n;
1837 *buf = p;
1838
1839 return( 0 );
1840}
1841
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001842static int x509_info_ext_key_usage( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001843 const mbedtls_x509_sequence *extended_key_usage )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001844{
1845 int ret;
1846 const char *desc;
1847 size_t n = *size;
1848 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001849 const mbedtls_x509_sequence *cur = extended_key_usage;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001850 const char *sep = "";
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001851
1852 while( cur != NULL )
1853 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001854 if( mbedtls_oid_get_extended_key_usage( &cur->buf, &desc ) != 0 )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001855 desc = "???";
1856
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001857 ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001858 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001859
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02001860 sep = ", ";
1861
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02001862 cur = cur->next;
1863 }
1864
1865 *size = n;
1866 *buf = p;
1867
1868 return( 0 );
1869}
1870
Hanno Becker4f869ed2019-02-24 16:47:57 +00001871typedef struct mbedtls_x509_crt_sig_info
1872{
1873 mbedtls_md_type_t sig_md;
1874 mbedtls_pk_type_t sig_pk;
1875 void *sig_opts;
1876 uint8_t crt_hash[MBEDTLS_MD_MAX_SIZE];
1877 size_t crt_hash_len;
1878 mbedtls_x509_buf_raw sig;
1879 mbedtls_x509_buf_raw issuer_raw;
1880} mbedtls_x509_crt_sig_info;
1881
1882static void x509_crt_free_sig_info( mbedtls_x509_crt_sig_info *info )
1883{
1884#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1885 mbedtls_free( info->sig_opts );
1886#else
1887 ((void) info);
1888#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
1889}
1890
1891static int x509_crt_get_sig_info( mbedtls_x509_crt_frame const *frame,
1892 mbedtls_x509_crt_sig_info *info )
1893{
1894 const mbedtls_md_info_t *md_info;
1895
1896 md_info = mbedtls_md_info_from_type( frame->sig_md );
1897 if( mbedtls_md( md_info, frame->tbs.p, frame->tbs.len,
1898 info->crt_hash ) != 0 )
1899 {
1900 /* Note: this can't happen except after an internal error */
1901 return( -1 );
1902 }
1903
1904 info->crt_hash_len = mbedtls_md_get_size( md_info );
1905
1906 /* Make sure that this function leaves the target structure
1907 * ready to be freed, regardless of success of failure. */
1908 info->sig_opts = NULL;
1909
1910#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1911 {
1912 int ret;
1913 unsigned char *alg_start = frame->sig_alg.p;
1914 unsigned char *alg_end = alg_start + frame->sig_alg.len;
1915
1916 /* Get signature options -- currently only
1917 * necessary for RSASSA-PSS. */
1918 ret = mbedtls_x509_get_sig_alg_raw( &alg_start, alg_end, &info->sig_md,
1919 &info->sig_pk, &info->sig_opts );
1920 if( ret != 0 )
1921 {
1922 /* Note: this can't happen except after an internal error */
1923 return( -1 );
1924 }
1925 }
1926#else /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
1927 info->sig_md = frame->sig_md;
1928 info->sig_pk = frame->sig_pk;
1929#endif /* !MBEDTLS_X509_RSASSA_PSS_SUPPORT */
1930
1931 info->issuer_raw = frame->issuer_raw;
1932 info->sig = frame->sig;
1933 return( 0 );
1934}
1935
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001936/*
1937 * Return an informational string about the certificate.
1938 */
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02001939#define BEFORE_COLON 18
1940#define BC "18"
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001941int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
Hanno Becker4f869ed2019-02-24 16:47:57 +00001942 const mbedtls_x509_crt *crt_raw )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001943{
1944 int ret;
1945 size_t n;
1946 char *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001947 char key_size_str[BEFORE_COLON];
Hanno Becker4f869ed2019-02-24 16:47:57 +00001948 mbedtls_x509_crt_frame *crt;
1949 mbedtls_pk_context *pk;
1950
1951 mbedtls_x509_name issuer, subject;
1952 mbedtls_x509_sequence ext_key_usage, subject_alt_names;
1953 mbedtls_x509_crt_sig_info sig_info;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001954
1955 p = buf;
1956 n = size;
1957
Hanno Becker4f869ed2019-02-24 16:47:57 +00001958 memset( &sig_info, 0, sizeof( mbedtls_x509_crt_sig_info ) );
1959 if( NULL == crt_raw )
Janos Follath98e28a72016-05-31 14:03:54 +01001960 {
1961 ret = mbedtls_snprintf( p, n, "\nCertificate is uninitialised!\n" );
Hanno Becker4f869ed2019-02-24 16:47:57 +00001962 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Janos Follath98e28a72016-05-31 14:03:54 +01001963
1964 return( (int) ( size - n ) );
1965 }
1966
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001967 ret = mbedtls_x509_crt_frame_acquire( crt_raw, &crt );
Hanno Becker4f869ed2019-02-24 16:47:57 +00001968 if( ret != 0 )
1969 return( MBEDTLS_ERR_X509_FATAL_ERROR );
1970
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001971 ret = mbedtls_x509_crt_pk_acquire( (mbedtls_x509_crt*) crt_raw, &pk );
Hanno Becker4f869ed2019-02-24 16:47:57 +00001972 if( ret != 0 )
1973 {
1974 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1975 goto cleanup;
1976 }
1977
1978 ret = x509_crt_get_sig_info( crt, &sig_info );
1979 if( ret != 0 )
1980 {
1981 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1982 goto cleanup;
1983 }
1984
1985 ret = x509_crt_subject_from_frame( crt, &subject );
1986 if( ret != 0 )
1987 {
1988 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1989 goto cleanup;
1990 }
1991
1992 ret = x509_crt_issuer_from_frame( crt, &issuer );
1993 if( ret != 0 )
1994 {
1995 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1996 goto cleanup;
1997 }
1998
1999 ret = x509_crt_subject_alt_from_frame( crt, &subject_alt_names );
2000 if( ret != 0 )
2001 {
2002 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2003 goto cleanup;
2004 }
2005
2006 ret = x509_crt_ext_key_usage_from_frame( crt, &ext_key_usage );
2007 if( ret != 0 )
2008 {
2009 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2010 goto cleanup;
2011 }
2012
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002013 ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002014 prefix, crt->version );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002015 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002016
Hanno Becker4f869ed2019-02-24 16:47:57 +00002017 {
2018 mbedtls_x509_buf serial;
2019 serial.p = crt->serial.p;
2020 serial.len = crt->serial.len;
2021 ret = mbedtls_snprintf( p, n, "%sserial number : ",
2022 prefix );
2023 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
2024 ret = mbedtls_x509_serial_gets( p, n, &serial );
2025 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
2026 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002027
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002028 ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002029 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
2030 ret = mbedtls_x509_dn_gets( p, n, &issuer );
2031 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002032
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002033 ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002034 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
2035 ret = mbedtls_x509_dn_gets( p, n, &subject );
2036 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002037
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002038 ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002039 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2040 crt->valid_from.year, crt->valid_from.mon,
2041 crt->valid_from.day, crt->valid_from.hour,
2042 crt->valid_from.min, crt->valid_from.sec );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002043 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002044
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002045 ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002046 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
2047 crt->valid_to.year, crt->valid_to.mon,
2048 crt->valid_to.day, crt->valid_to.hour,
2049 crt->valid_to.min, crt->valid_to.sec );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002050 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002051
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002052 ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002053 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002054
Hanno Becker83cd8672019-02-21 17:13:46 +00002055 ret = mbedtls_x509_sig_alg_gets( p, n, sig_info.sig_pk,
2056 sig_info.sig_md, sig_info.sig_opts );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002057 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002058
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002059 /* Key size */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002060 if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
Hanno Becker4f869ed2019-02-24 16:47:57 +00002061 mbedtls_pk_get_name( pk ) ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002062 {
2063 return( ret );
2064 }
2065
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002066 ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
Hanno Becker4f869ed2019-02-24 16:47:57 +00002067 (int) mbedtls_pk_get_bitlen( pk ) );
2068 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002069
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002070 /*
2071 * Optional extensions
2072 */
2073
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002074 if( crt->ext_types & MBEDTLS_X509_EXT_BASIC_CONSTRAINTS )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002075 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002076 ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002077 crt->ca_istrue ? "true" : "false" );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002078 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002079
2080 if( crt->max_pathlen > 0 )
2081 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002082 ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", crt->max_pathlen - 1 );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002083 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002084 }
2085 }
2086
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002087 if( crt->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002088 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002089 ret = mbedtls_snprintf( p, n, "\n%ssubject alt name : ", prefix );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002090 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002091
2092 if( ( ret = x509_info_subject_alt_name( &p, &n,
Hanno Becker4f869ed2019-02-24 16:47:57 +00002093 &subject_alt_names ) ) != 0 )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002094 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002095 }
2096
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002097 if( crt->ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002098 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002099 ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002100 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02002101
2102 if( ( ret = x509_info_cert_type( &p, &n, crt->ns_cert_type ) ) != 0 )
2103 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002104 }
2105
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002106 if( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002107 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002108 ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002109 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02002110
2111 if( ( ret = x509_info_key_usage( &p, &n, crt->key_usage ) ) != 0 )
2112 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002113 }
2114
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002115 if( crt->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002116 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002117 ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002118 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002119
2120 if( ( ret = x509_info_ext_key_usage( &p, &n,
Hanno Becker4f869ed2019-02-24 16:47:57 +00002121 &ext_key_usage ) ) != 0 )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002122 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002123 }
2124
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002125 ret = mbedtls_snprintf( p, n, "\n" );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002126 MBEDTLS_X509_SAFE_SNPRINTF_WITH_ERROR;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002127
Hanno Becker4f869ed2019-02-24 16:47:57 +00002128 ret = (int) ( size - n );
2129
2130cleanup:
2131
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002132 mbedtls_x509_crt_frame_release( crt_raw, crt );
2133 mbedtls_x509_crt_pk_release( (mbedtls_x509_crt*) crt_raw, pk );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002134
2135 x509_crt_free_sig_info( &sig_info );
2136 x509_free_name( issuer.next );
2137 x509_free_name( subject.next );
2138 x509_free_sequence( ext_key_usage.next );
2139 x509_free_sequence( subject_alt_names.next );
2140
2141 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002142}
2143
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002144struct x509_crt_verify_string {
2145 int code;
2146 const char *string;
2147};
2148
2149static const struct x509_crt_verify_string x509_crt_verify_strings[] = {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002150 { MBEDTLS_X509_BADCERT_EXPIRED, "The certificate validity has expired" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002151 { MBEDTLS_X509_BADCERT_REVOKED, "The certificate has been revoked (is on a CRL)" },
2152 { MBEDTLS_X509_BADCERT_CN_MISMATCH, "The certificate Common Name (CN) does not match with the expected CN" },
2153 { MBEDTLS_X509_BADCERT_NOT_TRUSTED, "The certificate is not correctly signed by the trusted CA" },
2154 { MBEDTLS_X509_BADCRL_NOT_TRUSTED, "The CRL is not correctly signed by the trusted CA" },
2155 { MBEDTLS_X509_BADCRL_EXPIRED, "The CRL is expired" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002156 { MBEDTLS_X509_BADCERT_MISSING, "Certificate was missing" },
2157 { MBEDTLS_X509_BADCERT_SKIP_VERIFY, "Certificate verification was skipped" },
2158 { MBEDTLS_X509_BADCERT_OTHER, "Other reason (can be used by verify callback)" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002159 { MBEDTLS_X509_BADCERT_FUTURE, "The certificate validity starts in the future" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002160 { MBEDTLS_X509_BADCRL_FUTURE, "The CRL is from the future" },
2161 { MBEDTLS_X509_BADCERT_KEY_USAGE, "Usage does not match the keyUsage extension" },
2162 { MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, "Usage does not match the extendedKeyUsage extension" },
2163 { MBEDTLS_X509_BADCERT_NS_CERT_TYPE, "Usage does not match the nsCertType extension" },
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002164 { MBEDTLS_X509_BADCERT_BAD_MD, "The certificate is signed with an unacceptable hash." },
2165 { MBEDTLS_X509_BADCERT_BAD_PK, "The certificate is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
2166 { MBEDTLS_X509_BADCERT_BAD_KEY, "The certificate is signed with an unacceptable key (eg bad curve, RSA too short)." },
2167 { MBEDTLS_X509_BADCRL_BAD_MD, "The CRL is signed with an unacceptable hash." },
2168 { MBEDTLS_X509_BADCRL_BAD_PK, "The CRL is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
2169 { 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 +01002170 { 0, NULL }
2171};
2172
2173int mbedtls_x509_crt_verify_info( char *buf, size_t size, const char *prefix,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02002174 uint32_t flags )
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002175{
2176 int ret;
2177 const struct x509_crt_verify_string *cur;
2178 char *p = buf;
2179 size_t n = size;
2180
2181 for( cur = x509_crt_verify_strings; cur->string != NULL ; cur++ )
2182 {
2183 if( ( flags & cur->code ) == 0 )
2184 continue;
2185
2186 ret = mbedtls_snprintf( p, n, "%s%s\n", prefix, cur->string );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02002187 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002188 flags ^= cur->code;
2189 }
2190
2191 if( flags != 0 )
2192 {
2193 ret = mbedtls_snprintf( p, n, "%sUnknown reason "
2194 "(this should not happen)\n", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02002195 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002196 }
2197
2198 return( (int) ( size - n ) );
2199}
Hanno Becker02a21932019-06-10 15:08:43 +01002200#endif /* !MBEDTLS_X509_REMOVE_INFO */
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002201
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002202#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Hanno Becker45eedf12019-02-25 13:55:33 +00002203static int x509_crt_check_key_usage_frame( const mbedtls_x509_crt_frame *crt,
2204 unsigned int usage )
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02002205{
Manuel Pégourié-Gonnard655a9642015-06-23 10:48:44 +02002206 unsigned int usage_must, usage_may;
2207 unsigned int may_mask = MBEDTLS_X509_KU_ENCIPHER_ONLY
2208 | MBEDTLS_X509_KU_DECIPHER_ONLY;
2209
2210 if( ( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE ) == 0 )
2211 return( 0 );
2212
2213 usage_must = usage & ~may_mask;
2214
2215 if( ( ( crt->key_usage & ~may_mask ) & usage_must ) != usage_must )
2216 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
2217
2218 usage_may = usage & may_mask;
2219
2220 if( ( ( crt->key_usage & may_mask ) | usage_may ) != usage_may )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002221 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02002222
2223 return( 0 );
2224}
Hanno Becker45eedf12019-02-25 13:55:33 +00002225
2226int mbedtls_x509_crt_check_key_usage( const mbedtls_x509_crt *crt,
2227 unsigned int usage )
2228{
2229 int ret;
2230 mbedtls_x509_crt_frame *frame;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002231 ret = mbedtls_x509_crt_frame_acquire( crt,
2232 (mbedtls_x509_crt_frame**) &frame );
Hanno Becker45eedf12019-02-25 13:55:33 +00002233 if( ret != 0 )
2234 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2235
2236 ret = x509_crt_check_key_usage_frame( frame, usage );
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002237 mbedtls_x509_crt_frame_release( crt, (mbedtls_x509_crt_frame*) frame );
Hanno Becker45eedf12019-02-25 13:55:33 +00002238
2239 return( ret );
2240}
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02002241#endif
2242
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002243#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
Hanno Beckerc7c638e2019-02-21 21:10:51 +00002244typedef struct
2245{
2246 const char *oid;
2247 size_t oid_len;
2248} x509_crt_check_ext_key_usage_cb_ctx_t;
2249
2250static int x509_crt_check_ext_key_usage_cb( void *ctx,
2251 int tag,
2252 unsigned char *data,
2253 size_t data_len )
2254{
2255 x509_crt_check_ext_key_usage_cb_ctx_t *cb_ctx =
2256 (x509_crt_check_ext_key_usage_cb_ctx_t *) ctx;
2257 ((void) tag);
2258
2259 if( MBEDTLS_OID_CMP_RAW( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE,
2260 data, data_len ) == 0 )
2261 {
2262 return( 1 );
2263 }
2264
2265 if( data_len == cb_ctx->oid_len && memcmp( data, cb_ctx->oid,
2266 data_len ) == 0 )
2267 {
2268 return( 1 );
2269 }
2270
2271 return( 0 );
2272}
2273
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002274int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
Hanno Beckere1956af2019-02-21 14:28:12 +00002275 const char *usage_oid,
2276 size_t usage_len )
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002277{
Hanno Beckere1956af2019-02-21 14:28:12 +00002278 int ret;
Hanno Beckere9718b42019-02-25 18:11:42 +00002279 mbedtls_x509_crt_frame *frame;
Hanno Beckere1956af2019-02-21 14:28:12 +00002280 unsigned ext_types;
2281 unsigned char *p, *end;
Hanno Beckerc7c638e2019-02-21 21:10:51 +00002282 x509_crt_check_ext_key_usage_cb_ctx_t cb_ctx = { usage_oid, usage_len };
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002283
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002284 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Hanno Beckere9718b42019-02-25 18:11:42 +00002285 if( ret != 0 )
2286 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2287
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002288 /* Extension is not mandatory, absent means no restriction */
Hanno Beckere9718b42019-02-25 18:11:42 +00002289 ext_types = frame->ext_types;
2290 if( ( ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) != 0 )
2291 {
2292 p = frame->ext_key_usage_raw.p;
2293 end = p + frame->ext_key_usage_raw.len;
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002294
Hanno Beckere9718b42019-02-25 18:11:42 +00002295 ret = mbedtls_asn1_traverse_sequence_of( &p, end,
2296 0xFF, MBEDTLS_ASN1_OID, 0, 0,
2297 x509_crt_check_ext_key_usage_cb,
2298 &cb_ctx );
2299 if( ret == 1 )
2300 ret = 0;
2301 else
2302 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
2303 }
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002304
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002305 mbedtls_x509_crt_frame_release( crt, frame );
Hanno Beckere9718b42019-02-25 18:11:42 +00002306 return( ret );
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002307}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002308#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002309
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002310#if defined(MBEDTLS_X509_CRL_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002311/*
2312 * Return 1 if the certificate is revoked, or 0 otherwise.
2313 */
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002314static int x509_serial_is_revoked( unsigned char const *serial,
2315 size_t serial_len,
2316 const mbedtls_x509_crl *crl )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002317{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002318 const mbedtls_x509_crl_entry *cur = &crl->entry;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002319
2320 while( cur != NULL && cur->serial.len != 0 )
2321 {
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002322 if( serial_len == cur->serial.len &&
2323 memcmp( serial, cur->serial.p, serial_len ) == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002324 {
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01002325 if( mbedtls_x509_time_is_past( &cur->revocation_date ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002326 return( 1 );
2327 }
2328
2329 cur = cur->next;
2330 }
2331
2332 return( 0 );
2333}
2334
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002335int mbedtls_x509_crt_is_revoked( const mbedtls_x509_crt *crt,
2336 const mbedtls_x509_crl *crl )
2337{
Hanno Becker79ae5b62019-02-25 18:12:00 +00002338 int ret;
2339 mbedtls_x509_crt_frame *frame;
2340
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002341 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Hanno Becker79ae5b62019-02-25 18:12:00 +00002342 if( ret != 0 )
2343 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2344
2345 ret = x509_serial_is_revoked( frame->serial.p,
2346 frame->serial.len,
2347 crl );
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002348 mbedtls_x509_crt_frame_release( crt, frame );
Hanno Becker79ae5b62019-02-25 18:12:00 +00002349 return( ret );
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002350}
2351
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002352/*
Manuel Pégourié-Gonnardeeef9472016-02-22 11:36:55 +01002353 * Check that the given certificate is not revoked according to the CRL.
Manuel Pégourié-Gonnard08eacec2017-10-18 14:20:24 +02002354 * Skip validation if no CRL for the given CA is present.
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002355 */
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002356static int x509_crt_verifycrl( unsigned char *crt_serial,
2357 size_t crt_serial_len,
Hanno Beckerbb266132019-02-25 18:12:46 +00002358 mbedtls_x509_crt *ca_crt,
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002359 mbedtls_x509_crl *crl_list,
2360 const mbedtls_x509_crt_profile *profile )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002361{
Hanno Beckerbb266132019-02-25 18:12:46 +00002362 int ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002363 int flags = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002364 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
2365 const mbedtls_md_info_t *md_info;
Hanno Beckerbb266132019-02-25 18:12:46 +00002366 mbedtls_x509_buf_raw ca_subject;
2367 mbedtls_pk_context *pk;
2368 int can_sign;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002369
Hanno Beckerbb266132019-02-25 18:12:46 +00002370 if( ca_crt == NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002371 return( flags );
2372
Hanno Beckerbb266132019-02-25 18:12:46 +00002373 {
2374 mbedtls_x509_crt_frame *ca;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002375 ret = mbedtls_x509_crt_frame_acquire( ca_crt, &ca );
Hanno Beckerbb266132019-02-25 18:12:46 +00002376 if( ret != 0 )
2377 return( MBEDTLS_X509_BADCRL_NOT_TRUSTED );
2378
2379 ca_subject = ca->subject_raw;
2380
2381 can_sign = 0;
2382 if( x509_crt_check_key_usage_frame( ca,
2383 MBEDTLS_X509_KU_CRL_SIGN ) == 0 )
2384 {
2385 can_sign = 1;
2386 }
2387
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002388 mbedtls_x509_crt_frame_release( ca_crt, ca );
Hanno Beckerbb266132019-02-25 18:12:46 +00002389 }
2390
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002391 ret = mbedtls_x509_crt_pk_acquire( ca_crt, &pk );
Hanno Beckerbb266132019-02-25 18:12:46 +00002392 if( ret != 0 )
2393 return( MBEDTLS_X509_BADCRL_NOT_TRUSTED );
2394
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002395 while( crl_list != NULL )
2396 {
2397 if( crl_list->version == 0 ||
Hanno Becker7dee12a2019-02-21 13:58:38 +00002398 mbedtls_x509_name_cmp_raw( &crl_list->issuer_raw_no_hdr,
Hanno Beckerbb266132019-02-25 18:12:46 +00002399 &ca_subject, NULL, NULL ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002400 {
2401 crl_list = crl_list->next;
2402 continue;
2403 }
2404
2405 /*
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02002406 * Check if the CA is configured to sign CRLs
2407 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002408#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Hanno Beckerbb266132019-02-25 18:12:46 +00002409 if( !can_sign )
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02002410 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002411 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02002412 break;
2413 }
2414#endif
2415
2416 /*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002417 * Check if CRL is correctly signed by the trusted CA
2418 */
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02002419 if( x509_profile_check_md_alg( profile, crl_list->sig_md ) != 0 )
2420 flags |= MBEDTLS_X509_BADCRL_BAD_MD;
2421
2422 if( x509_profile_check_pk_alg( profile, crl_list->sig_pk ) != 0 )
2423 flags |= MBEDTLS_X509_BADCRL_BAD_PK;
2424
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002425 md_info = mbedtls_md_info_from_type( crl_list->sig_md );
Manuel Pégourié-Gonnard329e78c2017-06-26 12:22:17 +02002426 if( mbedtls_md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002427 {
Manuel Pégourié-Gonnard329e78c2017-06-26 12:22:17 +02002428 /* Note: this can't happen except after an internal error */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002429 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002430 break;
2431 }
2432
Hanno Beckerbb266132019-02-25 18:12:46 +00002433 if( x509_profile_check_key( profile, pk ) != 0 )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02002434 flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002435
Hanno Beckerbb266132019-02-25 18:12:46 +00002436 if( mbedtls_pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, pk,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002437 crl_list->sig_md, hash, mbedtls_md_get_size( md_info ),
Manuel Pégourié-Gonnard53882022014-06-05 17:53:52 +02002438 crl_list->sig.p, crl_list->sig.len ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002439 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002440 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002441 break;
2442 }
2443
2444 /*
2445 * Check for validity of CRL (Do not drop out)
2446 */
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01002447 if( mbedtls_x509_time_is_past( &crl_list->next_update ) )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002448 flags |= MBEDTLS_X509_BADCRL_EXPIRED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002449
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01002450 if( mbedtls_x509_time_is_future( &crl_list->this_update ) )
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002451 flags |= MBEDTLS_X509_BADCRL_FUTURE;
Manuel Pégourié-Gonnard95337652014-03-10 13:15:18 +01002452
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002453 /*
2454 * Check if certificate is revoked
2455 */
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002456 if( x509_serial_is_revoked( crt_serial, crt_serial_len,
2457 crl_list ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002458 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002459 flags |= MBEDTLS_X509_BADCERT_REVOKED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002460 break;
2461 }
2462
2463 crl_list = crl_list->next;
2464 }
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02002465
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002466 mbedtls_x509_crt_pk_release( ca_crt, pk );
Paul Bakkerd8bb8262014-06-17 14:06:49 +02002467 return( flags );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002468}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002469#endif /* MBEDTLS_X509_CRL_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002470
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02002471/*
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002472 * Check the signature of a certificate by its parent
2473 */
Hanno Becker5299cf82019-02-25 13:50:41 +00002474static int x509_crt_check_signature( const mbedtls_x509_crt_sig_info *sig_info,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002475 mbedtls_x509_crt *parent,
2476 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002477{
Hanno Beckere449e2d2019-02-25 14:45:31 +00002478 int ret;
2479 mbedtls_pk_context *pk;
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002480
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002481 ret = mbedtls_x509_crt_pk_acquire( parent, &pk );
Hanno Beckere449e2d2019-02-25 14:45:31 +00002482 if( ret != 0 )
2483 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2484
2485 /* Skip expensive computation on obvious mismatch */
2486 if( ! mbedtls_pk_can_do( pk, sig_info->sig_pk ) )
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002487 {
Hanno Beckere449e2d2019-02-25 14:45:31 +00002488 ret = -1;
2489 goto exit;
2490 }
2491
2492#if !( defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE) )
2493 ((void) rs_ctx);
2494#else
2495 if( rs_ctx != NULL && sig_info->sig_pk == MBEDTLS_PK_ECDSA )
2496 {
2497 ret = mbedtls_pk_verify_restartable( pk,
Hanno Becker5299cf82019-02-25 13:50:41 +00002498 sig_info->sig_md,
2499 sig_info->crt_hash, sig_info->crt_hash_len,
2500 sig_info->sig.p, sig_info->sig.len,
Hanno Beckere449e2d2019-02-25 14:45:31 +00002501 &rs_ctx->pk );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002502 }
Hanno Beckere449e2d2019-02-25 14:45:31 +00002503 else
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002504#endif
Hanno Beckere449e2d2019-02-25 14:45:31 +00002505 {
2506 ret = mbedtls_pk_verify_ext( sig_info->sig_pk,
2507 sig_info->sig_opts,
2508 pk,
2509 sig_info->sig_md,
2510 sig_info->crt_hash, sig_info->crt_hash_len,
2511 sig_info->sig.p, sig_info->sig.len );
2512 }
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002513
Hanno Beckere449e2d2019-02-25 14:45:31 +00002514exit:
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002515 mbedtls_x509_crt_pk_release( parent, pk );
Hanno Beckere449e2d2019-02-25 14:45:31 +00002516 return( ret );
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002517}
2518
2519/*
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002520 * Check if 'parent' is a suitable parent (signing CA) for 'child'.
2521 * Return 0 if yes, -1 if not.
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002522 *
2523 * top means parent is a locally-trusted certificate
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002524 */
Hanno Becker43bf9002019-02-25 14:46:49 +00002525static int x509_crt_check_parent( const mbedtls_x509_crt_sig_info *sig_info,
2526 const mbedtls_x509_crt_frame *parent,
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002527 int top )
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002528{
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002529 int need_ca_bit;
2530
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02002531 /* Parent must be the issuer */
Hanno Becker43bf9002019-02-25 14:46:49 +00002532 if( mbedtls_x509_name_cmp_raw( &sig_info->issuer_raw,
2533 &parent->subject_raw,
Hanno Becker67284cc2019-02-21 14:31:51 +00002534 NULL, NULL ) != 0 )
Hanno Becker7dee12a2019-02-21 13:58:38 +00002535 {
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002536 return( -1 );
Hanno Becker7dee12a2019-02-21 13:58:38 +00002537 }
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002538
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002539 /* Parent must have the basicConstraints CA bit set as a general rule */
2540 need_ca_bit = 1;
2541
2542 /* Exception: v1/v2 certificates that are locally trusted. */
2543 if( top && parent->version < 3 )
2544 need_ca_bit = 0;
2545
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002546 if( need_ca_bit && ! parent->ca_istrue )
2547 return( -1 );
2548
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002549#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002550 if( need_ca_bit &&
Hanno Becker43bf9002019-02-25 14:46:49 +00002551 x509_crt_check_key_usage_frame( parent,
2552 MBEDTLS_X509_KU_KEY_CERT_SIGN ) != 0 )
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02002553 {
2554 return( -1 );
2555 }
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002556#endif
2557
2558 return( 0 );
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002559}
2560
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02002561/*
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002562 * Find a suitable parent for child in candidates, or return NULL.
2563 *
2564 * Here suitable is defined as:
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002565 * 1. subject name matches child's issuer
2566 * 2. if necessary, the CA bit is set and key usage allows signing certs
2567 * 3. for trusted roots, the signature is correct
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002568 * (for intermediates, the signature is checked and the result reported)
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002569 * 4. pathlen constraints are satisfied
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002570 *
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02002571 * If there's a suitable candidate which is also time-valid, return the first
2572 * such. Otherwise, return the first suitable candidate (or NULL if there is
2573 * none).
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002574 *
2575 * The rationale for this rule is that someone could have a list of trusted
2576 * roots with two versions on the same root with different validity periods.
2577 * (At least one user reported having such a list and wanted it to just work.)
2578 * The reason we don't just require time-validity is that generally there is
2579 * only one version, and if it's expired we want the flags to state that
2580 * rather than NOT_TRUSTED, as would be the case if we required it here.
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002581 *
2582 * The rationale for rule 3 (signature for trusted roots) is that users might
2583 * have two versions of the same CA with different keys in their list, and the
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002584 * way we select the correct one is by checking the signature (as we don't
2585 * rely on key identifier extensions). (This is one way users might choose to
2586 * handle key rollover, another relies on self-issued certs, see [SIRO].)
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02002587 *
2588 * Arguments:
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002589 * - [in] child: certificate for which we're looking for a parent
2590 * - [in] candidates: chained list of potential parents
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002591 * - [out] r_parent: parent found (or NULL)
2592 * - [out] r_signature_is_good: 1 if child signature by parent is valid, or 0
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002593 * - [in] top: 1 if candidates consists of trusted roots, ie we're at the top
2594 * of the chain, 0 otherwise
2595 * - [in] path_cnt: number of intermediates seen so far
2596 * - [in] self_cnt: number of self-signed intermediates seen so far
2597 * (will never be greater than path_cnt)
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002598 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002599 *
2600 * Return value:
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002601 * - 0 on success
2602 * - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002603 */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002604static int x509_crt_find_parent_in(
Hanno Becker5299cf82019-02-25 13:50:41 +00002605 mbedtls_x509_crt_sig_info const *child_sig,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002606 mbedtls_x509_crt *candidates,
2607 mbedtls_x509_crt **r_parent,
2608 int *r_signature_is_good,
2609 int top,
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002610 unsigned path_cnt,
2611 unsigned self_cnt,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002612 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002613{
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002614 int ret;
Hanno Becker43bf9002019-02-25 14:46:49 +00002615 mbedtls_x509_crt *parent_crt, *fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002616 int signature_is_good, fallback_signature_is_good;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002617
2618#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002619 /* did we have something in progress? */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002620 if( rs_ctx != NULL && rs_ctx->parent != NULL )
2621 {
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002622 /* restore saved state */
Hanno Becker43bf9002019-02-25 14:46:49 +00002623 parent_crt = rs_ctx->parent;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002624 fallback_parent = rs_ctx->fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002625 fallback_signature_is_good = rs_ctx->fallback_signature_is_good;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002626
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002627 /* clear saved state */
2628 rs_ctx->parent = NULL;
2629 rs_ctx->fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002630 rs_ctx->fallback_signature_is_good = 0;
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002631
2632 /* resume where we left */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002633 goto check_signature;
2634 }
2635#endif
2636
2637 fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002638 fallback_signature_is_good = 0;
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002639
Hanno Becker43bf9002019-02-25 14:46:49 +00002640 for( parent_crt = candidates; parent_crt != NULL;
2641 parent_crt = parent_crt->next )
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002642 {
Hanno Beckera788cab2019-02-24 17:47:46 +00002643 int parent_valid, parent_match, path_len_ok;
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002644
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002645#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2646check_signature:
2647#endif
Hanno Beckera788cab2019-02-24 17:47:46 +00002648
2649 parent_valid = parent_match = path_len_ok = 0;
Hanno Beckera788cab2019-02-24 17:47:46 +00002650 {
Hanno Becker43bf9002019-02-25 14:46:49 +00002651 mbedtls_x509_crt_frame *parent;
Hanno Beckera788cab2019-02-24 17:47:46 +00002652
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002653 ret = mbedtls_x509_crt_frame_acquire( parent_crt, &parent );
Hanno Becker43bf9002019-02-25 14:46:49 +00002654 if( ret != 0 )
2655 return( MBEDTLS_ERR_X509_FATAL_ERROR );
Hanno Beckera788cab2019-02-24 17:47:46 +00002656
Hanno Becker43bf9002019-02-25 14:46:49 +00002657 if( mbedtls_x509_time_is_past( &parent->valid_from ) &&
2658 mbedtls_x509_time_is_future( &parent->valid_to ) )
2659 {
2660 parent_valid = 1;
2661 }
2662
2663 /* basic parenting skills (name, CA bit, key usage) */
2664 if( x509_crt_check_parent( child_sig, parent, top ) == 0 )
2665 parent_match = 1;
2666
2667 /* +1 because the stored max_pathlen is 1 higher
2668 * than the actual value */
2669 if( !( parent->max_pathlen > 0 &&
2670 (size_t) parent->max_pathlen < 1 + path_cnt - self_cnt ) )
2671 {
2672 path_len_ok = 1;
2673 }
2674
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002675 mbedtls_x509_crt_frame_release( parent_crt, parent );
Hanno Beckera788cab2019-02-24 17:47:46 +00002676 }
2677
2678 if( parent_match == 0 || path_len_ok == 0 )
2679 continue;
2680
2681 /* Signature */
Hanno Becker43bf9002019-02-25 14:46:49 +00002682 ret = x509_crt_check_signature( child_sig, parent_crt, rs_ctx );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002683
2684#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002685 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
2686 {
2687 /* save state */
Hanno Becker43bf9002019-02-25 14:46:49 +00002688 rs_ctx->parent = parent_crt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002689 rs_ctx->fallback_parent = fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002690 rs_ctx->fallback_signature_is_good = fallback_signature_is_good;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002691
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002692 return( ret );
2693 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002694#else
2695 (void) ret;
2696#endif
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002697
2698 signature_is_good = ret == 0;
2699 if( top && ! signature_is_good )
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002700 continue;
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002701
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02002702 /* optional time check */
Hanno Beckera788cab2019-02-24 17:47:46 +00002703 if( !parent_valid )
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002704 {
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002705 if( fallback_parent == NULL )
2706 {
Hanno Becker43bf9002019-02-25 14:46:49 +00002707 fallback_parent = parent_crt;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002708 fallback_signature_is_good = signature_is_good;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002709 }
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002710
2711 continue;
2712 }
2713
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002714 break;
2715 }
2716
Hanno Becker43bf9002019-02-25 14:46:49 +00002717 if( parent_crt != NULL )
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002718 {
Hanno Becker43bf9002019-02-25 14:46:49 +00002719 *r_parent = parent_crt;
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002720 *r_signature_is_good = signature_is_good;
2721 }
2722 else
2723 {
2724 *r_parent = fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002725 *r_signature_is_good = fallback_signature_is_good;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002726 }
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002727
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002728 return( 0 );
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002729}
2730
2731/*
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002732 * Find a parent in trusted CAs or the provided chain, or return NULL.
2733 *
2734 * Searches in trusted CAs first, and return the first suitable parent found
2735 * (see find_parent_in() for definition of suitable).
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02002736 *
2737 * Arguments:
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002738 * - [in] child: certificate for which we're looking for a parent, followed
2739 * by a chain of possible intermediates
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002740 * - [in] trust_ca: list of locally trusted certificates
2741 * - [out] parent: parent found (or NULL)
2742 * - [out] parent_is_trusted: 1 if returned `parent` is trusted, or 0
2743 * - [out] signature_is_good: 1 if child signature by parent is valid, or 0
2744 * - [in] path_cnt: number of links in the chain so far (EE -> ... -> child)
2745 * - [in] self_cnt: number of self-signed certs in the chain so far
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002746 * (will always be no greater than path_cnt)
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002747 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002748 *
2749 * Return value:
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002750 * - 0 on success
2751 * - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002752 */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002753static int x509_crt_find_parent(
Hanno Becker5299cf82019-02-25 13:50:41 +00002754 mbedtls_x509_crt_sig_info const *child_sig,
Hanno Becker1e0677a2019-02-25 14:58:22 +00002755 mbedtls_x509_crt *rest,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002756 mbedtls_x509_crt *trust_ca,
2757 mbedtls_x509_crt **parent,
2758 int *parent_is_trusted,
2759 int *signature_is_good,
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002760 unsigned path_cnt,
2761 unsigned self_cnt,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002762 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002763{
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002764 int ret;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002765 mbedtls_x509_crt *search_list;
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002766
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002767 *parent_is_trusted = 1;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002768
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002769#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002770 /* restore then clear saved state if we have some stored */
2771 if( rs_ctx != NULL && rs_ctx->parent_is_trusted != -1 )
2772 {
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002773 *parent_is_trusted = rs_ctx->parent_is_trusted;
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002774 rs_ctx->parent_is_trusted = -1;
2775 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002776#endif
2777
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002778 while( 1 ) {
Hanno Becker1e0677a2019-02-25 14:58:22 +00002779 search_list = *parent_is_trusted ? trust_ca : rest;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002780
Hanno Becker5299cf82019-02-25 13:50:41 +00002781 ret = x509_crt_find_parent_in( child_sig, search_list,
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002782 parent, signature_is_good,
2783 *parent_is_trusted,
2784 path_cnt, self_cnt, rs_ctx );
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002785
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002786#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002787 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
2788 {
2789 /* save state */
2790 rs_ctx->parent_is_trusted = *parent_is_trusted;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002791 return( ret );
2792 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002793#else
2794 (void) ret;
2795#endif
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002796
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002797 /* stop here if found or already in second iteration */
2798 if( *parent != NULL || *parent_is_trusted == 0 )
2799 break;
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002800
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002801 /* prepare second iteration */
2802 *parent_is_trusted = 0;
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002803 }
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002804
2805 /* extra precaution against mistakes in the caller */
Krzysztof Stachowiakc388a8c2018-10-31 16:49:20 +01002806 if( *parent == NULL )
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002807 {
Manuel Pégourié-Gonnarda5a3e402018-10-16 11:27:23 +02002808 *parent_is_trusted = 0;
2809 *signature_is_good = 0;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02002810 }
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002811
2812 return( 0 );
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02002813}
2814
2815/*
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002816 * Check if an end-entity certificate is locally trusted
2817 *
2818 * Currently we require such certificates to be self-signed (actually only
2819 * check for self-issued as self-signatures are not checked)
2820 */
2821static int x509_crt_check_ee_locally_trusted(
Hanno Becker1e0677a2019-02-25 14:58:22 +00002822 mbedtls_x509_crt_frame const *crt,
2823 mbedtls_x509_crt const *trust_ca )
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002824{
Hanno Becker1e0677a2019-02-25 14:58:22 +00002825 mbedtls_x509_crt const *cur;
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002826
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002827 /* look for an exact match with trusted cert */
2828 for( cur = trust_ca; cur != NULL; cur = cur->next )
2829 {
2830 if( crt->raw.len == cur->raw.len &&
2831 memcmp( crt->raw.p, cur->raw.p, crt->raw.len ) == 0 )
2832 {
2833 return( 0 );
2834 }
2835 }
2836
2837 /* too bad */
2838 return( -1 );
2839}
2840
2841/*
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002842 * Build and verify a certificate chain
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02002843 *
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002844 * Given a peer-provided list of certificates EE, C1, ..., Cn and
2845 * a list of trusted certs R1, ... Rp, try to build and verify a chain
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02002846 * EE, Ci1, ... Ciq [, Rj]
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002847 * such that every cert in the chain is a child of the next one,
2848 * jumping to a trusted root as early as possible.
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002849 *
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002850 * Verify that chain and return it with flags for all issues found.
2851 *
2852 * Special cases:
2853 * - EE == Rj -> return a one-element list containing it
2854 * - EE, Ci1, ..., Ciq cannot be continued with a trusted root
2855 * -> return that chain with NOT_TRUSTED set on Ciq
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002856 *
Manuel Pégourié-Gonnardd19a41d2017-07-14 11:05:59 +02002857 * Tests for (aspects of) this function should include at least:
2858 * - trusted EE
2859 * - EE -> trusted root
2860 * - EE -> intermedate CA -> trusted root
2861 * - if relevant: EE untrusted
2862 * - if relevant: EE -> intermediate, untrusted
2863 * with the aspect under test checked at each relevant level (EE, int, root).
2864 * For some aspects longer chains are required, but usually length 2 is
2865 * enough (but length 1 is not in general).
2866 *
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002867 * Arguments:
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002868 * - [in] crt: the cert list EE, C1, ..., Cn
2869 * - [in] trust_ca: the trusted list R1, ..., Rp
2870 * - [in] ca_crl, profile: as in verify_with_profile()
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002871 * - [out] ver_chain: the built and verified chain
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02002872 * Only valid when return value is 0, may contain garbage otherwise!
2873 * Restart note: need not be the same when calling again to resume.
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02002874 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002875 *
2876 * Return value:
2877 * - non-zero if the chain could not be fully built and examined
2878 * - 0 is the chain was successfully built and examined,
2879 * even if it was found to be invalid
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02002880 */
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002881static int x509_crt_verify_chain(
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002882 mbedtls_x509_crt *crt,
2883 mbedtls_x509_crt *trust_ca,
2884 mbedtls_x509_crl *ca_crl,
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002885 const mbedtls_x509_crt_profile *profile,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002886 mbedtls_x509_crt_verify_chain *ver_chain,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002887 mbedtls_x509_crt_restart_ctx *rs_ctx )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002888{
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02002889 /* Don't initialize any of those variables here, so that the compiler can
2890 * catch potential issues with jumping ahead when restarting */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002891 int ret;
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002892 uint32_t *flags;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002893 mbedtls_x509_crt_verify_chain_item *cur;
Hanno Becker1e0677a2019-02-25 14:58:22 +00002894 mbedtls_x509_crt *child_crt;
Hanno Becker58c35642019-02-25 18:13:46 +00002895 mbedtls_x509_crt *parent_crt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002896 int parent_is_trusted;
2897 int child_is_trusted;
2898 int signature_is_good;
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002899 unsigned self_cnt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002900
2901#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2902 /* resume if we had an operation in progress */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002903 if( rs_ctx != NULL && rs_ctx->in_progress == x509_crt_rs_find_parent )
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002904 {
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002905 /* restore saved state */
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02002906 *ver_chain = rs_ctx->ver_chain; /* struct copy */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002907 self_cnt = rs_ctx->self_cnt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002908
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02002909 /* restore derived state */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002910 cur = &ver_chain->items[ver_chain->len - 1];
Hanno Becker1e0677a2019-02-25 14:58:22 +00002911 child_crt = cur->crt;
2912
2913 child_is_trusted = 0;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002914 goto find_parent;
2915 }
2916#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
Manuel Pégourié-Gonnard8f8c2822017-07-03 21:25:10 +02002917
Hanno Becker1e0677a2019-02-25 14:58:22 +00002918 child_crt = crt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002919 self_cnt = 0;
2920 parent_is_trusted = 0;
2921 child_is_trusted = 0;
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02002922
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002923 while( 1 ) {
Hanno Becker5299cf82019-02-25 13:50:41 +00002924#if defined(MBEDTLS_X509_CRL_PARSE_C)
2925 mbedtls_x509_buf_raw child_serial;
2926#endif /* MBEDTLS_X509_CRL_PARSE_C */
2927 int self_issued;
Hanno Becker1e0677a2019-02-25 14:58:22 +00002928
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002929 /* Add certificate to the verification chain */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002930 cur = &ver_chain->items[ver_chain->len];
Hanno Becker1e0677a2019-02-25 14:58:22 +00002931 cur->crt = child_crt;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002932 cur->flags = 0;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02002933 ver_chain->len++;
Hanno Becker10e6b9b2019-02-22 17:56:43 +00002934
2935#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2936find_parent:
2937#endif
2938
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02002939 flags = &cur->flags;
Manuel Pégourié-Gonnard66fac752017-07-03 21:39:21 +02002940
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02002941 {
Hanno Becker5299cf82019-02-25 13:50:41 +00002942 mbedtls_x509_crt_sig_info child_sig;
2943 {
2944 mbedtls_x509_crt_frame *child;
Manuel Pégourié-Gonnard8f8c2822017-07-03 21:25:10 +02002945
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002946 ret = mbedtls_x509_crt_frame_acquire( child_crt, &child );
Hanno Becker5299cf82019-02-25 13:50:41 +00002947 if( ret != 0 )
2948 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2949
2950 /* Check time-validity (all certificates) */
2951 if( mbedtls_x509_time_is_past( &child->valid_to ) )
2952 *flags |= MBEDTLS_X509_BADCERT_EXPIRED;
2953 if( mbedtls_x509_time_is_future( &child->valid_from ) )
2954 *flags |= MBEDTLS_X509_BADCERT_FUTURE;
2955
2956 /* Stop here for trusted roots (but not for trusted EE certs) */
2957 if( child_is_trusted )
2958 {
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002959 mbedtls_x509_crt_frame_release( child_crt, child );
Hanno Becker5299cf82019-02-25 13:50:41 +00002960 return( 0 );
2961 }
2962
2963 self_issued = 0;
2964 if( mbedtls_x509_name_cmp_raw( &child->issuer_raw,
2965 &child->subject_raw,
2966 NULL, NULL ) == 0 )
2967 {
2968 self_issued = 1;
2969 }
2970
2971 /* Check signature algorithm: MD & PK algs */
2972 if( x509_profile_check_md_alg( profile, child->sig_md ) != 0 )
2973 *flags |= MBEDTLS_X509_BADCERT_BAD_MD;
2974
2975 if( x509_profile_check_pk_alg( profile, child->sig_pk ) != 0 )
2976 *flags |= MBEDTLS_X509_BADCERT_BAD_PK;
2977
2978 /* Special case: EE certs that are locally trusted */
2979 if( ver_chain->len == 1 && self_issued &&
2980 x509_crt_check_ee_locally_trusted( child, trust_ca ) == 0 )
2981 {
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002982 mbedtls_x509_crt_frame_release( child_crt, child );
Hanno Becker5299cf82019-02-25 13:50:41 +00002983 return( 0 );
2984 }
2985
2986#if defined(MBEDTLS_X509_CRL_PARSE_C)
2987 child_serial = child->serial;
2988#endif /* MBEDTLS_X509_CRL_PARSE_C */
2989
2990 ret = x509_crt_get_sig_info( child, &child_sig );
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002991 mbedtls_x509_crt_frame_release( child_crt, child );
Hanno Becker5299cf82019-02-25 13:50:41 +00002992
Hanno Becker5299cf82019-02-25 13:50:41 +00002993 if( ret != 0 )
2994 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2995 }
2996
2997 /* Look for a parent in trusted CAs or up the chain */
2998 ret = x509_crt_find_parent( &child_sig, child_crt->next,
Hanno Becker58c35642019-02-25 18:13:46 +00002999 trust_ca, &parent_crt,
Hanno Becker5299cf82019-02-25 13:50:41 +00003000 &parent_is_trusted, &signature_is_good,
3001 ver_chain->len - 1, self_cnt, rs_ctx );
3002
3003 x509_crt_free_sig_info( &child_sig );
3004 }
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003005
3006#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003007 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
3008 {
3009 /* save state */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02003010 rs_ctx->in_progress = x509_crt_rs_find_parent;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003011 rs_ctx->self_cnt = self_cnt;
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02003012 rs_ctx->ver_chain = *ver_chain; /* struct copy */
Hanno Becker5299cf82019-02-25 13:50:41 +00003013 return( ret );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003014 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003015#else
3016 (void) ret;
3017#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003018
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003019 /* No parent? We're done here */
Hanno Becker58c35642019-02-25 18:13:46 +00003020 if( parent_crt == NULL )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003021 {
3022 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
Hanno Becker5299cf82019-02-25 13:50:41 +00003023 return( 0 );
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003024 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003025
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003026 /* Count intermediate self-issued (not necessarily self-signed) certs.
3027 * These can occur with some strategies for key rollover, see [SIRO],
3028 * and should be excluded from max_pathlen checks. */
Hanno Becker5299cf82019-02-25 13:50:41 +00003029 if( ver_chain->len != 1 && self_issued )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003030 self_cnt++;
Manuel Pégourié-Gonnardfd6c85c2014-11-20 16:34:20 +01003031
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003032 /* path_cnt is 0 for the first intermediate CA,
3033 * and if parent is trusted it's not an intermediate CA */
3034 if( ! parent_is_trusted &&
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003035 ver_chain->len > MBEDTLS_X509_MAX_INTERMEDIATE_CA )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003036 {
3037 /* return immediately to avoid overflow the chain array */
Hanno Becker5299cf82019-02-25 13:50:41 +00003038 return( MBEDTLS_ERR_X509_FATAL_ERROR );
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003039 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003040
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02003041 /* signature was checked while searching parent */
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003042 if( ! signature_is_good )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003043 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
3044
Hanno Becker58c35642019-02-25 18:13:46 +00003045 {
3046 mbedtls_pk_context *parent_pk;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003047 ret = mbedtls_x509_crt_pk_acquire( parent_crt, &parent_pk );
Hanno Becker58c35642019-02-25 18:13:46 +00003048 if( ret != 0 )
3049 return( MBEDTLS_ERR_X509_FATAL_ERROR );
3050
3051 /* check size of signing key */
3052 if( x509_profile_check_key( profile, parent_pk ) != 0 )
3053 *flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
3054
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003055 mbedtls_x509_crt_pk_release( parent_crt, parent_pk );
Hanno Becker58c35642019-02-25 18:13:46 +00003056 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003057
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003058#if defined(MBEDTLS_X509_CRL_PARSE_C)
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003059 /* Check trusted CA's CRL for the given crt */
Hanno Becker5299cf82019-02-25 13:50:41 +00003060 *flags |= x509_crt_verifycrl( child_serial.p,
3061 child_serial.len,
Hanno Becker58c35642019-02-25 18:13:46 +00003062 parent_crt, ca_crl, profile );
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003063#else
3064 (void) ca_crl;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003065#endif
3066
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003067 /* prepare for next iteration */
Hanno Becker58c35642019-02-25 18:13:46 +00003068 child_crt = parent_crt;
3069 parent_crt = NULL;
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003070 child_is_trusted = parent_is_trusted;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003071 signature_is_good = 0;
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003072 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003073}
3074
3075/*
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003076 * Check for CN match
3077 */
Hanno Becker24926222019-02-21 13:10:55 +00003078static int x509_crt_check_cn( unsigned char const *buf,
3079 size_t buflen,
3080 const char *cn,
3081 size_t cn_len )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003082{
Hanno Becker24926222019-02-21 13:10:55 +00003083 /* Try exact match */
Hanno Beckerb3def1d2019-02-22 11:46:06 +00003084 if( mbedtls_x509_memcasecmp( cn, buf, buflen, cn_len ) == 0 )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003085 return( 0 );
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003086
3087 /* try wildcard match */
Hanno Becker24926222019-02-21 13:10:55 +00003088 if( x509_check_wildcard( cn, cn_len, buf, buflen ) == 0 )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003089 {
3090 return( 0 );
3091 }
3092
3093 return( -1 );
3094}
3095
Hanno Becker8b543b32019-02-21 11:50:44 +00003096/* Returns 1 on a match and 0 on a mismatch.
3097 * This is because this function is used as a callback for
3098 * mbedtls_x509_name_cmp_raw(), which continues the name
3099 * traversal as long as the callback returns 0. */
3100static int x509_crt_check_name( void *ctx,
3101 mbedtls_x509_buf *oid,
Hanno Becker6b378122019-02-23 10:20:14 +00003102 mbedtls_x509_buf *val,
3103 int next_merged )
Hanno Becker8b543b32019-02-21 11:50:44 +00003104{
3105 char const *cn = (char const*) ctx;
3106 size_t cn_len = strlen( cn );
Hanno Becker6b378122019-02-23 10:20:14 +00003107 ((void) next_merged);
Hanno Becker8b543b32019-02-21 11:50:44 +00003108
3109 if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, oid ) == 0 &&
Hanno Becker24926222019-02-21 13:10:55 +00003110 x509_crt_check_cn( val->p, val->len, cn, cn_len ) == 0 )
Hanno Becker8b543b32019-02-21 11:50:44 +00003111 {
3112 return( 1 );
3113 }
3114
3115 return( 0 );
3116}
3117
Hanno Beckerda410822019-02-21 13:36:59 +00003118/* Returns 1 on a match and 0 on a mismatch.
3119 * This is because this function is used as a callback for
3120 * mbedtls_asn1_traverse_sequence_of(), which continues the
3121 * traversal as long as the callback returns 0. */
3122static int x509_crt_subject_alt_check_name( void *ctx,
3123 int tag,
3124 unsigned char *data,
3125 size_t data_len )
3126{
3127 char const *cn = (char const*) ctx;
3128 size_t cn_len = strlen( cn );
Hanno Becker90b94082019-02-21 21:13:21 +00003129 ((void) tag);
Hanno Beckerda410822019-02-21 13:36:59 +00003130
3131 if( x509_crt_check_cn( data, data_len, cn, cn_len ) == 0 )
3132 return( 1 );
3133
3134 return( 0 );
3135}
3136
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003137/*
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003138 * Verify the requested CN - only call this if cn is not NULL!
3139 */
Hanno Becker082435c2019-02-25 18:14:40 +00003140static int x509_crt_verify_name( const mbedtls_x509_crt *crt,
3141 const char *cn,
3142 uint32_t *flags )
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003143{
Hanno Beckerda410822019-02-21 13:36:59 +00003144 int ret;
Hanno Becker082435c2019-02-25 18:14:40 +00003145 mbedtls_x509_crt_frame *frame;
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003146
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003147 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Hanno Becker082435c2019-02-25 18:14:40 +00003148 if( ret != 0 )
3149 return( MBEDTLS_ERR_X509_FATAL_ERROR );
3150
3151 if( frame->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003152 {
Hanno Becker90b94082019-02-21 21:13:21 +00003153 unsigned char *p =
Hanno Becker082435c2019-02-25 18:14:40 +00003154 frame->subject_alt_raw.p;
Hanno Beckerda410822019-02-21 13:36:59 +00003155 const unsigned char *end =
Hanno Becker082435c2019-02-25 18:14:40 +00003156 frame->subject_alt_raw.p + frame->subject_alt_raw.len;
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003157
Hanno Becker90b94082019-02-21 21:13:21 +00003158 ret = mbedtls_asn1_traverse_sequence_of( &p, end,
3159 MBEDTLS_ASN1_TAG_CLASS_MASK,
3160 MBEDTLS_ASN1_CONTEXT_SPECIFIC,
3161 MBEDTLS_ASN1_TAG_VALUE_MASK,
3162 2 /* SubjectAlt DNS */,
3163 x509_crt_subject_alt_check_name,
3164 (void*) cn );
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003165 }
3166 else
3167 {
Hanno Becker082435c2019-02-25 18:14:40 +00003168 ret = mbedtls_x509_name_cmp_raw( &frame->subject_raw,
3169 &frame->subject_raw,
Hanno Becker8b543b32019-02-21 11:50:44 +00003170 x509_crt_check_name, (void*) cn );
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003171 }
Hanno Beckerda410822019-02-21 13:36:59 +00003172
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003173 mbedtls_x509_crt_frame_release( crt, frame );
Hanno Becker082435c2019-02-25 18:14:40 +00003174
3175 /* x509_crt_check_name() and x509_crt_subject_alt_check_name()
3176 * return 1 when finding a name component matching `cn`. */
3177 if( ret == 1 )
3178 return( 0 );
3179
3180 if( ret != 0 )
3181 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
3182
3183 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
3184 return( ret );
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003185}
3186
3187/*
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003188 * Merge the flags for all certs in the chain, after calling callback
3189 */
3190static int x509_crt_merge_flags_with_cb(
3191 uint32_t *flags,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003192 const mbedtls_x509_crt_verify_chain *ver_chain,
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003193 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
3194 void *p_vrfy )
3195{
3196 int ret;
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02003197 unsigned i;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003198 uint32_t cur_flags;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003199 const mbedtls_x509_crt_verify_chain_item *cur;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003200
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003201 for( i = ver_chain->len; i != 0; --i )
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003202 {
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003203 cur = &ver_chain->items[i-1];
3204 cur_flags = cur->flags;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003205
3206 if( NULL != f_vrfy )
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02003207 if( ( ret = f_vrfy( p_vrfy, cur->crt, (int) i-1, &cur_flags ) ) != 0 )
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003208 return( ret );
3209
3210 *flags |= cur_flags;
3211 }
3212
3213 return( 0 );
3214}
3215
3216/*
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003217 * Verify the certificate validity (default profile, not restartable)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003218 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003219int mbedtls_x509_crt_verify( mbedtls_x509_crt *crt,
3220 mbedtls_x509_crt *trust_ca,
3221 mbedtls_x509_crl *ca_crl,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02003222 const char *cn, uint32_t *flags,
3223 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Paul Bakkerddf26b42013-09-18 13:46:23 +02003224 void *p_vrfy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003225{
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003226 return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
3227 &mbedtls_x509_crt_profile_default, cn, flags,
3228 f_vrfy, p_vrfy, NULL ) );
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003229}
3230
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003231/*
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003232 * Verify the certificate validity (user-chosen profile, not restartable)
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003233 */
3234int mbedtls_x509_crt_verify_with_profile( mbedtls_x509_crt *crt,
3235 mbedtls_x509_crt *trust_ca,
3236 mbedtls_x509_crl *ca_crl,
3237 const mbedtls_x509_crt_profile *profile,
3238 const char *cn, uint32_t *flags,
3239 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
3240 void *p_vrfy )
3241{
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003242 return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
3243 profile, cn, flags, f_vrfy, p_vrfy, NULL ) );
3244}
3245
3246/*
3247 * Verify the certificate validity, with profile, restartable version
3248 *
3249 * This function:
3250 * - checks the requested CN (if any)
3251 * - checks the type and size of the EE cert's key,
3252 * as that isn't done as part of chain building/verification currently
3253 * - builds and verifies the chain
3254 * - then calls the callback and merges the flags
3255 */
3256int mbedtls_x509_crt_verify_restartable( mbedtls_x509_crt *crt,
3257 mbedtls_x509_crt *trust_ca,
3258 mbedtls_x509_crl *ca_crl,
3259 const mbedtls_x509_crt_profile *profile,
3260 const char *cn, uint32_t *flags,
3261 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
3262 void *p_vrfy,
3263 mbedtls_x509_crt_restart_ctx *rs_ctx )
3264{
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003265 int ret;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003266 mbedtls_x509_crt_verify_chain ver_chain;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003267 uint32_t ee_flags;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003268
3269 *flags = 0;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003270 ee_flags = 0;
3271 x509_crt_verify_chain_reset( &ver_chain );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003272
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02003273 if( profile == NULL )
3274 {
3275 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
3276 goto exit;
3277 }
3278
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003279 /* check name if requested */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003280 if( cn != NULL )
Hanno Becker87233362019-02-25 18:15:33 +00003281 {
3282 ret = x509_crt_verify_name( crt, cn, &ee_flags );
3283 if( ret != 0 )
3284 return( ret );
3285 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003286
Hanno Becker87233362019-02-25 18:15:33 +00003287 {
3288 mbedtls_pk_context *pk;
3289 mbedtls_pk_type_t pk_type;
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02003290
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003291 ret = mbedtls_x509_crt_pk_acquire( crt, &pk );
Hanno Becker87233362019-02-25 18:15:33 +00003292 if( ret != 0 )
3293 return( MBEDTLS_ERR_X509_FATAL_ERROR );
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02003294
Hanno Becker87233362019-02-25 18:15:33 +00003295 /* Check the type and size of the key */
3296 pk_type = mbedtls_pk_get_type( pk );
3297
3298 if( x509_profile_check_pk_alg( profile, pk_type ) != 0 )
3299 ee_flags |= MBEDTLS_X509_BADCERT_BAD_PK;
3300
3301 if( x509_profile_check_key( profile, pk ) != 0 )
3302 ee_flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
3303
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003304 mbedtls_x509_crt_pk_release( crt, pk );
Hanno Becker87233362019-02-25 18:15:33 +00003305 }
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02003306
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02003307 /* Check the chain */
Manuel Pégourié-Gonnard505c3952017-07-05 17:36:47 +02003308 ret = x509_crt_verify_chain( crt, trust_ca, ca_crl, profile,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003309 &ver_chain, rs_ctx );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003310
Manuel Pégourié-Gonnardc547d1a2017-07-05 13:28:45 +02003311 if( ret != 0 )
3312 goto exit;
3313
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003314 /* Merge end-entity flags */
3315 ver_chain.items[0].flags |= ee_flags;
3316
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003317 /* Build final flags, calling callback on the way if any */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003318 ret = x509_crt_merge_flags_with_cb( flags, &ver_chain, f_vrfy, p_vrfy );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003319
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02003320exit:
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003321#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
3322 if( rs_ctx != NULL && ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
3323 mbedtls_x509_crt_restart_free( rs_ctx );
3324#endif
3325
Manuel Pégourié-Gonnard9107b5f2017-07-06 12:16:25 +02003326 /* prevent misuse of the vrfy callback - VERIFY_FAILED would be ignored by
3327 * the SSL module for authmode optional, but non-zero return from the
3328 * callback means a fatal error so it shouldn't be ignored */
Manuel Pégourié-Gonnard31458a12017-06-26 10:11:49 +02003329 if( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
3330 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
3331
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02003332 if( ret != 0 )
3333 {
3334 *flags = (uint32_t) -1;
3335 return( ret );
3336 }
3337
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003338 if( *flags != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003339 return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003340
3341 return( 0 );
3342}
3343
3344/*
Paul Bakker369d2eb2013-09-18 11:58:25 +02003345 * Initialize a certificate chain
3346 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003347void mbedtls_x509_crt_init( mbedtls_x509_crt *crt )
Paul Bakker369d2eb2013-09-18 11:58:25 +02003348{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003349 memset( crt, 0, sizeof(mbedtls_x509_crt) );
Paul Bakker369d2eb2013-09-18 11:58:25 +02003350}
3351
3352/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003353 * Unallocate all certificate data
3354 */
Hanno Beckercd03bb22019-02-15 17:15:53 +00003355
3356static void x509_free_sequence( mbedtls_x509_sequence *seq )
3357{
3358 while( seq != NULL )
3359 {
3360 mbedtls_x509_sequence *next = seq->next;
3361 mbedtls_platform_zeroize( seq, sizeof( *seq ) );
3362 mbedtls_free( seq );
3363 seq = next;
3364 }
3365}
3366
3367static void x509_free_name( mbedtls_x509_name *name )
3368{
3369 while( name != NULL )
3370 {
3371 mbedtls_x509_name *next = name->next;
3372 mbedtls_platform_zeroize( name, sizeof( *name ) );
3373 mbedtls_free( name );
3374 name = next;
3375 }
3376}
3377
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003378void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003379{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003380 mbedtls_x509_crt *cert_cur = crt;
3381 mbedtls_x509_crt *cert_prv;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003382
3383 if( crt == NULL )
3384 return;
3385
3386 do
3387 {
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003388 x509_crt_cache_free( cert_cur->cache );
3389 mbedtls_free( cert_cur->cache );
Hanno Becker180f7bf2019-02-28 13:23:38 +00003390
3391#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003392 mbedtls_pk_free( &cert_cur->pk );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003393
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003394#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
3395 mbedtls_free( cert_cur->sig_opts );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +02003396#endif
3397
Hanno Beckercd03bb22019-02-15 17:15:53 +00003398 x509_free_name( cert_cur->issuer.next );
3399 x509_free_name( cert_cur->subject.next );
3400 x509_free_sequence( cert_cur->ext_key_usage.next );
3401 x509_free_sequence( cert_cur->subject_alt_names.next );
Hanno Becker180f7bf2019-02-28 13:23:38 +00003402#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003403
Hanno Beckeraa8665a2019-01-31 08:57:44 +00003404 if( cert_cur->raw.p != NULL && cert_cur->own_buffer )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003405 {
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05003406 mbedtls_platform_zeroize( cert_cur->raw.p, cert_cur->raw.len );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003407 mbedtls_free( cert_cur->raw.p );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003408 }
3409
3410 cert_cur = cert_cur->next;
3411 }
3412 while( cert_cur != NULL );
3413
3414 cert_cur = crt;
3415 do
3416 {
3417 cert_prv = cert_cur;
3418 cert_cur = cert_cur->next;
3419
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05003420 mbedtls_platform_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003421 if( cert_prv != crt )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003422 mbedtls_free( cert_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003423 }
3424 while( cert_cur != NULL );
3425}
3426
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003427#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
3428/*
3429 * Initialize a restart context
3430 */
3431void mbedtls_x509_crt_restart_init( mbedtls_x509_crt_restart_ctx *ctx )
3432{
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02003433 mbedtls_pk_restart_init( &ctx->pk );
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003434
3435 ctx->parent = NULL;
3436 ctx->fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02003437 ctx->fallback_signature_is_good = 0;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003438
3439 ctx->parent_is_trusted = -1;
3440
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02003441 ctx->in_progress = x509_crt_rs_none;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003442 ctx->self_cnt = 0;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003443 x509_crt_verify_chain_reset( &ctx->ver_chain );
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003444}
3445
3446/*
3447 * Free the components of a restart context
3448 */
3449void mbedtls_x509_crt_restart_free( mbedtls_x509_crt_restart_ctx *ctx )
3450{
3451 if( ctx == NULL )
3452 return;
3453
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02003454 mbedtls_pk_restart_free( &ctx->pk );
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003455 mbedtls_x509_crt_restart_init( ctx );
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003456}
3457#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
3458
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003459#endif /* MBEDTLS_X509_CRT_PARSE_C */