test_suite_asn1write.function (19937B)
1 /* BEGIN_HEADER */ 2 #include "mbedtls/asn1write.h" 3 4 #define GUARD_LEN 4 5 #define GUARD_VAL 0x2a 6 7 typedef struct { 8 unsigned char *output; 9 unsigned char *start; 10 unsigned char *end; 11 unsigned char *p; 12 size_t size; 13 } generic_write_data_t; 14 15 static int generic_write_start_step(generic_write_data_t *data) 16 { 17 mbedtls_test_set_step(data->size); 18 mbedtls_free(data->output); 19 data->output = NULL; 20 TEST_CALLOC(data->output, data->size == 0 ? 1 : data->size); 21 data->end = data->output + data->size; 22 data->p = data->end; 23 data->start = data->end - data->size; 24 return 1; 25 exit: 26 return 0; 27 } 28 29 static int generic_write_finish_step(generic_write_data_t *data, 30 const data_t *expected, int ret) 31 { 32 int ok = 0; 33 34 if (data->size < expected->len) { 35 TEST_EQUAL(ret, MBEDTLS_ERR_ASN1_BUF_TOO_SMALL); 36 } else { 37 TEST_EQUAL(ret, data->end - data->p); 38 TEST_ASSERT(data->p >= data->start); 39 TEST_ASSERT(data->p <= data->end); 40 TEST_MEMORY_COMPARE(data->p, (size_t) (data->end - data->p), 41 expected->x, expected->len); 42 } 43 ok = 1; 44 45 exit: 46 return ok; 47 } 48 49 /* END_HEADER */ 50 51 /* BEGIN_DEPENDENCIES 52 * depends_on:MBEDTLS_ASN1_WRITE_C 53 * END_DEPENDENCIES 54 */ 55 56 /* BEGIN_CASE */ 57 void mbedtls_asn1_write_null(data_t *expected) 58 { 59 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 60 int ret; 61 62 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 63 if (!generic_write_start_step(&data)) { 64 goto exit; 65 } 66 ret = mbedtls_asn1_write_null(&data.p, data.start); 67 if (!generic_write_finish_step(&data, expected, ret)) { 68 goto exit; 69 } 70 /* There's no parsing function for NULL. */ 71 } 72 73 exit: 74 mbedtls_free(data.output); 75 } 76 /* END_CASE */ 77 78 /* BEGIN_CASE */ 79 void mbedtls_asn1_write_bool(int val, data_t *expected) 80 { 81 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 82 int ret; 83 84 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 85 if (!generic_write_start_step(&data)) { 86 goto exit; 87 } 88 ret = mbedtls_asn1_write_bool(&data.p, data.start, val); 89 if (!generic_write_finish_step(&data, expected, ret)) { 90 goto exit; 91 } 92 #if defined(MBEDTLS_ASN1_PARSE_C) 93 if (ret >= 0) { 94 int read = 0xdeadbeef; 95 TEST_EQUAL(mbedtls_asn1_get_bool(&data.p, data.end, &read), 0); 96 TEST_EQUAL(val, read); 97 } 98 #endif /* MBEDTLS_ASN1_PARSE_C */ 99 } 100 101 exit: 102 mbedtls_free(data.output); 103 } 104 /* END_CASE */ 105 106 /* BEGIN_CASE */ 107 void mbedtls_asn1_write_int(int val, data_t *expected) 108 { 109 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 110 int ret; 111 112 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 113 if (!generic_write_start_step(&data)) { 114 goto exit; 115 } 116 ret = mbedtls_asn1_write_int(&data.p, data.start, val); 117 if (!generic_write_finish_step(&data, expected, ret)) { 118 goto exit; 119 } 120 #if defined(MBEDTLS_ASN1_PARSE_C) 121 if (ret >= 0) { 122 int read = 0xdeadbeef; 123 TEST_EQUAL(mbedtls_asn1_get_int(&data.p, data.end, &read), 0); 124 TEST_EQUAL(val, read); 125 } 126 #endif /* MBEDTLS_ASN1_PARSE_C */ 127 } 128 129 exit: 130 mbedtls_free(data.output); 131 } 132 /* END_CASE */ 133 134 135 /* BEGIN_CASE */ 136 void mbedtls_asn1_write_enum(int val, data_t *expected) 137 { 138 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 139 int ret; 140 141 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 142 if (!generic_write_start_step(&data)) { 143 goto exit; 144 } 145 ret = mbedtls_asn1_write_enum(&data.p, data.start, val); 146 if (!generic_write_finish_step(&data, expected, ret)) { 147 goto exit; 148 } 149 #if defined(MBEDTLS_ASN1_PARSE_C) 150 if (ret >= 0) { 151 int read = 0xdeadbeef; 152 TEST_EQUAL(mbedtls_asn1_get_enum(&data.p, data.end, &read), 0); 153 TEST_EQUAL(val, read); 154 } 155 #endif /* MBEDTLS_ASN1_PARSE_C */ 156 } 157 158 exit: 159 mbedtls_free(data.output); 160 } 161 /* END_CASE */ 162 163 /* BEGIN_CASE depends_on:MBEDTLS_BIGNUM_C */ 164 void mbedtls_asn1_write_mpi(data_t *val, data_t *expected) 165 { 166 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 167 mbedtls_mpi mpi, read; 168 int ret; 169 170 mbedtls_mpi_init(&mpi); 171 mbedtls_mpi_init(&read); 172 TEST_ASSERT(mbedtls_mpi_read_binary(&mpi, val->x, val->len) == 0); 173 174 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 175 if (!generic_write_start_step(&data)) { 176 goto exit; 177 } 178 ret = mbedtls_asn1_write_mpi(&data.p, data.start, &mpi); 179 if (!generic_write_finish_step(&data, expected, ret)) { 180 goto exit; 181 } 182 #if defined(MBEDTLS_ASN1_PARSE_C) 183 if (ret >= 0) { 184 TEST_EQUAL(mbedtls_asn1_get_mpi(&data.p, data.end, &read), 0); 185 TEST_EQUAL(0, mbedtls_mpi_cmp_mpi(&mpi, &read)); 186 } 187 #endif /* MBEDTLS_ASN1_PARSE_C */ 188 /* Skip some intermediate lengths, they're boring. */ 189 if (expected->len > 10 && data.size == 8) { 190 data.size = expected->len - 2; 191 } 192 } 193 194 exit: 195 mbedtls_mpi_free(&mpi); 196 mbedtls_mpi_free(&read); 197 mbedtls_free(data.output); 198 } 199 /* END_CASE */ 200 201 /* BEGIN_CASE */ 202 void mbedtls_asn1_write_string(int tag, data_t *content, data_t *expected) 203 { 204 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 205 int ret; 206 207 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 208 if (!generic_write_start_step(&data)) { 209 goto exit; 210 } 211 switch (tag) { 212 case MBEDTLS_ASN1_OCTET_STRING: 213 ret = mbedtls_asn1_write_octet_string( 214 &data.p, data.start, content->x, content->len); 215 break; 216 case MBEDTLS_ASN1_OID: 217 ret = mbedtls_asn1_write_oid( 218 &data.p, data.start, 219 (const char *) content->x, content->len); 220 break; 221 case MBEDTLS_ASN1_UTF8_STRING: 222 ret = mbedtls_asn1_write_utf8_string( 223 &data.p, data.start, 224 (const char *) content->x, content->len); 225 break; 226 case MBEDTLS_ASN1_PRINTABLE_STRING: 227 ret = mbedtls_asn1_write_printable_string( 228 &data.p, data.start, 229 (const char *) content->x, content->len); 230 break; 231 case MBEDTLS_ASN1_IA5_STRING: 232 ret = mbedtls_asn1_write_ia5_string( 233 &data.p, data.start, 234 (const char *) content->x, content->len); 235 break; 236 default: 237 ret = mbedtls_asn1_write_tagged_string( 238 &data.p, data.start, tag, 239 (const char *) content->x, content->len); 240 } 241 if (!generic_write_finish_step(&data, expected, ret)) { 242 goto exit; 243 } 244 /* There's no parsing function for octet or character strings. */ 245 /* Skip some intermediate lengths, they're boring. */ 246 if (expected->len > 10 && data.size == 8) { 247 data.size = expected->len - 2; 248 } 249 } 250 251 exit: 252 mbedtls_free(data.output); 253 } 254 /* END_CASE */ 255 256 /* BEGIN_CASE */ 257 void mbedtls_asn1_write_algorithm_identifier(data_t *oid, 258 int par_len, 259 data_t *expected) 260 { 261 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 262 int ret; 263 #if defined(MBEDTLS_ASN1_PARSE_C) 264 unsigned char *buf_complete = NULL; 265 #endif /* MBEDTLS_ASN1_PARSE_C */ 266 267 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 268 if (!generic_write_start_step(&data)) { 269 goto exit; 270 } 271 ret = mbedtls_asn1_write_algorithm_identifier( 272 &data.p, data.start, 273 (const char *) oid->x, oid->len, par_len); 274 /* If params_len != 0, mbedtls_asn1_write_algorithm_identifier() 275 * assumes that the parameters are already present in the buffer 276 * and returns a length that accounts for this, but our test 277 * data omits the parameters. */ 278 if (ret >= 0) { 279 ret -= par_len; 280 } 281 if (!generic_write_finish_step(&data, expected, ret)) { 282 goto exit; 283 } 284 285 #if defined(MBEDTLS_ASN1_PARSE_C) 286 /* Only do a parse-back test if the parameters aren't too large for 287 * a small-heap environment. The boundary is somewhat arbitrary. */ 288 if (ret >= 0 && par_len <= 1234) { 289 mbedtls_asn1_buf alg = { 0, 0, NULL }; 290 mbedtls_asn1_buf params = { 0, 0, NULL }; 291 /* The writing function doesn't write the parameters unless 292 * they're null: it only takes their length as input. But the 293 * parsing function requires the parameters to be present. 294 * Thus make up parameters. */ 295 size_t data_len = data.end - data.p; 296 size_t len_complete = data_len + par_len; 297 unsigned char expected_params_tag; 298 size_t expected_params_len; 299 TEST_CALLOC(buf_complete, len_complete); 300 unsigned char *end_complete = buf_complete + len_complete; 301 memcpy(buf_complete, data.p, data_len); 302 if (par_len == 0) { 303 /* mbedtls_asn1_write_algorithm_identifier() wrote a NULL */ 304 expected_params_tag = 0x05; 305 expected_params_len = 0; 306 } else if (par_len >= 2 && par_len < 2 + 128) { 307 /* Write an OCTET STRING with a short length encoding */ 308 expected_params_tag = buf_complete[data_len] = 0x04; 309 expected_params_len = par_len - 2; 310 buf_complete[data_len + 1] = (unsigned char) expected_params_len; 311 } else if (par_len >= 4 + 128 && par_len < 3 + 256 * 256) { 312 /* Write an OCTET STRING with a two-byte length encoding */ 313 expected_params_tag = buf_complete[data_len] = 0x04; 314 expected_params_len = par_len - 4; 315 buf_complete[data_len + 1] = 0x82; 316 buf_complete[data_len + 2] = (unsigned char) (expected_params_len >> 8); 317 buf_complete[data_len + 3] = (unsigned char) (expected_params_len); 318 } else { 319 TEST_FAIL("Bad test data: invalid length of ASN.1 element"); 320 } 321 unsigned char *p = buf_complete; 322 TEST_EQUAL(mbedtls_asn1_get_alg(&p, end_complete, 323 &alg, ¶ms), 0); 324 TEST_EQUAL(alg.tag, MBEDTLS_ASN1_OID); 325 TEST_MEMORY_COMPARE(alg.p, alg.len, oid->x, oid->len); 326 TEST_EQUAL(params.tag, expected_params_tag); 327 TEST_EQUAL(params.len, expected_params_len); 328 mbedtls_free(buf_complete); 329 buf_complete = NULL; 330 } 331 #endif /* MBEDTLS_ASN1_PARSE_C */ 332 } 333 334 exit: 335 mbedtls_free(data.output); 336 #if defined(MBEDTLS_ASN1_PARSE_C) 337 mbedtls_free(buf_complete); 338 #endif /* MBEDTLS_ASN1_PARSE_C */ 339 } 340 /* END_CASE */ 341 342 /* BEGIN_CASE depends_on:MBEDTLS_ASN1_PARSE_C */ 343 void mbedtls_asn1_write_len(int len, data_t *asn1, int buf_len, 344 int result) 345 { 346 int ret; 347 unsigned char buf[150]; 348 unsigned char *p; 349 size_t i; 350 size_t read_len; 351 352 memset(buf, GUARD_VAL, sizeof(buf)); 353 354 p = buf + GUARD_LEN + buf_len; 355 356 ret = mbedtls_asn1_write_len(&p, buf + GUARD_LEN, (size_t) len); 357 358 TEST_ASSERT(ret == result); 359 360 /* Check for buffer overwrite on both sides */ 361 for (i = 0; i < GUARD_LEN; i++) { 362 TEST_ASSERT(buf[i] == GUARD_VAL); 363 TEST_ASSERT(buf[GUARD_LEN + buf_len + i] == GUARD_VAL); 364 } 365 366 if (result >= 0) { 367 TEST_ASSERT(p + asn1->len == buf + GUARD_LEN + buf_len); 368 369 TEST_ASSERT(memcmp(p, asn1->x, asn1->len) == 0); 370 371 /* Read back with mbedtls_asn1_get_len() to check */ 372 ret = mbedtls_asn1_get_len(&p, buf + GUARD_LEN + buf_len, &read_len); 373 374 if (len == 0) { 375 TEST_ASSERT(ret == 0); 376 } else { 377 /* Return will be MBEDTLS_ERR_ASN1_OUT_OF_DATA because the rest of 378 * the buffer is missing 379 */ 380 TEST_ASSERT(ret == MBEDTLS_ERR_ASN1_OUT_OF_DATA); 381 } 382 TEST_ASSERT(read_len == (size_t) len); 383 TEST_ASSERT(p == buf + GUARD_LEN + buf_len); 384 } 385 } 386 /* END_CASE */ 387 388 /* BEGIN_CASE */ 389 void test_asn1_write_bitstrings(data_t *bitstring, int bits, 390 data_t *expected, int is_named) 391 { 392 generic_write_data_t data = { NULL, NULL, NULL, NULL, 0 }; 393 int ret; 394 int (*func)(unsigned char **p, const unsigned char *start, 395 const unsigned char *buf, size_t bits) = 396 (is_named ? mbedtls_asn1_write_named_bitstring : 397 mbedtls_asn1_write_bitstring); 398 #if defined(MBEDTLS_ASN1_PARSE_C) 399 unsigned char *masked_bitstring = NULL; 400 #endif /* MBEDTLS_ASN1_PARSE_C */ 401 402 /* The API expects `bitstring->x` to contain `bits` bits. */ 403 size_t byte_length = (bits + 7) / 8; 404 TEST_ASSERT(bitstring->len >= byte_length); 405 406 #if defined(MBEDTLS_ASN1_PARSE_C) 407 TEST_CALLOC(masked_bitstring, byte_length); 408 if (byte_length != 0) { 409 memcpy(masked_bitstring, bitstring->x, byte_length); 410 if (bits % 8 != 0) { 411 masked_bitstring[byte_length - 1] &= ~(0xff >> (bits % 8)); 412 } 413 } 414 size_t value_bits = bits; 415 if (is_named) { 416 /* In a named bit string, all trailing 0 bits are removed. */ 417 while (byte_length > 0 && masked_bitstring[byte_length - 1] == 0) { 418 --byte_length; 419 } 420 value_bits = 8 * byte_length; 421 if (byte_length > 0) { 422 unsigned char last_byte = masked_bitstring[byte_length - 1]; 423 for (unsigned b = 1; b < 0xff && (last_byte & b) == 0; b <<= 1) { 424 --value_bits; 425 } 426 } 427 } 428 #endif /* MBEDTLS_ASN1_PARSE_C */ 429 430 for (data.size = 0; data.size <= expected->len + 1; data.size++) { 431 if (!generic_write_start_step(&data)) { 432 goto exit; 433 } 434 ret = (*func)(&data.p, data.start, bitstring->x, bits); 435 if (!generic_write_finish_step(&data, expected, ret)) { 436 goto exit; 437 } 438 #if defined(MBEDTLS_ASN1_PARSE_C) 439 if (ret >= 0) { 440 mbedtls_asn1_bitstring read = { 0, 0, NULL }; 441 TEST_EQUAL(mbedtls_asn1_get_bitstring(&data.p, data.end, 442 &read), 0); 443 TEST_MEMORY_COMPARE(read.p, read.len, 444 masked_bitstring, byte_length); 445 TEST_EQUAL(read.unused_bits, 8 * byte_length - value_bits); 446 } 447 #endif /* MBEDTLS_ASN1_PARSE_C */ 448 } 449 450 exit: 451 mbedtls_free(data.output); 452 #if defined(MBEDTLS_ASN1_PARSE_C) 453 mbedtls_free(masked_bitstring); 454 #endif /* MBEDTLS_ASN1_PARSE_C */ 455 } 456 /* END_CASE */ 457 458 /* BEGIN_CASE */ 459 void store_named_data_find(data_t *oid0, data_t *oid1, 460 data_t *oid2, data_t *oid3, 461 data_t *needle, int from, int position) 462 { 463 data_t *oid[4] = { oid0, oid1, oid2, oid3 }; 464 mbedtls_asn1_named_data nd[] = { 465 { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 }, 466 { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 }, 467 { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 }, 468 { { 0x06, 0, NULL }, { 0, 0, NULL }, NULL, 0 }, 469 }; 470 mbedtls_asn1_named_data *pointers[ARRAY_LENGTH(nd) + 1]; 471 size_t i; 472 mbedtls_asn1_named_data *head = NULL; 473 mbedtls_asn1_named_data *found = NULL; 474 475 for (i = 0; i < ARRAY_LENGTH(nd); i++) { 476 pointers[i] = &nd[i]; 477 } 478 pointers[ARRAY_LENGTH(nd)] = NULL; 479 for (i = 0; i < ARRAY_LENGTH(nd); i++) { 480 TEST_CALLOC(nd[i].oid.p, oid[i]->len); 481 memcpy(nd[i].oid.p, oid[i]->x, oid[i]->len); 482 nd[i].oid.len = oid[i]->len; 483 nd[i].next = pointers[i+1]; 484 } 485 486 head = pointers[from]; 487 found = mbedtls_asn1_store_named_data(&head, 488 (const char *) needle->x, 489 needle->len, 490 NULL, 0); 491 492 /* In any case, the existing list structure must be unchanged. */ 493 for (i = 0; i < ARRAY_LENGTH(nd); i++) { 494 TEST_ASSERT(nd[i].next == pointers[i+1]); 495 } 496 497 if (position >= 0) { 498 /* position should have been found and modified. */ 499 TEST_ASSERT(head == pointers[from]); 500 TEST_ASSERT(found == pointers[position]); 501 } else { 502 /* A new entry should have been created. */ 503 TEST_ASSERT(found == head); 504 TEST_ASSERT(head->next == pointers[from]); 505 for (i = 0; i < ARRAY_LENGTH(nd); i++) { 506 TEST_ASSERT(found != &nd[i]); 507 } 508 } 509 510 exit: 511 if (found != NULL && found == head && found != pointers[from]) { 512 mbedtls_free(found->oid.p); 513 mbedtls_free(found); 514 } 515 for (i = 0; i < ARRAY_LENGTH(nd); i++) { 516 mbedtls_free(nd[i].oid.p); 517 } 518 } 519 /* END_CASE */ 520 521 /* BEGIN_CASE */ 522 void store_named_data_val_found(int old_len, int new_len) 523 { 524 mbedtls_asn1_named_data nd = 525 { { 0x06, 3, (unsigned char *) "OID" }, { 0, 0, NULL }, NULL, 0 }; 526 mbedtls_asn1_named_data *head = &nd; 527 mbedtls_asn1_named_data *found = NULL; 528 unsigned char *old_val = NULL; 529 unsigned char *new_val = (unsigned char *) "new value"; 530 531 if (old_len != 0) { 532 TEST_CALLOC(nd.val.p, (size_t) old_len); 533 old_val = nd.val.p; 534 nd.val.len = old_len; 535 memset(old_val, 'x', old_len); 536 } 537 if (new_len <= 0) { 538 new_len = -new_len; 539 new_val = NULL; 540 } 541 542 found = mbedtls_asn1_store_named_data(&head, "OID", 3, 543 new_val, new_len); 544 TEST_ASSERT(head == &nd); 545 TEST_ASSERT(found == head); 546 547 if (new_val != NULL) { 548 TEST_MEMORY_COMPARE(found->val.p, found->val.len, 549 new_val, (size_t) new_len); 550 } 551 if (new_len == 0) { 552 TEST_ASSERT(found->val.p == NULL); 553 /* If new_len != 0, then new_val != NULL and the length has been checked 554 * above by TEST_MEMORY_COMPARE(). But not here, so we need to check. */ 555 TEST_EQUAL(found->val.len, 0); 556 } else if (new_len == old_len) { 557 TEST_ASSERT(found->val.p == old_val); 558 } else { 559 TEST_ASSERT(found->val.p != old_val); 560 } 561 562 exit: 563 mbedtls_free(nd.val.p); 564 } 565 /* END_CASE */ 566 567 /* BEGIN_CASE */ 568 void store_named_data_val_new(int new_len, int set_new_val) 569 { 570 mbedtls_asn1_named_data *head = NULL; 571 mbedtls_asn1_named_data *found = NULL; 572 const unsigned char *oid = (unsigned char *) "OID"; 573 size_t oid_len = strlen((const char *) oid); 574 const unsigned char *new_val = (unsigned char *) "new value"; 575 576 if (set_new_val == 0) { 577 new_val = NULL; 578 } 579 580 found = mbedtls_asn1_store_named_data(&head, 581 (const char *) oid, oid_len, 582 new_val, (size_t) new_len); 583 TEST_ASSERT(found != NULL); 584 TEST_ASSERT(found == head); 585 TEST_ASSERT(found->oid.p != oid); 586 TEST_MEMORY_COMPARE(found->oid.p, found->oid.len, oid, oid_len); 587 if (new_len == 0) { 588 TEST_ASSERT(found->val.p == NULL); 589 TEST_EQUAL(found->val.len, 0); 590 } else if (new_val == NULL) { 591 TEST_ASSERT(found->val.p != NULL); 592 TEST_EQUAL(found->val.len, new_len); 593 } else { 594 TEST_ASSERT(found->val.p != new_val); 595 TEST_MEMORY_COMPARE(found->val.p, found->val.len, 596 new_val, (size_t) new_len); 597 } 598 599 exit: 600 if (found != NULL) { 601 mbedtls_free(found->oid.p); 602 mbedtls_free(found->val.p); 603 } 604 mbedtls_free(found); 605 } 606 /* END_CASE */