net/android/keystore_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <openssl/bn.h>
   6 #include <openssl/dsa.h>
   7 #include <openssl/ecdsa.h>
   8 #include <openssl/err.h>
   9 #include <openssl/evp.h>
  10 #include <openssl/pem.h>
  11 #include <openssl/rsa.h>
  12 #include <openssl/x509.h>
  13
  14 #include "base/android/build_info.h"
  15 #include "base/android/jni_android.h"
  16 #include "base/android/jni_array.h"
  17 #include "base/android/scoped_java_ref.h"
  18 #include "base/basictypes.h"
  19 #include "base/bind.h"
  20 #include "base/callback.h"
  21 #include "base/compiler_specific.h"
  22 #include "base/file_util.h"
  23 #include "base/files/file_path.h"
  24 #include "base/files/scoped_file.h"
  25 #include "base/strings/string_number_conversions.h"
  26 #include "base/strings/string_util.h"
  27 #include "crypto/openssl_util.h"
  28 #include "crypto/scoped_openssl_types.h"
  29 #include "jni/AndroidKeyStoreTestUtil_jni.h"
  30 #include "net/android/keystore.h"
  31 #include "net/android/keystore_openssl.h"
  32 #include "net/base/test_data_directory.h"
  33 #include "testing/gtest/include/gtest/gtest.h"
  34
  35 // Technical note:
  36 //
  37 // This source file not only checks that signing with
  38 // RawSignDigestWithPrivateKey() works correctly, it also verifies that
  39 // the generated signature matches 100% of what OpenSSL generates when
  40 // calling RSA_sign(NID_md5_sha1,...), DSA_sign(0, ...) or
  41 // ECDSA_sign(0, ...).
  42 //
  43 // That's crucial to ensure that this function can later be used to
  44 // implement client certificate support. More specifically, that it is
  45 // possible to create a custom EVP_PKEY that uses
  46 // RawSignDigestWithPrivateKey() internally to perform RSA/DSA/ECDSA
  47 // signing, as invoked by the OpenSSL code at
  48 // openssl/ssl/s3_clnt.c:ssl3_send_client_verify().
  49 //
  50 // For more details, read the comments in AndroidKeyStore.java.
  51 //
  52 // Finally, it also checks that using the EVP_PKEY generated with
  53 // GetOpenSSLPrivateKeyWrapper() works correctly.
  54
  55 namespace net {
  56 namespace android {
  57
  58 namespace {
  59
  60 typedef crypto::ScopedOpenSSL<PKCS8_PRIV_KEY_INFO,
  61                               PKCS8_PRIV_KEY_INFO_free>::Type
  62     ScopedPKCS8_PRIV_KEY_INFO;
  63
  64 typedef base::android::ScopedJavaLocalRef<jobject> ScopedJava;
  65
  66 JNIEnv* InitEnv() {
  67   JNIEnv* env = base::android::AttachCurrentThread();
  68   static bool inited = false;
  69   if (!inited) {
  70     RegisterNativesImpl(env);
  71     inited = true;
  72   }
  73   return env;
  74 }
  75
  76 // Returns true if running on an Android version older than 4.2
  77 bool IsOnAndroidOlderThan_4_2(void) {
  78   const int kAndroid42ApiLevel = 17;
  79   int level = base::android::BuildInfo::GetInstance()->sdk_int();
  80   return level < kAndroid42ApiLevel;
  81 }
  82
  83 // Implements the callback expected by ERR_print_errors_cb().
  84 // used by GetOpenSSLErrorString below.
  85 int openssl_print_error_callback(const char* msg, size_t msglen, void* u) {
  86   std::string* result = reinterpret_cast<std::string*>(u);
  87   result->append(msg, msglen);
  88   return 1;
  89 }
  90
  91 // Retrieves the OpenSSL error as a string
  92 std::string GetOpenSSLErrorString(void) {
  93   std::string result;
  94   ERR_print_errors_cb(openssl_print_error_callback, &result);
  95   return result;
  96 }
  97
  98 // Resize a string to |size| bytes of data, then return its data buffer
  99 // address cast as an 'unsigned char*', as expected by OpenSSL functions.
 100 // |str| the target string.
 101 // |size| the number of bytes to write into the string.
 102 // Return the string's new buffer in memory, as an 'unsigned char*'
 103 // pointer.
 104 unsigned char* OpenSSLWriteInto(std::string* str, size_t size) {
 105   return reinterpret_cast<unsigned char*>(WriteInto(str, size + 1));
 106 }
 107
 108 // Load a given private key file into an EVP_PKEY.
 109 // |filename| is the key file path.
 110 // Returns a new EVP_PKEY on success, NULL on failure.
 111 EVP_PKEY* ImportPrivateKeyFile(const char* filename) {
 112   // Load file in memory.
 113   base::FilePath certs_dir = GetTestCertsDirectory();
 114   base::FilePath file_path = certs_dir.AppendASCII(filename);
 115   base::ScopedFILE handle(base::OpenFile(file_path, "rb"));
 116   if (!handle.get()) {
 117     LOG(ERROR) << "Could not open private key file: " << filename;
 118     return NULL;
 119   }
 120   // Assume it is PEM_encoded. Load it as an EVP_PKEY.
 121   EVP_PKEY* pkey = PEM_read_PrivateKey(handle.get(), NULL, NULL, NULL);
 122   if (!pkey) {
 123     LOG(ERROR) << "Could not load public key file: " << filename
 124                << ", " << GetOpenSSLErrorString();
 125     return NULL;
 126   }
 127   return pkey;
 128 }
 129
 130 // Convert a private key into its PKCS#8 encoded representation.
 131 // |pkey| is the EVP_PKEY handle for the private key.
 132 // |pkcs8| will receive the PKCS#8 bytes.
 133 // Returns true on success, false otherwise.
 134 bool GetPrivateKeyPkcs8Bytes(const crypto::ScopedEVP_PKEY& pkey,
 135                              std::string* pkcs8) {
 136   // Convert to PKCS#8 object.
 137   ScopedPKCS8_PRIV_KEY_INFO p8_info(EVP_PKEY2PKCS8(pkey.get()));
 138   if (!p8_info.get()) {
 139     LOG(ERROR) << "Can't get PKCS#8 private key from EVP_PKEY: "
 140                << GetOpenSSLErrorString();
 141     return false;
 142   }
 143
 144   // Then convert it
 145   int len = i2d_PKCS8_PRIV_KEY_INFO(p8_info.get(), NULL);
 146   unsigned char* p = OpenSSLWriteInto(pkcs8, static_cast<size_t>(len));
 147   i2d_PKCS8_PRIV_KEY_INFO(p8_info.get(), &p);
 148   return true;
 149 }
 150
 151 bool ImportPrivateKeyFileAsPkcs8(const char* filename,
 152                                  std::string* pkcs8) {
 153   crypto::ScopedEVP_PKEY pkey(ImportPrivateKeyFile(filename));
 154   if (!pkey.get())
 155     return false;
 156   return GetPrivateKeyPkcs8Bytes(pkey, pkcs8);
 157 }
 158
 159 // Same as ImportPrivateKey, but for public ones.
 160 EVP_PKEY* ImportPublicKeyFile(const char* filename) {
 161   // Load file as PEM data.
 162   base::FilePath certs_dir = GetTestCertsDirectory();
 163   base::FilePath file_path = certs_dir.AppendASCII(filename);
 164   base::ScopedFILE handle(base::OpenFile(file_path, "rb"));
 165   if (!handle.get()) {
 166     LOG(ERROR) << "Could not open public key file: " << filename;
 167     return NULL;
 168   }
 169   EVP_PKEY* pkey = PEM_read_PUBKEY(handle.get(), NULL, NULL, NULL);
 170   if (!pkey) {
 171     LOG(ERROR) << "Could not load public key file: " << filename
 172                << ", " << GetOpenSSLErrorString();
 173     return NULL;
 174   }
 175   return pkey;
 176 }
 177
 178 // Retrieve a JNI local ref from encoded PKCS#8 data.
 179 ScopedJava GetPKCS8PrivateKeyJava(PrivateKeyType key_type,
 180                                   const std::string& pkcs8_key) {
 181   JNIEnv* env = InitEnv();
 182   base::android::ScopedJavaLocalRef<jbyteArray> bytes(
 183       base::android::ToJavaByteArray(
 184           env,
 185           reinterpret_cast<const uint8*>(pkcs8_key.data()),
 186           pkcs8_key.size()));
 187
 188   ScopedJava key(
 189       Java_AndroidKeyStoreTestUtil_createPrivateKeyFromPKCS8(
 190           env, key_type, bytes.obj()));
 191
 192   return key;
 193 }
 194
 195 const char kTestRsaKeyFile[] = "android-test-key-rsa.pem";
 196
 197 // The RSA test hash must be 36 bytes exactly.
 198 const char kTestRsaHash[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 199
 200 // Retrieve a JNI local ref for our test RSA key.
 201 ScopedJava GetRSATestKeyJava() {
 202   std::string key;
 203   if (!ImportPrivateKeyFileAsPkcs8(kTestRsaKeyFile, &key))
 204     return ScopedJava();
 205   return GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_RSA, key);
 206 }
 207
 208 const char kTestEcdsaKeyFile[] = "android-test-key-ecdsa.pem";
 209 const char kTestEcdsaPublicKeyFile[] = "android-test-key-ecdsa-public.pem";
 210
 211 // The test hash for ECDSA keys must be 20 bytes exactly.
 212 const char kTestEcdsaHash[] = "0123456789ABCDEFGHIJ";
 213
 214 // Retrieve a JNI local ref for our test ECDSA key.
 215 ScopedJava GetECDSATestKeyJava() {
 216   std::string key;
 217   if (!ImportPrivateKeyFileAsPkcs8(kTestEcdsaKeyFile, &key))
 218     return ScopedJava();
 219   return GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_ECDSA, key);
 220 }
 221
 222 // Call this function to verify that one message signed with our
 223 // test ECDSA private key is correct. Since ECDSA signing introduces
 224 // random elements in the signature, it is not possible to compare
 225 // signature bits directly. However, one can use the public key
 226 // to do the check.
 227 bool VerifyTestECDSASignature(const base::StringPiece& message,
 228                               const base::StringPiece& signature) {
 229   crypto::ScopedEVP_PKEY pkey(ImportPublicKeyFile(kTestEcdsaPublicKeyFile));
 230   if (!pkey.get())
 231     return false;
 232   crypto::ScopedEC_KEY pub_key(EVP_PKEY_get1_EC_KEY(pkey.get()));
 233   if (!pub_key.get()) {
 234     LOG(ERROR) << "Could not get ECDSA public key: "
 235                << GetOpenSSLErrorString();
 236     return false;
 237   }
 238
 239   const unsigned char* digest =
 240       reinterpret_cast<const unsigned char*>(message.data());
 241   int digest_len = static_cast<int>(message.size());
 242   const unsigned char* sigbuf =
 243       reinterpret_cast<const unsigned char*>(signature.data());
 244   int siglen = static_cast<int>(signature.size());
 245
 246   int ret = ECDSA_verify(
 247       0, digest, digest_len, sigbuf, siglen, pub_key.get());
 248   if (ret != 1) {
 249     LOG(ERROR) << "ECDSA_verify() failed: " << GetOpenSSLErrorString();
 250     return false;
 251   }
 252   return true;
 253 }
 254
 255 // Sign a message with OpenSSL, return the result as a string.
 256 // |message| is the message to be signed.
 257 // |openssl_key| is an OpenSSL EVP_PKEY to use.
 258 // |result| receives the result.
 259 // Returns true on success, false otherwise.
 260 bool SignWithOpenSSL(const base::StringPiece& message,
 261                      EVP_PKEY* openssl_key,
 262                      std::string* result) {
 263   const unsigned char* digest =
 264       reinterpret_cast<const unsigned char*>(message.data());
 265   unsigned int digest_len = static_cast<unsigned int>(message.size());
 266   std::string signature;
 267   size_t signature_size;
 268   size_t max_signature_size;
 269   int key_type = EVP_PKEY_id(openssl_key);
 270   switch (key_type) {
 271     case EVP_PKEY_RSA:
 272     {
 273       crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(openssl_key));
 274       if (!rsa.get()) {
 275         LOG(ERROR) << "Could not get RSA from EVP_PKEY: "
 276                    << GetOpenSSLErrorString();
 277         return false;
 278       }
 279       // With RSA, the signature will always be RSA_size() bytes.
 280       max_signature_size = static_cast<size_t>(RSA_size(rsa.get()));
 281       unsigned char* p = OpenSSLWriteInto(&signature,
 282                                           max_signature_size);
 283       unsigned int p_len = 0;
 284       int ret = RSA_sign(
 285           NID_md5_sha1, digest, digest_len, p, &p_len, rsa.get());
 286       if (ret != 1) {
 287         LOG(ERROR) << "RSA_sign() failed: " << GetOpenSSLErrorString();
 288         return false;
 289       }
 290       signature_size = static_cast<size_t>(p_len);
 291       break;
 292     }
 293     case EVP_PKEY_EC:
 294     {
 295       crypto::ScopedEC_KEY ecdsa(EVP_PKEY_get1_EC_KEY(openssl_key));
 296       if (!ecdsa.get()) {
 297         LOG(ERROR) << "Could not get EC_KEY from EVP_PKEY: "
 298                    << GetOpenSSLErrorString();
 299         return false;
 300       }
 301       // Note, the actual signature can be smaller than ECDSA_size()
 302       max_signature_size = ECDSA_size(ecdsa.get());
 303       unsigned char* p = OpenSSLWriteInto(&signature,
 304                                           max_signature_size);
 305       unsigned int p_len = 0;
 306       // Note: first parameter is ignored by function.
 307       int ret = ECDSA_sign(
 308           0, digest, digest_len, p, &p_len, ecdsa.get());
 309       if (ret != 1) {
 310         LOG(ERROR) << "ECDSA_sign() fialed: " << GetOpenSSLErrorString();
 311         return false;
 312       }
 313       signature_size = static_cast<size_t>(p_len);
 314       break;
 315     }
 316     default:
 317       LOG(WARNING) << "Invalid OpenSSL key type: " << key_type;
 318       return false;
 319   }
 320
 321   if (signature_size == 0) {
 322     LOG(ERROR) << "Signature is empty!";
 323     return false;
 324   }
 325   if (signature_size > max_signature_size) {
 326     LOG(ERROR) << "Signature size mismatch, actual " << signature_size
 327                 << ", expected <= " << max_signature_size;
 328     return false;
 329   }
 330   signature.resize(signature_size);
 331   result->swap(signature);
 332   return true;
 333 }
 334
 335 // Check that a generated signature for a given message matches
 336 // OpenSSL output byte-by-byte.
 337 // |message| is the input message.
 338 // |signature| is the generated signature for the message.
 339 // |openssl_key| is a raw EVP_PKEY for the same private key than the
 340 // one which was used to generate the signature.
 341 // Returns true on success, false otherwise.
 342 bool CompareSignatureWithOpenSSL(const base::StringPiece& message,
 343                                  const base::StringPiece& signature,
 344                                  EVP_PKEY* openssl_key) {
 345   std::string openssl_signature;
 346   SignWithOpenSSL(message, openssl_key, &openssl_signature);
 347
 348   if (signature.size() != openssl_signature.size()) {
 349     LOG(ERROR) << "Signature size mismatch, actual "
 350                << signature.size() << ", expected "
 351                << openssl_signature.size();
 352     return false;
 353   }
 354   for (size_t n = 0; n < signature.size(); ++n) {
 355     if (openssl_signature[n] != signature[n]) {
 356       LOG(ERROR) << "Signature byte mismatch at index " << n
 357                  << "actual " << signature[n] << ", expected "
 358                  << openssl_signature[n];
 359       LOG(ERROR) << "Actual signature  : "
 360                  << base::HexEncode(signature.data(), signature.size());
 361       LOG(ERROR) << "Expected signature: "
 362                  << base::HexEncode(openssl_signature.data(),
 363                                     openssl_signature.size());
 364       return false;
 365     }
 366   }
 367   return true;
 368 }
 369
 370 // Sign a message with our platform API.
 371 //
 372 // |android_key| is a JNI reference to the platform PrivateKey object.
 373 // |openssl_key| is a pointer to an OpenSSL key object for the exact
 374 // same key content.
 375 // |message| is a message.
 376 // |result| will receive the result.
 377 void DoKeySigning(jobject android_key,
 378                   EVP_PKEY* openssl_key,
 379                   const base::StringPiece& message,
 380                   std::string* result) {
 381   // First, get the platform signature.
 382   std::vector<uint8> android_signature;
 383   ASSERT_TRUE(
 384       RawSignDigestWithPrivateKey(android_key,
 385                                   message,
 386                                   &android_signature));
 387
 388   result->assign(
 389       reinterpret_cast<const char*>(&android_signature[0]),
 390       android_signature.size());
 391 }
 392
 393 // Sign a message with our OpenSSL EVP_PKEY wrapper around platform
 394 // APIS.
 395 //
 396 // |android_key| is a JNI reference to the platform PrivateKey object.
 397 // |openssl_key| is a pointer to an OpenSSL key object for the exact
 398 // same key content.
 399 // |message| is a message.
 400 // |result| will receive the result.
 401 void DoKeySigningWithWrapper(EVP_PKEY* wrapper_key,
 402                              EVP_PKEY* openssl_key,
 403                              const base::StringPiece& message,
 404                              std::string* result) {
 405   // First, get the platform signature.
 406   std::string wrapper_signature;
 407   SignWithOpenSSL(message, wrapper_key, &wrapper_signature);
 408   ASSERT_NE(0U, wrapper_signature.size());
 409
 410   result->assign(
 411       reinterpret_cast<const char*>(&wrapper_signature[0]),
 412       wrapper_signature.size());
 413 }
 414
 415 }  // namespace
 416
 417 TEST(AndroidKeyStore,GetRSAKeyModulus) {
 418   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 419   InitEnv();
 420
 421   // Load the test RSA key.
 422   crypto::ScopedEVP_PKEY pkey(ImportPrivateKeyFile(kTestRsaKeyFile));
 423   ASSERT_TRUE(pkey.get());
 424
 425   // Convert it to encoded PKCS#8 bytes.
 426   std::string pkcs8_data;
 427   ASSERT_TRUE(GetPrivateKeyPkcs8Bytes(pkey, &pkcs8_data));
 428
 429   // Create platform PrivateKey object from it.
 430   ScopedJava key_java = GetPKCS8PrivateKeyJava(PRIVATE_KEY_TYPE_RSA,
 431                                                 pkcs8_data);
 432   ASSERT_FALSE(key_java.is_null());
 433
 434   // Retrieve the corresponding modulus through JNI
 435   std::vector<uint8> modulus_java;
 436   ASSERT_TRUE(GetRSAKeyModulus(key_java.obj(), &modulus_java));
 437
 438   // Create an OpenSSL BIGNUM from it.
 439   crypto::ScopedBIGNUM bn(
 440       BN_bin2bn(reinterpret_cast<const unsigned char*>(&modulus_java[0]),
 441                 static_cast<int>(modulus_java.size()),
 442                 NULL));
 443   ASSERT_TRUE(bn.get());
 444
 445   // Compare it to the one in the RSA key, they must be identical.
 446   crypto::ScopedRSA rsa(EVP_PKEY_get1_RSA(pkey.get()));
 447   ASSERT_TRUE(rsa.get()) << GetOpenSSLErrorString();
 448
 449   ASSERT_EQ(0, BN_cmp(bn.get(), rsa.get()->n));
 450 }
 451
 452 TEST(AndroidKeyStore,GetPrivateKeyTypeRSA) {
 453   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 454
 455   ScopedJava rsa_key = GetRSATestKeyJava();
 456   ASSERT_FALSE(rsa_key.is_null());
 457   EXPECT_EQ(PRIVATE_KEY_TYPE_RSA,
 458             GetPrivateKeyType(rsa_key.obj()));
 459 }
 460
 461 TEST(AndroidKeyStore,SignWithPrivateKeyRSA) {
 462   ScopedJava rsa_key = GetRSATestKeyJava();
 463   ASSERT_FALSE(rsa_key.is_null());
 464
 465   if (IsOnAndroidOlderThan_4_2()) {
 466     LOG(INFO) << "This test can't run on Android < 4.2";
 467     return;
 468   }
 469
 470   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestRsaKeyFile));
 471   ASSERT_TRUE(openssl_key.get());
 472
 473   std::string message = kTestRsaHash;
 474   ASSERT_EQ(36U, message.size());
 475
 476   std::string signature;
 477   DoKeySigning(rsa_key.obj(), openssl_key.get(), message, &signature);
 478   ASSERT_TRUE(
 479       CompareSignatureWithOpenSSL(message, signature, openssl_key.get()));
 480   // All good.
 481 }
 482
 483 TEST(AndroidKeyStore,SignWithWrapperKeyRSA) {
 484   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 485
 486   ScopedJava rsa_key = GetRSATestKeyJava();
 487   ASSERT_FALSE(rsa_key.is_null());
 488
 489   crypto::ScopedEVP_PKEY wrapper_key(
 490       GetOpenSSLPrivateKeyWrapper(rsa_key.obj()));
 491   ASSERT_TRUE(wrapper_key.get() != NULL);
 492
 493   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestRsaKeyFile));
 494   ASSERT_TRUE(openssl_key.get());
 495
 496   // Check that RSA_size() works properly on the wrapper key.
 497   EXPECT_EQ(EVP_PKEY_size(openssl_key.get()),
 498             EVP_PKEY_size(wrapper_key.get()));
 499
 500   // Message size must be 36 for RSA_sign(NID_md5_sha1,...) to return
 501   // without an error.
 502   std::string message = kTestRsaHash;
 503   ASSERT_EQ(36U, message.size());
 504
 505   std::string signature;
 506   DoKeySigningWithWrapper(wrapper_key.get(),
 507                           openssl_key.get(),
 508                           message,
 509                           &signature);
 510   ASSERT_TRUE(
 511       CompareSignatureWithOpenSSL(message, signature, openssl_key.get()));
 512 }
 513
 514 TEST(AndroidKeyStore,GetPrivateKeyTypeECDSA) {
 515   crypto::OpenSSLErrStackTracer err_trace(FROM_HERE);
 516
 517   ScopedJava ecdsa_key = GetECDSATestKeyJava();
 518   ASSERT_FALSE(ecdsa_key.is_null());
 519   EXPECT_EQ(PRIVATE_KEY_TYPE_ECDSA,
 520             GetPrivateKeyType(ecdsa_key.obj()));
 521 }
 522
 523 TEST(AndroidKeyStore,SignWithPrivateKeyECDSA) {
 524   ScopedJava ecdsa_key = GetECDSATestKeyJava();
 525   ASSERT_FALSE(ecdsa_key.is_null());
 526
 527   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestEcdsaKeyFile));
 528   ASSERT_TRUE(openssl_key.get());
 529
 530   std::string message = kTestEcdsaHash;
 531   std::string signature;
 532   DoKeySigning(ecdsa_key.obj(), openssl_key.get(), message, &signature);
 533   ASSERT_TRUE(VerifyTestECDSASignature(message, signature));
 534 }
 535
 536 TEST(AndroidKeyStore, SignWithWrapperKeyECDSA) {
 537   crypto::OpenSSLErrStackTracer err_tracer(FROM_HERE);
 538
 539   ScopedJava ecdsa_key = GetECDSATestKeyJava();
 540   ASSERT_FALSE(ecdsa_key.is_null());
 541
 542   crypto::ScopedEVP_PKEY wrapper_key(
 543       GetOpenSSLPrivateKeyWrapper(ecdsa_key.obj()));
 544   ASSERT_TRUE(wrapper_key.get());
 545
 546   crypto::ScopedEVP_PKEY openssl_key(ImportPrivateKeyFile(kTestEcdsaKeyFile));
 547   ASSERT_TRUE(openssl_key.get());
 548
 549   // Check that ECDSA size works correctly on the wrapper.
 550   EXPECT_EQ(EVP_PKEY_size(openssl_key.get()),
 551             EVP_PKEY_size(wrapper_key.get()));
 552
 553   std::string message = kTestEcdsaHash;
 554   std::string signature;
 555   DoKeySigningWithWrapper(wrapper_key.get(),
 556                           openssl_key.get(),
 557                           message,
 558                           &signature);
 559   ASSERT_TRUE(VerifyTestECDSASignature(message, signature));
 560 }
 561
 562 }  // namespace android
 563 }  // namespace net