components/webcrypto/algorithms/test_helpers.h - codesearch/chromium/src - Git at Google

 // Copyright 2014 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.

 #ifndef COMPONENTS_WEBCRYPTO_ALGORITHMS_TEST_HELPERS_H_
 #define COMPONENTS_WEBCRYPTO_ALGORITHMS_TEST_HELPERS_H_

 #include <stdint.h>

 #include <ostream>
 #include <string>
 #include <vector>

 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
 #include "third_party/WebKit/public/platform/WebCryptoKey.h"

 #define EXPECT_BYTES_EQ(expected, actual) \
   EXPECT_EQ(CryptoData(expected), CryptoData(actual))

 #define EXPECT_BYTES_EQ_HEX(expected_hex, actual_bytes) \
   EXPECT_BYTES_EQ(HexStringToBytes(expected_hex), actual_bytes)

 namespace base {
 class DictionaryValue;
 class ListValue;
 class Value;
 }

 namespace blink {
 class WebCryptoAlgorithm;
 }

 namespace webcrypto {

 // Base class for WebCrypto tests. All WebCrypto tests must derive from this
 // to ensure that Blink has been properly initialized. In particular,
 // the WebCrypto tests use blink::WebCryptoAlgorithm, which in turn relies on
 // PartitionAlloc.
 class WebCryptoTestBase : public testing::Test {
  protected:
   static void SetUpTestCase();
 };

 class Status;
 class CryptoData;

 // These functions are used by GTEST to support EXPECT_EQ() for
 // webcrypto::Status and webcrypto::CryptoData

 void PrintTo(const Status& status, ::std::ostream* os);
 bool operator==(const Status& a, const Status& b);
 bool operator!=(const Status& a, const Status& b);

 void PrintTo(const CryptoData& data, ::std::ostream* os);
 bool operator==(const CryptoData& a, const CryptoData& b);
 bool operator!=(const CryptoData& a, const CryptoData& b);

 // Gives a human-readable description of |status| and any error it represents.
 std::string StatusToString(const Status& status);

 blink::WebCryptoAlgorithm CreateRsaHashedKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId algorithm_id,
     const blink::WebCryptoAlgorithmId hash_id,
     unsigned int modulus_length,
     const std::vector<uint8_t>& public_exponent);

 // Returns a slightly modified version of the input vector.
 //
 //  - For non-empty inputs a single bit is inverted.
 //  - For empty inputs, a byte is added.
 std::vector<uint8_t> Corrupted(const std::vector<uint8_t>& input);

 std::vector<uint8_t> HexStringToBytes(const std::string& hex);

 std::vector<uint8_t> MakeJsonVector(const std::string& json_string);
 std::vector<uint8_t> MakeJsonVector(const base::DictionaryValue& dict);

 // ----------------------------------------------------------------
 // Helpers for working with JSON data files for test expectations.
 // ----------------------------------------------------------------

 // Reads a file in "src/content/test/data/webcrypto" to a base::Value.
 // The file must be JSON, however it can also include C++ style comments.
 ::testing::AssertionResult ReadJsonTestFile(const char* test_file_name,
                                             scoped_ptr<base::Value>* value);
 // Same as ReadJsonTestFile(), but returns the value as a List.
 ::testing::AssertionResult ReadJsonTestFileToList(
     const char* test_file_name,
     scoped_ptr<base::ListValue>* list);
 // Same as ReadJsonTestFile(), but returns the value as a Dictionary.
 ::testing::AssertionResult ReadJsonTestFileToDictionary(
     const char* test_file_name,
     scoped_ptr<base::DictionaryValue>* dict);

 // Reads a string property from the dictionary with path |property_name|
 // (which can include periods for nested dictionaries). Interprets the
 // string as a hex encoded string and converts it to a bytes list.
 //
 // Returns empty vector on failure.
 std::vector<uint8_t> GetBytesFromHexString(const base::DictionaryValue* dict,
                                            const std::string& property_name);

 // Reads a string property with path "property_name" and converts it to a
 // WebCryptoAlgorith. Returns null algorithm on failure.
 blink::WebCryptoAlgorithm GetDigestAlgorithm(const base::DictionaryValue* dict,
                                              const char* property_name);

 // Returns true if any of the vectors in the input list have identical content.
 bool CopiesExist(const std::vector<std::vector<uint8_t>>& bufs);

 blink::WebCryptoAlgorithm CreateAesKeyGenAlgorithm(
     blink::WebCryptoAlgorithmId aes_alg_id,
     unsigned short length);

 // The following key pair is comprised of the SPKI (public key) and PKCS#8
 // (private key) representations of the key pair provided in Example 1 of the
 // NIST test vectors at
 // ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15sign-vectors.txt
 extern const unsigned int kModulusLengthBits;
 extern const char* const kPublicKeySpkiDerHex;
 extern const char* const kPrivateKeyPkcs8DerHex;

 // The modulus and exponent (in hex) of kPublicKeySpkiDerHex
 extern const char* const kPublicKeyModulusHex;
 extern const char* const kPublicKeyExponentHex;

 blink::WebCryptoKey ImportSecretKeyFromRaw(
     const std::vector<uint8_t>& key_raw,
     const blink::WebCryptoAlgorithm& algorithm,
     blink::WebCryptoKeyUsageMask usage);

 void ImportRsaKeyPair(const std::vector<uint8_t>& spki_der,
                       const std::vector<uint8_t>& pkcs8_der,
                       const blink::WebCryptoAlgorithm& algorithm,
                       bool extractable,
                       blink::WebCryptoKeyUsageMask public_key_usages,
                       blink::WebCryptoKeyUsageMask private_key_usages,
                       blink::WebCryptoKey* public_key,
                       blink::WebCryptoKey* private_key);

 Status ImportKeyJwkFromDict(const base::DictionaryValue& dict,
                             const blink::WebCryptoAlgorithm& algorithm,
                             bool extractable,
                             blink::WebCryptoKeyUsageMask usages,
                             blink::WebCryptoKey* key);

 // Parses a vector of JSON into a dictionary.
 scoped_ptr<base::DictionaryValue> GetJwkDictionary(
     const std::vector<uint8_t>& json);

 // Verifies the input dictionary contains the expected values. Exact matches are
 // required on the fields examined.
 ::testing::AssertionResult VerifyJwk(
     const scoped_ptr<base::DictionaryValue>& dict,
     const std::string& kty_expected,
     const std::string& alg_expected,
     blink::WebCryptoKeyUsageMask use_mask_expected);

 ::testing::AssertionResult VerifySecretJwk(
     const std::vector<uint8_t>& json,
     const std::string& alg_expected,
     const std::string& k_expected_hex,
     blink::WebCryptoKeyUsageMask use_mask_expected);

 // Verifies that the JSON in the input vector contains the provided
 // expected values. Exact matches are required on the fields examined.
 ::testing::AssertionResult VerifyPublicJwk(
     const std::vector<uint8_t>& json,
     const std::string& alg_expected,
     const std::string& n_expected_hex,
     const std::string& e_expected_hex,
     blink::WebCryptoKeyUsageMask use_mask_expected);

 // Helper that tests importing ane exporting of symmetric keys as JWK.
 void ImportExportJwkSymmetricKey(
     int key_len_bits,
     const blink::WebCryptoAlgorithm& import_algorithm,
     blink::WebCryptoKeyUsageMask usages,
     const std::string& jwk_alg);

 // Wrappers around GenerateKey() which expect the result to be either a secret
 // key or a public/private keypair. If the result does not match the
 // expectation, then it fails with Status::ErrorUnexpected().
 Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
                          bool extractable,
                          blink::WebCryptoKeyUsageMask usages,
                          blink::WebCryptoKey* key);
 Status GenerateKeyPair(const blink::WebCryptoAlgorithm& algorithm,
                        bool extractable,
                        blink::WebCryptoKeyUsageMask usages,
                        blink::WebCryptoKey* public_key,
                        blink::WebCryptoKey* private_key);

 // Reads a key format string as used in some JSON test files and converts it to
 // a WebCryptoKeyFormat.
 blink::WebCryptoKeyFormat GetKeyFormatFromJsonTestCase(
     const base::DictionaryValue* test);

 // Extracts the key data bytes from |test| as used insome JSON test files.
 std::vector<uint8_t> GetKeyDataFromJsonTestCase(
     const base::DictionaryValue* test,
     blink::WebCryptoKeyFormat key_format);

 // Reads the "crv" string from a JSON test case and returns it as a
 // WebCryptoNamedCurve.
 blink::WebCryptoNamedCurve GetCurveNameFromDictionary(
     const base::DictionaryValue* dict);

 // Creates an HMAC import algorithm whose inner hash algorithm is determined by
 // the specified algorithm ID. It is an error to call this method with a hash
 // algorithm that is not SHA*.
 blink::WebCryptoAlgorithm CreateHmacImportAlgorithm(
     blink::WebCryptoAlgorithmId hash_id,
     unsigned int length_bits);

 // Same as above but without specifying a length.
 blink::WebCryptoAlgorithm CreateHmacImportAlgorithmNoLength(
     blink::WebCryptoAlgorithmId hash_id);

 // Creates a WebCryptoAlgorithm without any parameters.
 blink::WebCryptoAlgorithm CreateAlgorithm(blink::WebCryptoAlgorithmId id);

 // Creates an import algorithm for RSA algorithms that take a hash.
 // It is an error to call this with a hash_id that is not a SHA*.
 blink::WebCryptoAlgorithm CreateRsaHashedImportAlgorithm(
     blink::WebCryptoAlgorithmId id,
     blink::WebCryptoAlgorithmId hash_id);

 // Creates an import algorithm for EC keys.
 blink::WebCryptoAlgorithm CreateEcImportAlgorithm(
     blink::WebCryptoAlgorithmId id,
     blink::WebCryptoNamedCurve named_curve);

 }  // namespace webcrypto

 #endif  // COMPONENTS_WEBCRYPTO_ALGORITHMS_TEST_HELPERS_H_
	// Copyright 2014 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.

	#ifndef COMPONENTS_WEBCRYPTO_ALGORITHMS_TEST_HELPERS_H_
	#define COMPONENTS_WEBCRYPTO_ALGORITHMS_TEST_HELPERS_H_

	#include <stdint.h>

	#include <ostream>
	#include <string>
	#include <vector>

	#include "base/memory/scoped_ptr.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h"
	#include "third_party/WebKit/public/platform/WebCryptoKey.h"

	#define EXPECT_BYTES_EQ(expected, actual) \
	EXPECT_EQ(CryptoData(expected), CryptoData(actual))

	#define EXPECT_BYTES_EQ_HEX(expected_hex, actual_bytes) \
	EXPECT_BYTES_EQ(HexStringToBytes(expected_hex), actual_bytes)

	namespace base {
	class DictionaryValue;
	class ListValue;
	class Value;
	}

	namespace blink {
	class WebCryptoAlgorithm;
	}

	namespace webcrypto {

	// Base class for WebCrypto tests. All WebCrypto tests must derive from this
	// to ensure that Blink has been properly initialized. In particular,
	// the WebCrypto tests use blink::WebCryptoAlgorithm, which in turn relies on
	// PartitionAlloc.
	class WebCryptoTestBase : public testing::Test {
	protected:
	static void SetUpTestCase();
	};

	class Status;
	class CryptoData;

	// These functions are used by GTEST to support EXPECT_EQ() for
	// webcrypto::Status and webcrypto::CryptoData

	void PrintTo(const Status& status, ::std::ostream* os);
	bool operator==(const Status& a, const Status& b);
	bool operator!=(const Status& a, const Status& b);

	void PrintTo(const CryptoData& data, ::std::ostream* os);
	bool operator==(const CryptoData& a, const CryptoData& b);
	bool operator!=(const CryptoData& a, const CryptoData& b);

	// Gives a human-readable description of \|status\| and any error it represents.
	std::string StatusToString(const Status& status);

	blink::WebCryptoAlgorithm CreateRsaHashedKeyGenAlgorithm(
	blink::WebCryptoAlgorithmId algorithm_id,
	const blink::WebCryptoAlgorithmId hash_id,
	unsigned int modulus_length,
	const std::vector<uint8_t>& public_exponent);

	// Returns a slightly modified version of the input vector.
	//
	// - For non-empty inputs a single bit is inverted.
	// - For empty inputs, a byte is added.
	std::vector<uint8_t> Corrupted(const std::vector<uint8_t>& input);

	std::vector<uint8_t> HexStringToBytes(const std::string& hex);

	std::vector<uint8_t> MakeJsonVector(const std::string& json_string);
	std::vector<uint8_t> MakeJsonVector(const base::DictionaryValue& dict);

	// ----------------------------------------------------------------
	// Helpers for working with JSON data files for test expectations.
	// ----------------------------------------------------------------

	// Reads a file in "src/content/test/data/webcrypto" to a base::Value.
	// The file must be JSON, however it can also include C++ style comments.
	::testing::AssertionResult ReadJsonTestFile(const char* test_file_name,
	scoped_ptr<base::Value>* value);
	// Same as ReadJsonTestFile(), but returns the value as a List.
	::testing::AssertionResult ReadJsonTestFileToList(
	const char* test_file_name,
	scoped_ptr<base::ListValue>* list);
	// Same as ReadJsonTestFile(), but returns the value as a Dictionary.
	::testing::AssertionResult ReadJsonTestFileToDictionary(
	const char* test_file_name,
	scoped_ptr<base::DictionaryValue>* dict);

	// Reads a string property from the dictionary with path \|property_name\|
	// (which can include periods for nested dictionaries). Interprets the
	// string as a hex encoded string and converts it to a bytes list.
	//
	// Returns empty vector on failure.
	std::vector<uint8_t> GetBytesFromHexString(const base::DictionaryValue* dict,
	const std::string& property_name);

	// Reads a string property with path "property_name" and converts it to a
	// WebCryptoAlgorith. Returns null algorithm on failure.
	blink::WebCryptoAlgorithm GetDigestAlgorithm(const base::DictionaryValue* dict,
	const char* property_name);

	// Returns true if any of the vectors in the input list have identical content.
	bool CopiesExist(const std::vector<std::vector<uint8_t>>& bufs);

	blink::WebCryptoAlgorithm CreateAesKeyGenAlgorithm(
	blink::WebCryptoAlgorithmId aes_alg_id,
	unsigned short length);

	// The following key pair is comprised of the SPKI (public key) and PKCS#8
	// (private key) representations of the key pair provided in Example 1 of the
	// NIST test vectors at
	// ftp://ftp.rsa.com/pub/rsalabs/tmp/pkcs1v15sign-vectors.txt
	extern const unsigned int kModulusLengthBits;
	extern const char* const kPublicKeySpkiDerHex;
	extern const char* const kPrivateKeyPkcs8DerHex;

	// The modulus and exponent (in hex) of kPublicKeySpkiDerHex
	extern const char* const kPublicKeyModulusHex;
	extern const char* const kPublicKeyExponentHex;

	blink::WebCryptoKey ImportSecretKeyFromRaw(
	const std::vector<uint8_t>& key_raw,
	const blink::WebCryptoAlgorithm& algorithm,
	blink::WebCryptoKeyUsageMask usage);

	void ImportRsaKeyPair(const std::vector<uint8_t>& spki_der,
	const std::vector<uint8_t>& pkcs8_der,
	const blink::WebCryptoAlgorithm& algorithm,
	bool extractable,
	blink::WebCryptoKeyUsageMask public_key_usages,
	blink::WebCryptoKeyUsageMask private_key_usages,
	blink::WebCryptoKey* public_key,
	blink::WebCryptoKey* private_key);

	Status ImportKeyJwkFromDict(const base::DictionaryValue& dict,
	const blink::WebCryptoAlgorithm& algorithm,
	bool extractable,
	blink::WebCryptoKeyUsageMask usages,
	blink::WebCryptoKey* key);

	// Parses a vector of JSON into a dictionary.
	scoped_ptr<base::DictionaryValue> GetJwkDictionary(
	const std::vector<uint8_t>& json);

	// Verifies the input dictionary contains the expected values. Exact matches are
	// required on the fields examined.
	::testing::AssertionResult VerifyJwk(
	const scoped_ptr<base::DictionaryValue>& dict,
	const std::string& kty_expected,
	const std::string& alg_expected,
	blink::WebCryptoKeyUsageMask use_mask_expected);

	::testing::AssertionResult VerifySecretJwk(
	const std::vector<uint8_t>& json,
	const std::string& alg_expected,
	const std::string& k_expected_hex,
	blink::WebCryptoKeyUsageMask use_mask_expected);

	// Verifies that the JSON in the input vector contains the provided
	// expected values. Exact matches are required on the fields examined.
	::testing::AssertionResult VerifyPublicJwk(
	const std::vector<uint8_t>& json,
	const std::string& alg_expected,
	const std::string& n_expected_hex,
	const std::string& e_expected_hex,
	blink::WebCryptoKeyUsageMask use_mask_expected);

	// Helper that tests importing ane exporting of symmetric keys as JWK.
	void ImportExportJwkSymmetricKey(
	int key_len_bits,
	const blink::WebCryptoAlgorithm& import_algorithm,
	blink::WebCryptoKeyUsageMask usages,
	const std::string& jwk_alg);

	// Wrappers around GenerateKey() which expect the result to be either a secret
	// key or a public/private keypair. If the result does not match the
	// expectation, then it fails with Status::ErrorUnexpected().
	Status GenerateSecretKey(const blink::WebCryptoAlgorithm& algorithm,
	bool extractable,
	blink::WebCryptoKeyUsageMask usages,
	blink::WebCryptoKey* key);
	Status GenerateKeyPair(const blink::WebCryptoAlgorithm& algorithm,
	bool extractable,
	blink::WebCryptoKeyUsageMask usages,
	blink::WebCryptoKey* public_key,
	blink::WebCryptoKey* private_key);

	// Reads a key format string as used in some JSON test files and converts it to
	// a WebCryptoKeyFormat.
	blink::WebCryptoKeyFormat GetKeyFormatFromJsonTestCase(
	const base::DictionaryValue* test);

	// Extracts the key data bytes from \|test\| as used insome JSON test files.
	std::vector<uint8_t> GetKeyDataFromJsonTestCase(
	const base::DictionaryValue* test,
	blink::WebCryptoKeyFormat key_format);

	// Reads the "crv" string from a JSON test case and returns it as a
	// WebCryptoNamedCurve.
	blink::WebCryptoNamedCurve GetCurveNameFromDictionary(
	const base::DictionaryValue* dict);

	// Creates an HMAC import algorithm whose inner hash algorithm is determined by
	// the specified algorithm ID. It is an error to call this method with a hash
	// algorithm that is not SHA*.
	blink::WebCryptoAlgorithm CreateHmacImportAlgorithm(
	blink::WebCryptoAlgorithmId hash_id,
	unsigned int length_bits);

	// Same as above but without specifying a length.
	blink::WebCryptoAlgorithm CreateHmacImportAlgorithmNoLength(
	blink::WebCryptoAlgorithmId hash_id);

	// Creates a WebCryptoAlgorithm without any parameters.
	blink::WebCryptoAlgorithm CreateAlgorithm(blink::WebCryptoAlgorithmId id);

	// Creates an import algorithm for RSA algorithms that take a hash.
	// It is an error to call this with a hash_id that is not a SHA*.
	blink::WebCryptoAlgorithm CreateRsaHashedImportAlgorithm(
	blink::WebCryptoAlgorithmId id,
	blink::WebCryptoAlgorithmId hash_id);

	// Creates an import algorithm for EC keys.
	blink::WebCryptoAlgorithm CreateEcImportAlgorithm(
	blink::WebCryptoAlgorithmId id,
	blink::WebCryptoNamedCurve named_curve);

	} // namespace webcrypto

	#endif // COMPONENTS_WEBCRYPTO_ALGORITHMS_TEST_HELPERS_H_