Report curve types in ECDSA SSLPrivateKeys.

net/ssl/ssl_platform_key_android_unittest.cc

 // Copyright (c) 2013 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 <openssl/bytestring.h>
 #include <openssl/digest.h>
 #include <openssl/ecdsa.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
 #include <openssl/pem.h>
@@ skipping 91 matching lines @@
           env, reinterpret_cast<const uint8_t*>(pkcs8_key.data()),
           pkcs8_key.size()));
 
   ScopedJava key(Java_AndroidKeyStoreTestUtil_createPrivateKeyFromPKCS8(
       env, key_type, bytes));
 
   return key;
 }
 
 const char kTestRsaKeyFile[] = "client_1.pk8";
+const char kTestRsaCertificateFile[] = "client_1.pem";
 
 // Retrieve a JNI local ref for our test RSA key.
 ScopedJava GetRSATestKeyJava() {
   std::string key;
   if (!ReadTestFile(kTestRsaKeyFile, &key))
     return ScopedJava();
   return GetPKCS8PrivateKeyJava(android::PRIVATE_KEY_TYPE_RSA, key);
 }
 
 const char kTestEcdsaKeyFile[] = "client_4.pk8";
@@ skipping 158 matching lines @@
     {"SHA-256", NID_sha256, SSLPrivateKey::Hash::SHA256},
     {"SHA-384", NID_sha384, SSLPrivateKey::Hash::SHA384},
     {"SHA-512", NID_sha512, SSLPrivateKey::Hash::SHA512},
 };
 
 }  // namespace
 
 TEST(SSLPlatformKeyAndroid, RSA) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
+  scoped_refptr<X509Certificate> cert =
+      ImportCertFromFile(GetTestCertsDirectory(), kTestRsaCertificateFile);
+  ASSERT_TRUE(cert);
   ScopedJava rsa_key = GetRSATestKeyJava();
   ASSERT_FALSE(rsa_key.is_null());
 
-  scoped_refptr<SSLPrivateKey> wrapper_key = WrapJavaPrivateKey(rsa_key);
+  scoped_refptr<SSLPrivateKey> wrapper_key =
+      WrapJavaPrivateKey(cert.get(), rsa_key);
   ASSERT_TRUE(wrapper_key);
 
   bssl::UniquePtr<EVP_PKEY> openssl_key = ImportPrivateKeyFile(kTestRsaKeyFile);
   ASSERT_TRUE(openssl_key);
 
   // Check that the wrapper key returns the correct length and type.
   EXPECT_EQ(SSLPrivateKey::Type::RSA, wrapper_key->GetType());
   EXPECT_EQ(static_cast<size_t>(EVP_PKEY_size(openssl_key.get())),
             wrapper_key->GetMaxSignatureLengthInBytes());
 
   // Test signing against each hash.
   for (const auto& hash : kHashes) {
     SCOPED_TRACE(hash.name);
 
     const EVP_MD* md = EVP_get_digestbynid(hash.nid);
     ASSERT_TRUE(md);
     std::string digest(EVP_MD_size(md), 'a');
 
     std::string signature;
     DoKeySigningWithWrapper(wrapper_key.get(), hash.hash, digest, &signature);
     ASSERT_TRUE(CompareSignatureWithOpenSSL(hash.nid, digest, signature,
                                             openssl_key.get()));
   }
 }
 
 TEST(SSLPlatformKeyAndroid, ECDSA) {
   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 
+  scoped_refptr<X509Certificate> cert =
+      ImportCertFromFile(GetTestCertsDirectory(), kTestEcdsaCertificateFile);
+  ASSERT_TRUE(cert);
   ScopedJava ecdsa_key = GetECDSATestKeyJava();
   ASSERT_FALSE(ecdsa_key.is_null());
 
-  scoped_refptr<SSLPrivateKey> wrapper_key = WrapJavaPrivateKey(ecdsa_key);
+  scoped_refptr<SSLPrivateKey> wrapper_key =
+      WrapJavaPrivateKey(cert.get(), ecdsa_key);
   ASSERT_TRUE(wrapper_key);
 
   bssl::UniquePtr<EVP_PKEY> openssl_key =
       ImportPrivateKeyFile(kTestEcdsaKeyFile);
   ASSERT_TRUE(openssl_key);
 
   // Check that the wrapper key returns the correct length and type.
-  EXPECT_EQ(SSLPrivateKey::Type::ECDSA, wrapper_key->GetType());
+  EXPECT_EQ(SSLPrivateKey::Type::ECDSA_P256, wrapper_key->GetType());
   EXPECT_EQ(static_cast<size_t>(EVP_PKEY_size(openssl_key.get())),
             wrapper_key->GetMaxSignatureLengthInBytes());
 
   // Test signing against each hash.
   for (const auto& hash : kHashes) {
     // ECDSA does not sign MD5-SHA1.
     if (hash.nid == NID_md5_sha1)
       continue;
 
     SCOPED_TRACE(hash.name);
     const EVP_MD* md = EVP_get_digestbynid(hash.nid);
     ASSERT_TRUE(md);
     std::string digest(EVP_MD_size(md), 'a');
 
     std::string signature;
     DoKeySigningWithWrapper(wrapper_key.get(), hash.hash, digest, &signature);
     ASSERT_TRUE(VerifyTestECDSASignature(digest, signature));
   }
 }
 
 }  // namespace net