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