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