blob: 857b8a3441914b255b9012839c494fbfc82fd564 [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é-Gonnarda658a402015-01-23 09:45:19 +00004 * Copyright (C) 2006-2014, ARM Limited, All Rights Reserved
Paul Bakker7c6b2c32013-09-16 13:49:26 +02005 *
Manuel Pégourié-Gonnardfe446432015-03-06 13:17:10 +00006 * This file is part of mbed TLS (https://tls.mbed.org)
Paul Bakker7c6b2c32013-09-16 13:49:26 +02007 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +02008 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 */
22/*
23 * The ITU-T X.509 standard defines a certificate format for PKI.
24 *
Manuel Pégourié-Gonnard1c082f32014-06-12 22:34:55 +020025 * http://www.ietf.org/rfc/rfc5280.txt (Certificates and CRLs)
26 * http://www.ietf.org/rfc/rfc3279.txt (Alg IDs for CRLs)
27 * http://www.ietf.org/rfc/rfc2986.txt (CSRs, aka PKCS#10)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020028 *
29 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.680-0207.pdf
30 * http://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf
31 */
32
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020033#if !defined(POLARSSL_CONFIG_FILE)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020034#include "polarssl/config.h"
Manuel Pégourié-Gonnardcef4ad22014-04-29 12:39:06 +020035#else
36#include POLARSSL_CONFIG_FILE
37#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +020038
39#if defined(POLARSSL_X509_USE_C)
40
41#include "polarssl/x509.h"
42#include "polarssl/asn1.h"
43#include "polarssl/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
Paul Bakker7c6b2c32013-09-16 13:49:26 +020048#if defined(POLARSSL_PEM_PARSE_C)
49#include "polarssl/pem.h"
50#endif
51
Paul Bakker7dc4c442014-02-01 22:50:26 +010052#if defined(POLARSSL_PLATFORM_C)
53#include "polarssl/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>
Paul Bakker7c6b2c32013-09-16 13:49:26 +020057#define polarssl_free free
Rich Evansfac657f2015-01-30 11:00:01 +000058#define polarssl_malloc malloc
59#define polarssl_printf printf
60#define polarssl_snprintf snprintf
Paul Bakker7c6b2c32013-09-16 13:49:26 +020061#endif
62
Paul Bakkerfa6a6202013-10-28 18:48:30 +010063#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +020064#include <windows.h>
65#else
66#include <time.h>
67#endif
68
69#if defined(POLARSSL_FS_IO)
Rich Evans36796df2015-02-12 18:27:14 +000070#include <stdio.h>
Paul Bakker7c6b2c32013-09-16 13:49:26 +020071#if !defined(_WIN32)
72#include <sys/types.h>
73#include <sys/stat.h>
74#include <dirent.h>
75#endif
76#endif
77
Rich Evans7d5a55a2015-02-13 11:48:02 +000078#define CHECK(code) if( ( ret = code ) != 0 ){ return( ret ); }
79
Paul Bakker7c6b2c32013-09-16 13:49:26 +020080/*
81 * CertificateSerialNumber ::= INTEGER
82 */
83int x509_get_serial( unsigned char **p, const unsigned char *end,
84 x509_buf *serial )
85{
86 int ret;
87
88 if( ( end - *p ) < 1 )
Paul Bakker51876562013-09-17 14:36:05 +020089 return( POLARSSL_ERR_X509_INVALID_SERIAL +
Paul Bakker7c6b2c32013-09-16 13:49:26 +020090 POLARSSL_ERR_ASN1_OUT_OF_DATA );
91
92 if( **p != ( ASN1_CONTEXT_SPECIFIC | ASN1_PRIMITIVE | 2 ) &&
93 **p != ASN1_INTEGER )
Paul Bakker51876562013-09-17 14:36:05 +020094 return( POLARSSL_ERR_X509_INVALID_SERIAL +
Paul Bakker7c6b2c32013-09-16 13:49:26 +020095 POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
96
97 serial->tag = *(*p)++;
98
99 if( ( ret = asn1_get_len( p, end, &serial->len ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200100 return( POLARSSL_ERR_X509_INVALID_SERIAL + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200101
102 serial->p = *p;
103 *p += serial->len;
104
105 return( 0 );
106}
107
108/* Get an algorithm identifier without parameters (eg for signatures)
109 *
110 * AlgorithmIdentifier ::= SEQUENCE {
111 * algorithm OBJECT IDENTIFIER,
112 * parameters ANY DEFINED BY algorithm OPTIONAL }
113 */
114int x509_get_alg_null( unsigned char **p, const unsigned char *end,
115 x509_buf *alg )
116{
117 int ret;
118
119 if( ( ret = asn1_get_alg_null( p, end, alg ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200120 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200121
122 return( 0 );
123}
124
125/*
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100126 * Parse an algorithm identifier with (optional) paramaters
127 */
128int x509_get_alg( unsigned char **p, const unsigned char *end,
129 x509_buf *alg, x509_buf *params )
130{
131 int ret;
132
133 if( ( ret = asn1_get_alg( p, end, alg, params ) ) != 0 )
134 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
135
136 return( 0 );
137}
138
Manuel Pégourié-Gonnardd1539b12014-06-06 16:42:37 +0200139#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
Manuel Pégourié-Gonnard59a75d52014-01-22 10:12:57 +0100140/*
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100141 * HashAlgorithm ::= AlgorithmIdentifier
142 *
143 * AlgorithmIdentifier ::= SEQUENCE {
144 * algorithm OBJECT IDENTIFIER,
145 * parameters ANY DEFINED BY algorithm OPTIONAL }
146 *
147 * For HashAlgorithm, parameters MUST be NULL or absent.
148 */
149static int x509_get_hash_alg( const x509_buf *alg, md_type_t *md_alg )
150{
151 int ret;
152 unsigned char *p;
153 const unsigned char *end;
154 x509_buf md_oid;
155 size_t len;
156
157 /* Make sure we got a SEQUENCE and setup bounds */
158 if( alg->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
159 return( POLARSSL_ERR_X509_INVALID_ALG +
160 POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
161
162 p = (unsigned char *) alg->p;
163 end = p + alg->len;
164
165 if( p >= end )
166 return( POLARSSL_ERR_X509_INVALID_ALG +
167 POLARSSL_ERR_ASN1_OUT_OF_DATA );
168
169 /* Parse md_oid */
170 md_oid.tag = *p;
171
172 if( ( ret = asn1_get_tag( &p, end, &md_oid.len, ASN1_OID ) ) != 0 )
173 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
174
175 md_oid.p = p;
176 p += md_oid.len;
177
178 /* Get md_alg from md_oid */
179 if( ( ret = oid_get_md_alg( &md_oid, md_alg ) ) != 0 )
180 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
181
182 /* Make sure params is absent of NULL */
183 if( p == end )
184 return( 0 );
185
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100186 if( ( ret = asn1_get_tag( &p, end, &len, ASN1_NULL ) ) != 0 || len != 0 )
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100187 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
188
189 if( p != end )
190 return( POLARSSL_ERR_X509_INVALID_ALG +
191 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
192
193 return( 0 );
194}
195
196/*
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100197 * RSASSA-PSS-params ::= SEQUENCE {
198 * hashAlgorithm [0] HashAlgorithm DEFAULT sha1Identifier,
199 * maskGenAlgorithm [1] MaskGenAlgorithm DEFAULT mgf1SHA1Identifier,
200 * saltLength [2] INTEGER DEFAULT 20,
201 * trailerField [3] INTEGER DEFAULT 1 }
202 * -- Note that the tags in this Sequence are explicit.
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200203 *
204 * RFC 4055 (which defines use of RSASSA-PSS in PKIX) states that the value
205 * of trailerField MUST be 1, and PKCS#1 v2.2 doesn't even define any other
206 * option. Enfore this at parsing time.
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100207 */
208int x509_get_rsassa_pss_params( const x509_buf *params,
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100209 md_type_t *md_alg, md_type_t *mgf_md,
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200210 int *salt_len )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100211{
212 int ret;
213 unsigned char *p;
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100214 const unsigned char *end, *end2;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100215 size_t len;
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100216 x509_buf alg_id, alg_params;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100217
218 /* First set everything to defaults */
219 *md_alg = POLARSSL_MD_SHA1;
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100220 *mgf_md = POLARSSL_MD_SHA1;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100221 *salt_len = 20;
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100222
223 /* Make sure params is a SEQUENCE and setup bounds */
224 if( params->tag != ( ASN1_CONSTRUCTED | ASN1_SEQUENCE ) )
225 return( POLARSSL_ERR_X509_INVALID_ALG +
226 POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
227
228 p = (unsigned char *) params->p;
229 end = p + params->len;
230
231 if( p == end )
232 return( 0 );
233
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100234 /*
235 * HashAlgorithm
236 */
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100237 if( ( ret = asn1_get_tag( &p, end, &len,
238 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 0 ) ) == 0 )
239 {
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100240 end2 = p + len;
241
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100242 /* HashAlgorithm ::= AlgorithmIdentifier (without parameters) */
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100243 if( ( ret = x509_get_alg_null( &p, end2, &alg_id ) ) != 0 )
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100244 return( ret );
245
246 if( ( ret = oid_get_md_alg( &alg_id, md_alg ) ) != 0 )
247 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100248
249 if( p != end2 )
250 return( POLARSSL_ERR_X509_INVALID_ALG +
251 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100252 }
253 else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
254 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
255
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100256 if( p == end )
257 return( 0 );
258
259 /*
260 * MaskGenAlgorithm
261 */
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100262 if( ( ret = asn1_get_tag( &p, end, &len,
263 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 1 ) ) == 0 )
264 {
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100265 end2 = p + len;
266
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100267 /* MaskGenAlgorithm ::= AlgorithmIdentifier (params = HashAlgorithm) */
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100268 if( ( ret = x509_get_alg( &p, end2, &alg_id, &alg_params ) ) != 0 )
Manuel Pégourié-Gonnarde76b7502014-01-23 19:15:29 +0100269 return( ret );
270
271 /* Only MFG1 is recognised for now */
272 if( ! OID_CMP( OID_MGF1, &alg_id ) )
273 return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE +
274 POLARSSL_ERR_OID_NOT_FOUND );
275
276 /* Parse HashAlgorithm */
277 if( ( ret = x509_get_hash_alg( &alg_params, mgf_md ) ) != 0 )
278 return( ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100279
280 if( p != end2 )
281 return( POLARSSL_ERR_X509_INVALID_ALG +
282 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100283 }
284 else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
285 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
286
287 if( p == end )
288 return( 0 );
289
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100290 /*
291 * salt_len
292 */
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100293 if( ( ret = asn1_get_tag( &p, end, &len,
294 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 2 ) ) == 0 )
295 {
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100296 end2 = p + len;
297
298 if( ( ret = asn1_get_int( &p, end2, salt_len ) ) != 0 )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100299 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100300
301 if( p != end2 )
302 return( POLARSSL_ERR_X509_INVALID_ALG +
303 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100304 }
305 else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
306 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
307
308 if( p == end )
309 return( 0 );
310
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100311 /*
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200312 * trailer_field (if present, must be 1)
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100313 */
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100314 if( ( ret = asn1_get_tag( &p, end, &len,
315 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | 3 ) ) == 0 )
316 {
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200317 int trailer_field;
318
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100319 end2 = p + len;
320
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200321 if( ( ret = asn1_get_int( &p, end2, &trailer_field ) ) != 0 )
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100322 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
Manuel Pégourié-Gonnard9c9cf5b2014-01-24 14:15:20 +0100323
324 if( p != end2 )
325 return( POLARSSL_ERR_X509_INVALID_ALG +
326 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
Manuel Pégourié-Gonnard78117d52014-05-31 17:08:16 +0200327
328 if( trailer_field != 1 )
329 return( POLARSSL_ERR_X509_INVALID_ALG );
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100330 }
331 else if( ret != POLARSSL_ERR_ASN1_UNEXPECTED_TAG )
332 return( POLARSSL_ERR_X509_INVALID_ALG + ret );
333
334 if( p != end )
335 return( POLARSSL_ERR_X509_INVALID_ALG +
336 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
337
338 return( 0 );
339}
Manuel Pégourié-Gonnardd1539b12014-06-06 16:42:37 +0200340#endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardf346bab2014-01-23 16:24:44 +0100341
342/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200343 * AttributeTypeAndValue ::= SEQUENCE {
344 * type AttributeType,
345 * value AttributeValue }
346 *
347 * AttributeType ::= OBJECT IDENTIFIER
348 *
349 * AttributeValue ::= ANY DEFINED BY AttributeType
350 */
351static int x509_get_attr_type_value( unsigned char **p,
352 const unsigned char *end,
353 x509_name *cur )
354{
355 int ret;
356 size_t len;
357 x509_buf *oid;
358 x509_buf *val;
359
360 if( ( ret = asn1_get_tag( p, end, &len,
361 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200362 return( POLARSSL_ERR_X509_INVALID_NAME + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200363
364 if( ( end - *p ) < 1 )
Paul Bakker51876562013-09-17 14:36:05 +0200365 return( POLARSSL_ERR_X509_INVALID_NAME +
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200366 POLARSSL_ERR_ASN1_OUT_OF_DATA );
367
368 oid = &cur->oid;
369 oid->tag = **p;
370
371 if( ( ret = asn1_get_tag( p, end, &oid->len, ASN1_OID ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200372 return( POLARSSL_ERR_X509_INVALID_NAME + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200373
374 oid->p = *p;
375 *p += oid->len;
376
377 if( ( end - *p ) < 1 )
Paul Bakker51876562013-09-17 14:36:05 +0200378 return( POLARSSL_ERR_X509_INVALID_NAME +
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200379 POLARSSL_ERR_ASN1_OUT_OF_DATA );
380
381 if( **p != ASN1_BMP_STRING && **p != ASN1_UTF8_STRING &&
382 **p != ASN1_T61_STRING && **p != ASN1_PRINTABLE_STRING &&
Manuel Pégourié-Gonnarddd5dbca2015-03-27 13:03:09 +0100383 **p != ASN1_IA5_STRING && **p != ASN1_UNIVERSAL_STRING &&
384 **p != ASN1_BIT_STRING )
Paul Bakker51876562013-09-17 14:36:05 +0200385 return( POLARSSL_ERR_X509_INVALID_NAME +
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200386 POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
387
388 val = &cur->val;
389 val->tag = *(*p)++;
390
391 if( ( ret = asn1_get_len( p, end, &val->len ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200392 return( POLARSSL_ERR_X509_INVALID_NAME + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200393
394 val->p = *p;
395 *p += val->len;
396
397 cur->next = NULL;
398
399 return( 0 );
400}
401
402/*
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000403 * Name ::= CHOICE { -- only one possibility for now --
404 * rdnSequence RDNSequence }
405 *
406 * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
407 *
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200408 * RelativeDistinguishedName ::=
409 * SET OF AttributeTypeAndValue
410 *
411 * AttributeTypeAndValue ::= SEQUENCE {
412 * type AttributeType,
413 * value AttributeValue }
414 *
415 * AttributeType ::= OBJECT IDENTIFIER
416 *
417 * AttributeValue ::= ANY DEFINED BY AttributeType
Manuel Pégourié-Gonnard5d861852014-10-17 12:41:41 +0200418 *
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000419 * The data structure is optimized for the common case where each RDN has only
420 * one element, which is represented as a list of AttributeTypeAndValue.
421 * For the general case we still use a flat list, but we mark elements of the
422 * same set so that they are "merged" together in the functions that consume
423 * this list, eg x509_dn_gets().
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200424 */
425int x509_get_name( unsigned char **p, const unsigned char *end,
426 x509_name *cur )
427{
428 int ret;
Manuel Pégourié-Gonnard5d861852014-10-17 12:41:41 +0200429 size_t set_len;
430 const unsigned char *end_set;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200431
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100432 /* don't use recursion, we'd risk stack overflow if not optimized */
433 while( 1 )
434 {
435 /*
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000436 * parse SET
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100437 */
438 if( ( ret = asn1_get_tag( p, end, &set_len,
439 ASN1_CONSTRUCTED | ASN1_SET ) ) != 0 )
440 return( POLARSSL_ERR_X509_INVALID_NAME + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200441
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100442 end_set = *p + set_len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200443
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000444 while( 1 )
445 {
446 if( ( ret = x509_get_attr_type_value( p, end_set, cur ) ) != 0 )
447 return( ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200448
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000449 if( *p == end_set )
450 break;
451
452 /* Mark this item as being only one in a set */
453 cur->next_merged = 1;
454
Mansour Moufidc531b4a2015-02-15 17:35:38 -0500455 cur->next = polarssl_malloc( sizeof( x509_name ) );
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000456
457 if( cur->next == NULL )
458 return( POLARSSL_ERR_X509_MALLOC_FAILED );
459
460 memset( cur->next, 0, sizeof( x509_name ) );
461
462 cur = cur->next;
463 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200464
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100465 /*
466 * continue until end of SEQUENCE is reached
467 */
468 if( *p == end )
469 return( 0 );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200470
Mansour Moufidc531b4a2015-02-15 17:35:38 -0500471 cur->next = polarssl_malloc( sizeof( x509_name ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200472
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100473 if( cur->next == NULL )
474 return( POLARSSL_ERR_X509_MALLOC_FAILED );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200475
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100476 memset( cur->next, 0, sizeof( x509_name ) );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200477
Manuel Pégourié-Gonnardd6814432014-11-12 01:25:31 +0100478 cur = cur->next;
479 }
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200480}
481
Rich Evans7d5a55a2015-02-13 11:48:02 +0000482static int x509_parse_int(unsigned char **p, unsigned n, int *res){
483 *res = 0;
484 for( ; n > 0; --n ){
485 if( ( **p < '0') || ( **p > '9' ) ) return POLARSSL_ERR_X509_INVALID_DATE;
486 *res *= 10;
487 *res += (*(*p)++ - '0');
488 }
489 return 0;
490}
491
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200492/*
493 * Time ::= CHOICE {
494 * utcTime UTCTime,
495 * generalTime GeneralizedTime }
496 */
497int x509_get_time( unsigned char **p, const unsigned char *end,
498 x509_time *time )
499{
500 int ret;
501 size_t len;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200502 unsigned char tag;
503
504 if( ( end - *p ) < 1 )
Paul Bakker51876562013-09-17 14:36:05 +0200505 return( POLARSSL_ERR_X509_INVALID_DATE +
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200506 POLARSSL_ERR_ASN1_OUT_OF_DATA );
507
508 tag = **p;
509
Paul Bakker66d5d072014-06-17 16:39:18 +0200510 if( tag == ASN1_UTC_TIME )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200511 {
512 (*p)++;
513 ret = asn1_get_len( p, end, &len );
Paul Bakker51876562013-09-17 14:36:05 +0200514
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200515 if( ret != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200516 return( POLARSSL_ERR_X509_INVALID_DATE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200517
Rich Evans7d5a55a2015-02-13 11:48:02 +0000518 CHECK( x509_parse_int( p, 2, &time->year ) );
519 CHECK( x509_parse_int( p, 2, &time->mon ) );
520 CHECK( x509_parse_int( p, 2, &time->day ) );
521 CHECK( x509_parse_int( p, 2, &time->hour ) );
522 CHECK( x509_parse_int( p, 2, &time->min ) );
523 if( len > 10 )
524 CHECK( x509_parse_int( p, 2, &time->sec ) );
525 if( len > 12 && *(*p)++ != 'Z' )
Paul Bakker51876562013-09-17 14:36:05 +0200526 return( POLARSSL_ERR_X509_INVALID_DATE );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200527
528 time->year += 100 * ( time->year < 50 );
529 time->year += 1900;
530
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200531 return( 0 );
532 }
Paul Bakker66d5d072014-06-17 16:39:18 +0200533 else if( tag == ASN1_GENERALIZED_TIME )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200534 {
535 (*p)++;
536 ret = asn1_get_len( p, end, &len );
Paul Bakker51876562013-09-17 14:36:05 +0200537
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200538 if( ret != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200539 return( POLARSSL_ERR_X509_INVALID_DATE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200540
Rich Evans7d5a55a2015-02-13 11:48:02 +0000541 CHECK( x509_parse_int( p, 4, &time->year ) );
542 CHECK( x509_parse_int( p, 2, &time->mon ) );
543 CHECK( x509_parse_int( p, 2, &time->day ) );
544 CHECK( x509_parse_int( p, 2, &time->hour ) );
545 CHECK( x509_parse_int( p, 2, &time->min ) );
546 if( len > 12 )
547 CHECK( x509_parse_int( p, 2, &time->sec ) );
548 if( len > 14 && *(*p)++ != 'Z' )
Paul Bakker51876562013-09-17 14:36:05 +0200549 return( POLARSSL_ERR_X509_INVALID_DATE );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200550
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200551 return( 0 );
552 }
553 else
Paul Bakker51876562013-09-17 14:36:05 +0200554 return( POLARSSL_ERR_X509_INVALID_DATE +
555 POLARSSL_ERR_ASN1_UNEXPECTED_TAG );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200556}
557
558int x509_get_sig( unsigned char **p, const unsigned char *end, x509_buf *sig )
559{
560 int ret;
561 size_t len;
562
563 if( ( end - *p ) < 1 )
Paul Bakker51876562013-09-17 14:36:05 +0200564 return( POLARSSL_ERR_X509_INVALID_SIGNATURE +
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200565 POLARSSL_ERR_ASN1_OUT_OF_DATA );
566
567 sig->tag = **p;
568
569 if( ( ret = asn1_get_bitstring_null( p, end, &len ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200570 return( POLARSSL_ERR_X509_INVALID_SIGNATURE + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200571
572 sig->len = len;
573 sig->p = *p;
574
575 *p += len;
576
577 return( 0 );
578}
579
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100580/*
581 * Get signature algorithm from alg OID and optional parameters
582 */
583int x509_get_sig_alg( const x509_buf *sig_oid, const x509_buf *sig_params,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200584 md_type_t *md_alg, pk_type_t *pk_alg,
585 void **sig_opts )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200586{
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100587 int ret;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200588
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200589 if( *sig_opts != NULL )
590 return( POLARSSL_ERR_X509_BAD_INPUT_DATA );
591
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100592 if( ( ret = oid_get_sig_alg( sig_oid, md_alg, pk_alg ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200593 return( POLARSSL_ERR_X509_UNKNOWN_SIG_ALG + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200594
Manuel Pégourié-Gonnardd1539b12014-06-06 16:42:37 +0200595#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100596 if( *pk_alg == POLARSSL_PK_RSASSA_PSS )
597 {
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200598 pk_rsassa_pss_options *pss_opts;
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100599
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200600 pss_opts = polarssl_malloc( sizeof( pk_rsassa_pss_options ) );
601 if( pss_opts == NULL )
602 return( POLARSSL_ERR_X509_MALLOC_FAILED );
603
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100604 ret = x509_get_rsassa_pss_params( sig_params,
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200605 md_alg,
606 &pss_opts->mgf1_hash_id,
607 &pss_opts->expected_salt_len );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100608 if( ret != 0 )
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200609 {
610 polarssl_free( pss_opts );
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100611 return( ret );
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200612 }
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100613
Manuel Pégourié-Gonnardf75f2f72014-06-05 15:14:28 +0200614 *sig_opts = (void *) pss_opts;
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100615 }
616 else
Paul Bakkerdb20c102014-06-17 14:34:44 +0200617#endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardcf975a32014-01-24 19:28:43 +0100618 {
619 /* Make sure parameters are absent or NULL */
620 if( ( sig_params->tag != ASN1_NULL && sig_params->tag != 0 ) ||
621 sig_params->len != 0 )
622 return( POLARSSL_ERR_X509_INVALID_ALG );
623 }
624
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200625 return( 0 );
626}
627
628/*
629 * X.509 Extensions (No parsing of extensions, pointer should
630 * be either manually updated or extensions should be parsed!
631 */
632int x509_get_ext( unsigned char **p, const unsigned char *end,
633 x509_buf *ext, int tag )
634{
635 int ret;
636 size_t len;
637
638 if( *p == end )
639 return( 0 );
640
641 ext->tag = **p;
642
643 if( ( ret = asn1_get_tag( p, end, &ext->len,
644 ASN1_CONTEXT_SPECIFIC | ASN1_CONSTRUCTED | tag ) ) != 0 )
645 return( ret );
646
647 ext->p = *p;
648 end = *p + ext->len;
649
650 /*
651 * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
652 *
653 * Extension ::= SEQUENCE {
654 * extnID OBJECT IDENTIFIER,
655 * critical BOOLEAN DEFAULT FALSE,
656 * extnValue OCTET STRING }
657 */
658 if( ( ret = asn1_get_tag( p, end, &len,
659 ASN1_CONSTRUCTED | ASN1_SEQUENCE ) ) != 0 )
Paul Bakker51876562013-09-17 14:36:05 +0200660 return( POLARSSL_ERR_X509_INVALID_EXTENSIONS + ret );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200661
662 if( end != *p + len )
Paul Bakker51876562013-09-17 14:36:05 +0200663 return( POLARSSL_ERR_X509_INVALID_EXTENSIONS +
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200664 POLARSSL_ERR_ASN1_LENGTH_MISMATCH );
665
666 return( 0 );
667}
668
Paul Bakker6edcd412013-10-29 15:22:54 +0100669#if defined(_MSC_VER) && !defined snprintf && !defined(EFIX64) && \
670 !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200671#include <stdarg.h>
672
673#if !defined vsnprintf
674#define vsnprintf _vsnprintf
675#endif // vsnprintf
676
677/*
678 * Windows _snprintf and _vsnprintf are not compatible to linux versions.
679 * Result value is not size of buffer needed, but -1 if no fit is possible.
680 *
681 * This fuction tries to 'fix' this by at least suggesting enlarging the
682 * size by 20.
683 */
Paul Bakker66d5d072014-06-17 16:39:18 +0200684static int compat_snprintf( char *str, size_t size, const char *format, ... )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200685{
686 va_list ap;
687 int res = -1;
688
689 va_start( ap, format );
690
691 res = vsnprintf( str, size, format, ap );
692
693 va_end( ap );
694
695 // No quick fix possible
Paul Bakker66d5d072014-06-17 16:39:18 +0200696 if( res < 0 )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200697 return( (int) size + 20 );
698
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200699 return( res );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200700}
701
702#define snprintf compat_snprintf
Paul Bakker9af723c2014-05-01 13:03:14 +0200703#endif /* _MSC_VER && !snprintf && !EFIX64 && !EFI32 */
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200704
705#define POLARSSL_ERR_DEBUG_BUF_TOO_SMALL -2
706
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200707#define SAFE_SNPRINTF() \
708{ \
709 if( ret == -1 ) \
710 return( -1 ); \
711 \
Paul Bakker66d5d072014-06-17 16:39:18 +0200712 if( (unsigned int) ret > n ) { \
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200713 p[n - 1] = '\0'; \
714 return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL ); \
715 } \
716 \
717 n -= (unsigned int) ret; \
718 p += (unsigned int) ret; \
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200719}
720
721/*
722 * Store the name in printable form into buf; no more
723 * than size characters will be written
724 */
Paul Bakker86d0c192013-09-18 11:11:02 +0200725int x509_dn_gets( char *buf, size_t size, const x509_name *dn )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200726{
727 int ret;
728 size_t i, n;
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000729 unsigned char c, merge = 0;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200730 const x509_name *name;
731 const char *short_name = NULL;
Paul Bakker8dcb2d72014-08-08 12:22:30 +0200732 char s[X509_MAX_DN_NAME_SIZE], *p;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200733
734 memset( s, 0, sizeof( s ) );
735
736 name = dn;
737 p = buf;
738 n = size;
739
740 while( name != NULL )
741 {
742 if( !name->oid.p )
743 {
744 name = name->next;
745 continue;
746 }
747
748 if( name != dn )
749 {
Rich Evansfac657f2015-01-30 11:00:01 +0000750 ret = polarssl_snprintf( p, n, merge ? " + " : ", " );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200751 SAFE_SNPRINTF();
752 }
753
754 ret = oid_get_attr_short_name( &name->oid, &short_name );
755
756 if( ret == 0 )
Rich Evansfac657f2015-01-30 11:00:01 +0000757 ret = polarssl_snprintf( p, n, "%s=", short_name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200758 else
Rich Evansfac657f2015-01-30 11:00:01 +0000759 ret = polarssl_snprintf( p, n, "\?\?=" );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200760 SAFE_SNPRINTF();
761
762 for( i = 0; i < name->val.len; i++ )
763 {
764 if( i >= sizeof( s ) - 1 )
765 break;
766
767 c = name->val.p[i];
768 if( c < 32 || c == 127 || ( c > 128 && c < 160 ) )
769 s[i] = '?';
770 else s[i] = c;
771 }
772 s[i] = '\0';
Rich Evansfac657f2015-01-30 11:00:01 +0000773 ret = polarssl_snprintf( p, n, "%s", s );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200774 SAFE_SNPRINTF();
Manuel Pégourié-Gonnard555fbf82015-02-04 17:11:55 +0000775
776 merge = name->next_merged;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200777 name = name->next;
778 }
779
780 return( (int) ( size - n ) );
781}
782
783/*
784 * Store the serial in printable form into buf; no more
785 * than size characters will be written
786 */
Paul Bakker86d0c192013-09-18 11:11:02 +0200787int x509_serial_gets( char *buf, size_t size, const x509_buf *serial )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200788{
789 int ret;
790 size_t i, n, nr;
791 char *p;
792
793 p = buf;
794 n = size;
795
796 nr = ( serial->len <= 32 )
797 ? serial->len : 28;
798
799 for( i = 0; i < nr; i++ )
800 {
801 if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
802 continue;
803
Rich Evansfac657f2015-01-30 11:00:01 +0000804 ret = polarssl_snprintf( p, n, "%02X%s",
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200805 serial->p[i], ( i < nr - 1 ) ? ":" : "" );
806 SAFE_SNPRINTF();
807 }
808
809 if( nr != serial->len )
810 {
Rich Evansfac657f2015-01-30 11:00:01 +0000811 ret = polarssl_snprintf( p, n, "...." );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200812 SAFE_SNPRINTF();
813 }
814
815 return( (int) ( size - n ) );
816}
817
818/*
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +0200819 * Helper for writing signature algorithms
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100820 */
821int x509_sig_alg_gets( char *buf, size_t size, const x509_buf *sig_oid,
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +0200822 pk_type_t pk_alg, md_type_t md_alg,
823 const void *sig_opts )
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100824{
825 int ret;
826 char *p = buf;
827 size_t n = size;
828 const char *desc = NULL;
829
830 ret = oid_get_sig_alg_desc( sig_oid, &desc );
831 if( ret != 0 )
Rich Evansfac657f2015-01-30 11:00:01 +0000832 ret = polarssl_snprintf( p, n, "???" );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100833 else
Rich Evansfac657f2015-01-30 11:00:01 +0000834 ret = polarssl_snprintf( p, n, "%s", desc );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100835 SAFE_SNPRINTF();
836
Manuel Pégourié-Gonnardd1539b12014-06-06 16:42:37 +0200837#if defined(POLARSSL_X509_RSASSA_PSS_SUPPORT)
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100838 if( pk_alg == POLARSSL_PK_RSASSA_PSS )
839 {
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +0200840 const pk_rsassa_pss_options *pss_opts;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100841 const md_info_t *md_info, *mgf_md_info;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100842
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +0200843 pss_opts = (const pk_rsassa_pss_options *) sig_opts;
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100844
845 md_info = md_info_from_type( md_alg );
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +0200846 mgf_md_info = md_info_from_type( pss_opts->mgf1_hash_id );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100847
Rich Evansfac657f2015-01-30 11:00:01 +0000848 ret = polarssl_snprintf( p, n, " (%s, MGF1-%s, 0x%02X)",
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100849 md_info ? md_info->name : "???",
850 mgf_md_info ? mgf_md_info->name : "???",
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +0200851 pss_opts->expected_salt_len );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100852 SAFE_SNPRINTF();
853 }
854#else
855 ((void) pk_alg);
Manuel Pégourié-Gonnard91136032014-06-05 15:41:39 +0200856 ((void) md_alg);
857 ((void) sig_opts);
Manuel Pégourié-Gonnardd1539b12014-06-06 16:42:37 +0200858#endif /* POLARSSL_X509_RSASSA_PSS_SUPPORT */
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100859
Sander Niemeijeref5087d2014-08-16 12:45:52 +0200860 return( (int)( size - n ) );
Manuel Pégourié-Gonnardcac31ee2014-01-25 11:50:59 +0100861}
862
863/*
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200864 * Helper for writing "RSA key size", "EC key size", etc
865 */
866int x509_key_size_helper( char *buf, size_t size, const char *name )
867{
868 char *p = buf;
869 size_t n = size;
870 int ret;
871
872 if( strlen( name ) + sizeof( " key size" ) > size )
Paul Bakkerd8bb8262014-06-17 14:06:49 +0200873 return( POLARSSL_ERR_DEBUG_BUF_TOO_SMALL );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200874
Rich Evansfac657f2015-01-30 11:00:01 +0000875 ret = polarssl_snprintf( p, n, "%s key size", name );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200876 SAFE_SNPRINTF();
877
878 return( 0 );
879}
880
881/*
882 * Return an informational string describing the given OID
883 */
Manuel Pégourié-Gonnardc70581c2015-03-23 13:58:27 +0100884#if ! defined(POLARSSL_DEPRECATED_REMOVED)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200885const char *x509_oid_get_description( x509_buf *oid )
886{
887 const char *desc = NULL;
888 int ret;
889
890 ret = oid_get_extended_key_usage( oid, &desc );
891
892 if( ret != 0 )
893 return( NULL );
894
895 return( desc );
896}
Manuel Pégourié-Gonnardc70581c2015-03-23 13:58:27 +0100897#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200898
899/* Return the x.y.z.... style numeric string for the given OID */
Manuel Pégourié-Gonnardc70581c2015-03-23 13:58:27 +0100900#if ! defined(POLARSSL_DEPRECATED_REMOVED)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200901int x509_oid_get_numeric_string( char *buf, size_t size, x509_buf *oid )
902{
903 return oid_get_numeric_string( buf, size, oid );
904}
Manuel Pégourié-Gonnardc70581c2015-03-23 13:58:27 +0100905#endif
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200906
907/*
908 * Return 0 if the x509_time is still valid, or 1 otherwise.
909 */
910#if defined(POLARSSL_HAVE_TIME)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200911
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100912static void x509_get_current_time( x509_time *now )
913{
Paul Bakkerfa6a6202013-10-28 18:48:30 +0100914#if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200915 SYSTEMTIME st;
916
Paul Bakker66d5d072014-06-17 16:39:18 +0200917 GetSystemTime( &st );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200918
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100919 now->year = st.wYear;
920 now->mon = st.wMonth;
921 now->day = st.wDay;
922 now->hour = st.wHour;
923 now->min = st.wMinute;
924 now->sec = st.wSecond;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200925#else
Paul Bakker5fff23b2014-03-26 15:34:54 +0100926 struct tm lt;
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200927 time_t tt;
928
929 tt = time( NULL );
Manuel Pégourié-Gonnard0776a432014-04-11 12:25:45 +0200930 gmtime_r( &tt, &lt );
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200931
Paul Bakker5fff23b2014-03-26 15:34:54 +0100932 now->year = lt.tm_year + 1900;
933 now->mon = lt.tm_mon + 1;
934 now->day = lt.tm_mday;
935 now->hour = lt.tm_hour;
936 now->min = lt.tm_min;
937 now->sec = lt.tm_sec;
Paul Bakker9af723c2014-05-01 13:03:14 +0200938#endif /* _WIN32 && !EFIX64 && !EFI32 */
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100939}
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200940
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100941/*
942 * Return 0 if before <= after, 1 otherwise
943 */
944static int x509_check_time( const x509_time *before, const x509_time *after )
945{
946 if( before->year > after->year )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200947 return( 1 );
948
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100949 if( before->year == after->year &&
950 before->mon > after->mon )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200951 return( 1 );
952
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100953 if( before->year == after->year &&
954 before->mon == after->mon &&
955 before->day > after->day )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200956 return( 1 );
957
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100958 if( before->year == after->year &&
959 before->mon == after->mon &&
960 before->day == after->day &&
961 before->hour > after->hour )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200962 return( 1 );
963
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100964 if( before->year == after->year &&
965 before->mon == after->mon &&
966 before->day == after->day &&
967 before->hour == after->hour &&
968 before->min > after->min )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200969 return( 1 );
970
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100971 if( before->year == after->year &&
972 before->mon == after->mon &&
973 before->day == after->day &&
974 before->hour == after->hour &&
975 before->min == after->min &&
976 before->sec > after->sec )
Paul Bakker7c6b2c32013-09-16 13:49:26 +0200977 return( 1 );
978
979 return( 0 );
980}
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +0100981
982int x509_time_expired( const x509_time *to )
983{
984 x509_time now;
985
986 x509_get_current_time( &now );
987
988 return( x509_check_time( &now, to ) );
989}
990
991int x509_time_future( const x509_time *from )
992{
993 x509_time now;
994
995 x509_get_current_time( &now );
996
997 return( x509_check_time( from, &now ) );
998}
999
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001000#else /* POLARSSL_HAVE_TIME */
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001001
Paul Bakker86d0c192013-09-18 11:11:02 +02001002int x509_time_expired( const x509_time *to )
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001003{
1004 ((void) to);
1005 return( 0 );
1006}
Manuel Pégourié-Gonnard6304f782014-03-10 12:26:11 +01001007
1008int x509_time_future( const x509_time *from )
1009{
1010 ((void) from);
1011 return( 0 );
1012}
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001013#endif /* POLARSSL_HAVE_TIME */
1014
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001015#if defined(POLARSSL_SELF_TEST)
1016
1017#include "polarssl/x509_crt.h"
1018#include "polarssl/certs.h"
1019
1020/*
1021 * Checkup routine
1022 */
1023int x509_self_test( int verbose )
1024{
Manuel Pégourié-Gonnard3d413702014-04-29 15:29:41 +02001025#if defined(POLARSSL_CERTS_C) && defined(POLARSSL_SHA1_C)
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001026 int ret;
1027 int flags;
Paul Bakkerc559c7a2013-09-18 14:13:26 +02001028 x509_crt cacert;
1029 x509_crt clicert;
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001030
1031 if( verbose != 0 )
Paul Bakker7dc4c442014-02-01 22:50:26 +01001032 polarssl_printf( " X.509 certificate load: " );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001033
Paul Bakkerb6b09562013-09-18 14:17:41 +02001034 x509_crt_init( &clicert );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001035
Paul Bakkerddf26b42013-09-18 13:46:23 +02001036 ret = x509_crt_parse( &clicert, (const unsigned char *) test_cli_crt,
1037 strlen( test_cli_crt ) );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001038 if( ret != 0 )
1039 {
1040 if( verbose != 0 )
Paul Bakker7dc4c442014-02-01 22:50:26 +01001041 polarssl_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001042
1043 return( ret );
1044 }
1045
Paul Bakkerb6b09562013-09-18 14:17:41 +02001046 x509_crt_init( &cacert );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001047
Paul Bakkerddf26b42013-09-18 13:46:23 +02001048 ret = x509_crt_parse( &cacert, (const unsigned char *) test_ca_crt,
1049 strlen( test_ca_crt ) );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001050 if( ret != 0 )
1051 {
1052 if( verbose != 0 )
Paul Bakker7dc4c442014-02-01 22:50:26 +01001053 polarssl_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001054
1055 return( ret );
1056 }
1057
1058 if( verbose != 0 )
Paul Bakker7dc4c442014-02-01 22:50:26 +01001059 polarssl_printf( "passed\n X.509 signature verify: ");
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001060
Paul Bakkerddf26b42013-09-18 13:46:23 +02001061 ret = x509_crt_verify( &clicert, &cacert, NULL, NULL, &flags, NULL, NULL );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001062 if( ret != 0 )
1063 {
1064 if( verbose != 0 )
Paul Bakker7dc4c442014-02-01 22:50:26 +01001065 polarssl_printf( "failed\n" );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001066
Paul Bakker66d5d072014-06-17 16:39:18 +02001067 polarssl_printf( "ret = %d, &flags = %04x\n", ret, flags );
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001068
1069 return( ret );
1070 }
1071
1072 if( verbose != 0 )
Paul Bakker7dc4c442014-02-01 22:50:26 +01001073 polarssl_printf( "passed\n\n");
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001074
1075 x509_crt_free( &cacert );
1076 x509_crt_free( &clicert );
1077
1078 return( 0 );
1079#else
1080 ((void) verbose);
1081 return( POLARSSL_ERR_X509_FEATURE_UNAVAILABLE );
Paul Bakker9af723c2014-05-01 13:03:14 +02001082#endif /* POLARSSL_CERTS_C && POLARSSL_SHA1_C */
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001083}
1084
Paul Bakker9af723c2014-05-01 13:03:14 +02001085#endif /* POLARSSL_SELF_TEST */
Paul Bakkere9e6ae32013-09-16 22:53:25 +02001086
Paul Bakker7c6b2c32013-09-16 13:49:26 +02001087#endif /* POLARSSL_X509_USE_C */