blob: 627a5a39bfa578cce26a9985426f3722ce11ac4d [file] [log] [blame]
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001/*
Manuel Pégourié-Gonnard1c082f32014-06-12 22:34:55 +02002 * X.509 common functions for 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
30 */
31
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020032#if !defined(MBEDTLS_CONFIG_FILE)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000033#include "mbedtls/config.h"
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020034#else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020035#include MBEDTLS_CONFIG_FILE
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020036#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +020037
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020038#if defined(MBEDTLS_X509_USE_C)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020039
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000040#include "mbedtls/x509.h"
Hanno Beckerf6bc8882019-05-02 13:05:58 +010041#include "mbedtls/x509_internal.h"
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000042#include "mbedtls/asn1.h"
43#include "mbedtls/oid.h"
Rich Evans00ab4702015-02-06 13:43:58 +000044
Rich Evans36796df2015-02-12 18:27:14 +000045#include <stdio.h>
Rich Evans00ab4702015-02-06 13:43:58 +000046#include <string.h>
47
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020048#if defined(MBEDTLS_PEM_PARSE_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000049#include "mbedtls/pem.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020050#endif
51
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020052#if defined(MBEDTLS_PLATFORM_C)
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +000053#include "mbedtls/platform.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020054#else
Rich Evans00ab4702015-02-06 13:43:58 +000055#include <stdio.h>
56#include <stdlib.h>
SimonBd5800b72016-04-26 07:43:27 +010057#define mbedtls_free free
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +020058#define mbedtls_calloc calloc
SimonBd5800b72016-04-26 07:43:27 +010059#define mbedtls_printf printf
60#define mbedtls_snprintf snprintf
Paul Bakker7c6b2c32013-09-16 13:49:26 +020061#endif
62
Simon Butcherb5b6af22016-07-13 14:46:18 +010063#if defined(MBEDTLS_HAVE_TIME)
64#include "mbedtls/platform_time.h"
65#endif
Nicholas Wilson512b4ee2017-12-05 12:07:33 +000066#if defined(MBEDTLS_HAVE_TIME_DATE)
Andres Amaya Garcia1abb3682018-08-16 21:42:09 +010067#include "mbedtls/platform_util.h"
Paul Bakker7c6b2c32013-09-16 13:49:26 +020068#include <time.h>
69#endif
70
Hanno Beckerd6028a12018-10-15 12:01:35 +010071#define CHECK(code) if( ( ret = ( code ) ) != 0 ){ return( ret ); }
72#define CHECK_RANGE(min, max, val) \
73 do \
74 { \
75 if( ( val ) < ( min ) || ( val ) > ( max ) ) \
76 { \
77 return( ret ); \
78 } \
79 } while( 0 )
Rich Evans7d5a55a2015-02-13 11:48:02 +000080
Paul Bakker7c6b2c32013-09-16 13:49:26 +020081/*
82 * CertificateSerialNumber ::= INTEGER
83 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020084int mbedtls_x509_get_serial( unsigned char **p, const unsigned char *end,
85 mbedtls_x509_buf *serial )
Paul Bakker7c6b2c32013-09-16 13:49:26 +020086{
87 int ret;
88
89 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020090 return( MBEDTLS_ERR_X509_INVALID_SERIAL +
91 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +020092
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +020093 if( **p != ( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_PRIMITIVE | 2 ) &&
94 **p != MBEDTLS_ASN1_INTEGER )
95 return( MBEDTLS_ERR_X509_INVALID_SERIAL +
96 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Paul Bakker7c6b2c32013-09-16 13:49:26 +020097
98 serial->tag = *(*p)++;
99
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200100 if( ( ret = mbedtls_asn1_get_len( p, end, &serial->len ) ) != 0 )
101 return( MBEDTLS_ERR_X509_INVALID_SERIAL + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200102
103 serial->p = *p;
104 *p += serial->len;
105
106 return( 0 );
107}
108
109/* Get an algorithm identifier without parameters (eg for signatures)
110 *
111 * AlgorithmIdentifier ::= SEQUENCE {
112 * algorithm OBJECT IDENTIFIER,
113 * parameters ANY DEFINED BY algorithm OPTIONAL }
114 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200115int mbedtls_x509_get_alg_null( unsigned char **p, const unsigned char *end,
116 mbedtls_x509_buf *alg )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200117{
118 int ret;
119
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200120 if( ( ret = mbedtls_asn1_get_alg_null( p, end, alg ) ) != 0 )
121 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200122
123 return( 0 );
124}
125
126/*
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100127 * Parse an algorithm identifier with (optional) paramaters
128 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200129int mbedtls_x509_get_alg( unsigned char **p, const unsigned char *end,
130 mbedtls_x509_buf *alg, mbedtls_x509_buf *params )
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100131{
132 int ret;
133
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200134 if( ( ret = mbedtls_asn1_get_alg( p, end, alg, params ) ) != 0 )
135 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100136
137 return( 0 );
138}
139
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200140#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100141/*
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100142 * HashAlgorithm ::= AlgorithmIdentifier
143 *
144 * AlgorithmIdentifier ::= SEQUENCE {
145 * algorithm OBJECT IDENTIFIER,
146 * parameters ANY DEFINED BY algorithm OPTIONAL }
147 *
148 * For HashAlgorithm, parameters MUST be NULL or absent.
149 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200150static int x509_get_hash_alg( const mbedtls_x509_buf *alg, mbedtls_md_type_t *md_alg )
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100151{
152 int ret;
153 unsigned char *p;
154 const unsigned char *end;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200155 mbedtls_x509_buf md_oid;
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100156 size_t len;
157
158 /* Make sure we got a SEQUENCE and setup bounds */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200159 if( alg->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
160 return( MBEDTLS_ERR_X509_INVALID_ALG +
161 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100162
163 p = (unsigned char *) alg->p;
164 end = p + alg->len;
165
166 if( p >= end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200167 return( MBEDTLS_ERR_X509_INVALID_ALG +
168 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100169
170 /* Parse md_oid */
171 md_oid.tag = *p;
172
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200173 if( ( ret = mbedtls_asn1_get_tag( &p, end, &md_oid.len, MBEDTLS_ASN1_OID ) ) != 0 )
174 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100175
176 md_oid.p = p;
177 p += md_oid.len;
178
179 /* Get md_alg from md_oid */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200180 if( ( ret = mbedtls_oid_get_md_alg( &md_oid, md_alg ) ) != 0 )
181 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100182
183 /* Make sure params is absent of NULL */
184 if( p == end )
185 return( 0 );
186
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200187 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_NULL ) ) != 0 || len != 0 )
188 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100189
190 if( p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200191 return( MBEDTLS_ERR_X509_INVALID_ALG +
192 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100193
194 return( 0 );
195}
196
197/*
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100198 * RSASSA-PSS-params ::= SEQUENCE {
199 * hashAlgorithm [0] HashAlgorithm DEFAULT sha1Identifier,
200 * maskGenAlgorithm [1] MaskGenAlgorithm DEFAULT mgf1SHA1Identifier,
201 * saltLength [2] INTEGER DEFAULT 20,
202 * trailerField [3] INTEGER DEFAULT 1 }
203 * -- Note that the tags in this Sequence are explicit.
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200204 *
205 * RFC 4055 (which defines use of RSASSA-PSS in PKIX) states that the value
206 * of trailerField MUST be 1, and PKCS#1 v2.2 doesn't even define any other
207 * option. Enfore this at parsing time.
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100208 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200209int mbedtls_x509_get_rsassa_pss_params( const mbedtls_x509_buf *params,
210 mbedtls_md_type_t *md_alg, mbedtls_md_type_t *mgf_md,
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200211 int *salt_len )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100212{
213 int ret;
214 unsigned char *p;
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100215 const unsigned char *end, *end2;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100216 size_t len;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200217 mbedtls_x509_buf alg_id, alg_params;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100218
219 /* First set everything to defaults */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200220 *md_alg = MBEDTLS_MD_SHA1;
221 *mgf_md = MBEDTLS_MD_SHA1;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100222 *salt_len = 20;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100223
224 /* Make sure params is a SEQUENCE and setup bounds */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200225 if( params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
226 return( MBEDTLS_ERR_X509_INVALID_ALG +
227 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100228
229 p = (unsigned char *) params->p;
230 end = p + params->len;
231
232 if( p == end )
233 return( 0 );
234
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100235 /*
236 * HashAlgorithm
237 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200238 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
239 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) == 0 )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100240 {
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100241 end2 = p + len;
242
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100243 /* HashAlgorithm ::= AlgorithmIdentifier (without parameters) */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200244 if( ( ret = mbedtls_x509_get_alg_null( &p, end2, &alg_id ) ) != 0 )
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100245 return( ret );
246
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200247 if( ( ret = mbedtls_oid_get_md_alg( &alg_id, md_alg ) ) != 0 )
248 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100249
250 if( p != end2 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200251 return( MBEDTLS_ERR_X509_INVALID_ALG +
252 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100253 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200254 else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
255 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100256
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100257 if( p == end )
258 return( 0 );
259
260 /*
261 * MaskGenAlgorithm
262 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200263 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
264 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) ) == 0 )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100265 {
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100266 end2 = p + len;
267
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100268 /* MaskGenAlgorithm ::= AlgorithmIdentifier (params = HashAlgorithm) */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200269 if( ( ret = mbedtls_x509_get_alg( &p, end2, &alg_id, &alg_params ) ) != 0 )
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100270 return( ret );
271
272 /* Only MFG1 is recognised for now */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200273 if( MBEDTLS_OID_CMP( MBEDTLS_OID_MGF1, &alg_id ) != 0 )
274 return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE +
275 MBEDTLS_ERR_OID_NOT_FOUND );
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100276
277 /* Parse HashAlgorithm */
278 if( ( ret = x509_get_hash_alg( &alg_params, mgf_md ) ) != 0 )
279 return( ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100280
281 if( p != end2 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200282 return( MBEDTLS_ERR_X509_INVALID_ALG +
283 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100284 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200285 else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
286 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100287
288 if( p == end )
289 return( 0 );
290
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100291 /*
292 * salt_len
293 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200294 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
295 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 2 ) ) == 0 )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100296 {
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100297 end2 = p + len;
298
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200299 if( ( ret = mbedtls_asn1_get_int( &p, end2, salt_len ) ) != 0 )
300 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100301
302 if( p != end2 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200303 return( MBEDTLS_ERR_X509_INVALID_ALG +
304 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100305 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200306 else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
307 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100308
309 if( p == end )
310 return( 0 );
311
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100312 /*
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200313 * trailer_field (if present, must be 1)
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100314 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200315 if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
316 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 3 ) ) == 0 )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100317 {
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200318 int trailer_field;
319
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100320 end2 = p + len;
321
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200322 if( ( ret = mbedtls_asn1_get_int( &p, end2, &trailer_field ) ) != 0 )
323 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100324
325 if( p != end2 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200326 return( MBEDTLS_ERR_X509_INVALID_ALG +
327 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200328
329 if( trailer_field != 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200330 return( MBEDTLS_ERR_X509_INVALID_ALG );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100331 }
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200332 else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
333 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100334
335 if( p != end )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200336 return( MBEDTLS_ERR_X509_INVALID_ALG +
337 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100338
339 return( 0 );
340}
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200341#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100342
343/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200344 * AttributeTypeAndValue ::= SEQUENCE {
345 * type AttributeType,
346 * value AttributeValue }
347 *
348 * AttributeType ::= OBJECT IDENTIFIER
349 *
350 * AttributeValue ::= ANY DEFINED BY AttributeType
Hanno Beckere452add2019-05-02 13:19:34 +0100351 *
352 * NOTE: This function returns an ASN.1 low-level error code.
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200353 */
354static int x509_get_attr_type_value( unsigned char **p,
355 const unsigned char *end,
Hanno Becker3470d592019-02-20 09:45:17 +0000356 mbedtls_x509_buf *oid,
357 mbedtls_x509_buf *val )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200358{
359 int ret;
360 size_t len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200361
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000362 ret = mbedtls_asn1_get_tag( p, end, &len,
363 MBEDTLS_ASN1_CONSTRUCTED |
364 MBEDTLS_ASN1_SEQUENCE );
365 if( ret != 0 )
366 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200367
Hanno Becker4e1bfc12019-02-12 17:22:36 +0000368 end = *p + len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200369
Hanno Becker3470d592019-02-20 09:45:17 +0000370 ret = mbedtls_asn1_get_tag( p, end, &oid->len, MBEDTLS_ASN1_OID );
371 if( ret != 0 )
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000372 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200373
Hanno Beckerace04a62019-02-20 09:35:34 +0000374 oid->tag = MBEDTLS_ASN1_OID;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200375 oid->p = *p;
376 *p += oid->len;
377
Hanno Becker3470d592019-02-20 09:45:17 +0000378 if( *p == end )
379 {
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000380 ret = MBEDTLS_ERR_ASN1_OUT_OF_DATA;
381 goto exit;
Hanno Becker3470d592019-02-20 09:45:17 +0000382 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200383
Hanno Beckerb40dc582019-02-20 09:38:45 +0000384 if( !MBEDTLS_ASN1_IS_STRING_TAG( **p ) )
385 {
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000386 ret = MBEDTLS_ERR_ASN1_UNEXPECTED_TAG;
387 goto exit;
Hanno Beckerb40dc582019-02-20 09:38:45 +0000388 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200389
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200390 val->tag = *(*p)++;
391
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000392 ret = mbedtls_asn1_get_len( p, end, &val->len );
393 if( ret != 0 )
394 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200395
396 val->p = *p;
397 *p += val->len;
398
Hanno Becker4e1bfc12019-02-12 17:22:36 +0000399 if( *p != end )
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000400 ret = MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
401
402exit:
403 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200404}
405
406/*
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000407 * Name ::= CHOICE { -- only one possibility for now --
408 * rdnSequence RDNSequence }
409 *
410 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
411 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200412 * RelativeDistinguishedName ::=
413 * SET OF AttributeTypeAndValue
414 *
415 * AttributeTypeAndValue ::= SEQUENCE {
416 * type AttributeType,
417 * value AttributeValue }
418 *
419 * AttributeType ::= OBJECT IDENTIFIER
420 *
421 * AttributeValue ::= ANY DEFINED BY AttributeType
Manuel Pégourié-Gonnard5d861852014-10-17 12:41:41 +0200422 *
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000423 * The data structure is optimized for the common case where each RDN has only
424 * one element, which is represented as a list of AttributeTypeAndValue.
425 * For the general case we still use a flat list, but we mark elements of the
426 * same set so that they are "merged" together in the functions that consume
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200427 * this list, eg mbedtls_x509_dn_gets().
Hanno Beckere452add2019-05-02 13:19:34 +0100428 *
429 * NOTE: This function returns an ASN.1 low-level error code.
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200430 */
Hanno Becker3470d592019-02-20 09:45:17 +0000431static int x509_set_sequence_iterate( unsigned char **p,
432 unsigned char const **end_set,
433 unsigned char const *end,
434 mbedtls_x509_buf *oid,
435 mbedtls_x509_buf *val )
436
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200437{
438 int ret;
Manuel Pégourié-Gonnard5d861852014-10-17 12:41:41 +0200439 size_t set_len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200440
Hanno Becker3470d592019-02-20 09:45:17 +0000441 if( *p == *end_set )
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100442 {
Hanno Becker3470d592019-02-20 09:45:17 +0000443 /* Parse next TLV of ASN.1 SET structure. */
444 ret = mbedtls_asn1_get_tag( p, end, &set_len,
445 MBEDTLS_ASN1_CONSTRUCTED |
446 MBEDTLS_ASN1_SET );
447 if( ret != 0 )
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000448 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200449
Hanno Becker3470d592019-02-20 09:45:17 +0000450 *end_set = *p + set_len;
451 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200452
Hanno Beckere452add2019-05-02 13:19:34 +0100453 /* x509_get_attr_type_value() returns ASN.1 low-level error codes. */
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000454 ret = x509_get_attr_type_value( p, *end_set, oid, val );
455
456exit:
457 return( ret );
Hanno Becker3470d592019-02-20 09:45:17 +0000458}
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200459
Hanno Becker88de3422019-02-20 12:41:55 +0000460/*
461 * Like memcmp, but case-insensitive and always returns -1 if different
462 */
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000463int mbedtls_x509_memcasecmp( const void *s1, const void *s2,
464 size_t len1, size_t len2 )
Hanno Becker88de3422019-02-20 12:41:55 +0000465{
466 size_t i;
467 unsigned char diff;
468 const unsigned char *n1 = s1, *n2 = s2;
469
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000470 if( len1 != len2 )
471 return( -1 );
472
473 for( i = 0; i < len1; i++ )
Hanno Becker88de3422019-02-20 12:41:55 +0000474 {
475 diff = n1[i] ^ n2[i];
476
477 if( diff == 0 )
478 continue;
479
480 if( diff == 32 &&
481 ( ( n1[i] >= 'a' && n1[i] <= 'z' ) ||
482 ( n1[i] >= 'A' && n1[i] <= 'Z' ) ) )
483 {
484 continue;
485 }
486
487 return( -1 );
488 }
489
490 return( 0 );
491}
492
493/*
494 * Compare two X.509 strings, case-insensitive, and allowing for some encoding
495 * variations (but not all).
496 *
497 * Return 0 if equal, -1 otherwise.
498 */
499static int x509_string_cmp( const mbedtls_x509_buf *a,
500 const mbedtls_x509_buf *b )
501{
502 if( a->tag == b->tag &&
503 a->len == b->len &&
504 memcmp( a->p, b->p, b->len ) == 0 )
505 {
506 return( 0 );
507 }
508
509 if( ( a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
510 ( b->tag == MBEDTLS_ASN1_UTF8_STRING || b->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000511 mbedtls_x509_memcasecmp( a->p, b->p,
512 a->len, b->len ) == 0 )
Hanno Becker88de3422019-02-20 12:41:55 +0000513 {
514 return( 0 );
515 }
516
517 return( -1 );
518}
519
520/*
Hanno Becker7dee12a2019-02-21 13:58:38 +0000521 * Compare two X.509 Names (aka rdnSequence) given as raw ASN.1 data.
Hanno Becker88de3422019-02-20 12:41:55 +0000522 *
523 * See RFC 5280 section 7.1, though we don't implement the whole algorithm:
Hanno Becker7dee12a2019-02-21 13:58:38 +0000524 * We sometimes return unequal when the full algorithm would return equal,
Hanno Becker88de3422019-02-20 12:41:55 +0000525 * but never the other way. (In particular, we don't do Unicode normalisation
526 * or space folding.)
527 *
Hanno Becker67284cc2019-02-21 14:31:51 +0000528 * Further, this function allows to pass a callback to be triggered for every
529 * pair of well-formed and equal entries in the two input name lists.
530 *
Hanno Becker7dee12a2019-02-21 13:58:38 +0000531 * Returns:
Hanno Becker67284cc2019-02-21 14:31:51 +0000532 * - 0 if both sequences are well-formed, present the same X.509 name,
533 * and the callback (if provided) hasn't returned a non-zero value
534 * on any of the name components.
535 * - 1 if a difference was detected in the name components.
536 * - A non-zero error code if the abort callback returns a non-zero value.
537 * In this case, the returned error code is the error code from the callback.
Hanno Becker7dee12a2019-02-21 13:58:38 +0000538 * - A negative error code if a parsing error occurred in either
539 * of the two buffers.
540 *
541 * This function can be used to verify that a buffer contains a well-formed
542 * ASN.1 encoded X.509 name by calling it with equal parameters.
Hanno Becker88de3422019-02-20 12:41:55 +0000543 */
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000544int mbedtls_x509_name_cmp_raw( mbedtls_x509_buf_raw const *a,
Hanno Becker67284cc2019-02-21 14:31:51 +0000545 mbedtls_x509_buf_raw const *b,
546 int (*abort_check)( void *ctx,
Hanno Beckerbe0cf9b2019-05-02 13:17:29 +0100547 mbedtls_x509_buf *oid,
548 mbedtls_x509_buf *val,
549 int next_merged ),
Hanno Becker67284cc2019-02-21 14:31:51 +0000550 void *abort_check_ctx )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000551{
552 int ret;
Hanno Becker1e11f212019-03-04 14:43:43 +0000553 size_t idx;
554 unsigned char *p[2], *end[2], *set[2];
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000555
Hanno Becker1e11f212019-03-04 14:43:43 +0000556 p[0] = a->p;
557 p[1] = b->p;
558 end[0] = p[0] + a->len;
559 end[1] = p[1] + b->len;
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000560
Hanno Becker1e11f212019-03-04 14:43:43 +0000561 for( idx = 0; idx < 2; idx++ )
562 {
563 size_t len;
564 ret = mbedtls_asn1_get_tag( &p[idx], end[idx], &len,
565 MBEDTLS_ASN1_CONSTRUCTED |
566 MBEDTLS_ASN1_SEQUENCE );
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000567
Hanno Becker1e11f212019-03-04 14:43:43 +0000568 if( end[idx] != p[idx] + len )
569 {
570 return( MBEDTLS_ERR_X509_INVALID_NAME +
571 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
572 }
573
574 set[idx] = p[idx];
575 }
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000576
577 while( 1 )
578 {
Hanno Becker6b378122019-02-23 10:20:14 +0000579 int next_merged;
Hanno Becker1e11f212019-03-04 14:43:43 +0000580 mbedtls_x509_buf oid[2], val[2];
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000581
Hanno Becker1e11f212019-03-04 14:43:43 +0000582 ret = x509_set_sequence_iterate( &p[0], (const unsigned char **) &set[0],
583 end[0], &oid[0], &val[0] );
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000584 if( ret != 0 )
585 goto exit;
586
Hanno Becker1e11f212019-03-04 14:43:43 +0000587 ret = x509_set_sequence_iterate( &p[1], (const unsigned char **) &set[1],
588 end[1], &oid[1], &val[1] );
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000589 if( ret != 0 )
590 goto exit;
591
Hanno Becker1e11f212019-03-04 14:43:43 +0000592 if( oid[0].len != oid[1].len ||
593 memcmp( oid[0].p, oid[1].p, oid[1].len ) != 0 )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000594 {
595 return( 1 );
596 }
597
Hanno Becker1e11f212019-03-04 14:43:43 +0000598 if( x509_string_cmp( &val[0], &val[1] ) != 0 )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000599 return( 1 );
600
Hanno Becker1e11f212019-03-04 14:43:43 +0000601 next_merged = ( set[0] != p[0] );
602 if( next_merged != ( set[1] != p[1] ) )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000603 return( 1 );
604
Hanno Becker67284cc2019-02-21 14:31:51 +0000605 if( abort_check != NULL )
606 {
Hanno Becker1e11f212019-03-04 14:43:43 +0000607 ret = abort_check( abort_check_ctx, &oid[0], &val[0],
Hanno Becker6b378122019-02-23 10:20:14 +0000608 next_merged );
Hanno Becker67284cc2019-02-21 14:31:51 +0000609 if( ret != 0 )
610 return( ret );
611 }
612
Hanno Becker1e11f212019-03-04 14:43:43 +0000613 if( p[0] == end[0] && p[1] == end[1] )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000614 break;
615 }
616
617exit:
618 if( ret < 0 )
619 ret += MBEDTLS_ERR_X509_INVALID_NAME;
620
621 return( ret );
622}
623
Hanno Beckerc6573a22019-02-23 09:13:17 +0000624static int x509_get_name_cb( void *ctx,
625 mbedtls_x509_buf *oid,
626 mbedtls_x509_buf *val,
627 int next_merged )
628{
629 mbedtls_x509_name **cur_ptr = (mbedtls_x509_name**) ctx;
630 mbedtls_x509_name *cur = *cur_ptr;
631
632 if( cur->oid.p != NULL )
633 {
634 cur->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
635 if( cur->next == NULL )
636 return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
637
638 cur = cur->next;
639 }
640
641 cur->oid = *oid;
642 cur->val = *val;
643 cur->next_merged = next_merged;
644
645 *cur_ptr = cur;
646 return( 0 );
647}
Hanno Becker6b378122019-02-23 10:20:14 +0000648
Hanno Becker1e11f212019-03-04 14:43:43 +0000649int mbedtls_x509_get_name( unsigned char *p,
650 size_t len,
Hanno Becker6b378122019-02-23 10:20:14 +0000651 mbedtls_x509_name *cur )
652{
Hanno Becker1e11f212019-03-04 14:43:43 +0000653 mbedtls_x509_buf_raw name_buf = { p, len };
Hanno Beckerc6573a22019-02-23 09:13:17 +0000654 memset( cur, 0, sizeof( mbedtls_x509_name ) );
Hanno Becker1e11f212019-03-04 14:43:43 +0000655 return( mbedtls_x509_name_cmp_raw( &name_buf, &name_buf,
656 x509_get_name_cb,
657 &cur ) );
Hanno Becker6b378122019-02-23 10:20:14 +0000658}
659
Janos Follath87c98072017-02-03 12:36:59 +0000660static int x509_parse_int( unsigned char **p, size_t n, int *res )
661{
Rich Evans7d5a55a2015-02-13 11:48:02 +0000662 *res = 0;
Janos Follath87c98072017-02-03 12:36:59 +0000663
664 for( ; n > 0; --n )
665 {
666 if( ( **p < '0') || ( **p > '9' ) )
667 return ( MBEDTLS_ERR_X509_INVALID_DATE );
668
Rich Evans7d5a55a2015-02-13 11:48:02 +0000669 *res *= 10;
Janos Follath87c98072017-02-03 12:36:59 +0000670 *res += ( *(*p)++ - '0' );
Rich Evans7d5a55a2015-02-13 11:48:02 +0000671 }
Janos Follath87c98072017-02-03 12:36:59 +0000672
673 return( 0 );
Rich Evans7d5a55a2015-02-13 11:48:02 +0000674}
675
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000676static int x509_date_is_valid(const mbedtls_x509_time *t )
Andres AG4b76aec2016-09-23 13:16:02 +0100677{
678 int ret = MBEDTLS_ERR_X509_INVALID_DATE;
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000679 int month_len;
Andres AG4b76aec2016-09-23 13:16:02 +0100680
Hanno Becker61937d42017-04-26 15:01:23 +0100681 CHECK_RANGE( 0, 9999, t->year );
682 CHECK_RANGE( 0, 23, t->hour );
683 CHECK_RANGE( 0, 59, t->min );
684 CHECK_RANGE( 0, 59, t->sec );
Andres AG4b76aec2016-09-23 13:16:02 +0100685
Hanno Becker61937d42017-04-26 15:01:23 +0100686 switch( t->mon )
Andres AG4b76aec2016-09-23 13:16:02 +0100687 {
688 case 1: case 3: case 5: case 7: case 8: case 10: case 12:
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000689 month_len = 31;
Andres AG4b76aec2016-09-23 13:16:02 +0100690 break;
691 case 4: case 6: case 9: case 11:
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000692 month_len = 30;
Andres AG4b76aec2016-09-23 13:16:02 +0100693 break;
694 case 2:
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000695 if( ( !( t->year % 4 ) && t->year % 100 ) ||
696 !( t->year % 400 ) )
697 month_len = 29;
698 else
699 month_len = 28;
Andres AG4b76aec2016-09-23 13:16:02 +0100700 break;
701 default:
702 return( ret );
703 }
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000704 CHECK_RANGE( 1, month_len, t->day );
Andres AG4b76aec2016-09-23 13:16:02 +0100705
706 return( 0 );
707}
708
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200709/*
Janos Follath87c98072017-02-03 12:36:59 +0000710 * Parse an ASN1_UTC_TIME (yearlen=2) or ASN1_GENERALIZED_TIME (yearlen=4)
711 * field.
712 */
713static int x509_parse_time( unsigned char **p, size_t len, size_t yearlen,
Hanno Becker61937d42017-04-26 15:01:23 +0100714 mbedtls_x509_time *tm )
Janos Follath87c98072017-02-03 12:36:59 +0000715{
716 int ret;
717
718 /*
719 * Minimum length is 10 or 12 depending on yearlen
720 */
721 if ( len < yearlen + 8 )
722 return ( MBEDTLS_ERR_X509_INVALID_DATE );
723 len -= yearlen + 8;
724
725 /*
726 * Parse year, month, day, hour, minute
727 */
Hanno Becker61937d42017-04-26 15:01:23 +0100728 CHECK( x509_parse_int( p, yearlen, &tm->year ) );
Janos Follath87c98072017-02-03 12:36:59 +0000729 if ( 2 == yearlen )
730 {
Hanno Becker61937d42017-04-26 15:01:23 +0100731 if ( tm->year < 50 )
732 tm->year += 100;
Janos Follath87c98072017-02-03 12:36:59 +0000733
Hanno Becker61937d42017-04-26 15:01:23 +0100734 tm->year += 1900;
Janos Follath87c98072017-02-03 12:36:59 +0000735 }
736
Hanno Becker61937d42017-04-26 15:01:23 +0100737 CHECK( x509_parse_int( p, 2, &tm->mon ) );
738 CHECK( x509_parse_int( p, 2, &tm->day ) );
739 CHECK( x509_parse_int( p, 2, &tm->hour ) );
740 CHECK( x509_parse_int( p, 2, &tm->min ) );
Janos Follath87c98072017-02-03 12:36:59 +0000741
742 /*
743 * Parse seconds if present
744 */
745 if ( len >= 2 )
746 {
Hanno Becker61937d42017-04-26 15:01:23 +0100747 CHECK( x509_parse_int( p, 2, &tm->sec ) );
Janos Follath87c98072017-02-03 12:36:59 +0000748 len -= 2;
749 }
750 else
751 return ( MBEDTLS_ERR_X509_INVALID_DATE );
752
753 /*
754 * Parse trailing 'Z' if present
755 */
756 if ( 1 == len && 'Z' == **p )
757 {
758 (*p)++;
759 len--;
760 }
761
762 /*
763 * We should have parsed all characters at this point
764 */
765 if ( 0 != len )
766 return ( MBEDTLS_ERR_X509_INVALID_DATE );
767
Hanno Becker61937d42017-04-26 15:01:23 +0100768 CHECK( x509_date_is_valid( tm ) );
Janos Follath87c98072017-02-03 12:36:59 +0000769
770 return ( 0 );
771}
772
773/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200774 * Time ::= CHOICE {
775 * utcTime UTCTime,
776 * generalTime GeneralizedTime }
777 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200778int mbedtls_x509_get_time( unsigned char **p, const unsigned char *end,
Hanno Becker61937d42017-04-26 15:01:23 +0100779 mbedtls_x509_time *tm )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200780{
781 int ret;
Janos Follath87c98072017-02-03 12:36:59 +0000782 size_t len, year_len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200783 unsigned char tag;
784
785 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200786 return( MBEDTLS_ERR_X509_INVALID_DATE +
787 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200788
789 tag = **p;
790
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200791 if( tag == MBEDTLS_ASN1_UTC_TIME )
Janos Follath87c98072017-02-03 12:36:59 +0000792 year_len = 2;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200793 else if( tag == MBEDTLS_ASN1_GENERALIZED_TIME )
Janos Follath87c98072017-02-03 12:36:59 +0000794 year_len = 4;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200795 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200796 return( MBEDTLS_ERR_X509_INVALID_DATE +
797 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Janos Follath87c98072017-02-03 12:36:59 +0000798
799 (*p)++;
800 ret = mbedtls_asn1_get_len( p, end, &len );
801
802 if( ret != 0 )
803 return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
804
Hanno Becker61937d42017-04-26 15:01:23 +0100805 return x509_parse_time( p, len, year_len, tm );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200806}
807
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200808int mbedtls_x509_get_sig( unsigned char **p, const unsigned char *end, mbedtls_x509_buf *sig )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200809{
810 int ret;
811 size_t len;
Andres AG4bdbe092016-09-19 16:58:45 +0100812 int tag_type;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200813
814 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200815 return( MBEDTLS_ERR_X509_INVALID_SIGNATURE +
816 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200817
Andres AG4bdbe092016-09-19 16:58:45 +0100818 tag_type = **p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200819
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200820 if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
821 return( MBEDTLS_ERR_X509_INVALID_SIGNATURE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200822
Andres AG4bdbe092016-09-19 16:58:45 +0100823 sig->tag = tag_type;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200824 sig->len = len;
825 sig->p = *p;
826
827 *p += len;
828
829 return( 0 );
830}
831
Hanno Beckerb59d3f12019-02-22 17:49:34 +0000832int mbedtls_x509_get_sig_alg_raw( unsigned char **p, unsigned char const *end,
833 mbedtls_md_type_t *md_alg,
834 mbedtls_pk_type_t *pk_alg,
835 void **sig_opts )
836{
837 int ret;
838 mbedtls_asn1_buf alg, params;
839 ret = mbedtls_asn1_get_alg( p, end, &alg, &params );
840 if( ret != 0 )
841 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
842
843 return( mbedtls_x509_get_sig_alg( &alg, &params, md_alg,
844 pk_alg, sig_opts ) );
845}
846
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100847/*
848 * Get signature algorithm from alg OID and optional parameters
849 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200850int mbedtls_x509_get_sig_alg( const mbedtls_x509_buf *sig_oid, const mbedtls_x509_buf *sig_params,
851 mbedtls_md_type_t *md_alg, mbedtls_pk_type_t *pk_alg,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200852 void **sig_opts )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200853{
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100854 int ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200855
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200856 if( ( ret = mbedtls_oid_get_sig_alg( sig_oid, md_alg, pk_alg ) ) != 0 )
857 return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200858
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200859#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
860 if( *pk_alg == MBEDTLS_PK_RSASSA_PSS )
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100861 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200862 mbedtls_pk_rsassa_pss_options *pss_opts;
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100863
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200864 pss_opts = mbedtls_calloc( 1, sizeof( mbedtls_pk_rsassa_pss_options ) );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200865 if( pss_opts == NULL )
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +0200866 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200867
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200868 ret = mbedtls_x509_get_rsassa_pss_params( sig_params,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200869 md_alg,
870 &pss_opts->mgf1_hash_id,
871 &pss_opts->expected_salt_len );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100872 if( ret != 0 )
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200873 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200874 mbedtls_free( pss_opts );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100875 return( ret );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200876 }
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100877
Hanno Becker1898b682019-02-22 16:03:29 +0000878 if( sig_opts != NULL )
879 *sig_opts = (void *) pss_opts;
880 else
881 mbedtls_free( pss_opts );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100882 }
883 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200884#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100885 {
886 /* Make sure parameters are absent or NULL */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200887 if( ( sig_params->tag != MBEDTLS_ASN1_NULL && sig_params->tag != 0 ) ||
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100888 sig_params->len != 0 )
Hanno Becker1898b682019-02-22 16:03:29 +0000889 return( MBEDTLS_ERR_X509_INVALID_ALG );
890
891 if( sig_opts != NULL )
892 *sig_opts = NULL;
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100893 }
894
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200895 return( 0 );
896}
897
898/*
899 * X.509 Extensions (No parsing of extensions, pointer should
Brian J Murray1903fb32016-11-06 04:45:15 -0800900 * be either manually updated or extensions should be parsed!)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200901 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200902int mbedtls_x509_get_ext( unsigned char **p, const unsigned char *end,
Hanno Becker2f472142019-02-12 11:52:10 +0000903 mbedtls_x509_buf *ext, int tag )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200904{
905 int ret;
906 size_t len;
907
Hanno Beckerc74ce442019-02-11 14:33:36 +0000908 /* Extension structure use EXPLICIT tagging. That is, the actual
909 * `Extensions` structure is wrapped by a tag-length pair using
910 * the respective context-specific tag. */
Hanno Becker2f472142019-02-12 11:52:10 +0000911 ret = mbedtls_asn1_get_tag( p, end, &ext->len,
912 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag );
913 if( ret != 0 )
914 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200915
Hanno Becker2f472142019-02-12 11:52:10 +0000916 ext->tag = MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag;
917 ext->p = *p;
918 end = *p + ext->len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200919
920 /*
921 * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200922 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200923 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
924 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
925 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200926
927 if( end != *p + len )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200928 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
929 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200930
931 return( 0 );
932}
933
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200934/*
935 * Store the name in printable form into buf; no more
936 * than size characters will be written
937 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200938int mbedtls_x509_dn_gets( char *buf, size_t size, const mbedtls_x509_name *dn )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200939{
940 int ret;
941 size_t i, n;
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000942 unsigned char c, merge = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200943 const mbedtls_x509_name *name;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200944 const char *short_name = NULL;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200945 char s[MBEDTLS_X509_MAX_DN_NAME_SIZE], *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200946
947 memset( s, 0, sizeof( s ) );
948
949 name = dn;
950 p = buf;
951 n = size;
952
953 while( name != NULL )
954 {
955 if( !name->oid.p )
956 {
957 name = name->next;
958 continue;
959 }
960
961 if( name != dn )
962 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200963 ret = mbedtls_snprintf( p, n, merge ? " + " : ", " );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +0200964 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200965 }
966
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200967 ret = mbedtls_oid_get_attr_short_name( &name->oid, &short_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200968
969 if( ret == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200970 ret = mbedtls_snprintf( p, n, "%s=", short_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200971 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200972 ret = mbedtls_snprintf( p, n, "\?\?=" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +0200973 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200974
975 for( i = 0; i < name->val.len; i++ )
976 {
977 if( i >= sizeof( s ) - 1 )
978 break;
979
980 c = name->val.p[i];
981 if( c < 32 || c == 127 || ( c > 128 && c < 160 ) )
982 s[i] = '?';
983 else s[i] = c;
984 }
985 s[i] = '\0';
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200986 ret = mbedtls_snprintf( p, n, "%s", s );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +0200987 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000988
989 merge = name->next_merged;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200990 name = name->next;
991 }
992
993 return( (int) ( size - n ) );
994}
995
996/*
997 * Store the serial in printable form into buf; no more
998 * than size characters will be written
999 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001000int mbedtls_x509_serial_gets( char *buf, size_t size, const mbedtls_x509_buf *serial )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001001{
1002 int ret;
1003 size_t i, n, nr;
1004 char *p;
1005
1006 p = buf;
1007 n = size;
1008
1009 nr = ( serial->len <= 32 )
1010 ? serial->len : 28;
1011
1012 for( i = 0; i < nr; i++ )
1013 {
1014 if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
1015 continue;
1016
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001017 ret = mbedtls_snprintf( p, n, "%02X%s",
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001018 serial->p[i], ( i < nr - 1 ) ? ":" : "" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001019 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001020 }
1021
1022 if( nr != serial->len )
1023 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001024 ret = mbedtls_snprintf( p, n, "...." );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001025 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001026 }
1027
1028 return( (int) ( size - n ) );
1029}
1030
Hanno Becker02a21932019-06-10 15:08:43 +01001031#if !defined(MBEDTLS_X509_REMOVE_INFO)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001032/*
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +02001033 * Helper for writing signature algorithms
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001034 */
Hanno Becker83cd8672019-02-21 17:13:46 +00001035int mbedtls_x509_sig_alg_gets( char *buf, size_t size, mbedtls_pk_type_t pk_alg,
1036 mbedtls_md_type_t md_alg, const void *sig_opts )
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001037{
1038 int ret;
1039 char *p = buf;
1040 size_t n = size;
1041 const char *desc = NULL;
Hanno Becker83cd8672019-02-21 17:13:46 +00001042 mbedtls_x509_buf sig_oid;
1043 mbedtls_md_type_t tmp_md_alg = md_alg;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001044
Hanno Becker83cd8672019-02-21 17:13:46 +00001045#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1046 /* The hash for RSASSA is determined by the algorithm parameters;
1047 * in the OID list, the hash is set to MBEDTLS_MD_NONE. */
1048 if( pk_alg == MBEDTLS_PK_RSASSA_PSS )
1049 tmp_md_alg = MBEDTLS_MD_NONE;
1050#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
1051
1052 sig_oid.tag = MBEDTLS_ASN1_OID;
1053 ret = mbedtls_oid_get_oid_by_sig_alg( pk_alg, tmp_md_alg,
1054 (const char**) &sig_oid.p,
1055 &sig_oid.len );
1056 if( ret == 0 &&
1057 mbedtls_oid_get_sig_alg_desc( &sig_oid, &desc ) == 0 )
1058 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001059 ret = mbedtls_snprintf( p, n, "%s", desc );
Hanno Becker83cd8672019-02-21 17:13:46 +00001060 }
1061 else
1062 ret = mbedtls_snprintf( p, n, "???" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001063 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001064
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001065#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1066 if( pk_alg == MBEDTLS_PK_RSASSA_PSS )
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001067 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001068 const mbedtls_pk_rsassa_pss_options *pss_opts;
1069 const mbedtls_md_info_t *md_info, *mgf_md_info;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001070
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001071 pss_opts = (const mbedtls_pk_rsassa_pss_options *) sig_opts;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001072
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001073 md_info = mbedtls_md_info_from_type( md_alg );
1074 mgf_md_info = mbedtls_md_info_from_type( pss_opts->mgf1_hash_id );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001075
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001076 ret = mbedtls_snprintf( p, n, " (%s, MGF1-%s, 0x%02X)",
1077 md_info ? mbedtls_md_get_name( md_info ) : "???",
1078 mgf_md_info ? mbedtls_md_get_name( mgf_md_info ) : "???",
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +02001079 pss_opts->expected_salt_len );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001080 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001081 }
1082#else
1083 ((void) pk_alg);
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +02001084 ((void) md_alg);
1085 ((void) sig_opts);
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001086#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001087
Sander Niemeijeref5087d2014-08-16 12:45:52 +02001088 return( (int)( size - n ) );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001089}
Hanno Becker02a21932019-06-10 15:08:43 +01001090#endif /* !MBEDTLS_X509_REMOVE_INFO */
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001091
1092/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001093 * Helper for writing "RSA key size", "EC key size", etc
1094 */
Manuel Pégourié-Gonnardfb317c52015-06-18 16:25:56 +02001095int mbedtls_x509_key_size_helper( char *buf, size_t buf_size, const char *name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001096{
1097 char *p = buf;
Manuel Pégourié-Gonnardfb317c52015-06-18 16:25:56 +02001098 size_t n = buf_size;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001099 int ret;
1100
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001101 ret = mbedtls_snprintf( p, n, "%s key size", name );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001102 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001103
1104 return( 0 );
1105}
1106
Manuel Pégourié-Gonnard60c793b2015-06-18 20:52:58 +02001107#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001108/*
1109 * Set the time structure to the current time.
1110 * Return 0 on success, non-zero on failure.
1111 */
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001112static int x509_get_current_time( mbedtls_x509_time *now )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001113{
Nicholas Wilson512b4ee2017-12-05 12:07:33 +00001114 struct tm *lt, tm_buf;
SimonBd5800b72016-04-26 07:43:27 +01001115 mbedtls_time_t tt;
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001116 int ret = 0;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001117
SimonBd5800b72016-04-26 07:43:27 +01001118 tt = mbedtls_time( NULL );
Hanno Becker6a739782018-09-05 15:06:19 +01001119 lt = mbedtls_platform_gmtime_r( &tt, &tm_buf );
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001120
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001121 if( lt == NULL )
1122 ret = -1;
1123 else
1124 {
1125 now->year = lt->tm_year + 1900;
1126 now->mon = lt->tm_mon + 1;
1127 now->day = lt->tm_mday;
1128 now->hour = lt->tm_hour;
1129 now->min = lt->tm_min;
1130 now->sec = lt->tm_sec;
1131 }
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001132
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001133 return( ret );
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001134}
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001135
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001136/*
1137 * Return 0 if before <= after, 1 otherwise
1138 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001139static int x509_check_time( const mbedtls_x509_time *before, const mbedtls_x509_time *after )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001140{
1141 if( before->year > after->year )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001142 return( 1 );
1143
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001144 if( before->year == after->year &&
1145 before->mon > after->mon )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001146 return( 1 );
1147
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001148 if( before->year == after->year &&
1149 before->mon == after->mon &&
1150 before->day > after->day )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001151 return( 1 );
1152
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001153 if( before->year == after->year &&
1154 before->mon == after->mon &&
1155 before->day == after->day &&
1156 before->hour > after->hour )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001157 return( 1 );
1158
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001159 if( before->year == after->year &&
1160 before->mon == after->mon &&
1161 before->day == after->day &&
1162 before->hour == after->hour &&
1163 before->min > after->min )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001164 return( 1 );
1165
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001166 if( before->year == after->year &&
1167 before->mon == after->mon &&
1168 before->day == after->day &&
1169 before->hour == after->hour &&
1170 before->min == after->min &&
1171 before->sec > after->sec )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001172 return( 1 );
1173
1174 return( 0 );
1175}
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001176
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001177int mbedtls_x509_time_is_past( const mbedtls_x509_time *to )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001178{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001179 mbedtls_x509_time now;
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001180
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001181 if( x509_get_current_time( &now ) != 0 )
Manuel Pégourié-Gonnarde7e89842015-06-22 19:15:32 +02001182 return( 1 );
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001183
1184 return( x509_check_time( &now, to ) );
1185}
1186
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001187int mbedtls_x509_time_is_future( const mbedtls_x509_time *from )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001188{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001189 mbedtls_x509_time now;
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001190
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001191 if( x509_get_current_time( &now ) != 0 )
Manuel Pégourié-Gonnarde7e89842015-06-22 19:15:32 +02001192 return( 1 );
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001193
1194 return( x509_check_time( from, &now ) );
1195}
1196
Manuel Pégourié-Gonnard60c793b2015-06-18 20:52:58 +02001197#else /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001198
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001199int mbedtls_x509_time_is_past( const mbedtls_x509_time *to )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001200{
1201 ((void) to);
1202 return( 0 );
1203}
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001204
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001205int mbedtls_x509_time_is_future( const mbedtls_x509_time *from )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001206{
1207 ((void) from);
1208 return( 0 );
1209}
Manuel Pégourié-Gonnard60c793b2015-06-18 20:52:58 +02001210#endif /* MBEDTLS_HAVE_TIME_DATE */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001211
Hanno Becker2bcc7642019-02-26 19:01:00 +00001212void mbedtls_x509_name_free( mbedtls_x509_name *name )
1213{
1214 while( name != NULL )
1215 {
1216 mbedtls_x509_name *next = name->next;
1217 mbedtls_platform_zeroize( name, sizeof( *name ) );
1218 mbedtls_free( name );
1219 name = next;
1220 }
1221}
1222
1223void mbedtls_x509_sequence_free( mbedtls_x509_sequence *seq )
1224{
1225 while( seq != NULL )
1226 {
1227 mbedtls_x509_sequence *next = seq->next;
1228 mbedtls_platform_zeroize( seq, sizeof( *seq ) );
1229 mbedtls_free( seq );
1230 seq = next;
1231 }
1232}
1233
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001234#if defined(MBEDTLS_SELF_TEST)
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001235
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00001236#include "mbedtls/x509_crt.h"
1237#include "mbedtls/certs.h"
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001238
1239/*
1240 * Checkup routine
1241 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001242int mbedtls_x509_self_test( int verbose )
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001243{
Junhwan Park60ee28b2018-10-17 21:01:08 +09001244 int ret = 0;
Gilles Peskine750c3532017-05-05 18:56:30 +02001245#if defined(MBEDTLS_CERTS_C) && defined(MBEDTLS_SHA256_C)
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001246 uint32_t flags;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001247 mbedtls_x509_crt cacert;
1248 mbedtls_x509_crt clicert;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001249
1250 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001251 mbedtls_printf( " X.509 certificate load: " );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001252
Junhwan Park60ee28b2018-10-17 21:01:08 +09001253 mbedtls_x509_crt_init( &cacert );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001254 mbedtls_x509_crt_init( &clicert );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001255
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001256 ret = mbedtls_x509_crt_parse( &clicert, (const unsigned char *) mbedtls_test_cli_crt,
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001257 mbedtls_test_cli_crt_len );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001258 if( ret != 0 )
1259 {
1260 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001261 mbedtls_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001262
Junhwan Park60ee28b2018-10-17 21:01:08 +09001263 goto cleanup;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001264 }
1265
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001266 ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_ca_crt,
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001267 mbedtls_test_ca_crt_len );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001268 if( ret != 0 )
1269 {
1270 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001271 mbedtls_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001272
Junhwan Park60ee28b2018-10-17 21:01:08 +09001273 goto cleanup;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001274 }
1275
1276 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001277 mbedtls_printf( "passed\n X.509 signature verify: ");
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001278
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001279 ret = mbedtls_x509_crt_verify( &clicert, &cacert, NULL, NULL, &flags, NULL, NULL );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001280 if( ret != 0 )
1281 {
1282 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001283 mbedtls_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001284
Junhwan Park60ee28b2018-10-17 21:01:08 +09001285 goto cleanup;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001286 }
1287
1288 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001289 mbedtls_printf( "passed\n\n");
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001290
Junhwan Park60ee28b2018-10-17 21:01:08 +09001291cleanup:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001292 mbedtls_x509_crt_free( &cacert );
1293 mbedtls_x509_crt_free( &clicert );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001294#else
1295 ((void) verbose);
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001296#endif /* MBEDTLS_CERTS_C && MBEDTLS_SHA1_C */
Junhwan Park60ee28b2018-10-17 21:01:08 +09001297 return( ret );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001298}
1299
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001300#endif /* MBEDTLS_SELF_TEST */
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001301
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001302#endif /* MBEDTLS_X509_USE_C */