crypto/ec_private_key_unittest.cc

   1 // Copyright (c) 2011 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 "crypto/ec_private_key.h"
   6
   7 #include <vector>
   8
   9 #include "base/macros.h"
  10 #include "base/memory/scoped_ptr.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 // Generate random private keys. Export, then re-import. We should get
  14 // back the same exact public key, and the private key should have the same
  15 // value and elliptic curve params.
  16 TEST(ECPrivateKeyUnitTest, InitRandomTest) {
  17   const std::string password1;
  18   const std::string password2 = "test";
  19
  20   scoped_ptr<crypto::ECPrivateKey> keypair1(crypto::ECPrivateKey::Create());
  21   scoped_ptr<crypto::ECPrivateKey> keypair2(crypto::ECPrivateKey::Create());
  22   ASSERT_TRUE(keypair1.get());
  23   ASSERT_TRUE(keypair2.get());
  24
  25   std::vector<uint8> key1value;
  26   std::vector<uint8> key2value;
  27   std::vector<uint8> key1params;
  28   std::vector<uint8> key2params;
  29   EXPECT_TRUE(keypair1->ExportValue(&key1value));
  30   EXPECT_TRUE(keypair2->ExportValue(&key2value));
  31   EXPECT_TRUE(keypair1->ExportECParams(&key1params));
  32   EXPECT_TRUE(keypair2->ExportECParams(&key2params));
  33
  34   std::vector<uint8> privkey1;
  35   std::vector<uint8> privkey2;
  36   std::vector<uint8> pubkey1;
  37   std::vector<uint8> pubkey2;
  38   std::string raw_pubkey1;
  39   std::string raw_pubkey2;
  40   ASSERT_TRUE(keypair1->ExportEncryptedPrivateKey(password1, 1, &privkey1));
  41   ASSERT_TRUE(keypair2->ExportEncryptedPrivateKey(password2, 1, &privkey2));
  42   EXPECT_TRUE(keypair1->ExportPublicKey(&pubkey1));
  43   EXPECT_TRUE(keypair2->ExportPublicKey(&pubkey2));
  44   EXPECT_TRUE(keypair1->ExportRawPublicKey(&raw_pubkey1));
  45   EXPECT_TRUE(keypair2->ExportRawPublicKey(&raw_pubkey2));
  46
  47   scoped_ptr<crypto::ECPrivateKey> keypair3(
  48       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
  49           password1, privkey1, pubkey1));
  50   scoped_ptr<crypto::ECPrivateKey> keypair4(
  51       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
  52           password2, privkey2, pubkey2));
  53   ASSERT_TRUE(keypair3.get());
  54   ASSERT_TRUE(keypair4.get());
  55
  56   std::vector<uint8> key3value;
  57   std::vector<uint8> key4value;
  58   std::vector<uint8> key3params;
  59   std::vector<uint8> key4params;
  60   EXPECT_TRUE(keypair3->ExportValue(&key3value));
  61   EXPECT_TRUE(keypair4->ExportValue(&key4value));
  62   EXPECT_TRUE(keypair3->ExportECParams(&key3params));
  63   EXPECT_TRUE(keypair4->ExportECParams(&key4params));
  64
  65   EXPECT_EQ(key1value, key3value);
  66   EXPECT_EQ(key2value, key4value);
  67   EXPECT_EQ(key1params, key3params);
  68   EXPECT_EQ(key2params, key4params);
  69
  70   std::vector<uint8> pubkey3;
  71   std::vector<uint8> pubkey4;
  72   std::string raw_pubkey3;
  73   std::string raw_pubkey4;
  74   EXPECT_TRUE(keypair3->ExportPublicKey(&pubkey3));
  75   EXPECT_TRUE(keypair4->ExportPublicKey(&pubkey4));
  76   EXPECT_TRUE(keypair3->ExportRawPublicKey(&raw_pubkey3));
  77   EXPECT_TRUE(keypair4->ExportRawPublicKey(&raw_pubkey4));
  78
  79   EXPECT_EQ(pubkey1, pubkey3);
  80   EXPECT_EQ(pubkey2, pubkey4);
  81   EXPECT_EQ(raw_pubkey1, raw_pubkey3);
  82   EXPECT_EQ(raw_pubkey2, raw_pubkey4);
  83 }
  84
  85 #if !defined(USE_OPENSSL)
  86 TEST(ECPrivateKeyUnitTest, Copy) {
  87   scoped_ptr<crypto::ECPrivateKey> keypair1(crypto::ECPrivateKey::Create());
  88   scoped_ptr<crypto::ECPrivateKey> keypair2(keypair1->Copy());
  89   ASSERT_TRUE(keypair1.get());
  90   ASSERT_TRUE(keypair2.get());
  91
  92   std::vector<uint8> key1value;
  93   std::vector<uint8> key2value;
  94   EXPECT_TRUE(keypair1->ExportValue(&key1value));
  95   EXPECT_TRUE(keypair2->ExportValue(&key2value));
  96   EXPECT_EQ(key1value, key2value);
  97
  98   std::vector<uint8> key1params;
  99   std::vector<uint8> key2params;
 100   EXPECT_TRUE(keypair1->ExportECParams(&key1params));
 101   EXPECT_TRUE(keypair2->ExportECParams(&key2params));
 102   EXPECT_EQ(key1params, key2params);
 103
 104   std::vector<uint8> pubkey1;
 105   std::vector<uint8> pubkey2;
 106   EXPECT_TRUE(keypair1->ExportPublicKey(&pubkey1));
 107   EXPECT_TRUE(keypair2->ExportPublicKey(&pubkey2));
 108   EXPECT_EQ(pubkey1, pubkey2);
 109
 110   std::string raw_pubkey1;
 111   std::string raw_pubkey2;
 112   EXPECT_TRUE(keypair1->ExportRawPublicKey(&raw_pubkey1));
 113   EXPECT_TRUE(keypair2->ExportRawPublicKey(&raw_pubkey2));
 114   EXPECT_EQ(raw_pubkey1, raw_pubkey2);
 115 }
 116 #endif  // !defined(USE_OPENSSL)
 117
 118 TEST(ECPrivateKeyUnitTest, BadPasswordTest) {
 119   const std::string password1;
 120   const std::string password2 = "test";
 121
 122   scoped_ptr<crypto::ECPrivateKey> keypair1(
 123       crypto::ECPrivateKey::Create());
 124   ASSERT_TRUE(keypair1.get());
 125
 126   std::vector<uint8> privkey1;
 127   std::vector<uint8> pubkey1;
 128   ASSERT_TRUE(keypair1->ExportEncryptedPrivateKey(
 129       password1, 1, &privkey1));
 130   ASSERT_TRUE(keypair1->ExportPublicKey(&pubkey1));
 131
 132   scoped_ptr<crypto::ECPrivateKey> keypair2(
 133       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
 134           password2, privkey1, pubkey1));
 135   ASSERT_FALSE(keypair2.get());
 136 }
 137
 138 TEST(ECPrivateKeyUnitTest, LoadNSSKeyTest) {
 139   static const unsigned char nss_key[] = {
 140       0x30, 0x81, 0xb8, 0x30, 0x23, 0x06, 0x0a, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 141       0x0d, 0x01, 0x0c, 0x01, 0x03, 0x30, 0x15, 0x04, 0x10, 0x3f, 0xac, 0xe9,
 142       0x38, 0xdb, 0x40, 0x6b, 0x26, 0x89, 0x09, 0x73, 0x18, 0x8d, 0x7f, 0x1c,
 143       0x82, 0x02, 0x01, 0x01, 0x04, 0x81, 0x90, 0x5e, 0x5e, 0x11, 0xef, 0xbb,
 144       0x7c, 0x4d, 0xec, 0xc0, 0xdc, 0xc7, 0x23, 0xd2, 0xc4, 0x77, 0xbc, 0xf4,
 145       0x5d, 0x59, 0x4c, 0x07, 0xc2, 0x8a, 0x26, 0xfa, 0x25, 0x1c, 0xaa, 0x42,
 146       0xed, 0xd0, 0xed, 0xbb, 0x5c, 0xe9, 0x13, 0x07, 0xaa, 0xdd, 0x52, 0x3c,
 147       0x65, 0x25, 0xbf, 0x94, 0x02, 0xaf, 0xd6, 0x97, 0xe9, 0x33, 0x00, 0x76,
 148       0x64, 0x4a, 0x73, 0xab, 0xfb, 0x99, 0x6e, 0x83, 0x12, 0x05, 0x86, 0x72,
 149       0x6c, 0xd5, 0xa4, 0xcf, 0xb1, 0xd5, 0x4d, 0x54, 0x87, 0x8b, 0x4b, 0x95,
 150       0x1d, 0xcd, 0xf3, 0xfe, 0xa8, 0xda, 0xe0, 0xb6, 0x72, 0x13, 0x3f, 0x2e,
 151       0x66, 0xe0, 0xb9, 0x2e, 0xfa, 0x69, 0x40, 0xbe, 0xd7, 0x67, 0x6e, 0x53,
 152       0x2b, 0x3f, 0x53, 0xe5, 0x39, 0x54, 0x77, 0xe1, 0x1d, 0xe6, 0x81, 0x92,
 153       0x58, 0x82, 0x14, 0xfb, 0x47, 0x85, 0x3c, 0xc3, 0xdf, 0xdd, 0xcc, 0x79,
 154       0x9f, 0x41, 0x83, 0x72, 0xf2, 0x0a, 0xe9, 0xe1, 0x2c, 0x12, 0xb0, 0xb0,
 155       0x0a, 0xb2, 0x1d, 0xca, 0x15, 0xb2, 0xca};
 156   static const unsigned char nss_pub_key[] = {
 157       0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 158       0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 159       0x42, 0x00, 0x04, 0x85, 0x92, 0x9e, 0x95, 0x5c, 0x6b, 0x9e, 0xd6, 0x1e,
 160       0xb8, 0x64, 0xea, 0xc2, 0xb3, 0xef, 0x18, 0xed, 0x3a, 0x5e, 0xc4, 0x5c,
 161       0x15, 0x37, 0x6a, 0xe9, 0xaa, 0x0b, 0x34, 0x03, 0xfd, 0xca, 0x83, 0x0f,
 162       0xd7, 0x5c, 0x5d, 0xc5, 0x53, 0x6e, 0xe5, 0xa9, 0x33, 0xd5, 0xcc, 0xab,
 163       0x53, 0x78, 0xdd, 0xd6, 0x12, 0x3a, 0x5e, 0xeb, 0xbf, 0xdf, 0x16, 0xd3,
 164       0x2c, 0x3b, 0xe8, 0xdb, 0x19, 0xfc, 0x5e};
 165
 166   scoped_ptr<crypto::ECPrivateKey> keypair_nss(
 167       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
 168           "",
 169           std::vector<uint8>(nss_key, nss_key + arraysize(nss_key)),
 170           std::vector<uint8>(nss_pub_key,
 171                              nss_pub_key + arraysize(nss_pub_key))));
 172
 173   EXPECT_TRUE(keypair_nss.get());
 174 }
 175
 176 // Although the plan is to transition from OpenSSL to NSS, ensure NSS can import
 177 // OpenSSL's format so that it is possible to rollback.
 178 TEST(ECPrivateKeyUnitTest, LoadOpenSSLKeyTest) {
 179   static const unsigned char openssl_key[] = {
 180       0x30, 0x81, 0xb0, 0x30, 0x1b, 0x06, 0x0a, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 181       0x0d, 0x01, 0x0c, 0x01, 0x03, 0x30, 0x0d, 0x04, 0x08, 0xb2, 0xfe, 0x68,
 182       0xc2, 0xea, 0x0f, 0x10, 0x9c, 0x02, 0x01, 0x01, 0x04, 0x81, 0x90, 0xe2,
 183       0xf6, 0x1c, 0xca, 0xad, 0x64, 0x30, 0xbf, 0x88, 0x04, 0x35, 0xe5, 0x0f,
 184       0x11, 0x49, 0x06, 0x01, 0x14, 0x33, 0x80, 0xa2, 0x78, 0x44, 0x5b, 0xaa,
 185       0x0d, 0xd7, 0x00, 0x36, 0x9d, 0x91, 0x97, 0x37, 0x20, 0x7b, 0x27, 0xc1,
 186       0xa0, 0xa2, 0x73, 0x06, 0x15, 0xdf, 0xc8, 0x13, 0x9b, 0xc9, 0x8c, 0x9c,
 187       0xce, 0x00, 0xd0, 0xc8, 0x42, 0xc1, 0xda, 0x2b, 0x07, 0x2b, 0x12, 0xa3,
 188       0xce, 0x10, 0x39, 0x7a, 0xf1, 0x55, 0x69, 0x8d, 0xa5, 0xc4, 0x2a, 0x00,
 189       0x0d, 0x94, 0xc6, 0xde, 0x6a, 0x3d, 0xb7, 0xe5, 0x6d, 0x59, 0x3e, 0x09,
 190       0xb5, 0xe3, 0x3e, 0xfc, 0x50, 0x56, 0xe9, 0x50, 0x42, 0x7c, 0xe7, 0xf0,
 191       0x19, 0xbd, 0x31, 0xa7, 0x85, 0x47, 0xb3, 0xe9, 0xb3, 0x50, 0x3c, 0xc9,
 192       0x32, 0x37, 0x1a, 0x93, 0x78, 0x48, 0x78, 0x82, 0xde, 0xad, 0x5c, 0xf2,
 193       0xcf, 0xf2, 0xbb, 0x2c, 0x44, 0x05, 0x7f, 0x4a, 0xf9, 0xb1, 0x2b, 0xdd,
 194       0x49, 0xf6, 0x7e, 0xd0, 0x42, 0xaa, 0x14, 0x3c, 0x24, 0x77, 0xb4};
 195   static const unsigned char openssl_pub_key[] = {
 196       0x30, 0x59, 0x30, 0x13, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02,
 197       0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07, 0x03,
 198       0x42, 0x00, 0x04, 0xb9, 0xda, 0x0d, 0x71, 0x60, 0xb3, 0x63, 0x28, 0x22,
 199       0x67, 0xe7, 0xe0, 0xa3, 0xf8, 0x00, 0x8e, 0x4c, 0x89, 0xed, 0x31, 0x34,
 200       0xf6, 0xdb, 0xc4, 0xfe, 0x0b, 0x5d, 0xe1, 0x11, 0x39, 0x49, 0xa6, 0x50,
 201       0xa8, 0xe3, 0x4a, 0xc0, 0x40, 0x88, 0xb8, 0x38, 0x3f, 0x56, 0xfb, 0x33,
 202       0x8d, 0xd4, 0x64, 0x91, 0xd6, 0x15, 0x77, 0x42, 0x27, 0xc5, 0xaa, 0x44,
 203       0xff, 0xab, 0x4d, 0xb5, 0x7e, 0x25, 0x3d};
 204
 205   scoped_ptr<crypto::ECPrivateKey> keypair_openssl(
 206       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
 207           "",
 208           std::vector<uint8>(openssl_key, openssl_key + arraysize(openssl_key)),
 209           std::vector<uint8>(openssl_pub_key,
 210                              openssl_pub_key + arraysize(openssl_pub_key))));
 211
 212   EXPECT_TRUE(keypair_openssl.get());
 213 }
 214
 215 // The Android code writes out Channel IDs differently from the NSS
 216 // implementation; the empty password is converted to "\0\0". The OpenSSL port
 217 // should support either.
 218 #if defined(USE_OPENSSL)
 219 TEST(ECPrivateKeyUnitTest, LoadOldOpenSSLKeyTest) {
 220   static const unsigned char openssl_key[] = {
 221       0x30, 0x82, 0x01, 0xa1, 0x30, 0x1b, 0x06, 0x0a, 0x2a, 0x86, 0x48, 0x86,
 222       0xf7, 0x0d, 0x01, 0x0c, 0x01, 0x03, 0x30, 0x0d, 0x04, 0x08, 0x86, 0xaa,
 223       0xd7, 0xdf, 0x3b, 0x91, 0x97, 0x60, 0x02, 0x01, 0x01, 0x04, 0x82, 0x01,
 224       0x80, 0xcb, 0x2a, 0x14, 0xaa, 0x4f, 0x38, 0x4c, 0xe1, 0x49, 0x00, 0xe2,
 225       0x1a, 0x3a, 0x75, 0x87, 0x7e, 0x3d, 0xea, 0x4d, 0x53, 0xd4, 0x46, 0x47,
 226       0x23, 0x8f, 0xa1, 0x72, 0x51, 0x92, 0x86, 0x8b, 0xeb, 0x53, 0xe6, 0x6a,
 227       0x0a, 0x6b, 0xb6, 0xa0, 0xdc, 0x0f, 0xdc, 0x20, 0xc3, 0x45, 0x85, 0xf1,
 228       0x95, 0x90, 0x5c, 0xf4, 0xfa, 0xee, 0x47, 0xaf, 0x35, 0xd0, 0xd0, 0xd3,
 229       0x14, 0xde, 0x0d, 0xca, 0x1b, 0xd3, 0xbb, 0x20, 0xec, 0x9d, 0x6a, 0xd4,
 230       0xc1, 0xce, 0x60, 0x81, 0xab, 0x0c, 0x72, 0x10, 0xfa, 0x28, 0x3c, 0xac,
 231       0x87, 0x7b, 0x82, 0x85, 0x00, 0xb8, 0x58, 0x9c, 0x07, 0xc4, 0x7d, 0xa9,
 232       0xc5, 0x94, 0x95, 0xf7, 0x23, 0x93, 0x3f, 0xed, 0xef, 0x92, 0x55, 0x25,
 233       0x74, 0xbb, 0xd3, 0xd1, 0x67, 0x3b, 0x3d, 0x5a, 0xfe, 0x84, 0xf8, 0x97,
 234       0x7d, 0x7c, 0x01, 0xc7, 0xd7, 0x0d, 0xf8, 0xc3, 0x6d, 0xd6, 0xf1, 0xaa,
 235       0x9d, 0x1f, 0x69, 0x97, 0x45, 0x06, 0xc4, 0x1c, 0x95, 0x3c, 0xe0, 0xef,
 236       0x11, 0xb2, 0xb3, 0x72, 0x91, 0x9e, 0x7d, 0x0f, 0x7f, 0xc8, 0xf6, 0x64,
 237       0x49, 0x5e, 0x3c, 0x53, 0x37, 0x79, 0x03, 0x1c, 0x3f, 0x29, 0x6c, 0x6b,
 238       0xea, 0x4c, 0x35, 0x9b, 0x6d, 0x1b, 0x59, 0x43, 0x4c, 0x14, 0x47, 0x2a,
 239       0x36, 0x39, 0x2a, 0xd8, 0x96, 0x90, 0xdc, 0xfc, 0xd2, 0xdd, 0x23, 0x0e,
 240       0x2c, 0xb3, 0x83, 0xf9, 0xf2, 0xe3, 0xe6, 0x99, 0x53, 0x57, 0x33, 0xc5,
 241       0x5f, 0xf9, 0xfd, 0x56, 0x0b, 0x32, 0xd4, 0xf3, 0x9d, 0x5b, 0x34, 0xe5,
 242       0x94, 0xbf, 0xb6, 0xc0, 0xce, 0xe1, 0x73, 0x5c, 0x02, 0x7a, 0x4c, 0xed,
 243       0xde, 0x23, 0x38, 0x89, 0x9f, 0xcd, 0x51, 0xf3, 0x90, 0x80, 0xd3, 0x4b,
 244       0x83, 0xd3, 0xee, 0xf2, 0x9e, 0x35, 0x91, 0xa5, 0xa3, 0xc0, 0x5c, 0xce,
 245       0xdb, 0xaa, 0x70, 0x1e, 0x1d, 0xc1, 0x44, 0xea, 0x3b, 0xa7, 0x5a, 0x11,
 246       0xd1, 0xf3, 0xf3, 0xd0, 0xf4, 0x5a, 0xc4, 0x99, 0xaf, 0x8d, 0xe2, 0xbc,
 247       0xa2, 0xb9, 0x3d, 0x86, 0x5e, 0xba, 0xa0, 0xdf, 0x78, 0x81, 0x7c, 0x54,
 248       0x31, 0xe3, 0x98, 0xb5, 0x46, 0xcb, 0x4d, 0x26, 0x4b, 0xf8, 0xac, 0x3a,
 249       0x54, 0x1b, 0x77, 0x5a, 0x18, 0xa5, 0x43, 0x0e, 0x14, 0xde, 0x7b, 0xb7,
 250       0x4e, 0x45, 0x99, 0x03, 0xd1, 0x3d, 0x18, 0xb2, 0x36, 0x00, 0x48, 0x07,
 251       0x72, 0xbb, 0x4f, 0x21, 0x25, 0x3e, 0xda, 0x25, 0x24, 0x5b, 0xc8, 0xa0,
 252       0x28, 0xd5, 0x9b, 0x96, 0x87, 0x07, 0x77, 0x84, 0xff, 0xd7, 0xac, 0x71,
 253       0xf6, 0x61, 0x63, 0x0b, 0xfb, 0x42, 0xfd, 0x52, 0xf4, 0xc4, 0x35, 0x0c,
 254       0xc2, 0xc1, 0x55, 0x22, 0x42, 0x2f, 0x13, 0x7d, 0x93, 0x27, 0xc8, 0x11,
 255       0x35, 0xc5, 0xe3, 0xc5, 0xaa, 0x15, 0x3c, 0xac, 0x30, 0xbc, 0x45, 0x16,
 256       0xed};
 257   static const unsigned char openssl_pub_key[] = {
 258       0x30, 0x82, 0x01, 0x4b, 0x30, 0x82, 0x01, 0x03, 0x06, 0x07, 0x2a, 0x86,
 259       0x48, 0xce, 0x3d, 0x02, 0x01, 0x30, 0x81, 0xf7, 0x02, 0x01, 0x01, 0x30,
 260       0x2c, 0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01, 0x02, 0x21,
 261       0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 262       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
 263       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x30, 0x5b, 0x04,
 264       0x20, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
 265       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
 266       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x04, 0x20, 0x5a,
 267       0xc6, 0x35, 0xd8, 0xaa, 0x3a, 0x93, 0xe7, 0xb3, 0xeb, 0xbd, 0x55, 0x76,
 268       0x98, 0x86, 0xbc, 0x65, 0x1d, 0x06, 0xb0, 0xcc, 0x53, 0xb0, 0xf6, 0x3b,
 269       0xce, 0x3c, 0x3e, 0x27, 0xd2, 0x60, 0x4b, 0x03, 0x15, 0x00, 0xc4, 0x9d,
 270       0x36, 0x08, 0x86, 0xe7, 0x04, 0x93, 0x6a, 0x66, 0x78, 0xe1, 0x13, 0x9d,
 271       0x26, 0xb7, 0x81, 0x9f, 0x7e, 0x90, 0x04, 0x41, 0x04, 0x6b, 0x17, 0xd1,
 272       0xf2, 0xe1, 0x2c, 0x42, 0x47, 0xf8, 0xbc, 0xe6, 0xe5, 0x63, 0xa4, 0x40,
 273       0xf2, 0x77, 0x03, 0x7d, 0x81, 0x2d, 0xeb, 0x33, 0xa0, 0xf4, 0xa1, 0x39,
 274       0x45, 0xd8, 0x98, 0xc2, 0x96, 0x4f, 0xe3, 0x42, 0xe2, 0xfe, 0x1a, 0x7f,
 275       0x9b, 0x8e, 0xe7, 0xeb, 0x4a, 0x7c, 0x0f, 0x9e, 0x16, 0x2b, 0xce, 0x33,
 276       0x57, 0x6b, 0x31, 0x5e, 0xce, 0xcb, 0xb6, 0x40, 0x68, 0x37, 0xbf, 0x51,
 277       0xf5, 0x02, 0x21, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
 278       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xbc, 0xe6, 0xfa, 0xad,
 279       0xa7, 0x17, 0x9e, 0x84, 0xf3, 0xb9, 0xca, 0xc2, 0xfc, 0x63, 0x25, 0x51,
 280       0x02, 0x01, 0x01, 0x03, 0x42, 0x00, 0x04, 0xde, 0x09, 0x08, 0x07, 0x03,
 281       0x2e, 0x8f, 0x37, 0x9a, 0xd5, 0xad, 0xe5, 0xc6, 0x9d, 0xd4, 0x63, 0xc7,
 282       0x4a, 0xe7, 0x20, 0xcb, 0x90, 0xa0, 0x1f, 0x18, 0x18, 0x72, 0xb5, 0x21,
 283       0x88, 0x38, 0xc0, 0xdb, 0xba, 0xf6, 0x99, 0xd8, 0xa5, 0x3b, 0x83, 0xe9,
 284       0xe3, 0xd5, 0x61, 0x99, 0x73, 0x42, 0xc6, 0x6c, 0xe8, 0x0a, 0x95, 0x40,
 285       0x41, 0x3b, 0x0d, 0x10, 0xa7, 0x4a, 0x93, 0xdb, 0x5a, 0xe7, 0xec};
 286
 287   scoped_ptr<crypto::ECPrivateKey> keypair_openssl(
 288       crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo(
 289           "",
 290           std::vector<uint8>(openssl_key, openssl_key + arraysize(openssl_key)),
 291           std::vector<uint8>(openssl_pub_key,
 292                              openssl_pub_key + arraysize(openssl_pub_key))));
 293
 294   EXPECT_TRUE(keypair_openssl.get());
 295 }
 296 #endif  // defined(USE_OPENSSL)