crypto/rsa_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/rsa_private_key.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace {
  11
  12 const uint8 kTestPrivateKeyInfo[] = {
  13   0x30, 0x82, 0x02, 0x78, 0x02, 0x01, 0x00, 0x30,
  14   0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
  15   0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
  16   0x02, 0x62, 0x30, 0x82, 0x02, 0x5e, 0x02, 0x01,
  17   0x00, 0x02, 0x81, 0x81, 0x00, 0xb8, 0x7f, 0x2b,
  18   0x20, 0xdc, 0x7c, 0x9b, 0x0c, 0xdc, 0x51, 0x61,
  19   0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08,
  20   0x55, 0x84, 0xd5, 0x3a, 0xbf, 0x2b, 0xa4, 0x64,
  21   0x85, 0x7b, 0x0c, 0x04, 0x13, 0x3f, 0x8d, 0xf4,
  22   0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a,
  23   0xb0, 0x40, 0x53, 0x3a, 0xd7, 0x66, 0x09, 0x0f,
  24   0x9e, 0x36, 0x74, 0x30, 0xda, 0x8a, 0x31, 0x4f,
  25   0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17,
  26   0xde, 0x4e, 0xb9, 0x57, 0x5e, 0x7e, 0x0a, 0xe5,
  27   0xb2, 0x65, 0x7a, 0x89, 0x4e, 0xb6, 0x47, 0xff,
  28   0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85,
  29   0x84, 0x32, 0x33, 0xf3, 0x17, 0x49, 0xbf, 0xe9,
  30   0x96, 0xd0, 0xd6, 0x14, 0x6f, 0x13, 0x8d, 0xc5,
  31   0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18,
  32   0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93,
  33   0xe7, 0x1f, 0x0f, 0xe6, 0x0f, 0x02, 0x03, 0x01,
  34   0x00, 0x01, 0x02, 0x81, 0x80, 0x03, 0x61, 0x89,
  35   0x37, 0xcb, 0xf2, 0x98, 0xa0, 0xce, 0xb4, 0xcb,
  36   0x16, 0x13, 0xf0, 0xe6, 0xaf, 0x5c, 0xc5, 0xa7,
  37   0x69, 0x71, 0xca, 0xba, 0x8d, 0xe0, 0x4d, 0xdd,
  38   0xed, 0xb8, 0x48, 0x8b, 0x16, 0x93, 0x36, 0x95,
  39   0xc2, 0x91, 0x40, 0x65, 0x17, 0xbd, 0x7f, 0xd6,
  40   0xad, 0x9e, 0x30, 0x28, 0x46, 0xe4, 0x3e, 0xcc,
  41   0x43, 0x78, 0xf9, 0xfe, 0x1f, 0x33, 0x23, 0x1e,
  42   0x31, 0x12, 0x9d, 0x3c, 0xa7, 0x08, 0x82, 0x7b,
  43   0x7d, 0x25, 0x4e, 0x5e, 0x19, 0xa8, 0x9b, 0xed,
  44   0x86, 0xb2, 0xcb, 0x3c, 0xfe, 0x4e, 0xa1, 0xfa,
  45   0x62, 0x87, 0x3a, 0x17, 0xf7, 0x60, 0xec, 0x38,
  46   0x29, 0xe8, 0x4f, 0x34, 0x9f, 0x76, 0x9d, 0xee,
  47   0xa3, 0xf6, 0x85, 0x6b, 0x84, 0x43, 0xc9, 0x1e,
  48   0x01, 0xff, 0xfd, 0xd0, 0x29, 0x4c, 0xfa, 0x8e,
  49   0x57, 0x0c, 0xc0, 0x71, 0xa5, 0xbb, 0x88, 0x46,
  50   0x29, 0x5c, 0xc0, 0x4f, 0x01, 0x02, 0x41, 0x00,
  51   0xf5, 0x83, 0xa4, 0x64, 0x4a, 0xf2, 0xdd, 0x8c,
  52   0x2c, 0xed, 0xa8, 0xd5, 0x60, 0x5a, 0xe4, 0xc7,
  53   0xcc, 0x61, 0xcd, 0x38, 0x42, 0x20, 0xd3, 0x82,
  54   0x18, 0xf2, 0x35, 0x00, 0x72, 0x2d, 0xf7, 0x89,
  55   0x80, 0x67, 0xb5, 0x93, 0x05, 0x5f, 0xdd, 0x42,
  56   0xba, 0x16, 0x1a, 0xea, 0x15, 0xc6, 0xf0, 0xb8,
  57   0x8c, 0xbc, 0xbf, 0x54, 0x9e, 0xf1, 0xc1, 0xb2,
  58   0xb3, 0x8b, 0xb6, 0x26, 0x02, 0x30, 0xc4, 0x81,
  59   0x02, 0x41, 0x00, 0xc0, 0x60, 0x62, 0x80, 0xe1,
  60   0x22, 0x78, 0xf6, 0x9d, 0x83, 0x18, 0xeb, 0x72,
  61   0x45, 0xd7, 0xc8, 0x01, 0x7f, 0xa9, 0xca, 0x8f,
  62   0x7d, 0xd6, 0xb8, 0x31, 0x2b, 0x84, 0x7f, 0x62,
  63   0xd9, 0xa9, 0x22, 0x17, 0x7d, 0x06, 0x35, 0x6c,
  64   0xf3, 0xc1, 0x94, 0x17, 0x85, 0x5a, 0xaf, 0x9c,
  65   0x5c, 0x09, 0x3c, 0xcf, 0x2f, 0x44, 0x9d, 0xb6,
  66   0x52, 0x68, 0x5f, 0xf9, 0x59, 0xc8, 0x84, 0x2b,
  67   0x39, 0x22, 0x8f, 0x02, 0x41, 0x00, 0xb2, 0x04,
  68   0xe2, 0x0e, 0x56, 0xca, 0x03, 0x1a, 0xc0, 0xf9,
  69   0x12, 0x92, 0xa5, 0x6b, 0x42, 0xb8, 0x1c, 0xda,
  70   0x4d, 0x93, 0x9d, 0x5f, 0x6f, 0xfd, 0xc5, 0x58,
  71   0xda, 0x55, 0x98, 0x74, 0xfc, 0x28, 0x17, 0x93,
  72   0x1b, 0x75, 0x9f, 0x50, 0x03, 0x7f, 0x7e, 0xae,
  73   0xc8, 0x95, 0x33, 0x75, 0x2c, 0xd6, 0xa4, 0x35,
  74   0xb8, 0x06, 0x03, 0xba, 0x08, 0x59, 0x2b, 0x17,
  75   0x02, 0xdc, 0x4c, 0x7a, 0x50, 0x01, 0x02, 0x41,
  76   0x00, 0x9d, 0xdb, 0x39, 0x59, 0x09, 0xe4, 0x30,
  77   0xa0, 0x24, 0xf5, 0xdb, 0x2f, 0xf0, 0x2f, 0xf1,
  78   0x75, 0x74, 0x0d, 0x5e, 0xb5, 0x11, 0x73, 0xb0,
  79   0x0a, 0xaa, 0x86, 0x4c, 0x0d, 0xff, 0x7e, 0x1d,
  80   0xb4, 0x14, 0xd4, 0x09, 0x91, 0x33, 0x5a, 0xfd,
  81   0xa0, 0x58, 0x80, 0x9b, 0xbe, 0x78, 0x2e, 0x69,
  82   0x82, 0x15, 0x7c, 0x72, 0xf0, 0x7b, 0x18, 0x39,
  83   0xff, 0x6e, 0xeb, 0xc6, 0x86, 0xf5, 0xb4, 0xc7,
  84   0x6f, 0x02, 0x41, 0x00, 0x8d, 0x1a, 0x37, 0x0f,
  85   0x76, 0xc4, 0x82, 0xfa, 0x5c, 0xc3, 0x79, 0x35,
  86   0x3e, 0x70, 0x8a, 0xbf, 0x27, 0x49, 0xb0, 0x99,
  87   0x63, 0xcb, 0x77, 0x5f, 0xa8, 0x82, 0x65, 0xf6,
  88   0x03, 0x52, 0x51, 0xf1, 0xae, 0x2e, 0x05, 0xb3,
  89   0xc6, 0xa4, 0x92, 0xd1, 0xce, 0x6c, 0x72, 0xfb,
  90   0x21, 0xb3, 0x02, 0x87, 0xe4, 0xfd, 0x61, 0xca,
  91   0x00, 0x42, 0x19, 0xf0, 0xda, 0x5a, 0x53, 0xe3,
  92   0xb1, 0xc5, 0x15, 0xf3
  93 };
  94
  95 }  // namespace
  96
  97 // Generate random private keys with two different sizes. Reimport, then
  98 // export them again. We should get back the same exact bytes.
  99 TEST(RSAPrivateKeyUnitTest, InitRandomTest) {
 100   scoped_ptr<crypto::RSAPrivateKey> keypair1(
 101       crypto::RSAPrivateKey::Create(1024));
 102   scoped_ptr<crypto::RSAPrivateKey> keypair2(
 103       crypto::RSAPrivateKey::Create(2048));
 104   ASSERT_TRUE(keypair1.get());
 105   ASSERT_TRUE(keypair2.get());
 106
 107   std::vector<uint8> privkey1;
 108   std::vector<uint8> privkey2;
 109   std::vector<uint8> pubkey1;
 110   std::vector<uint8> pubkey2;
 111
 112   ASSERT_TRUE(keypair1->ExportPrivateKey(&privkey1));
 113   ASSERT_TRUE(keypair2->ExportPrivateKey(&privkey2));
 114   ASSERT_TRUE(keypair1->ExportPublicKey(&pubkey1));
 115   ASSERT_TRUE(keypair2->ExportPublicKey(&pubkey2));
 116
 117   scoped_ptr<crypto::RSAPrivateKey> keypair3(
 118       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(privkey1));
 119   scoped_ptr<crypto::RSAPrivateKey> keypair4(
 120       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(privkey2));
 121   ASSERT_TRUE(keypair3.get());
 122   ASSERT_TRUE(keypair4.get());
 123
 124   std::vector<uint8> privkey3;
 125   std::vector<uint8> privkey4;
 126   ASSERT_TRUE(keypair3->ExportPrivateKey(&privkey3));
 127   ASSERT_TRUE(keypair4->ExportPrivateKey(&privkey4));
 128
 129   ASSERT_EQ(privkey1.size(), privkey3.size());
 130   ASSERT_EQ(privkey2.size(), privkey4.size());
 131   ASSERT_TRUE(0 == memcmp(&privkey1.front(), &privkey3.front(),
 132                           privkey1.size()));
 133   ASSERT_TRUE(0 == memcmp(&privkey2.front(), &privkey4.front(),
 134                           privkey2.size()));
 135 }
 136
 137 // Test Copy() method.
 138 TEST(RSAPrivateKeyUnitTest, CopyTest) {
 139   std::vector<uint8> input(
 140       kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
 141
 142   scoped_ptr<crypto::RSAPrivateKey> key(
 143       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
 144
 145   scoped_ptr<crypto::RSAPrivateKey> key_copy(key->Copy());
 146   ASSERT_TRUE(key_copy.get());
 147
 148   std::vector<uint8> privkey_copy;
 149   ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy));
 150   ASSERT_EQ(input, privkey_copy);
 151 }
 152
 153 // Test that CreateFromPrivateKeyInfo fails if there is extra data after the RSA
 154 // key.
 155 TEST(RSAPrivateKeyUnitTest, ExtraData) {
 156   std::vector<uint8> input(
 157       kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
 158   input.push_back(0);
 159
 160   scoped_ptr<crypto::RSAPrivateKey> key(
 161       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
 162
 163   // Import should fail.
 164   EXPECT_FALSE(key);
 165 }
 166
 167 TEST(RSAPrivateKeyUnitTest, NotRsaKey) {
 168   // Defines a valid P-256 private key.
 169   const uint8 kTestEcPrivateKeyInfo[] = {
 170       0x30, 0x81, 0x87, 0x02, 0x01, 0x00, 0x30, 0x13, 0x06, 0x07, 0x2A, 0x86,
 171       0x48, 0xCE, 0x3D, 0x02, 0x01, 0x06, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D,
 172       0x03, 0x01, 0x07, 0x04, 0x6D, 0x30, 0x6B, 0x02, 0x01, 0x01, 0x04, 0x20,
 173       0x1F, 0xE3, 0x39, 0x50, 0xC5, 0xF4, 0x61, 0x12, 0x4A, 0xE9, 0x92, 0xC2,
 174       0xBD, 0xFD, 0xF1, 0xC7, 0x3B, 0x16, 0x15, 0xF5, 0x71, 0xBD, 0x56, 0x7E,
 175       0x60, 0xD1, 0x9A, 0xA1, 0xF4, 0x8C, 0xDF, 0x42, 0xA1, 0x44, 0x03, 0x42,
 176       0x00, 0x04, 0x7C, 0x11, 0x0C, 0x66, 0xDC, 0xFD, 0xA8, 0x07, 0xF6, 0xE6,
 177       0x9E, 0x45, 0xDD, 0xB3, 0xC7, 0x4F, 0x69, 0xA1, 0x48, 0x4D, 0x20, 0x3E,
 178       0x8D, 0xC5, 0xAD, 0xA8, 0xE9, 0xA9, 0xDD, 0x7C, 0xB3, 0xC7, 0x0D, 0xF4,
 179       0x48, 0x98, 0x6E, 0x51, 0xBD, 0xE5, 0xD1, 0x57, 0x6F, 0x99, 0x90, 0x1F,
 180       0x9C, 0x2C, 0x6A, 0x80, 0x6A, 0x47, 0xFD, 0x90, 0x76, 0x43, 0xA7, 0x2B,
 181       0x83, 0x55, 0x97, 0xEF, 0xC8, 0xC6
 182   };
 183
 184   std::vector<uint8> input(
 185       kTestEcPrivateKeyInfo,
 186       kTestEcPrivateKeyInfo + sizeof(kTestEcPrivateKeyInfo));
 187
 188   scoped_ptr<crypto::RSAPrivateKey> key(
 189       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
 190
 191   // Import should fail as the given PKCS8 bytes were for an EC key not RSA key.
 192   EXPECT_FALSE(key);
 193 }
 194
 195 // Verify that generated public keys look good. This test data was generated
 196 // with the openssl command line tool.
 197 TEST(RSAPrivateKeyUnitTest, PublicKeyTest) {
 198   const uint8 expected_public_key_info[] = {
 199     0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 200     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
 201     0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81,
 202     0x89, 0x02, 0x81, 0x81, 0x00, 0xb8, 0x7f, 0x2b,
 203     0x20, 0xdc, 0x7c, 0x9b, 0x0c, 0xdc, 0x51, 0x61,
 204     0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08,
 205     0x55, 0x84, 0xd5, 0x3a, 0xbf, 0x2b, 0xa4, 0x64,
 206     0x85, 0x7b, 0x0c, 0x04, 0x13, 0x3f, 0x8d, 0xf4,
 207     0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a,
 208     0xb0, 0x40, 0x53, 0x3a, 0xd7, 0x66, 0x09, 0x0f,
 209     0x9e, 0x36, 0x74, 0x30, 0xda, 0x8a, 0x31, 0x4f,
 210     0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17,
 211     0xde, 0x4e, 0xb9, 0x57, 0x5e, 0x7e, 0x0a, 0xe5,
 212     0xb2, 0x65, 0x7a, 0x89, 0x4e, 0xb6, 0x47, 0xff,
 213     0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85,
 214     0x84, 0x32, 0x33, 0xf3, 0x17, 0x49, 0xbf, 0xe9,
 215     0x96, 0xd0, 0xd6, 0x14, 0x6f, 0x13, 0x8d, 0xc5,
 216     0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18,
 217     0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93,
 218     0xe7, 0x1f, 0x0f, 0xe6, 0x0f, 0x02, 0x03, 0x01,
 219     0x00, 0x01
 220   };
 221
 222   std::vector<uint8> input(
 223       kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
 224
 225   scoped_ptr<crypto::RSAPrivateKey> key(
 226       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
 227   ASSERT_TRUE(key.get());
 228
 229   std::vector<uint8> output;
 230   ASSERT_TRUE(key->ExportPublicKey(&output));
 231
 232   ASSERT_TRUE(
 233       memcmp(expected_public_key_info, &output.front(), output.size()) == 0);
 234 }
 235
 236 // These two test keys each contain an integer that has 0x00 for its most
 237 // significant byte. When encoded as ASN.1, this byte is dropped and there are
 238 // two interesting sub-cases. When the sign bit of the integer is set, an extra
 239 // null byte is added back to force the encoded value to be positive. When the
 240 // sign bit is not set, the encoded integer is just left shorter than usual.
 241 // See also: http://code.google.com/p/chromium/issues/detail?id=14877.
 242 //
 243 // Before we were handling this correctly, we would see one of two failures:
 244 // * RSAPrivateKey::CreateFromPrivateKeyInfo would return null because the
 245 //   underlying windows API failed to import the key.
 246 // * The import would succeed, but incorrectly interpret the data. On export,
 247 //   the key would contain different values.
 248 //
 249 // This test case verifies these two failures modes don't occur.
 250 TEST(RSAPrivateKeyUnitTest, ShortIntegers) {
 251   const uint8 short_integer_with_high_bit[] = {
 252     0x30, 0x82, 0x02, 0x77, 0x02, 0x01, 0x00, 0x30,
 253     0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 254     0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 255     0x02, 0x61, 0x30, 0x82, 0x02, 0x5d, 0x02, 0x01,
 256     0x00, 0x02, 0x81, 0x81, 0x00, 0x92, 0x59, 0x32,
 257     0x7d, 0x8e, 0xaf, 0x2e, 0xd5, 0xb2, 0x5c, 0x67,
 258     0xc8, 0x7d, 0x48, 0xb7, 0x84, 0x12, 0xd0, 0x76,
 259     0xda, 0xe1, 0xa3, 0x1e, 0x40, 0x01, 0x14, 0x5c,
 260     0xef, 0x26, 0x6e, 0x28, 0xa2, 0xf7, 0xa5, 0xb4,
 261     0x02, 0x37, 0xd0, 0x53, 0x10, 0xcb, 0x7c, 0x6a,
 262     0xf4, 0x53, 0x9f, 0xb8, 0xe0, 0x83, 0x93, 0xd1,
 263     0x19, 0xd8, 0x28, 0xd1, 0xd1, 0xd8, 0x87, 0x8f,
 264     0x92, 0xfd, 0x73, 0xc0, 0x4d, 0x3e, 0x07, 0x22,
 265     0x1f, 0xc1, 0x20, 0xb0, 0x70, 0xb2, 0x3b, 0xea,
 266     0xb1, 0xe5, 0x0a, 0xfd, 0x56, 0x49, 0x5e, 0x39,
 267     0x90, 0x91, 0xce, 0x04, 0x83, 0x29, 0xaa, 0xfd,
 268     0x12, 0xa4, 0x42, 0x26, 0x6c, 0x6e, 0x79, 0x70,
 269     0x77, 0x03, 0xb2, 0x07, 0x01, 0x3d, 0x85, 0x81,
 270     0x95, 0x9e, 0xda, 0x5a, 0xa3, 0xf4, 0x2d, 0x38,
 271     0x04, 0x58, 0xf5, 0x6b, 0xc9, 0xf1, 0xb5, 0x65,
 272     0xfe, 0x66, 0x0d, 0xa2, 0xd5, 0x02, 0x03, 0x01,
 273     0x00, 0x01, 0x02, 0x81, 0x80, 0x5e, 0x01, 0x5f,
 274     0xb6, 0x59, 0x1d, 0xdc, 0x36, 0xb6, 0x60, 0x36,
 275     0xe6, 0x08, 0xdb, 0xd9, 0xcd, 0xc3, 0x8c, 0x16,
 276     0x9c, 0x98, 0x8d, 0x7f, 0xd3, 0xdb, 0x1d, 0xaa,
 277     0x68, 0x8f, 0xc5, 0xf8, 0xe2, 0x5d, 0xb3, 0x19,
 278     0xc2, 0xc6, 0xf9, 0x51, 0x32, 0x1b, 0x93, 0x6a,
 279     0xdc, 0x50, 0x8e, 0xeb, 0x61, 0x84, 0x03, 0x42,
 280     0x30, 0x98, 0xb1, 0xf7, 0xbd, 0x14, 0x9a, 0x57,
 281     0x36, 0x33, 0x09, 0xd4, 0x3e, 0x90, 0xda, 0xef,
 282     0x09, 0x6e, 0xef, 0x49, 0xb6, 0x60, 0x68, 0x5e,
 283     0x54, 0x17, 0x25, 0x5b, 0x37, 0xe3, 0x35, 0x63,
 284     0x5b, 0x60, 0x3c, 0xbd, 0x50, 0xdf, 0x46, 0x43,
 285     0x08, 0xa4, 0x71, 0x21, 0xf1, 0x30, 0x71, 0xdc,
 286     0xda, 0xd7, 0x6f, 0xd2, 0x18, 0xbd, 0x39, 0xf1,
 287     0xe1, 0xbe, 0xa8, 0x8d, 0x62, 0xdf, 0xa2, 0x3e,
 288     0xb6, 0x15, 0x26, 0xb6, 0x57, 0xbd, 0x63, 0xdb,
 289     0xc1, 0x91, 0xec, 0xb8, 0x01, 0x02, 0x41, 0x00,
 290     0xc6, 0x1a, 0x06, 0x48, 0xf2, 0x12, 0x1c, 0x9f,
 291     0x74, 0x20, 0x5c, 0x85, 0xa2, 0xda, 0xe5, 0x62,
 292     0x96, 0x8d, 0x22, 0x7b, 0x78, 0x73, 0xea, 0xbb,
 293     0x9f, 0x59, 0x42, 0x13, 0x15, 0xc8, 0x11, 0x50,
 294     0x6c, 0x55, 0xf6, 0xdf, 0x8b, 0xfe, 0xc7, 0xdd,
 295     0xa8, 0xca, 0x54, 0x41, 0xe8, 0xce, 0xbe, 0x7d,
 296     0xbd, 0xe2, 0x13, 0x4b, 0x5b, 0x61, 0xeb, 0x69,
 297     0x6c, 0xb1, 0x9b, 0x28, 0x68, 0x5b, 0xd6, 0x01,
 298     0x02, 0x41, 0x00, 0xbd, 0x1e, 0xfe, 0x51, 0x99,
 299     0xb6, 0xe3, 0x84, 0xfe, 0xf1, 0x9e, 0xfd, 0x9c,
 300     0xe7, 0x86, 0x43, 0x68, 0x7f, 0x2f, 0x6a, 0x2a,
 301     0x4c, 0xae, 0xa6, 0x41, 0x1c, 0xf0, 0x10, 0x37,
 302     0x54, 0x23, 0xba, 0x05, 0x0d, 0x18, 0x27, 0x8d,
 303     0xb8, 0xe4, 0x8f, 0xf2, 0x25, 0x73, 0x8a, 0xd7,
 304     0x05, 0x98, 0x6b, 0x3d, 0x55, 0xb7, 0x6f, 0x7c,
 305     0xec, 0x77, 0x61, 0x54, 0x7b, 0xb6, 0x6b, 0x31,
 306     0xec, 0x94, 0xd5, 0x02, 0x41, 0x00, 0x90, 0xa2,
 307     0xa5, 0x9e, 0x12, 0xa7, 0x68, 0xa0, 0x7e, 0xdf,
 308     0xb5, 0xcd, 0x98, 0x26, 0xab, 0xbd, 0xbc, 0x5f,
 309     0xd5, 0x22, 0x42, 0xc2, 0x97, 0x4a, 0x5f, 0x40,
 310     0x82, 0xfe, 0x7e, 0x33, 0xb1, 0x78, 0x7f, 0x70,
 311     0x90, 0x2b, 0x8d, 0x01, 0xfb, 0x18, 0xfa, 0x48,
 312     0xa7, 0x15, 0xec, 0x0d, 0x2e, 0x85, 0x8d, 0xe2,
 313     0x86, 0xe5, 0xc9, 0x15, 0x88, 0x14, 0x53, 0xd8,
 314     0xa4, 0x88, 0xef, 0x10, 0xc6, 0x01, 0x02, 0x41,
 315     0x00, 0xba, 0xe4, 0xaf, 0x14, 0xfa, 0xdf, 0xf6,
 316     0xd5, 0xce, 0x8f, 0xfe, 0xbb, 0xc8, 0x5c, 0x30,
 317     0x9d, 0xda, 0xdd, 0x9d, 0x80, 0xc0, 0x0e, 0x89,
 318     0xa5, 0xb8, 0xc1, 0x1d, 0x28, 0x19, 0x55, 0x67,
 319     0xfd, 0x03, 0xd2, 0xdd, 0xe4, 0xf0, 0xb4, 0x20,
 320     0x03, 0x74, 0x9b, 0xb8, 0x24, 0x23, 0xbb, 0xde,
 321     0xd5, 0x53, 0x86, 0xaa, 0xc1, 0x5d, 0x65, 0xdd,
 322     0xcf, 0xec, 0x8a, 0x59, 0x4a, 0x73, 0xca, 0xc5,
 323     0x85, 0x02, 0x40, 0x00, 0xc4, 0x5e, 0x8d, 0xa4,
 324     0xea, 0xbb, 0x6a, 0x9b, 0xe6, 0x3a, 0x4d, 0xc1,
 325     0xdb, 0xe5, 0x52, 0x38, 0xf9, 0x59, 0x91, 0x2d,
 326     0x90, 0x82, 0xe3, 0x31, 0x1b, 0x48, 0xb7, 0x42,
 327     0xfa, 0x1d, 0x83, 0xd5, 0x3d, 0x02, 0xc2, 0x12,
 328     0x71, 0x10, 0x3a, 0xbd, 0x92, 0x8f, 0x9b, 0xa2,
 329     0x6b, 0x2d, 0x21, 0xa4, 0x65, 0xe9, 0xfa, 0x8c,
 330     0x30, 0x2a, 0x89, 0xce, 0xd0, 0xa7, 0x67, 0xd8,
 331     0x45, 0x84, 0xb0
 332   };
 333
 334   const uint8 short_integer_without_high_bit[] = {
 335     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30,
 336     0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 337     0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 338     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01,
 339     0x00, 0x02, 0x81, 0x81, 0x00, 0xc3, 0x9e, 0x8d,
 340     0xc4, 0x6d, 0x38, 0xe8, 0x0e, 0x9f, 0x84, 0x03,
 341     0x40, 0x8e, 0x81, 0x2e, 0x56, 0x67, 0x78, 0x11,
 342     0x85, 0x27, 0x81, 0x52, 0xf2, 0x1b, 0x3e, 0x5b,
 343     0xf8, 0xab, 0xfc, 0xaf, 0xca, 0x5c, 0x26, 0xd5,
 344     0xfa, 0xd4, 0x55, 0x50, 0x38, 0xb9, 0x9d, 0x89,
 345     0x92, 0x7e, 0x34, 0xcf, 0x37, 0x82, 0x48, 0x2d,
 346     0xaa, 0xc4, 0x6a, 0x0e, 0x93, 0xea, 0xad, 0x8a,
 347     0x33, 0xf0, 0x42, 0x23, 0xe0, 0x4c, 0x98, 0xbf,
 348     0x01, 0x00, 0x1b, 0xfe, 0x06, 0x15, 0xc6, 0xe3,
 349     0x80, 0x79, 0x6d, 0xfe, 0x48, 0xcd, 0x40, 0xbb,
 350     0xf9, 0x58, 0xe6, 0xbf, 0xd5, 0x4c, 0x29, 0x48,
 351     0x53, 0x78, 0x06, 0x03, 0x0d, 0x59, 0xf5, 0x20,
 352     0xe0, 0xe6, 0x8c, 0xb2, 0xf5, 0xd8, 0x61, 0x52,
 353     0x7e, 0x40, 0x83, 0xd7, 0x69, 0xae, 0xd7, 0x75,
 354     0x02, 0x2d, 0x49, 0xd5, 0x15, 0x5b, 0xf1, 0xd9,
 355     0x4d, 0x60, 0x7d, 0x62, 0xa5, 0x02, 0x03, 0x01,
 356     0x00, 0x01, 0x02, 0x7f, 0x6d, 0x45, 0x23, 0xeb,
 357     0x95, 0x17, 0x34, 0x88, 0xf6, 0x91, 0xc7, 0x3f,
 358     0x48, 0x5a, 0xe0, 0x87, 0x63, 0x44, 0xae, 0x84,
 359     0xb2, 0x8c, 0x8a, 0xc8, 0xb2, 0x6f, 0x22, 0xf0,
 360     0xc5, 0x21, 0x61, 0x10, 0xa8, 0x69, 0x09, 0x1e,
 361     0x13, 0x7d, 0x94, 0x52, 0x1b, 0x5c, 0xe4, 0x7b,
 362     0xf0, 0x03, 0x8f, 0xbc, 0x72, 0x09, 0xdf, 0x78,
 363     0x84, 0x3e, 0xb9, 0xe5, 0xe6, 0x31, 0x0a, 0x01,
 364     0xf9, 0x32, 0xf8, 0xd6, 0x57, 0xa3, 0x87, 0xe6,
 365     0xf5, 0x98, 0xbc, 0x8e, 0x41, 0xb9, 0x50, 0x17,
 366     0x7b, 0xd3, 0x97, 0x5a, 0x44, 0x3a, 0xee, 0xff,
 367     0x6b, 0xb3, 0x3a, 0x52, 0xe7, 0xa4, 0x96, 0x9a,
 368     0xf6, 0x83, 0xc8, 0x97, 0x1c, 0x63, 0xa1, 0xd6,
 369     0xb3, 0xa8, 0xb2, 0xc7, 0x73, 0x25, 0x0f, 0x58,
 370     0x36, 0xb9, 0x7a, 0x47, 0xa7, 0x4d, 0x30, 0xfe,
 371     0x4d, 0x74, 0x56, 0xe8, 0xfb, 0xd6, 0x50, 0xe5,
 372     0xe0, 0x28, 0x15, 0x02, 0x41, 0x00, 0xeb, 0x15,
 373     0x62, 0xb6, 0x37, 0x41, 0x7c, 0xc5, 0x00, 0x22,
 374     0x2c, 0x5a, 0x5e, 0xe4, 0xb2, 0x11, 0x87, 0x89,
 375     0xad, 0xf4, 0x57, 0x68, 0x90, 0xb7, 0x9f, 0xe2,
 376     0x79, 0x20, 0x6b, 0x98, 0x00, 0x0d, 0x3a, 0x3b,
 377     0xc1, 0xcd, 0x36, 0xf9, 0x27, 0xda, 0x40, 0x36,
 378     0x1d, 0xb8, 0x5c, 0x96, 0xeb, 0x04, 0x08, 0xe1,
 379     0x3f, 0xfa, 0x94, 0x8b, 0x0f, 0xa0, 0xff, 0xc1,
 380     0x51, 0xea, 0x90, 0xad, 0x15, 0xc7, 0x02, 0x41,
 381     0x00, 0xd5, 0x06, 0x45, 0xd7, 0x55, 0x63, 0x1a,
 382     0xf0, 0x89, 0x81, 0xae, 0x87, 0x23, 0xa2, 0x39,
 383     0xfe, 0x3d, 0x82, 0xc7, 0xcb, 0x15, 0xb9, 0xe3,
 384     0xe2, 0x5b, 0xc6, 0xd2, 0x55, 0xdd, 0xab, 0x55,
 385     0x29, 0x7c, 0xda, 0x0e, 0x1c, 0x09, 0xfc, 0x73,
 386     0x0d, 0x01, 0xed, 0x6d, 0x2f, 0x05, 0xd0, 0xd5,
 387     0x1d, 0xce, 0x18, 0x7f, 0xb0, 0xc8, 0x47, 0x77,
 388     0xd2, 0xa9, 0x9e, 0xfc, 0x39, 0x4b, 0x3d, 0x94,
 389     0x33, 0x02, 0x41, 0x00, 0x8f, 0x94, 0x09, 0x2d,
 390     0x17, 0x44, 0x75, 0x0a, 0xf1, 0x10, 0xee, 0x1b,
 391     0xe7, 0xd7, 0x2f, 0xf6, 0xca, 0xdc, 0x49, 0x15,
 392     0x72, 0x09, 0x58, 0x51, 0xfe, 0x61, 0xd8, 0xee,
 393     0xf7, 0x27, 0xe7, 0xe8, 0x2c, 0x47, 0xf1, 0x0f,
 394     0x00, 0x63, 0x5e, 0x76, 0xcb, 0x3f, 0x02, 0x19,
 395     0xe6, 0xda, 0xfa, 0x01, 0x05, 0xd7, 0x65, 0x37,
 396     0x0b, 0x60, 0x7f, 0x94, 0x2a, 0x80, 0x8d, 0x22,
 397     0x81, 0x68, 0x65, 0x63, 0x02, 0x41, 0x00, 0xc2,
 398     0xd4, 0x18, 0xde, 0x47, 0x9e, 0xfb, 0x8d, 0x91,
 399     0x05, 0xc5, 0x3c, 0x9d, 0xcf, 0x8a, 0x60, 0xc7,
 400     0x9b, 0x2b, 0xe5, 0xc6, 0xba, 0x1b, 0xfc, 0xf3,
 401     0xd9, 0x54, 0x97, 0xe9, 0xc4, 0x00, 0x80, 0x90,
 402     0x4a, 0xd2, 0x6a, 0xbc, 0x8b, 0x62, 0x22, 0x3c,
 403     0x68, 0x0c, 0xda, 0xdb, 0xe3, 0xd2, 0x76, 0x8e,
 404     0xff, 0x03, 0x12, 0x09, 0x2a, 0xac, 0x21, 0x44,
 405     0xb7, 0x3e, 0x91, 0x9c, 0x09, 0xf6, 0xd7, 0x02,
 406     0x41, 0x00, 0xc0, 0xa1, 0xbb, 0x70, 0xdc, 0xf8,
 407     0xeb, 0x17, 0x61, 0xd4, 0x8c, 0x7c, 0x3b, 0x82,
 408     0x91, 0x58, 0xff, 0xf9, 0x19, 0xac, 0x3a, 0x73,
 409     0xa7, 0x20, 0xe5, 0x22, 0x02, 0xc4, 0xf6, 0xb9,
 410     0xb9, 0x43, 0x53, 0x35, 0x88, 0xe1, 0x05, 0xb6,
 411     0x43, 0x9b, 0x39, 0xc8, 0x04, 0x4d, 0x2b, 0x01,
 412     0xf7, 0xe6, 0x1b, 0x8d, 0x7e, 0x89, 0xe3, 0x43,
 413     0xd4, 0xf3, 0xab, 0x28, 0xd4, 0x5a, 0x1f, 0x20,
 414     0xea, 0xbe
 415   };
 416
 417   std::vector<uint8> input1;
 418   std::vector<uint8> input2;
 419
 420   input1.resize(sizeof(short_integer_with_high_bit));
 421   input2.resize(sizeof(short_integer_without_high_bit));
 422
 423   memcpy(&input1.front(), short_integer_with_high_bit,
 424          sizeof(short_integer_with_high_bit));
 425   memcpy(&input2.front(), short_integer_without_high_bit,
 426          sizeof(short_integer_without_high_bit));
 427
 428   scoped_ptr<crypto::RSAPrivateKey> keypair1(
 429       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input1));
 430   scoped_ptr<crypto::RSAPrivateKey> keypair2(
 431       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input2));
 432   ASSERT_TRUE(keypair1.get());
 433   ASSERT_TRUE(keypair2.get());
 434
 435   std::vector<uint8> output1;
 436   std::vector<uint8> output2;
 437   ASSERT_TRUE(keypair1->ExportPrivateKey(&output1));
 438   ASSERT_TRUE(keypair2->ExportPrivateKey(&output2));
 439
 440   ASSERT_EQ(input1.size(), output1.size());
 441   ASSERT_EQ(input2.size(), output2.size());
 442   ASSERT_TRUE(0 == memcmp(&output1.front(), &input1.front(),
 443                           input1.size()));
 444   ASSERT_TRUE(0 == memcmp(&output2.front(), &input2.front(),
 445                           input2.size()));
 446 }
 447
 448 // The following test can run if either USE_NSS or USE_OPENSSL is defined, but
 449 // not otherwise (since it uses crypto::RSAPrivateKey::CreateFromKey).
 450 #if defined(USE_NSS) || defined(USE_OPENSSL)
 451 TEST(RSAPrivateKeyUnitTest, CreateFromKeyTest) {
 452   scoped_ptr<crypto::RSAPrivateKey> key_pair(
 453       crypto::RSAPrivateKey::Create(256));
 454
 455   scoped_ptr<crypto::RSAPrivateKey> key_copy(
 456       crypto::RSAPrivateKey::CreateFromKey(key_pair->key()));
 457   ASSERT_TRUE(key_copy.get());
 458
 459   std::vector<uint8> privkey;
 460   std::vector<uint8> pubkey;
 461   ASSERT_TRUE(key_pair->ExportPrivateKey(&privkey));
 462   ASSERT_TRUE(key_pair->ExportPublicKey(&pubkey));
 463
 464   std::vector<uint8> privkey_copy;
 465   std::vector<uint8> pubkey_copy;
 466   ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy));
 467   ASSERT_TRUE(key_copy->ExportPublicKey(&pubkey_copy));
 468
 469   ASSERT_EQ(privkey, privkey_copy);
 470   ASSERT_EQ(pubkey, pubkey_copy);
 471 }
 472 #endif
 473