blob: 0a9138fa70ce714b14bdb57ab56c7ae6ef1fa39d [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
351 */
352static int x509_get_attr_type_value( unsigned char **p,
353 const unsigned char *end,
Hanno Becker3470d592019-02-20 09:45:17 +0000354 mbedtls_x509_buf *oid,
355 mbedtls_x509_buf *val )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200356{
357 int ret;
358 size_t len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200359
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000360 ret = mbedtls_asn1_get_tag( p, end, &len,
361 MBEDTLS_ASN1_CONSTRUCTED |
362 MBEDTLS_ASN1_SEQUENCE );
363 if( ret != 0 )
364 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200365
Hanno Becker4e1bfc12019-02-12 17:22:36 +0000366 end = *p + len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200367
Hanno Becker3470d592019-02-20 09:45:17 +0000368 ret = mbedtls_asn1_get_tag( p, end, &oid->len, MBEDTLS_ASN1_OID );
369 if( ret != 0 )
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000370 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200371
Hanno Beckerace04a62019-02-20 09:35:34 +0000372 oid->tag = MBEDTLS_ASN1_OID;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200373 oid->p = *p;
374 *p += oid->len;
375
Hanno Becker3470d592019-02-20 09:45:17 +0000376 if( *p == end )
377 {
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000378 ret = MBEDTLS_ERR_ASN1_OUT_OF_DATA;
379 goto exit;
Hanno Becker3470d592019-02-20 09:45:17 +0000380 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200381
Hanno Beckerb40dc582019-02-20 09:38:45 +0000382 if( !MBEDTLS_ASN1_IS_STRING_TAG( **p ) )
383 {
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000384 ret = MBEDTLS_ERR_ASN1_UNEXPECTED_TAG;
385 goto exit;
Hanno Beckerb40dc582019-02-20 09:38:45 +0000386 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200387
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200388 val->tag = *(*p)++;
389
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000390 ret = mbedtls_asn1_get_len( p, end, &val->len );
391 if( ret != 0 )
392 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200393
394 val->p = *p;
395 *p += val->len;
396
Hanno Becker4e1bfc12019-02-12 17:22:36 +0000397 if( *p != end )
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000398 ret = MBEDTLS_ERR_ASN1_LENGTH_MISMATCH;
399
400exit:
401 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200402}
403
404/*
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000405 * Name ::= CHOICE { -- only one possibility for now --
406 * rdnSequence RDNSequence }
407 *
408 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
409 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200410 * RelativeDistinguishedName ::=
411 * SET OF AttributeTypeAndValue
412 *
413 * AttributeTypeAndValue ::= SEQUENCE {
414 * type AttributeType,
415 * value AttributeValue }
416 *
417 * AttributeType ::= OBJECT IDENTIFIER
418 *
419 * AttributeValue ::= ANY DEFINED BY AttributeType
Manuel Pégourié-Gonnard5d861852014-10-17 12:41:41 +0200420 *
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000421 * The data structure is optimized for the common case where each RDN has only
422 * one element, which is represented as a list of AttributeTypeAndValue.
423 * For the general case we still use a flat list, but we mark elements of the
424 * same set so that they are "merged" together in the functions that consume
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200425 * this list, eg mbedtls_x509_dn_gets().
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200426 */
Hanno Becker3470d592019-02-20 09:45:17 +0000427static int x509_set_sequence_iterate( unsigned char **p,
428 unsigned char const **end_set,
429 unsigned char const *end,
430 mbedtls_x509_buf *oid,
431 mbedtls_x509_buf *val )
432
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200433{
434 int ret;
Manuel Pégourié-Gonnard5d861852014-10-17 12:41:41 +0200435 size_t set_len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200436
Hanno Becker3470d592019-02-20 09:45:17 +0000437 if( *p == *end_set )
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100438 {
Hanno Becker3470d592019-02-20 09:45:17 +0000439 /* Parse next TLV of ASN.1 SET structure. */
440 ret = mbedtls_asn1_get_tag( p, end, &set_len,
441 MBEDTLS_ASN1_CONSTRUCTED |
442 MBEDTLS_ASN1_SET );
443 if( ret != 0 )
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000444 goto exit;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200445
Hanno Becker3470d592019-02-20 09:45:17 +0000446 *end_set = *p + set_len;
447 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200448
Hanno Becker30cb1ac2019-02-20 11:30:29 +0000449 ret = x509_get_attr_type_value( p, *end_set, oid, val );
450
451exit:
452 return( ret );
Hanno Becker3470d592019-02-20 09:45:17 +0000453}
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200454
Hanno Becker88de3422019-02-20 12:41:55 +0000455/*
456 * Like memcmp, but case-insensitive and always returns -1 if different
457 */
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000458int mbedtls_x509_memcasecmp( const void *s1, const void *s2,
459 size_t len1, size_t len2 )
Hanno Becker88de3422019-02-20 12:41:55 +0000460{
461 size_t i;
462 unsigned char diff;
463 const unsigned char *n1 = s1, *n2 = s2;
464
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000465 if( len1 != len2 )
466 return( -1 );
467
468 for( i = 0; i < len1; i++ )
Hanno Becker88de3422019-02-20 12:41:55 +0000469 {
470 diff = n1[i] ^ n2[i];
471
472 if( diff == 0 )
473 continue;
474
475 if( diff == 32 &&
476 ( ( n1[i] >= 'a' && n1[i] <= 'z' ) ||
477 ( n1[i] >= 'A' && n1[i] <= 'Z' ) ) )
478 {
479 continue;
480 }
481
482 return( -1 );
483 }
484
485 return( 0 );
486}
487
488/*
489 * Compare two X.509 strings, case-insensitive, and allowing for some encoding
490 * variations (but not all).
491 *
492 * Return 0 if equal, -1 otherwise.
493 */
494static int x509_string_cmp( const mbedtls_x509_buf *a,
495 const mbedtls_x509_buf *b )
496{
497 if( a->tag == b->tag &&
498 a->len == b->len &&
499 memcmp( a->p, b->p, b->len ) == 0 )
500 {
501 return( 0 );
502 }
503
504 if( ( a->tag == MBEDTLS_ASN1_UTF8_STRING || a->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
505 ( b->tag == MBEDTLS_ASN1_UTF8_STRING || b->tag == MBEDTLS_ASN1_PRINTABLE_STRING ) &&
Hanno Beckerb3def1d2019-02-22 11:46:06 +0000506 mbedtls_x509_memcasecmp( a->p, b->p,
507 a->len, b->len ) == 0 )
Hanno Becker88de3422019-02-20 12:41:55 +0000508 {
509 return( 0 );
510 }
511
512 return( -1 );
513}
514
515/*
Hanno Becker7dee12a2019-02-21 13:58:38 +0000516 * Compare two X.509 Names (aka rdnSequence) given as raw ASN.1 data.
Hanno Becker88de3422019-02-20 12:41:55 +0000517 *
518 * See RFC 5280 section 7.1, though we don't implement the whole algorithm:
Hanno Becker7dee12a2019-02-21 13:58:38 +0000519 * We sometimes return unequal when the full algorithm would return equal,
Hanno Becker88de3422019-02-20 12:41:55 +0000520 * but never the other way. (In particular, we don't do Unicode normalisation
521 * or space folding.)
522 *
Hanno Becker67284cc2019-02-21 14:31:51 +0000523 * Further, this function allows to pass a callback to be triggered for every
524 * pair of well-formed and equal entries in the two input name lists.
525 *
Hanno Becker7dee12a2019-02-21 13:58:38 +0000526 * Returns:
Hanno Becker67284cc2019-02-21 14:31:51 +0000527 * - 0 if both sequences are well-formed, present the same X.509 name,
528 * and the callback (if provided) hasn't returned a non-zero value
529 * on any of the name components.
530 * - 1 if a difference was detected in the name components.
531 * - A non-zero error code if the abort callback returns a non-zero value.
532 * In this case, the returned error code is the error code from the callback.
Hanno Becker7dee12a2019-02-21 13:58:38 +0000533 * - A negative error code if a parsing error occurred in either
534 * of the two buffers.
535 *
536 * This function can be used to verify that a buffer contains a well-formed
537 * ASN.1 encoded X.509 name by calling it with equal parameters.
Hanno Becker88de3422019-02-20 12:41:55 +0000538 */
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000539int mbedtls_x509_name_cmp_raw( mbedtls_x509_buf_raw const *a,
Hanno Becker67284cc2019-02-21 14:31:51 +0000540 mbedtls_x509_buf_raw const *b,
541 int (*abort_check)( void *ctx,
542 mbedtls_x509_buf *oid,
Hanno Becker6b378122019-02-23 10:20:14 +0000543 mbedtls_x509_buf *val,
544 int next_merged ),
Hanno Becker67284cc2019-02-21 14:31:51 +0000545 void *abort_check_ctx )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000546{
547 int ret;
Hanno Becker1e11f212019-03-04 14:43:43 +0000548 size_t idx;
549 unsigned char *p[2], *end[2], *set[2];
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000550
Hanno Becker1e11f212019-03-04 14:43:43 +0000551 p[0] = a->p;
552 p[1] = b->p;
553 end[0] = p[0] + a->len;
554 end[1] = p[1] + b->len;
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000555
Hanno Becker1e11f212019-03-04 14:43:43 +0000556 for( idx = 0; idx < 2; idx++ )
557 {
558 size_t len;
559 ret = mbedtls_asn1_get_tag( &p[idx], end[idx], &len,
560 MBEDTLS_ASN1_CONSTRUCTED |
561 MBEDTLS_ASN1_SEQUENCE );
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000562
Hanno Becker1e11f212019-03-04 14:43:43 +0000563 if( end[idx] != p[idx] + len )
564 {
565 return( MBEDTLS_ERR_X509_INVALID_NAME +
566 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
567 }
568
569 set[idx] = p[idx];
570 }
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000571
572 while( 1 )
573 {
Hanno Becker6b378122019-02-23 10:20:14 +0000574 int next_merged;
Hanno Becker1e11f212019-03-04 14:43:43 +0000575 mbedtls_x509_buf oid[2], val[2];
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000576
Hanno Becker1e11f212019-03-04 14:43:43 +0000577 ret = x509_set_sequence_iterate( &p[0], (const unsigned char **) &set[0],
578 end[0], &oid[0], &val[0] );
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000579 if( ret != 0 )
580 goto exit;
581
Hanno Becker1e11f212019-03-04 14:43:43 +0000582 ret = x509_set_sequence_iterate( &p[1], (const unsigned char **) &set[1],
583 end[1], &oid[1], &val[1] );
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000584 if( ret != 0 )
585 goto exit;
586
Hanno Becker1e11f212019-03-04 14:43:43 +0000587 if( oid[0].len != oid[1].len ||
588 memcmp( oid[0].p, oid[1].p, oid[1].len ) != 0 )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000589 {
590 return( 1 );
591 }
592
Hanno Becker1e11f212019-03-04 14:43:43 +0000593 if( x509_string_cmp( &val[0], &val[1] ) != 0 )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000594 return( 1 );
595
Hanno Becker1e11f212019-03-04 14:43:43 +0000596 next_merged = ( set[0] != p[0] );
597 if( next_merged != ( set[1] != p[1] ) )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000598 return( 1 );
599
Hanno Becker67284cc2019-02-21 14:31:51 +0000600 if( abort_check != NULL )
601 {
Hanno Becker1e11f212019-03-04 14:43:43 +0000602 ret = abort_check( abort_check_ctx, &oid[0], &val[0],
Hanno Becker6b378122019-02-23 10:20:14 +0000603 next_merged );
Hanno Becker67284cc2019-02-21 14:31:51 +0000604 if( ret != 0 )
605 return( ret );
606 }
607
Hanno Becker1e11f212019-03-04 14:43:43 +0000608 if( p[0] == end[0] && p[1] == end[1] )
Hanno Beckera3a2ca12019-02-20 12:42:07 +0000609 break;
610 }
611
612exit:
613 if( ret < 0 )
614 ret += MBEDTLS_ERR_X509_INVALID_NAME;
615
616 return( ret );
617}
618
Hanno Beckerc6573a22019-02-23 09:13:17 +0000619static int x509_get_name_cb( void *ctx,
620 mbedtls_x509_buf *oid,
621 mbedtls_x509_buf *val,
622 int next_merged )
623{
624 mbedtls_x509_name **cur_ptr = (mbedtls_x509_name**) ctx;
625 mbedtls_x509_name *cur = *cur_ptr;
626
627 if( cur->oid.p != NULL )
628 {
629 cur->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
630 if( cur->next == NULL )
631 return( MBEDTLS_ERR_ASN1_ALLOC_FAILED );
632
633 cur = cur->next;
634 }
635
636 cur->oid = *oid;
637 cur->val = *val;
638 cur->next_merged = next_merged;
639
640 *cur_ptr = cur;
641 return( 0 );
642}
Hanno Becker6b378122019-02-23 10:20:14 +0000643
Hanno Becker1e11f212019-03-04 14:43:43 +0000644int mbedtls_x509_get_name( unsigned char *p,
645 size_t len,
Hanno Becker6b378122019-02-23 10:20:14 +0000646 mbedtls_x509_name *cur )
647{
Hanno Becker1e11f212019-03-04 14:43:43 +0000648 mbedtls_x509_buf_raw name_buf = { p, len };
Hanno Beckerc6573a22019-02-23 09:13:17 +0000649 memset( cur, 0, sizeof( mbedtls_x509_name ) );
Hanno Becker1e11f212019-03-04 14:43:43 +0000650 return( mbedtls_x509_name_cmp_raw( &name_buf, &name_buf,
651 x509_get_name_cb,
652 &cur ) );
Hanno Becker6b378122019-02-23 10:20:14 +0000653}
654
Janos Follath87c98072017-02-03 12:36:59 +0000655static int x509_parse_int( unsigned char **p, size_t n, int *res )
656{
Rich Evans7d5a55a2015-02-13 11:48:02 +0000657 *res = 0;
Janos Follath87c98072017-02-03 12:36:59 +0000658
659 for( ; n > 0; --n )
660 {
661 if( ( **p < '0') || ( **p > '9' ) )
662 return ( MBEDTLS_ERR_X509_INVALID_DATE );
663
Rich Evans7d5a55a2015-02-13 11:48:02 +0000664 *res *= 10;
Janos Follath87c98072017-02-03 12:36:59 +0000665 *res += ( *(*p)++ - '0' );
Rich Evans7d5a55a2015-02-13 11:48:02 +0000666 }
Janos Follath87c98072017-02-03 12:36:59 +0000667
668 return( 0 );
Rich Evans7d5a55a2015-02-13 11:48:02 +0000669}
670
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000671static int x509_date_is_valid(const mbedtls_x509_time *t )
Andres AG4b76aec2016-09-23 13:16:02 +0100672{
673 int ret = MBEDTLS_ERR_X509_INVALID_DATE;
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000674 int month_len;
Andres AG4b76aec2016-09-23 13:16:02 +0100675
Hanno Becker61937d42017-04-26 15:01:23 +0100676 CHECK_RANGE( 0, 9999, t->year );
677 CHECK_RANGE( 0, 23, t->hour );
678 CHECK_RANGE( 0, 59, t->min );
679 CHECK_RANGE( 0, 59, t->sec );
Andres AG4b76aec2016-09-23 13:16:02 +0100680
Hanno Becker61937d42017-04-26 15:01:23 +0100681 switch( t->mon )
Andres AG4b76aec2016-09-23 13:16:02 +0100682 {
683 case 1: case 3: case 5: case 7: case 8: case 10: case 12:
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000684 month_len = 31;
Andres AG4b76aec2016-09-23 13:16:02 +0100685 break;
686 case 4: case 6: case 9: case 11:
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000687 month_len = 30;
Andres AG4b76aec2016-09-23 13:16:02 +0100688 break;
689 case 2:
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000690 if( ( !( t->year % 4 ) && t->year % 100 ) ||
691 !( t->year % 400 ) )
692 month_len = 29;
693 else
694 month_len = 28;
Andres AG4b76aec2016-09-23 13:16:02 +0100695 break;
696 default:
697 return( ret );
698 }
Andres Amaya Garcia735b37e2016-11-21 15:38:02 +0000699 CHECK_RANGE( 1, month_len, t->day );
Andres AG4b76aec2016-09-23 13:16:02 +0100700
701 return( 0 );
702}
703
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200704/*
Janos Follath87c98072017-02-03 12:36:59 +0000705 * Parse an ASN1_UTC_TIME (yearlen=2) or ASN1_GENERALIZED_TIME (yearlen=4)
706 * field.
707 */
708static int x509_parse_time( unsigned char **p, size_t len, size_t yearlen,
Hanno Becker61937d42017-04-26 15:01:23 +0100709 mbedtls_x509_time *tm )
Janos Follath87c98072017-02-03 12:36:59 +0000710{
711 int ret;
712
713 /*
714 * Minimum length is 10 or 12 depending on yearlen
715 */
716 if ( len < yearlen + 8 )
717 return ( MBEDTLS_ERR_X509_INVALID_DATE );
718 len -= yearlen + 8;
719
720 /*
721 * Parse year, month, day, hour, minute
722 */
Hanno Becker61937d42017-04-26 15:01:23 +0100723 CHECK( x509_parse_int( p, yearlen, &tm->year ) );
Janos Follath87c98072017-02-03 12:36:59 +0000724 if ( 2 == yearlen )
725 {
Hanno Becker61937d42017-04-26 15:01:23 +0100726 if ( tm->year < 50 )
727 tm->year += 100;
Janos Follath87c98072017-02-03 12:36:59 +0000728
Hanno Becker61937d42017-04-26 15:01:23 +0100729 tm->year += 1900;
Janos Follath87c98072017-02-03 12:36:59 +0000730 }
731
Hanno Becker61937d42017-04-26 15:01:23 +0100732 CHECK( x509_parse_int( p, 2, &tm->mon ) );
733 CHECK( x509_parse_int( p, 2, &tm->day ) );
734 CHECK( x509_parse_int( p, 2, &tm->hour ) );
735 CHECK( x509_parse_int( p, 2, &tm->min ) );
Janos Follath87c98072017-02-03 12:36:59 +0000736
737 /*
738 * Parse seconds if present
739 */
740 if ( len >= 2 )
741 {
Hanno Becker61937d42017-04-26 15:01:23 +0100742 CHECK( x509_parse_int( p, 2, &tm->sec ) );
Janos Follath87c98072017-02-03 12:36:59 +0000743 len -= 2;
744 }
745 else
746 return ( MBEDTLS_ERR_X509_INVALID_DATE );
747
748 /*
749 * Parse trailing 'Z' if present
750 */
751 if ( 1 == len && 'Z' == **p )
752 {
753 (*p)++;
754 len--;
755 }
756
757 /*
758 * We should have parsed all characters at this point
759 */
760 if ( 0 != len )
761 return ( MBEDTLS_ERR_X509_INVALID_DATE );
762
Hanno Becker61937d42017-04-26 15:01:23 +0100763 CHECK( x509_date_is_valid( tm ) );
Janos Follath87c98072017-02-03 12:36:59 +0000764
765 return ( 0 );
766}
767
768/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200769 * Time ::= CHOICE {
770 * utcTime UTCTime,
771 * generalTime GeneralizedTime }
772 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200773int mbedtls_x509_get_time( unsigned char **p, const unsigned char *end,
Hanno Becker61937d42017-04-26 15:01:23 +0100774 mbedtls_x509_time *tm )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200775{
776 int ret;
Janos Follath87c98072017-02-03 12:36:59 +0000777 size_t len, year_len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200778 unsigned char tag;
779
780 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200781 return( MBEDTLS_ERR_X509_INVALID_DATE +
782 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200783
784 tag = **p;
785
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200786 if( tag == MBEDTLS_ASN1_UTC_TIME )
Janos Follath87c98072017-02-03 12:36:59 +0000787 year_len = 2;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200788 else if( tag == MBEDTLS_ASN1_GENERALIZED_TIME )
Janos Follath87c98072017-02-03 12:36:59 +0000789 year_len = 4;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200790 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200791 return( MBEDTLS_ERR_X509_INVALID_DATE +
792 MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
Janos Follath87c98072017-02-03 12:36:59 +0000793
794 (*p)++;
795 ret = mbedtls_asn1_get_len( p, end, &len );
796
797 if( ret != 0 )
798 return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
799
Hanno Becker61937d42017-04-26 15:01:23 +0100800 return x509_parse_time( p, len, year_len, tm );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200801}
802
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200803int mbedtls_x509_get_sig( unsigned char **p, const unsigned char *end, mbedtls_x509_buf *sig )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200804{
805 int ret;
806 size_t len;
Andres AG4bdbe092016-09-19 16:58:45 +0100807 int tag_type;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200808
809 if( ( end - *p ) < 1 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200810 return( MBEDTLS_ERR_X509_INVALID_SIGNATURE +
811 MBEDTLS_ERR_ASN1_OUT_OF_DATA );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200812
Andres AG4bdbe092016-09-19 16:58:45 +0100813 tag_type = **p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200814
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200815 if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
816 return( MBEDTLS_ERR_X509_INVALID_SIGNATURE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200817
Andres AG4bdbe092016-09-19 16:58:45 +0100818 sig->tag = tag_type;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200819 sig->len = len;
820 sig->p = *p;
821
822 *p += len;
823
824 return( 0 );
825}
826
Hanno Beckerb59d3f12019-02-22 17:49:34 +0000827int mbedtls_x509_get_sig_alg_raw( unsigned char **p, unsigned char const *end,
828 mbedtls_md_type_t *md_alg,
829 mbedtls_pk_type_t *pk_alg,
830 void **sig_opts )
831{
832 int ret;
833 mbedtls_asn1_buf alg, params;
834 ret = mbedtls_asn1_get_alg( p, end, &alg, &params );
835 if( ret != 0 )
836 return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
837
838 return( mbedtls_x509_get_sig_alg( &alg, &params, md_alg,
839 pk_alg, sig_opts ) );
840}
841
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100842/*
843 * Get signature algorithm from alg OID and optional parameters
844 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200845int mbedtls_x509_get_sig_alg( const mbedtls_x509_buf *sig_oid, const mbedtls_x509_buf *sig_params,
846 mbedtls_md_type_t *md_alg, mbedtls_pk_type_t *pk_alg,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200847 void **sig_opts )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200848{
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100849 int ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200850
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200851 if( ( ret = mbedtls_oid_get_sig_alg( sig_oid, md_alg, pk_alg ) ) != 0 )
852 return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200853
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200854#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
855 if( *pk_alg == MBEDTLS_PK_RSASSA_PSS )
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100856 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200857 mbedtls_pk_rsassa_pss_options *pss_opts;
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100858
Manuel Pégourié-Gonnard7551cb92015-05-26 16:04:06 +0200859 pss_opts = mbedtls_calloc( 1, sizeof( mbedtls_pk_rsassa_pss_options ) );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200860 if( pss_opts == NULL )
Manuel Pégourié-Gonnard6a8ca332015-05-28 09:33:39 +0200861 return( MBEDTLS_ERR_X509_ALLOC_FAILED );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200862
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200863 ret = mbedtls_x509_get_rsassa_pss_params( sig_params,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200864 md_alg,
865 &pss_opts->mgf1_hash_id,
866 &pss_opts->expected_salt_len );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100867 if( ret != 0 )
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200868 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200869 mbedtls_free( pss_opts );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100870 return( ret );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200871 }
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100872
Hanno Becker1898b682019-02-22 16:03:29 +0000873 if( sig_opts != NULL )
874 *sig_opts = (void *) pss_opts;
875 else
876 mbedtls_free( pss_opts );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100877 }
878 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200879#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100880 {
881 /* Make sure parameters are absent or NULL */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200882 if( ( sig_params->tag != MBEDTLS_ASN1_NULL && sig_params->tag != 0 ) ||
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100883 sig_params->len != 0 )
Hanno Becker1898b682019-02-22 16:03:29 +0000884 return( MBEDTLS_ERR_X509_INVALID_ALG );
885
886 if( sig_opts != NULL )
887 *sig_opts = NULL;
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100888 }
889
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200890 return( 0 );
891}
892
893/*
894 * X.509 Extensions (No parsing of extensions, pointer should
Brian J Murray1903fb32016-11-06 04:45:15 -0800895 * be either manually updated or extensions should be parsed!)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200896 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200897int mbedtls_x509_get_ext( unsigned char **p, const unsigned char *end,
Hanno Becker2f472142019-02-12 11:52:10 +0000898 mbedtls_x509_buf *ext, int tag )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200899{
900 int ret;
901 size_t len;
902
Hanno Beckerc74ce442019-02-11 14:33:36 +0000903 /* Extension structure use EXPLICIT tagging. That is, the actual
904 * `Extensions` structure is wrapped by a tag-length pair using
905 * the respective context-specific tag. */
Hanno Becker2f472142019-02-12 11:52:10 +0000906 ret = mbedtls_asn1_get_tag( p, end, &ext->len,
907 MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag );
908 if( ret != 0 )
909 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200910
Hanno Becker2f472142019-02-12 11:52:10 +0000911 ext->tag = MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag;
912 ext->p = *p;
913 end = *p + ext->len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200914
915 /*
916 * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200917 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200918 if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
919 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
920 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200921
922 if( end != *p + len )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200923 return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
924 MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200925
926 return( 0 );
927}
928
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200929/*
930 * Store the name in printable form into buf; no more
931 * than size characters will be written
932 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200933int mbedtls_x509_dn_gets( char *buf, size_t size, const mbedtls_x509_name *dn )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200934{
935 int ret;
936 size_t i, n;
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000937 unsigned char c, merge = 0;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200938 const mbedtls_x509_name *name;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200939 const char *short_name = NULL;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200940 char s[MBEDTLS_X509_MAX_DN_NAME_SIZE], *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200941
942 memset( s, 0, sizeof( s ) );
943
944 name = dn;
945 p = buf;
946 n = size;
947
948 while( name != NULL )
949 {
950 if( !name->oid.p )
951 {
952 name = name->next;
953 continue;
954 }
955
956 if( name != dn )
957 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200958 ret = mbedtls_snprintf( p, n, merge ? " + " : ", " );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +0200959 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200960 }
961
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200962 ret = mbedtls_oid_get_attr_short_name( &name->oid, &short_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200963
964 if( ret == 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200965 ret = mbedtls_snprintf( p, n, "%s=", short_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200966 else
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200967 ret = mbedtls_snprintf( p, n, "\?\?=" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +0200968 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200969
970 for( i = 0; i < name->val.len; i++ )
971 {
972 if( i >= sizeof( s ) - 1 )
973 break;
974
975 c = name->val.p[i];
976 if( c < 32 || c == 127 || ( c > 128 && c < 160 ) )
977 s[i] = '?';
978 else s[i] = c;
979 }
980 s[i] = '\0';
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200981 ret = mbedtls_snprintf( p, n, "%s", s );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +0200982 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000983
984 merge = name->next_merged;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200985 name = name->next;
986 }
987
988 return( (int) ( size - n ) );
989}
990
991/*
992 * Store the serial in printable form into buf; no more
993 * than size characters will be written
994 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +0200995int mbedtls_x509_serial_gets( char *buf, size_t size, const mbedtls_x509_buf *serial )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200996{
997 int ret;
998 size_t i, n, nr;
999 char *p;
1000
1001 p = buf;
1002 n = size;
1003
1004 nr = ( serial->len <= 32 )
1005 ? serial->len : 28;
1006
1007 for( i = 0; i < nr; i++ )
1008 {
1009 if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
1010 continue;
1011
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001012 ret = mbedtls_snprintf( p, n, "%02X%s",
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001013 serial->p[i], ( i < nr - 1 ) ? ":" : "" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001014 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001015 }
1016
1017 if( nr != serial->len )
1018 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001019 ret = mbedtls_snprintf( p, n, "...." );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001020 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001021 }
1022
1023 return( (int) ( size - n ) );
1024}
1025
Hanno Becker02a21932019-06-10 15:08:43 +01001026#if !defined(MBEDTLS_X509_REMOVE_INFO)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001027/*
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +02001028 * Helper for writing signature algorithms
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001029 */
Hanno Becker83cd8672019-02-21 17:13:46 +00001030int mbedtls_x509_sig_alg_gets( char *buf, size_t size, mbedtls_pk_type_t pk_alg,
1031 mbedtls_md_type_t md_alg, const void *sig_opts )
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001032{
1033 int ret;
1034 char *p = buf;
1035 size_t n = size;
1036 const char *desc = NULL;
Hanno Becker83cd8672019-02-21 17:13:46 +00001037 mbedtls_x509_buf sig_oid;
1038 mbedtls_md_type_t tmp_md_alg = md_alg;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001039
Hanno Becker83cd8672019-02-21 17:13:46 +00001040#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1041 /* The hash for RSASSA is determined by the algorithm parameters;
1042 * in the OID list, the hash is set to MBEDTLS_MD_NONE. */
1043 if( pk_alg == MBEDTLS_PK_RSASSA_PSS )
1044 tmp_md_alg = MBEDTLS_MD_NONE;
1045#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
1046
1047 sig_oid.tag = MBEDTLS_ASN1_OID;
1048 ret = mbedtls_oid_get_oid_by_sig_alg( pk_alg, tmp_md_alg,
1049 (const char**) &sig_oid.p,
1050 &sig_oid.len );
1051 if( ret == 0 &&
1052 mbedtls_oid_get_sig_alg_desc( &sig_oid, &desc ) == 0 )
1053 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001054 ret = mbedtls_snprintf( p, n, "%s", desc );
Hanno Becker83cd8672019-02-21 17:13:46 +00001055 }
1056 else
1057 ret = mbedtls_snprintf( p, n, "???" );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001058 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001059
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001060#if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
1061 if( pk_alg == MBEDTLS_PK_RSASSA_PSS )
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001062 {
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001063 const mbedtls_pk_rsassa_pss_options *pss_opts;
1064 const mbedtls_md_info_t *md_info, *mgf_md_info;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001065
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001066 pss_opts = (const mbedtls_pk_rsassa_pss_options *) sig_opts;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001067
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001068 md_info = mbedtls_md_info_from_type( md_alg );
1069 mgf_md_info = mbedtls_md_info_from_type( pss_opts->mgf1_hash_id );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001070
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001071 ret = mbedtls_snprintf( p, n, " (%s, MGF1-%s, 0x%02X)",
1072 md_info ? mbedtls_md_get_name( md_info ) : "???",
1073 mgf_md_info ? mbedtls_md_get_name( mgf_md_info ) : "???",
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +02001074 pss_opts->expected_salt_len );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001075 MBEDTLS_X509_SAFE_SNPRINTF;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001076 }
1077#else
1078 ((void) pk_alg);
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +02001079 ((void) md_alg);
1080 ((void) sig_opts);
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001081#endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001082
Sander Niemeijeref5087d2014-08-16 12:45:52 +02001083 return( (int)( size - n ) );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001084}
Hanno Becker02a21932019-06-10 15:08:43 +01001085#endif /* !MBEDTLS_X509_REMOVE_INFO */
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +01001086
1087/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001088 * Helper for writing "RSA key size", "EC key size", etc
1089 */
Manuel Pégourié-Gonnardfb317c52015-06-18 16:25:56 +02001090int mbedtls_x509_key_size_helper( char *buf, size_t buf_size, const char *name )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001091{
1092 char *p = buf;
Manuel Pégourié-Gonnardfb317c52015-06-18 16:25:56 +02001093 size_t n = buf_size;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001094 int ret;
1095
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001096 ret = mbedtls_snprintf( p, n, "%s key size", name );
Manuel Pégourié-Gonnard16853682015-06-22 11:12:02 +02001097 MBEDTLS_X509_SAFE_SNPRINTF;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001098
1099 return( 0 );
1100}
1101
Manuel Pégourié-Gonnard60c793b2015-06-18 20:52:58 +02001102#if defined(MBEDTLS_HAVE_TIME_DATE)
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001103/*
1104 * Set the time structure to the current time.
1105 * Return 0 on success, non-zero on failure.
1106 */
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001107static int x509_get_current_time( mbedtls_x509_time *now )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001108{
Nicholas Wilson512b4ee2017-12-05 12:07:33 +00001109 struct tm *lt, tm_buf;
SimonBd5800b72016-04-26 07:43:27 +01001110 mbedtls_time_t tt;
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001111 int ret = 0;
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001112
SimonBd5800b72016-04-26 07:43:27 +01001113 tt = mbedtls_time( NULL );
Hanno Becker6a739782018-09-05 15:06:19 +01001114 lt = mbedtls_platform_gmtime_r( &tt, &tm_buf );
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001115
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001116 if( lt == NULL )
1117 ret = -1;
1118 else
1119 {
1120 now->year = lt->tm_year + 1900;
1121 now->mon = lt->tm_mon + 1;
1122 now->day = lt->tm_mday;
1123 now->hour = lt->tm_hour;
1124 now->min = lt->tm_min;
1125 now->sec = lt->tm_sec;
1126 }
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001127
Manuel Pégourié-Gonnard57e10d72015-06-22 18:59:21 +02001128 return( ret );
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001129}
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001130
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001131/*
1132 * Return 0 if before <= after, 1 otherwise
1133 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001134static int x509_check_time( const mbedtls_x509_time *before, const mbedtls_x509_time *after )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001135{
1136 if( before->year > after->year )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001137 return( 1 );
1138
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001139 if( before->year == after->year &&
1140 before->mon > after->mon )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001141 return( 1 );
1142
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001143 if( before->year == after->year &&
1144 before->mon == after->mon &&
1145 before->day > after->day )
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 &&
1151 before->hour > after->hour )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001152 return( 1 );
1153
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001154 if( before->year == after->year &&
1155 before->mon == after->mon &&
1156 before->day == after->day &&
1157 before->hour == after->hour &&
1158 before->min > after->min )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001159 return( 1 );
1160
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001161 if( before->year == after->year &&
1162 before->mon == after->mon &&
1163 before->day == after->day &&
1164 before->hour == after->hour &&
1165 before->min == after->min &&
1166 before->sec > after->sec )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001167 return( 1 );
1168
1169 return( 0 );
1170}
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001171
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001172int mbedtls_x509_time_is_past( const mbedtls_x509_time *to )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001173{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001174 mbedtls_x509_time now;
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001175
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001176 if( x509_get_current_time( &now ) != 0 )
Manuel Pégourié-Gonnarde7e89842015-06-22 19:15:32 +02001177 return( 1 );
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001178
1179 return( x509_check_time( &now, to ) );
1180}
1181
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001182int mbedtls_x509_time_is_future( const mbedtls_x509_time *from )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001183{
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001184 mbedtls_x509_time now;
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001185
Manuel Pégourié-Gonnard864108d2015-05-29 10:11:03 +02001186 if( x509_get_current_time( &now ) != 0 )
Manuel Pégourié-Gonnarde7e89842015-06-22 19:15:32 +02001187 return( 1 );
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001188
1189 return( x509_check_time( from, &now ) );
1190}
1191
Manuel Pégourié-Gonnard60c793b2015-06-18 20:52:58 +02001192#else /* MBEDTLS_HAVE_TIME_DATE */
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001193
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001194int mbedtls_x509_time_is_past( const mbedtls_x509_time *to )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001195{
1196 ((void) to);
1197 return( 0 );
1198}
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001199
Manuel Pégourié-Gonnardc730ed32015-06-02 10:38:50 +01001200int mbedtls_x509_time_is_future( const mbedtls_x509_time *from )
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001201{
1202 ((void) from);
1203 return( 0 );
1204}
Manuel Pégourié-Gonnard60c793b2015-06-18 20:52:58 +02001205#endif /* MBEDTLS_HAVE_TIME_DATE */
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001206
Hanno Becker2bcc7642019-02-26 19:01:00 +00001207void mbedtls_x509_name_free( mbedtls_x509_name *name )
1208{
1209 while( name != NULL )
1210 {
1211 mbedtls_x509_name *next = name->next;
1212 mbedtls_platform_zeroize( name, sizeof( *name ) );
1213 mbedtls_free( name );
1214 name = next;
1215 }
1216}
1217
1218void mbedtls_x509_sequence_free( mbedtls_x509_sequence *seq )
1219{
1220 while( seq != NULL )
1221 {
1222 mbedtls_x509_sequence *next = seq->next;
1223 mbedtls_platform_zeroize( seq, sizeof( *seq ) );
1224 mbedtls_free( seq );
1225 seq = next;
1226 }
1227}
1228
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001229#if defined(MBEDTLS_SELF_TEST)
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001230
Manuel Pégourié-Gonnard7f809972015-03-09 17:05:11 +00001231#include "mbedtls/x509_crt.h"
1232#include "mbedtls/certs.h"
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001233
1234/*
1235 * Checkup routine
1236 */
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001237int mbedtls_x509_self_test( int verbose )
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001238{
Junhwan Park60ee28b2018-10-17 21:01:08 +09001239 int ret = 0;
Gilles Peskine750c3532017-05-05 18:56:30 +02001240#if defined(MBEDTLS_CERTS_C) && defined(MBEDTLS_SHA256_C)
Manuel Pégourié-Gonnarde6ef16f2015-05-11 19:54:43 +02001241 uint32_t flags;
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001242 mbedtls_x509_crt cacert;
1243 mbedtls_x509_crt clicert;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001244
1245 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001246 mbedtls_printf( " X.509 certificate load: " );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001247
Junhwan Park60ee28b2018-10-17 21:01:08 +09001248 mbedtls_x509_crt_init( &cacert );
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001249 mbedtls_x509_crt_init( &clicert );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001250
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001251 ret = mbedtls_x509_crt_parse( &clicert, (const unsigned char *) mbedtls_test_cli_crt,
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001252 mbedtls_test_cli_crt_len );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001253 if( ret != 0 )
1254 {
1255 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001256 mbedtls_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001257
Junhwan Park60ee28b2018-10-17 21:01:08 +09001258 goto cleanup;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001259 }
1260
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001261 ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_ca_crt,
Manuel Pégourié-Gonnard43b37cb2015-05-12 11:20:10 +02001262 mbedtls_test_ca_crt_len );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001263 if( ret != 0 )
1264 {
1265 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001266 mbedtls_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001267
Junhwan Park60ee28b2018-10-17 21:01:08 +09001268 goto cleanup;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001269 }
1270
1271 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001272 mbedtls_printf( "passed\n X.509 signature verify: ");
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001273
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001274 ret = mbedtls_x509_crt_verify( &clicert, &cacert, NULL, NULL, &flags, NULL, NULL );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001275 if( ret != 0 )
1276 {
1277 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001278 mbedtls_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001279
Junhwan Park60ee28b2018-10-17 21:01:08 +09001280 goto cleanup;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001281 }
1282
1283 if( verbose != 0 )
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001284 mbedtls_printf( "passed\n\n");
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001285
Junhwan Park60ee28b2018-10-17 21:01:08 +09001286cleanup:
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001287 mbedtls_x509_crt_free( &cacert );
1288 mbedtls_x509_crt_free( &clicert );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001289#else
1290 ((void) verbose);
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001291#endif /* MBEDTLS_CERTS_C && MBEDTLS_SHA1_C */
Junhwan Park60ee28b2018-10-17 21:01:08 +09001292 return( ret );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001293}
1294
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001295#endif /* MBEDTLS_SELF_TEST */
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001296
Manuel Pégourié-Gonnard2cf5a7c2015-04-08 12:49:31 +02001297#endif /* MBEDTLS_X509_USE_C */