legacy-libs/grpc-cloned/deps/grpc/third_party/boringssl/crypto/bytestring/bytestring_test.cc

   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, CBS_ASN1_BOOLEAN));
 127   EXPECT_TRUE(CBS_peek_asn1_tag(&data, CBS_ASN1_SEQUENCE));
 128
 129   ASSERT_TRUE(CBS_get_asn1(&data, &contents, CBS_ASN1_SEQUENCE));
 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, CBS_ASN1_SEQUENCE));
 135
 136   CBS_init(&data, kData3, sizeof(kData3));
 137   // zero byte length of length
 138   EXPECT_FALSE(CBS_get_asn1(&data, &contents, CBS_ASN1_SEQUENCE));
 139
 140   CBS_init(&data, kData4, sizeof(kData4));
 141   // long form mistakenly used.
 142   EXPECT_FALSE(CBS_get_asn1(&data, &contents, CBS_ASN1_SEQUENCE));
 143
 144   CBS_init(&data, kData5, sizeof(kData5));
 145   // length takes too many bytes.
 146   EXPECT_FALSE(CBS_get_asn1(&data, &contents, CBS_ASN1_SEQUENCE));
 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, CBS_ASN1_SEQUENCE));
 155
 156   CBS_init(&data, NULL, 0);
 157   // optional elements at empty data.
 158   ASSERT_TRUE(CBS_get_optional_asn1(
 159       &data, &contents, &present,
 160       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
 161   EXPECT_FALSE(present);
 162   ASSERT_TRUE(CBS_get_optional_asn1_octet_string(
 163       &data, &contents, &present,
 164       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
 165   EXPECT_FALSE(present);
 166   EXPECT_EQ(0u, CBS_len(&contents));
 167   ASSERT_TRUE(CBS_get_optional_asn1_octet_string(
 168       &data, &contents, NULL,
 169       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
 170   EXPECT_EQ(0u, CBS_len(&contents));
 171   ASSERT_TRUE(CBS_get_optional_asn1_uint64(
 172       &data, &value, CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0, 42));
 173   EXPECT_EQ(42u, value);
 174
 175   CBS_init(&data, kData6, sizeof(kData6));
 176   // optional element.
 177   ASSERT_TRUE(CBS_get_optional_asn1(
 178       &data, &contents, &present,
 179       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
 180   EXPECT_FALSE(present);
 181   ASSERT_TRUE(CBS_get_optional_asn1(
 182       &data, &contents, &present,
 183       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 1));
 184   EXPECT_TRUE(present);
 185   EXPECT_EQ(Bytes("\x04\x01\x01"),
 186             Bytes(CBS_data(&contents), CBS_len(&contents)));
 187
 188   CBS_init(&data, kData6, sizeof(kData6));
 189   // optional octet string.
 190   ASSERT_TRUE(CBS_get_optional_asn1_octet_string(
 191       &data, &contents, &present,
 192       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0));
 193   EXPECT_FALSE(present);
 194   EXPECT_EQ(0u, CBS_len(&contents));
 195   ASSERT_TRUE(CBS_get_optional_asn1_octet_string(
 196       &data, &contents, &present,
 197       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 1));
 198   EXPECT_TRUE(present);
 199   EXPECT_EQ(Bytes("\x01"), Bytes(CBS_data(&contents), CBS_len(&contents)));
 200
 201   CBS_init(&data, kData7, sizeof(kData7));
 202   // invalid optional octet string.
 203   EXPECT_FALSE(CBS_get_optional_asn1_octet_string(
 204       &data, &contents, &present,
 205       CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 1));
 206
 207   CBS_init(&data, kData8, sizeof(kData8));
 208   // optional integer.
 209   ASSERT_TRUE(CBS_get_optional_asn1_uint64(
 210       &data, &value, CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 0, 42));
 211   EXPECT_EQ(42u, value);
 212   ASSERT_TRUE(CBS_get_optional_asn1_uint64(
 213       &data, &value, CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 1, 42));
 214   EXPECT_EQ(1u, value);
 215
 216   CBS_init(&data, kData9, sizeof(kData9));
 217   // invalid optional integer.
 218   EXPECT_FALSE(CBS_get_optional_asn1_uint64(
 219       &data, &value, CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 1, 42));
 220
 221   unsigned tag;
 222   CBS_init(&data, kData1, sizeof(kData1));
 223   ASSERT_TRUE(CBS_get_any_asn1(&data, &contents, &tag));
 224   EXPECT_EQ(CBS_ASN1_SEQUENCE, tag);
 225   EXPECT_EQ(Bytes("\x01\x02"), Bytes(CBS_data(&contents), CBS_len(&contents)));
 226
 227   size_t header_len;
 228   CBS_init(&data, kData1, sizeof(kData1));
 229   ASSERT_TRUE(CBS_get_any_asn1_element(&data, &contents, &tag, &header_len));
 230   EXPECT_EQ(CBS_ASN1_SEQUENCE, tag);
 231   EXPECT_EQ(2u, header_len);
 232   EXPECT_EQ(Bytes("\x30\x02\x01\x02"),
 233             Bytes(CBS_data(&contents), CBS_len(&contents)));
 234 }
 235
 236 TEST(CBSTest, ParseASN1Tag) {
 237   const struct {
 238     bool ok;
 239     unsigned tag;
 240     std::vector<uint8_t> in;
 241   } kTests[] = {
 242       {true, CBS_ASN1_SEQUENCE, {0x30, 0}},
 243       {true, CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 4, {0xa4, 0}},
 244       {true, CBS_ASN1_APPLICATION | 30, {0x5e, 0}},
 245       {true, CBS_ASN1_APPLICATION | 31, {0x5f, 0x1f, 0}},
 246       {true, CBS_ASN1_APPLICATION | 32, {0x5f, 0x20, 0}},
 247       {true,
 248        CBS_ASN1_PRIVATE | CBS_ASN1_CONSTRUCTED | 0x1fffffff,
 249        {0xff, 0x81, 0xff, 0xff, 0xff, 0x7f, 0}},
 250       // Tag number fits in unsigned but not |CBS_ASN1_TAG_NUMBER_MASK|.
 251       {false, 0, {0xff, 0x82, 0xff, 0xff, 0xff, 0x7f, 0}},
 252       // Tag number does not fit in unsigned.
 253       {false, 0, {0xff, 0x90, 0x80, 0x80, 0x80, 0, 0}},
 254       // Tag number is not minimally-encoded
 255       {false, 0, {0x5f, 0x80, 0x1f, 0}},
 256       // Tag number should have used short form.
 257       {false, 0, {0x5f, 0x80, 0x1e, 0}},
 258   };
 259   for (const auto &t : kTests) {
 260     SCOPED_TRACE(Bytes(t.in));
 261     unsigned tag;
 262     CBS cbs, child;
 263     CBS_init(&cbs, t.in.data(), t.in.size());
 264     ASSERT_EQ(t.ok, !!CBS_get_any_asn1(&cbs, &child, &tag));
 265     if (t.ok) {
 266       EXPECT_EQ(t.tag, tag);
 267       EXPECT_EQ(0u, CBS_len(&child));
 268       EXPECT_EQ(0u, CBS_len(&cbs));
 269
 270       CBS_init(&cbs, t.in.data(), t.in.size());
 271       EXPECT_TRUE(CBS_peek_asn1_tag(&cbs, t.tag));
 272       EXPECT_FALSE(CBS_peek_asn1_tag(&cbs, t.tag + 1));
 273
 274       EXPECT_TRUE(CBS_get_asn1(&cbs, &child, t.tag));
 275       EXPECT_EQ(0u, CBS_len(&child));
 276       EXPECT_EQ(0u, CBS_len(&cbs));
 277
 278       CBS_init(&cbs, t.in.data(), t.in.size());
 279       EXPECT_FALSE(CBS_get_asn1(&cbs, &child, t.tag + 1));
 280     }
 281   }
 282 }
 283
 284 TEST(CBSTest, GetOptionalASN1Bool) {
 285   static const uint8_t kTrue[] = {0x0a, 3, CBS_ASN1_BOOLEAN, 1, 0xff};
 286   static const uint8_t kFalse[] = {0x0a, 3, CBS_ASN1_BOOLEAN, 1, 0x00};
 287   static const uint8_t kInvalid[] = {0x0a, 3, CBS_ASN1_BOOLEAN, 1, 0x01};
 288
 289   CBS data;
 290   CBS_init(&data, NULL, 0);
 291   int val = 2;
 292   ASSERT_TRUE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0));
 293   EXPECT_EQ(0, val);
 294
 295   CBS_init(&data, kTrue, sizeof(kTrue));
 296   val = 2;
 297   ASSERT_TRUE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 0));
 298   EXPECT_EQ(1, val);
 299
 300   CBS_init(&data, kFalse, sizeof(kFalse));
 301   val = 2;
 302   ASSERT_TRUE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1));
 303   EXPECT_EQ(0, val);
 304
 305   CBS_init(&data, kInvalid, sizeof(kInvalid));
 306   EXPECT_FALSE(CBS_get_optional_asn1_bool(&data, &val, 0x0a, 1));
 307 }
 308
 309 // Test that CBB_init may be used on an uninitialized input.
 310 TEST(CBBTest, InitUninitialized) {
 311   CBB cbb;
 312   ASSERT_TRUE(CBB_init(&cbb, 100));
 313   CBB_cleanup(&cbb);
 314 }
 315
 316 TEST(CBBTest, Basic) {
 317   static const uint8_t kExpected[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc};
 318   uint8_t *buf;
 319   size_t buf_len;
 320
 321   bssl::ScopedCBB cbb;
 322   ASSERT_TRUE(CBB_init(cbb.get(), 100));
 323   cbb.Reset();
 324
 325   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 326   ASSERT_TRUE(CBB_add_u8(cbb.get(), 1));
 327   ASSERT_TRUE(CBB_add_u16(cbb.get(), 0x203));
 328   ASSERT_TRUE(CBB_add_u24(cbb.get(), 0x40506));
 329   ASSERT_TRUE(CBB_add_u32(cbb.get(), 0x708090a));
 330   ASSERT_TRUE(CBB_add_bytes(cbb.get(), (const uint8_t *)"\x0b\x0c", 2));
 331   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 332
 333   bssl::UniquePtr<uint8_t> scoper(buf);
 334   EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len));
 335 }
 336
 337 TEST(CBBTest, Fixed) {
 338   bssl::ScopedCBB cbb;
 339   uint8_t buf[1];
 340   uint8_t *out_buf;
 341   size_t out_size;
 342
 343   ASSERT_TRUE(CBB_init_fixed(cbb.get(), NULL, 0));
 344   ASSERT_TRUE(CBB_finish(cbb.get(), &out_buf, &out_size));
 345   EXPECT_EQ(NULL, out_buf);
 346   EXPECT_EQ(0u, out_size);
 347
 348   cbb.Reset();
 349   ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, 1));
 350   ASSERT_TRUE(CBB_add_u8(cbb.get(), 1));
 351   ASSERT_TRUE(CBB_finish(cbb.get(), &out_buf, &out_size));
 352   EXPECT_EQ(buf, out_buf);
 353   EXPECT_EQ(1u, out_size);
 354   EXPECT_EQ(1u, buf[0]);
 355
 356   cbb.Reset();
 357   ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, 1));
 358   ASSERT_TRUE(CBB_add_u8(cbb.get(), 1));
 359   EXPECT_FALSE(CBB_add_u8(cbb.get(), 2));
 360 }
 361
 362 // Test that calling CBB_finish on a child does nothing.
 363 TEST(CBBTest, FinishChild) {
 364   CBB child;
 365   uint8_t *out_buf;
 366   size_t out_size;
 367
 368   bssl::ScopedCBB cbb;
 369   ASSERT_TRUE(CBB_init(cbb.get(), 16));
 370   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &child));
 371
 372   EXPECT_FALSE(CBB_finish(&child, &out_buf, &out_size));
 373
 374   ASSERT_TRUE(CBB_finish(cbb.get(), &out_buf, &out_size));
 375   bssl::UniquePtr<uint8_t> scoper(out_buf);
 376   ASSERT_EQ(1u, out_size);
 377   EXPECT_EQ(0u, out_buf[0]);
 378 }
 379
 380 TEST(CBBTest, Prefixed) {
 381   static const uint8_t kExpected[] = {0, 1, 1, 0, 2, 2, 3, 0, 0, 3,
 382                                       4, 5, 6, 5, 4, 1, 0, 1, 2};
 383   uint8_t *buf;
 384   size_t buf_len;
 385   bssl::ScopedCBB cbb;
 386   CBB contents, inner_contents, inner_inner_contents;
 387   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 388   EXPECT_EQ(0u, CBB_len(cbb.get()));
 389   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents));
 390   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents));
 391   ASSERT_TRUE(CBB_add_u8(&contents, 1));
 392   EXPECT_EQ(1u, CBB_len(&contents));
 393   ASSERT_TRUE(CBB_flush(cbb.get()));
 394   EXPECT_EQ(3u, CBB_len(cbb.get()));
 395   ASSERT_TRUE(CBB_add_u16_length_prefixed(cbb.get(), &contents));
 396   ASSERT_TRUE(CBB_add_u16(&contents, 0x203));
 397   ASSERT_TRUE(CBB_add_u24_length_prefixed(cbb.get(), &contents));
 398   ASSERT_TRUE(CBB_add_u24(&contents, 0x40506));
 399   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents));
 400   ASSERT_TRUE(CBB_add_u8_length_prefixed(&contents, &inner_contents));
 401   ASSERT_TRUE(CBB_add_u8(&inner_contents, 1));
 402   ASSERT_TRUE(
 403       CBB_add_u16_length_prefixed(&inner_contents, &inner_inner_contents));
 404   ASSERT_TRUE(CBB_add_u8(&inner_inner_contents, 2));
 405   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 406
 407   bssl::UniquePtr<uint8_t> scoper(buf);
 408   EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len));
 409 }
 410
 411 TEST(CBBTest, DiscardChild) {
 412   bssl::ScopedCBB cbb;
 413   CBB contents, inner_contents, inner_inner_contents;
 414
 415   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 416   ASSERT_TRUE(CBB_add_u8(cbb.get(), 0xaa));
 417
 418   // Discarding |cbb|'s children preserves the byte written.
 419   CBB_discard_child(cbb.get());
 420
 421   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents));
 422   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents));
 423   ASSERT_TRUE(CBB_add_u8(&contents, 0xbb));
 424   ASSERT_TRUE(CBB_add_u16_length_prefixed(cbb.get(), &contents));
 425   ASSERT_TRUE(CBB_add_u16(&contents, 0xcccc));
 426   ASSERT_TRUE(CBB_add_u24_length_prefixed(cbb.get(), &contents));
 427   ASSERT_TRUE(CBB_add_u24(&contents, 0xdddddd));
 428   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &contents));
 429   ASSERT_TRUE(CBB_add_u8(&contents, 0xff));
 430   ASSERT_TRUE(CBB_add_u8_length_prefixed(&contents, &inner_contents));
 431   ASSERT_TRUE(CBB_add_u8(&inner_contents, 0x42));
 432   ASSERT_TRUE(
 433       CBB_add_u16_length_prefixed(&inner_contents, &inner_inner_contents));
 434   ASSERT_TRUE(CBB_add_u8(&inner_inner_contents, 0x99));
 435
 436   // Discard everything from |inner_contents| down.
 437   CBB_discard_child(&contents);
 438
 439   uint8_t *buf;
 440   size_t buf_len;
 441   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 442   bssl::UniquePtr<uint8_t> scoper(buf);
 443
 444   static const uint8_t kExpected[] = {
 445         0xaa,
 446         0,
 447         1, 0xbb,
 448         0, 2, 0xcc, 0xcc,
 449         0, 0, 3, 0xdd, 0xdd, 0xdd,
 450         1, 0xff,
 451   };
 452   EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len));
 453 }
 454
 455 TEST(CBBTest, Misuse) {
 456   bssl::ScopedCBB cbb;
 457   CBB child, contents;
 458   uint8_t *buf;
 459   size_t buf_len;
 460
 461   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 462   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &child));
 463   ASSERT_TRUE(CBB_add_u8(&child, 1));
 464   ASSERT_TRUE(CBB_add_u8(cbb.get(), 2));
 465
 466   // Since we wrote to |cbb|, |child| is now invalid and attempts to write to
 467   // it should fail.
 468   EXPECT_FALSE(CBB_add_u8(&child, 1));
 469   EXPECT_FALSE(CBB_add_u16(&child, 1));
 470   EXPECT_FALSE(CBB_add_u24(&child, 1));
 471   EXPECT_FALSE(CBB_add_u8_length_prefixed(&child, &contents));
 472   EXPECT_FALSE(CBB_add_u16_length_prefixed(&child, &contents));
 473   EXPECT_FALSE(CBB_add_asn1(&child, &contents, 1));
 474   EXPECT_FALSE(CBB_add_bytes(&child, (const uint8_t*) "a", 1));
 475
 476   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 477   bssl::UniquePtr<uint8_t> scoper(buf);
 478
 479   EXPECT_EQ(Bytes("\x01\x01\x02"), Bytes(buf, buf_len));
 480 }
 481
 482 TEST(CBBTest, ASN1) {
 483   static const uint8_t kExpected[] = {
 484       // SEQUENCE { 1 2 3 }
 485       0x30, 3, 1, 2, 3,
 486       // [4 CONSTRUCTED] { 4 5 6 }
 487       0xa4, 3, 4, 5, 6,
 488       // [APPLICATION 30 PRIMITIVE] { 7 8 9 }
 489       0x5e, 3, 7, 8, 9,
 490       // [APPLICATION 31 PRIMITIVE] { 10 11 12 }
 491       0x5f, 0x1f, 3, 10, 11, 12,
 492       // [PRIVATE 2^29-1 CONSTRUCTED] { 13 14 15 }
 493       0xff, 0x81, 0xff, 0xff, 0xff, 0x7f, 3, 13, 14, 15,
 494   };
 495   uint8_t *buf;
 496   size_t buf_len;
 497   bssl::ScopedCBB cbb;
 498   CBB contents, inner_contents;
 499
 500   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 501   ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, CBS_ASN1_SEQUENCE));
 502   ASSERT_TRUE(CBB_add_bytes(&contents, (const uint8_t *)"\x01\x02\x03", 3));
 503   ASSERT_TRUE(
 504       CBB_add_asn1(cbb.get(), &contents,
 505                    CBS_ASN1_CONTEXT_SPECIFIC | CBS_ASN1_CONSTRUCTED | 4));
 506   ASSERT_TRUE(CBB_add_bytes(&contents, (const uint8_t *)"\x04\x05\x06", 3));
 507   ASSERT_TRUE(
 508       CBB_add_asn1(cbb.get(), &contents,
 509                    CBS_ASN1_APPLICATION | 30));
 510   ASSERT_TRUE(CBB_add_bytes(&contents, (const uint8_t *)"\x07\x08\x09", 3));
 511   ASSERT_TRUE(
 512       CBB_add_asn1(cbb.get(), &contents,
 513                    CBS_ASN1_APPLICATION | 31));
 514   ASSERT_TRUE(CBB_add_bytes(&contents, (const uint8_t *)"\x0a\x0b\x0c", 3));
 515   ASSERT_TRUE(
 516       CBB_add_asn1(cbb.get(), &contents,
 517                    CBS_ASN1_PRIVATE | CBS_ASN1_CONSTRUCTED | 0x1fffffff));
 518   ASSERT_TRUE(CBB_add_bytes(&contents, (const uint8_t *)"\x0d\x0e\x0f", 3));
 519   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 520   bssl::UniquePtr<uint8_t> scoper(buf);
 521
 522   EXPECT_EQ(Bytes(kExpected), Bytes(buf, buf_len));
 523
 524   std::vector<uint8_t> test_data(100000, 0x42);
 525   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 526   ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, CBS_ASN1_SEQUENCE));
 527   ASSERT_TRUE(CBB_add_bytes(&contents, test_data.data(), 130));
 528   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 529   scoper.reset(buf);
 530
 531   ASSERT_EQ(3u + 130u, buf_len);
 532   EXPECT_EQ(Bytes("\x30\x81\x82"), Bytes(buf, 3));
 533   EXPECT_EQ(Bytes(test_data.data(), 130), Bytes(buf + 3, 130));
 534
 535   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 536   ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, CBS_ASN1_SEQUENCE));
 537   ASSERT_TRUE(CBB_add_bytes(&contents, test_data.data(), 1000));
 538   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 539   scoper.reset(buf);
 540
 541   ASSERT_EQ(4u + 1000u, buf_len);
 542   EXPECT_EQ(Bytes("\x30\x82\x03\xe8"), Bytes(buf, 4));
 543   EXPECT_EQ(Bytes(test_data.data(), 1000), Bytes(buf + 4, 1000));
 544
 545   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 546   ASSERT_TRUE(CBB_add_asn1(cbb.get(), &contents, CBS_ASN1_SEQUENCE));
 547   ASSERT_TRUE(CBB_add_asn1(&contents, &inner_contents, CBS_ASN1_SEQUENCE));
 548   ASSERT_TRUE(CBB_add_bytes(&inner_contents, test_data.data(), 100000));
 549   ASSERT_TRUE(CBB_finish(cbb.get(), &buf, &buf_len));
 550   scoper.reset(buf);
 551
 552   ASSERT_EQ(5u + 5u + 100000u, buf_len);
 553   EXPECT_EQ(Bytes("\x30\x83\x01\x86\xa5\x30\x83\x01\x86\xa0"), Bytes(buf, 10));
 554   EXPECT_EQ(Bytes(test_data.data(), test_data.size()), Bytes(buf + 10, 100000));
 555 }
 556
 557 static void ExpectBerConvert(const char *name, const uint8_t *der_expected,
 558                              size_t der_len, const uint8_t *ber,
 559                              size_t ber_len) {
 560   SCOPED_TRACE(name);
 561   CBS in;
 562   uint8_t *out;
 563   size_t out_len;
 564
 565   CBS_init(&in, ber, ber_len);
 566   ASSERT_TRUE(CBS_asn1_ber_to_der(&in, &out, &out_len));
 567   bssl::UniquePtr<uint8_t> scoper(out);
 568
 569   if (out == NULL) {
 570     EXPECT_EQ(Bytes(der_expected, der_len), Bytes(ber, ber_len));
 571   } else {
 572     EXPECT_NE(Bytes(der_expected, der_len), Bytes(ber, ber_len));
 573     EXPECT_EQ(Bytes(der_expected, der_len), Bytes(out, out_len));
 574   }
 575 }
 576
 577 TEST(CBSTest, BerConvert) {
 578   static const uint8_t kSimpleBER[] = {0x01, 0x01, 0x00};
 579
 580   // kIndefBER contains a SEQUENCE with an indefinite length.
 581   static const uint8_t kIndefBER[] = {0x30, 0x80, 0x01, 0x01, 0x02, 0x00, 0x00};
 582   static const uint8_t kIndefDER[] = {0x30, 0x03, 0x01, 0x01, 0x02};
 583
 584   // kIndefBER2 contains a constructed [APPLICATION 31] with an indefinite
 585   // length.
 586   static const uint8_t kIndefBER2[] = {0x7f, 0x1f, 0x80, 0x01,
 587                                        0x01, 0x02, 0x00, 0x00};
 588   static const uint8_t kIndefDER2[] = {0x7f, 0x1f, 0x03, 0x01, 0x01, 0x02};
 589
 590   // kOctetStringBER contains an indefinite length OCTET STRING with two parts.
 591   // These parts need to be concatenated in DER form.
 592   static const uint8_t kOctetStringBER[] = {0x24, 0x80, 0x04, 0x02, 0,    1,
 593                                             0x04, 0x02, 2,    3,    0x00, 0x00};
 594   static const uint8_t kOctetStringDER[] = {0x04, 0x04, 0, 1, 2, 3};
 595
 596   // kNSSBER is part of a PKCS#12 message generated by NSS that uses indefinite
 597   // length elements extensively.
 598   static const uint8_t kNSSBER[] = {
 599       0x30, 0x80, 0x02, 0x01, 0x03, 0x30, 0x80, 0x06, 0x09, 0x2a, 0x86, 0x48,
 600       0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0xa0, 0x80, 0x24, 0x80, 0x04, 0x04,
 601       0x01, 0x02, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x39,
 602       0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05,
 603       0x00, 0x04, 0x14, 0x84, 0x98, 0xfc, 0x66, 0x33, 0xee, 0xba, 0xe7, 0x90,
 604       0xc1, 0xb6, 0xe8, 0x8f, 0xfe, 0x1d, 0xc5, 0xa5, 0x97, 0x93, 0x3e, 0x04,
 605       0x10, 0x38, 0x62, 0xc6, 0x44, 0x12, 0xd5, 0x30, 0x00, 0xf8, 0xf2, 0x1b,
 606       0xf0, 0x6e, 0x10, 0x9b, 0xb8, 0x02, 0x02, 0x07, 0xd0, 0x00, 0x00,
 607   };
 608
 609   static const uint8_t kNSSDER[] = {
 610       0x30, 0x53, 0x02, 0x01, 0x03, 0x30, 0x13, 0x06, 0x09, 0x2a, 0x86,
 611       0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x01, 0xa0, 0x06, 0x04, 0x04,
 612       0x01, 0x02, 0x03, 0x04, 0x30, 0x39, 0x30, 0x21, 0x30, 0x09, 0x06,
 613       0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14, 0x84,
 614       0x98, 0xfc, 0x66, 0x33, 0xee, 0xba, 0xe7, 0x90, 0xc1, 0xb6, 0xe8,
 615       0x8f, 0xfe, 0x1d, 0xc5, 0xa5, 0x97, 0x93, 0x3e, 0x04, 0x10, 0x38,
 616       0x62, 0xc6, 0x44, 0x12, 0xd5, 0x30, 0x00, 0xf8, 0xf2, 0x1b, 0xf0,
 617       0x6e, 0x10, 0x9b, 0xb8, 0x02, 0x02, 0x07, 0xd0,
 618   };
 619
 620   // kConstructedStringBER contains a deeply-nested constructed OCTET STRING.
 621   // The BER conversion collapses this to one level deep, but not completely.
 622   static const uint8_t kConstructedStringBER[] = {
 623       0xa0, 0x10, 0x24, 0x06, 0x04, 0x01, 0x00, 0x04, 0x01,
 624       0x01, 0x24, 0x06, 0x04, 0x01, 0x02, 0x04, 0x01, 0x03,
 625   };
 626   static const uint8_t kConstructedStringDER[] = {
 627       0xa0, 0x08, 0x04, 0x02, 0x00, 0x01, 0x04, 0x02, 0x02, 0x03,
 628   };
 629
 630   ExpectBerConvert("kSimpleBER", kSimpleBER, sizeof(kSimpleBER), kSimpleBER,
 631                    sizeof(kSimpleBER));
 632   ExpectBerConvert("kIndefBER", kIndefDER, sizeof(kIndefDER), kIndefBER,
 633                    sizeof(kIndefBER));
 634   ExpectBerConvert("kIndefBER2", kIndefDER2, sizeof(kIndefDER2), kIndefBER2,
 635                    sizeof(kIndefBER2));
 636   ExpectBerConvert("kOctetStringBER", kOctetStringDER, sizeof(kOctetStringDER),
 637                    kOctetStringBER, sizeof(kOctetStringBER));
 638   ExpectBerConvert("kNSSBER", kNSSDER, sizeof(kNSSDER), kNSSBER,
 639                    sizeof(kNSSBER));
 640   ExpectBerConvert("kConstructedStringBER", kConstructedStringDER,
 641                    sizeof(kConstructedStringDER), kConstructedStringBER,
 642                    sizeof(kConstructedStringBER));
 643 }
 644
 645 struct ImplicitStringTest {
 646   const char *in;
 647   size_t in_len;
 648   bool ok;
 649   const char *out;
 650   size_t out_len;
 651 };
 652
 653 static const ImplicitStringTest kImplicitStringTests[] = {
 654     // A properly-encoded string.
 655     {"\x80\x03\x61\x61\x61", 5, true, "aaa", 3},
 656     // An implicit-tagged string.
 657     {"\xa0\x09\x04\x01\x61\x04\x01\x61\x04\x01\x61", 11, true, "aaa", 3},
 658     // |CBS_get_asn1_implicit_string| only accepts one level deep of nesting.
 659     {"\xa0\x0b\x24\x06\x04\x01\x61\x04\x01\x61\x04\x01\x61", 13, false, nullptr,
 660      0},
 661     // The outer tag must match.
 662     {"\x81\x03\x61\x61\x61", 5, false, nullptr, 0},
 663     {"\xa1\x09\x04\x01\x61\x04\x01\x61\x04\x01\x61", 11, false, nullptr, 0},
 664     // The inner tag must match.
 665     {"\xa1\x09\x0c\x01\x61\x0c\x01\x61\x0c\x01\x61", 11, false, nullptr, 0},
 666 };
 667
 668 TEST(CBSTest, ImplicitString) {
 669   for (const auto &test : kImplicitStringTests) {
 670     SCOPED_TRACE(Bytes(test.in, test.in_len));
 671     uint8_t *storage = nullptr;
 672     CBS in, out;
 673     CBS_init(&in, reinterpret_cast<const uint8_t *>(test.in), test.in_len);
 674     int ok = CBS_get_asn1_implicit_string(&in, &out, &storage,
 675                                           CBS_ASN1_CONTEXT_SPECIFIC | 0,
 676                                           CBS_ASN1_OCTETSTRING);
 677     bssl::UniquePtr<uint8_t> scoper(storage);
 678     EXPECT_EQ(test.ok, static_cast<bool>(ok));
 679
 680     if (ok) {
 681       EXPECT_EQ(Bytes(test.out, test.out_len),
 682                 Bytes(CBS_data(&out), CBS_len(&out)));
 683     }
 684   }
 685 }
 686
 687 struct ASN1Uint64Test {
 688   uint64_t value;
 689   const char *encoding;
 690   size_t encoding_len;
 691 };
 692
 693 static const ASN1Uint64Test kASN1Uint64Tests[] = {
 694     {0, "\x02\x01\x00", 3},
 695     {1, "\x02\x01\x01", 3},
 696     {127, "\x02\x01\x7f", 3},
 697     {128, "\x02\x02\x00\x80", 4},
 698     {0xdeadbeef, "\x02\x05\x00\xde\xad\xbe\xef", 7},
 699     {UINT64_C(0x0102030405060708),
 700      "\x02\x08\x01\x02\x03\x04\x05\x06\x07\x08", 10},
 701     {UINT64_C(0xffffffffffffffff),
 702       "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff", 11},
 703 };
 704
 705 struct ASN1InvalidUint64Test {
 706   const char *encoding;
 707   size_t encoding_len;
 708 };
 709
 710 static const ASN1InvalidUint64Test kASN1InvalidUint64Tests[] = {
 711     // Bad tag.
 712     {"\x03\x01\x00", 3},
 713     // Empty contents.
 714     {"\x02\x00", 2},
 715     // Negative number.
 716     {"\x02\x01\x80", 3},
 717     // Overflow.
 718     {"\x02\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00", 11},
 719     // Leading zeros.
 720     {"\x02\x02\x00\x01", 4},
 721 };
 722
 723 TEST(CBSTest, ASN1Uint64) {
 724   for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kASN1Uint64Tests); i++) {
 725     SCOPED_TRACE(i);
 726     const ASN1Uint64Test *test = &kASN1Uint64Tests[i];
 727     CBS cbs;
 728     uint64_t value;
 729     uint8_t *out;
 730     size_t len;
 731
 732     CBS_init(&cbs, (const uint8_t *)test->encoding, test->encoding_len);
 733     ASSERT_TRUE(CBS_get_asn1_uint64(&cbs, &value));
 734     EXPECT_EQ(0u, CBS_len(&cbs));
 735     EXPECT_EQ(test->value, value);
 736
 737     bssl::ScopedCBB cbb;
 738     ASSERT_TRUE(CBB_init(cbb.get(), 0));
 739     ASSERT_TRUE(CBB_add_asn1_uint64(cbb.get(), test->value));
 740     ASSERT_TRUE(CBB_finish(cbb.get(), &out, &len));
 741     bssl::UniquePtr<uint8_t> scoper(out);
 742     EXPECT_EQ(Bytes(test->encoding, test->encoding_len), Bytes(out, len));
 743   }
 744
 745   for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kASN1InvalidUint64Tests); i++) {
 746     const ASN1InvalidUint64Test *test = &kASN1InvalidUint64Tests[i];
 747     CBS cbs;
 748     uint64_t value;
 749
 750     CBS_init(&cbs, (const uint8_t *)test->encoding, test->encoding_len);
 751     EXPECT_FALSE(CBS_get_asn1_uint64(&cbs, &value));
 752   }
 753 }
 754
 755 TEST(CBBTest, Zero) {
 756   CBB cbb;
 757   CBB_zero(&cbb);
 758   // Calling |CBB_cleanup| on a zero-state |CBB| must not crash.
 759   CBB_cleanup(&cbb);
 760 }
 761
 762 TEST(CBBTest, Reserve) {
 763   uint8_t buf[10];
 764   uint8_t *ptr;
 765   size_t len;
 766   bssl::ScopedCBB cbb;
 767   ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, sizeof(buf)));
 768   // Too large.
 769   EXPECT_FALSE(CBB_reserve(cbb.get(), &ptr, 11));
 770
 771   cbb.Reset();
 772   ASSERT_TRUE(CBB_init_fixed(cbb.get(), buf, sizeof(buf)));
 773   // Successfully reserve the entire space.
 774   ASSERT_TRUE(CBB_reserve(cbb.get(), &ptr, 10));
 775   EXPECT_EQ(buf, ptr);
 776   // Advancing under the maximum bytes is legal.
 777   ASSERT_TRUE(CBB_did_write(cbb.get(), 5));
 778   ASSERT_TRUE(CBB_finish(cbb.get(), NULL, &len));
 779   EXPECT_EQ(5u, len);
 780 }
 781
 782 // Test that CBB errors are sticky; once on operation on CBB fails, all
 783 // subsequent ones do.
 784 TEST(CBBTest, StickyError) {
 785   // Write an input that exceeds the limit for its length prefix.
 786   bssl::ScopedCBB cbb;
 787   CBB child;
 788   static const uint8_t kZeros[256] = {0};
 789   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 790   ASSERT_TRUE(CBB_add_u8_length_prefixed(cbb.get(), &child));
 791   ASSERT_TRUE(CBB_add_bytes(&child, kZeros, sizeof(kZeros)));
 792   ASSERT_FALSE(CBB_flush(cbb.get()));
 793
 794   // All future operations should fail.
 795   uint8_t *ptr;
 796   size_t len;
 797   EXPECT_FALSE(CBB_add_u8(cbb.get(), 0));
 798   EXPECT_FALSE(CBB_finish(cbb.get(), &ptr, &len));
 799
 800   // Write an input that cannot fit in a fixed CBB.
 801   cbb.Reset();
 802   uint8_t buf;
 803   ASSERT_TRUE(CBB_init_fixed(cbb.get(), &buf, 1));
 804   ASSERT_FALSE(CBB_add_bytes(cbb.get(), kZeros, sizeof(kZeros)));
 805
 806   // All future operations should fail.
 807   EXPECT_FALSE(CBB_add_u8(cbb.get(), 0));
 808   EXPECT_FALSE(CBB_finish(cbb.get(), &ptr, &len));
 809
 810   // Write a u32 that cannot fit in a u24.
 811   cbb.Reset();
 812   ASSERT_TRUE(CBB_init(cbb.get(), 0));
 813   ASSERT_FALSE(CBB_add_u24(cbb.get(), 1u << 24));
 814
 815   // All future operations should fail.
 816   EXPECT_FALSE(CBB_add_u8(cbb.get(), 0));
 817   EXPECT_FALSE(CBB_finish(cbb.get(), &ptr, &len));
 818 }
 819
 820 TEST(CBSTest, BitString) {
 821   static const std::vector<uint8_t> kValidBitStrings[] = {
 822       {0x00},                                      // 0 bits
 823       {0x07, 0x80},                                // 1 bit
 824       {0x04, 0xf0},                                // 4 bits
 825       {0x00, 0xff},                                // 8 bits
 826       {0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0},  // 42 bits
 827   };
 828   for (const auto& test : kValidBitStrings) {
 829     SCOPED_TRACE(Bytes(test.data(), test.size()));
 830     CBS cbs;
 831     CBS_init(&cbs, test.data(), test.size());
 832     EXPECT_TRUE(CBS_is_valid_asn1_bitstring(&cbs));
 833   }
 834
 835   static const std::vector<uint8_t> kInvalidBitStrings[] = {
 836       // BIT STRINGs always have a leading byte.
 837       std::vector<uint8_t>{},
 838       // It's not possible to take an unused bit off the empty string.
 839       {0x01},
 840       // There can be at most 7 unused bits.
 841       {0x08, 0xff},
 842       {0xff, 0xff},
 843       // All unused bits must be cleared.
 844       {0x06, 0xff, 0xc1},
 845   };
 846   for (const auto& test : kInvalidBitStrings) {
 847     SCOPED_TRACE(Bytes(test.data(), test.size()));
 848     CBS cbs;
 849     CBS_init(&cbs, test.data(), test.size());
 850     EXPECT_FALSE(CBS_is_valid_asn1_bitstring(&cbs));
 851
 852     // CBS_asn1_bitstring_has_bit returns false on invalid inputs.
 853     EXPECT_FALSE(CBS_asn1_bitstring_has_bit(&cbs, 0));
 854   }
 855
 856   static const struct {
 857     std::vector<uint8_t> in;
 858     unsigned bit;
 859     bool bit_set;
 860   } kBitTests[] = {
 861       // Basic tests.
 862       {{0x00}, 0, false},
 863       {{0x07, 0x80}, 0, true},
 864       {{0x06, 0x0f, 0x40}, 0, false},
 865       {{0x06, 0x0f, 0x40}, 1, false},
 866       {{0x06, 0x0f, 0x40}, 2, false},
 867       {{0x06, 0x0f, 0x40}, 3, false},
 868       {{0x06, 0x0f, 0x40}, 4, true},
 869       {{0x06, 0x0f, 0x40}, 5, true},
 870       {{0x06, 0x0f, 0x40}, 6, true},
 871       {{0x06, 0x0f, 0x40}, 7, true},
 872       {{0x06, 0x0f, 0x40}, 8, false},
 873       {{0x06, 0x0f, 0x40}, 9, true},
 874       // Out-of-bounds bits return 0.
 875       {{0x06, 0x0f, 0x40}, 10, false},
 876       {{0x06, 0x0f, 0x40}, 15, false},
 877       {{0x06, 0x0f, 0x40}, 16, false},
 878       {{0x06, 0x0f, 0x40}, 1000, false},
 879   };
 880   for (const auto& test : kBitTests) {
 881     SCOPED_TRACE(Bytes(test.in.data(), test.in.size()));
 882     SCOPED_TRACE(test.bit);
 883     CBS cbs;
 884     CBS_init(&cbs, test.in.data(), test.in.size());
 885     EXPECT_EQ(static_cast<int>(test.bit_set),
 886               CBS_asn1_bitstring_has_bit(&cbs, test.bit));
 887   }
 888 }
 889
 890 TEST(CBBTest, AddOIDFromText) {
 891   const struct {
 892     const char *text;
 893     std::vector<uint8_t> der;
 894   } kValidOIDs[] = {
 895       // Some valid values.
 896       {"0.0", {0x00}},
 897       {"0.2.3.4", {0x2, 0x3, 0x4}},
 898       {"1.2.3.4", {0x2a, 0x3, 0x4}},
 899       {"2.2.3.4", {0x52, 0x3, 0x4}},
 900       {"1.2.840.113554.4.1.72585",
 901        {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04, 0x01, 0x84, 0xb7, 0x09}},
 902       // Test edge cases around the first component.
 903       {"0.39", {0x27}},
 904       {"1.0", {0x28}},
 905       {"1.39", {0x4f}},
 906       {"2.0", {0x50}},
 907       {"2.1", {0x51}},
 908       {"2.40", {0x78}},
 909       // Edge cases near an overflow.
 910       {"1.2.18446744073709551615",
 911        {0x2a, 0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
 912       {"2.18446744073709551535",
 913        {0x81, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f}},
 914   };
 915
 916   const char *kInvalidTexts[] = {
 917       // Invalid second component.
 918       "0.40",
 919       "1.40",
 920       // Invalid first component.
 921       "3.1",
 922       // The empty string is not an OID.
 923       "",
 924       // No empty components.
 925       ".1.2.3.4.5",
 926       "1..2.3.4.5",
 927       "1.2.3.4.5.",
 928       // There must be at least two components.
 929       "1",
 930       // No extra leading zeros.
 931       "00.1.2.3.4",
 932       "01.1.2.3.4",
 933       // Overflow for both components or 40*A + B.
 934       "1.2.18446744073709551616",
 935       "2.18446744073709551536",
 936   };
 937
 938   const std::vector<uint8_t> kInvalidDER[] = {
 939       // The empty string is not an OID.
 940       {},
 941       // Non-minimal representation.
 942       {0x80, 0x01},
 943       // Overflow. This is the DER representation of
 944       // 1.2.840.113554.4.1.72585.18446744073709551616. (The final value is
 945       // 2^64.)
 946       {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x04, 0x01, 0x84, 0xb7, 0x09,
 947        0x82, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00},
 948   };
 949
 950   for (const auto &t : kValidOIDs) {
 951     SCOPED_TRACE(t.text);
 952
 953     bssl::ScopedCBB cbb;
 954     ASSERT_TRUE(CBB_init(cbb.get(), 0));
 955     ASSERT_TRUE(CBB_add_asn1_oid_from_text(cbb.get(), t.text, strlen(t.text)));
 956     uint8_t *out;
 957     size_t len;
 958     ASSERT_TRUE(CBB_finish(cbb.get(), &out, &len));
 959     bssl::UniquePtr<uint8_t> free_out(out);
 960     EXPECT_EQ(Bytes(t.der), Bytes(out, len));
 961
 962     CBS cbs;
 963     CBS_init(&cbs, t.der.data(), t.der.size());
 964     bssl::UniquePtr<char> text(CBS_asn1_oid_to_text(&cbs));
 965     ASSERT_TRUE(text.get());
 966     EXPECT_STREQ(t.text, text.get());
 967   }
 968
 969   for (const char *t : kInvalidTexts) {
 970     SCOPED_TRACE(t);
 971     bssl::ScopedCBB cbb;
 972     ASSERT_TRUE(CBB_init(cbb.get(), 0));
 973     EXPECT_FALSE(CBB_add_asn1_oid_from_text(cbb.get(), t, strlen(t)));
 974   }
 975
 976   for (const auto &t : kInvalidDER) {
 977     SCOPED_TRACE(Bytes(t));
 978     CBS cbs;
 979     CBS_init(&cbs, t.data(), t.size());
 980     bssl::UniquePtr<char> text(CBS_asn1_oid_to_text(&cbs));
 981     EXPECT_FALSE(text);
 982   }
 983 }
 984
 985 TEST(CBBTest, FlushASN1SetOf) {
 986   const struct {
 987     std::vector<uint8_t> in, out;
 988   } kValidInputs[] = {
 989     // No elements.
 990     {{}, {}},
 991     // One element.
 992     {{0x30, 0x00}, {0x30, 0x00}},
 993     // Two identical elements.
 994     {{0x30, 0x00, 0x30, 0x00}, {0x30, 0x00, 0x30, 0x00}},
 995     // clang-format off
 996     {{0x30, 0x02, 0x00, 0x00,
 997       0x30, 0x00,
 998       0x01, 0x00,
 999       0x30, 0x02, 0x00, 0x00,
1000       0x30, 0x03, 0x00, 0x00, 0x00,
1001       0x30, 0x00,
1002       0x30, 0x03, 0x00, 0x00, 0x01,
1003       0x30, 0x01, 0x00,
1004       0x01, 0x01, 0x00},
1005      {0x01, 0x00,
1006       0x01, 0x01, 0x00,
1007       0x30, 0x00,
1008       0x30, 0x00,
1009       0x30, 0x01, 0x00,
1010       0x30, 0x02, 0x00, 0x00,
1011       0x30, 0x02, 0x00, 0x00,
1012       0x30, 0x03, 0x00, 0x00, 0x00,
1013       0x30, 0x03, 0x00, 0x00, 0x01}},
1014     // clang-format on
1015   };
1016
1017   for (const auto &t : kValidInputs) {
1018     SCOPED_TRACE(Bytes(t.in));
1019
1020     bssl::ScopedCBB cbb;
1021     CBB child;
1022     ASSERT_TRUE(CBB_init(cbb.get(), 0));
1023     ASSERT_TRUE(CBB_add_asn1(cbb.get(), &child, CBS_ASN1_SET));
1024     ASSERT_TRUE(CBB_add_bytes(&child, t.in.data(), t.in.size()));
1025     ASSERT_TRUE(CBB_flush_asn1_set_of(&child));
1026     EXPECT_EQ(Bytes(t.out), Bytes(CBB_data(&child), CBB_len(&child)));
1027
1028     // Running it again should be idempotent.
1029     ASSERT_TRUE(CBB_flush_asn1_set_of(&child));
1030     EXPECT_EQ(Bytes(t.out), Bytes(CBB_data(&child), CBB_len(&child)));
1031
1032     // The ASN.1 header remain intact.
1033     ASSERT_TRUE(CBB_flush(cbb.get()));
1034     EXPECT_EQ(0x31, CBB_data(cbb.get())[0]);
1035   }
1036
1037   const std::vector<uint8_t> kInvalidInputs[] = {
1038     {0x30},
1039     {0x30, 0x01},
1040     {0x30, 0x00, 0x30, 0x00, 0x30, 0x01},
1041   };
1042
1043   for (const auto &t : kInvalidInputs) {
1044     SCOPED_TRACE(Bytes(t));
1045
1046     bssl::ScopedCBB cbb;
1047     CBB child;
1048     ASSERT_TRUE(CBB_init(cbb.get(), 0));
1049     ASSERT_TRUE(CBB_add_asn1(cbb.get(), &child, CBS_ASN1_SET));
1050     ASSERT_TRUE(CBB_add_bytes(&child, t.data(), t.size()));
1051     EXPECT_FALSE(CBB_flush_asn1_set_of(&child));
1052   }
1053 }