1 /* Copyright (c) 2014, Google Inc. 2 * 3 * Permission to use, copy, modify, and/or distribute this software for any 4 * purpose with or without fee is hereby granted, provided that the above 5 * copyright notice and this permission notice appear in all copies. 6 * 7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 10 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 12 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 13 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ 14 15 #if !defined(__STDC_CONSTANT_MACROS) 16 #define __STDC_CONSTANT_MACROS 17 #endif 18 19 #include <stdio.h> 20 #include <stdlib.h> 21 #include <string.h> 22 23 #include <vector> 24 25 #include <gtest/gtest.h> 26 27 #include <openssl/bytestring.h> 28 #include <openssl/crypto.h> 29 30 #include "internal.h" 31 #include "../internal.h" 32 #include "../test/test_util.h" 33 34 35 TEST(CBSTest, Skip) { 36 static const uint8_t kData[] = {1, 2, 3}; 37 CBS data; 38 39 CBS_init(&data, kData, sizeof(kData)); 40 EXPECT_EQ(3u, CBS_len(&data)); 41 EXPECT_TRUE(CBS_skip(&data, 1)); 42 EXPECT_EQ(2u, CBS_len(&data)); 43 EXPECT_TRUE(CBS_skip(&data, 2)); 44 EXPECT_EQ(0u, CBS_len(&data)); 45 EXPECT_FALSE(CBS_skip(&data, 1)); 46 } 47 48 TEST(CBSTest, GetUint) { 49 static const uint8_t kData[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; 50 uint8_t u8; 51 uint16_t u16; 52 uint32_t u32; 53 CBS data; 54 55 CBS_init(&data, kData, sizeof(kData)); 56 ASSERT_TRUE(CBS_get_u8(&data, &u8)); 57 EXPECT_EQ(1u, u8); 58 ASSERT_TRUE(CBS_get_u16(&data, &u16)); 59 EXPECT_EQ(0x203u, u16); 60 ASSERT_TRUE(CBS_get_u24(&data, &u32)); 61 EXPECT_EQ(0x40506u, u32); 62 ASSERT_TRUE(CBS_get_u32(&data, &u32)); 63 EXPECT_EQ(0x708090au, u32); 64 ASSERT_TRUE(CBS_get_last_u8(&data, &u8)); 65 EXPECT_EQ(0xcu, u8); 66 ASSERT_TRUE(CBS_get_last_u8(&data, &u8)); 67 EXPECT_EQ(0xbu, u8); 68 EXPECT_FALSE(CBS_get_u8(&data, &u8)); 69 EXPECT_FALSE(CBS_get_last_u8(&data, &u8)); 70 } 71 72 TEST(CBSTest, GetPrefixed) { 73 static const uint8_t kData[] = {1, 2, 0, 2, 3, 4, 0, 0, 3, 3, 2, 1}; 74 uint8_t u8; 75 uint16_t u16; 76 uint32_t u32; 77 CBS data, prefixed; 78 79 CBS_init(&data, kData, sizeof(kData)); 80 ASSERT_TRUE(CBS_get_u8_length_prefixed(&data, &prefixed)); 81 EXPECT_EQ(1u, CBS_len(&prefixed)); 82 ASSERT_TRUE(CBS_get_u8(&prefixed, &u8)); 83 EXPECT_EQ(2u, u8); 84 ASSERT_TRUE(CBS_get_u16_length_prefixed(&data, &prefixed)); 85 EXPECT_EQ(2u, CBS_len(&prefixed)); 86 ASSERT_TRUE(CBS_get_u16(&prefixed, &u16)); 87 EXPECT_EQ(0x304u, u16); 88 ASSERT_TRUE(CBS_get_u24_length_prefixed(&data, &prefixed)); 89 EXPECT_EQ(3u, CBS_len(&prefixed)); 90 ASSERT_TRUE(CBS_get_u24(&prefixed, &u32)); 91 EXPECT_EQ(0x30201u, u32); 92 } 93 94 TEST(CBSTest, GetPrefixedBad) { 95 static const uint8_t kData1[] = {2, 1}; 96 static const uint8_t kData2[] = {0, 2, 1}; 97 static const uint8_t kData3[] = {0, 0, 2, 1}; 98 CBS data, prefixed; 99 100 CBS_init(&data, kData1, sizeof(kData1)); 101 EXPECT_FALSE(CBS_get_u8_length_prefixed(&data, &prefixed)); 102 103 CBS_init(&data, kData2, sizeof(kData2)); 104 EXPECT_FALSE(CBS_get_u16_length_prefixed(&data, &prefixed)); 105 106 CBS_init(&data, kData3, sizeof(kData3)); 107 EXPECT_FALSE(CBS_get_u24_length_prefixed(&data, &prefixed)); 108 } 109 110 TEST(CBSTest, GetASN1) { 111 static const uint8_t kData1[] = {0x30, 2, 1, 2}; 112 static const uint8_t kData2[] = {0x30, 3, 1, 2}; 113 static const uint8_t kData3[] = {0x30, 0x80}; 114 static const uint8_t kData4[] = {0x30, 0x81, 1, 1}; 115 static const uint8_t kData5[4 + 0x80] = {0x30, 0x82, 0, 0x80}; 116 static const uint8_t kData6[] = {0xa1, 3, 0x4, 1, 1}; 117 static const uint8_t kData7[] = {0xa1, 3, 0x4, 2, 1}; 118 static const uint8_t kData8[] = {0xa1, 3, 0x2, 1, 1}; 119 static const uint8_t kData9[] = {0xa1, 3, 0x2, 1, 0xff}; 120 121 CBS data, contents; 122 int present; 123 uint64_t value; 124 125 CBS_init(&data, kData1, sizeof(kData1)); 126 EXPECT_FALSE(CBS_peek_asn1_tag(&data, 0x1)); 127 EXPECT_TRUE(CBS_peek_asn1_tag(&data, 0x30)); 128 129 ASSERT_TRUE(CBS_get_asn1(&data, &contents, 0x30)); 130 EXPECT_EQ(Bytes("\x01\x02"), Bytes(CBS_data(&contents), CBS_len(&contents))); 131 132 CBS_init(&data, kData2, sizeof(kData2)); 133 // data is truncated 134 EXPECT_FALSE(CBS_get_asn1(&data, &contents, 0x30)); 135 136 CBS_init(&data, kData3, sizeof(kData3)); 137 // zero byte length of length 138 EXPECT_FALSE(CBS_get_asn1(&data, &contents, 0x30)); 139 140 CBS_init(&data, kData4, sizeof(kData4)); 141 // long form mistakenly used. 142 EXPECT_FALSE(CBS_get_asn1(&data, &contents, 0x30)); 143 144 CBS_init(&data, kData5, sizeof(kData5)); 145 // length takes too many bytes. 146 EXPECT_FALSE(CBS_get_asn1(&data, &contents, 0x30)); 147 148 CBS_init(&data, kData1, sizeof(kData1)); 149 // wrong tag. 150 EXPECT_FALSE(CBS_get_asn1(&data, &contents, 0x31)); 151 152 CBS_init(&data, NULL, 0); 153 // peek at empty data. 154 EXPECT_FALSE(CBS_peek_asn1_tag(&data, 0x30)); 155 156 CBS_init(&data, NULL, 0); 157 // optional elements at empty data. 158 ASSERT_TRUE(CBS_get_optional_asn1(&data, &contents, &present, 0xa0)); 159 EXPECT_FALSE(present); 160 ASSERT_TRUE( 161 CBS_get_optional_asn1_octet_string(&data, &contents, &present, 0xa0)); 162 EXPECT_FALSE(present); 163 EXPECT_EQ(0u, CBS_len(&contents)); 164 ASSERT_TRUE(CBS_get_optional_asn1_octet_string(&data, &contents, NULL, 0xa0)); 165 EXPECT_EQ(0u, CBS_len(&contents)); 166 ASSERT_TRUE(CBS_get_optional_asn1_uint64(&data, &value, 0xa0, 42)); 167 EXPECT_EQ(42u, value); 168 169 CBS_init(&data, kData6, sizeof(kData6)); 170 // optional element. 171 ASSERT_TRUE(CBS_get_optional_asn1(&data, &contents, &present, 0xa0)); 172 EXPECT_FALSE(present); 173 ASSERT_TRUE(CBS_get_optional_asn1(&data, &contents, &present, 0xa1)); 174 EXPECT_TRUE(present); 175 EXPECT_EQ(Bytes("\x04\x01\x01"), 176 Bytes(CBS_data(&contents), CBS_len(&contents))); 177 178 CBS_init(&data, kData6, sizeof(kData6)); 179 // optional octet string. 180 ASSERT_TRUE( 181 CBS_get_optional_asn1_octet_string(&data, &contents, &present, 0xa0)); 182 EXPECT_FALSE(present); 183 EXPECT_EQ(0u, CBS_len(&contents)); 184 ASSERT_TRUE( 185 CBS_get_optional_asn1_octet_string(&data, &contents, &present, 0xa1)); 186 EXPECT_TRUE(present); 187 EXPECT_EQ(Bytes("\x01"), Bytes(CBS_data(&contents), CBS_len(&contents))); 188 189 CBS_init(&data, kData7, sizeof(kData7)); 190 // invalid optional octet string. 191 EXPECT_FALSE( 192 CBS_get_optional_asn1_octet_string(&data, &contents, &present, 0xa1)); 193 194 CBS_init(&data, kData8, sizeof(kData8)); 195 // optional integer. 196 ASSERT_TRUE(CBS_get_optional_asn1_uint64(&data, &value, 0xa0, 42)); 197 EXPECT_EQ(42u, value); 198 ASSERT_TRUE(CBS_get_optional_asn1_uint64(&data, &value, 0xa1, 42)); 199 EXPECT_EQ(1u, value); 200 201 CBS_init(&data, kData9, sizeof(kData9)); 202 // invalid optional integer. 203 EXPECT_FALSE(CBS_get_optional_asn1_uint64(&data, &value, 0xa1, 42)); 204 205 unsigned tag; 206 CBS_init(&data, kData1, sizeof(kData1)); 207 ASSERT_TRUE(CBS_get_any_asn1(&data, &contents, &tag)); 208 EXPECT_EQ(CBS_ASN1_SEQUENCE, tag); 209 EXPECT_EQ(Bytes("\x01\x02"), Bytes(CBS_data(&contents), CBS_len(&contents))); 210 211 size_t header_len; 212 CBS_init(&data, kData1, sizeof(kData1)); 213 ASSERT_TRUE(CBS_get_any_asn1_element(&data, &contents, &tag, &header_len)); 214 EXPECT_EQ(CBS_ASN1_SEQUENCE, tag); 215 EXPECT_EQ(2u, header_len); 216 EXPECT_EQ(Bytes("\x30\x02\x01\x02"), 217 Bytes(CBS_data(&contents), CBS_len(&contents))); 218 } 219 220 TEST(CBSTest, GetOptionalASN1Bool) { 221 static const uint8_t kTrue[] = {0x0a, 3, CBS_ASN1_BOOLEAN, 1, 0xff}; 222 static const uint8_t kFalse[] = {0x0a, 3, CBS_ASN1_BOOLEAN, 1, 0x00}; 223 static const uint8_t kInvalid[] = {0x0a, 3, CBS_ASN1_BOOLEAN, 1, 0x01}; 224 225 CBS data; 226 CBS_init(&data, NULL, 0); 227 int val = 2; 228 ASSERT_TRUE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0)); 229 EXPECT_EQ(0, val); 230 231 CBS_init(&data, kTrue, sizeof(kTrue)); 232 val = 2; 233 ASSERT_TRUE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0)); 234 EXPECT_EQ(1, val); 235 236 CBS_init(&data, kFalse, sizeof(kFalse)); 237 val = 2; 238 ASSERT_TRUE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1)); 239 EXPECT_EQ(0, val); 240 241 CBS_init(&data, kInvalid, sizeof(kInvalid)); 242 EXPECT_FALSE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1)); 243 } 244 245 // Test that CBB_init may be used on an uninitialized input. 246 TEST(CBBTest, InitUninitialized) { 247 CBB cbb; 248 ASSERT_TRUE(CBB_init(&cbb, 100)); 249 CBB_cleanup(&cbb); 250 } 251 252 TEST(CBBTest, Basic) { 253 static const uint8_t kExpected[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc}; 254 uint8_t *buf; 255 size_t buf_len; 256 257 bssl::ScopedCBB cbb; 258 ASSERT_TRUE(CBB_init(cbb.get(), 100)); 259 cbb.Reset(); 260 261 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 262 ASSERT_TRUE(CBB_add_u8(cbb.get(), 1)); 263 ASSERT_TRUE(CBB_add_u16(cbb.get(), 0x203)); 264 ASSERT_TRUE(CBB_add_u24(cbb.get(), 0x40506)); 265 ASSERT_TRUE(CBB_add_u32(cbb.get(), 0x708090a)); 266 ASSERT_TRUE(CBB_add_bytes(cbb.get(), (const uint8_t *)"\x0b\x0c", 2)); 267 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 268 269 bssl::UniquePtr<uint8_t> scoper(buf); 270 EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len)); 271 } 272 273 TEST(CBBTest, Fixed) { 274 bssl::ScopedCBB cbb; 275 uint8_t buf[1]; 276 uint8_t *out_buf; 277 size_t out_size; 278 279 ASSERT_TRUE(CBB_init_fixed(cbb.get(), NULL, 0)); 280 ASSERT_TRUE(CBB_finish(cbb.get(), &out_buf, &out_size)); 281 EXPECT_EQ(NULL, out_buf); 282 EXPECT_EQ(0u, out_size); 283 284 cbb.Reset(); 285 ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, 1)); 286 ASSERT_TRUE(CBB_add_u8(cbb.get(), 1)); 287 ASSERT_TRUE(CBB_finish(cbb.get(), &out_buf, &out_size)); 288 EXPECT_EQ(buf, out_buf); 289 EXPECT_EQ(1u, out_size); 290 EXPECT_EQ(1u, buf[0]); 291 292 cbb.Reset(); 293 ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, 1)); 294 ASSERT_TRUE(CBB_add_u8(cbb.get(), 1)); 295 EXPECT_FALSE(CBB_add_u8(cbb.get(), 2)); 296 } 297 298 // Test that calling CBB_finish on a child does nothing. 299 TEST(CBBTest, FinishChild) { 300 CBB child; 301 uint8_t *out_buf; 302 size_t out_size; 303 304 bssl::ScopedCBB cbb; 305 ASSERT_TRUE(CBB_init(cbb.get(), 16)); 306 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &child)); 307 308 EXPECT_FALSE(CBB_finish(&child, &out_buf, &out_size)); 309 310 ASSERT_TRUE(CBB_finish(cbb.get(), &out_buf, &out_size)); 311 bssl::UniquePtr<uint8_t> scoper(out_buf); 312 ASSERT_EQ(1u, out_size); 313 EXPECT_EQ(0u, out_buf[0]); 314 } 315 316 TEST(CBBTest, Prefixed) { 317 static const uint8_t kExpected[] = {0, 1, 1, 0, 2, 2, 3, 0, 0, 3, 318 4, 5, 6, 5, 4, 1, 0, 1, 2}; 319 uint8_t *buf; 320 size_t buf_len; 321 bssl::ScopedCBB cbb; 322 CBB contents, inner_contents, inner_inner_contents; 323 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 324 EXPECT_EQ(0u, CBB_len(cbb.get())); 325 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents)); 326 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents)); 327 ASSERT_TRUE(CBB_add_u8(&contents, 1)); 328 EXPECT_EQ(1u, CBB_len(&contents)); 329 ASSERT_TRUE(CBB_flush(cbb.get())); 330 EXPECT_EQ(3u, CBB_len(cbb.get())); 331 ASSERT_TRUE(CBB_add_u16_length_prefixed(cbb.get(), &contents)); 332 ASSERT_TRUE(CBB_add_u16(&contents, 0x203)); 333 ASSERT_TRUE(CBB_add_u24_length_prefixed(cbb.get(), &contents)); 334 ASSERT_TRUE(CBB_add_u24(&contents, 0x40506)); 335 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents)); 336 ASSERT_TRUE(CBB_add_u8_length_prefixed(&contents, &inner_contents)); 337 ASSERT_TRUE(CBB_add_u8(&inner_contents, 1)); 338 ASSERT_TRUE( 339 CBB_add_u16_length_prefixed(&inner_contents, &inner_inner_contents)); 340 ASSERT_TRUE(CBB_add_u8(&inner_inner_contents, 2)); 341 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 342 343 bssl::UniquePtr<uint8_t> scoper(buf); 344 EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len)); 345 } 346 347 TEST(CBBTest, DiscardChild) { 348 bssl::ScopedCBB cbb; 349 CBB contents, inner_contents, inner_inner_contents; 350 351 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 352 ASSERT_TRUE(CBB_add_u8(cbb.get(), 0xaa)); 353 354 // Discarding |cbb|'s children preserves the byte written. 355 CBB_discard_child(cbb.get()); 356 357 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents)); 358 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents)); 359 ASSERT_TRUE(CBB_add_u8(&contents, 0xbb)); 360 ASSERT_TRUE(CBB_add_u16_length_prefixed(cbb.get(), &contents)); 361 ASSERT_TRUE(CBB_add_u16(&contents, 0xcccc)); 362 ASSERT_TRUE(CBB_add_u24_length_prefixed(cbb.get(), &contents)); 363 ASSERT_TRUE(CBB_add_u24(&contents, 0xdddddd)); 364 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents)); 365 ASSERT_TRUE(CBB_add_u8(&contents, 0xff)); 366 ASSERT_TRUE(CBB_add_u8_length_prefixed(&contents, &inner_contents)); 367 ASSERT_TRUE(CBB_add_u8(&inner_contents, 0x42)); 368 ASSERT_TRUE( 369 CBB_add_u16_length_prefixed(&inner_contents, &inner_inner_contents)); 370 ASSERT_TRUE(CBB_add_u8(&inner_inner_contents, 0x99)); 371 372 // Discard everything from |inner_contents| down. 373 CBB_discard_child(&contents); 374 375 uint8_t *buf; 376 size_t buf_len; 377 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 378 bssl::UniquePtr<uint8_t> scoper(buf); 379 380 static const uint8_t kExpected[] = { 381 0xaa, 382 0, 383 1, 0xbb, 384 0, 2, 0xcc, 0xcc, 385 0, 0, 3, 0xdd, 0xdd, 0xdd, 386 1, 0xff, 387 }; 388 EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len)); 389 } 390 391 TEST(CBBTest, Misuse) { 392 bssl::ScopedCBB cbb; 393 CBB child, contents; 394 uint8_t *buf; 395 size_t buf_len; 396 397 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 398 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &child)); 399 ASSERT_TRUE(CBB_add_u8(&child, 1)); 400 ASSERT_TRUE(CBB_add_u8(cbb.get(), 2)); 401 402 // Since we wrote to |cbb|, |child| is now invalid and attempts to write to 403 // it should fail. 404 EXPECT_FALSE(CBB_add_u8(&child, 1)); 405 EXPECT_FALSE(CBB_add_u16(&child, 1)); 406 EXPECT_FALSE(CBB_add_u24(&child, 1)); 407 EXPECT_FALSE(CBB_add_u8_length_prefixed(&child, &contents)); 408 EXPECT_FALSE(CBB_add_u16_length_prefixed(&child, &contents)); 409 EXPECT_FALSE(CBB_add_asn1(&child, &contents, 1)); 410 EXPECT_FALSE(CBB_add_bytes(&child, (const uint8_t*) "a", 1)); 411 412 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 413 bssl::UniquePtr<uint8_t> scoper(buf); 414 415 EXPECT_EQ(Bytes("\x01\x01\x02"), Bytes(buf, buf_len)); 416 } 417 418 TEST(CBBTest, ASN1) { 419 static const uint8_t kExpected[] = {0x30, 3, 1, 2, 3}; 420 uint8_t *buf; 421 size_t buf_len; 422 bssl::ScopedCBB cbb; 423 CBB contents, inner_contents; 424 425 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 426 ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, 0x30)); 427 ASSERT_TRUE(CBB_add_bytes(&contents, (const uint8_t *)"\x01\x02\x03", 3)); 428 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 429 bssl::UniquePtr<uint8_t> scoper(buf); 430 431 EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len)); 432 433 std::vector<uint8_t> test_data(100000, 0x42); 434 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 435 ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, 0x30)); 436 ASSERT_TRUE(CBB_add_bytes(&contents, test_data.data(), 130)); 437 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 438 scoper.reset(buf); 439 440 ASSERT_EQ(3u + 130u, buf_len); 441 EXPECT_EQ(Bytes("\x30\x81\x82"), Bytes(buf, 3)); 442 EXPECT_EQ(Bytes(test_data.data(), 130), Bytes(buf + 3, 130)); 443 444 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 445 ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, 0x30)); 446 ASSERT_TRUE(CBB_add_bytes(&contents, test_data.data(), 1000)); 447 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 448 scoper.reset(buf); 449 450 ASSERT_EQ(4u + 1000u, buf_len); 451 EXPECT_EQ(Bytes("\x30\x82\x03\xe8"), Bytes(buf, 4)); 452 EXPECT_EQ(Bytes(test_data.data(), 1000), Bytes(buf + 4, 1000)); 453 454 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 455 ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, 0x30)); 456 ASSERT_TRUE(CBB_add_asn1(&contents, &inner_contents, 0x30)); 457 ASSERT_TRUE(CBB_add_bytes(&inner_contents, test_data.data(), 100000)); 458 ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len)); 459 scoper.reset(buf); 460 461 ASSERT_EQ(5u + 5u + 100000u, buf_len); 462 EXPECT_EQ(Bytes("\x30\x83\x01\x86\xa5\x30\x83\x01\x86\xa0"), Bytes(buf, 10)); 463 EXPECT_EQ(Bytes(test_data.data(), test_data.size()), Bytes(buf + 10, 100000)); 464 } 465 466 static void ExpectBerConvert(const char *name, const uint8_t *der_expected, 467 size_t der_len, const uint8_t *ber, 468 size_t ber_len) { 469 SCOPED_TRACE(name); 470 CBS in; 471 uint8_t *out; 472 size_t out_len; 473 474 CBS_init(&in, ber, ber_len); 475 ASSERT_TRUE(CBS_asn1_ber_to_der(&in, &out, &out_len)); 476 bssl::UniquePtr<uint8_t> scoper(out); 477 478 if (out == NULL) { 479 EXPECT_EQ(Bytes(der_expected, der_len), Bytes(ber, ber_len)); 480 } else { 481 EXPECT_NE(Bytes(der_expected, der_len), Bytes(ber, ber_len)); 482 EXPECT_EQ(Bytes(der_expected, der_len), Bytes(out, out_len)); 483 } 484 } 485 486 TEST(CBSTest, BerConvert) { 487 static const uint8_t kSimpleBER[] = {0x01, 0x01, 0x00}; 488 489 // kIndefBER contains a SEQUENCE with an indefinite length. 490 static const uint8_t kIndefBER[] = {0x30, 0x80, 0x01, 0x01, 0x02, 0x00, 0x00}; 491 static const uint8_t kIndefDER[] = {0x30, 0x03, 0x01, 0x01, 0x02}; 492 493 // kOctetStringBER contains an indefinite length OCTET STRING with two parts. 494 // These parts need to be concatenated in DER form. 495 static const uint8_t kOctetStringBER[] = {0x24, 0x80, 0x04, 0x02, 0, 1, 496 0x04, 0x02, 2, 3, 0x00, 0x00}; 497 static const uint8_t kOctetStringDER[] = {0x04, 0x04, 0, 1, 2, 3}; 498 499 // kNSSBER is part of a PKCS#12 message generated by NSS that uses indefinite 500 // length elements extensively. 501 static const uint8_t kNSSBER[] = { 502 0x30, 0x80, 0x02, 0x01, 0x03, 0x30, 0x80, 0x06, 0x09, 0x2a, 0x86, 0x48, 503 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0xa0, 0x80, 0x24, 0x80, 0x04, 0x04, 504 0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x39, 505 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 506 0x00, 0x04, 0x14, 0x84, 0x98, 0xfc, 0x66, 0x33, 0xee, 0xba, 0xe7, 0x90, 507 0xc1, 0xb6, 0xe8, 0x8f, 0xfe, 0x1d, 0xc5, 0xa5, 0x97, 0x93, 0x3e, 0x04, 508 0x10, 0x38, 0x62, 0xc6, 0x44, 0x12, 0xd5, 0x30, 0x00, 0xf8, 0xf2, 0x1b, 509 0xf0, 0x6e, 0x10, 0x9b, 0xb8, 0x02, 0x02, 0x07, 0xd0, 0x00, 0x00, 510 }; 511 512 static const uint8_t kNSSDER[] = { 513 0x30, 0x53, 0x02, 0x01, 0x03, 0x30, 0x13, 0x06, 0x09, 0x2a, 0x86, 514 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0xa0, 0x06, 0x04, 0x04, 515 0x01, 0x02, 0x03, 0x04, 0x30, 0x39, 0x30, 0x21, 0x30, 0x09, 0x06, 516 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, 0x84, 517 0x98, 0xfc, 0x66, 0x33, 0xee, 0xba, 0xe7, 0x90, 0xc1, 0xb6, 0xe8, 518 0x8f, 0xfe, 0x1d, 0xc5, 0xa5, 0x97, 0x93, 0x3e, 0x04, 0x10, 0x38, 519 0x62, 0xc6, 0x44, 0x12, 0xd5, 0x30, 0x00, 0xf8, 0xf2, 0x1b, 0xf0, 520 0x6e, 0x10, 0x9b, 0xb8, 0x02, 0x02, 0x07, 0xd0, 521 }; 522 523 // kConstructedStringBER contains a deeply-nested constructed OCTET STRING. 524 // The BER conversion collapses this to one level deep, but not completely. 525 static const uint8_t kConstructedStringBER[] = { 526 0xa0, 0x10, 0x24, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01, 527 0x01, 0x24, 0x06, 0x04, 0x01, 0x02, 0x04, 0x01, 0x03, 528 }; 529 static const uint8_t kConstructedStringDER[] = { 530 0xa0, 0x08, 0x04, 0x02, 0x00, 0x01, 0x04, 0x02, 0x02, 0x03, 531 }; 532 533 ExpectBerConvert("kSimpleBER", kSimpleBER, sizeof(kSimpleBER), kSimpleBER, 534 sizeof(kSimpleBER)); 535 ExpectBerConvert("kIndefBER", kIndefDER, sizeof(kIndefDER), kIndefBER, 536 sizeof(kIndefBER)); 537 ExpectBerConvert("kOctetStringBER", kOctetStringDER, sizeof(kOctetStringDER), 538 kOctetStringBER, sizeof(kOctetStringBER)); 539 ExpectBerConvert("kNSSBER", kNSSDER, sizeof(kNSSDER), kNSSBER, 540 sizeof(kNSSBER)); 541 ExpectBerConvert("kConstructedStringBER", kConstructedStringDER, 542 sizeof(kConstructedStringDER), kConstructedStringBER, 543 sizeof(kConstructedStringBER)); 544 } 545 546 struct ImplicitStringTest { 547 const char *in; 548 size_t in_len; 549 bool ok; 550 const char *out; 551 size_t out_len; 552 }; 553 554 static const ImplicitStringTest kImplicitStringTests[] = { 555 // A properly-encoded string. 556 {"\x80\x03\x61\x61\x61", 5, true, "aaa", 3}, 557 // An implicit-tagged string. 558 {"\xa0\x09\x04\x01\x61\x04\x01\x61\x04\x01\x61", 11, true, "aaa", 3}, 559 // |CBS_get_asn1_implicit_string| only accepts one level deep of nesting. 560 {"\xa0\x0b\x24\x06\x04\x01\x61\x04\x01\x61\x04\x01\x61", 13, false, nullptr, 561 0}, 562 // The outer tag must match. 563 {"\x81\x03\x61\x61\x61", 5, false, nullptr, 0}, 564 {"\xa1\x09\x04\x01\x61\x04\x01\x61\x04\x01\x61", 11, false, nullptr, 0}, 565 // The inner tag must match. 566 {"\xa1\x09\x0c\x01\x61\x0c\x01\x61\x0c\x01\x61", 11, false, nullptr, 0}, 567 }; 568 569 TEST(CBSTest, ImplicitString) { 570 for (const auto &test : kImplicitStringTests) { 571 SCOPED_TRACE(Bytes(test.in, test.in_len)); 572 uint8_t *storage = nullptr; 573 CBS in, out; 574 CBS_init(&in, reinterpret_cast<const uint8_t *>(test.in), test.in_len); 575 int ok = CBS_get_asn1_implicit_string(&in, &out, &storage, 576 CBS_ASN1_CONTEXT_SPECIFIC | 0, 577 CBS_ASN1_OCTETSTRING); 578 bssl::UniquePtr<uint8_t> scoper(storage); 579 EXPECT_EQ(test.ok, static_cast<bool>(ok)); 580 581 if (ok) { 582 EXPECT_EQ(Bytes(test.out, test.out_len), 583 Bytes(CBS_data(&out), CBS_len(&out))); 584 } 585 } 586 } 587 588 struct ASN1Uint64Test { 589 uint64_t value; 590 const char *encoding; 591 size_t encoding_len; 592 }; 593 594 static const ASN1Uint64Test kASN1Uint64Tests[] = { 595 {0, "\x02\x01\x00", 3}, 596 {1, "\x02\x01\x01", 3}, 597 {127, "\x02\x01\x7f", 3}, 598 {128, "\x02\x02\x00\x80", 4}, 599 {0xdeadbeef, "\x02\x05\x00\xde\xad\xbe\xef", 7}, 600 {UINT64_C(0x0102030405060708), 601 "\x02\x08\x01\x02\x03\x04\x05\x06\x07\x08", 10}, 602 {UINT64_C(0xffffffffffffffff), 603 "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff", 11}, 604 }; 605 606 struct ASN1InvalidUint64Test { 607 const char *encoding; 608 size_t encoding_len; 609 }; 610 611 static const ASN1InvalidUint64Test kASN1InvalidUint64Tests[] = { 612 // Bad tag. 613 {"\x03\x01\x00", 3}, 614 // Empty contents. 615 {"\x02\x00", 2}, 616 // Negative number. 617 {"\x02\x01\x80", 3}, 618 // Overflow. 619 {"\x02\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00", 11}, 620 // Leading zeros. 621 {"\x02\x02\x00\x01", 4}, 622 }; 623 624 TEST(CBSTest, ASN1Uint64) { 625 for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kASN1Uint64Tests); i++) { 626 SCOPED_TRACE(i); 627 const ASN1Uint64Test *test = &kASN1Uint64Tests[i]; 628 CBS cbs; 629 uint64_t value; 630 uint8_t *out; 631 size_t len; 632 633 CBS_init(&cbs, (const uint8_t *)test->encoding, test->encoding_len); 634 ASSERT_TRUE(CBS_get_asn1_uint64(&cbs, &value)); 635 EXPECT_EQ(0u, CBS_len(&cbs)); 636 EXPECT_EQ(test->value, value); 637 638 bssl::ScopedCBB cbb; 639 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 640 ASSERT_TRUE(CBB_add_asn1_uint64(cbb.get(), test->value)); 641 ASSERT_TRUE(CBB_finish(cbb.get(), &out, &len)); 642 bssl::UniquePtr<uint8_t> scoper(out); 643 EXPECT_EQ(Bytes(test->encoding, test->encoding_len), Bytes(out, len)); 644 } 645 646 for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kASN1InvalidUint64Tests); i++) { 647 const ASN1InvalidUint64Test *test = &kASN1InvalidUint64Tests[i]; 648 CBS cbs; 649 uint64_t value; 650 651 CBS_init(&cbs, (const uint8_t *)test->encoding, test->encoding_len); 652 EXPECT_FALSE(CBS_get_asn1_uint64(&cbs, &value)); 653 } 654 } 655 656 TEST(CBBTest, Zero) { 657 CBB cbb; 658 CBB_zero(&cbb); 659 // Calling |CBB_cleanup| on a zero-state |CBB| must not crash. 660 CBB_cleanup(&cbb); 661 } 662 663 TEST(CBBTest, Reserve) { 664 uint8_t buf[10]; 665 uint8_t *ptr; 666 size_t len; 667 bssl::ScopedCBB cbb; 668 ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, sizeof(buf))); 669 // Too large. 670 EXPECT_FALSE(CBB_reserve(cbb.get(), &ptr, 11)); 671 672 cbb.Reset(); 673 ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, sizeof(buf))); 674 // Successfully reserve the entire space. 675 ASSERT_TRUE(CBB_reserve(cbb.get(), &ptr, 10)); 676 EXPECT_EQ(buf, ptr); 677 // Advancing under the maximum bytes is legal. 678 ASSERT_TRUE(CBB_did_write(cbb.get(), 5)); 679 ASSERT_TRUE(CBB_finish(cbb.get(), NULL, &len)); 680 EXPECT_EQ(5u, len); 681 } 682 683 // Test that CBB errors are sticky; once on operation on CBB fails, all 684 // subsequent ones do. 685 TEST(CBBTest, StickyError) { 686 // Write an input that exceeds the limit for its length prefix. 687 bssl::ScopedCBB cbb; 688 CBB child; 689 static const uint8_t kZeros[256] = {0}; 690 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 691 ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &child)); 692 ASSERT_TRUE(CBB_add_bytes(&child, kZeros, sizeof(kZeros))); 693 ASSERT_FALSE(CBB_flush(cbb.get())); 694 695 // All future operations should fail. 696 uint8_t *ptr; 697 size_t len; 698 EXPECT_FALSE(CBB_add_u8(cbb.get(), 0)); 699 EXPECT_FALSE(CBB_finish(cbb.get(), &ptr, &len)); 700 701 // Write an input that cannot fit in a fixed CBB. 702 cbb.Reset(); 703 uint8_t buf; 704 ASSERT_TRUE(CBB_init_fixed(cbb.get(), &buf, 1)); 705 ASSERT_FALSE(CBB_add_bytes(cbb.get(), kZeros, sizeof(kZeros))); 706 707 // All future operations should fail. 708 EXPECT_FALSE(CBB_add_u8(cbb.get(), 0)); 709 EXPECT_FALSE(CBB_finish(cbb.get(), &ptr, &len)); 710 711 // Write a u32 that cannot fit in a u24. 712 cbb.Reset(); 713 ASSERT_TRUE(CBB_init(cbb.get(), 0)); 714 ASSERT_FALSE(CBB_add_u24(cbb.get(), 1u << 24)); 715 716 // All future operations should fail. 717 EXPECT_FALSE(CBB_add_u8(cbb.get(), 0)); 718 EXPECT_FALSE(CBB_finish(cbb.get(), &ptr, &len)); 719 } 720 721 TEST(CBSTest, BitString) { 722 static const std::vector<uint8_t> kValidBitStrings[] = { 723 {0x00}, // 0 bits 724 {0x07, 0x80}, // 1 bit 725 {0x04, 0xf0}, // 4 bits 726 {0x00, 0xff}, // 8 bits 727 {0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0}, // 42 bits 728 }; 729 for (const auto& test : kValidBitStrings) { 730 SCOPED_TRACE(Bytes(test.data(), test.size())); 731 CBS cbs; 732 CBS_init(&cbs, test.data(), test.size()); 733 EXPECT_TRUE(CBS_is_valid_asn1_bitstring(&cbs)); 734 } 735 736 static const std::vector<uint8_t> kInvalidBitStrings[] = { 737 // BIT STRINGs always have a leading byte. 738 std::vector<uint8_t>{}, 739 // It's not possible to take an unused bit off the empty string. 740 {0x01}, 741 // There can be at most 7 unused bits. 742 {0x08, 0xff}, 743 {0xff, 0xff}, 744 // All unused bits must be cleared. 745 {0x06, 0xff, 0xc1}, 746 }; 747 for (const auto& test : kInvalidBitStrings) { 748 SCOPED_TRACE(Bytes(test.data(), test.size())); 749 CBS cbs; 750 CBS_init(&cbs, test.data(), test.size()); 751 EXPECT_FALSE(CBS_is_valid_asn1_bitstring(&cbs)); 752 753 // CBS_asn1_bitstring_has_bit returns false on invalid inputs. 754 EXPECT_FALSE(CBS_asn1_bitstring_has_bit(&cbs, 0)); 755 } 756 757 static const struct { 758 std::vector<uint8_t> in; 759 unsigned bit; 760 bool bit_set; 761 } kBitTests[] = { 762 // Basic tests. 763 {{0x00}, 0, false}, 764 {{0x07, 0x80}, 0, true}, 765 {{0x06, 0x0f, 0x40}, 0, false}, 766 {{0x06, 0x0f, 0x40}, 1, false}, 767 {{0x06, 0x0f, 0x40}, 2, false}, 768 {{0x06, 0x0f, 0x40}, 3, false}, 769 {{0x06, 0x0f, 0x40}, 4, true}, 770 {{0x06, 0x0f, 0x40}, 5, true}, 771 {{0x06, 0x0f, 0x40}, 6, true}, 772 {{0x06, 0x0f, 0x40}, 7, true}, 773 {{0x06, 0x0f, 0x40}, 8, false}, 774 {{0x06, 0x0f, 0x40}, 9, true}, 775 // Out-of-bounds bits return 0. 776 {{0x06, 0x0f, 0x40}, 10, false}, 777 {{0x06, 0x0f, 0x40}, 15, false}, 778 {{0x06, 0x0f, 0x40}, 16, false}, 779 {{0x06, 0x0f, 0x40}, 1000, false}, 780 }; 781 for (const auto& test : kBitTests) { 782 SCOPED_TRACE(Bytes(test.in.data(), test.in.size())); 783 SCOPED_TRACE(test.bit); 784 CBS cbs; 785 CBS_init(&cbs, test.in.data(), test.in.size()); 786 EXPECT_EQ(static_cast<int>(test.bit_set), 787 CBS_asn1_bitstring_has_bit(&cbs, test.bit)); 788 } 789 } 790
