blob: 1c4237bda6dda15c48af7e55e34a43d4f9e9c7ff [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"
Hanno Beckerf6bc8882019-05-02 13:05:58 +010043#include "mbedtls/x509_internal.h"
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000044#include "mbedtls/oid.h"
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -050045#include "mbedtls/platform_util.h"
Rich Evans00ab4702015-02-06 13:43:58 +000046
Rich Evans00ab4702015-02-06 13:43:58 +000047#include <string.h>
48
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020049#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000050#include "mbedtls/pem.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020051#endif
52
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020053#if defined(MBEDTLS_PLATFORM_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000054#include "mbedtls/platform.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020055#else
Simon Butcherd2642582018-10-03 15:11:19 +010056#include <stdio.h>
Rich Evans00ab4702015-02-06 13:43:58 +000057#include <stdlib.h>
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020058#define mbedtls_free free
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +020059#define mbedtls_calloc calloc
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020060#define mbedtls_snprintf snprintf
Paul Bakker7c6b2c32013-09-16 13:49:26 +020061#endif
62
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020063#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000064#include "mbedtls/threading.h"
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +010065#endif
66
Paul Bakkerfa6a6202013-10-28 18:48:30 +010067#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020068#include <windows.h>
69#else
70#include <time.h>
71#endif
72
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020073#if defined(MBEDTLS_FS_IO)
Rich Evans00ab4702015-02-06 13:43:58 +000074#include <stdio.h>
Paul Bakker5ff3f912014-04-04 15:08:20 +020075#if !defined(_WIN32) || defined(EFIX64) || defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020076#include <sys/types.h>
77#include <sys/stat.h>
78#include <dirent.h>
Rich Evans00ab4702015-02-06 13:43:58 +000079#endif /* !_WIN32 || EFIX64 || EFI32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +020080#endif
81
Hanno Becker38f0cb42019-03-04 15:13:45 +000082#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
83static void x509_buf_to_buf_raw( mbedtls_x509_buf_raw *dst,
84 mbedtls_x509_buf const *src )
85{
86 dst->p = src->p;
87 dst->len = src->len;
88}
89
90static void x509_buf_raw_to_buf( mbedtls_x509_buf *dst,
91 mbedtls_x509_buf_raw const *src )
92{
93 dst->p = src->p;
94 dst->len = src->len;
95}
96#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
97
Hanno Becker21f55672019-02-15 15:27:59 +000098static int x509_crt_parse_frame( unsigned char *start,
99 unsigned char *end,
100 mbedtls_x509_crt_frame *frame );
Hanno Becker12506232019-05-13 13:53:21 +0100101static int x509_crt_subject_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +0000102 mbedtls_x509_name *subject );
Hanno Becker12506232019-05-13 13:53:21 +0100103static int x509_crt_issuer_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +0000104 mbedtls_x509_name *issuer );
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300105#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Becker12506232019-05-13 13:53:21 +0100106static int x509_crt_subject_alt_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +0000107 mbedtls_x509_sequence *subject_alt );
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300108#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Becker12506232019-05-13 13:53:21 +0100109static int x509_crt_ext_key_usage_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +0000110 mbedtls_x509_sequence *ext_key_usage );
111
Hanno Beckerbc685192019-03-05 15:35:31 +0000112int mbedtls_x509_crt_flush_cache_pk( mbedtls_x509_crt const *crt )
113{
114#if defined(MBEDTLS_THREADING_C)
115 if( mbedtls_mutex_lock( &crt->cache->pk_mutex ) != 0 )
116 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
Hanno Beckera4bfaa82019-06-28 10:34:23 +0100117#endif
Hanno Beckerfc99a092019-06-28 14:45:26 +0100118
119#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
120 defined(MBEDTLS_THREADING_C)
121 /* Can only free the PK context if nobody is using it.
122 * If MBEDTLS_X509_ALWAYS_FLUSH is set, nested uses
123 * of xxx_acquire() are prohibited, and no reference
124 * counting is needed. Also, notice that the code-path
125 * below is safe if the cache isn't filled. */
Hanno Becker2ba9fbd2019-05-28 16:11:43 +0100126 if( crt->cache->pk_readers == 0 )
Hanno Beckerfc99a092019-06-28 14:45:26 +0100127#endif /* !MBEDTLS_X509_ALWAYS_FLUSH ||
128 MBEDTLS_THREADING_C */
Hanno Becker2ba9fbd2019-05-28 16:11:43 +0100129 {
Hanno Beckerbc685192019-03-05 15:35:31 +0000130#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Hanno Becker2ba9fbd2019-05-28 16:11:43 +0100131 /* The cache holds a shallow copy of the PK context
132 * in the legacy struct, so don't free PK context. */
133 mbedtls_free( crt->cache->pk );
Hanno Beckerbc685192019-03-05 15:35:31 +0000134#else
Hanno Becker2ba9fbd2019-05-28 16:11:43 +0100135 mbedtls_pk_free( crt->cache->pk );
136 mbedtls_free( crt->cache->pk );
Hanno Beckerbc685192019-03-05 15:35:31 +0000137#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Becker2ba9fbd2019-05-28 16:11:43 +0100138 crt->cache->pk = NULL;
139 }
Hanno Beckerbc685192019-03-05 15:35:31 +0000140
141#if defined(MBEDTLS_THREADING_C)
142 if( mbedtls_mutex_unlock( &crt->cache->pk_mutex ) != 0 )
143 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
144#endif
145 return( 0 );
146}
147
148int mbedtls_x509_crt_flush_cache_frame( mbedtls_x509_crt const *crt )
149{
150#if defined(MBEDTLS_THREADING_C)
151 if( mbedtls_mutex_lock( &crt->cache->frame_mutex ) != 0 )
152 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
Hanno Beckera4bfaa82019-06-28 10:34:23 +0100153#endif
Hanno Beckerbc685192019-03-05 15:35:31 +0000154
Hanno Beckerfc99a092019-06-28 14:45:26 +0100155#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
156 defined(MBEDTLS_THREADING_C)
157 /* Can only free the PK context if nobody is using it.
158 * If MBEDTLS_X509_ALWAYS_FLUSH is set, nested uses
159 * of xxx_acquire() are prohibited, and no reference
160 * counting is needed. Also, notice that the code-path
161 * below is safe if the cache isn't filled. */
Hanno Becker2ba9fbd2019-05-28 16:11:43 +0100162 if( crt->cache->frame_readers == 0 )
Hanno Beckerfc99a092019-06-28 14:45:26 +0100163#endif /* !MBEDTLS_X509_ALWAYS_FLUSH ||
164 MBEDTLS_THREADING_C */
Hanno Becker2ba9fbd2019-05-28 16:11:43 +0100165 {
166 mbedtls_free( crt->cache->frame );
167 crt->cache->frame = NULL;
168 }
Hanno Beckerbc685192019-03-05 15:35:31 +0000169
170#if defined(MBEDTLS_THREADING_C)
171 if( mbedtls_mutex_unlock( &crt->cache->frame_mutex ) != 0 )
172 return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
173#endif
174 return( 0 );
175}
176
177int mbedtls_x509_crt_flush_cache( mbedtls_x509_crt const *crt )
178{
179 int ret;
180 ret = mbedtls_x509_crt_flush_cache_frame( crt );
181 if( ret != 0 )
182 return( ret );
183 ret = mbedtls_x509_crt_flush_cache_pk( crt );
184 if( ret != 0 )
185 return( ret );
186 return( 0 );
187}
188
Hanno Beckerea32d8b2019-03-04 11:52:23 +0000189static int x509_crt_frame_parse_ext( mbedtls_x509_crt_frame *frame );
Hanno Beckered058882019-06-28 10:46:43 +0100190
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000191int mbedtls_x509_crt_cache_provide_frame( mbedtls_x509_crt const *crt )
Hanno Becker337088a2019-02-25 14:53:14 +0000192{
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000193 mbedtls_x509_crt_cache *cache = crt->cache;
Hanno Becker337088a2019-02-25 14:53:14 +0000194 mbedtls_x509_crt_frame *frame;
195
Hanno Becker76428352019-03-05 15:29:23 +0000196 if( cache->frame != NULL )
Hanno Beckerfc99a092019-06-28 14:45:26 +0100197 {
Hanno Becker410322f2019-07-02 13:37:12 +0100198#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
199 defined(MBEDTLS_THREADING_C)
Hanno Becker76428352019-03-05 15:29:23 +0000200 return( 0 );
Hanno Beckerfc99a092019-06-28 14:45:26 +0100201#else
202 /* If MBEDTLS_X509_ALWAYS_FLUSH is set, we don't
203 * allow nested uses of acquire. */
204 return( MBEDTLS_ERR_X509_FATAL_ERROR );
205#endif
206 }
Hanno Becker76428352019-03-05 15:29:23 +0000207
Hanno Becker337088a2019-02-25 14:53:14 +0000208 frame = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_frame ) );
209 if( frame == NULL )
210 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000211 cache->frame = frame;
Hanno Becker337088a2019-02-25 14:53:14 +0000212
Hanno Beckerea32d8b2019-03-04 11:52:23 +0000213#if defined(MBEDTLS_X509_ON_DEMAND_PARSING)
214 /* This would work with !MBEDTLS_X509_ON_DEMAND_PARSING, too,
215 * but is inefficient compared to copying the respective fields
216 * from the legacy mbedtls_x509_crt. */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000217 return( x509_crt_parse_frame( crt->raw.p,
218 crt->raw.p + crt->raw.len,
219 frame ) );
Hanno Beckerea32d8b2019-03-04 11:52:23 +0000220#else /* MBEDTLS_X509_ON_DEMAND_PARSING */
221 /* Make sure all extension related fields are properly initialized. */
222 frame->ca_istrue = 0;
223 frame->max_pathlen = 0;
224 frame->ext_types = 0;
225 frame->version = crt->version;
226 frame->sig_md = crt->sig_md;
227 frame->sig_pk = crt->sig_pk;
Hanno Becker843b71a2019-06-25 09:39:21 +0100228
229#if !defined(MBEDTLS_X509_CRT_REMOVE_TIME)
Hanno Beckerea32d8b2019-03-04 11:52:23 +0000230 frame->valid_from = crt->valid_from;
231 frame->valid_to = crt->valid_to;
Hanno Becker843b71a2019-06-25 09:39:21 +0100232#endif /* !MBEDTLS_X509_CRT_REMOVE_TIME */
233
Hanno Becker38f0cb42019-03-04 15:13:45 +0000234 x509_buf_to_buf_raw( &frame->raw, &crt->raw );
235 x509_buf_to_buf_raw( &frame->tbs, &crt->tbs );
236 x509_buf_to_buf_raw( &frame->serial, &crt->serial );
237 x509_buf_to_buf_raw( &frame->pubkey_raw, &crt->pk_raw );
238 x509_buf_to_buf_raw( &frame->issuer_raw, &crt->issuer_raw );
239 x509_buf_to_buf_raw( &frame->subject_raw, &crt->subject_raw );
Hanno Beckerd07614c2019-06-25 10:19:58 +0100240#if !defined(MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID)
Hanno Becker38f0cb42019-03-04 15:13:45 +0000241 x509_buf_to_buf_raw( &frame->subject_id, &crt->subject_id );
242 x509_buf_to_buf_raw( &frame->issuer_id, &crt->issuer_id );
Hanno Beckerd07614c2019-06-25 10:19:58 +0100243#endif /* !MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID */
Hanno Becker38f0cb42019-03-04 15:13:45 +0000244 x509_buf_to_buf_raw( &frame->sig, &crt->sig );
245 x509_buf_to_buf_raw( &frame->v3_ext, &crt->v3_ext );
Hanno Beckerea32d8b2019-03-04 11:52:23 +0000246
247 /* The legacy CRT structure doesn't explicitly contain
248 * the `AlgorithmIdentifier` bounds; however, those can
249 * be inferred from the surrounding (mandatory) `SerialNumber`
250 * and `Issuer` fields. */
251 frame->sig_alg.p = crt->serial.p + crt->serial.len;
252 frame->sig_alg.len = crt->issuer_raw.p - frame->sig_alg.p;
253
254 return( x509_crt_frame_parse_ext( frame ) );
255#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000256}
Hanno Becker337088a2019-02-25 14:53:14 +0000257
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000258int mbedtls_x509_crt_cache_provide_pk( mbedtls_x509_crt const *crt )
259{
260 mbedtls_x509_crt_cache *cache = crt->cache;
261 mbedtls_pk_context *pk;
262
Hanno Becker76428352019-03-05 15:29:23 +0000263 if( cache->pk != NULL )
Hanno Beckerfc99a092019-06-28 14:45:26 +0100264 {
Hanno Becker410322f2019-07-02 13:37:12 +0100265#if !defined(MBEDTLS_X509_ALWAYS_FLUSH) || \
266 defined(MBEDTLS_THREADING_C)
Hanno Becker76428352019-03-05 15:29:23 +0000267 return( 0 );
Hanno Beckerfc99a092019-06-28 14:45:26 +0100268#else
269 /* If MBEDTLS_X509_ALWAYS_FLUSH is set, we don't
270 * allow nested uses of acquire. */
271 return( MBEDTLS_ERR_X509_FATAL_ERROR );
272#endif
273 }
Hanno Becker76428352019-03-05 15:29:23 +0000274
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000275 pk = mbedtls_calloc( 1, sizeof( mbedtls_pk_context ) );
276 if( pk == NULL )
277 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000278 cache->pk = pk;
Hanno Becker180f7bf2019-02-28 13:23:38 +0000279
280#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
281 *pk = crt->pk;
Hanno Becker337088a2019-02-25 14:53:14 +0000282 return( 0 );
Hanno Becker180f7bf2019-02-28 13:23:38 +0000283#else
284 {
285 mbedtls_x509_buf_raw pk_raw = cache->pk_raw;
286 return( mbedtls_pk_parse_subpubkey( &pk_raw.p,
287 pk_raw.p + pk_raw.len,
288 pk ) );
289 }
290#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Becker337088a2019-02-25 14:53:14 +0000291}
292
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000293static void x509_crt_cache_init( mbedtls_x509_crt_cache *cache )
Hanno Becker337088a2019-02-25 14:53:14 +0000294{
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000295 memset( cache, 0, sizeof( *cache ) );
296#if defined(MBEDTLS_THREADING_C)
297 mbedtls_mutex_init( &cache->frame_mutex );
298 mbedtls_mutex_init( &cache->pk_mutex );
299#endif
300}
301
302static void x509_crt_cache_clear_pk( mbedtls_x509_crt_cache *cache )
303{
Hanno Becker180f7bf2019-02-28 13:23:38 +0000304#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000305 /* The cache holds a shallow copy of the PK context
306 * in the legacy struct, so don't free PK context. */
307 mbedtls_free( cache->pk );
Hanno Becker180f7bf2019-02-28 13:23:38 +0000308#else
309 mbedtls_pk_free( cache->pk );
310 mbedtls_free( cache->pk );
311#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
312
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000313 cache->pk = NULL;
314}
315
316static void x509_crt_cache_clear_frame( mbedtls_x509_crt_cache *cache )
317{
318 mbedtls_free( cache->frame );
319 cache->frame = NULL;
320}
321
322static void x509_crt_cache_free( mbedtls_x509_crt_cache *cache )
323{
324 if( cache == NULL )
Hanno Becker337088a2019-02-25 14:53:14 +0000325 return;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +0000326
327#if defined(MBEDTLS_THREADING_C)
328 mbedtls_mutex_free( &cache->frame_mutex );
329 mbedtls_mutex_free( &cache->pk_mutex );
330#endif
331
332 x509_crt_cache_clear_frame( cache );
333 x509_crt_cache_clear_pk( cache );
334
335 memset( cache, 0, sizeof( *cache ) );
Hanno Becker337088a2019-02-25 14:53:14 +0000336}
337
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300338#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Beckerab6c8ea2019-02-27 17:33:14 +0000339int mbedtls_x509_crt_get_subject_alt_names( mbedtls_x509_crt const *crt,
340 mbedtls_x509_sequence **subj_alt )
341{
342 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +0100343 mbedtls_x509_crt_frame const *frame;
Hanno Beckerab6c8ea2019-02-27 17:33:14 +0000344 mbedtls_x509_sequence *seq;
345
346 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
347 if( ret != 0 )
348 return( ret );
349
350 seq = mbedtls_calloc( 1, sizeof( mbedtls_x509_sequence ) );
351 if( seq == NULL )
352 ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
353 else
354 ret = x509_crt_subject_alt_from_frame( frame, seq );
355
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +0000356 mbedtls_x509_crt_frame_release( crt );
Hanno Beckerab6c8ea2019-02-27 17:33:14 +0000357
358 *subj_alt = seq;
359 return( ret );
360}
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300361#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Beckerab6c8ea2019-02-27 17:33:14 +0000362
363int mbedtls_x509_crt_get_ext_key_usage( mbedtls_x509_crt const *crt,
364 mbedtls_x509_sequence **ext_key_usage )
365{
366 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +0100367 mbedtls_x509_crt_frame const *frame;
Hanno Beckerab6c8ea2019-02-27 17:33:14 +0000368 mbedtls_x509_sequence *seq;
369
370 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
371 if( ret != 0 )
372 return( ret );
373
374 seq = mbedtls_calloc( 1, sizeof( mbedtls_x509_sequence ) );
375 if( seq == NULL )
376 ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
377 else
378 ret = x509_crt_ext_key_usage_from_frame( frame, seq );
379
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +0000380 mbedtls_x509_crt_frame_release( crt );
Hanno Beckerab6c8ea2019-02-27 17:33:14 +0000381
382 *ext_key_usage = seq;
383 return( ret );
384}
385
Hanno Becker63e69982019-02-26 18:50:49 +0000386int mbedtls_x509_crt_get_subject( mbedtls_x509_crt const *crt,
387 mbedtls_x509_name **subject )
388{
389 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +0100390 mbedtls_x509_crt_frame const *frame;
Hanno Becker63e69982019-02-26 18:50:49 +0000391 mbedtls_x509_name *name;
392
393 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
394 if( ret != 0 )
395 return( ret );
396
397 name = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
398 if( name == NULL )
399 ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
400 else
401 ret = x509_crt_subject_from_frame( frame, name );
402
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +0000403 mbedtls_x509_crt_frame_release( crt );
Hanno Becker63e69982019-02-26 18:50:49 +0000404
405 *subject = name;
406 return( ret );
407}
408
409int mbedtls_x509_crt_get_issuer( mbedtls_x509_crt const *crt,
410 mbedtls_x509_name **issuer )
411{
412 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +0100413 mbedtls_x509_crt_frame const *frame;
Hanno Becker63e69982019-02-26 18:50:49 +0000414 mbedtls_x509_name *name;
415
416 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
417 if( ret != 0 )
418 return( ret );
419
420 name = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
421 if( name == NULL )
422 ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
423 else
424 ret = x509_crt_issuer_from_frame( frame, name );
425
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +0000426 mbedtls_x509_crt_frame_release( crt );
Hanno Becker63e69982019-02-26 18:50:49 +0000427
428 *issuer = name;
429 return( ret );
430}
431
Hanno Becker823efad2019-02-28 13:23:58 +0000432int mbedtls_x509_crt_get_frame( mbedtls_x509_crt const *crt,
433 mbedtls_x509_crt_frame *dst )
434{
435 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +0100436 mbedtls_x509_crt_frame const *frame;
Hanno Becker823efad2019-02-28 13:23:58 +0000437 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
438 if( ret != 0 )
439 return( ret );
440 *dst = *frame;
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +0000441 mbedtls_x509_crt_frame_release( crt );
Hanno Becker823efad2019-02-28 13:23:58 +0000442 return( 0 );
443}
444
445int mbedtls_x509_crt_get_pk( mbedtls_x509_crt const *crt,
446 mbedtls_pk_context *dst )
447{
448#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
449 mbedtls_x509_buf_raw pk_raw = crt->cache->pk_raw;
450 return( mbedtls_pk_parse_subpubkey( &pk_raw.p,
451 pk_raw.p + pk_raw.len,
452 dst ) );
453#else /* !MBEDTLS_X509_ON_DEMAND_PARSING */
454 int ret;
455 mbedtls_pk_context *pk;
456 ret = mbedtls_x509_crt_pk_acquire( crt, &pk );
457 if( ret != 0 )
458 return( ret );
459
460 /* Move PK from CRT cache to destination pointer
461 * to avoid a copy. */
462 *dst = *pk;
463 mbedtls_free( crt->cache->pk );
464 crt->cache->pk = NULL;
465
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +0000466 mbedtls_x509_crt_pk_release( crt );
Hanno Becker823efad2019-02-28 13:23:58 +0000467 return( 0 );
468#endif /* MBEDTLS_X509_ON_DEMAND_PARSING */
469}
470
Manuel Pégourié-Gonnardc547d1a2017-07-05 13:28:45 +0200471/*
472 * Item in a verification chain: cert and flags for it
473 */
474typedef struct {
475 mbedtls_x509_crt *crt;
476 uint32_t flags;
477} x509_crt_verify_chain_item;
478
479/*
480 * Max size of verification chain: end-entity + intermediates + trusted root
481 */
482#define X509_MAX_VERIFY_CHAIN_SIZE ( MBEDTLS_X509_MAX_INTERMEDIATE_CA + 2 )
Paul Bakker34617722014-06-13 17:20:13 +0200483
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200484/*
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200485 * Default profile
486 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200487const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_default =
488{
Gilles Peskine5d2511c2017-05-12 13:16:40 +0200489#if defined(MBEDTLS_TLS_DEFAULT_ALLOW_SHA1_IN_CERTIFICATES)
Gilles Peskine5e79cb32017-05-04 16:17:21 +0200490 /* Allow SHA-1 (weak, but still safe in controlled environments) */
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200491 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA1 ) |
Gilles Peskine5e79cb32017-05-04 16:17:21 +0200492#endif
493 /* Only SHA-2 hashes */
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200494 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA224 ) |
495 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
496 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
497 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
498 0xFFFFFFF, /* Any PK alg */
499 0xFFFFFFF, /* Any curve */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200500 2048,
501};
502
503/*
504 * Next-default profile
505 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200506const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_next =
507{
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200508 /* Hashes from SHA-256 and above */
509 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
510 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ) |
511 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA512 ),
512 0xFFFFFFF, /* Any PK alg */
513#if defined(MBEDTLS_ECP_C)
514 /* Curves at or above 128-bit security level */
515 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
516 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ) |
517 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP521R1 ) |
518 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP256R1 ) |
519 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP384R1 ) |
520 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_BP512R1 ) |
521 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256K1 ),
522#else
523 0,
524#endif
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200525 2048,
526};
527
528/*
529 * NSA Suite B Profile
530 */
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200531const mbedtls_x509_crt_profile mbedtls_x509_crt_profile_suiteb =
532{
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200533 /* Only SHA-256 and 384 */
534 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA256 ) |
535 MBEDTLS_X509_ID_FLAG( MBEDTLS_MD_SHA384 ),
536 /* Only ECDSA */
Ron Eldor85e1dcf2018-02-06 15:59:38 +0200537 MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECDSA ) |
538 MBEDTLS_X509_ID_FLAG( MBEDTLS_PK_ECKEY ),
Manuel Pégourié-Gonnardf8ea8562015-06-15 15:33:19 +0200539#if defined(MBEDTLS_ECP_C)
540 /* Only NIST P-256 and P-384 */
541 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP256R1 ) |
542 MBEDTLS_X509_ID_FLAG( MBEDTLS_ECP_DP_SECP384R1 ),
543#else
544 0,
545#endif
546 0,
Manuel Pégourié-Gonnard88db5da2015-06-15 14:34:59 +0200547};
548
549/*
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200550 * Check md_alg against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200551 * Return 0 if md_alg is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200552 */
553static int x509_profile_check_md_alg( const mbedtls_x509_crt_profile *profile,
554 mbedtls_md_type_t md_alg )
555{
Philippe Antoineb5b25432018-05-11 11:06:29 +0200556 if( md_alg == MBEDTLS_MD_NONE )
557 return( -1 );
558
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200559 if( ( profile->allowed_mds & MBEDTLS_X509_ID_FLAG( md_alg ) ) != 0 )
560 return( 0 );
561
562 return( -1 );
563}
564
565/*
566 * Check pk_alg against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200567 * Return 0 if pk_alg is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200568 */
569static int x509_profile_check_pk_alg( const mbedtls_x509_crt_profile *profile,
570 mbedtls_pk_type_t pk_alg )
571{
Philippe Antoineb5b25432018-05-11 11:06:29 +0200572 if( pk_alg == MBEDTLS_PK_NONE )
573 return( -1 );
574
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200575 if( ( profile->allowed_pks & MBEDTLS_X509_ID_FLAG( pk_alg ) ) != 0 )
576 return( 0 );
577
578 return( -1 );
579}
580
581/*
582 * Check key against profile
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200583 * Return 0 if pk is acceptable for this profile, -1 otherwise
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200584 */
585static int x509_profile_check_key( const mbedtls_x509_crt_profile *profile,
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200586 const mbedtls_pk_context *pk )
587{
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200588 const mbedtls_pk_type_t pk_alg = mbedtls_pk_get_type( pk );
Manuel Pégourié-Gonnard19773ff2017-10-24 10:51:26 +0200589
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200590#if defined(MBEDTLS_RSA_C)
591 if( pk_alg == MBEDTLS_PK_RSA || pk_alg == MBEDTLS_PK_RSASSA_PSS )
592 {
Manuel Pégourié-Gonnard097c7bb2015-06-18 16:43:38 +0200593 if( mbedtls_pk_get_bitlen( pk ) >= profile->rsa_min_bitlen )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200594 return( 0 );
595
596 return( -1 );
597 }
598#endif
599
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +0200600#if defined(MBEDTLS_ECP_C)
601 if( pk_alg == MBEDTLS_PK_ECDSA ||
602 pk_alg == MBEDTLS_PK_ECKEY ||
603 pk_alg == MBEDTLS_PK_ECKEY_DH )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200604 {
Manuel Pégourié-Gonnard3f816912017-10-26 10:24:16 +0200605 const mbedtls_ecp_group_id gid = mbedtls_pk_ec( *pk )->grp.id;
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200606
Philippe Antoineb5b25432018-05-11 11:06:29 +0200607 if( gid == MBEDTLS_ECP_DP_NONE )
608 return( -1 );
609
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200610 if( ( profile->allowed_curves & MBEDTLS_X509_ID_FLAG( gid ) ) != 0 )
611 return( 0 );
612
613 return( -1 );
614 }
615#endif
616
617 return( -1 );
618}
619
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300620#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +0200621/*
Hanno Becker1f8527f2018-11-02 09:19:16 +0000622 * Return 0 if name matches wildcard, -1 otherwise
623 */
Hanno Becker24926222019-02-21 13:10:55 +0000624static int x509_check_wildcard( char const *cn,
625 size_t cn_len,
626 unsigned char const *buf,
627 size_t buf_len )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000628{
629 size_t i;
Hanno Becker24926222019-02-21 13:10:55 +0000630 size_t cn_idx = 0;
Hanno Becker1f8527f2018-11-02 09:19:16 +0000631
632 /* We can't have a match if there is no wildcard to match */
Hanno Becker24926222019-02-21 13:10:55 +0000633 if( buf_len < 3 || buf[0] != '*' || buf[1] != '.' )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000634 return( -1 );
635
636 for( i = 0; i < cn_len; ++i )
637 {
638 if( cn[i] == '.' )
639 {
640 cn_idx = i;
641 break;
642 }
643 }
644
645 if( cn_idx == 0 )
646 return( -1 );
647
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000648 if( mbedtls_x509_memcasecmp( buf + 1, cn + cn_idx,
649 buf_len - 1, cn_len - cn_idx ) == 0 )
Hanno Becker1f8527f2018-11-02 09:19:16 +0000650 {
651 return( 0 );
652 }
653
654 return( -1 );
655}
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300656#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Becker1f8527f2018-11-02 09:19:16 +0000657
658/*
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +0200659 * Reset (init or clear) a verify_chain
660 */
661static void x509_crt_verify_chain_reset(
662 mbedtls_x509_crt_verify_chain *ver_chain )
663{
664 size_t i;
665
666 for( i = 0; i < MBEDTLS_X509_MAX_VERIFY_CHAIN_SIZE; i++ )
667 {
668 ver_chain->items[i].crt = NULL;
Hanno Beckerd6ddcd62019-01-10 09:19:26 +0000669 ver_chain->items[i].flags = (uint32_t) -1;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +0200670 }
671
672 ver_chain->len = 0;
673}
674
675/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200676 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
677 */
678static int x509_get_version( unsigned char **p,
679 const unsigned char *end,
680 int *ver )
681{
682 int ret;
683 size_t len;
684
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200685 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
686 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200687 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200688 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200689 {
690 *ver = 0;
691 return( 0 );
692 }
693
Hanno Becker2f472142019-02-12 11:52:10 +0000694 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200695 }
696
697 end = *p + len;
698
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200699 if( ( ret = mbedtls_asn1_get_int( p, end, ver ) ) != 0 )
700 return( MBEDTLS_ERR_X509_INVALID_VERSION + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200701
702 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200703 return( MBEDTLS_ERR_X509_INVALID_VERSION +
704 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200705
706 return( 0 );
707}
708
Hanno Becker843b71a2019-06-25 09:39:21 +0100709#if !defined(MBEDTLS_X509_CRT_REMOVE_TIME)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200710/*
711 * Validity ::= SEQUENCE {
712 * notBefore Time,
713 * notAfter Time }
714 */
715static int x509_get_dates( unsigned char **p,
716 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200717 mbedtls_x509_time *from,
718 mbedtls_x509_time *to )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200719{
720 int ret;
721 size_t len;
722
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200723 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
724 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
725 return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200726
727 end = *p + len;
728
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200729 if( ( ret = mbedtls_x509_get_time( p, end, from ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200730 return( ret );
731
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200732 if( ( ret = mbedtls_x509_get_time( p, end, to ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200733 return( ret );
734
735 if( *p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200736 return( MBEDTLS_ERR_X509_INVALID_DATE +
737 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200738
739 return( 0 );
740}
Hanno Becker843b71a2019-06-25 09:39:21 +0100741#else /* !MBEDTLS_X509_CRT_REMOVE_TIME */
742static int x509_skip_dates( unsigned char **p,
743 const unsigned char *end )
744{
745 int ret;
746 size_t len;
747
748 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
749 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
750 return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
751
Manuel Pégourié-Gonnard0d1db202019-07-30 14:11:25 +0200752 /* skip contents of the sequence */
753 *p += len;
Hanno Becker843b71a2019-06-25 09:39:21 +0100754
755 return( 0 );
756}
757#endif /* MBEDTLS_X509_CRT_REMOVE_TIME */
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200758
Hanno Beckerd07614c2019-06-25 10:19:58 +0100759#if !defined(MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200760/*
761 * X.509 v2/v3 unique identifier (not parsed)
762 */
763static int x509_get_uid( unsigned char **p,
764 const unsigned char *end,
Hanno Beckere9084122019-06-07 12:04:39 +0100765 mbedtls_x509_buf_raw *uid, int n )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200766{
767 int ret;
768
769 if( *p == end )
770 return( 0 );
771
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200772 if( ( ret = mbedtls_asn1_get_tag( p, end, &uid->len,
773 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200774 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200775 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200776 return( 0 );
777
Hanno Becker2f472142019-02-12 11:52:10 +0000778 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200779 }
780
781 uid->p = *p;
782 *p += uid->len;
783
784 return( 0 );
785}
Hanno Beckerd07614c2019-06-25 10:19:58 +0100786#else /* !MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID */
787static int x509_skip_uid( unsigned char **p,
788 const unsigned char *end,
789 int n )
790{
791 int ret;
792 size_t len;
793
794 if( *p == end )
795 return( 0 );
796
797 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
798 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | n ) ) != 0 )
799 {
800 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
801 return( 0 );
802
803 return( MBEDTLS_ERR_X509_INVALID_FORMAT + ret );
804 }
805
806 *p += len;
807 return( 0 );
808}
809#endif /* MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID */
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200810
811static int x509_get_basic_constraints( unsigned char **p,
812 const unsigned char *end,
813 int *ca_istrue,
814 int *max_pathlen )
815{
816 int ret;
817 size_t len;
818
819 /*
820 * BasicConstraints ::= SEQUENCE {
821 * cA BOOLEAN DEFAULT FALSE,
822 * pathLenConstraint INTEGER (0..MAX) OPTIONAL }
823 */
824 *ca_istrue = 0; /* DEFAULT FALSE */
825 *max_pathlen = 0; /* endless */
826
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200827 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
828 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000829 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200830
831 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200832 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200833
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200834 if( ( ret = mbedtls_asn1_get_bool( p, end, ca_istrue ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200835 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200836 if( ret == MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
837 ret = mbedtls_asn1_get_int( p, end, ca_istrue );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200838
839 if( ret != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000840 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200841
842 if( *ca_istrue != 0 )
843 *ca_istrue = 1;
844 }
845
846 if( *p == end )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200847 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200848
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200849 if( ( ret = mbedtls_asn1_get_int( p, end, max_pathlen ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000850 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200851
852 if( *p != end )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000853 return( MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200854
855 (*max_pathlen)++;
856
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200857 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200858}
859
860static int x509_get_ns_cert_type( unsigned char **p,
861 const unsigned char *end,
862 unsigned char *ns_cert_type)
863{
864 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200865 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200866
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200867 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000868 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200869
870 if( bs.len != 1 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000871 return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200872
873 /* Get actual bitstring */
874 *ns_cert_type = *bs.p;
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200875 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200876}
877
878static int x509_get_key_usage( unsigned char **p,
879 const unsigned char *end,
Hanno Beckerfd5c1852019-05-13 12:52:57 +0100880 uint16_t *key_usage)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200881{
882 int ret;
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200883 size_t i;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200884 mbedtls_x509_bitstring bs = { 0, 0, NULL };
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200885
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200886 if( ( ret = mbedtls_asn1_get_bitstring( p, end, &bs ) ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000887 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200888
889 if( bs.len < 1 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000890 return( MBEDTLS_ERR_ASN1_INVALID_LENGTH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200891
892 /* Get actual bitstring */
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200893 *key_usage = 0;
Hanno Beckerfd5c1852019-05-13 12:52:57 +0100894 for( i = 0; i < bs.len && i < sizeof( *key_usage ); i++ )
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200895 {
Hanno Beckerfd5c1852019-05-13 12:52:57 +0100896 *key_usage |= (uint16_t) bs.p[i] << ( 8*i );
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +0200897 }
898
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200899 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200900}
901
Hanno Becker529f25d2019-05-02 14:48:25 +0100902static int asn1_build_sequence_cb( void *ctx,
903 int tag,
904 unsigned char *data,
905 size_t data_len )
Hanno Becker15b73b42019-05-02 13:21:27 +0100906{
907 mbedtls_asn1_sequence **cur_ptr = (mbedtls_asn1_sequence **) ctx;
908 mbedtls_asn1_sequence *cur = *cur_ptr;
909
910 /* Allocate and assign next pointer */
911 if( cur->buf.p != NULL )
912 {
913 cur->next = mbedtls_calloc( 1, sizeof( mbedtls_asn1_sequence ) );
914 if( cur->next == NULL )
915 return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
916 cur = cur->next;
917 }
918
919 cur->buf.tag = tag;
920 cur->buf.p = data;
921 cur->buf.len = data_len;
922
923 *cur_ptr = cur;
924 return( 0 );
925}
926
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200927/*
Hanno Becker529f25d2019-05-02 14:48:25 +0100928 * ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId
929 *
930 * KeyPurposeId ::= OBJECT IDENTIFIER
931 */
932static int x509_get_ext_key_usage( unsigned char **p,
933 const unsigned char *end,
934 mbedtls_x509_sequence *ext_key_usage)
935{
936 return( mbedtls_asn1_traverse_sequence_of( p, end,
937 0xFF, MBEDTLS_ASN1_OID,
938 0, 0,
939 asn1_build_sequence_cb,
Hanno Becker484caf02019-05-29 14:41:44 +0100940 (void *) &ext_key_usage ) );
Hanno Becker529f25d2019-05-02 14:48:25 +0100941}
942
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300943#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Becker529f25d2019-05-02 14:48:25 +0100944/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200945 * SubjectAltName ::= GeneralNames
946 *
947 * GeneralNames ::= SEQUENCE SIZE (1..MAX) OF GeneralName
948 *
949 * GeneralName ::= CHOICE {
950 * otherName [0] OtherName,
951 * rfc822Name [1] IA5String,
952 * dNSName [2] IA5String,
953 * x400Address [3] ORAddress,
954 * directoryName [4] Name,
955 * ediPartyName [5] EDIPartyName,
956 * uniformResourceIdentifier [6] IA5String,
957 * iPAddress [7] OCTET STRING,
958 * registeredID [8] OBJECT IDENTIFIER }
959 *
960 * OtherName ::= SEQUENCE {
961 * type-id OBJECT IDENTIFIER,
962 * value [0] EXPLICIT ANY DEFINED BY type-id }
963 *
964 * EDIPartyName ::= SEQUENCE {
965 * nameAssigner [0] DirectoryString OPTIONAL,
966 * partyName [1] DirectoryString }
967 *
Manuel Pégourié-Gonnardb4fe3cb2015-01-22 16:11:05 +0000968 * NOTE: we only parse and use dNSName at this point.
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200969 */
Hanno Becker5984d302019-02-21 14:46:54 +0000970static int x509_get_subject_alt_name( unsigned char *p,
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200971 const unsigned char *end,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200972 mbedtls_x509_sequence *subject_alt_name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200973{
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000974 return( mbedtls_asn1_traverse_sequence_of( &p, end,
975 MBEDTLS_ASN1_TAG_CLASS_MASK,
976 MBEDTLS_ASN1_CONTEXT_SPECIFIC,
977 MBEDTLS_ASN1_TAG_VALUE_MASK,
978 2 /* SubjectAlt DNS */,
Hanno Becker529f25d2019-05-02 14:48:25 +0100979 asn1_build_sequence_cb,
Hanno Becker484caf02019-05-29 14:41:44 +0100980 (void *) &subject_alt_name ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200981}
Teppo Järvelin4009d8f2019-08-19 14:48:09 +0300982#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200983
984/*
985 * X.509 v3 extensions
986 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200987 */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000988static int x509_crt_get_ext_cb( void *ctx,
989 int tag,
990 unsigned char *p,
991 size_t ext_len )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200992{
993 int ret;
Hanno Becker21f55672019-02-15 15:27:59 +0000994 mbedtls_x509_crt_frame *frame = (mbedtls_x509_crt_frame *) ctx;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200995 size_t len;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +0000996 unsigned char *end, *end_ext_octet;
997 mbedtls_x509_buf extn_oid = { 0, 0, NULL };
998 int is_critical = 0; /* DEFAULT FALSE */
999 int ext_type = 0;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001000
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001001 ((void) tag);
Hanno Becker4e1bfc12019-02-12 17:22:36 +00001002
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001003 /*
1004 * Extension ::= SEQUENCE {
1005 * extnID OBJECT IDENTIFIER,
1006 * critical BOOLEAN DEFAULT FALSE,
1007 * extnValue OCTET STRING }
1008 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001009
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001010 end = p + ext_len;
1011
1012 /* Get extension ID */
1013 if( ( ret = mbedtls_asn1_get_tag( &p, end, &extn_oid.len,
1014 MBEDTLS_ASN1_OID ) ) != 0 )
1015 goto err;
1016
1017 extn_oid.tag = MBEDTLS_ASN1_OID;
1018 extn_oid.p = p;
1019 p += extn_oid.len;
1020
1021 /* Get optional critical */
1022 if( ( ret = mbedtls_asn1_get_bool( &p, end, &is_critical ) ) != 0 &&
1023 ( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG ) )
1024 goto err;
1025
1026 /* Data should be octet string type */
1027 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
1028 MBEDTLS_ASN1_OCTET_STRING ) ) != 0 )
1029 goto err;
1030
1031 end_ext_octet = p + len;
1032 if( end_ext_octet != end )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001033 {
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001034 ret = MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
1035 goto err;
1036 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001037
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001038 /*
1039 * Detect supported extensions
1040 */
1041 ret = mbedtls_oid_get_x509_ext_type( &extn_oid, &ext_type );
1042 if( ret != 0 )
1043 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001044#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001045 if( is_critical )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001046 {
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001047 /* Data is marked as critical: fail */
1048 ret = MBEDTLS_ERR_ASN1_UNEXPECTED_TAG;
1049 goto err;
1050 }
Hanno Beckerb36a2452019-05-29 14:43:17 +01001051#endif /* MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001052 return( 0 );
1053 }
1054
1055 /* Forbid repeated extensions */
Hanno Becker21f55672019-02-15 15:27:59 +00001056 if( ( frame->ext_types & ext_type ) != 0 )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001057 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS );
1058
Hanno Becker21f55672019-02-15 15:27:59 +00001059 frame->ext_types |= ext_type;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001060 switch( ext_type )
1061 {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01001062 case MBEDTLS_X509_EXT_BASIC_CONSTRAINTS:
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001063 {
1064 int ca_istrue;
1065 int max_pathlen;
1066
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001067 /* Parse basic constraints */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001068 ret = x509_get_basic_constraints( &p, end_ext_octet,
1069 &ca_istrue,
1070 &max_pathlen );
1071 if( ret != 0 )
1072 goto err;
1073
Hanno Becker21f55672019-02-15 15:27:59 +00001074 frame->ca_istrue = ca_istrue;
1075 frame->max_pathlen = max_pathlen;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001076 break;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001077 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001078
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001079 case MBEDTLS_X509_EXT_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001080 /* Parse key usage */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001081 ret = x509_get_key_usage( &p, end_ext_octet,
Hanno Becker21f55672019-02-15 15:27:59 +00001082 &frame->key_usage );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001083 if( ret != 0 )
1084 goto err;
1085 break;
1086
1087 case MBEDTLS_X509_EXT_SUBJECT_ALT_NAME:
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03001088#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001089 /* Copy reference to raw subject alt name data. */
Hanno Becker21f55672019-02-15 15:27:59 +00001090 frame->subject_alt_raw.p = p;
1091 frame->subject_alt_raw.len = end_ext_octet - p;
Hanno Becker21f55672019-02-15 15:27:59 +00001092 ret = mbedtls_asn1_traverse_sequence_of( &p, end_ext_octet,
1093 MBEDTLS_ASN1_TAG_CLASS_MASK,
1094 MBEDTLS_ASN1_CONTEXT_SPECIFIC,
1095 MBEDTLS_ASN1_TAG_VALUE_MASK,
1096 2 /* SubjectAlt DNS */,
1097 NULL, NULL );
1098 if( ret != 0 )
1099 goto err;
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03001100#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001101 break;
1102
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001103 case MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001104 /* Parse extended key usage */
Hanno Becker21f55672019-02-15 15:27:59 +00001105 frame->ext_key_usage_raw.p = p;
1106 frame->ext_key_usage_raw.len = end_ext_octet - p;
1107 if( frame->ext_key_usage_raw.len == 0 )
Hanno Becker5984d302019-02-21 14:46:54 +00001108 {
Hanno Becker21f55672019-02-15 15:27:59 +00001109 ret = MBEDTLS_ERR_ASN1_INVALID_LENGTH;
1110 goto err;
Hanno Becker5984d302019-02-21 14:46:54 +00001111 }
Hanno Becker21f55672019-02-15 15:27:59 +00001112
1113 /* Check structural sanity of extension. */
1114 ret = mbedtls_asn1_traverse_sequence_of( &p, end_ext_octet,
1115 0xFF, MBEDTLS_ASN1_OID,
1116 0, 0, NULL, NULL );
1117 if( ret != 0 )
1118 goto err;
1119
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001120 break;
1121
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001122 case MBEDTLS_X509_EXT_NS_CERT_TYPE:
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001123 /* Parse netscape certificate type */
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001124 ret = x509_get_ns_cert_type( &p, end_ext_octet,
Hanno Becker21f55672019-02-15 15:27:59 +00001125 &frame->ns_cert_type );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001126 if( ret != 0 )
1127 goto err;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001128 break;
1129
1130 default:
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001131 /*
1132 * If this is a non-critical extension, which the oid layer
1133 * supports, but there isn't an X.509 parser for it,
1134 * skip the extension.
1135 */
1136#if !defined(MBEDTLS_X509_ALLOW_UNSUPPORTED_CRITICAL_EXTENSION)
1137 if( is_critical )
1138 return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE );
1139#endif
1140 p = end_ext_octet;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001141 }
1142
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001143 return( 0 );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001144
1145err:
1146 return( ret );
1147}
1148
Hanno Becker21f55672019-02-15 15:27:59 +00001149static int x509_crt_frame_parse_ext( mbedtls_x509_crt_frame *frame )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001150{
1151 int ret;
Hanno Becker21f55672019-02-15 15:27:59 +00001152 unsigned char *p = frame->v3_ext.p;
1153 unsigned char *end = p + frame->v3_ext.len;
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001154
Hanno Becker21f55672019-02-15 15:27:59 +00001155 if( p == end )
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001156 return( 0 );
1157
Hanno Becker21f55672019-02-15 15:27:59 +00001158 ret = mbedtls_asn1_traverse_sequence_of( &p, end,
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001159 0xFF, MBEDTLS_ASN1_SEQUENCE | MBEDTLS_ASN1_CONSTRUCTED,
Hanno Becker21f55672019-02-15 15:27:59 +00001160 0, 0, x509_crt_get_ext_cb, frame );
Hanno Beckerf1b39bf2019-02-22 11:09:48 +00001161
1162 if( ret == MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE )
1163 return( ret );
1164 if( ret == MBEDTLS_ERR_X509_INVALID_EXTENSIONS )
1165 return( ret );
1166
1167 if( ret != 0 )
1168 ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
1169
1170 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001171}
1172
Hanno Becker21f55672019-02-15 15:27:59 +00001173static int x509_crt_parse_frame( unsigned char *start,
1174 unsigned char *end,
1175 mbedtls_x509_crt_frame *frame )
1176{
1177 int ret;
1178 unsigned char *p;
1179 size_t len;
1180
1181 mbedtls_x509_buf tmp;
1182 unsigned char *tbs_start;
1183
1184 mbedtls_x509_buf outer_sig_alg;
1185 size_t inner_sig_alg_len;
1186 unsigned char *inner_sig_alg_start;
1187
1188 memset( frame, 0, sizeof( *frame ) );
1189
1190 /*
1191 * Certificate ::= SEQUENCE {
1192 * tbsCertificate TBSCertificate,
1193 * signatureAlgorithm AlgorithmIdentifier,
1194 * signatureValue BIT STRING
1195 * }
1196 *
1197 */
1198 p = start;
1199
1200 frame->raw.p = p;
1201 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
1202 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
1203 {
1204 return( MBEDTLS_ERR_X509_INVALID_FORMAT );
1205 }
1206
1207 /* NOTE: We are currently not checking that the `Certificate`
1208 * structure spans the entire buffer. */
1209 end = p + len;
1210 frame->raw.len = end - frame->raw.p;
1211
1212 /*
1213 * TBSCertificate ::= SEQUENCE { ...
1214 */
1215 frame->tbs.p = p;
1216 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
1217 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
1218 {
1219 return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
1220 }
1221 tbs_start = p;
1222
1223 /* Breadth-first parsing: Jump over TBS for now. */
1224 p += len;
1225 frame->tbs.len = p - frame->tbs.p;
1226
1227 /*
1228 * AlgorithmIdentifier ::= SEQUENCE { ...
1229 */
1230 outer_sig_alg.p = p;
1231 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
1232 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
1233 {
1234 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
1235 }
1236 p += len;
1237 outer_sig_alg.len = p - outer_sig_alg.p;
1238
1239 /*
1240 * signatureValue BIT STRING
1241 */
1242 ret = mbedtls_x509_get_sig( &p, end, &tmp );
1243 if( ret != 0 )
1244 return( ret );
1245 frame->sig.p = tmp.p;
1246 frame->sig.len = tmp.len;
1247
1248 /* Check that we consumed the entire `Certificate` structure. */
1249 if( p != end )
1250 {
1251 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
1252 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
1253 }
1254
1255 /* Parse TBSCertificate structure
1256 *
1257 * TBSCertificate ::= SEQUENCE {
1258 * version [0] EXPLICIT Version DEFAULT v1,
1259 * serialNumber CertificateSerialNumber,
1260 * signature AlgorithmIdentifier,
1261 * issuer Name,
1262 * validity Validity,
1263 * subject Name,
1264 * subjectPublicKeyInfo SubjectPublicKeyInfo,
1265 * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
1266 * -- If present, version MUST be v2 or v3
1267 * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
1268 * -- If present, version MUST be v2 or v3
1269 * extensions [3] EXPLICIT Extensions OPTIONAL
1270 * -- If present, version MUST be v3
1271 * }
1272 */
1273 end = frame->tbs.p + frame->tbs.len;
1274 p = tbs_start;
1275
1276 /*
1277 * Version ::= INTEGER { v1(0), v2(1), v3(2) }
1278 */
1279 {
1280 int version;
1281 ret = x509_get_version( &p, end, &version );
1282 if( ret != 0 )
1283 return( ret );
1284
1285 if( version < 0 || version > 2 )
1286 return( MBEDTLS_ERR_X509_UNKNOWN_VERSION );
1287
1288 frame->version = version + 1;
1289 }
1290
1291 /*
1292 * CertificateSerialNumber ::= INTEGER
1293 */
1294 ret = mbedtls_x509_get_serial( &p, end, &tmp );
1295 if( ret != 0 )
1296 return( ret );
1297
1298 frame->serial.p = tmp.p;
1299 frame->serial.len = tmp.len;
1300
1301 /*
1302 * signature AlgorithmIdentifier
1303 */
1304 inner_sig_alg_start = p;
1305 ret = mbedtls_x509_get_sig_alg_raw( &p, end, &frame->sig_md,
1306 &frame->sig_pk, NULL );
1307 if( ret != 0 )
1308 return( ret );
1309 inner_sig_alg_len = p - inner_sig_alg_start;
1310
1311 frame->sig_alg.p = inner_sig_alg_start;
1312 frame->sig_alg.len = inner_sig_alg_len;
1313
1314 /* Consistency check:
1315 * Inner and outer AlgorithmIdentifier structures must coincide:
1316 *
1317 * Quoting RFC 5280, Section 4.1.1.2:
1318 * This field MUST contain the same algorithm identifier as the
1319 * signature field in the sequence tbsCertificate (Section 4.1.2.3).
1320 */
1321 if( outer_sig_alg.len != inner_sig_alg_len ||
1322 memcmp( outer_sig_alg.p, inner_sig_alg_start, inner_sig_alg_len ) != 0 )
1323 {
1324 return( MBEDTLS_ERR_X509_SIG_MISMATCH );
1325 }
1326
1327 /*
1328 * issuer Name
1329 *
1330 * Name ::= CHOICE { -- only one possibility for now --
1331 * rdnSequence RDNSequence }
1332 *
1333 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
1334 */
Hanno Becker1e11f212019-03-04 14:43:43 +00001335 frame->issuer_raw.p = p;
Hanno Becker21f55672019-02-15 15:27:59 +00001336
1337 ret = mbedtls_asn1_get_tag( &p, end, &len,
1338 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
1339 if( ret != 0 )
1340 return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
Hanno Becker21f55672019-02-15 15:27:59 +00001341 p += len;
Hanno Becker1e11f212019-03-04 14:43:43 +00001342 frame->issuer_raw.len = p - frame->issuer_raw.p;
Hanno Becker21f55672019-02-15 15:27:59 +00001343
Hanno Becker3aa12162019-07-02 16:47:40 +01001344 /* Comparing the raw buffer to itself amounts to structural validation. */
Hanno Becker21f55672019-02-15 15:27:59 +00001345 ret = mbedtls_x509_name_cmp_raw( &frame->issuer_raw,
1346 &frame->issuer_raw,
1347 NULL, NULL );
1348 if( ret != 0 )
1349 return( ret );
1350
Hanno Becker21f55672019-02-15 15:27:59 +00001351 /*
1352 * Validity ::= SEQUENCE { ...
1353 */
Hanno Becker843b71a2019-06-25 09:39:21 +01001354#if !defined(MBEDTLS_X509_CRT_REMOVE_TIME)
Hanno Becker21f55672019-02-15 15:27:59 +00001355 ret = x509_get_dates( &p, end, &frame->valid_from, &frame->valid_to );
1356 if( ret != 0 )
1357 return( ret );
Hanno Becker843b71a2019-06-25 09:39:21 +01001358#else /* !MBEDTLS_X509_CRT_REMOVE_TIME */
1359 ret = x509_skip_dates( &p, end );
1360 if( ret != 0 )
1361 return( ret );
1362#endif /* MBEDTLS_X509_CRT_REMOVE_TIME */
Hanno Becker21f55672019-02-15 15:27:59 +00001363
1364 /*
1365 * subject Name
1366 *
1367 * Name ::= CHOICE { -- only one possibility for now --
1368 * rdnSequence RDNSequence }
1369 *
1370 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
1371 */
Hanno Becker1e11f212019-03-04 14:43:43 +00001372 frame->subject_raw.p = p;
Hanno Becker21f55672019-02-15 15:27:59 +00001373
1374 ret = mbedtls_asn1_get_tag( &p, end, &len,
1375 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
1376 if( ret != 0 )
1377 return( ret + MBEDTLS_ERR_X509_INVALID_FORMAT );
Hanno Becker21f55672019-02-15 15:27:59 +00001378 p += len;
Hanno Becker1e11f212019-03-04 14:43:43 +00001379 frame->subject_raw.len = p - frame->subject_raw.p;
Hanno Becker21f55672019-02-15 15:27:59 +00001380
Hanno Becker3aa12162019-07-02 16:47:40 +01001381 /* Comparing the raw buffer to itself amounts to structural validation. */
Hanno Becker21f55672019-02-15 15:27:59 +00001382 ret = mbedtls_x509_name_cmp_raw( &frame->subject_raw,
1383 &frame->subject_raw,
1384 NULL, NULL );
1385 if( ret != 0 )
1386 return( ret );
1387
Hanno Becker21f55672019-02-15 15:27:59 +00001388 /*
1389 * SubjectPublicKeyInfo
1390 */
1391 frame->pubkey_raw.p = p;
1392 ret = mbedtls_asn1_get_tag( &p, end, &len,
1393 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE );
1394 if( ret != 0 )
1395 return( ret + MBEDTLS_ERR_PK_KEY_INVALID_FORMAT );
1396 p += len;
1397 frame->pubkey_raw.len = p - frame->pubkey_raw.p;
1398
Hanno Becker97aa4362019-06-08 07:38:20 +01001399 if( frame->version != 1 )
Hanno Becker21f55672019-02-15 15:27:59 +00001400 {
Hanno Beckerd07614c2019-06-25 10:19:58 +01001401#if !defined(MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID)
Hanno Beckerfd64f142019-06-07 11:47:12 +01001402 /*
1403 * issuerUniqueID [1] IMPLICIT UniqueIdentifier OPTIONAL,
1404 * -- If present, version shall be v2 or v3
1405 */
Hanno Beckere9084122019-06-07 12:04:39 +01001406 ret = x509_get_uid( &p, end, &frame->issuer_id, 1 /* implicit tag */ );
Hanno Becker21f55672019-02-15 15:27:59 +00001407 if( ret != 0 )
1408 return( ret );
1409
Hanno Beckerfd64f142019-06-07 11:47:12 +01001410 /*
1411 * subjectUniqueID [2] IMPLICIT UniqueIdentifier OPTIONAL,
1412 * -- If present, version shall be v2 or v3
1413 */
Hanno Beckere9084122019-06-07 12:04:39 +01001414 ret = x509_get_uid( &p, end, &frame->subject_id, 2 /* implicit tag */ );
Hanno Becker21f55672019-02-15 15:27:59 +00001415 if( ret != 0 )
1416 return( ret );
Hanno Beckerd07614c2019-06-25 10:19:58 +01001417#else /* !MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID */
1418 ret = x509_skip_uid( &p, end, 1 /* implicit tag */ );
1419 if( ret != 0 )
1420 return( ret );
1421 ret = x509_skip_uid( &p, end, 2 /* implicit tag */ );
1422 if( ret != 0 )
1423 return( ret );
1424#endif /* MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID */
Hanno Becker21f55672019-02-15 15:27:59 +00001425 }
1426
1427 /*
1428 * extensions [3] EXPLICIT Extensions OPTIONAL
1429 * -- If present, version shall be v3
1430 */
1431#if !defined(MBEDTLS_X509_ALLOW_EXTENSIONS_NON_V3)
1432 if( frame->version == 3 )
1433#endif
1434 {
1435 if( p != end )
1436 {
1437 ret = mbedtls_asn1_get_tag( &p, end, &len,
1438 MBEDTLS_ASN1_CONTEXT_SPECIFIC |
1439 MBEDTLS_ASN1_CONSTRUCTED | 3 );
1440 if( len == 0 )
1441 ret = MBEDTLS_ERR_ASN1_OUT_OF_DATA;
1442 if( ret != 0 )
1443 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
1444
1445 frame->v3_ext.p = p;
1446 frame->v3_ext.len = len;
1447
1448 p += len;
1449 }
1450
1451 ret = x509_crt_frame_parse_ext( frame );
1452 if( ret != 0 )
1453 return( ret );
1454 }
1455
1456 /* Wrapup: Check that we consumed the entire `TBSCertificate` structure. */
1457 if( p != end )
1458 {
1459 return( MBEDTLS_ERR_X509_INVALID_FORMAT +
1460 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
1461 }
1462
1463 return( 0 );
1464}
1465
Hanno Becker12506232019-05-13 13:53:21 +01001466static int x509_crt_subject_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +00001467 mbedtls_x509_name *subject )
1468{
Hanno Becker1e11f212019-03-04 14:43:43 +00001469 return( mbedtls_x509_get_name( frame->subject_raw.p,
1470 frame->subject_raw.len,
1471 subject ) );
Hanno Becker21f55672019-02-15 15:27:59 +00001472}
1473
Hanno Becker12506232019-05-13 13:53:21 +01001474static int x509_crt_issuer_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +00001475 mbedtls_x509_name *issuer )
1476{
Hanno Becker1e11f212019-03-04 14:43:43 +00001477 return( mbedtls_x509_get_name( frame->issuer_raw.p,
1478 frame->issuer_raw.len,
1479 issuer ) );
Hanno Becker21f55672019-02-15 15:27:59 +00001480}
1481
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03001482#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Becker12506232019-05-13 13:53:21 +01001483static int x509_crt_subject_alt_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +00001484 mbedtls_x509_sequence *subject_alt )
1485{
1486 int ret;
1487 unsigned char *p = frame->subject_alt_raw.p;
1488 unsigned char *end = p + frame->subject_alt_raw.len;
1489
1490 memset( subject_alt, 0, sizeof( *subject_alt ) );
1491
1492 if( ( frame->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME ) == 0 )
1493 return( 0 );
1494
1495 ret = x509_get_subject_alt_name( p, end, subject_alt );
1496 if( ret != 0 )
1497 ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
1498 return( ret );
1499}
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03001500#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Becker21f55672019-02-15 15:27:59 +00001501
Hanno Becker12506232019-05-13 13:53:21 +01001502static int x509_crt_ext_key_usage_from_frame( mbedtls_x509_crt_frame const *frame,
Hanno Becker21f55672019-02-15 15:27:59 +00001503 mbedtls_x509_sequence *ext_key_usage )
1504{
1505 int ret;
1506 unsigned char *p = frame->ext_key_usage_raw.p;
1507 unsigned char *end = p + frame->ext_key_usage_raw.len;
1508
1509 memset( ext_key_usage, 0, sizeof( *ext_key_usage ) );
1510
1511 if( ( frame->ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) == 0 )
1512 return( 0 );
1513
1514 ret = x509_get_ext_key_usage( &p, end, ext_key_usage );
1515 if( ret != 0 )
1516 {
1517 ret += MBEDTLS_ERR_X509_INVALID_EXTENSIONS;
1518 return( ret );
1519 }
1520
1521 return( 0 );
1522}
1523
Hanno Becker180f7bf2019-02-28 13:23:38 +00001524#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Hanno Becker21f55672019-02-15 15:27:59 +00001525static int x509_crt_pk_from_frame( mbedtls_x509_crt_frame *frame,
1526 mbedtls_pk_context *pk )
1527{
1528 unsigned char *p = frame->pubkey_raw.p;
1529 unsigned char *end = p + frame->pubkey_raw.len;
1530 return( mbedtls_pk_parse_subpubkey( &p, end, pk ) );
1531}
Hanno Becker180f7bf2019-02-28 13:23:38 +00001532#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Becker21f55672019-02-15 15:27:59 +00001533
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001534/*
1535 * Parse and fill a single X.509 certificate in DER format
1536 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001537static int x509_crt_parse_der_core( mbedtls_x509_crt *crt,
1538 const unsigned char *buf,
1539 size_t buflen,
1540 int make_copy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001541{
1542 int ret;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001543 mbedtls_x509_crt_frame *frame;
1544 mbedtls_x509_crt_cache *cache;
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +01001545
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001546 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001547 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001548
Hanno Becker21f55672019-02-15 15:27:59 +00001549 if( make_copy == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001550 {
Hanno Becker21f55672019-02-15 15:27:59 +00001551 crt->raw.p = (unsigned char*) buf;
1552 crt->raw.len = buflen;
1553 crt->own_buffer = 0;
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001554 }
1555 else
1556 {
Hanno Becker7b8e11e2019-05-03 12:37:12 +01001557 /* Call mbedtls_calloc with buflen + 1 in order to avoid potential
1558 * return of NULL in case of length 0 certificates, which we want
1559 * to cleanly fail with MBEDTLS_ERR_X509_INVALID_FORMAT in the
1560 * core parsing routine, but not here. */
1561 crt->raw.p = mbedtls_calloc( 1, buflen + 1 );
Hanno Becker21f55672019-02-15 15:27:59 +00001562 if( crt->raw.p == NULL )
1563 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
1564 crt->raw.len = buflen;
1565 memcpy( crt->raw.p, buf, buflen );
1566
1567 crt->own_buffer = 1;
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001568 }
Janos Follathcc0e49d2016-02-17 14:34:12 +00001569
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001570 cache = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_cache ) );
1571 if( cache == NULL )
1572 {
1573 ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
1574 goto exit;
1575 }
1576 crt->cache = cache;
1577 x509_crt_cache_init( cache );
1578
Hanno Beckerea32d8b2019-03-04 11:52:23 +00001579#if defined(MBEDTLS_X509_ON_DEMAND_PARSING)
1580
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001581 ret = mbedtls_x509_crt_cache_provide_frame( crt );
Hanno Becker21f55672019-02-15 15:27:59 +00001582 if( ret != 0 )
1583 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001584
Hanno Becker76428352019-03-05 15:29:23 +00001585 frame = crt->cache->frame;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001586
Hanno Beckerea32d8b2019-03-04 11:52:23 +00001587#else /* MBEDTLS_X509_ON_DEMAND_PARSING */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001588
Hanno Beckerea32d8b2019-03-04 11:52:23 +00001589 frame = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt_frame ) );
1590 if( frame == NULL )
1591 {
1592 ret = MBEDTLS_ERR_X509_ALLOC_FAILED;
1593 goto exit;
1594 }
1595 cache->frame = frame;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001596
Hanno Beckerea32d8b2019-03-04 11:52:23 +00001597 ret = x509_crt_parse_frame( crt->raw.p,
1598 crt->raw.p + crt->raw.len,
1599 frame );
1600 if( ret != 0 )
1601 goto exit;
1602
Hanno Becker21f55672019-02-15 15:27:59 +00001603 /* Copy frame to legacy CRT structure -- that's inefficient, but if
1604 * memory matters, the new CRT structure should be used anyway. */
Hanno Becker38f0cb42019-03-04 15:13:45 +00001605 x509_buf_raw_to_buf( &crt->tbs, &frame->tbs );
1606 x509_buf_raw_to_buf( &crt->serial, &frame->serial );
1607 x509_buf_raw_to_buf( &crt->issuer_raw, &frame->issuer_raw );
1608 x509_buf_raw_to_buf( &crt->subject_raw, &frame->subject_raw );
Hanno Beckerd07614c2019-06-25 10:19:58 +01001609#if !defined(MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID)
Hanno Becker38f0cb42019-03-04 15:13:45 +00001610 x509_buf_raw_to_buf( &crt->issuer_id, &frame->issuer_id );
1611 x509_buf_raw_to_buf( &crt->subject_id, &frame->subject_id );
Hanno Beckerd07614c2019-06-25 10:19:58 +01001612#endif /* !MBEDTLS_X509_CRT_REMOVE_SUBJECT_ISSUER_ID */
Hanno Becker38f0cb42019-03-04 15:13:45 +00001613 x509_buf_raw_to_buf( &crt->pk_raw, &frame->pubkey_raw );
1614 x509_buf_raw_to_buf( &crt->sig, &frame->sig );
1615 x509_buf_raw_to_buf( &crt->v3_ext, &frame->v3_ext );
Hanno Becker843b71a2019-06-25 09:39:21 +01001616
1617#if !defined(MBEDTLS_X509_CRT_REMOVE_TIME)
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001618 crt->valid_from = frame->valid_from;
1619 crt->valid_to = frame->valid_to;
Hanno Becker843b71a2019-06-25 09:39:21 +01001620#endif /* !MBEDTLS_X509_CRT_REMOVE_TIME */
1621
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001622 crt->version = frame->version;
1623 crt->ca_istrue = frame->ca_istrue;
1624 crt->max_pathlen = frame->max_pathlen;
1625 crt->ext_types = frame->ext_types;
1626 crt->key_usage = frame->key_usage;
1627 crt->ns_cert_type = frame->ns_cert_type;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001628
1629 /*
Hanno Becker21f55672019-02-15 15:27:59 +00001630 * Obtain the remaining fields from the frame.
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001631 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001632
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001633 {
Hanno Becker21f55672019-02-15 15:27:59 +00001634 /* sig_oid: Previously, needed for convenience in
1635 * mbedtls_x509_crt_info(), now pure legacy burden. */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001636 unsigned char *tmp = frame->sig_alg.p;
1637 unsigned char *end = tmp + frame->sig_alg.len;
Hanno Becker21f55672019-02-15 15:27:59 +00001638 mbedtls_x509_buf sig_oid, sig_params;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001639
Hanno Becker21f55672019-02-15 15:27:59 +00001640 ret = mbedtls_x509_get_alg( &tmp, end,
1641 &sig_oid, &sig_params );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001642 if( ret != 0 )
1643 {
Hanno Becker21f55672019-02-15 15:27:59 +00001644 /* This should never happen, because we check
1645 * the sanity of the AlgorithmIdentifier structure
1646 * during frame parsing. */
1647 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1648 goto exit;
1649 }
1650 crt->sig_oid = sig_oid;
1651
1652 /* Signature parameters */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001653 tmp = frame->sig_alg.p;
Hanno Becker21f55672019-02-15 15:27:59 +00001654 ret = mbedtls_x509_get_sig_alg_raw( &tmp, end,
1655 &crt->sig_md, &crt->sig_pk,
1656 &crt->sig_opts );
1657 if( ret != 0 )
1658 {
1659 /* Again, this should never happen. */
1660 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
1661 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001662 }
1663 }
1664
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001665 ret = x509_crt_pk_from_frame( frame, &crt->pk );
Hanno Becker21f55672019-02-15 15:27:59 +00001666 if( ret != 0 )
1667 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001668
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001669 ret = x509_crt_subject_from_frame( frame, &crt->subject );
Hanno Becker21f55672019-02-15 15:27:59 +00001670 if( ret != 0 )
1671 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001672
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001673 ret = x509_crt_issuer_from_frame( frame, &crt->issuer );
Hanno Becker21f55672019-02-15 15:27:59 +00001674 if( ret != 0 )
1675 goto exit;
1676
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03001677#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001678 ret = x509_crt_subject_alt_from_frame( frame, &crt->subject_alt_names );
Hanno Becker21f55672019-02-15 15:27:59 +00001679 if( ret != 0 )
1680 goto exit;
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03001681#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Becker21f55672019-02-15 15:27:59 +00001682
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001683 ret = x509_crt_ext_key_usage_from_frame( frame, &crt->ext_key_usage );
1684 if( ret != 0 )
1685 goto exit;
Hanno Becker180f7bf2019-02-28 13:23:38 +00001686#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001687
Hanno Beckerea32d8b2019-03-04 11:52:23 +00001688 /* Currently, we accept DER encoded CRTs with trailing garbage
1689 * and promise to not account for the garbage in the `raw` field.
1690 *
1691 * Note that this means that `crt->raw.len` is not necessarily the
1692 * full size of the heap buffer allocated at `crt->raw.p` in case
1693 * of copy-mode, but this is not a problem: freeing the buffer doesn't
1694 * need the size, and the garbage data doesn't need zeroization. */
1695 crt->raw.len = frame->raw.len;
1696
1697 cache->pk_raw = frame->pubkey_raw;
1698
Hanno Becker7a4de9c2019-02-27 13:12:24 +00001699 /* Free the frame before parsing the public key to
1700 * keep peak RAM usage low. This is slightly inefficient
1701 * because the frame will need to be parsed again on the
1702 * first usage of the CRT, but that seems acceptable.
1703 * As soon as the frame gets used multiple times, it
1704 * will be cached by default. */
1705 x509_crt_cache_clear_frame( crt->cache );
1706
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001707 /* The cache just references the PK structure from the legacy
1708 * implementation, so set up the latter first before setting up
Hanno Becker7a4de9c2019-02-27 13:12:24 +00001709 * the cache.
1710 *
1711 * We're not actually using the parsed PK context here;
1712 * we just parse it to check that it's well-formed. */
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00001713 ret = mbedtls_x509_crt_cache_provide_pk( crt );
Hanno Becker21f55672019-02-15 15:27:59 +00001714 if( ret != 0 )
1715 goto exit;
Hanno Becker7a4de9c2019-02-27 13:12:24 +00001716 x509_crt_cache_clear_pk( crt->cache );
Hanno Becker21f55672019-02-15 15:27:59 +00001717
1718exit:
1719 if( ret != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001720 mbedtls_x509_crt_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001721
Hanno Becker21f55672019-02-15 15:27:59 +00001722 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001723}
1724
1725/*
1726 * Parse one X.509 certificate in DER format from a buffer and add them to a
1727 * chained list
1728 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001729static int mbedtls_x509_crt_parse_der_internal( mbedtls_x509_crt *chain,
1730 const unsigned char *buf,
1731 size_t buflen,
1732 int make_copy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001733{
1734 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001735 mbedtls_x509_crt *crt = chain, *prev = NULL;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001736
1737 /*
1738 * Check for valid input
1739 */
1740 if( crt == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001741 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001742
Hanno Becker371e0e42019-02-25 18:08:59 +00001743 while( crt->raw.p != NULL && crt->next != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001744 {
1745 prev = crt;
1746 crt = crt->next;
1747 }
1748
1749 /*
1750 * Add new certificate on the end of the chain if needed.
1751 */
Hanno Becker371e0e42019-02-25 18:08:59 +00001752 if( crt->raw.p != NULL && crt->next == NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001753 {
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +02001754 crt->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001755
1756 if( crt->next == NULL )
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02001757 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001758
1759 prev = crt;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001760 mbedtls_x509_crt_init( crt->next );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001761 crt = crt->next;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001762 }
1763
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001764 if( ( ret = x509_crt_parse_der_core( crt, buf, buflen, make_copy ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001765 {
1766 if( prev )
1767 prev->next = NULL;
1768
1769 if( crt != chain )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001770 mbedtls_free( crt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001771
1772 return( ret );
1773 }
1774
1775 return( 0 );
1776}
1777
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001778int mbedtls_x509_crt_parse_der_nocopy( mbedtls_x509_crt *chain,
1779 const unsigned char *buf,
1780 size_t buflen )
1781{
1782 return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 0 ) );
1783}
1784
1785int mbedtls_x509_crt_parse_der( mbedtls_x509_crt *chain,
1786 const unsigned char *buf,
1787 size_t buflen )
1788{
1789 return( mbedtls_x509_crt_parse_der_internal( chain, buf, buflen, 1 ) );
1790}
1791
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001792/*
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001793 * Parse one or more PEM certificates from a buffer and add them to the chained
1794 * list
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001795 */
Hanno Beckeraa8665a2019-01-31 08:57:44 +00001796int mbedtls_x509_crt_parse( mbedtls_x509_crt *chain,
1797 const unsigned char *buf,
1798 size_t buflen )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001799{
Janos Follath98e28a72016-05-31 14:03:54 +01001800#if defined(MBEDTLS_PEM_PARSE_C)
Andres AGc0db5112016-12-07 15:05:53 +00001801 int success = 0, first_error = 0, total_failed = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001802 int buf_format = MBEDTLS_X509_FORMAT_DER;
Janos Follath98e28a72016-05-31 14:03:54 +01001803#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001804
1805 /*
1806 * Check for valid input
1807 */
1808 if( chain == NULL || buf == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001809 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001810
1811 /*
1812 * Determine buffer content. Buffer contains either one DER certificate or
1813 * one or more PEM certificates.
1814 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001815#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard0ece0f92015-05-12 12:43:54 +02001816 if( buflen != 0 && buf[buflen - 1] == '\0' &&
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001817 strstr( (const char *) buf, "-----BEGIN CERTIFICATE-----" ) != NULL )
1818 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001819 buf_format = MBEDTLS_X509_FORMAT_PEM;
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001820 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001821
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001822 if( buf_format == MBEDTLS_X509_FORMAT_DER )
1823 return mbedtls_x509_crt_parse_der( chain, buf, buflen );
Janos Follath98e28a72016-05-31 14:03:54 +01001824#else
1825 return mbedtls_x509_crt_parse_der( chain, buf, buflen );
1826#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001827
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001828#if defined(MBEDTLS_PEM_PARSE_C)
1829 if( buf_format == MBEDTLS_X509_FORMAT_PEM )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001830 {
1831 int ret;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001832 mbedtls_pem_context pem;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001833
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001834 /* 1 rather than 0 since the terminating NULL byte is counted in */
1835 while( buflen > 1 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001836 {
1837 size_t use_len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001838 mbedtls_pem_init( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001839
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001840 /* If we get there, we know the string is null-terminated */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001841 ret = mbedtls_pem_read_buffer( &pem,
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001842 "-----BEGIN CERTIFICATE-----",
1843 "-----END CERTIFICATE-----",
1844 buf, NULL, 0, &use_len );
1845
1846 if( ret == 0 )
1847 {
1848 /*
1849 * Was PEM encoded
1850 */
1851 buflen -= use_len;
1852 buf += use_len;
1853 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001854 else if( ret == MBEDTLS_ERR_PEM_BAD_INPUT_DATA )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001855 {
1856 return( ret );
1857 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001858 else if( ret != MBEDTLS_ERR_PEM_NO_HEADER_FOOTER_PRESENT )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001859 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001860 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001861
1862 /*
1863 * PEM header and footer were found
1864 */
1865 buflen -= use_len;
1866 buf += use_len;
1867
1868 if( first_error == 0 )
1869 first_error = ret;
1870
Paul Bakker5a5fa922014-09-26 14:53:04 +02001871 total_failed++;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001872 continue;
1873 }
1874 else
1875 break;
1876
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001877 ret = mbedtls_x509_crt_parse_der( chain, pem.buf, pem.buflen );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001878
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001879 mbedtls_pem_free( &pem );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001880
1881 if( ret != 0 )
1882 {
1883 /*
1884 * Quit parsing on a memory error
1885 */
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +02001886 if( ret == MBEDTLS_ERR_X509_ALLOC_FAILED )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001887 return( ret );
1888
1889 if( first_error == 0 )
1890 first_error = ret;
1891
1892 total_failed++;
1893 continue;
1894 }
1895
1896 success = 1;
1897 }
1898 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001899
1900 if( success )
1901 return( total_failed );
1902 else if( first_error )
1903 return( first_error );
1904 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001905 return( MBEDTLS_ERR_X509_CERT_UNKNOWN_FORMAT );
Janos Follath98e28a72016-05-31 14:03:54 +01001906#endif /* MBEDTLS_PEM_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001907}
1908
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001909#if defined(MBEDTLS_FS_IO)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001910/*
1911 * Load one or more certificates and add them to the chained list
1912 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001913int mbedtls_x509_crt_parse_file( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001914{
1915 int ret;
1916 size_t n;
1917 unsigned char *buf;
1918
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001919 if( ( ret = mbedtls_pk_load_file( path, &buf, &n ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001920 return( ret );
1921
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001922 ret = mbedtls_x509_crt_parse( chain, buf, n );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001923
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05001924 mbedtls_platform_zeroize( buf, n );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001925 mbedtls_free( buf );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001926
1927 return( ret );
1928}
1929
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001930int mbedtls_x509_crt_parse_path( mbedtls_x509_crt *chain, const char *path )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001931{
1932 int ret = 0;
Paul Bakkerfa6a6202013-10-28 18:48:30 +01001933#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001934 int w_ret;
1935 WCHAR szDir[MAX_PATH];
1936 char filename[MAX_PATH];
Paul Bakker9af723c2014-05-01 13:03:14 +02001937 char *p;
Manuel Pégourié-Gonnard261faed2015-10-21 10:16:29 +02001938 size_t len = strlen( path );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001939
Paul Bakker9af723c2014-05-01 13:03:14 +02001940 WIN32_FIND_DATAW file_data;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001941 HANDLE hFind;
1942
1943 if( len > MAX_PATH - 3 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001944 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001945
Paul Bakker9af723c2014-05-01 13:03:14 +02001946 memset( szDir, 0, sizeof(szDir) );
1947 memset( filename, 0, MAX_PATH );
1948 memcpy( filename, path, len );
1949 filename[len++] = '\\';
1950 p = filename + len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001951 filename[len++] = '*';
1952
Simon B3c6b18d2016-11-03 01:11:37 +00001953 w_ret = MultiByteToWideChar( CP_ACP, 0, filename, (int)len, szDir,
Paul Bakkerb9e4e2c2014-05-01 14:18:25 +02001954 MAX_PATH - 3 );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +00001955 if( w_ret == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001956 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001957
1958 hFind = FindFirstFileW( szDir, &file_data );
Paul Bakker66d5d072014-06-17 16:39:18 +02001959 if( hFind == INVALID_HANDLE_VALUE )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001960 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001961
1962 len = MAX_PATH - len;
1963 do
1964 {
Paul Bakker9af723c2014-05-01 13:03:14 +02001965 memset( p, 0, len );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001966
1967 if( file_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
1968 continue;
1969
Paul Bakker9af723c2014-05-01 13:03:14 +02001970 w_ret = WideCharToMultiByte( CP_ACP, 0, file_data.cFileName,
Paul Bakker66d5d072014-06-17 16:39:18 +02001971 lstrlenW( file_data.cFileName ),
Manuel Pégourié-Gonnard261faed2015-10-21 10:16:29 +02001972 p, (int) len - 1,
Paul Bakker9af723c2014-05-01 13:03:14 +02001973 NULL, NULL );
Manuel Pégourié-Gonnardacdb9b92015-01-23 17:50:34 +00001974 if( w_ret == 0 )
Ron Eldor36d90422017-01-09 15:09:16 +02001975 {
1976 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
1977 goto cleanup;
1978 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001979
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001980 w_ret = mbedtls_x509_crt_parse_file( chain, filename );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001981 if( w_ret < 0 )
1982 ret++;
1983 else
1984 ret += w_ret;
1985 }
1986 while( FindNextFileW( hFind, &file_data ) != 0 );
1987
Paul Bakker66d5d072014-06-17 16:39:18 +02001988 if( GetLastError() != ERROR_NO_MORE_FILES )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001989 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001990
Ron Eldor36d90422017-01-09 15:09:16 +02001991cleanup:
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001992 FindClose( hFind );
Paul Bakkerbe089b02013-10-14 15:51:50 +02001993#else /* _WIN32 */
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001994 int t_ret;
Andres AGf9113192016-09-02 14:06:04 +01001995 int snp_ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001996 struct stat sb;
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01001997 struct dirent *entry;
Andres AGf9113192016-09-02 14:06:04 +01001998 char entry_name[MBEDTLS_X509_MAX_FILE_PATH_LEN];
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001999 DIR *dir = opendir( path );
2000
Paul Bakker66d5d072014-06-17 16:39:18 +02002001 if( dir == NULL )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002002 return( MBEDTLS_ERR_X509_FILE_IO_ERROR );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002003
Ron Eldor63140682017-01-09 19:27:59 +02002004#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard944cfe82015-05-27 20:07:18 +02002005 if( ( ret = mbedtls_mutex_lock( &mbedtls_threading_readdir_mutex ) ) != 0 )
Manuel Pégourié-Gonnardf9b85d92015-06-22 18:39:57 +02002006 {
2007 closedir( dir );
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01002008 return( ret );
Manuel Pégourié-Gonnardf9b85d92015-06-22 18:39:57 +02002009 }
Ron Eldor63140682017-01-09 19:27:59 +02002010#endif /* MBEDTLS_THREADING_C */
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01002011
Manuel Pégourié-Gonnard964bf9b2013-11-26 16:47:11 +01002012 while( ( entry = readdir( dir ) ) != NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002013 {
Andres AGf9113192016-09-02 14:06:04 +01002014 snp_ret = mbedtls_snprintf( entry_name, sizeof entry_name,
2015 "%s/%s", path, entry->d_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002016
Andres AGf9113192016-09-02 14:06:04 +01002017 if( snp_ret < 0 || (size_t)snp_ret >= sizeof entry_name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002018 {
Andres AGf9113192016-09-02 14:06:04 +01002019 ret = MBEDTLS_ERR_X509_BUFFER_TOO_SMALL;
2020 goto cleanup;
2021 }
2022 else if( stat( entry_name, &sb ) == -1 )
2023 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002024 ret = MBEDTLS_ERR_X509_FILE_IO_ERROR;
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01002025 goto cleanup;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002026 }
2027
2028 if( !S_ISREG( sb.st_mode ) )
2029 continue;
2030
2031 // Ignore parse errors
2032 //
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002033 t_ret = mbedtls_x509_crt_parse_file( chain, entry_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002034 if( t_ret < 0 )
2035 ret++;
2036 else
2037 ret += t_ret;
2038 }
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01002039
2040cleanup:
Andres AGf9113192016-09-02 14:06:04 +01002041 closedir( dir );
2042
Ron Eldor63140682017-01-09 19:27:59 +02002043#if defined(MBEDTLS_THREADING_C)
Manuel Pégourié-Gonnard944cfe82015-05-27 20:07:18 +02002044 if( mbedtls_mutex_unlock( &mbedtls_threading_readdir_mutex ) != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002045 ret = MBEDTLS_ERR_THREADING_MUTEX_ERROR;
Ron Eldor63140682017-01-09 19:27:59 +02002046#endif /* MBEDTLS_THREADING_C */
Manuel Pégourié-Gonnard5ad68e42013-11-28 17:11:54 +01002047
Paul Bakkerbe089b02013-10-14 15:51:50 +02002048#endif /* _WIN32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002049
2050 return( ret );
2051}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002052#endif /* MBEDTLS_FS_IO */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002053
Hanno Becker08d34122019-06-25 09:42:57 +01002054typedef struct mbedtls_x509_crt_sig_info
2055{
2056 mbedtls_md_type_t sig_md;
2057 mbedtls_pk_type_t sig_pk;
2058 void *sig_opts;
2059 uint8_t crt_hash[MBEDTLS_MD_MAX_SIZE];
2060 size_t crt_hash_len;
2061 mbedtls_x509_buf_raw sig;
2062 mbedtls_x509_buf_raw issuer_raw;
2063} mbedtls_x509_crt_sig_info;
2064
2065static void x509_crt_free_sig_info( mbedtls_x509_crt_sig_info *info )
2066{
2067#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
2068 mbedtls_free( info->sig_opts );
2069#else
2070 ((void) info);
2071#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
2072}
2073
2074static int x509_crt_get_sig_info( mbedtls_x509_crt_frame const *frame,
2075 mbedtls_x509_crt_sig_info *info )
2076{
2077 const mbedtls_md_info_t *md_info;
2078
2079 md_info = mbedtls_md_info_from_type( frame->sig_md );
2080 if( mbedtls_md( md_info, frame->tbs.p, frame->tbs.len,
2081 info->crt_hash ) != 0 )
2082 {
2083 /* Note: this can't happen except after an internal error */
2084 return( -1 );
2085 }
2086
2087 info->crt_hash_len = mbedtls_md_get_size( md_info );
2088
2089 /* Make sure that this function leaves the target structure
2090 * ready to be freed, regardless of success of failure. */
2091 info->sig_opts = NULL;
2092
2093#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
2094 {
2095 int ret;
2096 unsigned char *alg_start = frame->sig_alg.p;
2097 unsigned char *alg_end = alg_start + frame->sig_alg.len;
2098
2099 /* Get signature options -- currently only
2100 * necessary for RSASSA-PSS. */
2101 ret = mbedtls_x509_get_sig_alg_raw( &alg_start, alg_end, &info->sig_md,
2102 &info->sig_pk, &info->sig_opts );
2103 if( ret != 0 )
2104 {
2105 /* Note: this can't happen except after an internal error */
2106 return( -1 );
2107 }
2108 }
2109#else /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
2110 info->sig_md = frame->sig_md;
2111 info->sig_pk = frame->sig_pk;
2112#endif /* !MBEDTLS_X509_RSASSA_PSS_SUPPORT */
2113
2114 info->issuer_raw = frame->issuer_raw;
2115 info->sig = frame->sig;
2116 return( 0 );
2117}
2118
Hanno Becker02a21932019-06-10 15:08:43 +01002119#if !defined(MBEDTLS_X509_REMOVE_INFO)
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002120#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002121static int x509_info_subject_alt_name( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002122 const mbedtls_x509_sequence *subject_alt_name )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002123{
2124 size_t i;
2125 size_t n = *size;
2126 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002127 const mbedtls_x509_sequence *cur = subject_alt_name;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002128 const char *sep = "";
2129 size_t sep_len = 0;
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002130
2131 while( cur != NULL )
2132 {
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002133 if( cur->buf.len + sep_len >= n )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002134 {
2135 *p = '\0';
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02002136 return( MBEDTLS_ERR_X509_BUFFER_TOO_SMALL );
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002137 }
2138
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002139 n -= cur->buf.len + sep_len;
2140 for( i = 0; i < sep_len; i++ )
2141 *p++ = sep[i];
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002142 for( i = 0; i < cur->buf.len; i++ )
2143 *p++ = cur->buf.p[i];
2144
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002145 sep = ", ";
2146 sep_len = 2;
2147
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002148 cur = cur->next;
2149 }
2150
2151 *p = '\0';
2152
2153 *size = n;
2154 *buf = p;
2155
2156 return( 0 );
2157}
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002158#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002159
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02002160#define PRINT_ITEM(i) \
2161 { \
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002162 ret = mbedtls_snprintf( p, n, "%s" i, sep ); \
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02002163 MBEDTLS_X509_SAFE_SNPRINTF; \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02002164 sep = ", "; \
2165 }
2166
2167#define CERT_TYPE(type,name) \
Hanno Beckerd6028a12018-10-15 12:01:35 +01002168 if( ns_cert_type & (type) ) \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02002169 PRINT_ITEM( name );
2170
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02002171static int x509_info_cert_type( char **buf, size_t *size,
2172 unsigned char ns_cert_type )
2173{
2174 int ret;
2175 size_t n = *size;
2176 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002177 const char *sep = "";
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02002178
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002179 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CLIENT, "SSL Client" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002180 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_SERVER, "SSL Server" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002181 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL, "Email" );
2182 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING, "Object Signing" );
2183 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_RESERVED, "Reserved" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002184 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_SSL_CA, "SSL CA" );
2185 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_EMAIL_CA, "Email CA" );
2186 CERT_TYPE( MBEDTLS_X509_NS_CERT_TYPE_OBJECT_SIGNING_CA, "Object Signing CA" );
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02002187
2188 *size = n;
2189 *buf = p;
2190
2191 return( 0 );
2192}
2193
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02002194#define KEY_USAGE(code,name) \
Hanno Beckerd6028a12018-10-15 12:01:35 +01002195 if( key_usage & (code) ) \
Manuel Pégourié-Gonnard0db29b02014-04-01 18:12:24 +02002196 PRINT_ITEM( name );
2197
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02002198static int x509_info_key_usage( char **buf, size_t *size,
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +02002199 unsigned int key_usage )
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02002200{
2201 int ret;
2202 size_t n = *size;
2203 char *p = *buf;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002204 const char *sep = "";
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02002205
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002206 KEY_USAGE( MBEDTLS_X509_KU_DIGITAL_SIGNATURE, "Digital Signature" );
2207 KEY_USAGE( MBEDTLS_X509_KU_NON_REPUDIATION, "Non Repudiation" );
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002208 KEY_USAGE( MBEDTLS_X509_KU_KEY_ENCIPHERMENT, "Key Encipherment" );
2209 KEY_USAGE( MBEDTLS_X509_KU_DATA_ENCIPHERMENT, "Data Encipherment" );
2210 KEY_USAGE( MBEDTLS_X509_KU_KEY_AGREEMENT, "Key Agreement" );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002211 KEY_USAGE( MBEDTLS_X509_KU_KEY_CERT_SIGN, "Key Cert Sign" );
2212 KEY_USAGE( MBEDTLS_X509_KU_CRL_SIGN, "CRL Sign" );
Manuel Pégourié-Gonnard9a702252015-06-23 10:14:36 +02002213 KEY_USAGE( MBEDTLS_X509_KU_ENCIPHER_ONLY, "Encipher Only" );
2214 KEY_USAGE( MBEDTLS_X509_KU_DECIPHER_ONLY, "Decipher Only" );
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02002215
2216 *size = n;
2217 *buf = p;
2218
2219 return( 0 );
2220}
2221
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002222static int x509_info_ext_key_usage( char **buf, size_t *size,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002223 const mbedtls_x509_sequence *extended_key_usage )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002224{
2225 int ret;
2226 const char *desc;
2227 size_t n = *size;
2228 char *p = *buf;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002229 const mbedtls_x509_sequence *cur = extended_key_usage;
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002230 const char *sep = "";
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002231
2232 while( cur != NULL )
2233 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002234 if( mbedtls_oid_get_extended_key_usage( &cur->buf, &desc ) != 0 )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002235 desc = "???";
2236
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002237 ret = mbedtls_snprintf( p, n, "%s%s", sep, desc );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02002238 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002239
Manuel Pégourié-Gonnard7b30cfc2014-04-01 18:00:07 +02002240 sep = ", ";
2241
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002242 cur = cur->next;
2243 }
2244
2245 *size = n;
2246 *buf = p;
2247
2248 return( 0 );
2249}
2250
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002251/*
2252 * Return an informational string about the certificate.
2253 */
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002254#define BEFORE_COLON 18
2255#define BC "18"
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002256int mbedtls_x509_crt_info( char *buf, size_t size, const char *prefix,
Hanno Becker5226c532019-02-27 17:38:40 +00002257 const mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002258{
2259 int ret;
2260 size_t n;
2261 char *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002262 char key_size_str[BEFORE_COLON];
Hanno Becker5226c532019-02-27 17:38:40 +00002263 mbedtls_x509_crt_frame frame;
2264 mbedtls_pk_context pk;
Hanno Becker4f869ed2019-02-24 16:47:57 +00002265
Hanno Becker5226c532019-02-27 17:38:40 +00002266 mbedtls_x509_name *issuer = NULL, *subject = NULL;
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002267 mbedtls_x509_sequence *ext_key_usage = NULL;
2268#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
2269 mbedtls_x509_sequence *subject_alt_names = NULL;
2270#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
2271
Hanno Becker4f869ed2019-02-24 16:47:57 +00002272 mbedtls_x509_crt_sig_info sig_info;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002273
2274 p = buf;
2275 n = size;
2276
Hanno Becker4f869ed2019-02-24 16:47:57 +00002277 memset( &sig_info, 0, sizeof( mbedtls_x509_crt_sig_info ) );
Hanno Becker5226c532019-02-27 17:38:40 +00002278 mbedtls_pk_init( &pk );
2279
2280 if( NULL == crt )
Janos Follath98e28a72016-05-31 14:03:54 +01002281 {
2282 ret = mbedtls_snprintf( p, n, "\nCertificate is uninitialised!\n" );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002283 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Janos Follath98e28a72016-05-31 14:03:54 +01002284
2285 return( (int) ( size - n ) );
2286 }
2287
Hanno Becker5226c532019-02-27 17:38:40 +00002288 ret = mbedtls_x509_crt_get_frame( crt, &frame );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002289 if( ret != 0 )
2290 {
2291 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2292 goto cleanup;
2293 }
2294
Hanno Becker5226c532019-02-27 17:38:40 +00002295 ret = mbedtls_x509_crt_get_subject( crt, &subject );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002296 if( ret != 0 )
2297 {
2298 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2299 goto cleanup;
2300 }
2301
Hanno Becker5226c532019-02-27 17:38:40 +00002302 ret = mbedtls_x509_crt_get_issuer( crt, &issuer );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002303 if( ret != 0 )
2304 {
2305 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2306 goto cleanup;
2307 }
2308
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002309#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Becker5226c532019-02-27 17:38:40 +00002310 ret = mbedtls_x509_crt_get_subject_alt_names( crt, &subject_alt_names );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002311 if( ret != 0 )
2312 {
2313 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2314 goto cleanup;
2315 }
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002316#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Becker4f869ed2019-02-24 16:47:57 +00002317
Hanno Becker5226c532019-02-27 17:38:40 +00002318 ret = mbedtls_x509_crt_get_ext_key_usage( crt, &ext_key_usage );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002319 if( ret != 0 )
2320 {
2321 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2322 goto cleanup;
2323 }
2324
Hanno Becker5226c532019-02-27 17:38:40 +00002325 ret = mbedtls_x509_crt_get_pk( crt, &pk );
2326 if( ret != 0 )
2327 {
2328 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2329 goto cleanup;
2330 }
2331
2332 ret = x509_crt_get_sig_info( &frame, &sig_info );
Hanno Becker4f869ed2019-02-24 16:47:57 +00002333 if( ret != 0 )
2334 {
2335 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
2336 goto cleanup;
2337 }
2338
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002339 ret = mbedtls_snprintf( p, n, "%scert. version : %d\n",
Hanno Becker5226c532019-02-27 17:38:40 +00002340 prefix, frame.version );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002341 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002342
Hanno Becker4f869ed2019-02-24 16:47:57 +00002343 {
2344 mbedtls_x509_buf serial;
Hanno Becker5226c532019-02-27 17:38:40 +00002345 serial.p = frame.serial.p;
2346 serial.len = frame.serial.len;
Hanno Becker4f869ed2019-02-24 16:47:57 +00002347 ret = mbedtls_snprintf( p, n, "%sserial number : ",
2348 prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002349 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Hanno Becker4f869ed2019-02-24 16:47:57 +00002350 ret = mbedtls_x509_serial_gets( p, n, &serial );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002351 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Hanno Becker4f869ed2019-02-24 16:47:57 +00002352 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002353
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002354 ret = mbedtls_snprintf( p, n, "\n%sissuer name : ", prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002355 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Hanno Becker5226c532019-02-27 17:38:40 +00002356 ret = mbedtls_x509_dn_gets( p, n, issuer );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002357 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002358
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002359 ret = mbedtls_snprintf( p, n, "\n%ssubject name : ", prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002360 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Hanno Becker5226c532019-02-27 17:38:40 +00002361 ret = mbedtls_x509_dn_gets( p, n, subject );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002362 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002363
Hanno Becker843b71a2019-06-25 09:39:21 +01002364#if !defined(MBEDTLS_X509_CRT_REMOVE_TIME)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002365 ret = mbedtls_snprintf( p, n, "\n%sissued on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002366 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
Hanno Becker5226c532019-02-27 17:38:40 +00002367 frame.valid_from.year, frame.valid_from.mon,
2368 frame.valid_from.day, frame.valid_from.hour,
2369 frame.valid_from.min, frame.valid_from.sec );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002370 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002371
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002372 ret = mbedtls_snprintf( p, n, "\n%sexpires on : " \
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002373 "%04d-%02d-%02d %02d:%02d:%02d", prefix,
Hanno Becker5226c532019-02-27 17:38:40 +00002374 frame.valid_to.year, frame.valid_to.mon,
2375 frame.valid_to.day, frame.valid_to.hour,
2376 frame.valid_to.min, frame.valid_to.sec );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002377 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Hanno Becker843b71a2019-06-25 09:39:21 +01002378#endif /* MBEDTLS_X509_CRT_REMOVE_TIME */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002379
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002380 ret = mbedtls_snprintf( p, n, "\n%ssigned using : ", prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002381 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002382
Hanno Becker83cd8672019-02-21 17:13:46 +00002383 ret = mbedtls_x509_sig_alg_gets( p, n, sig_info.sig_pk,
2384 sig_info.sig_md, sig_info.sig_opts );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002385 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002386
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002387 /* Key size */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002388 if( ( ret = mbedtls_x509_key_size_helper( key_size_str, BEFORE_COLON,
Hanno Becker5226c532019-02-27 17:38:40 +00002389 mbedtls_pk_get_name( &pk ) ) ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002390 {
2391 return( ret );
2392 }
2393
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002394 ret = mbedtls_snprintf( p, n, "\n%s%-" BC "s: %d bits", prefix, key_size_str,
Hanno Becker5226c532019-02-27 17:38:40 +00002395 (int) mbedtls_pk_get_bitlen( &pk ) );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002396 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002397
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002398 /*
2399 * Optional extensions
2400 */
2401
Hanno Becker5226c532019-02-27 17:38:40 +00002402 if( frame.ext_types & MBEDTLS_X509_EXT_BASIC_CONSTRAINTS )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002403 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002404 ret = mbedtls_snprintf( p, n, "\n%sbasic constraints : CA=%s", prefix,
Hanno Becker5226c532019-02-27 17:38:40 +00002405 frame.ca_istrue ? "true" : "false" );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002406 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002407
Hanno Becker5226c532019-02-27 17:38:40 +00002408 if( frame.max_pathlen > 0 )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002409 {
Hanno Becker5226c532019-02-27 17:38:40 +00002410 ret = mbedtls_snprintf( p, n, ", max_pathlen=%d", frame.max_pathlen - 1 );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002411 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002412 }
2413 }
2414
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002415#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Becker5226c532019-02-27 17:38:40 +00002416 if( frame.ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002417 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002418 ret = mbedtls_snprintf( p, n, "\n%ssubject alt name : ", prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002419 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002420
2421 if( ( ret = x509_info_subject_alt_name( &p, &n,
Hanno Becker5226c532019-02-27 17:38:40 +00002422 subject_alt_names ) ) != 0 )
Manuel Pégourié-Gonnardbce2b302014-04-01 13:43:28 +02002423 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002424 }
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002425#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002426
Hanno Becker5226c532019-02-27 17:38:40 +00002427 if( frame.ext_types & MBEDTLS_X509_EXT_NS_CERT_TYPE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002428 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002429 ret = mbedtls_snprintf( p, n, "\n%scert. type : ", prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002430 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02002431
Hanno Becker5226c532019-02-27 17:38:40 +00002432 if( ( ret = x509_info_cert_type( &p, &n, frame.ns_cert_type ) ) != 0 )
Manuel Pégourié-Gonnard919f8f52014-04-01 13:01:11 +02002433 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002434 }
2435
Hanno Becker5226c532019-02-27 17:38:40 +00002436 if( frame.ext_types & MBEDTLS_X509_EXT_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002437 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002438 ret = mbedtls_snprintf( p, n, "\n%skey usage : ", prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002439 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02002440
Hanno Becker5226c532019-02-27 17:38:40 +00002441 if( ( ret = x509_info_key_usage( &p, &n, frame.key_usage ) ) != 0 )
Manuel Pégourié-Gonnard65c2ddc2014-04-01 14:12:11 +02002442 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002443 }
2444
Hanno Becker5226c532019-02-27 17:38:40 +00002445 if( frame.ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE )
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002446 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002447 ret = mbedtls_snprintf( p, n, "\n%sext key usage : ", prefix );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002448 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002449
2450 if( ( ret = x509_info_ext_key_usage( &p, &n,
Hanno Becker5226c532019-02-27 17:38:40 +00002451 ext_key_usage ) ) != 0 )
Manuel Pégourié-Gonnardf6f4ab42014-04-01 17:32:44 +02002452 return( ret );
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002453 }
2454
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002455 ret = mbedtls_snprintf( p, n, "\n" );
Hanno Becker54f1c2c2019-05-13 11:58:47 +01002456 MBEDTLS_X509_SAFE_SNPRINTF_WITH_CLEANUP;
Manuel Pégourié-Gonnardb28487d2014-04-01 12:19:09 +02002457
Hanno Becker4f869ed2019-02-24 16:47:57 +00002458 ret = (int) ( size - n );
2459
2460cleanup:
2461
Hanno Becker4f869ed2019-02-24 16:47:57 +00002462 x509_crt_free_sig_info( &sig_info );
Hanno Becker5226c532019-02-27 17:38:40 +00002463 mbedtls_pk_free( &pk );
2464 mbedtls_x509_name_free( issuer );
2465 mbedtls_x509_name_free( subject );
2466 mbedtls_x509_sequence_free( ext_key_usage );
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002467#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Becker5226c532019-02-27 17:38:40 +00002468 mbedtls_x509_sequence_free( subject_alt_names );
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03002469#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Hanno Becker4f869ed2019-02-24 16:47:57 +00002470
2471 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002472}
2473
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002474struct x509_crt_verify_string {
2475 int code;
2476 const char *string;
2477};
2478
2479static const struct x509_crt_verify_string x509_crt_verify_strings[] = {
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002480 { MBEDTLS_X509_BADCERT_EXPIRED, "The certificate validity has expired" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002481 { MBEDTLS_X509_BADCERT_REVOKED, "The certificate has been revoked (is on a CRL)" },
2482 { MBEDTLS_X509_BADCERT_CN_MISMATCH, "The certificate Common Name (CN) does not match with the expected CN" },
2483 { MBEDTLS_X509_BADCERT_NOT_TRUSTED, "The certificate is not correctly signed by the trusted CA" },
2484 { MBEDTLS_X509_BADCRL_NOT_TRUSTED, "The CRL is not correctly signed by the trusted CA" },
2485 { MBEDTLS_X509_BADCRL_EXPIRED, "The CRL is expired" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002486 { MBEDTLS_X509_BADCERT_MISSING, "Certificate was missing" },
2487 { MBEDTLS_X509_BADCERT_SKIP_VERIFY, "Certificate verification was skipped" },
2488 { MBEDTLS_X509_BADCERT_OTHER, "Other reason (can be used by verify callback)" },
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002489 { MBEDTLS_X509_BADCERT_FUTURE, "The certificate validity starts in the future" },
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002490 { MBEDTLS_X509_BADCRL_FUTURE, "The CRL is from the future" },
2491 { MBEDTLS_X509_BADCERT_KEY_USAGE, "Usage does not match the keyUsage extension" },
2492 { MBEDTLS_X509_BADCERT_EXT_KEY_USAGE, "Usage does not match the extendedKeyUsage extension" },
2493 { MBEDTLS_X509_BADCERT_NS_CERT_TYPE, "Usage does not match the nsCertType extension" },
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002494 { MBEDTLS_X509_BADCERT_BAD_MD, "The certificate is signed with an unacceptable hash." },
2495 { MBEDTLS_X509_BADCERT_BAD_PK, "The certificate is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
2496 { MBEDTLS_X509_BADCERT_BAD_KEY, "The certificate is signed with an unacceptable key (eg bad curve, RSA too short)." },
2497 { MBEDTLS_X509_BADCRL_BAD_MD, "The CRL is signed with an unacceptable hash." },
2498 { MBEDTLS_X509_BADCRL_BAD_PK, "The CRL is signed with an unacceptable PK alg (eg RSA vs ECDSA)." },
2499 { 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 +01002500 { 0, NULL }
2501};
2502
2503int mbedtls_x509_crt_verify_info( char *buf, size_t size, const char *prefix,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02002504 uint32_t flags )
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002505{
2506 int ret;
2507 const struct x509_crt_verify_string *cur;
2508 char *p = buf;
2509 size_t n = size;
2510
2511 for( cur = x509_crt_verify_strings; cur->string != NULL ; cur++ )
2512 {
2513 if( ( flags & cur->code ) == 0 )
2514 continue;
2515
2516 ret = mbedtls_snprintf( p, n, "%s%s\n", prefix, cur->string );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02002517 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002518 flags ^= cur->code;
2519 }
2520
2521 if( flags != 0 )
2522 {
2523 ret = mbedtls_snprintf( p, n, "%sUnknown reason "
2524 "(this should not happen)\n", prefix );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02002525 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002526 }
2527
2528 return( (int) ( size - n ) );
2529}
Hanno Becker02a21932019-06-10 15:08:43 +01002530#endif /* !MBEDTLS_X509_REMOVE_INFO */
Manuel Pégourié-Gonnardb5f48ad2015-04-20 10:38:13 +01002531
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002532#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Hanno Becker45eedf12019-02-25 13:55:33 +00002533static int x509_crt_check_key_usage_frame( const mbedtls_x509_crt_frame *crt,
2534 unsigned int usage )
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02002535{
Manuel Pégourié-Gonnard655a9642015-06-23 10:48:44 +02002536 unsigned int usage_must, usage_may;
2537 unsigned int may_mask = MBEDTLS_X509_KU_ENCIPHER_ONLY
2538 | MBEDTLS_X509_KU_DECIPHER_ONLY;
2539
2540 if( ( crt->ext_types & MBEDTLS_X509_EXT_KEY_USAGE ) == 0 )
2541 return( 0 );
2542
2543 usage_must = usage & ~may_mask;
2544
2545 if( ( ( crt->key_usage & ~may_mask ) & usage_must ) != usage_must )
2546 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
2547
2548 usage_may = usage & may_mask;
2549
2550 if( ( ( crt->key_usage & may_mask ) | usage_may ) != usage_may )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002551 return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02002552
2553 return( 0 );
2554}
Hanno Becker45eedf12019-02-25 13:55:33 +00002555
2556int mbedtls_x509_crt_check_key_usage( const mbedtls_x509_crt *crt,
2557 unsigned int usage )
2558{
2559 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +01002560 mbedtls_x509_crt_frame const *frame;
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00002561 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Hanno Becker45eedf12019-02-25 13:55:33 +00002562 if( ret != 0 )
2563 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2564
2565 ret = x509_crt_check_key_usage_frame( frame, usage );
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00002566 mbedtls_x509_crt_frame_release( crt );
Hanno Becker45eedf12019-02-25 13:55:33 +00002567
2568 return( ret );
2569}
Manuel Pégourié-Gonnard603116c2014-04-09 09:50:03 +02002570#endif
2571
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002572#if defined(MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE)
Hanno Beckerc7c638e2019-02-21 21:10:51 +00002573typedef struct
2574{
2575 const char *oid;
2576 size_t oid_len;
2577} x509_crt_check_ext_key_usage_cb_ctx_t;
2578
2579static int x509_crt_check_ext_key_usage_cb( void *ctx,
2580 int tag,
2581 unsigned char *data,
2582 size_t data_len )
2583{
2584 x509_crt_check_ext_key_usage_cb_ctx_t *cb_ctx =
2585 (x509_crt_check_ext_key_usage_cb_ctx_t *) ctx;
2586 ((void) tag);
2587
2588 if( MBEDTLS_OID_CMP_RAW( MBEDTLS_OID_ANY_EXTENDED_KEY_USAGE,
2589 data, data_len ) == 0 )
2590 {
2591 return( 1 );
2592 }
2593
2594 if( data_len == cb_ctx->oid_len && memcmp( data, cb_ctx->oid,
2595 data_len ) == 0 )
2596 {
2597 return( 1 );
2598 }
2599
2600 return( 0 );
2601}
2602
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002603int mbedtls_x509_crt_check_extended_key_usage( const mbedtls_x509_crt *crt,
Hanno Beckere1956af2019-02-21 14:28:12 +00002604 const char *usage_oid,
2605 size_t usage_len )
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002606{
Hanno Beckere1956af2019-02-21 14:28:12 +00002607 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +01002608 mbedtls_x509_crt_frame const *frame;
Hanno Beckere1956af2019-02-21 14:28:12 +00002609 unsigned ext_types;
2610 unsigned char *p, *end;
Hanno Beckerc7c638e2019-02-21 21:10:51 +00002611 x509_crt_check_ext_key_usage_cb_ctx_t cb_ctx = { usage_oid, usage_len };
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002612
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002613 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Hanno Beckere9718b42019-02-25 18:11:42 +00002614 if( ret != 0 )
2615 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2616
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002617 /* Extension is not mandatory, absent means no restriction */
Hanno Beckere9718b42019-02-25 18:11:42 +00002618 ext_types = frame->ext_types;
2619 if( ( ext_types & MBEDTLS_X509_EXT_EXTENDED_KEY_USAGE ) != 0 )
2620 {
2621 p = frame->ext_key_usage_raw.p;
2622 end = p + frame->ext_key_usage_raw.len;
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002623
Hanno Beckere9718b42019-02-25 18:11:42 +00002624 ret = mbedtls_asn1_traverse_sequence_of( &p, end,
2625 0xFF, MBEDTLS_ASN1_OID, 0, 0,
2626 x509_crt_check_ext_key_usage_cb,
2627 &cb_ctx );
2628 if( ret == 1 )
2629 ret = 0;
2630 else
2631 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
2632 }
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002633
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00002634 mbedtls_x509_crt_frame_release( crt );
Hanno Beckere9718b42019-02-25 18:11:42 +00002635 return( ret );
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002636}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002637#endif /* MBEDTLS_X509_CHECK_EXTENDED_KEY_USAGE */
Manuel Pégourié-Gonnard7afb8a02014-04-10 17:53:56 +02002638
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002639#if defined(MBEDTLS_X509_CRL_PARSE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002640/*
2641 * Return 1 if the certificate is revoked, or 0 otherwise.
2642 */
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002643static int x509_serial_is_revoked( unsigned char const *serial,
2644 size_t serial_len,
2645 const mbedtls_x509_crl *crl )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002646{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002647 const mbedtls_x509_crl_entry *cur = &crl->entry;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002648
2649 while( cur != NULL && cur->serial.len != 0 )
2650 {
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002651 if( serial_len == cur->serial.len &&
2652 memcmp( serial, cur->serial.p, serial_len ) == 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002653 {
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01002654 if( mbedtls_x509_time_is_past( &cur->revocation_date ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002655 return( 1 );
2656 }
2657
2658 cur = cur->next;
2659 }
2660
2661 return( 0 );
2662}
2663
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002664int mbedtls_x509_crt_is_revoked( const mbedtls_x509_crt *crt,
2665 const mbedtls_x509_crl *crl )
2666{
Hanno Becker79ae5b62019-02-25 18:12:00 +00002667 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +01002668 mbedtls_x509_crt_frame const *frame;
Hanno Becker79ae5b62019-02-25 18:12:00 +00002669
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002670 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Hanno Becker79ae5b62019-02-25 18:12:00 +00002671 if( ret != 0 )
2672 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2673
2674 ret = x509_serial_is_revoked( frame->serial.p,
2675 frame->serial.len,
2676 crl );
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00002677 mbedtls_x509_crt_frame_release( crt );
Hanno Becker79ae5b62019-02-25 18:12:00 +00002678 return( ret );
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002679}
2680
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002681/*
Manuel Pégourié-Gonnardeeef9472016-02-22 11:36:55 +01002682 * Check that the given certificate is not revoked according to the CRL.
Manuel Pégourié-Gonnard08eacec2017-10-18 14:20:24 +02002683 * Skip validation if no CRL for the given CA is present.
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002684 */
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002685static int x509_crt_verifycrl( unsigned char *crt_serial,
2686 size_t crt_serial_len,
Hanno Beckerbb266132019-02-25 18:12:46 +00002687 mbedtls_x509_crt *ca_crt,
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002688 mbedtls_x509_crl *crl_list,
2689 const mbedtls_x509_crt_profile *profile )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002690{
Hanno Beckerbb266132019-02-25 18:12:46 +00002691 int ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002692 int flags = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002693 unsigned char hash[MBEDTLS_MD_MAX_SIZE];
2694 const mbedtls_md_info_t *md_info;
Hanno Beckerbb266132019-02-25 18:12:46 +00002695 mbedtls_x509_buf_raw ca_subject;
2696 mbedtls_pk_context *pk;
2697 int can_sign;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002698
Hanno Beckerbb266132019-02-25 18:12:46 +00002699 if( ca_crt == NULL )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002700 return( flags );
2701
Hanno Beckerbb266132019-02-25 18:12:46 +00002702 {
Hanno Becker5f268b32019-05-20 16:26:34 +01002703 mbedtls_x509_crt_frame const *ca;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002704 ret = mbedtls_x509_crt_frame_acquire( ca_crt, &ca );
Hanno Beckerbb266132019-02-25 18:12:46 +00002705 if( ret != 0 )
2706 return( MBEDTLS_X509_BADCRL_NOT_TRUSTED );
2707
2708 ca_subject = ca->subject_raw;
2709
2710 can_sign = 0;
2711 if( x509_crt_check_key_usage_frame( ca,
2712 MBEDTLS_X509_KU_CRL_SIGN ) == 0 )
2713 {
2714 can_sign = 1;
2715 }
2716
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00002717 mbedtls_x509_crt_frame_release( ca_crt );
Hanno Beckerbb266132019-02-25 18:12:46 +00002718 }
2719
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002720 ret = mbedtls_x509_crt_pk_acquire( ca_crt, &pk );
Hanno Beckerbb266132019-02-25 18:12:46 +00002721 if( ret != 0 )
2722 return( MBEDTLS_X509_BADCRL_NOT_TRUSTED );
2723
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002724 while( crl_list != NULL )
2725 {
2726 if( crl_list->version == 0 ||
Hanno Becker1e11f212019-03-04 14:43:43 +00002727 mbedtls_x509_name_cmp_raw( &crl_list->issuer_raw,
Hanno Beckerbb266132019-02-25 18:12:46 +00002728 &ca_subject, NULL, NULL ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002729 {
2730 crl_list = crl_list->next;
2731 continue;
2732 }
2733
2734 /*
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02002735 * Check if the CA is configured to sign CRLs
2736 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002737#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Hanno Beckerbb266132019-02-25 18:12:46 +00002738 if( !can_sign )
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02002739 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002740 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Manuel Pégourié-Gonnard99d4f192014-04-08 15:10:07 +02002741 break;
2742 }
2743#endif
2744
2745 /*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002746 * Check if CRL is correctly signed by the trusted CA
2747 */
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02002748 if( x509_profile_check_md_alg( profile, crl_list->sig_md ) != 0 )
2749 flags |= MBEDTLS_X509_BADCRL_BAD_MD;
2750
2751 if( x509_profile_check_pk_alg( profile, crl_list->sig_pk ) != 0 )
2752 flags |= MBEDTLS_X509_BADCRL_BAD_PK;
2753
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002754 md_info = mbedtls_md_info_from_type( crl_list->sig_md );
Manuel Pégourié-Gonnard329e78c2017-06-26 12:22:17 +02002755 if( mbedtls_md( md_info, crl_list->tbs.p, crl_list->tbs.len, hash ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002756 {
Manuel Pégourié-Gonnard329e78c2017-06-26 12:22:17 +02002757 /* Note: this can't happen except after an internal error */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002758 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002759 break;
2760 }
2761
Hanno Beckerbb266132019-02-25 18:12:46 +00002762 if( x509_profile_check_key( profile, pk ) != 0 )
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02002763 flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02002764
Hanno Beckerbb266132019-02-25 18:12:46 +00002765 if( mbedtls_pk_verify_ext( crl_list->sig_pk, crl_list->sig_opts, pk,
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002766 crl_list->sig_md, hash, mbedtls_md_get_size( md_info ),
Manuel Pégourié-Gonnard53882022014-06-05 17:53:52 +02002767 crl_list->sig.p, crl_list->sig.len ) != 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002768 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002769 flags |= MBEDTLS_X509_BADCRL_NOT_TRUSTED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002770 break;
2771 }
2772
2773 /*
2774 * Check for validity of CRL (Do not drop out)
2775 */
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01002776 if( mbedtls_x509_time_is_past( &crl_list->next_update ) )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002777 flags |= MBEDTLS_X509_BADCRL_EXPIRED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002778
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01002779 if( mbedtls_x509_time_is_future( &crl_list->this_update ) )
Manuel Pégourié-Gonnarde6028c92015-04-20 12:19:02 +01002780 flags |= MBEDTLS_X509_BADCRL_FUTURE;
Manuel Pégourié-Gonnard95337652014-03-10 13:15:18 +01002781
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002782 /*
2783 * Check if certificate is revoked
2784 */
Hanno Beckerc84fd1c2019-02-22 15:01:03 +00002785 if( x509_serial_is_revoked( crt_serial, crt_serial_len,
2786 crl_list ) )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002787 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002788 flags |= MBEDTLS_X509_BADCERT_REVOKED;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002789 break;
2790 }
2791
2792 crl_list = crl_list->next;
2793 }
Manuel Pégourié-Gonnardcbb1f6e2015-06-15 16:17:55 +02002794
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00002795 mbedtls_x509_crt_pk_release( ca_crt );
Paul Bakkerd8bb8262014-06-17 14:06:49 +02002796 return( flags );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002797}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002798#endif /* MBEDTLS_X509_CRL_PARSE_C */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02002799
Manuel Pégourié-Gonnard88421242014-10-17 11:36:18 +02002800/*
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002801 * Check the signature of a certificate by its parent
2802 */
Hanno Becker5299cf82019-02-25 13:50:41 +00002803static int x509_crt_check_signature( const mbedtls_x509_crt_sig_info *sig_info,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002804 mbedtls_x509_crt *parent,
2805 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002806{
Hanno Beckere449e2d2019-02-25 14:45:31 +00002807 int ret;
2808 mbedtls_pk_context *pk;
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002809
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002810 ret = mbedtls_x509_crt_pk_acquire( parent, &pk );
Hanno Beckere449e2d2019-02-25 14:45:31 +00002811 if( ret != 0 )
2812 return( MBEDTLS_ERR_X509_FATAL_ERROR );
2813
2814 /* Skip expensive computation on obvious mismatch */
2815 if( ! mbedtls_pk_can_do( pk, sig_info->sig_pk ) )
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002816 {
Hanno Beckere449e2d2019-02-25 14:45:31 +00002817 ret = -1;
2818 goto exit;
2819 }
2820
2821#if !( defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE) )
2822 ((void) rs_ctx);
2823#else
2824 if( rs_ctx != NULL && sig_info->sig_pk == MBEDTLS_PK_ECDSA )
2825 {
2826 ret = mbedtls_pk_verify_restartable( pk,
Hanno Becker5299cf82019-02-25 13:50:41 +00002827 sig_info->sig_md,
2828 sig_info->crt_hash, sig_info->crt_hash_len,
2829 sig_info->sig.p, sig_info->sig.len,
Hanno Beckere449e2d2019-02-25 14:45:31 +00002830 &rs_ctx->pk );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002831 }
Hanno Beckere449e2d2019-02-25 14:45:31 +00002832 else
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002833#endif
Hanno Beckere449e2d2019-02-25 14:45:31 +00002834 {
2835 ret = mbedtls_pk_verify_ext( sig_info->sig_pk,
2836 sig_info->sig_opts,
2837 pk,
2838 sig_info->sig_md,
2839 sig_info->crt_hash, sig_info->crt_hash_len,
2840 sig_info->sig.p, sig_info->sig.len );
2841 }
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002842
Hanno Beckere449e2d2019-02-25 14:45:31 +00002843exit:
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00002844 mbedtls_x509_crt_pk_release( parent );
Hanno Beckere449e2d2019-02-25 14:45:31 +00002845 return( ret );
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02002846}
2847
2848/*
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002849 * Check if 'parent' is a suitable parent (signing CA) for 'child'.
2850 * Return 0 if yes, -1 if not.
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002851 *
2852 * top means parent is a locally-trusted certificate
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002853 */
Hanno Becker43bf9002019-02-25 14:46:49 +00002854static int x509_crt_check_parent( const mbedtls_x509_crt_sig_info *sig_info,
2855 const mbedtls_x509_crt_frame *parent,
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02002856 int top )
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002857{
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002858 int need_ca_bit;
2859
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02002860 /* Parent must be the issuer */
Hanno Becker43bf9002019-02-25 14:46:49 +00002861 if( mbedtls_x509_name_cmp_raw( &sig_info->issuer_raw,
2862 &parent->subject_raw,
Hanno Becker67284cc2019-02-21 14:31:51 +00002863 NULL, NULL ) != 0 )
Hanno Becker7dee12a2019-02-21 13:58:38 +00002864 {
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002865 return( -1 );
Hanno Becker7dee12a2019-02-21 13:58:38 +00002866 }
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002867
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002868 /* Parent must have the basicConstraints CA bit set as a general rule */
2869 need_ca_bit = 1;
2870
2871 /* Exception: v1/v2 certificates that are locally trusted. */
2872 if( top && parent->version < 3 )
2873 need_ca_bit = 0;
2874
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002875 if( need_ca_bit && ! parent->ca_istrue )
2876 return( -1 );
2877
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02002878#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
Manuel Pégourié-Gonnardd249b7a2014-06-24 11:49:16 +02002879 if( need_ca_bit &&
Hanno Becker43bf9002019-02-25 14:46:49 +00002880 x509_crt_check_key_usage_frame( parent,
2881 MBEDTLS_X509_KU_KEY_CERT_SIGN ) != 0 )
Manuel Pégourié-Gonnardc4eff162014-06-19 12:18:08 +02002882 {
2883 return( -1 );
2884 }
Manuel Pégourié-Gonnard312010e2014-04-09 14:30:11 +02002885#endif
2886
2887 return( 0 );
Manuel Pégourié-Gonnard3fed0b32014-04-08 13:18:01 +02002888}
2889
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02002890/*
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002891 * Find a suitable parent for child in candidates, or return NULL.
2892 *
2893 * Here suitable is defined as:
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002894 * 1. subject name matches child's issuer
2895 * 2. if necessary, the CA bit is set and key usage allows signing certs
2896 * 3. for trusted roots, the signature is correct
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02002897 * (for intermediates, the signature is checked and the result reported)
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002898 * 4. pathlen constraints are satisfied
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002899 *
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02002900 * If there's a suitable candidate which is also time-valid, return the first
2901 * such. Otherwise, return the first suitable candidate (or NULL if there is
2902 * none).
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02002903 *
2904 * The rationale for this rule is that someone could have a list of trusted
2905 * roots with two versions on the same root with different validity periods.
2906 * (At least one user reported having such a list and wanted it to just work.)
2907 * The reason we don't just require time-validity is that generally there is
2908 * only one version, and if it's expired we want the flags to state that
2909 * rather than NOT_TRUSTED, as would be the case if we required it here.
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02002910 *
2911 * The rationale for rule 3 (signature for trusted roots) is that users might
2912 * have two versions of the same CA with different keys in their list, and the
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02002913 * way we select the correct one is by checking the signature (as we don't
2914 * rely on key identifier extensions). (This is one way users might choose to
2915 * handle key rollover, another relies on self-issued certs, see [SIRO].)
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02002916 *
2917 * Arguments:
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002918 * - [in] child: certificate for which we're looking for a parent
2919 * - [in] candidates: chained list of potential parents
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002920 * - [out] r_parent: parent found (or NULL)
2921 * - [out] r_signature_is_good: 1 if child signature by parent is valid, or 0
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002922 * - [in] top: 1 if candidates consists of trusted roots, ie we're at the top
2923 * of the chain, 0 otherwise
2924 * - [in] path_cnt: number of intermediates seen so far
2925 * - [in] self_cnt: number of self-signed intermediates seen so far
2926 * (will never be greater than path_cnt)
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002927 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01002928 *
2929 * Return value:
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02002930 * - 0 on success
2931 * - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002932 */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002933static int x509_crt_find_parent_in(
Hanno Becker5299cf82019-02-25 13:50:41 +00002934 mbedtls_x509_crt_sig_info const *child_sig,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002935 mbedtls_x509_crt *candidates,
2936 mbedtls_x509_crt **r_parent,
2937 int *r_signature_is_good,
2938 int top,
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02002939 unsigned path_cnt,
2940 unsigned self_cnt,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002941 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002942{
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02002943 int ret;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01002944 mbedtls_x509_crt *parent_crt;
2945 int signature_is_good;
2946
2947#if defined(MBEDTLS_HAVE_TIME_DATE)
2948 mbedtls_x509_crt *fallback_parent;
2949 int fallback_signature_is_good;
2950#endif /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002951
2952#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002953 /* did we have something in progress? */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002954 if( rs_ctx != NULL && rs_ctx->parent != NULL )
2955 {
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002956 /* restore saved state */
Hanno Becker43bf9002019-02-25 14:46:49 +00002957 parent_crt = rs_ctx->parent;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01002958#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002959 fallback_parent = rs_ctx->fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002960 fallback_signature_is_good = rs_ctx->fallback_signature_is_good;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01002961#endif /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002962
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002963 /* clear saved state */
2964 rs_ctx->parent = NULL;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01002965#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002966 rs_ctx->fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002967 rs_ctx->fallback_signature_is_good = 0;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01002968#endif /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02002969
2970 /* resume where we left */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002971 goto check_signature;
2972 }
2973#endif
2974
Hanno Becker6f61b7b2019-06-10 11:12:33 +01002975#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002976 fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02002977 fallback_signature_is_good = 0;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01002978#endif /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002979
Hanno Becker43bf9002019-02-25 14:46:49 +00002980 for( parent_crt = candidates; parent_crt != NULL;
2981 parent_crt = parent_crt->next )
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002982 {
Hanno Beckera788cab2019-02-24 17:47:46 +00002983 int parent_valid, parent_match, path_len_ok;
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02002984
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02002985#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
2986check_signature:
2987#endif
Hanno Beckera788cab2019-02-24 17:47:46 +00002988
2989 parent_valid = parent_match = path_len_ok = 0;
Hanno Beckera788cab2019-02-24 17:47:46 +00002990 {
Hanno Becker5f268b32019-05-20 16:26:34 +01002991 mbedtls_x509_crt_frame const *parent;
Hanno Beckera788cab2019-02-24 17:47:46 +00002992
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00002993 ret = mbedtls_x509_crt_frame_acquire( parent_crt, &parent );
Hanno Becker43bf9002019-02-25 14:46:49 +00002994 if( ret != 0 )
2995 return( MBEDTLS_ERR_X509_FATAL_ERROR );
Hanno Beckera788cab2019-02-24 17:47:46 +00002996
Hanno Becker843b71a2019-06-25 09:39:21 +01002997#if !defined(MBEDTLS_X509_CRT_REMOVE_TIME)
Hanno Becker040c5642019-06-10 11:14:24 +01002998 if( !mbedtls_x509_time_is_past( &parent->valid_to ) &&
2999 !mbedtls_x509_time_is_future( &parent->valid_from ) )
Manuel Pégourié-Gonnardf1358ac2019-07-30 16:03:06 +02003000#endif /* !MBEDTLS_X509_CRT_REMOVE_TIME */
Hanno Becker43bf9002019-02-25 14:46:49 +00003001 {
3002 parent_valid = 1;
3003 }
3004
3005 /* basic parenting skills (name, CA bit, key usage) */
3006 if( x509_crt_check_parent( child_sig, parent, top ) == 0 )
3007 parent_match = 1;
3008
3009 /* +1 because the stored max_pathlen is 1 higher
3010 * than the actual value */
3011 if( !( parent->max_pathlen > 0 &&
3012 (size_t) parent->max_pathlen < 1 + path_cnt - self_cnt ) )
3013 {
3014 path_len_ok = 1;
3015 }
3016
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00003017 mbedtls_x509_crt_frame_release( parent_crt );
Hanno Beckera788cab2019-02-24 17:47:46 +00003018 }
3019
3020 if( parent_match == 0 || path_len_ok == 0 )
3021 continue;
3022
3023 /* Signature */
Hanno Becker43bf9002019-02-25 14:46:49 +00003024 ret = x509_crt_check_signature( child_sig, parent_crt, rs_ctx );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003025
3026#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003027 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
3028 {
3029 /* save state */
Hanno Becker43bf9002019-02-25 14:46:49 +00003030 rs_ctx->parent = parent_crt;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003031#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003032 rs_ctx->fallback_parent = fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02003033 rs_ctx->fallback_signature_is_good = fallback_signature_is_good;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003034#endif /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003035
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003036 return( ret );
3037 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003038#else
3039 (void) ret;
3040#endif
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003041
3042 signature_is_good = ret == 0;
3043 if( top && ! signature_is_good )
Manuel Pégourié-Gonnardf82a4d52017-07-03 19:26:25 +02003044 continue;
Manuel Pégourié-Gonnard2f09d592017-07-03 18:30:43 +02003045
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02003046 /* optional time check */
Hanno Beckera788cab2019-02-24 17:47:46 +00003047 if( !parent_valid )
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02003048 {
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003049#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003050 if( fallback_parent == NULL )
3051 {
Hanno Becker43bf9002019-02-25 14:46:49 +00003052 fallback_parent = parent_crt;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02003053 fallback_signature_is_good = signature_is_good;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003054 }
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003055#endif /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02003056
3057 continue;
3058 }
3059
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02003060 break;
3061 }
3062
Hanno Becker43bf9002019-02-25 14:46:49 +00003063 if( parent_crt != NULL )
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003064 {
Hanno Becker43bf9002019-02-25 14:46:49 +00003065 *r_parent = parent_crt;
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003066 *r_signature_is_good = signature_is_good;
3067 }
3068 else
3069 {
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003070#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003071 *r_parent = fallback_parent;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02003072 *r_signature_is_good = fallback_signature_is_good;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003073#else /* MBEDTLS_HAVE_TIME_DATE */
3074 *r_parent = NULL;
3075#endif /* !MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003076 }
Manuel Pégourié-Gonnard3e329b82017-06-29 12:55:27 +02003077
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003078 return( 0 );
Manuel Pégourié-Gonnard2f1c33d2017-06-29 12:27:23 +02003079}
3080
3081/*
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003082 * Find a parent in trusted CAs or the provided chain, or return NULL.
3083 *
3084 * Searches in trusted CAs first, and return the first suitable parent found
3085 * (see find_parent_in() for definition of suitable).
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02003086 *
3087 * Arguments:
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01003088 * - [in] child: certificate for which we're looking for a parent, followed
3089 * by a chain of possible intermediates
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02003090 * - [in] trust_ca: list of locally trusted certificates
3091 * - [out] parent: parent found (or NULL)
3092 * - [out] parent_is_trusted: 1 if returned `parent` is trusted, or 0
3093 * - [out] signature_is_good: 1 if child signature by parent is valid, or 0
3094 * - [in] path_cnt: number of links in the chain so far (EE -> ... -> child)
3095 * - [in] self_cnt: number of self-signed certs in the chain so far
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01003096 * (will always be no greater than path_cnt)
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02003097 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnarde57d7432018-03-07 10:00:57 +01003098 *
3099 * Return value:
Manuel Pégourié-Gonnardda19f4c2018-06-12 12:40:54 +02003100 * - 0 on success
3101 * - MBEDTLS_ERR_ECP_IN_PROGRESS otherwise
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003102 */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003103static int x509_crt_find_parent(
Hanno Becker5299cf82019-02-25 13:50:41 +00003104 mbedtls_x509_crt_sig_info const *child_sig,
Hanno Becker1e0677a2019-02-25 14:58:22 +00003105 mbedtls_x509_crt *rest,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003106 mbedtls_x509_crt *trust_ca,
3107 mbedtls_x509_crt **parent,
3108 int *parent_is_trusted,
3109 int *signature_is_good,
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02003110 unsigned path_cnt,
3111 unsigned self_cnt,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003112 mbedtls_x509_crt_restart_ctx *rs_ctx )
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003113{
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003114 int ret;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003115 mbedtls_x509_crt *search_list;
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003116
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003117 *parent_is_trusted = 1;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003118
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003119#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02003120 /* restore then clear saved state if we have some stored */
3121 if( rs_ctx != NULL && rs_ctx->parent_is_trusted != -1 )
3122 {
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003123 *parent_is_trusted = rs_ctx->parent_is_trusted;
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02003124 rs_ctx->parent_is_trusted = -1;
3125 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003126#endif
3127
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003128 while( 1 ) {
Hanno Becker1e0677a2019-02-25 14:58:22 +00003129 search_list = *parent_is_trusted ? trust_ca : rest;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003130
Hanno Becker5299cf82019-02-25 13:50:41 +00003131 ret = x509_crt_find_parent_in( child_sig, search_list,
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003132 parent, signature_is_good,
3133 *parent_is_trusted,
3134 path_cnt, self_cnt, rs_ctx );
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003135
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003136#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003137 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
3138 {
3139 /* save state */
3140 rs_ctx->parent_is_trusted = *parent_is_trusted;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003141 return( ret );
3142 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003143#else
3144 (void) ret;
3145#endif
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003146
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003147 /* stop here if found or already in second iteration */
3148 if( *parent != NULL || *parent_is_trusted == 0 )
3149 break;
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003150
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003151 /* prepare second iteration */
3152 *parent_is_trusted = 0;
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003153 }
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003154
3155 /* extra precaution against mistakes in the caller */
Krzysztof Stachowiakc388a8c2018-10-31 16:49:20 +01003156 if( *parent == NULL )
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003157 {
Manuel Pégourié-Gonnarda5a3e402018-10-16 11:27:23 +02003158 *parent_is_trusted = 0;
3159 *signature_is_good = 0;
Manuel Pégourié-Gonnard18547b52017-08-14 16:11:43 +02003160 }
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003161
3162 return( 0 );
Manuel Pégourié-Gonnard63686122017-07-04 01:01:39 +02003163}
3164
3165/*
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02003166 * Check if an end-entity certificate is locally trusted
3167 *
3168 * Currently we require such certificates to be self-signed (actually only
3169 * check for self-issued as self-signatures are not checked)
3170 */
3171static int x509_crt_check_ee_locally_trusted(
Hanno Becker1e0677a2019-02-25 14:58:22 +00003172 mbedtls_x509_crt_frame const *crt,
3173 mbedtls_x509_crt const *trust_ca )
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02003174{
Hanno Becker1e0677a2019-02-25 14:58:22 +00003175 mbedtls_x509_crt const *cur;
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02003176
Manuel Pégourié-Gonnard27e94792017-07-04 00:49:31 +02003177 /* look for an exact match with trusted cert */
3178 for( cur = trust_ca; cur != NULL; cur = cur->next )
3179 {
3180 if( crt->raw.len == cur->raw.len &&
3181 memcmp( crt->raw.p, cur->raw.p, crt->raw.len ) == 0 )
3182 {
3183 return( 0 );
3184 }
3185 }
3186
3187 /* too bad */
3188 return( -1 );
3189}
3190
3191/*
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02003192 * Build and verify a certificate chain
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02003193 *
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02003194 * Given a peer-provided list of certificates EE, C1, ..., Cn and
3195 * a list of trusted certs R1, ... Rp, try to build and verify a chain
Manuel Pégourié-Gonnard562df402017-08-08 18:09:14 +02003196 * EE, Ci1, ... Ciq [, Rj]
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02003197 * such that every cert in the chain is a child of the next one,
3198 * jumping to a trusted root as early as possible.
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02003199 *
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02003200 * Verify that chain and return it with flags for all issues found.
3201 *
3202 * Special cases:
3203 * - EE == Rj -> return a one-element list containing it
3204 * - EE, Ci1, ..., Ciq cannot be continued with a trusted root
3205 * -> return that chain with NOT_TRUSTED set on Ciq
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02003206 *
Manuel Pégourié-Gonnardd19a41d2017-07-14 11:05:59 +02003207 * Tests for (aspects of) this function should include at least:
3208 * - trusted EE
3209 * - EE -> trusted root
Antonin Décimod5f47592019-01-23 15:24:37 +01003210 * - EE -> intermediate CA -> trusted root
Manuel Pégourié-Gonnardd19a41d2017-07-14 11:05:59 +02003211 * - if relevant: EE untrusted
3212 * - if relevant: EE -> intermediate, untrusted
3213 * with the aspect under test checked at each relevant level (EE, int, root).
3214 * For some aspects longer chains are required, but usually length 2 is
3215 * enough (but length 1 is not in general).
3216 *
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02003217 * Arguments:
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003218 * - [in] crt: the cert list EE, C1, ..., Cn
3219 * - [in] trust_ca: the trusted list R1, ..., Rp
3220 * - [in] ca_crl, profile: as in verify_with_profile()
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003221 * - [out] ver_chain: the built and verified chain
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02003222 * Only valid when return value is 0, may contain garbage otherwise!
3223 * Restart note: need not be the same when calling again to resume.
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02003224 * - [in-out] rs_ctx: context for restarting operations
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02003225 *
3226 * Return value:
3227 * - non-zero if the chain could not be fully built and examined
3228 * - 0 is the chain was successfully built and examined,
3229 * even if it was found to be invalid
Manuel Pégourié-Gonnard35407c72017-06-29 10:45:25 +02003230 */
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02003231static int x509_crt_verify_chain(
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003232 mbedtls_x509_crt *crt,
3233 mbedtls_x509_crt *trust_ca,
3234 mbedtls_x509_crl *ca_crl,
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003235 const mbedtls_x509_crt_profile *profile,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003236 mbedtls_x509_crt_verify_chain *ver_chain,
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003237 mbedtls_x509_crt_restart_ctx *rs_ctx )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003238{
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02003239 /* Don't initialize any of those variables here, so that the compiler can
3240 * catch potential issues with jumping ahead when restarting */
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003241 int ret;
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02003242 uint32_t *flags;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003243 mbedtls_x509_crt_verify_chain_item *cur;
Hanno Becker1e0677a2019-02-25 14:58:22 +00003244 mbedtls_x509_crt *child_crt;
Hanno Becker58c35642019-02-25 18:13:46 +00003245 mbedtls_x509_crt *parent_crt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003246 int parent_is_trusted;
3247 int child_is_trusted;
3248 int signature_is_good;
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02003249 unsigned self_cnt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003250
3251#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
3252 /* resume if we had an operation in progress */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02003253 if( rs_ctx != NULL && rs_ctx->in_progress == x509_crt_rs_find_parent )
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003254 {
Manuel Pégourié-Gonnard3627a8b2017-08-23 11:20:48 +02003255 /* restore saved state */
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02003256 *ver_chain = rs_ctx->ver_chain; /* struct copy */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02003257 self_cnt = rs_ctx->self_cnt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003258
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02003259 /* restore derived state */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003260 cur = &ver_chain->items[ver_chain->len - 1];
Hanno Becker1e0677a2019-02-25 14:58:22 +00003261 child_crt = cur->crt;
3262
3263 child_is_trusted = 0;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003264 goto find_parent;
3265 }
3266#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
Manuel Pégourié-Gonnard8f8c2822017-07-03 21:25:10 +02003267
Hanno Becker1e0677a2019-02-25 14:58:22 +00003268 child_crt = crt;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003269 self_cnt = 0;
3270 parent_is_trusted = 0;
3271 child_is_trusted = 0;
Manuel Pégourié-Gonnardf86f4912017-07-05 16:43:44 +02003272
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003273 while( 1 ) {
Hanno Becker5299cf82019-02-25 13:50:41 +00003274#if defined(MBEDTLS_X509_CRL_PARSE_C)
3275 mbedtls_x509_buf_raw child_serial;
3276#endif /* MBEDTLS_X509_CRL_PARSE_C */
3277 int self_issued;
Hanno Becker1e0677a2019-02-25 14:58:22 +00003278
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003279 /* Add certificate to the verification chain */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003280 cur = &ver_chain->items[ver_chain->len];
Hanno Becker1e0677a2019-02-25 14:58:22 +00003281 cur->crt = child_crt;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003282 cur->flags = 0;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003283 ver_chain->len++;
Hanno Becker10e6b9b2019-02-22 17:56:43 +00003284
3285#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
3286find_parent:
3287#endif
3288
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003289 flags = &cur->flags;
Manuel Pégourié-Gonnard66fac752017-07-03 21:39:21 +02003290
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003291 {
Hanno Becker5299cf82019-02-25 13:50:41 +00003292 mbedtls_x509_crt_sig_info child_sig;
3293 {
Hanno Becker5f268b32019-05-20 16:26:34 +01003294 mbedtls_x509_crt_frame const *child;
Manuel Pégourié-Gonnard8f8c2822017-07-03 21:25:10 +02003295
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003296 ret = mbedtls_x509_crt_frame_acquire( child_crt, &child );
Hanno Becker5299cf82019-02-25 13:50:41 +00003297 if( ret != 0 )
3298 return( MBEDTLS_ERR_X509_FATAL_ERROR );
3299
Hanno Becker843b71a2019-06-25 09:39:21 +01003300#if !defined(MBEDTLS_X509_CRT_REMOVE_TIME)
Hanno Becker5299cf82019-02-25 13:50:41 +00003301 /* Check time-validity (all certificates) */
3302 if( mbedtls_x509_time_is_past( &child->valid_to ) )
3303 *flags |= MBEDTLS_X509_BADCERT_EXPIRED;
3304 if( mbedtls_x509_time_is_future( &child->valid_from ) )
3305 *flags |= MBEDTLS_X509_BADCERT_FUTURE;
Hanno Becker843b71a2019-06-25 09:39:21 +01003306#endif /* !MBEDTLS_X509_CRT_REMOVE_TIME */
Hanno Becker5299cf82019-02-25 13:50:41 +00003307
3308 /* Stop here for trusted roots (but not for trusted EE certs) */
3309 if( child_is_trusted )
3310 {
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00003311 mbedtls_x509_crt_frame_release( child_crt );
Hanno Becker5299cf82019-02-25 13:50:41 +00003312 return( 0 );
3313 }
3314
3315 self_issued = 0;
3316 if( mbedtls_x509_name_cmp_raw( &child->issuer_raw,
3317 &child->subject_raw,
3318 NULL, NULL ) == 0 )
3319 {
3320 self_issued = 1;
3321 }
3322
3323 /* Check signature algorithm: MD & PK algs */
3324 if( x509_profile_check_md_alg( profile, child->sig_md ) != 0 )
3325 *flags |= MBEDTLS_X509_BADCERT_BAD_MD;
3326
3327 if( x509_profile_check_pk_alg( profile, child->sig_pk ) != 0 )
3328 *flags |= MBEDTLS_X509_BADCERT_BAD_PK;
3329
3330 /* Special case: EE certs that are locally trusted */
3331 if( ver_chain->len == 1 && self_issued &&
3332 x509_crt_check_ee_locally_trusted( child, trust_ca ) == 0 )
3333 {
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00003334 mbedtls_x509_crt_frame_release( child_crt );
Hanno Becker5299cf82019-02-25 13:50:41 +00003335 return( 0 );
3336 }
3337
3338#if defined(MBEDTLS_X509_CRL_PARSE_C)
3339 child_serial = child->serial;
3340#endif /* MBEDTLS_X509_CRL_PARSE_C */
3341
3342 ret = x509_crt_get_sig_info( child, &child_sig );
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00003343 mbedtls_x509_crt_frame_release( child_crt );
Hanno Becker5299cf82019-02-25 13:50:41 +00003344
Hanno Becker5299cf82019-02-25 13:50:41 +00003345 if( ret != 0 )
3346 return( MBEDTLS_ERR_X509_FATAL_ERROR );
3347 }
3348
3349 /* Look for a parent in trusted CAs or up the chain */
3350 ret = x509_crt_find_parent( &child_sig, child_crt->next,
Hanno Becker58c35642019-02-25 18:13:46 +00003351 trust_ca, &parent_crt,
Hanno Becker5299cf82019-02-25 13:50:41 +00003352 &parent_is_trusted, &signature_is_good,
3353 ver_chain->len - 1, self_cnt, rs_ctx );
3354
3355 x509_crt_free_sig_info( &child_sig );
3356 }
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003357
3358#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003359 if( rs_ctx != NULL && ret == MBEDTLS_ERR_ECP_IN_PROGRESS )
3360 {
3361 /* save state */
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02003362 rs_ctx->in_progress = x509_crt_rs_find_parent;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003363 rs_ctx->self_cnt = self_cnt;
Manuel Pégourié-Gonnarda9688432017-08-23 11:23:59 +02003364 rs_ctx->ver_chain = *ver_chain; /* struct copy */
Hanno Becker5299cf82019-02-25 13:50:41 +00003365 return( ret );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003366 }
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003367#else
3368 (void) ret;
3369#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003370
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003371 /* No parent? We're done here */
Hanno Becker58c35642019-02-25 18:13:46 +00003372 if( parent_crt == NULL )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003373 {
3374 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
Hanno Becker5299cf82019-02-25 13:50:41 +00003375 return( 0 );
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003376 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003377
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003378 /* Count intermediate self-issued (not necessarily self-signed) certs.
3379 * These can occur with some strategies for key rollover, see [SIRO],
3380 * and should be excluded from max_pathlen checks. */
Hanno Becker5299cf82019-02-25 13:50:41 +00003381 if( ver_chain->len != 1 && self_issued )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003382 self_cnt++;
Manuel Pégourié-Gonnardfd6c85c2014-11-20 16:34:20 +01003383
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003384 /* path_cnt is 0 for the first intermediate CA,
3385 * and if parent is trusted it's not an intermediate CA */
3386 if( ! parent_is_trusted &&
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003387 ver_chain->len > MBEDTLS_X509_MAX_INTERMEDIATE_CA )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003388 {
3389 /* return immediately to avoid overflow the chain array */
Hanno Becker5299cf82019-02-25 13:50:41 +00003390 return( MBEDTLS_ERR_X509_FATAL_ERROR );
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003391 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003392
Manuel Pégourié-Gonnard98a67782017-08-17 10:52:20 +02003393 /* signature was checked while searching parent */
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003394 if( ! signature_is_good )
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003395 *flags |= MBEDTLS_X509_BADCERT_NOT_TRUSTED;
3396
Hanno Becker58c35642019-02-25 18:13:46 +00003397 {
3398 mbedtls_pk_context *parent_pk;
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003399 ret = mbedtls_x509_crt_pk_acquire( parent_crt, &parent_pk );
Hanno Becker58c35642019-02-25 18:13:46 +00003400 if( ret != 0 )
3401 return( MBEDTLS_ERR_X509_FATAL_ERROR );
3402
3403 /* check size of signing key */
3404 if( x509_profile_check_key( profile, parent_pk ) != 0 )
3405 *flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
3406
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00003407 mbedtls_x509_crt_pk_release( parent_crt );
Hanno Becker58c35642019-02-25 18:13:46 +00003408 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003409
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003410#if defined(MBEDTLS_X509_CRL_PARSE_C)
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003411 /* Check trusted CA's CRL for the given crt */
Hanno Becker5299cf82019-02-25 13:50:41 +00003412 *flags |= x509_crt_verifycrl( child_serial.p,
3413 child_serial.len,
Hanno Becker58c35642019-02-25 18:13:46 +00003414 parent_crt, ca_crl, profile );
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003415#else
3416 (void) ca_crl;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003417#endif
3418
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003419 /* prepare for next iteration */
Hanno Becker58c35642019-02-25 18:13:46 +00003420 child_crt = parent_crt;
3421 parent_crt = NULL;
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003422 child_is_trusted = parent_is_trusted;
Manuel Pégourié-Gonnardbe4ff422017-07-14 12:04:14 +02003423 signature_is_good = 0;
Manuel Pégourié-Gonnardce6e52f2017-07-05 17:05:03 +02003424 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003425}
3426
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003427#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003428/*
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003429 * Check for CN match
3430 */
Hanno Becker24926222019-02-21 13:10:55 +00003431static int x509_crt_check_cn( unsigned char const *buf,
3432 size_t buflen,
3433 const char *cn,
3434 size_t cn_len )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003435{
Hanno Becker24926222019-02-21 13:10:55 +00003436 /* Try exact match */
Hanno Beckerb3def1d2019-02-22 11:46:06 +00003437 if( mbedtls_x509_memcasecmp( cn, buf, buflen, cn_len ) == 0 )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003438 return( 0 );
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003439
3440 /* try wildcard match */
Hanno Becker24926222019-02-21 13:10:55 +00003441 if( x509_check_wildcard( cn, cn_len, buf, buflen ) == 0 )
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003442 {
3443 return( 0 );
3444 }
3445
3446 return( -1 );
3447}
3448
Hanno Becker8b543b32019-02-21 11:50:44 +00003449/* Returns 1 on a match and 0 on a mismatch.
3450 * This is because this function is used as a callback for
3451 * mbedtls_x509_name_cmp_raw(), which continues the name
3452 * traversal as long as the callback returns 0. */
3453static int x509_crt_check_name( void *ctx,
3454 mbedtls_x509_buf *oid,
Hanno Becker6b378122019-02-23 10:20:14 +00003455 mbedtls_x509_buf *val,
3456 int next_merged )
Hanno Becker8b543b32019-02-21 11:50:44 +00003457{
3458 char const *cn = (char const*) ctx;
3459 size_t cn_len = strlen( cn );
Hanno Becker6b378122019-02-23 10:20:14 +00003460 ((void) next_merged);
Hanno Becker8b543b32019-02-21 11:50:44 +00003461
3462 if( MBEDTLS_OID_CMP( MBEDTLS_OID_AT_CN, oid ) == 0 &&
Hanno Becker24926222019-02-21 13:10:55 +00003463 x509_crt_check_cn( val->p, val->len, cn, cn_len ) == 0 )
Hanno Becker8b543b32019-02-21 11:50:44 +00003464 {
3465 return( 1 );
3466 }
3467
3468 return( 0 );
3469}
3470
Hanno Beckerda410822019-02-21 13:36:59 +00003471/* Returns 1 on a match and 0 on a mismatch.
3472 * This is because this function is used as a callback for
3473 * mbedtls_asn1_traverse_sequence_of(), which continues the
3474 * traversal as long as the callback returns 0. */
3475static int x509_crt_subject_alt_check_name( void *ctx,
3476 int tag,
3477 unsigned char *data,
3478 size_t data_len )
3479{
3480 char const *cn = (char const*) ctx;
3481 size_t cn_len = strlen( cn );
Hanno Becker90b94082019-02-21 21:13:21 +00003482 ((void) tag);
Hanno Beckerda410822019-02-21 13:36:59 +00003483
3484 if( x509_crt_check_cn( data, data_len, cn, cn_len ) == 0 )
3485 return( 1 );
3486
3487 return( 0 );
3488}
3489
Manuel Pégourié-Gonnarda468eb12017-07-04 01:31:59 +02003490/*
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003491 * Verify the requested CN - only call this if cn is not NULL!
3492 */
Hanno Becker082435c2019-02-25 18:14:40 +00003493static int x509_crt_verify_name( const mbedtls_x509_crt *crt,
3494 const char *cn,
3495 uint32_t *flags )
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003496{
Hanno Beckerda410822019-02-21 13:36:59 +00003497 int ret;
Hanno Becker5f268b32019-05-20 16:26:34 +01003498 mbedtls_x509_crt_frame const *frame;
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003499
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003500 ret = mbedtls_x509_crt_frame_acquire( crt, &frame );
Hanno Becker082435c2019-02-25 18:14:40 +00003501 if( ret != 0 )
3502 return( MBEDTLS_ERR_X509_FATAL_ERROR );
3503
3504 if( frame->ext_types & MBEDTLS_X509_EXT_SUBJECT_ALT_NAME )
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003505 {
Hanno Becker90b94082019-02-21 21:13:21 +00003506 unsigned char *p =
Hanno Becker082435c2019-02-25 18:14:40 +00003507 frame->subject_alt_raw.p;
Hanno Beckerda410822019-02-21 13:36:59 +00003508 const unsigned char *end =
Hanno Becker082435c2019-02-25 18:14:40 +00003509 frame->subject_alt_raw.p + frame->subject_alt_raw.len;
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003510
Hanno Becker90b94082019-02-21 21:13:21 +00003511 ret = mbedtls_asn1_traverse_sequence_of( &p, end,
3512 MBEDTLS_ASN1_TAG_CLASS_MASK,
3513 MBEDTLS_ASN1_CONTEXT_SPECIFIC,
3514 MBEDTLS_ASN1_TAG_VALUE_MASK,
3515 2 /* SubjectAlt DNS */,
3516 x509_crt_subject_alt_check_name,
Hanno Becker484caf02019-05-29 14:41:44 +01003517 (void *) cn );
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003518 }
3519 else
3520 {
Hanno Becker082435c2019-02-25 18:14:40 +00003521 ret = mbedtls_x509_name_cmp_raw( &frame->subject_raw,
3522 &frame->subject_raw,
Hanno Becker484caf02019-05-29 14:41:44 +01003523 x509_crt_check_name, (void *) cn );
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003524 }
Hanno Beckerda410822019-02-21 13:36:59 +00003525
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00003526 mbedtls_x509_crt_frame_release( crt );
Hanno Becker082435c2019-02-25 18:14:40 +00003527
3528 /* x509_crt_check_name() and x509_crt_subject_alt_check_name()
3529 * return 1 when finding a name component matching `cn`. */
3530 if( ret == 1 )
3531 return( 0 );
3532
3533 if( ret != 0 )
3534 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
3535
3536 *flags |= MBEDTLS_X509_BADCERT_CN_MISMATCH;
3537 return( ret );
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003538}
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003539#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003540
3541/*
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003542 * Merge the flags for all certs in the chain, after calling callback
3543 */
3544static int x509_crt_merge_flags_with_cb(
3545 uint32_t *flags,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003546 const mbedtls_x509_crt_verify_chain *ver_chain,
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003547 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
3548 void *p_vrfy )
3549{
3550 int ret;
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02003551 unsigned i;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003552 uint32_t cur_flags;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003553 const mbedtls_x509_crt_verify_chain_item *cur;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003554
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003555 for( i = ver_chain->len; i != 0; --i )
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003556 {
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003557 cur = &ver_chain->items[i-1];
3558 cur_flags = cur->flags;
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003559
3560 if( NULL != f_vrfy )
Manuel Pégourié-Gonnardbb216bd2017-08-28 13:25:55 +02003561 if( ( ret = f_vrfy( p_vrfy, cur->crt, (int) i-1, &cur_flags ) ) != 0 )
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003562 return( ret );
3563
3564 *flags |= cur_flags;
3565 }
3566
3567 return( 0 );
3568}
3569
3570/*
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003571 * Verify the certificate validity (default profile, not restartable)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003572 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003573int mbedtls_x509_crt_verify( mbedtls_x509_crt *crt,
3574 mbedtls_x509_crt *trust_ca,
3575 mbedtls_x509_crl *ca_crl,
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003576#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
3577 const char *cn,
3578#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
3579 uint32_t *flags,
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02003580 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
Paul Bakkerddf26b42013-09-18 13:46:23 +02003581 void *p_vrfy )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003582{
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003583 return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003584 &mbedtls_x509_crt_profile_default,
3585#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
3586 cn,
3587#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
3588 flags,
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003589 f_vrfy, p_vrfy, NULL ) );
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003590}
3591
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003592/*
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003593 * Verify the certificate validity (user-chosen profile, not restartable)
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003594 */
3595int mbedtls_x509_crt_verify_with_profile( mbedtls_x509_crt *crt,
3596 mbedtls_x509_crt *trust_ca,
3597 mbedtls_x509_crl *ca_crl,
3598 const mbedtls_x509_crt_profile *profile,
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003599#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
3600 const char *cn,
3601#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
3602 uint32_t *flags,
Manuel Pégourié-Gonnard95051642015-06-15 10:39:46 +02003603 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
3604 void *p_vrfy )
3605{
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003606 return( mbedtls_x509_crt_verify_restartable( crt, trust_ca, ca_crl,
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003607 profile,
3608#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
3609 cn,
3610#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
3611 flags, f_vrfy, p_vrfy, NULL ) );
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003612}
3613
3614/*
3615 * Verify the certificate validity, with profile, restartable version
3616 *
3617 * This function:
3618 * - checks the requested CN (if any)
3619 * - checks the type and size of the EE cert's key,
3620 * as that isn't done as part of chain building/verification currently
3621 * - builds and verifies the chain
3622 * - then calls the callback and merges the flags
3623 */
3624int mbedtls_x509_crt_verify_restartable( mbedtls_x509_crt *crt,
3625 mbedtls_x509_crt *trust_ca,
3626 mbedtls_x509_crl *ca_crl,
3627 const mbedtls_x509_crt_profile *profile,
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003628#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
3629 const char *cn,
3630#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
3631 uint32_t *flags,
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003632 int (*f_vrfy)(void *, mbedtls_x509_crt *, int, uint32_t *),
3633 void *p_vrfy,
3634 mbedtls_x509_crt_restart_ctx *rs_ctx )
3635{
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003636 int ret;
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003637 mbedtls_x509_crt_verify_chain ver_chain;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003638 uint32_t ee_flags;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003639
3640 *flags = 0;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003641 ee_flags = 0;
3642 x509_crt_verify_chain_reset( &ver_chain );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003643
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02003644 if( profile == NULL )
3645 {
3646 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA;
3647 goto exit;
3648 }
3649
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003650#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Manuel Pégourié-Gonnard1300e992017-07-04 01:13:44 +02003651 /* check name if requested */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003652 if( cn != NULL )
Hanno Becker87233362019-02-25 18:15:33 +00003653 {
3654 ret = x509_crt_verify_name( crt, cn, &ee_flags );
3655 if( ret != 0 )
3656 return( ret );
3657 }
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003658#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003659
Hanno Becker87233362019-02-25 18:15:33 +00003660 {
3661 mbedtls_pk_context *pk;
3662 mbedtls_pk_type_t pk_type;
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02003663
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003664 ret = mbedtls_x509_crt_pk_acquire( crt, &pk );
Hanno Becker87233362019-02-25 18:15:33 +00003665 if( ret != 0 )
3666 return( MBEDTLS_ERR_X509_FATAL_ERROR );
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02003667
Hanno Becker87233362019-02-25 18:15:33 +00003668 /* Check the type and size of the key */
3669 pk_type = mbedtls_pk_get_type( pk );
3670
3671 if( x509_profile_check_pk_alg( profile, pk_type ) != 0 )
3672 ee_flags |= MBEDTLS_X509_BADCERT_BAD_PK;
3673
3674 if( x509_profile_check_key( profile, pk ) != 0 )
3675 ee_flags |= MBEDTLS_X509_BADCERT_BAD_KEY;
3676
Hanno Beckerc6d1c3e2019-03-05 13:50:56 +00003677 mbedtls_x509_crt_pk_release( crt );
Hanno Becker87233362019-02-25 18:15:33 +00003678 }
Manuel Pégourié-Gonnard65eefc82015-10-23 14:08:48 +02003679
Manuel Pégourié-Gonnardbdc54402017-07-04 00:33:39 +02003680 /* Check the chain */
Manuel Pégourié-Gonnard505c3952017-07-05 17:36:47 +02003681 ret = x509_crt_verify_chain( crt, trust_ca, ca_crl, profile,
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003682 &ver_chain, rs_ctx );
Manuel Pégourié-Gonnarda4a5d1d2017-07-17 10:26:19 +02003683
Manuel Pégourié-Gonnardc547d1a2017-07-05 13:28:45 +02003684 if( ret != 0 )
3685 goto exit;
3686
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003687 /* Merge end-entity flags */
3688 ver_chain.items[0].flags |= ee_flags;
3689
Manuel Pégourié-Gonnarda707e1d2017-07-05 17:18:42 +02003690 /* Build final flags, calling callback on the way if any */
Manuel Pégourié-Gonnardc11e4ba2017-08-14 17:17:14 +02003691 ret = x509_crt_merge_flags_with_cb( flags, &ver_chain, f_vrfy, p_vrfy );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003692
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02003693exit:
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003694#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
3695 if( rs_ctx != NULL && ret != MBEDTLS_ERR_ECP_IN_PROGRESS )
3696 mbedtls_x509_crt_restart_free( rs_ctx );
3697#endif
3698
Manuel Pégourié-Gonnard9107b5f2017-07-06 12:16:25 +02003699 /* prevent misuse of the vrfy callback - VERIFY_FAILED would be ignored by
3700 * the SSL module for authmode optional, but non-zero return from the
3701 * callback means a fatal error so it shouldn't be ignored */
Manuel Pégourié-Gonnard31458a12017-06-26 10:11:49 +02003702 if( ret == MBEDTLS_ERR_X509_CERT_VERIFY_FAILED )
3703 ret = MBEDTLS_ERR_X509_FATAL_ERROR;
3704
Manuel Pégourié-Gonnardd15795a2017-06-22 12:19:27 +02003705 if( ret != 0 )
3706 {
3707 *flags = (uint32_t) -1;
3708 return( ret );
3709 }
3710
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003711 if( *flags != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003712 return( MBEDTLS_ERR_X509_CERT_VERIFY_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003713
3714 return( 0 );
3715}
3716
3717/*
Paul Bakker369d2eb2013-09-18 11:58:25 +02003718 * Initialize a certificate chain
3719 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003720void mbedtls_x509_crt_init( mbedtls_x509_crt *crt )
Paul Bakker369d2eb2013-09-18 11:58:25 +02003721{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003722 memset( crt, 0, sizeof(mbedtls_x509_crt) );
Paul Bakker369d2eb2013-09-18 11:58:25 +02003723}
3724
3725/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003726 * Unallocate all certificate data
3727 */
Hanno Beckercd03bb22019-02-15 17:15:53 +00003728
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003729void mbedtls_x509_crt_free( mbedtls_x509_crt *crt )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003730{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003731 mbedtls_x509_crt *cert_cur = crt;
3732 mbedtls_x509_crt *cert_prv;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003733
3734 if( crt == NULL )
3735 return;
3736
3737 do
3738 {
Hanno Beckerb6c39fc2019-02-25 13:50:14 +00003739 x509_crt_cache_free( cert_cur->cache );
3740 mbedtls_free( cert_cur->cache );
Hanno Becker180f7bf2019-02-28 13:23:38 +00003741
3742#if !defined(MBEDTLS_X509_ON_DEMAND_PARSING)
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003743 mbedtls_pk_free( &cert_cur->pk );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003744
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003745#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
3746 mbedtls_free( cert_cur->sig_opts );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +02003747#endif
3748
Hanno Becker2bcc7642019-02-26 19:01:00 +00003749 mbedtls_x509_name_free( cert_cur->issuer.next );
3750 mbedtls_x509_name_free( cert_cur->subject.next );
3751 mbedtls_x509_sequence_free( cert_cur->ext_key_usage.next );
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003752#if !defined(MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION)
Hanno Becker2bcc7642019-02-26 19:01:00 +00003753 mbedtls_x509_sequence_free( cert_cur->subject_alt_names.next );
Teppo Järvelin4009d8f2019-08-19 14:48:09 +03003754#endif /* !MBEDTLS_X509_REMOVE_HOSTNAME_VERIFICATION */
3755
Hanno Becker180f7bf2019-02-28 13:23:38 +00003756#endif /* !MBEDTLS_X509_ON_DEMAND_PARSING */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003757
Hanno Beckeraa8665a2019-01-31 08:57:44 +00003758 if( cert_cur->raw.p != NULL && cert_cur->own_buffer )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003759 {
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05003760 mbedtls_platform_zeroize( cert_cur->raw.p, cert_cur->raw.len );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003761 mbedtls_free( cert_cur->raw.p );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003762 }
3763
3764 cert_cur = cert_cur->next;
3765 }
3766 while( cert_cur != NULL );
3767
3768 cert_cur = crt;
3769 do
3770 {
3771 cert_prv = cert_cur;
3772 cert_cur = cert_cur->next;
3773
Andres Amaya Garcia1f6301b2018-04-17 09:51:09 -05003774 mbedtls_platform_zeroize( cert_prv, sizeof( mbedtls_x509_crt ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003775 if( cert_prv != crt )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003776 mbedtls_free( cert_prv );
Paul Bakker7c6b2c32013-09-16 13:49:26 +02003777 }
3778 while( cert_cur != NULL );
3779}
3780
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003781#if defined(MBEDTLS_ECDSA_C) && defined(MBEDTLS_ECP_RESTARTABLE)
3782/*
3783 * Initialize a restart context
3784 */
3785void mbedtls_x509_crt_restart_init( mbedtls_x509_crt_restart_ctx *ctx )
3786{
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02003787 mbedtls_pk_restart_init( &ctx->pk );
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003788
3789 ctx->parent = NULL;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003790#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003791 ctx->fallback_parent = NULL;
Manuel Pégourié-Gonnard78d7e8c2018-07-02 12:33:14 +02003792 ctx->fallback_signature_is_good = 0;
Hanno Becker6f61b7b2019-06-10 11:12:33 +01003793#endif /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003794
3795 ctx->parent_is_trusted = -1;
3796
Manuel Pégourié-Gonnarddaf04912017-08-23 12:32:19 +02003797 ctx->in_progress = x509_crt_rs_none;
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003798 ctx->self_cnt = 0;
Manuel Pégourié-Gonnard83e923b2017-08-23 10:55:41 +02003799 x509_crt_verify_chain_reset( &ctx->ver_chain );
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003800}
3801
3802/*
3803 * Free the components of a restart context
3804 */
3805void mbedtls_x509_crt_restart_free( mbedtls_x509_crt_restart_ctx *ctx )
3806{
3807 if( ctx == NULL )
3808 return;
3809
Manuel Pégourié-Gonnard15d7df22017-08-17 14:33:31 +02003810 mbedtls_pk_restart_free( &ctx->pk );
Manuel Pégourié-Gonnard8b590492017-08-14 18:04:19 +02003811 mbedtls_x509_crt_restart_init( ctx );
Manuel Pégourié-Gonnardbc3f44a2017-07-11 11:02:20 +02003812}
3813#endif /* MBEDTLS_ECDSA_C && MBEDTLS_ECP_RESTARTABLE */
3814
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02003815#endif /* MBEDTLS_X509_CRT_PARSE_C */