Allow Cast certificates to have serial numbers greater than 20 bytes.

net/cert/internal/verify_certificate_chain_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 "net/cert/internal/verify_certificate_chain.h"
 
 #include "base/base_paths.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
 #include "base/strings/string_split.h"
@@ skipping 59 matching lines @@
 
   PEMTokenizer pem_tokenizer(file_data, pem_headers);
   while (pem_tokenizer.GetNext()) {
     const std::string& block_type = pem_tokenizer.block_type();
     const std::string& block_data = pem_tokenizer.data();
 
     if (block_type == kCertificateHeader) {
       chain->push_back(block_data);
     } else if (block_type == kTrustedCertificateHeader) {
       scoped_refptr<ParsedCertificate> cert(
-          ParsedCertificate::CreateFromCertificateCopy(block_data));
+          ParsedCertificate::CreateFromCertificateCopy(block_data, {}));
       ASSERT_TRUE(cert);
       trust_store->AddTrustedCertificate(std::move(cert));
     } else if (block_type == kTimeHeader) {
       ASSERT_FALSE(has_time) << "Duplicate " << kTimeHeader;
       has_time = true;
       ASSERT_TRUE(der::ParseUTCTime(der::Input(&block_data), time));
     } else if (block_type == kResultHeader) {
       ASSERT_FALSE(has_result) << "Duplicate " << kResultHeader;
       ASSERT_TRUE(block_data == "SUCCESS" || block_data == "FAIL")
           << "Unrecognized result: " << block_data;
@@ skipping 11 matching lines @@
   TrustStore trust_store;
   der::GeneralizedTime time;
   bool expected_result;
 
   ReadTestFromFile(file_name, &chain, &trust_store, &time, &expected_result);
 
   std::vector<scoped_refptr<net::ParsedCertificate>> input_chain;
   for (const auto& cert_der : chain) {
     ASSERT_TRUE(net::ParsedCertificate::CreateAndAddToVector(
         reinterpret_cast<const uint8_t*>(cert_der.data()), cert_der.size(),
-        net::ParsedCertificate::DataSource::EXTERNAL_REFERENCE, &input_chain));
+        net::ParsedCertificate::DataSource::EXTERNAL_REFERENCE, {},
+        &input_chain));
   }
 
   SimpleSignaturePolicy signature_policy(1024);
 
   std::vector<scoped_refptr<ParsedCertificate>> trusted_chain;
   bool result = VerifyCertificateChain(input_chain, trust_store,
                                        &signature_policy, time, &trusted_chain);
   if (result) {
     ASSERT_EQ(trusted_chain.size(), input_chain.size() + 1);
     ASSERT_TRUE(std::equal(input_chain.begin(), input_chain.end(),
@@ skipping 124 matching lines @@
   ASSERT_FALSE(VerifyCertificateChain(chain, trust_store, &signature_policy,
                                       time, nullptr));
 }
 
 // TODO(eroman): Add test that invalidate validity dates where the day or month
 // ordinal not in range, like "March 39, 2016" are rejected.
 
 }  // namespace
 
 }  // namespace net