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
 168 // Verify that generated public keys look good. This test data was generated
 169 // with the openssl command line tool.
 170 TEST(RSAPrivateKeyUnitTest, PublicKeyTest) {
 171   const uint8 expected_public_key_info[] = {
 172     0x30, 0x81, 0x9f, 0x30, 0x0d, 0x06, 0x09, 0x2a,
 173     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01,
 174     0x05, 0x00, 0x03, 0x81, 0x8d, 0x00, 0x30, 0x81,
 175     0x89, 0x02, 0x81, 0x81, 0x00, 0xb8, 0x7f, 0x2b,
 176     0x20, 0xdc, 0x7c, 0x9b, 0x0c, 0xdc, 0x51, 0x61,
 177     0x99, 0x0d, 0x36, 0x0f, 0xd4, 0x66, 0x88, 0x08,
 178     0x55, 0x84, 0xd5, 0x3a, 0xbf, 0x2b, 0xa4, 0x64,
 179     0x85, 0x7b, 0x0c, 0x04, 0x13, 0x3f, 0x8d, 0xf4,
 180     0xbc, 0x38, 0x0d, 0x49, 0xfe, 0x6b, 0xc4, 0x5a,
 181     0xb0, 0x40, 0x53, 0x3a, 0xd7, 0x66, 0x09, 0x0f,
 182     0x9e, 0x36, 0x74, 0x30, 0xda, 0x8a, 0x31, 0x4f,
 183     0x1f, 0x14, 0x50, 0xd7, 0xc7, 0x20, 0x94, 0x17,
 184     0xde, 0x4e, 0xb9, 0x57, 0x5e, 0x7e, 0x0a, 0xe5,
 185     0xb2, 0x65, 0x7a, 0x89, 0x4e, 0xb6, 0x47, 0xff,
 186     0x1c, 0xbd, 0xb7, 0x38, 0x13, 0xaf, 0x47, 0x85,
 187     0x84, 0x32, 0x33, 0xf3, 0x17, 0x49, 0xbf, 0xe9,
 188     0x96, 0xd0, 0xd6, 0x14, 0x6f, 0x13, 0x8d, 0xc5,
 189     0xfc, 0x2c, 0x72, 0xba, 0xac, 0xea, 0x7e, 0x18,
 190     0x53, 0x56, 0xa6, 0x83, 0xa2, 0xce, 0x93, 0x93,
 191     0xe7, 0x1f, 0x0f, 0xe6, 0x0f, 0x02, 0x03, 0x01,
 192     0x00, 0x01
 193   };
 194
 195   std::vector<uint8> input(
 196       kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
 197
 198   scoped_ptr<crypto::RSAPrivateKey> key(
 199       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
 200   ASSERT_TRUE(key.get());
 201
 202   std::vector<uint8> output;
 203   ASSERT_TRUE(key->ExportPublicKey(&output));
 204
 205   ASSERT_TRUE(
 206       memcmp(expected_public_key_info, &output.front(), output.size()) == 0);
 207 }
 208
 209 // These two test keys each contain an integer that has 0x00 for its most
 210 // significant byte. When encoded as ASN.1, this byte is dropped and there are
 211 // two interesting sub-cases. When the sign bit of the integer is set, an extra
 212 // null byte is added back to force the encoded value to be positive. When the
 213 // sign bit is not set, the encoded integer is just left shorter than usual.
 214 // See also: http://code.google.com/p/chromium/issues/detail?id=14877.
 215 //
 216 // Before we were handling this correctly, we would see one of two failures:
 217 // * RSAPrivateKey::CreateFromPrivateKeyInfo would return null because the
 218 //   underlying windows API failed to import the key.
 219 // * The import would succeed, but incorrectly interpret the data. On export,
 220 //   the key would contain different values.
 221 //
 222 // This test case verifies these two failures modes don't occur.
 223 TEST(RSAPrivateKeyUnitTest, ShortIntegers) {
 224   const uint8 short_integer_with_high_bit[] = {
 225     0x30, 0x82, 0x02, 0x77, 0x02, 0x01, 0x00, 0x30,
 226     0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 227     0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 228     0x02, 0x61, 0x30, 0x82, 0x02, 0x5d, 0x02, 0x01,
 229     0x00, 0x02, 0x81, 0x81, 0x00, 0x92, 0x59, 0x32,
 230     0x7d, 0x8e, 0xaf, 0x2e, 0xd5, 0xb2, 0x5c, 0x67,
 231     0xc8, 0x7d, 0x48, 0xb7, 0x84, 0x12, 0xd0, 0x76,
 232     0xda, 0xe1, 0xa3, 0x1e, 0x40, 0x01, 0x14, 0x5c,
 233     0xef, 0x26, 0x6e, 0x28, 0xa2, 0xf7, 0xa5, 0xb4,
 234     0x02, 0x37, 0xd0, 0x53, 0x10, 0xcb, 0x7c, 0x6a,
 235     0xf4, 0x53, 0x9f, 0xb8, 0xe0, 0x83, 0x93, 0xd1,
 236     0x19, 0xd8, 0x28, 0xd1, 0xd1, 0xd8, 0x87, 0x8f,
 237     0x92, 0xfd, 0x73, 0xc0, 0x4d, 0x3e, 0x07, 0x22,
 238     0x1f, 0xc1, 0x20, 0xb0, 0x70, 0xb2, 0x3b, 0xea,
 239     0xb1, 0xe5, 0x0a, 0xfd, 0x56, 0x49, 0x5e, 0x39,
 240     0x90, 0x91, 0xce, 0x04, 0x83, 0x29, 0xaa, 0xfd,
 241     0x12, 0xa4, 0x42, 0x26, 0x6c, 0x6e, 0x79, 0x70,
 242     0x77, 0x03, 0xb2, 0x07, 0x01, 0x3d, 0x85, 0x81,
 243     0x95, 0x9e, 0xda, 0x5a, 0xa3, 0xf4, 0x2d, 0x38,
 244     0x04, 0x58, 0xf5, 0x6b, 0xc9, 0xf1, 0xb5, 0x65,
 245     0xfe, 0x66, 0x0d, 0xa2, 0xd5, 0x02, 0x03, 0x01,
 246     0x00, 0x01, 0x02, 0x81, 0x80, 0x5e, 0x01, 0x5f,
 247     0xb6, 0x59, 0x1d, 0xdc, 0x36, 0xb6, 0x60, 0x36,
 248     0xe6, 0x08, 0xdb, 0xd9, 0xcd, 0xc3, 0x8c, 0x16,
 249     0x9c, 0x98, 0x8d, 0x7f, 0xd3, 0xdb, 0x1d, 0xaa,
 250     0x68, 0x8f, 0xc5, 0xf8, 0xe2, 0x5d, 0xb3, 0x19,
 251     0xc2, 0xc6, 0xf9, 0x51, 0x32, 0x1b, 0x93, 0x6a,
 252     0xdc, 0x50, 0x8e, 0xeb, 0x61, 0x84, 0x03, 0x42,
 253     0x30, 0x98, 0xb1, 0xf7, 0xbd, 0x14, 0x9a, 0x57,
 254     0x36, 0x33, 0x09, 0xd4, 0x3e, 0x90, 0xda, 0xef,
 255     0x09, 0x6e, 0xef, 0x49, 0xb6, 0x60, 0x68, 0x5e,
 256     0x54, 0x17, 0x25, 0x5b, 0x37, 0xe3, 0x35, 0x63,
 257     0x5b, 0x60, 0x3c, 0xbd, 0x50, 0xdf, 0x46, 0x43,
 258     0x08, 0xa4, 0x71, 0x21, 0xf1, 0x30, 0x71, 0xdc,
 259     0xda, 0xd7, 0x6f, 0xd2, 0x18, 0xbd, 0x39, 0xf1,
 260     0xe1, 0xbe, 0xa8, 0x8d, 0x62, 0xdf, 0xa2, 0x3e,
 261     0xb6, 0x15, 0x26, 0xb6, 0x57, 0xbd, 0x63, 0xdb,
 262     0xc1, 0x91, 0xec, 0xb8, 0x01, 0x02, 0x41, 0x00,
 263     0xc6, 0x1a, 0x06, 0x48, 0xf2, 0x12, 0x1c, 0x9f,
 264     0x74, 0x20, 0x5c, 0x85, 0xa2, 0xda, 0xe5, 0x62,
 265     0x96, 0x8d, 0x22, 0x7b, 0x78, 0x73, 0xea, 0xbb,
 266     0x9f, 0x59, 0x42, 0x13, 0x15, 0xc8, 0x11, 0x50,
 267     0x6c, 0x55, 0xf6, 0xdf, 0x8b, 0xfe, 0xc7, 0xdd,
 268     0xa8, 0xca, 0x54, 0x41, 0xe8, 0xce, 0xbe, 0x7d,
 269     0xbd, 0xe2, 0x13, 0x4b, 0x5b, 0x61, 0xeb, 0x69,
 270     0x6c, 0xb1, 0x9b, 0x28, 0x68, 0x5b, 0xd6, 0x01,
 271     0x02, 0x41, 0x00, 0xbd, 0x1e, 0xfe, 0x51, 0x99,
 272     0xb6, 0xe3, 0x84, 0xfe, 0xf1, 0x9e, 0xfd, 0x9c,
 273     0xe7, 0x86, 0x43, 0x68, 0x7f, 0x2f, 0x6a, 0x2a,
 274     0x4c, 0xae, 0xa6, 0x41, 0x1c, 0xf0, 0x10, 0x37,
 275     0x54, 0x23, 0xba, 0x05, 0x0d, 0x18, 0x27, 0x8d,
 276     0xb8, 0xe4, 0x8f, 0xf2, 0x25, 0x73, 0x8a, 0xd7,
 277     0x05, 0x98, 0x6b, 0x3d, 0x55, 0xb7, 0x6f, 0x7c,
 278     0xec, 0x77, 0x61, 0x54, 0x7b, 0xb6, 0x6b, 0x31,
 279     0xec, 0x94, 0xd5, 0x02, 0x41, 0x00, 0x90, 0xa2,
 280     0xa5, 0x9e, 0x12, 0xa7, 0x68, 0xa0, 0x7e, 0xdf,
 281     0xb5, 0xcd, 0x98, 0x26, 0xab, 0xbd, 0xbc, 0x5f,
 282     0xd5, 0x22, 0x42, 0xc2, 0x97, 0x4a, 0x5f, 0x40,
 283     0x82, 0xfe, 0x7e, 0x33, 0xb1, 0x78, 0x7f, 0x70,
 284     0x90, 0x2b, 0x8d, 0x01, 0xfb, 0x18, 0xfa, 0x48,
 285     0xa7, 0x15, 0xec, 0x0d, 0x2e, 0x85, 0x8d, 0xe2,
 286     0x86, 0xe5, 0xc9, 0x15, 0x88, 0x14, 0x53, 0xd8,
 287     0xa4, 0x88, 0xef, 0x10, 0xc6, 0x01, 0x02, 0x41,
 288     0x00, 0xba, 0xe4, 0xaf, 0x14, 0xfa, 0xdf, 0xf6,
 289     0xd5, 0xce, 0x8f, 0xfe, 0xbb, 0xc8, 0x5c, 0x30,
 290     0x9d, 0xda, 0xdd, 0x9d, 0x80, 0xc0, 0x0e, 0x89,
 291     0xa5, 0xb8, 0xc1, 0x1d, 0x28, 0x19, 0x55, 0x67,
 292     0xfd, 0x03, 0xd2, 0xdd, 0xe4, 0xf0, 0xb4, 0x20,
 293     0x03, 0x74, 0x9b, 0xb8, 0x24, 0x23, 0xbb, 0xde,
 294     0xd5, 0x53, 0x86, 0xaa, 0xc1, 0x5d, 0x65, 0xdd,
 295     0xcf, 0xec, 0x8a, 0x59, 0x4a, 0x73, 0xca, 0xc5,
 296     0x85, 0x02, 0x40, 0x00, 0xc4, 0x5e, 0x8d, 0xa4,
 297     0xea, 0xbb, 0x6a, 0x9b, 0xe6, 0x3a, 0x4d, 0xc1,
 298     0xdb, 0xe5, 0x52, 0x38, 0xf9, 0x59, 0x91, 0x2d,
 299     0x90, 0x82, 0xe3, 0x31, 0x1b, 0x48, 0xb7, 0x42,
 300     0xfa, 0x1d, 0x83, 0xd5, 0x3d, 0x02, 0xc2, 0x12,
 301     0x71, 0x10, 0x3a, 0xbd, 0x92, 0x8f, 0x9b, 0xa2,
 302     0x6b, 0x2d, 0x21, 0xa4, 0x65, 0xe9, 0xfa, 0x8c,
 303     0x30, 0x2a, 0x89, 0xce, 0xd0, 0xa7, 0x67, 0xd8,
 304     0x45, 0x84, 0xb0
 305   };
 306
 307   const uint8 short_integer_without_high_bit[] = {
 308     0x30, 0x82, 0x02, 0x76, 0x02, 0x01, 0x00, 0x30,
 309     0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
 310     0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
 311     0x02, 0x60, 0x30, 0x82, 0x02, 0x5c, 0x02, 0x01,
 312     0x00, 0x02, 0x81, 0x81, 0x00, 0xc3, 0x9e, 0x8d,
 313     0xc4, 0x6d, 0x38, 0xe8, 0x0e, 0x9f, 0x84, 0x03,
 314     0x40, 0x8e, 0x81, 0x2e, 0x56, 0x67, 0x78, 0x11,
 315     0x85, 0x27, 0x81, 0x52, 0xf2, 0x1b, 0x3e, 0x5b,
 316     0xf8, 0xab, 0xfc, 0xaf, 0xca, 0x5c, 0x26, 0xd5,
 317     0xfa, 0xd4, 0x55, 0x50, 0x38, 0xb9, 0x9d, 0x89,
 318     0x92, 0x7e, 0x34, 0xcf, 0x37, 0x82, 0x48, 0x2d,
 319     0xaa, 0xc4, 0x6a, 0x0e, 0x93, 0xea, 0xad, 0x8a,
 320     0x33, 0xf0, 0x42, 0x23, 0xe0, 0x4c, 0x98, 0xbf,
 321     0x01, 0x00, 0x1b, 0xfe, 0x06, 0x15, 0xc6, 0xe3,
 322     0x80, 0x79, 0x6d, 0xfe, 0x48, 0xcd, 0x40, 0xbb,
 323     0xf9, 0x58, 0xe6, 0xbf, 0xd5, 0x4c, 0x29, 0x48,
 324     0x53, 0x78, 0x06, 0x03, 0x0d, 0x59, 0xf5, 0x20,
 325     0xe0, 0xe6, 0x8c, 0xb2, 0xf5, 0xd8, 0x61, 0x52,
 326     0x7e, 0x40, 0x83, 0xd7, 0x69, 0xae, 0xd7, 0x75,
 327     0x02, 0x2d, 0x49, 0xd5, 0x15, 0x5b, 0xf1, 0xd9,
 328     0x4d, 0x60, 0x7d, 0x62, 0xa5, 0x02, 0x03, 0x01,
 329     0x00, 0x01, 0x02, 0x7f, 0x6d, 0x45, 0x23, 0xeb,
 330     0x95, 0x17, 0x34, 0x88, 0xf6, 0x91, 0xc7, 0x3f,
 331     0x48, 0x5a, 0xe0, 0x87, 0x63, 0x44, 0xae, 0x84,
 332     0xb2, 0x8c, 0x8a, 0xc8, 0xb2, 0x6f, 0x22, 0xf0,
 333     0xc5, 0x21, 0x61, 0x10, 0xa8, 0x69, 0x09, 0x1e,
 334     0x13, 0x7d, 0x94, 0x52, 0x1b, 0x5c, 0xe4, 0x7b,
 335     0xf0, 0x03, 0x8f, 0xbc, 0x72, 0x09, 0xdf, 0x78,
 336     0x84, 0x3e, 0xb9, 0xe5, 0xe6, 0x31, 0x0a, 0x01,
 337     0xf9, 0x32, 0xf8, 0xd6, 0x57, 0xa3, 0x87, 0xe6,
 338     0xf5, 0x98, 0xbc, 0x8e, 0x41, 0xb9, 0x50, 0x17,
 339     0x7b, 0xd3, 0x97, 0x5a, 0x44, 0x3a, 0xee, 0xff,
 340     0x6b, 0xb3, 0x3a, 0x52, 0xe7, 0xa4, 0x96, 0x9a,
 341     0xf6, 0x83, 0xc8, 0x97, 0x1c, 0x63, 0xa1, 0xd6,
 342     0xb3, 0xa8, 0xb2, 0xc7, 0x73, 0x25, 0x0f, 0x58,
 343     0x36, 0xb9, 0x7a, 0x47, 0xa7, 0x4d, 0x30, 0xfe,
 344     0x4d, 0x74, 0x56, 0xe8, 0xfb, 0xd6, 0x50, 0xe5,
 345     0xe0, 0x28, 0x15, 0x02, 0x41, 0x00, 0xeb, 0x15,
 346     0x62, 0xb6, 0x37, 0x41, 0x7c, 0xc5, 0x00, 0x22,
 347     0x2c, 0x5a, 0x5e, 0xe4, 0xb2, 0x11, 0x87, 0x89,
 348     0xad, 0xf4, 0x57, 0x68, 0x90, 0xb7, 0x9f, 0xe2,
 349     0x79, 0x20, 0x6b, 0x98, 0x00, 0x0d, 0x3a, 0x3b,
 350     0xc1, 0xcd, 0x36, 0xf9, 0x27, 0xda, 0x40, 0x36,
 351     0x1d, 0xb8, 0x5c, 0x96, 0xeb, 0x04, 0x08, 0xe1,
 352     0x3f, 0xfa, 0x94, 0x8b, 0x0f, 0xa0, 0xff, 0xc1,
 353     0x51, 0xea, 0x90, 0xad, 0x15, 0xc7, 0x02, 0x41,
 354     0x00, 0xd5, 0x06, 0x45, 0xd7, 0x55, 0x63, 0x1a,
 355     0xf0, 0x89, 0x81, 0xae, 0x87, 0x23, 0xa2, 0x39,
 356     0xfe, 0x3d, 0x82, 0xc7, 0xcb, 0x15, 0xb9, 0xe3,
 357     0xe2, 0x5b, 0xc6, 0xd2, 0x55, 0xdd, 0xab, 0x55,
 358     0x29, 0x7c, 0xda, 0x0e, 0x1c, 0x09, 0xfc, 0x73,
 359     0x0d, 0x01, 0xed, 0x6d, 0x2f, 0x05, 0xd0, 0xd5,
 360     0x1d, 0xce, 0x18, 0x7f, 0xb0, 0xc8, 0x47, 0x77,
 361     0xd2, 0xa9, 0x9e, 0xfc, 0x39, 0x4b, 0x3d, 0x94,
 362     0x33, 0x02, 0x41, 0x00, 0x8f, 0x94, 0x09, 0x2d,
 363     0x17, 0x44, 0x75, 0x0a, 0xf1, 0x10, 0xee, 0x1b,
 364     0xe7, 0xd7, 0x2f, 0xf6, 0xca, 0xdc, 0x49, 0x15,
 365     0x72, 0x09, 0x58, 0x51, 0xfe, 0x61, 0xd8, 0xee,
 366     0xf7, 0x27, 0xe7, 0xe8, 0x2c, 0x47, 0xf1, 0x0f,
 367     0x00, 0x63, 0x5e, 0x76, 0xcb, 0x3f, 0x02, 0x19,
 368     0xe6, 0xda, 0xfa, 0x01, 0x05, 0xd7, 0x65, 0x37,
 369     0x0b, 0x60, 0x7f, 0x94, 0x2a, 0x80, 0x8d, 0x22,
 370     0x81, 0x68, 0x65, 0x63, 0x02, 0x41, 0x00, 0xc2,
 371     0xd4, 0x18, 0xde, 0x47, 0x9e, 0xfb, 0x8d, 0x91,
 372     0x05, 0xc5, 0x3c, 0x9d, 0xcf, 0x8a, 0x60, 0xc7,
 373     0x9b, 0x2b, 0xe5, 0xc6, 0xba, 0x1b, 0xfc, 0xf3,
 374     0xd9, 0x54, 0x97, 0xe9, 0xc4, 0x00, 0x80, 0x90,
 375     0x4a, 0xd2, 0x6a, 0xbc, 0x8b, 0x62, 0x22, 0x3c,
 376     0x68, 0x0c, 0xda, 0xdb, 0xe3, 0xd2, 0x76, 0x8e,
 377     0xff, 0x03, 0x12, 0x09, 0x2a, 0xac, 0x21, 0x44,
 378     0xb7, 0x3e, 0x91, 0x9c, 0x09, 0xf6, 0xd7, 0x02,
 379     0x41, 0x00, 0xc0, 0xa1, 0xbb, 0x70, 0xdc, 0xf8,
 380     0xeb, 0x17, 0x61, 0xd4, 0x8c, 0x7c, 0x3b, 0x82,
 381     0x91, 0x58, 0xff, 0xf9, 0x19, 0xac, 0x3a, 0x73,
 382     0xa7, 0x20, 0xe5, 0x22, 0x02, 0xc4, 0xf6, 0xb9,
 383     0xb9, 0x43, 0x53, 0x35, 0x88, 0xe1, 0x05, 0xb6,
 384     0x43, 0x9b, 0x39, 0xc8, 0x04, 0x4d, 0x2b, 0x01,
 385     0xf7, 0xe6, 0x1b, 0x8d, 0x7e, 0x89, 0xe3, 0x43,
 386     0xd4, 0xf3, 0xab, 0x28, 0xd4, 0x5a, 0x1f, 0x20,
 387     0xea, 0xbe
 388   };
 389
 390   std::vector<uint8> input1;
 391   std::vector<uint8> input2;
 392
 393   input1.resize(sizeof(short_integer_with_high_bit));
 394   input2.resize(sizeof(short_integer_without_high_bit));
 395
 396   memcpy(&input1.front(), short_integer_with_high_bit,
 397          sizeof(short_integer_with_high_bit));
 398   memcpy(&input2.front(), short_integer_without_high_bit,
 399          sizeof(short_integer_without_high_bit));
 400
 401   scoped_ptr<crypto::RSAPrivateKey> keypair1(
 402       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input1));
 403   scoped_ptr<crypto::RSAPrivateKey> keypair2(
 404       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input2));
 405   ASSERT_TRUE(keypair1.get());
 406   ASSERT_TRUE(keypair2.get());
 407
 408   std::vector<uint8> output1;
 409   std::vector<uint8> output2;
 410   ASSERT_TRUE(keypair1->ExportPrivateKey(&output1));
 411   ASSERT_TRUE(keypair2->ExportPrivateKey(&output2));
 412
 413   ASSERT_EQ(input1.size(), output1.size());
 414   ASSERT_EQ(input2.size(), output2.size());
 415   ASSERT_TRUE(0 == memcmp(&output1.front(), &input1.front(),
 416                           input1.size()));
 417   ASSERT_TRUE(0 == memcmp(&output2.front(), &input2.front(),
 418                           input2.size()));
 419 }
 420
 421 // The following test can run if either USE_NSS or USE_OPENSSL is defined, but
 422 // not otherwise (since it uses crypto::RSAPrivateKey::CreateFromKey).
 423 #if defined(USE_NSS) || defined(USE_OPENSSL)
 424 TEST(RSAPrivateKeyUnitTest, CreateFromKeyTest) {
 425   scoped_ptr<crypto::RSAPrivateKey> key_pair(
 426       crypto::RSAPrivateKey::Create(256));
 427
 428   scoped_ptr<crypto::RSAPrivateKey> key_copy(
 429       crypto::RSAPrivateKey::CreateFromKey(key_pair->key()));
 430   ASSERT_TRUE(key_copy.get());
 431
 432   std::vector<uint8> privkey;
 433   std::vector<uint8> pubkey;
 434   ASSERT_TRUE(key_pair->ExportPrivateKey(&privkey));
 435   ASSERT_TRUE(key_pair->ExportPublicKey(&pubkey));
 436
 437   std::vector<uint8> privkey_copy;
 438   std::vector<uint8> pubkey_copy;
 439   ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy));
 440   ASSERT_TRUE(key_copy->ExportPublicKey(&pubkey_copy));
 441
 442   ASSERT_EQ(privkey, privkey_copy);
 443   ASSERT_EQ(pubkey, pubkey_copy);
 444 }
 445 #endif
 446