OLD | NEW |
---|---|
(Empty) | |
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/memory/scoped_ptr.h" | |
10 #include "testing/gtest/include/gtest/gtest.h" | |
11 | |
12 #if defined(USE_OPENSSL) | |
13 // Once ECPrivateKey is implemented for OpenSSL, remove this #if block. | |
14 // TODO(mattm): When that happens, also add some golden test data to test | |
wtc
2011/11/08 23:21:18
I don't know what "golden" test data means. Is th
mattm
2011/11/09 04:11:35
I guess it's a somewhat common term, though now th
| |
15 // interop between NSS and OpenSSL. | |
16 TEST(ECPrivateKeyUnitTest, OpenSSLStub) { | |
17 scoped_ptr<crypto::ECPrivateKey> keypair1( | |
18 crypto::ECPrivateKey::Create()); | |
19 ASSERT_FALSE(keypair1.get()); | |
20 } | |
21 #else | |
22 // Generate random private keys. Export, then re-import. We should get | |
23 // back the same exact public key, and the private key should have the same | |
24 // value and elliptic curve params. | |
25 TEST(ECPrivateKeyUnitTest, InitRandomTest) { | |
26 const std::string password1 = ""; | |
27 const std::string password2 = "test"; | |
28 | |
29 scoped_ptr<crypto::ECPrivateKey> keypair1( | |
30 crypto::ECPrivateKey::Create()); | |
31 scoped_ptr<crypto::ECPrivateKey> keypair2( | |
32 crypto::ECPrivateKey::Create()); | |
33 ASSERT_TRUE(keypair1.get()); | |
34 ASSERT_TRUE(keypair2.get()); | |
35 | |
36 std::vector<uint8> key1value; | |
37 std::vector<uint8> key2value; | |
38 std::vector<uint8> key1params; | |
39 std::vector<uint8> key2params; | |
40 EXPECT_TRUE(keypair1->ExportValue(&key1value)); | |
41 EXPECT_TRUE(keypair2->ExportValue(&key2value)); | |
42 EXPECT_TRUE(keypair1->ExportECParams(&key1params)); | |
43 EXPECT_TRUE(keypair2->ExportECParams(&key2params)); | |
44 | |
45 std::vector<uint8> privkey1; | |
46 std::vector<uint8> privkey2; | |
47 std::vector<uint8> pubkey1; | |
48 std::vector<uint8> pubkey2; | |
49 ASSERT_TRUE(keypair1->ExportEncryptedPrivateKey( | |
50 password1, 1, &privkey1)); | |
51 ASSERT_TRUE(keypair2->ExportEncryptedPrivateKey( | |
52 password2, 1, &privkey2)); | |
53 EXPECT_TRUE(keypair1->ExportPublicKey(&pubkey1)); | |
54 EXPECT_TRUE(keypair2->ExportPublicKey(&pubkey2)); | |
55 | |
56 scoped_ptr<crypto::ECPrivateKey> keypair3( | |
57 crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( | |
58 password1, privkey1, pubkey1)); | |
59 scoped_ptr<crypto::ECPrivateKey> keypair4( | |
60 crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( | |
61 password2, privkey2, pubkey2)); | |
62 ASSERT_TRUE(keypair3.get()); | |
63 ASSERT_TRUE(keypair4.get()); | |
64 | |
65 std::vector<uint8> key3value; | |
66 std::vector<uint8> key4value; | |
67 std::vector<uint8> key3params; | |
68 std::vector<uint8> key4params; | |
69 EXPECT_TRUE(keypair3->ExportValue(&key3value)); | |
70 EXPECT_TRUE(keypair4->ExportValue(&key4value)); | |
71 EXPECT_TRUE(keypair3->ExportECParams(&key3params)); | |
72 EXPECT_TRUE(keypair4->ExportECParams(&key4params)); | |
73 | |
74 EXPECT_EQ(key1value, key3value); | |
75 EXPECT_EQ(key2value, key4value); | |
76 EXPECT_EQ(key1params, key3params); | |
77 EXPECT_EQ(key2params, key4params); | |
78 | |
79 std::vector<uint8> pubkey3; | |
80 std::vector<uint8> pubkey4; | |
81 EXPECT_TRUE(keypair3->ExportPublicKey(&pubkey3)); | |
82 EXPECT_TRUE(keypair4->ExportPublicKey(&pubkey4)); | |
83 | |
84 EXPECT_EQ(pubkey1, pubkey3); | |
85 EXPECT_EQ(pubkey2, pubkey4); | |
86 } | |
87 | |
88 TEST(ECPrivateKeyUnitTest, BadPasswordTest) { | |
89 const std::string password1 = ""; | |
90 const std::string password2 = "test"; | |
91 | |
92 scoped_ptr<crypto::ECPrivateKey> keypair1( | |
93 crypto::ECPrivateKey::Create()); | |
94 ASSERT_TRUE(keypair1.get()); | |
95 | |
96 std::vector<uint8> privkey1; | |
97 std::vector<uint8> pubkey1; | |
98 ASSERT_TRUE(keypair1->ExportEncryptedPrivateKey( | |
99 password1, 1, &privkey1)); | |
100 ASSERT_TRUE(keypair1->ExportPublicKey(&pubkey1)); | |
101 | |
102 scoped_ptr<crypto::ECPrivateKey> keypair2( | |
103 crypto::ECPrivateKey::CreateFromEncryptedPrivateKeyInfo( | |
104 password2, privkey1, pubkey1)); | |
105 ASSERT_FALSE(keypair2.get()); | |
106 } | |
107 #endif // !defined(USE_OPENSSL) | |
OLD | NEW |