[refactor] Extract some test helpers for certificate verification unittests.

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 <set>
 
-#include "base/base_paths.h"
-#include "base/files/file_util.h"
-#include "base/path_service.h"
 #include "net/cert/internal/signature_algorithm.h"
 #include "net/cert/internal/signature_policy.h"
-#include "net/cert/pem_tokenizer.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"
 
 #if defined(USE_OPENSSL)
 #include <openssl/obj.h>
 #endif
 
 namespace net {
 
 namespace {
 
-// Creates a der::Input from an std::string. The lifetimes are a bit subtle
-// when using this function:
-//
-// The returned der::Input() is only valid so long as the input string is alive
-// and is not mutated.
-//
-// Note that the input parameter has been made a pointer to prevent callers
-// from accidentally passing an r-value.
-der::Input InputFromString(const std::string* s) {
-  return der::Input(reinterpret_cast<const uint8_t*>(s->data()), s->size());
-}
-
-// Reads a signature verification test file.
-//
-// The test file is a series of PEM blocks (PEM is just base64 data) with
-// headings of:
-//
-//    "PUBLIC KEY" - DER encoding of the SubjectPublicKeyInfo
-//    "ALGORITHM" - DER encoding of the AlgorithmIdentifier for the signature
-//                  algorithm (signatureAlgorithm in X.509)
-//    "DATA" - The data that was signed (tbsCertificate in X.509)
-//    "SIGNATURE" - The result of signing DATA.
-::testing::AssertionResult ParseTestDataFile(const std::string& file_data,
-                                             std::string* public_key,
-                                             std::string* algorithm,
-                                             std::string* signed_data,
-                                             std::string* signature_value) {
-  const char kPublicKeyBlock[] = "PUBLIC KEY";
-  const char kAlgorithmBlock[] = "ALGORITHM";
-  const char kSignedDataBlock[] = "DATA";
-  const char kSignatureBlock[] = "SIGNATURE";
-
-  std::vector<std::string> pem_headers;
-  pem_headers.push_back(kPublicKeyBlock);
-  pem_headers.push_back(kAlgorithmBlock);
-  pem_headers.push_back(kSignedDataBlock);
-  pem_headers.push_back(kSignatureBlock);
-
-  // Keep track of which blocks have been encountered (by elimination).
-  std::set<std::string> remaining_blocks(pem_headers.begin(),
-                                         pem_headers.end());
-
-  PEMTokenizer pem_tokenizer(file_data, pem_headers);
-  while (pem_tokenizer.GetNext()) {
-    const std::string& block_type = pem_tokenizer.block_type();
-    if (block_type == kPublicKeyBlock) {
-      public_key->assign(pem_tokenizer.data());
-    } else if (block_type == kAlgorithmBlock) {
-      algorithm->assign(pem_tokenizer.data());
-    } else if (block_type == kSignedDataBlock) {
-      signed_data->assign(pem_tokenizer.data());
-    } else if (block_type == kSignatureBlock) {
-      signature_value->assign(pem_tokenizer.data());
-    }
-
-    if (remaining_blocks.erase(block_type) != 1u) {
-      return ::testing::AssertionFailure()
-             << "PEM block defined multiple times: " << block_type;
-    }
-  }
-
-  if (!remaining_blocks.empty()) {
-    // Print one of the missing PEM blocks.
-    return ::testing::AssertionFailure() << "PEM block missing: "
-                                         << *remaining_blocks.begin();
-  }
-
-  return ::testing::AssertionSuccess();
-}
-
-// Returns a path to the file |file_name| within the unittest data directory.
-base::FilePath GetTestFilePath(const char* file_name) {
-  base::FilePath src_root;
-  PathService::Get(base::DIR_SOURCE_ROOT, &src_root);
-  return src_root.Append(
-                     FILE_PATH_LITERAL("net/data/verify_signed_data_unittest"))
-      .AppendASCII(file_name);
-}
-
 enum VerifyResult {
   SUCCESS,
   FAILURE,
 };
 
 // Reads test data from |file_name| and runs VerifySignedData() over its
 // inputs, using |policy|.
 //
 // If expected_result was SUCCESS then the test will only succeed if
 // VerifySignedData() returns true.
 //
 // If expected_result was FAILURE then the test will only succeed if
 // VerifySignedData() returns false.
 void RunTestCaseUsingPolicy(VerifyResult expected_result,
                             const char* file_name,
                             const SignaturePolicy* policy) {
 #if !defined(USE_OPENSSL)
   LOG(INFO) << "Skipping test, only implemented for BoringSSL";
   return;
 #endif
 
-  base::FilePath test_file_path = GetTestFilePath(file_name);
-
-  std::string file_data;
-  ASSERT_TRUE(base::ReadFileToString(test_file_path, &file_data))
-      << "Couldn't read file: " << test_file_path.value();
+  std::string path =
+      std::string("net/data/verify_signed_data_unittest/") + file_name;
 
   std::string public_key;
   std::string algorithm;
   std::string signed_data;
   std::string signature_value;
 
-  ASSERT_TRUE(ParseTestDataFile(file_data, &public_key, &algorithm,
-                                &signed_data, &signature_value));
+  const PemBlockMapping mappings[] = {
+      {"PUBLIC KEY", &public_key},
+      {"ALGORITHM", &algorithm},
+      {"DATA", &signed_data},
+      {"SIGNATURE", &signature_value},
+  };
+
+  ASSERT_TRUE(ReadTestDataFromPemFile(path, mappings));
 
   scoped_ptr<SignatureAlgorithm> signature_algorithm =
       SignatureAlgorithm::CreateFromDer(InputFromString(&algorithm));
   ASSERT_TRUE(signature_algorithm);
 
   der::BitString signature_value_bit_string;
   der::Parser signature_value_parser(InputFromString(&signature_value));
   ASSERT_TRUE(signature_value_parser.ReadBitString(&signature_value_bit_string))
       << "The signature value is not a valid BIT STRING";
 
@@ skipping 230 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