The Tor Browser: security/pkix/test/gtest/pkixder_input

security/pkix/test/gtest/pkixder_input_tests.cpp@97036ab72558 (annotated)

security/pkix/test/gtest/pkixder_input_tests.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* Copyright 2013 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include <functional>
 #include <vector>
 #include <gtest/gtest.h>
 #include "pkix/bind.h"
 #include "pkixder.h"
 using namespace mozilla::pkix::der;
 namespace {
 class pkixder_input_tests : public ::testing::Test
 {
 protected:
   virtual void SetUp()
   {
     PR_SetError(0, 0);
   }
 };
 const uint8_t DER_SEQUENCE_OF_INT8[] = {
 x30,                       // SEQUENCE
 x09,                       // length
 x02, 0x01, 0x01,           // INTEGER length 1 value 0x01
 x02, 0x01, 0x02,           // INTEGER length 1 value 0x02
 x02, 0x01, 0x03            // INTEGER length 1 value 0x03
 };
 const uint8_t DER_TRUNCATED_SEQUENCE_OF_INT8[] = {
 x30,                       // SEQUENCE
 x09,                       // length
 x02, 0x01, 0x01,           // INTEGER length 1 value 0x01
 x02, 0x01, 0x02            // INTEGER length 1 value 0x02
   // MISSING DATA HERE ON PURPOSE
 };
 const uint8_t DER_OVERRUN_SEQUENCE_OF_INT8[] = {
 x30,                       // SEQUENCE
 x09,                       // length
 x02, 0x01, 0x01,           // INTEGER length 1 value 0x01
 x02, 0x01, 0x02,           // INTEGER length 1 value 0x02
 x02, 0x02, 0xFF, 0x03      // INTEGER length 2 value 0xFF03
 };
 const uint8_t DER_INT16[] = {
 x02,                       // INTEGER
 x02,                       // length
 x12, 0x34                  // 0x1234
 };
 TEST_F(pkixder_input_tests, FailWithError)
 {
   ASSERT_EQ(Failure, Fail(SEC_ERROR_BAD_DER));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
   ASSERT_EQ(Failure, Fail(SEC_ERROR_INVALID_ARGS));
   ASSERT_EQ(SEC_ERROR_INVALID_ARGS, PR_GetError());
 }
 TEST_F(pkixder_input_tests, InputInit)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
 }
 TEST_F(pkixder_input_tests, InputInitWithNullPointerOrZeroLength)
 {
   Input input;
   ASSERT_EQ(Failure, input.Init(nullptr, 0));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
   ASSERT_EQ(Failure, input.Init(nullptr, 100));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
   // Is this a bug?
   ASSERT_EQ(Success, input.Init((const uint8_t*) "hello", 0));
 }
 TEST_F(pkixder_input_tests, InputInitWithLargeData)
 {
   Input input;
   // Data argument length does not matter, it is not touched, just
   // needs to be non-null
   ASSERT_EQ(Failure, input.Init((const uint8_t*) "", 0xffff+1));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
   ASSERT_EQ(Success, input.Init((const uint8_t*) "", 0xffff));
 }
 TEST_F(pkixder_input_tests, InputInitMultipleTimes)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   ASSERT_EQ(Failure,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   ASSERT_EQ(SEC_ERROR_INVALID_ARGS, PR_GetError());
 }
 TEST_F(pkixder_input_tests, ExpectSuccess)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   ASSERT_EQ(Success,
             input.Expect(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   ASSERT_TRUE(input.AtEnd());
 }
 TEST_F(pkixder_input_tests, ExpectMismatch)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   const uint8_t expected[] = { 0x11, 0x22 };
   ASSERT_EQ(Failure, input.Expect(expected, sizeof expected));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, ExpectTooMuch)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   const uint8_t expected[] = { 0x11, 0x22, 0x33 };
   ASSERT_EQ(Failure, input.Expect(expected, sizeof expected));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, PeekWithinBounds)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x11 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   ASSERT_TRUE(input.Peek(0x11));
   ASSERT_FALSE(input.Peek(0x22));
 }
 TEST_F(pkixder_input_tests, PeekPastBounds)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22 };
   ASSERT_EQ(Success, input.Init(der, 1));
   uint8_t readByte;
   ASSERT_EQ(Success, input.Read(readByte));
   ASSERT_EQ(0x11, readByte);
   ASSERT_FALSE(input.Peek(0x22));
 }
 TEST_F(pkixder_input_tests, ReadByte)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   uint8_t readByte1;
   ASSERT_EQ(Success, input.Read(readByte1));
   ASSERT_EQ(0x11, readByte1);
   uint8_t readByte2;
   ASSERT_EQ(Success, input.Read(readByte2));
   ASSERT_EQ(0x22, readByte2);
 }
 TEST_F(pkixder_input_tests, ReadBytePastEnd)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22 };
   // Initialize with too-short length
   ASSERT_EQ(Success, input.Init(der, 1));
   uint8_t readByte1 = 0;
   ASSERT_EQ(Success, input.Read(readByte1));
   ASSERT_EQ(0x11, readByte1);
   uint8_t readByte2 = 0;
   ASSERT_EQ(Failure, input.Read(readByte2));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
   ASSERT_NE(0x22, readByte2);
 }
 TEST_F(pkixder_input_tests, ReadByteWrapAroundPointer)
 {
   // The original implementation of our buffer read overflow checks was
   // susceptible to integer overflows which could make the checks ineffective.
   // This attempts to verify that we've fixed that. Unfortunately, decrementing
   // a null pointer is undefined behavior according to the C++ language spec.,
   // but this should catch the problem on at least some compilers, if not all of
   // them.
   const uint8_t* der = nullptr;
   --der;
   Input input;
   ASSERT_EQ(Success, input.Init(der, 0));
   uint8_t b;
   ASSERT_EQ(Failure, input.Read(b));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, ReadWord)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   uint16_t readWord1 = 0;
   ASSERT_EQ(Success, input.Read(readWord1));
   ASSERT_EQ(0x1122, readWord1);
   uint16_t readWord2 = 0;
   ASSERT_EQ(Success, input.Read(readWord2));
   ASSERT_EQ(0x3344, readWord2);
 }
 TEST_F(pkixder_input_tests, ReadWordPastEnd)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   // Initialize with too-short length
   ASSERT_EQ(Success, input.Init(der, 2));
   uint16_t readWord1 = 0;
   ASSERT_EQ(Success, input.Read(readWord1));
   ASSERT_EQ(0x1122, readWord1);
   uint16_t readWord2 = 0;
   ASSERT_EQ(Failure, input.Read(readWord2));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
   ASSERT_NE(0x3344, readWord2);
 }
 TEST_F(pkixder_input_tests, ReadWordWithInsufficentData)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22 };
   ASSERT_EQ(Success, input.Init(der, 1));
   uint16_t readWord1 = 0;
   ASSERT_EQ(Failure, input.Read(readWord1));
   ASSERT_NE(0x1122, readWord1);
 }
 TEST_F(pkixder_input_tests, ReadWordWrapAroundPointer)
 {
   // The original implementation of our buffer read overflow checks was
   // susceptible to integer overflows which could make the checks ineffective.
   // This attempts to verify that we've fixed that. Unfortunately, decrementing
   // a null pointer is undefined behavior according to the C++ language spec.,
   // but this should catch the problem on at least some compilers, if not all of
   // them.
   const uint8_t* der = nullptr;
   --der;
   Input input;
   ASSERT_EQ(Success, input.Init(der, 0));
   uint16_t b;
   ASSERT_EQ(Failure, input.Read(b));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, InputSkip)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   ASSERT_EQ(Success, input.Skip(1));
   uint8_t readByte1 = 0;
   ASSERT_EQ(Success, input.Read(readByte1));
   ASSERT_EQ(0x22, readByte1);
   ASSERT_EQ(Success, input.Skip(1));
   uint8_t readByte2 = 0;
   ASSERT_EQ(Success, input.Read(readByte2));
   ASSERT_EQ(0x44, readByte2);
 }
 TEST_F(pkixder_input_tests, InputSkipToEnd)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   ASSERT_EQ(Success, input.Skip(sizeof der));
   ASSERT_TRUE(input.AtEnd());
 }
 TEST_F(pkixder_input_tests, InputSkipPastEnd)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   ASSERT_EQ(Failure, input.Skip(sizeof der + 1));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, InputSkipToNewInput)
 {
   Input input;
   const uint8_t der[] = { 0x01, 0x02, 0x03, 0x04 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   Input skippedInput;
   ASSERT_EQ(Success, input.Skip(3, skippedInput));
   uint8_t readByte1 = 0;
   ASSERT_EQ(Success, input.Read(readByte1));
   ASSERT_EQ(0x04, readByte1);
   ASSERT_TRUE(input.AtEnd());
   // Input has no Remaining() or Length() so we simply read the bytes
   // and then expect to be at the end.
   for (uint8_t i = 1; i <= 3; ++i) {
     uint8_t readByte = 0;
     ASSERT_EQ(Success, skippedInput.Read(readByte));
     ASSERT_EQ(i, readByte);
   }
   ASSERT_TRUE(skippedInput.AtEnd());
 }
 TEST_F(pkixder_input_tests, InputSkipToNewInputPastEnd)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   Input skippedInput;
   ASSERT_EQ(Failure, input.Skip(sizeof der * 2, skippedInput));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, InputSkipToSECItem)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   const uint8_t expectedItemData[] = { 0x11, 0x22, 0x33 };
   SECItem item;
   ASSERT_EQ(Success, input.Skip(sizeof expectedItemData, item));
   ASSERT_EQ(siBuffer, item.type);
   ASSERT_EQ(sizeof expectedItemData, item.len);
   ASSERT_EQ(der, item.data);
   ASSERT_EQ(0, memcmp(item.data, expectedItemData, sizeof expectedItemData));
 }
 TEST_F(pkixder_input_tests, SkipWrapAroundPointer)
 {
   // The original implementation of our buffer read overflow checks was
   // susceptible to integer overflows which could make the checks ineffective.
   // This attempts to verify that we've fixed that. Unfortunately, decrementing
   // a null pointer is undefined behavior according to the C++ language spec.,
   // but this should catch the problem on at least some compilers, if not all of
   // them.
   const uint8_t* der = nullptr;
   --der;
   Input input;
   ASSERT_EQ(Success, input.Init(der, 0));
   ASSERT_EQ(Failure, input.Skip(1));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, SkipToSECItemPastEnd)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   SECItem skippedSECItem;
   ASSERT_EQ(Failure, input.Skip(sizeof der + 1, skippedSECItem));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, Skip)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   ASSERT_EQ(Success, Skip(input, SEQUENCE));
   ASSERT_EQ(Success, End(input));
 }
 TEST_F(pkixder_input_tests, SkipWithTruncatedData)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_TRUNCATED_SEQUENCE_OF_INT8,
                                 sizeof DER_TRUNCATED_SEQUENCE_OF_INT8));
   ASSERT_EQ(Failure, Skip(input, SEQUENCE));
 }
 TEST_F(pkixder_input_tests, SkipWithOverrunData)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_OVERRUN_SEQUENCE_OF_INT8,
                                 sizeof DER_OVERRUN_SEQUENCE_OF_INT8));
   ASSERT_EQ(Success, Skip(input, SEQUENCE));
   ASSERT_EQ(Failure, End(input));
 }
 TEST_F(pkixder_input_tests, AtEndOnUnInitializedInput)
 {
   Input input;
   ASSERT_TRUE(input.AtEnd());
 }
 TEST_F(pkixder_input_tests, AtEndAtBeginning)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   ASSERT_FALSE(input.AtEnd());
 }
 TEST_F(pkixder_input_tests, AtEndAtEnd)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   ASSERT_EQ(Success, input.Skip(sizeof der));
   ASSERT_TRUE(input.AtEnd());
 }
 TEST_F(pkixder_input_tests, MarkAndGetSECItem)
 {
   Input input;
   const uint8_t der[] = { 0x11, 0x22, 0x33, 0x44 };
   ASSERT_EQ(Success, input.Init(der, sizeof der));
   Input::Mark mark = input.GetMark();
   const uint8_t expectedItemData[] = { 0x11, 0x22, 0x33 };
   ASSERT_EQ(Success, input.Skip(sizeof expectedItemData));
   SECItem item;
   memset(&item, 0x00, sizeof item);
   ASSERT_TRUE(input.GetSECItem(siBuffer, mark, item));
   ASSERT_EQ(siBuffer, item.type);
   ASSERT_EQ(sizeof expectedItemData, item.len);
   ASSERT_TRUE(item.data);
   ASSERT_EQ(0, memcmp(item.data, expectedItemData, sizeof expectedItemData));
 }
 TEST_F(pkixder_input_tests, ExpectTagAndLength)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   ASSERT_EQ(Success, ExpectTagAndLength(input, SEQUENCE,
                                         sizeof DER_SEQUENCE_OF_INT8 - 2));
 }
 TEST_F(pkixder_input_tests, ExpectTagAndLengthWithWrongLength)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_INT16, sizeof DER_INT16));
   // Wrong length
   ASSERT_EQ(Failure, ExpectTagAndLength(input, INTEGER, 4));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, ExpectTagAndLengthWithWrongTag)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_INT16, sizeof DER_INT16));
   // Wrong type
   ASSERT_EQ(Failure, ExpectTagAndLength(input, OCTET_STRING, 2));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, ExpectTagAndGetLength)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   uint16_t length = 0;
   ASSERT_EQ(Success, ExpectTagAndGetLength(input, SEQUENCE, length));
   ASSERT_EQ(sizeof DER_SEQUENCE_OF_INT8 - 2, length);
   ASSERT_EQ(Success, input.Skip(length));
   ASSERT_TRUE(input.AtEnd());
 }
 TEST_F(pkixder_input_tests, ExpectTagAndGetLengthWithWrongTag)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   uint16_t length = 0;
   ASSERT_EQ(Failure, ExpectTagAndGetLength(input, INTEGER, length));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, ExpectTagAndGetLengthWithWrongLength)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_TRUNCATED_SEQUENCE_OF_INT8,
                                 sizeof DER_TRUNCATED_SEQUENCE_OF_INT8));
   uint16_t length = 0;
   ASSERT_EQ(Failure, ExpectTagAndGetLength(input, SEQUENCE, length));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, ExpectTagAndIgnoreLength)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_INT16, sizeof DER_INT16));
   ASSERT_EQ(Success, ExpectTagAndIgnoreLength(input, INTEGER));
 }
 TEST_F(pkixder_input_tests, ExpectTagAndIgnoreLengthWithWrongTag)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_INT16, sizeof DER_INT16));
   ASSERT_EQ(Failure, ExpectTagAndIgnoreLength(input, OCTET_STRING));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, EndAtEnd)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_INT16, sizeof DER_INT16));
   ASSERT_EQ(Success, input.Skip(4));
   ASSERT_EQ(Success, End(input));
 }
 TEST_F(pkixder_input_tests, EndBeforeEnd)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_INT16, sizeof DER_INT16));
   ASSERT_EQ(Success, input.Skip(2));
   ASSERT_EQ(Failure, End(input));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 TEST_F(pkixder_input_tests, EndAtBeginning)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_INT16, sizeof DER_INT16));
   ASSERT_EQ(Failure, End(input));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
 }
 // TODO: Need tests for Nested too?
 Result NestedOfHelper(Input& input, std::vector<uint8_t>& readValues)
 {
   uint8_t value = 0;
   if (input.Read(value) != Success) {
     return Failure;
   }
   readValues.push_back(value);
   return Success;
 }
 TEST_F(pkixder_input_tests, NestedOf)
 {
   Input input;
   ASSERT_EQ(Success,
             input.Init(DER_SEQUENCE_OF_INT8, sizeof DER_SEQUENCE_OF_INT8));
   std::vector<uint8_t> readValues;
   ASSERT_EQ(Success,
     NestedOf(input, SEQUENCE, INTEGER, MustNotBeEmpty,
              mozilla::pkix::bind(NestedOfHelper, mozilla::pkix::_1,
                                  mozilla::pkix::ref(readValues))));
   ASSERT_EQ((size_t) 3, readValues.size());
   ASSERT_EQ(0x01, readValues[0]);
   ASSERT_EQ(0x02, readValues[1]);
   ASSERT_EQ(0x03, readValues[2]);
   ASSERT_EQ(Success, End(input));
 }
 TEST_F(pkixder_input_tests, NestedOfWithTruncatedData)
 {
   Input input;
   ASSERT_EQ(Success, input.Init(DER_TRUNCATED_SEQUENCE_OF_INT8,
                                 sizeof DER_TRUNCATED_SEQUENCE_OF_INT8));
   std::vector<uint8_t> readValues;
   ASSERT_EQ(Failure,
     NestedOf(input, SEQUENCE, INTEGER, MustNotBeEmpty,
              mozilla::pkix::bind(NestedOfHelper, mozilla::pkix::_1,
                                  mozilla::pkix::ref(readValues))));
   ASSERT_EQ(SEC_ERROR_BAD_DER, PR_GetError());
   ASSERT_EQ((size_t) 0, readValues.size());
 }
 } // unnamed namespace

The Tor Browser / annotate

security/pkix/test/gtest/pkixder_input_tests.cpp@97036ab72558 (annotated)

security/pkix/test/gtest/pkixder_input_tests.cpp