Add error information to VerifySignedData().

net/cert/internal/verify_signed_data_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_signed_data.h"
 
 #include <memory>
 #include <set>
 
+#include "net/cert/internal/cert_errors.h"
 #include "net/cert/internal/signature_algorithm.h"
 #include "net/cert/internal/signature_policy.h"
 #include "net/cert/internal/test_helpers.h"
 #include "net/der/input.h"
 #include "net/der/parse_values.h"
 #include "net/der/parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <openssl/obj.h>
 
@@ skipping 38 matching lines @@
       SignatureAlgorithm::CreateFromDer(der::Input(&algorithm));
   ASSERT_TRUE(signature_algorithm);
 
   der::BitString signature_value_bit_string;
   der::Parser signature_value_parser((der::Input(&signature_value)));
   ASSERT_TRUE(signature_value_parser.ReadBitString(&signature_value_bit_string))
       << "The signature value is not a valid BIT STRING";
 
   bool expected_result_bool = expected_result == SUCCESS;
 
+  // TODO(crbug.com/634443): Verify the returned errors.
+  CertErrors errors;
   EXPECT_EQ(expected_result_bool,
             VerifySignedData(*signature_algorithm, der::Input(&signed_data),
                              signature_value_bit_string,
-                             der::Input(&public_key), policy));
+                             der::Input(&public_key), policy, &errors));
 }
 
 // RunTestCase() is the same as RunTestCaseUsingPolicy(), only it uses a
 // default policy. This policy will accept a basic profile of signature
 // algorithms (including ANY sized RSA key >= 1024).
 void RunTestCase(VerifyResult expected_result, const char* file_name) {
   SimpleSignaturePolicy policy(1024);
   return RunTestCaseUsingPolicy(expected_result, file_name, &policy);
 }
 
@@ skipping 126 matching lines @@
   RunTestCase(FAILURE, "rsa-pkcs1-sha256-spki-non-null-params.pem");
 }
 
 TEST(VerifySignedDataTest, EcdsaPrime256v1Sha512UnusedBitsSignature) {
   RunTestCase(FAILURE, "ecdsa-prime256v1-sha512-unused-bits-signature.pem");
 }
 
 // This policy rejects specifically secp384r1 curves.
 class RejectSecp384r1Policy : public SignaturePolicy {
  public:
-  bool IsAcceptableCurveForEcdsa(int curve_nid) const override {
+  bool IsAcceptableCurveForEcdsa(int curve_nid,
+                                 CertErrors* errors) const override {
     if (curve_nid == NID_secp384r1)
       return false;
     return true;
   }
 };
 
 TEST(VerifySignedDataTest, PolicyIsAcceptableCurveForEcdsa) {
   // Using the regular policy both secp384r1 and secp256r1 should be accepted.
   RunTestCase(SUCCESS, "ecdsa-secp384r1-sha256.pem");
   RunTestCase(SUCCESS, "ecdsa-prime256v1-sha512.pem");
@@ skipping 17 matching lines @@
   SimpleSignaturePolicy policy_2048(2048);
   RunTestCaseUsingPolicy(FAILURE, "rsa-pkcs1-sha256.pem", &policy_2048);
   RunTestCaseUsingPolicy(SUCCESS, "rsa2048-pkcs1-sha512.pem", &policy_2048);
 }
 
 // This policy rejects the use of SHA-512.
 class RejectSha512 : public SignaturePolicy {
  public:
   RejectSha512() : SignaturePolicy() {}
 
-  bool IsAcceptableSignatureAlgorithm(
-      const SignatureAlgorithm& algorithm) const override {
+  bool IsAcceptableSignatureAlgorithm(const SignatureAlgorithm& algorithm,
+                                      CertErrors* errors) const override {
     if (algorithm.algorithm() == SignatureAlgorithmId::RsaPss &&
         algorithm.ParamsForRsaPss()->mgf1_hash() == DigestAlgorithm::Sha512) {
       return false;
     }
 
     return algorithm.digest() != DigestAlgorithm::Sha512;
   }
 
-  bool IsAcceptableModulusLengthForRsa(
-      size_t modulus_length_bits) const override {
+  bool IsAcceptableModulusLengthForRsa(size_t modulus_length_bits,
+                                       CertErrors* errors) const override {
     return true;
   }
 };
 
 TEST(VerifySignedDataTest, PolicyIsAcceptableDigestAlgorithm) {
   // Using the regular policy use of either SHA256 or SHA512 should work
   // (whether as the main digest, or the MGF1 for RSASSA-PSS)
   RunTestCase(SUCCESS, "rsa2048-pkcs1-sha512.pem");
   RunTestCase(SUCCESS, "ecdsa-prime256v1-sha512.pem");
   RunTestCase(SUCCESS, "ecdsa-secp384r1-sha256.pem");
@@ skipping 10 matching lines @@
   RunTestCaseUsingPolicy(SUCCESS, "ecdsa-secp384r1-sha256.pem", &policy);
   RunTestCaseUsingPolicy(SUCCESS, "rsa-pkcs1-sha256.pem", &policy);
   RunTestCaseUsingPolicy(SUCCESS, "rsa-pss-sha256-salt10.pem", &policy);
   RunTestCaseUsingPolicy(FAILURE, "rsa-pss-sha256-mgf1-sha512-salt33.pem",
                          &policy);
 }
 
 }  // namespace
 
 }  // namespace net