cc/signature/rsa_ssa_pkcs1_sign_key_manager_test.cc - third_party/tink - Git at Google

 // Copyright 2018 Google LLC
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 //
 ////////////////////////////////////////////////////////////////////////////////

 #include "tink/signature/rsa_ssa_pkcs1_sign_key_manager.h"

 #include <string>

 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "absl/container/flat_hash_set.h"
 #include "openssl/rsa.h"
 #include "tink/internal/bn_util.h"
 #include "tink/internal/ssl_unique_ptr.h"
 #include "tink/public_key_sign.h"
 #include "tink/signature/rsa_ssa_pkcs1_verify_key_manager.h"
 #include "tink/subtle/rsa_ssa_pkcs1_verify_boringssl.h"
 #include "tink/util/status.h"
 #include "tink/util/statusor.h"
 #include "tink/util/test_matchers.h"
 #include "tink/util/test_util.h"
 #include "proto/rsa_ssa_pkcs1.pb.h"
 #include "proto/tink.pb.h"

 namespace crypto {
 namespace tink {
 namespace {

 using ::crypto::tink::test::IsOk;
 using ::crypto::tink::util::StatusOr;
 using ::google::crypto::tink::HashType;
 using ::google::crypto::tink::KeyData;
 using ::google::crypto::tink::RsaSsaPkcs1KeyFormat;
 using ::google::crypto::tink::RsaSsaPkcs1PrivateKey;
 using ::google::crypto::tink::RsaSsaPkcs1PublicKey;
 using ::testing::Eq;
 using ::testing::Not;
 using ::testing::SizeIs;

 TEST(RsaSsaPkcsSignKeyManagerTest, Basic) {
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().get_version(), Eq(0));
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().key_material_type(),
               Eq(KeyData::ASYMMETRIC_PRIVATE));
   EXPECT_THAT(
       RsaSsaPkcs1SignKeyManager().get_key_type(),
       Eq("type.googleapis.com/google.crypto.tink.RsaSsaPkcs1PrivateKey"));
 }

 RsaSsaPkcs1KeyFormat CreateKeyFormat(HashType hash_type,
                                      int modulus_size_in_bits,
                                      int public_exponent) {
   RsaSsaPkcs1KeyFormat key_format;
   auto params = key_format.mutable_params();
   params->set_hash_type(hash_type);
   key_format.set_modulus_size_in_bits(modulus_size_in_bits);
   internal::SslUniquePtr<BIGNUM> e(BN_new());
   BN_set_word(e.get(), public_exponent);
   key_format.set_public_exponent(
       internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
   return key_format;
 }

 RsaSsaPkcs1KeyFormat ValidKeyFormat() {
   return CreateKeyFormat(HashType::SHA256, 3072, RSA_F4);
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormat) {
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(ValidKeyFormat()),
               IsOk());
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSha384Allowed) {
   RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
   key_format.mutable_params()->set_hash_type(HashType::SHA384);
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
               IsOk());
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSha512Allowed) {
   RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
   key_format.mutable_params()->set_hash_type(HashType::SHA512);
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
               IsOk());
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSha1Disallowed) {
   RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
   key_format.mutable_params()->set_hash_type(HashType::SHA1);
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
               Not(IsOk()));
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatUnkownHashDisallowed) {
   RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
   key_format.mutable_params()->set_hash_type(HashType::UNKNOWN_HASH);
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
               Not(IsOk()));
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSmallModulusDisallowed) {
   RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
   key_format.set_modulus_size_in_bits(2047);
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
               Not(IsOk()));
 }

 // Checks whether given key is compatible with the given format.
 void CheckNewKey(const RsaSsaPkcs1PrivateKey& private_key,
                  const RsaSsaPkcs1KeyFormat& key_format) {
   RsaSsaPkcs1SignKeyManager key_manager;
   RsaSsaPkcs1PublicKey public_key = private_key.public_key();
   EXPECT_EQ(0, private_key.version());
   EXPECT_TRUE(private_key.has_public_key());
   EXPECT_EQ(0, public_key.version());
   EXPECT_GT(public_key.n().length(), 0);
   EXPECT_GT(public_key.e().length(), 0);
   EXPECT_EQ(public_key.params().SerializeAsString(),
             key_format.params().SerializeAsString());
   EXPECT_EQ(key_format.public_exponent(), public_key.e());
   util::StatusOr<internal::SslUniquePtr<BIGNUM>> n =
       internal::StringToBignum(public_key.n());
   ASSERT_THAT(n, IsOk());
   util::StatusOr<internal::SslUniquePtr<BIGNUM>> d =
       internal::StringToBignum(private_key.d());
   ASSERT_THAT(d, IsOk());
   util::StatusOr<internal::SslUniquePtr<BIGNUM>> p =
       internal::StringToBignum(private_key.p());
   ASSERT_THAT(p, IsOk());
   util::StatusOr<internal::SslUniquePtr<BIGNUM>> q =
       internal::StringToBignum(private_key.q());
   ASSERT_THAT(q, IsOk());
   util::StatusOr<internal::SslUniquePtr<BIGNUM>> dp =
       internal::StringToBignum(private_key.dp());
   ASSERT_THAT(dp, IsOk());
   util::StatusOr<internal::SslUniquePtr<BIGNUM>> dq =
       internal::StringToBignum(private_key.dq());
   ASSERT_THAT(dq, IsOk());
   internal::SslUniquePtr<BN_CTX> ctx(BN_CTX_new());

   // Check n = p * q.
   auto n_calc = internal::SslUniquePtr<BIGNUM>(BN_new());
   EXPECT_TRUE(BN_mul(n_calc.get(), p->get(), q->get(), ctx.get()));
   EXPECT_EQ(BN_cmp(n_calc.get(), n->get()), 0);

   // Check n size >= modulus_size_in_bits bit.
   EXPECT_GE(BN_num_bits(n->get()), key_format.modulus_size_in_bits());

   // dp = d mod (p - 1)
   auto pm1 = internal::SslUniquePtr<BIGNUM>(BN_dup(p->get()));
   EXPECT_TRUE(BN_sub_word(pm1.get(), 1));
   auto dp_calc = internal::SslUniquePtr<BIGNUM>(BN_new());
   EXPECT_TRUE(BN_mod(dp_calc.get(), d->get(), pm1.get(), ctx.get()));
   EXPECT_EQ(BN_cmp(dp_calc.get(), dp->get()), 0);

   // dq = d mod (q - 1)
   auto qm1 = internal::SslUniquePtr<BIGNUM>(BN_dup(q->get()));
   EXPECT_TRUE(BN_sub_word(qm1.get(), 1));
   auto dq_calc = internal::SslUniquePtr<BIGNUM>(BN_new());
   EXPECT_TRUE(BN_mod(dq_calc.get(), d->get(), qm1.get(), ctx.get()));
   EXPECT_EQ(BN_cmp(dq_calc.get(), dq->get()), 0);
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKey) {
   RsaSsaPkcs1KeyFormat key_format =
       CreateKeyFormat(HashType::SHA256, 3072, RSA_F4);
   StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
       RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
   ASSERT_THAT(private_key_or, IsOk());
   CheckNewKey(private_key_or.value(), key_format);
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeySmallKey) {
   RsaSsaPkcs1KeyFormat key_format =
       CreateKeyFormat(HashType::SHA256, 2048, RSA_F4);

   StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
       RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
   ASSERT_THAT(private_key_or, IsOk());
   CheckNewKey(private_key_or.value(), key_format);
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyLargeKey) {
   RsaSsaPkcs1KeyFormat key_format =
       CreateKeyFormat(HashType::SHA512, 4096, RSA_F4);

   StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
       RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
   ASSERT_THAT(private_key_or, IsOk());
   CheckNewKey(private_key_or.value(), key_format);
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyValid) {
   StatusOr<RsaSsaPkcs1PrivateKey> key_or =
       RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
   ASSERT_THAT(key_or, IsOk());
   EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKey(key_or.value()), IsOk());
 }

 // Check that in a bunch of CreateKey calls all generated primes are distinct.
 TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyAlwaysNewRsaPair) {
   absl::flat_hash_set<std::string> keys;
   // This test takes about a second per key.
   int num_generated_keys = 5;
   for (int i = 0; i < num_generated_keys; ++i) {
     StatusOr<RsaSsaPkcs1PrivateKey> key_or =
         RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
     ASSERT_THAT(key_or, IsOk());
     keys.insert(key_or.value().p());
     keys.insert(key_or.value().q());
   }
   EXPECT_THAT(keys, SizeIs(2 * num_generated_keys));
 }

 TEST(RsaSsaPkcs1SignKeyManagerTest, GetPublicKey) {
   StatusOr<RsaSsaPkcs1PrivateKey> key_or =
       RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
   ASSERT_THAT(key_or, IsOk());
   StatusOr<RsaSsaPkcs1PublicKey> public_key_or =
       RsaSsaPkcs1SignKeyManager().GetPublicKey(key_or.value());
   ASSERT_THAT(public_key_or, IsOk());
   EXPECT_THAT(public_key_or.value().version(),
               Eq(key_or.value().public_key().version()));
   EXPECT_THAT(public_key_or.value().params().hash_type(),
               Eq(key_or.value().public_key().params().hash_type()));
   EXPECT_THAT(public_key_or.value().n(), Eq(key_or.value().public_key().n()));
   EXPECT_THAT(public_key_or.value().e(), Eq(key_or.value().public_key().e()));
 }

 TEST(EcdsaSignKeyManagerTest, Create) {
   RsaSsaPkcs1KeyFormat key_format =
       CreateKeyFormat(HashType::SHA256, 3072, RSA_F4);
   StatusOr<RsaSsaPkcs1PrivateKey> key_or =
       RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
   ASSERT_THAT(key_or, IsOk());
   RsaSsaPkcs1PrivateKey key = key_or.value();

   auto signer_or = RsaSsaPkcs1SignKeyManager().GetPrimitive<PublicKeySign>(key);
   ASSERT_THAT(signer_or, IsOk());

   auto direct_verifier_or = subtle::RsaSsaPkcs1VerifyBoringSsl::New(
       {key.public_key().n(), key.public_key().e()}, {subtle::HashType::SHA256});
   ASSERT_THAT(direct_verifier_or, IsOk());

   std::string message = "Some message";
   EXPECT_THAT(direct_verifier_or.value()->Verify(
                   signer_or.value()->Sign(message).value(), message),
               IsOk());
 }

 }  // namespace
 }  // namespace tink
 }  // namespace crypto
	// Copyright 2018 Google LLC
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	//
	////////////////////////////////////////////////////////////////////////////////

	#include "tink/signature/rsa_ssa_pkcs1_sign_key_manager.h"

	#include <string>

	#include "gmock/gmock.h"
	#include "gtest/gtest.h"
	#include "absl/container/flat_hash_set.h"
	#include "openssl/rsa.h"
	#include "tink/internal/bn_util.h"
	#include "tink/internal/ssl_unique_ptr.h"
	#include "tink/public_key_sign.h"
	#include "tink/signature/rsa_ssa_pkcs1_verify_key_manager.h"
	#include "tink/subtle/rsa_ssa_pkcs1_verify_boringssl.h"
	#include "tink/util/status.h"
	#include "tink/util/statusor.h"
	#include "tink/util/test_matchers.h"
	#include "tink/util/test_util.h"
	#include "proto/rsa_ssa_pkcs1.pb.h"
	#include "proto/tink.pb.h"

	namespace crypto {
	namespace tink {
	namespace {

	using ::crypto::tink::test::IsOk;
	using ::crypto::tink::util::StatusOr;
	using ::google::crypto::tink::HashType;
	using ::google::crypto::tink::KeyData;
	using ::google::crypto::tink::RsaSsaPkcs1KeyFormat;
	using ::google::crypto::tink::RsaSsaPkcs1PrivateKey;
	using ::google::crypto::tink::RsaSsaPkcs1PublicKey;
	using ::testing::Eq;
	using ::testing::Not;
	using ::testing::SizeIs;

	TEST(RsaSsaPkcsSignKeyManagerTest, Basic) {
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().get_version(), Eq(0));
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().key_material_type(),
	Eq(KeyData::ASYMMETRIC_PRIVATE));
	EXPECT_THAT(
	RsaSsaPkcs1SignKeyManager().get_key_type(),
	Eq("type.googleapis.com/google.crypto.tink.RsaSsaPkcs1PrivateKey"));
	}

	RsaSsaPkcs1KeyFormat CreateKeyFormat(HashType hash_type,
	int modulus_size_in_bits,
	int public_exponent) {
	RsaSsaPkcs1KeyFormat key_format;
	auto params = key_format.mutable_params();
	params->set_hash_type(hash_type);
	key_format.set_modulus_size_in_bits(modulus_size_in_bits);
	internal::SslUniquePtr<BIGNUM> e(BN_new());
	BN_set_word(e.get(), public_exponent);
	key_format.set_public_exponent(
	internal::BignumToString(e.get(), BN_num_bytes(e.get())).value());
	return key_format;
	}

	RsaSsaPkcs1KeyFormat ValidKeyFormat() {
	return CreateKeyFormat(HashType::SHA256, 3072, RSA_F4);
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormat) {
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(ValidKeyFormat()),
	IsOk());
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSha384Allowed) {
	RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
	key_format.mutable_params()->set_hash_type(HashType::SHA384);
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
	IsOk());
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSha512Allowed) {
	RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
	key_format.mutable_params()->set_hash_type(HashType::SHA512);
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
	IsOk());
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSha1Disallowed) {
	RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
	key_format.mutable_params()->set_hash_type(HashType::SHA1);
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
	Not(IsOk()));
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatUnkownHashDisallowed) {
	RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
	key_format.mutable_params()->set_hash_type(HashType::UNKNOWN_HASH);
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
	Not(IsOk()));
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, ValidateKeyFormatSmallModulusDisallowed) {
	RsaSsaPkcs1KeyFormat key_format = ValidKeyFormat();
	key_format.set_modulus_size_in_bits(2047);
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKeyFormat(key_format),
	Not(IsOk()));
	}

	// Checks whether given key is compatible with the given format.
	void CheckNewKey(const RsaSsaPkcs1PrivateKey& private_key,
	const RsaSsaPkcs1KeyFormat& key_format) {
	RsaSsaPkcs1SignKeyManager key_manager;
	RsaSsaPkcs1PublicKey public_key = private_key.public_key();
	EXPECT_EQ(0, private_key.version());
	EXPECT_TRUE(private_key.has_public_key());
	EXPECT_EQ(0, public_key.version());
	EXPECT_GT(public_key.n().length(), 0);
	EXPECT_GT(public_key.e().length(), 0);
	EXPECT_EQ(public_key.params().SerializeAsString(),
	key_format.params().SerializeAsString());
	EXPECT_EQ(key_format.public_exponent(), public_key.e());
	util::StatusOr<internal::SslUniquePtr<BIGNUM>> n =
	internal::StringToBignum(public_key.n());
	ASSERT_THAT(n, IsOk());
	util::StatusOr<internal::SslUniquePtr<BIGNUM>> d =
	internal::StringToBignum(private_key.d());
	ASSERT_THAT(d, IsOk());
	util::StatusOr<internal::SslUniquePtr<BIGNUM>> p =
	internal::StringToBignum(private_key.p());
	ASSERT_THAT(p, IsOk());
	util::StatusOr<internal::SslUniquePtr<BIGNUM>> q =
	internal::StringToBignum(private_key.q());
	ASSERT_THAT(q, IsOk());
	util::StatusOr<internal::SslUniquePtr<BIGNUM>> dp =
	internal::StringToBignum(private_key.dp());
	ASSERT_THAT(dp, IsOk());
	util::StatusOr<internal::SslUniquePtr<BIGNUM>> dq =
	internal::StringToBignum(private_key.dq());
	ASSERT_THAT(dq, IsOk());
	internal::SslUniquePtr<BN_CTX> ctx(BN_CTX_new());

	// Check n = p * q.
	auto n_calc = internal::SslUniquePtr<BIGNUM>(BN_new());
	EXPECT_TRUE(BN_mul(n_calc.get(), p->get(), q->get(), ctx.get()));
	EXPECT_EQ(BN_cmp(n_calc.get(), n->get()), 0);

	// Check n size >= modulus_size_in_bits bit.
	EXPECT_GE(BN_num_bits(n->get()), key_format.modulus_size_in_bits());

	// dp = d mod (p - 1)
	auto pm1 = internal::SslUniquePtr<BIGNUM>(BN_dup(p->get()));
	EXPECT_TRUE(BN_sub_word(pm1.get(), 1));
	auto dp_calc = internal::SslUniquePtr<BIGNUM>(BN_new());
	EXPECT_TRUE(BN_mod(dp_calc.get(), d->get(), pm1.get(), ctx.get()));
	EXPECT_EQ(BN_cmp(dp_calc.get(), dp->get()), 0);

	// dq = d mod (q - 1)
	auto qm1 = internal::SslUniquePtr<BIGNUM>(BN_dup(q->get()));
	EXPECT_TRUE(BN_sub_word(qm1.get(), 1));
	auto dq_calc = internal::SslUniquePtr<BIGNUM>(BN_new());
	EXPECT_TRUE(BN_mod(dq_calc.get(), d->get(), qm1.get(), ctx.get()));
	EXPECT_EQ(BN_cmp(dq_calc.get(), dq->get()), 0);
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKey) {
	RsaSsaPkcs1KeyFormat key_format =
	CreateKeyFormat(HashType::SHA256, 3072, RSA_F4);
	StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
	RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
	ASSERT_THAT(private_key_or, IsOk());
	CheckNewKey(private_key_or.value(), key_format);
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeySmallKey) {
	RsaSsaPkcs1KeyFormat key_format =
	CreateKeyFormat(HashType::SHA256, 2048, RSA_F4);

	StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
	RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
	ASSERT_THAT(private_key_or, IsOk());
	CheckNewKey(private_key_or.value(), key_format);
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyLargeKey) {
	RsaSsaPkcs1KeyFormat key_format =
	CreateKeyFormat(HashType::SHA512, 4096, RSA_F4);

	StatusOr<RsaSsaPkcs1PrivateKey> private_key_or =
	RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
	ASSERT_THAT(private_key_or, IsOk());
	CheckNewKey(private_key_or.value(), key_format);
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyValid) {
	StatusOr<RsaSsaPkcs1PrivateKey> key_or =
	RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
	ASSERT_THAT(key_or, IsOk());
	EXPECT_THAT(RsaSsaPkcs1SignKeyManager().ValidateKey(key_or.value()), IsOk());
	}

	// Check that in a bunch of CreateKey calls all generated primes are distinct.
	TEST(RsaSsaPkcs1SignKeyManagerTest, CreateKeyAlwaysNewRsaPair) {
	absl::flat_hash_set<std::string> keys;
	// This test takes about a second per key.
	int num_generated_keys = 5;
	for (int i = 0; i < num_generated_keys; ++i) {
	StatusOr<RsaSsaPkcs1PrivateKey> key_or =
	RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
	ASSERT_THAT(key_or, IsOk());
	keys.insert(key_or.value().p());
	keys.insert(key_or.value().q());
	}
	EXPECT_THAT(keys, SizeIs(2 * num_generated_keys));
	}

	TEST(RsaSsaPkcs1SignKeyManagerTest, GetPublicKey) {
	StatusOr<RsaSsaPkcs1PrivateKey> key_or =
	RsaSsaPkcs1SignKeyManager().CreateKey(ValidKeyFormat());
	ASSERT_THAT(key_or, IsOk());
	StatusOr<RsaSsaPkcs1PublicKey> public_key_or =
	RsaSsaPkcs1SignKeyManager().GetPublicKey(key_or.value());
	ASSERT_THAT(public_key_or, IsOk());
	EXPECT_THAT(public_key_or.value().version(),
	Eq(key_or.value().public_key().version()));
	EXPECT_THAT(public_key_or.value().params().hash_type(),
	Eq(key_or.value().public_key().params().hash_type()));
	EXPECT_THAT(public_key_or.value().n(), Eq(key_or.value().public_key().n()));
	EXPECT_THAT(public_key_or.value().e(), Eq(key_or.value().public_key().e()));
	}

	TEST(EcdsaSignKeyManagerTest, Create) {
	RsaSsaPkcs1KeyFormat key_format =
	CreateKeyFormat(HashType::SHA256, 3072, RSA_F4);
	StatusOr<RsaSsaPkcs1PrivateKey> key_or =
	RsaSsaPkcs1SignKeyManager().CreateKey(key_format);
	ASSERT_THAT(key_or, IsOk());
	RsaSsaPkcs1PrivateKey key = key_or.value();

	auto signer_or = RsaSsaPkcs1SignKeyManager().GetPrimitive<PublicKeySign>(key);
	ASSERT_THAT(signer_or, IsOk());

	auto direct_verifier_or = subtle::RsaSsaPkcs1VerifyBoringSsl::New(
	{key.public_key().n(), key.public_key().e()}, {subtle::HashType::SHA256});
	ASSERT_THAT(direct_verifier_or, IsOk());

	std::string message = "Some message";
	EXPECT_THAT(direct_verifier_or.value()->Verify(
	signer_or.value()->Sign(message).value(), message),
	IsOk());
	}

	} // namespace
	} // namespace tink
	} // namespace crypto