test_suite_x509write.function (28892B)
1 /* BEGIN_HEADER */ 2 #include "mbedtls/bignum.h" 3 #include "mbedtls/x509_crt.h" 4 #include "mbedtls/x509_csr.h" 5 #include "x509_internal.h" 6 #include "mbedtls/pem.h" 7 #include "mbedtls/oid.h" 8 #include "mbedtls/rsa.h" 9 #include "mbedtls/asn1write.h" 10 #include "mbedtls/pk.h" 11 #include "mbedtls/psa_util.h" 12 13 #if defined(MBEDTLS_PEM_WRITE_C) && \ 14 defined(MBEDTLS_X509_CRT_WRITE_C) && \ 15 defined(MBEDTLS_X509_CRT_PARSE_C) && \ 16 defined(MBEDTLS_MD_CAN_SHA1) && \ 17 defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT) 18 static int mbedtls_rsa_decrypt_func(void *ctx, size_t *olen, 19 const unsigned char *input, unsigned char *output, 20 size_t output_max_len) 21 { 22 return mbedtls_rsa_pkcs1_decrypt((mbedtls_rsa_context *) ctx, NULL, NULL, 23 olen, input, output, output_max_len); 24 } 25 static int mbedtls_rsa_sign_func(void *ctx, 26 int (*f_rng)(void *, unsigned char *, size_t), void *p_rng, 27 mbedtls_md_type_t md_alg, unsigned int hashlen, 28 const unsigned char *hash, unsigned char *sig) 29 { 30 return mbedtls_rsa_pkcs1_sign((mbedtls_rsa_context *) ctx, f_rng, p_rng, 31 md_alg, hashlen, hash, sig); 32 } 33 static size_t mbedtls_rsa_key_len_func(void *ctx) 34 { 35 return ((const mbedtls_rsa_context *) ctx)->len; 36 } 37 #endif 38 39 #if defined(MBEDTLS_USE_PSA_CRYPTO) && \ 40 defined(MBEDTLS_PEM_WRITE_C) && defined(MBEDTLS_X509_CSR_WRITE_C) 41 static int x509_crt_verifycsr(const unsigned char *buf, size_t buflen) 42 { 43 unsigned char hash[PSA_HASH_MAX_SIZE]; 44 mbedtls_x509_csr csr; 45 int ret = 0; 46 47 mbedtls_x509_csr_init(&csr); 48 49 if (mbedtls_x509_csr_parse(&csr, buf, buflen) != 0) { 50 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA; 51 goto cleanup; 52 } 53 54 psa_algorithm_t psa_alg = mbedtls_md_psa_alg_from_type(csr.sig_md); 55 size_t hash_size = 0; 56 psa_status_t status = psa_hash_compute(psa_alg, csr.cri.p, csr.cri.len, 57 hash, PSA_HASH_MAX_SIZE, &hash_size); 58 59 if (status != PSA_SUCCESS) { 60 /* Note: this can't happen except after an internal error */ 61 ret = MBEDTLS_ERR_X509_BAD_INPUT_DATA; 62 goto cleanup; 63 } 64 65 if (mbedtls_pk_verify_ext(csr.sig_pk, csr.sig_opts, &csr.pk, 66 csr.sig_md, hash, mbedtls_md_get_size_from_type(csr.sig_md), 67 csr.sig.p, csr.sig.len) != 0) { 68 ret = MBEDTLS_ERR_X509_CERT_VERIFY_FAILED; 69 goto cleanup; 70 } 71 72 cleanup: 73 74 mbedtls_x509_csr_free(&csr); 75 return ret; 76 } 77 #endif /* MBEDTLS_USE_PSA_CRYPTO && MBEDTLS_PEM_WRITE_C && MBEDTLS_X509_CSR_WRITE_C */ 78 79 #if defined(MBEDTLS_X509_CSR_WRITE_C) 80 81 /* 82 * The size of this temporary buffer is given by the sequence of functions 83 * called hereinafter: 84 * - mbedtls_asn1_write_oid() 85 * - 8 bytes for MBEDTLS_OID_EXTENDED_KEY_USAGE raw value 86 * - 1 byte for MBEDTLS_OID_EXTENDED_KEY_USAGE length 87 * - 1 byte for MBEDTLS_ASN1_OID tag 88 * - mbedtls_asn1_write_len() 89 * - 1 byte since we're dealing with sizes which are less than 0x80 90 * - mbedtls_asn1_write_tag() 91 * - 1 byte 92 * 93 * This length is fine as long as this function is called using the 94 * MBEDTLS_OID_SERVER_AUTH OID. If this is changed in the future, then this 95 * buffer's length should be adjusted accordingly. 96 * Unfortunately there's no predefined max size for OIDs which can be used 97 * to set an overall upper boundary which is always guaranteed. 98 */ 99 #define EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH 12 100 101 static int csr_set_extended_key_usage(mbedtls_x509write_csr *ctx, 102 const char *oid, size_t oid_len) 103 { 104 unsigned char buf[EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH] = { 0 }; 105 unsigned char *p = buf + sizeof(buf); 106 int ret; 107 size_t len = 0; 108 109 /* 110 * Following functions fail anyway if the temporary buffer is not large, 111 * but we set an extra check here to emphasize a possible source of errors 112 */ 113 if (oid_len > EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH) { 114 return MBEDTLS_ERR_X509_BAD_INPUT_DATA; 115 } 116 117 MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_oid(&p, buf, oid, oid_len)); 118 MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&p, buf, ret)); 119 MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(&p, buf, 120 MBEDTLS_ASN1_CONSTRUCTED | 121 MBEDTLS_ASN1_SEQUENCE)); 122 123 ret = mbedtls_x509write_csr_set_extension(ctx, 124 MBEDTLS_OID_EXTENDED_KEY_USAGE, 125 MBEDTLS_OID_SIZE(MBEDTLS_OID_EXTENDED_KEY_USAGE), 126 0, 127 p, 128 len); 129 130 return ret; 131 } 132 #endif /* MBEDTLS_X509_CSR_WRITE_C */ 133 134 /* Due to inconsistencies in the input size limits applied by different 135 * library functions, some write-parse tests may fail. */ 136 #define MAY_FAIL_GET_NAME 0x0001 137 #define MAY_FAIL_DN_GETS 0x0002 138 139 /* END_HEADER */ 140 141 /* BEGIN_DEPENDENCIES 142 * depends_on:MBEDTLS_FS_IO:MBEDTLS_PK_PARSE_C 143 * END_DEPENDENCIES 144 */ 145 146 /* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CSR_WRITE_C */ 147 void x509_csr_check(char *key_file, char *cert_req_check_file, int md_type, 148 int key_usage, int set_key_usage, int cert_type, 149 int set_cert_type, int set_extension) 150 { 151 mbedtls_pk_context key; 152 mbedtls_x509write_csr req; 153 unsigned char buf[4096]; 154 int ret; 155 #if !defined(MBEDTLS_USE_PSA_CRYPTO) 156 unsigned char check_buf[4000]; 157 FILE *f; 158 size_t olen = 0; 159 #endif /* !MBEDTLS_USE_PSA_CRYPTO */ 160 size_t pem_len = 0, buf_index; 161 int der_len = -1; 162 const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1"; 163 mbedtls_test_rnd_pseudo_info rnd_info; 164 mbedtls_x509_san_list san_ip; 165 mbedtls_x509_san_list san_dns; 166 mbedtls_x509_san_list san_uri; 167 mbedtls_x509_san_list san_mail; 168 mbedtls_x509_san_list san_dn; 169 mbedtls_x509_san_list *san_list = NULL; 170 mbedtls_asn1_named_data *ext_san_dirname = NULL; 171 172 const char san_ip_name[] = { 0x7f, 0x00, 0x00, 0x01 }; // 127.0.0.1 173 const char *san_dns_name = "example.com"; 174 const char *san_dn_name = "C=UK,O=Mbed TLS,CN=Mbed TLS directoryName SAN"; 175 const char *san_mail_name = "mail@example.com"; 176 const char *san_uri_name = "http://pki.example.com"; 177 178 san_mail.node.type = MBEDTLS_X509_SAN_RFC822_NAME; 179 san_mail.node.san.unstructured_name.p = (unsigned char *) san_mail_name; 180 san_mail.node.san.unstructured_name.len = strlen(san_mail_name); 181 san_mail.next = NULL; 182 183 san_dns.node.type = MBEDTLS_X509_SAN_DNS_NAME; 184 san_dns.node.san.unstructured_name.p = (unsigned char *) san_dns_name; 185 san_dns.node.san.unstructured_name.len = strlen(san_dns_name); 186 san_dns.next = &san_mail; 187 188 san_dn.node.type = MBEDTLS_X509_SAN_DIRECTORY_NAME; 189 TEST_ASSERT(mbedtls_x509_string_to_names(&ext_san_dirname, 190 san_dn_name) == 0); 191 san_dn.node.san.directory_name = *ext_san_dirname; 192 san_dn.next = &san_dns; 193 194 san_ip.node.type = MBEDTLS_X509_SAN_IP_ADDRESS; 195 san_ip.node.san.unstructured_name.p = (unsigned char *) san_ip_name; 196 san_ip.node.san.unstructured_name.len = sizeof(san_ip_name); 197 san_ip.next = &san_dn; 198 199 san_uri.node.type = MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER; 200 san_uri.node.san.unstructured_name.p = (unsigned char *) san_uri_name; 201 san_uri.node.san.unstructured_name.len = strlen(san_uri_name); 202 san_uri.next = &san_ip; 203 204 san_list = &san_uri; 205 206 memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info)); 207 208 mbedtls_x509write_csr_init(&req); 209 mbedtls_pk_init(&key); 210 MD_OR_USE_PSA_INIT(); 211 212 TEST_ASSERT(mbedtls_pk_parse_keyfile(&key, key_file, NULL, 213 mbedtls_test_rnd_std_rand, NULL) == 0); 214 215 mbedtls_x509write_csr_set_md_alg(&req, md_type); 216 mbedtls_x509write_csr_set_key(&req, &key); 217 TEST_ASSERT(mbedtls_x509write_csr_set_subject_name(&req, subject_name) == 0); 218 if (set_key_usage != 0) { 219 TEST_ASSERT(mbedtls_x509write_csr_set_key_usage(&req, key_usage) == 0); 220 } 221 if (set_cert_type != 0) { 222 TEST_ASSERT(mbedtls_x509write_csr_set_ns_cert_type(&req, cert_type) == 0); 223 } 224 if (set_extension != 0) { 225 TEST_ASSERT(csr_set_extended_key_usage(&req, MBEDTLS_OID_SERVER_AUTH, 226 MBEDTLS_OID_SIZE(MBEDTLS_OID_SERVER_AUTH)) == 0); 227 228 TEST_ASSERT(mbedtls_x509write_csr_set_subject_alternative_name(&req, san_list) == 0); 229 } 230 231 ret = mbedtls_x509write_csr_pem(&req, buf, sizeof(buf), 232 mbedtls_test_rnd_pseudo_rand, &rnd_info); 233 TEST_ASSERT(ret == 0); 234 235 pem_len = strlen((char *) buf); 236 237 for (buf_index = pem_len; buf_index < sizeof(buf); ++buf_index) { 238 TEST_ASSERT(buf[buf_index] == 0); 239 } 240 241 #if defined(MBEDTLS_USE_PSA_CRYPTO) 242 // When using PSA crypto, RNG isn't controllable, so cert_req_check_file can't be used 243 (void) cert_req_check_file; 244 buf[pem_len] = '\0'; 245 TEST_ASSERT(x509_crt_verifycsr(buf, pem_len + 1) == 0); 246 #else 247 f = fopen(cert_req_check_file, "r"); 248 TEST_ASSERT(f != NULL); 249 olen = fread(check_buf, 1, sizeof(check_buf), f); 250 fclose(f); 251 252 TEST_ASSERT(olen >= pem_len - 1); 253 TEST_ASSERT(memcmp(buf, check_buf, pem_len - 1) == 0); 254 #endif /* MBEDTLS_USE_PSA_CRYPTO */ 255 256 der_len = mbedtls_x509write_csr_der(&req, buf, sizeof(buf), 257 mbedtls_test_rnd_pseudo_rand, 258 &rnd_info); 259 TEST_ASSERT(der_len >= 0); 260 261 if (der_len == 0) { 262 goto exit; 263 } 264 265 #if defined(MBEDTLS_USE_PSA_CRYPTO) 266 // When using PSA crypto, RNG isn't controllable, result length isn't 267 // deterministic over multiple runs, removing a single byte isn't enough to 268 // go into the MBEDTLS_ERR_ASN1_BUF_TOO_SMALL error case 269 der_len /= 2; 270 #else 271 der_len -= 1; 272 #endif 273 ret = mbedtls_x509write_csr_der(&req, buf, (size_t) (der_len), 274 mbedtls_test_rnd_pseudo_rand, &rnd_info); 275 TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL); 276 277 exit: 278 mbedtls_asn1_free_named_data_list(&ext_san_dirname); 279 mbedtls_x509write_csr_free(&req); 280 mbedtls_pk_free(&key); 281 MD_OR_USE_PSA_DONE(); 282 } 283 /* END_CASE */ 284 285 /* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CSR_WRITE_C:MBEDTLS_USE_PSA_CRYPTO */ 286 void x509_csr_check_opaque(char *key_file, int md_type, int key_usage, 287 int cert_type) 288 { 289 mbedtls_pk_context key; 290 mbedtls_pk_init(&key); 291 292 mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT; 293 psa_key_attributes_t key_attr = PSA_KEY_ATTRIBUTES_INIT; 294 295 mbedtls_x509write_csr req; 296 mbedtls_x509write_csr_init(&req); 297 298 unsigned char buf[4096]; 299 int ret; 300 size_t pem_len = 0; 301 const char *subject_name = "C=NL,O=PolarSSL,CN=PolarSSL Server 1"; 302 mbedtls_test_rnd_pseudo_info rnd_info; 303 304 MD_OR_USE_PSA_INIT(); 305 306 memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info)); 307 308 TEST_ASSERT(mbedtls_pk_parse_keyfile(&key, key_file, NULL, 309 mbedtls_test_rnd_std_rand, NULL) == 0); 310 311 /* Turn the PK context into an opaque one. */ 312 TEST_EQUAL(mbedtls_pk_get_psa_attributes(&key, PSA_KEY_USAGE_SIGN_HASH, &key_attr), 0); 313 TEST_EQUAL(mbedtls_pk_import_into_psa(&key, &key_attr, &key_id), 0); 314 mbedtls_pk_free(&key); 315 mbedtls_pk_init(&key); 316 TEST_EQUAL(mbedtls_pk_setup_opaque(&key, key_id), 0); 317 318 mbedtls_x509write_csr_set_md_alg(&req, md_type); 319 mbedtls_x509write_csr_set_key(&req, &key); 320 TEST_ASSERT(mbedtls_x509write_csr_set_subject_name(&req, subject_name) == 0); 321 if (key_usage != 0) { 322 TEST_ASSERT(mbedtls_x509write_csr_set_key_usage(&req, key_usage) == 0); 323 } 324 if (cert_type != 0) { 325 TEST_ASSERT(mbedtls_x509write_csr_set_ns_cert_type(&req, cert_type) == 0); 326 } 327 328 ret = mbedtls_x509write_csr_pem(&req, buf, sizeof(buf) - 1, 329 mbedtls_test_rnd_pseudo_rand, &rnd_info); 330 331 TEST_ASSERT(ret == 0); 332 333 pem_len = strlen((char *) buf); 334 buf[pem_len] = '\0'; 335 TEST_ASSERT(x509_crt_verifycsr(buf, pem_len + 1) == 0); 336 337 338 exit: 339 mbedtls_x509write_csr_free(&req); 340 mbedtls_pk_free(&key); 341 psa_destroy_key(key_id); 342 MD_OR_USE_PSA_DONE(); 343 } 344 /* END_CASE */ 345 346 /* BEGIN_CASE depends_on:MBEDTLS_PEM_WRITE_C:MBEDTLS_X509_CRT_WRITE_C:MBEDTLS_X509_CRT_PARSE_C:MBEDTLS_MD_CAN_SHA1 */ 347 void x509_crt_check(char *subject_key_file, char *subject_pwd, 348 char *subject_name, char *issuer_key_file, 349 char *issuer_pwd, char *issuer_name, 350 data_t *serial_arg, char *not_before, char *not_after, 351 int md_type, int key_usage, int set_key_usage, 352 char *ext_key_usage, 353 int cert_type, int set_cert_type, int auth_ident, 354 int ver, char *cert_check_file, int pk_wrap, int is_ca, 355 char *cert_verify_file, int set_subjectAltNames) 356 { 357 mbedtls_pk_context subject_key, issuer_key, issuer_key_alt; 358 mbedtls_pk_context *key = &issuer_key; 359 360 mbedtls_x509write_cert crt; 361 unsigned char buf[4096]; 362 unsigned char check_buf[5000]; 363 unsigned char *p, *end; 364 unsigned char tag, sz; 365 #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) 366 mbedtls_mpi serial_mpi; 367 #endif 368 int ret, before_tag, after_tag; 369 size_t olen = 0, pem_len = 0, buf_index = 0; 370 int der_len = -1; 371 FILE *f; 372 mbedtls_test_rnd_pseudo_info rnd_info; 373 #if defined(MBEDTLS_USE_PSA_CRYPTO) 374 mbedtls_svc_key_id_t key_id = MBEDTLS_SVC_KEY_ID_INIT; 375 psa_key_attributes_t key_attr = PSA_KEY_ATTRIBUTES_INIT; 376 #endif 377 mbedtls_pk_type_t issuer_key_type; 378 mbedtls_x509_san_list san_ip; 379 mbedtls_x509_san_list san_dns; 380 mbedtls_x509_san_list san_uri; 381 mbedtls_x509_san_list san_mail; 382 mbedtls_x509_san_list san_dn; 383 mbedtls_asn1_named_data *ext_san_dirname = NULL; 384 const char san_ip_name[] = { 0x01, 0x02, 0x03, 0x04 }; 385 const char *san_dns_name = "example.com"; 386 const char *san_dn_name = "C=UK,O=Mbed TLS,CN=SubjectAltName test"; 387 const char *san_mail_name = "mail@example.com"; 388 const char *san_uri_name = "http://pki.example.com"; 389 mbedtls_x509_san_list *san_list = NULL; 390 391 if (set_subjectAltNames) { 392 san_mail.node.type = MBEDTLS_X509_SAN_RFC822_NAME; 393 san_mail.node.san.unstructured_name.p = (unsigned char *) san_mail_name; 394 san_mail.node.san.unstructured_name.len = strlen(san_mail_name); 395 san_mail.next = NULL; 396 397 san_dns.node.type = MBEDTLS_X509_SAN_DNS_NAME; 398 san_dns.node.san.unstructured_name.p = (unsigned char *) san_dns_name; 399 san_dns.node.san.unstructured_name.len = strlen(san_dns_name); 400 san_dns.next = &san_mail; 401 402 san_dn.node.type = MBEDTLS_X509_SAN_DIRECTORY_NAME; 403 TEST_ASSERT(mbedtls_x509_string_to_names(&ext_san_dirname, 404 san_dn_name) == 0); 405 san_dn.node.san.directory_name = *ext_san_dirname; 406 san_dn.next = &san_dns; 407 408 san_ip.node.type = MBEDTLS_X509_SAN_IP_ADDRESS; 409 san_ip.node.san.unstructured_name.p = (unsigned char *) san_ip_name; 410 san_ip.node.san.unstructured_name.len = sizeof(san_ip_name); 411 san_ip.next = &san_dn; 412 413 san_uri.node.type = MBEDTLS_X509_SAN_UNIFORM_RESOURCE_IDENTIFIER; 414 san_uri.node.san.unstructured_name.p = (unsigned char *) san_uri_name; 415 san_uri.node.san.unstructured_name.len = strlen(san_uri_name); 416 san_uri.next = &san_ip; 417 418 san_list = &san_uri; 419 } 420 421 memset(&rnd_info, 0x2a, sizeof(mbedtls_test_rnd_pseudo_info)); 422 #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) 423 mbedtls_mpi_init(&serial_mpi); 424 #endif 425 426 mbedtls_pk_init(&subject_key); 427 mbedtls_pk_init(&issuer_key); 428 mbedtls_pk_init(&issuer_key_alt); 429 mbedtls_x509write_crt_init(&crt); 430 MD_OR_USE_PSA_INIT(); 431 432 TEST_ASSERT(mbedtls_pk_parse_keyfile(&subject_key, subject_key_file, 433 subject_pwd, mbedtls_test_rnd_std_rand, NULL) == 0); 434 435 TEST_ASSERT(mbedtls_pk_parse_keyfile(&issuer_key, issuer_key_file, 436 issuer_pwd, mbedtls_test_rnd_std_rand, NULL) == 0); 437 438 issuer_key_type = mbedtls_pk_get_type(&issuer_key); 439 440 #if defined(MBEDTLS_RSA_C) && defined(MBEDTLS_PK_RSA_ALT_SUPPORT) 441 /* For RSA PK contexts, create a copy as an alternative RSA context. */ 442 if (pk_wrap == 1 && issuer_key_type == MBEDTLS_PK_RSA) { 443 TEST_ASSERT(mbedtls_pk_setup_rsa_alt(&issuer_key_alt, 444 mbedtls_pk_rsa(issuer_key), 445 mbedtls_rsa_decrypt_func, 446 mbedtls_rsa_sign_func, 447 mbedtls_rsa_key_len_func) == 0); 448 449 key = &issuer_key_alt; 450 } 451 #endif 452 453 #if defined(MBEDTLS_USE_PSA_CRYPTO) 454 /* Turn the issuer PK context into an opaque one. */ 455 if (pk_wrap == 2) { 456 TEST_EQUAL(mbedtls_pk_get_psa_attributes(&issuer_key, PSA_KEY_USAGE_SIGN_HASH, 457 &key_attr), 0); 458 TEST_EQUAL(mbedtls_pk_import_into_psa(&issuer_key, &key_attr, &key_id), 0); 459 mbedtls_pk_free(&issuer_key); 460 mbedtls_pk_init(&issuer_key); 461 TEST_EQUAL(mbedtls_pk_setup_opaque(&issuer_key, key_id), 0); 462 } 463 #endif /* MBEDTLS_USE_PSA_CRYPTO */ 464 465 if (pk_wrap == 2) { 466 TEST_ASSERT(mbedtls_pk_get_type(&issuer_key) == MBEDTLS_PK_OPAQUE); 467 } 468 469 if (ver != -1) { 470 mbedtls_x509write_crt_set_version(&crt, ver); 471 } 472 473 #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) 474 TEST_ASSERT(mbedtls_mpi_read_binary(&serial_mpi, serial_arg->x, 475 serial_arg->len) == 0); 476 TEST_ASSERT(mbedtls_x509write_crt_set_serial(&crt, &serial_mpi) == 0); 477 #else 478 TEST_ASSERT(mbedtls_x509write_crt_set_serial_raw(&crt, serial_arg->x, 479 serial_arg->len) == 0); 480 #endif 481 TEST_ASSERT(mbedtls_x509write_crt_set_validity(&crt, not_before, 482 not_after) == 0); 483 mbedtls_x509write_crt_set_md_alg(&crt, md_type); 484 TEST_ASSERT(mbedtls_x509write_crt_set_issuer_name(&crt, issuer_name) == 0); 485 TEST_ASSERT(mbedtls_x509write_crt_set_subject_name(&crt, subject_name) == 0); 486 mbedtls_x509write_crt_set_subject_key(&crt, &subject_key); 487 488 mbedtls_x509write_crt_set_issuer_key(&crt, key); 489 490 if (crt.version >= MBEDTLS_X509_CRT_VERSION_3) { 491 /* For the CA case, a path length of -1 means unlimited. */ 492 TEST_ASSERT(mbedtls_x509write_crt_set_basic_constraints(&crt, is_ca, 493 (is_ca ? -1 : 0)) == 0); 494 TEST_ASSERT(mbedtls_x509write_crt_set_subject_key_identifier(&crt) == 0); 495 if (auth_ident) { 496 TEST_ASSERT(mbedtls_x509write_crt_set_authority_key_identifier(&crt) == 0); 497 } 498 if (set_key_usage != 0) { 499 TEST_ASSERT(mbedtls_x509write_crt_set_key_usage(&crt, key_usage) == 0); 500 } 501 if (set_cert_type != 0) { 502 TEST_ASSERT(mbedtls_x509write_crt_set_ns_cert_type(&crt, cert_type) == 0); 503 } 504 if (strcmp(ext_key_usage, "NULL") != 0) { 505 mbedtls_asn1_sequence exts[2]; 506 memset(exts, 0, sizeof(exts)); 507 508 #define SET_OID(x, oid) \ 509 do { \ 510 x.len = MBEDTLS_OID_SIZE(oid); \ 511 x.p = (unsigned char *) oid; \ 512 x.tag = MBEDTLS_ASN1_OID; \ 513 } \ 514 while (0) 515 516 if (strcmp(ext_key_usage, "serverAuth") == 0) { 517 SET_OID(exts[0].buf, MBEDTLS_OID_SERVER_AUTH); 518 } else if (strcmp(ext_key_usage, "codeSigning,timeStamping") == 0) { 519 SET_OID(exts[0].buf, MBEDTLS_OID_CODE_SIGNING); 520 exts[0].next = &exts[1]; 521 SET_OID(exts[1].buf, MBEDTLS_OID_TIME_STAMPING); 522 } 523 TEST_ASSERT(mbedtls_x509write_crt_set_ext_key_usage(&crt, exts) == 0); 524 } 525 } 526 527 if (set_subjectAltNames) { 528 TEST_ASSERT(mbedtls_x509write_crt_set_subject_alternative_name(&crt, san_list) == 0); 529 } 530 ret = mbedtls_x509write_crt_pem(&crt, buf, sizeof(buf), 531 mbedtls_test_rnd_pseudo_rand, &rnd_info); 532 TEST_ASSERT(ret == 0); 533 534 pem_len = strlen((char *) buf); 535 536 // check that the rest of the buffer remains clear 537 for (buf_index = pem_len; buf_index < sizeof(buf); ++buf_index) { 538 TEST_ASSERT(buf[buf_index] == 0); 539 } 540 541 if (issuer_key_type != MBEDTLS_PK_RSA) { 542 mbedtls_x509_crt crt_parse, trusted; 543 uint32_t flags; 544 545 mbedtls_x509_crt_init(&crt_parse); 546 mbedtls_x509_crt_init(&trusted); 547 548 TEST_ASSERT(mbedtls_x509_crt_parse_file(&trusted, 549 cert_verify_file) == 0); 550 TEST_ASSERT(mbedtls_x509_crt_parse(&crt_parse, 551 buf, sizeof(buf)) == 0); 552 553 ret = mbedtls_x509_crt_verify(&crt_parse, &trusted, NULL, NULL, &flags, 554 NULL, NULL); 555 556 mbedtls_x509_crt_free(&crt_parse); 557 mbedtls_x509_crt_free(&trusted); 558 559 TEST_EQUAL(flags, 0); 560 TEST_EQUAL(ret, 0); 561 } else if (*cert_check_file != '\0') { 562 f = fopen(cert_check_file, "r"); 563 TEST_ASSERT(f != NULL); 564 olen = fread(check_buf, 1, sizeof(check_buf), f); 565 fclose(f); 566 TEST_ASSERT(olen < sizeof(check_buf)); 567 568 TEST_EQUAL(olen, pem_len); 569 TEST_ASSERT(olen >= pem_len - 1); 570 TEST_ASSERT(memcmp(buf, check_buf, pem_len - 1) == 0); 571 } 572 573 der_len = mbedtls_x509write_crt_der(&crt, buf, sizeof(buf), 574 mbedtls_test_rnd_pseudo_rand, 575 &rnd_info); 576 TEST_ASSERT(der_len >= 0); 577 578 if (der_len == 0) { 579 goto exit; 580 } 581 582 // Not testing against file, check date format 583 if (*cert_check_file == '\0') { 584 // UTC tag if before 2050, 2 digits less for year 585 if (not_before[0] == '2' && (not_before[1] > '0' || not_before[2] > '4')) { 586 before_tag = MBEDTLS_ASN1_GENERALIZED_TIME; 587 } else { 588 before_tag = MBEDTLS_ASN1_UTC_TIME; 589 not_before += 2; 590 } 591 if (not_after[0] == '2' && (not_after[1] > '0' || not_after[2] > '4')) { 592 after_tag = MBEDTLS_ASN1_GENERALIZED_TIME; 593 } else { 594 after_tag = MBEDTLS_ASN1_UTC_TIME; 595 not_after += 2; 596 } 597 end = buf + sizeof(buf); 598 for (p = end - der_len; p < end;) { 599 tag = *p++; 600 sz = *p++; 601 if (tag == MBEDTLS_ASN1_UTC_TIME || tag == MBEDTLS_ASN1_GENERALIZED_TIME) { 602 // Check correct tag and time written 603 TEST_ASSERT(before_tag == tag); 604 TEST_ASSERT(memcmp(p, not_before, sz - 1) == 0); 605 p += sz; 606 tag = *p++; 607 sz = *p++; 608 TEST_ASSERT(after_tag == tag); 609 TEST_ASSERT(memcmp(p, not_after, sz - 1) == 0); 610 break; 611 } 612 // Increment if long form ASN1 length 613 if (sz & 0x80) { 614 p += sz & 0x0F; 615 } 616 if (tag != (MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE)) { 617 p += sz; 618 } 619 } 620 TEST_ASSERT(p < end); 621 } 622 623 #if defined(MBEDTLS_USE_PSA_CRYPTO) 624 // When using PSA crypto, RNG isn't controllable, result length isn't 625 // deterministic over multiple runs, removing a single byte isn't enough to 626 // go into the MBEDTLS_ERR_ASN1_BUF_TOO_SMALL error case 627 if (issuer_key_type != MBEDTLS_PK_RSA) { 628 der_len /= 2; 629 } else 630 #endif 631 der_len -= 1; 632 633 ret = mbedtls_x509write_crt_der(&crt, buf, (size_t) (der_len), 634 mbedtls_test_rnd_pseudo_rand, &rnd_info); 635 TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_BUF_TOO_SMALL); 636 637 exit: 638 mbedtls_asn1_free_named_data_list(&ext_san_dirname); 639 mbedtls_x509write_crt_free(&crt); 640 mbedtls_pk_free(&issuer_key_alt); 641 mbedtls_pk_free(&subject_key); 642 mbedtls_pk_free(&issuer_key); 643 #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) 644 mbedtls_mpi_free(&serial_mpi); 645 #endif 646 #if defined(MBEDTLS_USE_PSA_CRYPTO) 647 psa_destroy_key(key_id); 648 #endif 649 MD_OR_USE_PSA_DONE(); 650 } 651 /* END_CASE */ 652 653 /* BEGIN_CASE depends_on:MBEDTLS_X509_CRT_WRITE_C */ 654 void x509_set_serial_check() 655 { 656 mbedtls_x509write_cert ctx; 657 uint8_t invalid_serial[MBEDTLS_X509_RFC5280_MAX_SERIAL_LEN + 1]; 658 659 #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) 660 mbedtls_mpi serial_mpi; 661 mbedtls_mpi_init(&serial_mpi); 662 #endif 663 664 USE_PSA_INIT(); 665 memset(invalid_serial, 0x01, sizeof(invalid_serial)); 666 667 #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) 668 TEST_EQUAL(mbedtls_mpi_read_binary(&serial_mpi, invalid_serial, 669 sizeof(invalid_serial)), 0); 670 TEST_EQUAL(mbedtls_x509write_crt_set_serial(&ctx, &serial_mpi), 671 MBEDTLS_ERR_X509_BAD_INPUT_DATA); 672 #endif 673 674 TEST_EQUAL(mbedtls_x509write_crt_set_serial_raw(&ctx, invalid_serial, 675 sizeof(invalid_serial)), 676 MBEDTLS_ERR_X509_BAD_INPUT_DATA); 677 678 exit: 679 #if defined(MBEDTLS_TEST_DEPRECATED) && defined(MBEDTLS_BIGNUM_C) 680 mbedtls_mpi_free(&serial_mpi); 681 #else 682 ; 683 #endif 684 USE_PSA_DONE(); 685 } 686 /* END_CASE */ 687 688 /* BEGIN_CASE depends_on:MBEDTLS_X509_CREATE_C:MBEDTLS_X509_USE_C */ 689 void mbedtls_x509_string_to_names(char *name, char *parsed_name, 690 int result, int may_fail) 691 { 692 int ret; 693 size_t len = 0; 694 mbedtls_asn1_named_data *names = NULL; 695 mbedtls_x509_name parsed; 696 memset(&parsed, 0, sizeof(parsed)); 697 mbedtls_x509_name *parsed_cur = NULL; 698 mbedtls_x509_name *parsed_prv = NULL; 699 unsigned char buf[1024] = { 0 }; 700 unsigned char out[1024] = { 0 }; 701 unsigned char *c = buf + sizeof(buf); 702 703 USE_PSA_INIT(); 704 705 ret = mbedtls_x509_string_to_names(&names, name); 706 TEST_EQUAL(ret, result); 707 708 if (ret != 0) { 709 goto exit; 710 } 711 712 ret = mbedtls_x509_write_names(&c, buf, names); 713 TEST_LE_S(1, ret); 714 715 TEST_EQUAL(mbedtls_asn1_get_tag(&c, buf + sizeof(buf), &len, 716 MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE), 0); 717 ret = mbedtls_x509_get_name(&c, buf + sizeof(buf), &parsed); 718 if ((may_fail & MAY_FAIL_GET_NAME) && ret < 0) { 719 /* Validation inconsistency between mbedtls_x509_string_to_names() and 720 * mbedtls_x509_get_name(). Accept it for now. */ 721 goto exit; 722 } 723 TEST_EQUAL(ret, 0); 724 725 ret = mbedtls_x509_dn_gets((char *) out, sizeof(out), &parsed); 726 if ((may_fail & MAY_FAIL_DN_GETS) && ret < 0) { 727 /* Validation inconsistency between mbedtls_x509_string_to_names() and 728 * mbedtls_x509_dn_gets(). Accept it for now. */ 729 goto exit; 730 } 731 TEST_LE_S(1, ret); 732 TEST_ASSERT(strcmp((char *) out, parsed_name) == 0); 733 734 /* Check that calling a 2nd time with the same param (now non-NULL) 735 * returns an error as expected. */ 736 ret = mbedtls_x509_string_to_names(&names, name); 737 TEST_EQUAL(ret, MBEDTLS_ERR_X509_BAD_INPUT_DATA); 738 739 exit: 740 mbedtls_asn1_free_named_data_list(&names); 741 742 parsed_cur = parsed.next; 743 while (parsed_cur != 0) { 744 parsed_prv = parsed_cur; 745 parsed_cur = parsed_cur->next; 746 mbedtls_free(parsed_prv); 747 } 748 USE_PSA_DONE(); 749 } 750 /* END_CASE */ 751 752 /* BEGIN_CASE depends_on:MBEDTLS_X509_CSR_WRITE_C */ 753 void x509_set_extension_length_check() 754 { 755 int ret = 0; 756 757 mbedtls_x509write_csr ctx; 758 mbedtls_x509write_csr_init(&ctx); 759 760 unsigned char buf[EXT_KEY_USAGE_TMP_BUF_MAX_LENGTH] = { 0 }; 761 unsigned char *p = buf + sizeof(buf); 762 763 ret = mbedtls_x509_set_extension(&(ctx.MBEDTLS_PRIVATE(extensions)), 764 MBEDTLS_OID_EXTENDED_KEY_USAGE, 765 MBEDTLS_OID_SIZE(MBEDTLS_OID_EXTENDED_KEY_USAGE), 766 0, 767 p, 768 SIZE_MAX); 769 TEST_ASSERT(MBEDTLS_ERR_X509_BAD_INPUT_DATA == ret); 770 } 771 /* END_CASE */