cygprofile: increase timeouts to allow showing web contents
[chromium-blink-merge.git] / crypto / rsa_private_key_unittest.cc
blob9e7f6ff51fe044ae4ab05c2dffddc686012dcfd5
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.
5 #include "crypto/rsa_private_key.h"
7 #include "base/memory/scoped_ptr.h"
8 #include "testing/gtest/include/gtest/gtest.h"
10 namespace {
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
95 } // namespace
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());
107 std::vector<uint8> privkey1;
108 std::vector<uint8> privkey2;
109 std::vector<uint8> pubkey1;
110 std::vector<uint8> pubkey2;
112 ASSERT_TRUE(keypair1->ExportPrivateKey(&privkey1));
113 ASSERT_TRUE(keypair2->ExportPrivateKey(&privkey2));
114 ASSERT_TRUE(keypair1->ExportPublicKey(&pubkey1));
115 ASSERT_TRUE(keypair2->ExportPublicKey(&pubkey2));
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());
124 std::vector<uint8> privkey3;
125 std::vector<uint8> privkey4;
126 ASSERT_TRUE(keypair3->ExportPrivateKey(&privkey3));
127 ASSERT_TRUE(keypair4->ExportPrivateKey(&privkey4));
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()));
137 // Test Copy() method.
138 TEST(RSAPrivateKeyUnitTest, CopyTest) {
139 std::vector<uint8> input(
140 kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
142 scoped_ptr<crypto::RSAPrivateKey> key(
143 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
145 scoped_ptr<crypto::RSAPrivateKey> key_copy(key->Copy());
146 ASSERT_TRUE(key_copy.get());
148 std::vector<uint8> privkey_copy;
149 ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy));
150 ASSERT_EQ(input, privkey_copy);
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);
160 scoped_ptr<crypto::RSAPrivateKey> key(
161 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
163 // Import should fail.
164 EXPECT_FALSE(key);
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
184 std::vector<uint8> input(
185 kTestEcPrivateKeyInfo,
186 kTestEcPrivateKeyInfo + sizeof(kTestEcPrivateKeyInfo));
188 scoped_ptr<crypto::RSAPrivateKey> key(
189 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
191 // Import should fail as the given PKCS8 bytes were for an EC key not RSA key.
192 EXPECT_FALSE(key);
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
222 std::vector<uint8> input(
223 kTestPrivateKeyInfo, kTestPrivateKeyInfo + sizeof(kTestPrivateKeyInfo));
225 scoped_ptr<crypto::RSAPrivateKey> key(
226 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(input));
227 ASSERT_TRUE(key.get());
229 std::vector<uint8> output;
230 ASSERT_TRUE(key->ExportPublicKey(&output));
232 ASSERT_TRUE(
233 memcmp(expected_public_key_info, &output.front(), output.size()) == 0);
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.
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.
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
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
417 std::vector<uint8> input1;
418 std::vector<uint8> input2;
420 input1.resize(sizeof(short_integer_with_high_bit));
421 input2.resize(sizeof(short_integer_without_high_bit));
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));
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());
435 std::vector<uint8> output1;
436 std::vector<uint8> output2;
437 ASSERT_TRUE(keypair1->ExportPrivateKey(&output1));
438 ASSERT_TRUE(keypair2->ExportPrivateKey(&output2));
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()));
448 TEST(RSAPrivateKeyUnitTest, CreateFromKeyTest) {
449 scoped_ptr<crypto::RSAPrivateKey> key_pair(
450 crypto::RSAPrivateKey::Create(512));
451 ASSERT_TRUE(key_pair.get());
453 scoped_ptr<crypto::RSAPrivateKey> key_copy(
454 crypto::RSAPrivateKey::CreateFromKey(key_pair->key()));
455 ASSERT_TRUE(key_copy.get());
457 std::vector<uint8> privkey;
458 std::vector<uint8> pubkey;
459 ASSERT_TRUE(key_pair->ExportPrivateKey(&privkey));
460 ASSERT_TRUE(key_pair->ExportPublicKey(&pubkey));
462 std::vector<uint8> privkey_copy;
463 std::vector<uint8> pubkey_copy;
464 ASSERT_TRUE(key_copy->ExportPrivateKey(&privkey_copy));
465 ASSERT_TRUE(key_copy->ExportPublicKey(&pubkey_copy));
467 ASSERT_EQ(privkey, privkey_copy);
468 ASSERT_EQ(pubkey, pubkey_copy);