Add a function for validating a DER-encoded INTEGER.

net/der/parse_values_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "net/der/parse_values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 166 matching lines @@
 
 struct Uint64TestData {
   bool should_pass;
   const uint8_t input[9];
   size_t length;
   uint64_t expected_value;
 };
 
 const Uint64TestData kUint64TestData[] = {
     {true, {0x00}, 1, 0},
+    // This number fails because it is not a minimal representation.
+    {false, {0x00, 0x00}, 2},
     {true, {0x01}, 1, 1},
-    {false, {0xFF}, 1, 0},
+    {false, {0xFF}, 1},
     {true, {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 8, INT64_MAX},
-    {false, {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 8, 0},
-    {false, {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 9, 0},
-    {false, {0x00, 0x01}, 2, 1},
-    {false, {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09}, 9, 0},
-    {false, {0}, 0, 0},
+    {true,
+     {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
+     9,
+     UINT64_MAX},
+    // This number fails because it is negative.
+    {false, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 8},
+    {false, {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 8},
+    {false, {0x00, 0x01}, 2},
+    {false, {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09}, 9},
+    {false, {0}, 0},
 };
 
 TEST(ParseValuesTest, ParseUint64) {
   for (size_t i = 0; i < arraysize(kUint64TestData); i++) {
-    Uint64TestData test_case = kUint64TestData[i];
+    const Uint64TestData& test_case = kUint64TestData[i];
     SCOPED_TRACE(i);
 
     uint64_t result;
     EXPECT_EQ(test_case.should_pass,
               ParseUint64(Input(test_case.input, test_case.length), &result));
     if (test_case.should_pass)
       EXPECT_EQ(test_case.expected_value, result);
   }
 }
 
+struct ParseIntegerTestData {
+  bool should_pass;
+  const uint8_t input[2];
+  size_t length;
+  bool negative;
+  // The difference between length and numeric_length. If it is 0 then
+  // numeric_length is expected to match length.
+  int length_difference;
+};
+
+const ParseIntegerTestData kParseIntegerTestData[] = {
+    // Empty input (invalid DER).
+    {false, {0x00}, 0},
+
+    // The correct encoding for zero.
+    {true, {0x00}, 1, false},
+
+    // Invalid representation of zero (not minimal)
+    {false, {0x00, 0x00}, 2},
+
+    // Valid single byte negative numbers.
+    {true, {0x80}, 1, true},
+    {true, {0xFF}, 1, true},
+
+    // Non-minimal negative number.
+    {false, {0xFF, 0x80}, 2},
+
+    // Positive number with a legitimate leading zero.
+    {true, {0x00, 0x80}, 2, false, -1},
+
+    // A legitimate negative number that starts with FF (MSB of second byte is
+    // 0 so OK).
+    {true, {0xFF, 0x7F}, 2, true},
+};
+
+TEST(ParseValuesTest, IsValidInteger) {
+  for (size_t i = 0; i < arraysize(kParseIntegerTestData); i++) {
+    const ParseIntegerTestData& test_case = kParseIntegerTestData[i];
+    SCOPED_TRACE(i);
+
+    bool negative;
+    size_t numeric_length;
+    EXPECT_EQ(test_case.should_pass,
+              IsValidInteger(Input(test_case.input, test_case.length),
+                             &negative, &numeric_length));
+    if (test_case.should_pass) {
+      EXPECT_EQ(test_case.negative, negative);
+      EXPECT_EQ(test_case.length + test_case.length_difference, numeric_length);
+    }
+  }
+}
+
 // Tests parsing an empty BIT STRING.
 TEST(ParseValuesTest, ParseBitStringEmptyNoUnusedBits) {
   const uint8_t kData[] = {0x00};
 
   BitString bit_string;
   ASSERT_TRUE(ParseBitString(Input(kData), &bit_string));
 
   EXPECT_EQ(0u, bit_string.unused_bits());
   EXPECT_EQ(0u, bit_string.bytes().Length());
 }
@@ skipping 32 matching lines @@
 TEST(ParseValuesTest, ParseBitStringSevenOneBitsUnusedBitIsOne) {
   const uint8_t kData[] = {0x01, 0xFF};
 
   BitString bit_string;
   EXPECT_FALSE(ParseBitString(Input(kData), &bit_string));
 }
 
 }  // namespace test
 }  // namespace der
 }  // namespace net