x509.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095
  1. /*
  2. * X.509 common functions for parsing and verification
  3. *
  4. * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
  5. * 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.
  18. *
  19. * This file is part of mbed TLS (https://tls.mbed.org)
  20. */
  21. /*
  22. * The ITU-T X.509 standard defines a certificate format for PKI.
  23. *
  24. * 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)
  27. *
  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. #if !defined(MBEDTLS_CONFIG_FILE)
  32. #include "mbedtls/config.h"
  33. #else
  34. #include MBEDTLS_CONFIG_FILE
  35. #endif
  36. #if defined(MBEDTLS_X509_USE_C)
  37. #include "mbedtls/x509.h"
  38. #include "mbedtls/asn1.h"
  39. #include "mbedtls/oid.h"
  40. #include <stdio.h>
  41. #include <string.h>
  42. #if defined(MBEDTLS_PEM_PARSE_C)
  43. #include "mbedtls/pem.h"
  44. #endif
  45. #if defined(MBEDTLS_PLATFORM_C)
  46. #include "mbedtls/platform.h"
  47. #else
  48. #include <stdio.h>
  49. #include <stdlib.h>
  50. #define mbedtls_free free
  51. #define mbedtls_calloc calloc
  52. #define mbedtls_printf printf
  53. #define mbedtls_snprintf snprintf
  54. #endif
  55. #if defined(MBEDTLS_HAVE_TIME)
  56. #include "mbedtls/platform_time.h"
  57. #endif
  58. #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
  59. #include <windows.h>
  60. #else
  61. #include <time.h>
  62. #endif
  63. #define CHECK(code) if( ( ret = code ) != 0 ){ return( ret ); }
  64. #define CHECK_RANGE(min, max, val) if( val < min || val > max ){ return( ret ); }
  65. /*
  66. * CertificateSerialNumber ::= INTEGER
  67. */
  68. int mbedtls_x509_get_serial( unsigned char **p, const unsigned char *end,
  69. mbedtls_x509_buf *serial )
  70. {
  71. int ret;
  72. if( ( end - *p ) < 1 )
  73. return( MBEDTLS_ERR_X509_INVALID_SERIAL +
  74. MBEDTLS_ERR_ASN1_OUT_OF_DATA );
  75. if( **p != ( MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_PRIMITIVE | 2 ) &&
  76. **p != MBEDTLS_ASN1_INTEGER )
  77. return( MBEDTLS_ERR_X509_INVALID_SERIAL +
  78. MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
  79. serial->tag = *(*p)++;
  80. if( ( ret = mbedtls_asn1_get_len( p, end, &serial->len ) ) != 0 )
  81. return( MBEDTLS_ERR_X509_INVALID_SERIAL + ret );
  82. serial->p = *p;
  83. *p += serial->len;
  84. return( 0 );
  85. }
  86. /* Get an algorithm identifier without parameters (eg for signatures)
  87. *
  88. * AlgorithmIdentifier ::= SEQUENCE {
  89. * algorithm OBJECT IDENTIFIER,
  90. * parameters ANY DEFINED BY algorithm OPTIONAL }
  91. */
  92. int mbedtls_x509_get_alg_null( unsigned char **p, const unsigned char *end,
  93. mbedtls_x509_buf *alg )
  94. {
  95. int ret;
  96. if( ( ret = mbedtls_asn1_get_alg_null( p, end, alg ) ) != 0 )
  97. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  98. return( 0 );
  99. }
  100. /*
  101. * Parse an algorithm identifier with (optional) paramaters
  102. */
  103. int mbedtls_x509_get_alg( unsigned char **p, const unsigned char *end,
  104. mbedtls_x509_buf *alg, mbedtls_x509_buf *params )
  105. {
  106. int ret;
  107. if( ( ret = mbedtls_asn1_get_alg( p, end, alg, params ) ) != 0 )
  108. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  109. return( 0 );
  110. }
  111. #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
  112. /*
  113. * HashAlgorithm ::= AlgorithmIdentifier
  114. *
  115. * AlgorithmIdentifier ::= SEQUENCE {
  116. * algorithm OBJECT IDENTIFIER,
  117. * parameters ANY DEFINED BY algorithm OPTIONAL }
  118. *
  119. * For HashAlgorithm, parameters MUST be NULL or absent.
  120. */
  121. static int x509_get_hash_alg( const mbedtls_x509_buf *alg, mbedtls_md_type_t *md_alg )
  122. {
  123. int ret;
  124. unsigned char *p;
  125. const unsigned char *end;
  126. mbedtls_x509_buf md_oid;
  127. size_t len;
  128. /* Make sure we got a SEQUENCE and setup bounds */
  129. if( alg->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
  130. return( MBEDTLS_ERR_X509_INVALID_ALG +
  131. MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
  132. p = (unsigned char *) alg->p;
  133. end = p + alg->len;
  134. if( p >= end )
  135. return( MBEDTLS_ERR_X509_INVALID_ALG +
  136. MBEDTLS_ERR_ASN1_OUT_OF_DATA );
  137. /* Parse md_oid */
  138. md_oid.tag = *p;
  139. if( ( ret = mbedtls_asn1_get_tag( &p, end, &md_oid.len, MBEDTLS_ASN1_OID ) ) != 0 )
  140. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  141. md_oid.p = p;
  142. p += md_oid.len;
  143. /* Get md_alg from md_oid */
  144. if( ( ret = mbedtls_oid_get_md_alg( &md_oid, md_alg ) ) != 0 )
  145. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  146. /* Make sure params is absent of NULL */
  147. if( p == end )
  148. return( 0 );
  149. if( ( ret = mbedtls_asn1_get_tag( &p, end, &len, MBEDTLS_ASN1_NULL ) ) != 0 || len != 0 )
  150. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  151. if( p != end )
  152. return( MBEDTLS_ERR_X509_INVALID_ALG +
  153. MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
  154. return( 0 );
  155. }
  156. /*
  157. * RSASSA-PSS-params ::= SEQUENCE {
  158. * hashAlgorithm [0] HashAlgorithm DEFAULT sha1Identifier,
  159. * maskGenAlgorithm [1] MaskGenAlgorithm DEFAULT mgf1SHA1Identifier,
  160. * saltLength [2] INTEGER DEFAULT 20,
  161. * trailerField [3] INTEGER DEFAULT 1 }
  162. * -- Note that the tags in this Sequence are explicit.
  163. *
  164. * RFC 4055 (which defines use of RSASSA-PSS in PKIX) states that the value
  165. * of trailerField MUST be 1, and PKCS#1 v2.2 doesn't even define any other
  166. * option. Enfore this at parsing time.
  167. */
  168. int mbedtls_x509_get_rsassa_pss_params( const mbedtls_x509_buf *params,
  169. mbedtls_md_type_t *md_alg, mbedtls_md_type_t *mgf_md,
  170. int *salt_len )
  171. {
  172. int ret;
  173. unsigned char *p;
  174. const unsigned char *end, *end2;
  175. size_t len;
  176. mbedtls_x509_buf alg_id, alg_params;
  177. /* First set everything to defaults */
  178. *md_alg = MBEDTLS_MD_SHA1;
  179. *mgf_md = MBEDTLS_MD_SHA1;
  180. *salt_len = 20;
  181. /* Make sure params is a SEQUENCE and setup bounds */
  182. if( params->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) )
  183. return( MBEDTLS_ERR_X509_INVALID_ALG +
  184. MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
  185. p = (unsigned char *) params->p;
  186. end = p + params->len;
  187. if( p == end )
  188. return( 0 );
  189. /*
  190. * HashAlgorithm
  191. */
  192. if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
  193. MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 0 ) ) == 0 )
  194. {
  195. end2 = p + len;
  196. /* HashAlgorithm ::= AlgorithmIdentifier (without parameters) */
  197. if( ( ret = mbedtls_x509_get_alg_null( &p, end2, &alg_id ) ) != 0 )
  198. return( ret );
  199. if( ( ret = mbedtls_oid_get_md_alg( &alg_id, md_alg ) ) != 0 )
  200. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  201. if( p != end2 )
  202. return( MBEDTLS_ERR_X509_INVALID_ALG +
  203. MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
  204. }
  205. else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
  206. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  207. if( p == end )
  208. return( 0 );
  209. /*
  210. * MaskGenAlgorithm
  211. */
  212. if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
  213. MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 1 ) ) == 0 )
  214. {
  215. end2 = p + len;
  216. /* MaskGenAlgorithm ::= AlgorithmIdentifier (params = HashAlgorithm) */
  217. if( ( ret = mbedtls_x509_get_alg( &p, end2, &alg_id, &alg_params ) ) != 0 )
  218. return( ret );
  219. /* Only MFG1 is recognised for now */
  220. if( MBEDTLS_OID_CMP( MBEDTLS_OID_MGF1, &alg_id ) != 0 )
  221. return( MBEDTLS_ERR_X509_FEATURE_UNAVAILABLE +
  222. MBEDTLS_ERR_OID_NOT_FOUND );
  223. /* Parse HashAlgorithm */
  224. if( ( ret = x509_get_hash_alg( &alg_params, mgf_md ) ) != 0 )
  225. return( ret );
  226. if( p != end2 )
  227. return( MBEDTLS_ERR_X509_INVALID_ALG +
  228. MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
  229. }
  230. else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
  231. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  232. if( p == end )
  233. return( 0 );
  234. /*
  235. * salt_len
  236. */
  237. if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
  238. MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 2 ) ) == 0 )
  239. {
  240. end2 = p + len;
  241. if( ( ret = mbedtls_asn1_get_int( &p, end2, salt_len ) ) != 0 )
  242. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  243. if( p != end2 )
  244. return( MBEDTLS_ERR_X509_INVALID_ALG +
  245. MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
  246. }
  247. else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
  248. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  249. if( p == end )
  250. return( 0 );
  251. /*
  252. * trailer_field (if present, must be 1)
  253. */
  254. if( ( ret = mbedtls_asn1_get_tag( &p, end, &len,
  255. MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | 3 ) ) == 0 )
  256. {
  257. int trailer_field;
  258. end2 = p + len;
  259. if( ( ret = mbedtls_asn1_get_int( &p, end2, &trailer_field ) ) != 0 )
  260. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  261. if( p != end2 )
  262. return( MBEDTLS_ERR_X509_INVALID_ALG +
  263. MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
  264. if( trailer_field != 1 )
  265. return( MBEDTLS_ERR_X509_INVALID_ALG );
  266. }
  267. else if( ret != MBEDTLS_ERR_ASN1_UNEXPECTED_TAG )
  268. return( MBEDTLS_ERR_X509_INVALID_ALG + ret );
  269. if( p != end )
  270. return( MBEDTLS_ERR_X509_INVALID_ALG +
  271. MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
  272. return( 0 );
  273. }
  274. #endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
  275. /*
  276. * AttributeTypeAndValue ::= SEQUENCE {
  277. * type AttributeType,
  278. * value AttributeValue }
  279. *
  280. * AttributeType ::= OBJECT IDENTIFIER
  281. *
  282. * AttributeValue ::= ANY DEFINED BY AttributeType
  283. */
  284. static int x509_get_attr_type_value( unsigned char **p,
  285. const unsigned char *end,
  286. mbedtls_x509_name *cur )
  287. {
  288. int ret;
  289. size_t len;
  290. mbedtls_x509_buf *oid;
  291. mbedtls_x509_buf *val;
  292. if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
  293. MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
  294. return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
  295. if( ( end - *p ) < 1 )
  296. return( MBEDTLS_ERR_X509_INVALID_NAME +
  297. MBEDTLS_ERR_ASN1_OUT_OF_DATA );
  298. oid = &cur->oid;
  299. oid->tag = **p;
  300. if( ( ret = mbedtls_asn1_get_tag( p, end, &oid->len, MBEDTLS_ASN1_OID ) ) != 0 )
  301. return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
  302. oid->p = *p;
  303. *p += oid->len;
  304. if( ( end - *p ) < 1 )
  305. return( MBEDTLS_ERR_X509_INVALID_NAME +
  306. MBEDTLS_ERR_ASN1_OUT_OF_DATA );
  307. if( **p != MBEDTLS_ASN1_BMP_STRING && **p != MBEDTLS_ASN1_UTF8_STRING &&
  308. **p != MBEDTLS_ASN1_T61_STRING && **p != MBEDTLS_ASN1_PRINTABLE_STRING &&
  309. **p != MBEDTLS_ASN1_IA5_STRING && **p != MBEDTLS_ASN1_UNIVERSAL_STRING &&
  310. **p != MBEDTLS_ASN1_BIT_STRING )
  311. return( MBEDTLS_ERR_X509_INVALID_NAME +
  312. MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
  313. val = &cur->val;
  314. val->tag = *(*p)++;
  315. if( ( ret = mbedtls_asn1_get_len( p, end, &val->len ) ) != 0 )
  316. return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
  317. val->p = *p;
  318. *p += val->len;
  319. cur->next = NULL;
  320. return( 0 );
  321. }
  322. /*
  323. * Name ::= CHOICE { -- only one possibility for now --
  324. * rdnSequence RDNSequence }
  325. *
  326. * RDNSequence ::= SEQUENCE OF RelativeDistinguishedName
  327. *
  328. * RelativeDistinguishedName ::=
  329. * SET OF AttributeTypeAndValue
  330. *
  331. * AttributeTypeAndValue ::= SEQUENCE {
  332. * type AttributeType,
  333. * value AttributeValue }
  334. *
  335. * AttributeType ::= OBJECT IDENTIFIER
  336. *
  337. * AttributeValue ::= ANY DEFINED BY AttributeType
  338. *
  339. * The data structure is optimized for the common case where each RDN has only
  340. * one element, which is represented as a list of AttributeTypeAndValue.
  341. * For the general case we still use a flat list, but we mark elements of the
  342. * same set so that they are "merged" together in the functions that consume
  343. * this list, eg mbedtls_x509_dn_gets().
  344. */
  345. int mbedtls_x509_get_name( unsigned char **p, const unsigned char *end,
  346. mbedtls_x509_name *cur )
  347. {
  348. int ret;
  349. size_t set_len;
  350. const unsigned char *end_set;
  351. /* don't use recursion, we'd risk stack overflow if not optimized */
  352. while( 1 )
  353. {
  354. /*
  355. * parse SET
  356. */
  357. if( ( ret = mbedtls_asn1_get_tag( p, end, &set_len,
  358. MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SET ) ) != 0 )
  359. return( MBEDTLS_ERR_X509_INVALID_NAME + ret );
  360. end_set = *p + set_len;
  361. while( 1 )
  362. {
  363. if( ( ret = x509_get_attr_type_value( p, end_set, cur ) ) != 0 )
  364. return( ret );
  365. if( *p == end_set )
  366. break;
  367. /* Mark this item as being no the only one in a set */
  368. cur->next_merged = 1;
  369. cur->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
  370. if( cur->next == NULL )
  371. return( MBEDTLS_ERR_X509_ALLOC_FAILED );
  372. cur = cur->next;
  373. }
  374. /*
  375. * continue until end of SEQUENCE is reached
  376. */
  377. if( *p == end )
  378. return( 0 );
  379. cur->next = mbedtls_calloc( 1, sizeof( mbedtls_x509_name ) );
  380. if( cur->next == NULL )
  381. return( MBEDTLS_ERR_X509_ALLOC_FAILED );
  382. cur = cur->next;
  383. }
  384. }
  385. static int x509_parse_int( unsigned char **p, size_t n, int *res )
  386. {
  387. *res = 0;
  388. for( ; n > 0; --n )
  389. {
  390. if( ( **p < '0') || ( **p > '9' ) )
  391. return ( MBEDTLS_ERR_X509_INVALID_DATE );
  392. *res *= 10;
  393. *res += ( *(*p)++ - '0' );
  394. }
  395. return( 0 );
  396. }
  397. static int x509_date_is_valid(const mbedtls_x509_time *t )
  398. {
  399. int ret = MBEDTLS_ERR_X509_INVALID_DATE;
  400. int month_len;
  401. CHECK_RANGE( 0, 9999, t->year );
  402. CHECK_RANGE( 0, 23, t->hour );
  403. CHECK_RANGE( 0, 59, t->min );
  404. CHECK_RANGE( 0, 59, t->sec );
  405. switch( t->mon )
  406. {
  407. case 1: case 3: case 5: case 7: case 8: case 10: case 12:
  408. month_len = 31;
  409. break;
  410. case 4: case 6: case 9: case 11:
  411. month_len = 30;
  412. break;
  413. case 2:
  414. if( ( !( t->year % 4 ) && t->year % 100 ) ||
  415. !( t->year % 400 ) )
  416. month_len = 29;
  417. else
  418. month_len = 28;
  419. break;
  420. default:
  421. return( ret );
  422. }
  423. CHECK_RANGE( 1, month_len, t->day );
  424. return( 0 );
  425. }
  426. /*
  427. * Parse an ASN1_UTC_TIME (yearlen=2) or ASN1_GENERALIZED_TIME (yearlen=4)
  428. * field.
  429. */
  430. static int x509_parse_time( unsigned char **p, size_t len, size_t yearlen,
  431. mbedtls_x509_time *tm )
  432. {
  433. int ret;
  434. /*
  435. * Minimum length is 10 or 12 depending on yearlen
  436. */
  437. if ( len < yearlen + 8 )
  438. return ( MBEDTLS_ERR_X509_INVALID_DATE );
  439. len -= yearlen + 8;
  440. /*
  441. * Parse year, month, day, hour, minute
  442. */
  443. CHECK( x509_parse_int( p, yearlen, &tm->year ) );
  444. if ( 2 == yearlen )
  445. {
  446. if ( tm->year < 50 )
  447. tm->year += 100;
  448. tm->year += 1900;
  449. }
  450. CHECK( x509_parse_int( p, 2, &tm->mon ) );
  451. CHECK( x509_parse_int( p, 2, &tm->day ) );
  452. CHECK( x509_parse_int( p, 2, &tm->hour ) );
  453. CHECK( x509_parse_int( p, 2, &tm->min ) );
  454. /*
  455. * Parse seconds if present
  456. */
  457. if ( len >= 2 )
  458. {
  459. CHECK( x509_parse_int( p, 2, &tm->sec ) );
  460. len -= 2;
  461. }
  462. else
  463. return ( MBEDTLS_ERR_X509_INVALID_DATE );
  464. /*
  465. * Parse trailing 'Z' if present
  466. */
  467. if ( 1 == len && 'Z' == **p )
  468. {
  469. (*p)++;
  470. len--;
  471. }
  472. /*
  473. * We should have parsed all characters at this point
  474. */
  475. if ( 0 != len )
  476. return ( MBEDTLS_ERR_X509_INVALID_DATE );
  477. CHECK( x509_date_is_valid( tm ) );
  478. return ( 0 );
  479. }
  480. /*
  481. * Time ::= CHOICE {
  482. * utcTime UTCTime,
  483. * generalTime GeneralizedTime }
  484. */
  485. int mbedtls_x509_get_time( unsigned char **p, const unsigned char *end,
  486. mbedtls_x509_time *tm )
  487. {
  488. int ret;
  489. size_t len, year_len;
  490. unsigned char tag;
  491. if( ( end - *p ) < 1 )
  492. return( MBEDTLS_ERR_X509_INVALID_DATE +
  493. MBEDTLS_ERR_ASN1_OUT_OF_DATA );
  494. tag = **p;
  495. if( tag == MBEDTLS_ASN1_UTC_TIME )
  496. year_len = 2;
  497. else if( tag == MBEDTLS_ASN1_GENERALIZED_TIME )
  498. year_len = 4;
  499. else
  500. return( MBEDTLS_ERR_X509_INVALID_DATE +
  501. MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
  502. (*p)++;
  503. ret = mbedtls_asn1_get_len( p, end, &len );
  504. if( ret != 0 )
  505. return( MBEDTLS_ERR_X509_INVALID_DATE + ret );
  506. return x509_parse_time( p, len, year_len, tm );
  507. }
  508. int mbedtls_x509_get_sig( unsigned char **p, const unsigned char *end, mbedtls_x509_buf *sig )
  509. {
  510. int ret;
  511. size_t len;
  512. int tag_type;
  513. if( ( end - *p ) < 1 )
  514. return( MBEDTLS_ERR_X509_INVALID_SIGNATURE +
  515. MBEDTLS_ERR_ASN1_OUT_OF_DATA );
  516. tag_type = **p;
  517. if( ( ret = mbedtls_asn1_get_bitstring_null( p, end, &len ) ) != 0 )
  518. return( MBEDTLS_ERR_X509_INVALID_SIGNATURE + ret );
  519. sig->tag = tag_type;
  520. sig->len = len;
  521. sig->p = *p;
  522. *p += len;
  523. return( 0 );
  524. }
  525. /*
  526. * Get signature algorithm from alg OID and optional parameters
  527. */
  528. int mbedtls_x509_get_sig_alg( const mbedtls_x509_buf *sig_oid, const mbedtls_x509_buf *sig_params,
  529. mbedtls_md_type_t *md_alg, mbedtls_pk_type_t *pk_alg,
  530. void **sig_opts )
  531. {
  532. int ret;
  533. if( *sig_opts != NULL )
  534. return( MBEDTLS_ERR_X509_BAD_INPUT_DATA );
  535. if( ( ret = mbedtls_oid_get_sig_alg( sig_oid, md_alg, pk_alg ) ) != 0 )
  536. return( MBEDTLS_ERR_X509_UNKNOWN_SIG_ALG + ret );
  537. #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
  538. if( *pk_alg == MBEDTLS_PK_RSASSA_PSS )
  539. {
  540. mbedtls_pk_rsassa_pss_options *pss_opts;
  541. pss_opts = mbedtls_calloc( 1, sizeof( mbedtls_pk_rsassa_pss_options ) );
  542. if( pss_opts == NULL )
  543. return( MBEDTLS_ERR_X509_ALLOC_FAILED );
  544. ret = mbedtls_x509_get_rsassa_pss_params( sig_params,
  545. md_alg,
  546. &pss_opts->mgf1_hash_id,
  547. &pss_opts->expected_salt_len );
  548. if( ret != 0 )
  549. {
  550. mbedtls_free( pss_opts );
  551. return( ret );
  552. }
  553. *sig_opts = (void *) pss_opts;
  554. }
  555. else
  556. #endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
  557. {
  558. /* Make sure parameters are absent or NULL */
  559. if( ( sig_params->tag != MBEDTLS_ASN1_NULL && sig_params->tag != 0 ) ||
  560. sig_params->len != 0 )
  561. return( MBEDTLS_ERR_X509_INVALID_ALG );
  562. }
  563. return( 0 );
  564. }
  565. /*
  566. * X.509 Extensions (No parsing of extensions, pointer should
  567. * be either manually updated or extensions should be parsed!)
  568. */
  569. int mbedtls_x509_get_ext( unsigned char **p, const unsigned char *end,
  570. mbedtls_x509_buf *ext, int tag )
  571. {
  572. int ret;
  573. size_t len;
  574. if( *p == end )
  575. return( 0 );
  576. ext->tag = **p;
  577. if( ( ret = mbedtls_asn1_get_tag( p, end, &ext->len,
  578. MBEDTLS_ASN1_CONTEXT_SPECIFIC | MBEDTLS_ASN1_CONSTRUCTED | tag ) ) != 0 )
  579. return( ret );
  580. ext->p = *p;
  581. end = *p + ext->len;
  582. /*
  583. * Extensions ::= SEQUENCE SIZE (1..MAX) OF Extension
  584. *
  585. * Extension ::= SEQUENCE {
  586. * extnID OBJECT IDENTIFIER,
  587. * critical BOOLEAN DEFAULT FALSE,
  588. * extnValue OCTET STRING }
  589. */
  590. if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
  591. MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE ) ) != 0 )
  592. return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS + ret );
  593. if( end != *p + len )
  594. return( MBEDTLS_ERR_X509_INVALID_EXTENSIONS +
  595. MBEDTLS_ERR_ASN1_LENGTH_MISMATCH );
  596. return( 0 );
  597. }
  598. /*
  599. * Store the name in printable form into buf; no more
  600. * than size characters will be written
  601. */
  602. int mbedtls_x509_dn_gets( char *buf, size_t size, const mbedtls_x509_name *dn )
  603. {
  604. int ret;
  605. size_t i, n;
  606. unsigned char c, merge = 0;
  607. const mbedtls_x509_name *name;
  608. const char *short_name = NULL;
  609. char s[MBEDTLS_X509_MAX_DN_NAME_SIZE], *p;
  610. memset( s, 0, sizeof( s ) );
  611. name = dn;
  612. p = buf;
  613. n = size;
  614. while( name != NULL )
  615. {
  616. if( !name->oid.p )
  617. {
  618. name = name->next;
  619. continue;
  620. }
  621. if( name != dn )
  622. {
  623. ret = mbedtls_snprintf( p, n, merge ? " + " : ", " );
  624. MBEDTLS_X509_SAFE_SNPRINTF;
  625. }
  626. ret = mbedtls_oid_get_attr_short_name( &name->oid, &short_name );
  627. if( ret == 0 )
  628. ret = mbedtls_snprintf( p, n, "%s=", short_name );
  629. else
  630. ret = mbedtls_snprintf( p, n, "\?\?=" );
  631. MBEDTLS_X509_SAFE_SNPRINTF;
  632. for( i = 0; i < name->val.len; i++ )
  633. {
  634. if( i >= sizeof( s ) - 1 )
  635. break;
  636. c = name->val.p[i];
  637. if( c < 32 || c == 127 || ( c > 128 && c < 160 ) )
  638. s[i] = '?';
  639. else s[i] = c;
  640. }
  641. s[i] = '\0';
  642. ret = mbedtls_snprintf( p, n, "%s", s );
  643. MBEDTLS_X509_SAFE_SNPRINTF;
  644. merge = name->next_merged;
  645. name = name->next;
  646. }
  647. return( (int) ( size - n ) );
  648. }
  649. /*
  650. * Store the serial in printable form into buf; no more
  651. * than size characters will be written
  652. */
  653. int mbedtls_x509_serial_gets( char *buf, size_t size, const mbedtls_x509_buf *serial )
  654. {
  655. int ret;
  656. size_t i, n, nr;
  657. char *p;
  658. p = buf;
  659. n = size;
  660. nr = ( serial->len <= 32 )
  661. ? serial->len : 28;
  662. for( i = 0; i < nr; i++ )
  663. {
  664. if( i == 0 && nr > 1 && serial->p[i] == 0x0 )
  665. continue;
  666. ret = mbedtls_snprintf( p, n, "%02X%s",
  667. serial->p[i], ( i < nr - 1 ) ? ":" : "" );
  668. MBEDTLS_X509_SAFE_SNPRINTF;
  669. }
  670. if( nr != serial->len )
  671. {
  672. ret = mbedtls_snprintf( p, n, "...." );
  673. MBEDTLS_X509_SAFE_SNPRINTF;
  674. }
  675. return( (int) ( size - n ) );
  676. }
  677. /*
  678. * Helper for writing signature algorithms
  679. */
  680. int mbedtls_x509_sig_alg_gets( char *buf, size_t size, const mbedtls_x509_buf *sig_oid,
  681. mbedtls_pk_type_t pk_alg, mbedtls_md_type_t md_alg,
  682. const void *sig_opts )
  683. {
  684. int ret;
  685. char *p = buf;
  686. size_t n = size;
  687. const char *desc = NULL;
  688. ret = mbedtls_oid_get_sig_alg_desc( sig_oid, &desc );
  689. if( ret != 0 )
  690. ret = mbedtls_snprintf( p, n, "???" );
  691. else
  692. ret = mbedtls_snprintf( p, n, "%s", desc );
  693. MBEDTLS_X509_SAFE_SNPRINTF;
  694. #if defined(MBEDTLS_X509_RSASSA_PSS_SUPPORT)
  695. if( pk_alg == MBEDTLS_PK_RSASSA_PSS )
  696. {
  697. const mbedtls_pk_rsassa_pss_options *pss_opts;
  698. const mbedtls_md_info_t *md_info, *mgf_md_info;
  699. pss_opts = (const mbedtls_pk_rsassa_pss_options *) sig_opts;
  700. md_info = mbedtls_md_info_from_type( md_alg );
  701. mgf_md_info = mbedtls_md_info_from_type( pss_opts->mgf1_hash_id );
  702. ret = mbedtls_snprintf( p, n, " (%s, MGF1-%s, 0x%02X)",
  703. md_info ? mbedtls_md_get_name( md_info ) : "???",
  704. mgf_md_info ? mbedtls_md_get_name( mgf_md_info ) : "???",
  705. pss_opts->expected_salt_len );
  706. MBEDTLS_X509_SAFE_SNPRINTF;
  707. }
  708. #else
  709. ((void) pk_alg);
  710. ((void) md_alg);
  711. ((void) sig_opts);
  712. #endif /* MBEDTLS_X509_RSASSA_PSS_SUPPORT */
  713. return( (int)( size - n ) );
  714. }
  715. /*
  716. * Helper for writing "RSA key size", "EC key size", etc
  717. */
  718. int mbedtls_x509_key_size_helper( char *buf, size_t buf_size, const char *name )
  719. {
  720. char *p = buf;
  721. size_t n = buf_size;
  722. int ret;
  723. ret = mbedtls_snprintf( p, n, "%s key size", name );
  724. MBEDTLS_X509_SAFE_SNPRINTF;
  725. return( 0 );
  726. }
  727. #if defined(MBEDTLS_HAVE_TIME_DATE)
  728. /*
  729. * Set the time structure to the current time.
  730. * Return 0 on success, non-zero on failure.
  731. */
  732. #if defined(_WIN32) && !defined(EFIX64) && !defined(EFI32)
  733. static int x509_get_current_time( mbedtls_x509_time *now )
  734. {
  735. SYSTEMTIME st;
  736. GetSystemTime( &st );
  737. now->year = st.wYear;
  738. now->mon = st.wMonth;
  739. now->day = st.wDay;
  740. now->hour = st.wHour;
  741. now->min = st.wMinute;
  742. now->sec = st.wSecond;
  743. return( 0 );
  744. }
  745. #else
  746. static int x509_get_current_time( mbedtls_x509_time *now )
  747. {
  748. struct tm *lt;
  749. mbedtls_time_t tt;
  750. int ret = 0;
  751. #if defined(MBEDTLS_THREADING_C)
  752. if( mbedtls_mutex_lock( &mbedtls_threading_gmtime_mutex ) != 0 )
  753. return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
  754. #endif
  755. tt = mbedtls_time( NULL );
  756. lt = gmtime( &tt );
  757. if( lt == NULL )
  758. ret = -1;
  759. else
  760. {
  761. now->year = lt->tm_year + 1900;
  762. now->mon = lt->tm_mon + 1;
  763. now->day = lt->tm_mday;
  764. now->hour = lt->tm_hour;
  765. now->min = lt->tm_min;
  766. now->sec = lt->tm_sec;
  767. }
  768. #if defined(MBEDTLS_THREADING_C)
  769. if( mbedtls_mutex_unlock( &mbedtls_threading_gmtime_mutex ) != 0 )
  770. return( MBEDTLS_ERR_THREADING_MUTEX_ERROR );
  771. #endif
  772. return( ret );
  773. }
  774. #endif /* _WIN32 && !EFIX64 && !EFI32 */
  775. /*
  776. * Return 0 if before <= after, 1 otherwise
  777. */
  778. static int x509_check_time( const mbedtls_x509_time *before, const mbedtls_x509_time *after )
  779. {
  780. if( before->year > after->year )
  781. return( 1 );
  782. if( before->year == after->year &&
  783. before->mon > after->mon )
  784. return( 1 );
  785. if( before->year == after->year &&
  786. before->mon == after->mon &&
  787. before->day > after->day )
  788. return( 1 );
  789. if( before->year == after->year &&
  790. before->mon == after->mon &&
  791. before->day == after->day &&
  792. before->hour > after->hour )
  793. return( 1 );
  794. if( before->year == after->year &&
  795. before->mon == after->mon &&
  796. before->day == after->day &&
  797. before->hour == after->hour &&
  798. before->min > after->min )
  799. return( 1 );
  800. if( before->year == after->year &&
  801. before->mon == after->mon &&
  802. before->day == after->day &&
  803. before->hour == after->hour &&
  804. before->min == after->min &&
  805. before->sec > after->sec )
  806. return( 1 );
  807. return( 0 );
  808. }
  809. int mbedtls_x509_time_is_past( const mbedtls_x509_time *to )
  810. {
  811. mbedtls_x509_time now;
  812. if( x509_get_current_time( &now ) != 0 )
  813. return( 1 );
  814. return( x509_check_time( &now, to ) );
  815. }
  816. int mbedtls_x509_time_is_future( const mbedtls_x509_time *from )
  817. {
  818. mbedtls_x509_time now;
  819. if( x509_get_current_time( &now ) != 0 )
  820. return( 1 );
  821. return( x509_check_time( from, &now ) );
  822. }
  823. #else /* MBEDTLS_HAVE_TIME_DATE */
  824. int mbedtls_x509_time_is_past( const mbedtls_x509_time *to )
  825. {
  826. ((void) to);
  827. return( 0 );
  828. }
  829. int mbedtls_x509_time_is_future( const mbedtls_x509_time *from )
  830. {
  831. ((void) from);
  832. return( 0 );
  833. }
  834. #endif /* MBEDTLS_HAVE_TIME_DATE */
  835. #if defined(MBEDTLS_SELF_TEST)
  836. #include "mbedtls/x509_crt.h"
  837. #include "mbedtls/certs.h"
  838. /*
  839. * Checkup routine
  840. */
  841. int mbedtls_x509_self_test( int verbose )
  842. {
  843. #if defined(MBEDTLS_CERTS_C) && defined(MBEDTLS_SHA256_C)
  844. int ret;
  845. uint32_t flags;
  846. mbedtls_x509_crt cacert;
  847. mbedtls_x509_crt clicert;
  848. if( verbose != 0 )
  849. mbedtls_printf( " X.509 certificate load: " );
  850. mbedtls_x509_crt_init( &clicert );
  851. ret = mbedtls_x509_crt_parse( &clicert, (const unsigned char *) mbedtls_test_cli_crt,
  852. mbedtls_test_cli_crt_len );
  853. if( ret != 0 )
  854. {
  855. if( verbose != 0 )
  856. mbedtls_printf( "failed\n" );
  857. return( ret );
  858. }
  859. mbedtls_x509_crt_init( &cacert );
  860. ret = mbedtls_x509_crt_parse( &cacert, (const unsigned char *) mbedtls_test_ca_crt,
  861. mbedtls_test_ca_crt_len );
  862. if( ret != 0 )
  863. {
  864. if( verbose != 0 )
  865. mbedtls_printf( "failed\n" );
  866. return( ret );
  867. }
  868. if( verbose != 0 )
  869. mbedtls_printf( "passed\n X.509 signature verify: ");
  870. ret = mbedtls_x509_crt_verify( &clicert, &cacert, NULL, NULL, &flags, NULL, NULL );
  871. if( ret != 0 )
  872. {
  873. if( verbose != 0 )
  874. mbedtls_printf( "failed\n" );
  875. return( ret );
  876. }
  877. if( verbose != 0 )
  878. mbedtls_printf( "passed\n\n");
  879. mbedtls_x509_crt_free( &cacert );
  880. mbedtls_x509_crt_free( &clicert );
  881. return( 0 );
  882. #else
  883. ((void) verbose);
  884. return( 0 );
  885. #endif /* MBEDTLS_CERTS_C && MBEDTLS_SHA1_C */
  886. }
  887. #endif /* MBEDTLS_SELF_TEST */
  888. #endif /* MBEDTLS_X509_USE_C */