OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
| 5 #include "crypto/signature_creator.h" |
| 6 |
5 #include <stdint.h> | 7 #include <stdint.h> |
6 | 8 |
| 9 #include <memory> |
7 #include <vector> | 10 #include <vector> |
8 | 11 |
9 #include "base/memory/scoped_ptr.h" | |
10 #include "base/sha1.h" | 12 #include "base/sha1.h" |
11 #include "crypto/rsa_private_key.h" | 13 #include "crypto/rsa_private_key.h" |
12 #include "crypto/sha2.h" | 14 #include "crypto/sha2.h" |
13 #include "crypto/signature_creator.h" | |
14 #include "crypto/signature_verifier.h" | 15 #include "crypto/signature_verifier.h" |
15 #include "testing/gtest/include/gtest/gtest.h" | 16 #include "testing/gtest/include/gtest/gtest.h" |
16 | 17 |
17 TEST(SignatureCreatorTest, BasicTest) { | 18 TEST(SignatureCreatorTest, BasicTest) { |
18 // Do a verify round trip. | 19 // Do a verify round trip. |
19 scoped_ptr<crypto::RSAPrivateKey> key_original( | 20 std::unique_ptr<crypto::RSAPrivateKey> key_original( |
20 crypto::RSAPrivateKey::Create(1024)); | 21 crypto::RSAPrivateKey::Create(1024)); |
21 ASSERT_TRUE(key_original.get()); | 22 ASSERT_TRUE(key_original.get()); |
22 | 23 |
23 std::vector<uint8_t> key_info; | 24 std::vector<uint8_t> key_info; |
24 key_original->ExportPrivateKey(&key_info); | 25 key_original->ExportPrivateKey(&key_info); |
25 scoped_ptr<crypto::RSAPrivateKey> key( | 26 std::unique_ptr<crypto::RSAPrivateKey> key( |
26 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); | 27 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); |
27 ASSERT_TRUE(key.get()); | 28 ASSERT_TRUE(key.get()); |
28 | 29 |
29 scoped_ptr<crypto::SignatureCreator> signer( | 30 std::unique_ptr<crypto::SignatureCreator> signer( |
30 crypto::SignatureCreator::Create(key.get(), | 31 crypto::SignatureCreator::Create(key.get(), |
31 crypto::SignatureCreator::SHA1)); | 32 crypto::SignatureCreator::SHA1)); |
32 ASSERT_TRUE(signer.get()); | 33 ASSERT_TRUE(signer.get()); |
33 | 34 |
34 std::string data("Hello, World!"); | 35 std::string data("Hello, World!"); |
35 ASSERT_TRUE(signer->Update(reinterpret_cast<const uint8_t*>(data.c_str()), | 36 ASSERT_TRUE(signer->Update(reinterpret_cast<const uint8_t*>(data.c_str()), |
36 data.size())); | 37 data.size())); |
37 | 38 |
38 std::vector<uint8_t> signature; | 39 std::vector<uint8_t> signature; |
39 ASSERT_TRUE(signer->Final(&signature)); | 40 ASSERT_TRUE(signer->Final(&signature)); |
40 | 41 |
41 std::vector<uint8_t> public_key_info; | 42 std::vector<uint8_t> public_key_info; |
42 ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); | 43 ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); |
43 | 44 |
44 crypto::SignatureVerifier verifier; | 45 crypto::SignatureVerifier verifier; |
45 ASSERT_TRUE(verifier.VerifyInit( | 46 ASSERT_TRUE(verifier.VerifyInit( |
46 crypto::SignatureVerifier::RSA_PKCS1_SHA1, &signature.front(), | 47 crypto::SignatureVerifier::RSA_PKCS1_SHA1, &signature.front(), |
47 signature.size(), &public_key_info.front(), public_key_info.size())); | 48 signature.size(), &public_key_info.front(), public_key_info.size())); |
48 | 49 |
49 verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), | 50 verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), |
50 data.size()); | 51 data.size()); |
51 ASSERT_TRUE(verifier.VerifyFinal()); | 52 ASSERT_TRUE(verifier.VerifyFinal()); |
52 } | 53 } |
53 | 54 |
54 TEST(SignatureCreatorTest, SignDigestTest) { | 55 TEST(SignatureCreatorTest, SignDigestTest) { |
55 // Do a verify round trip. | 56 // Do a verify round trip. |
56 scoped_ptr<crypto::RSAPrivateKey> key_original( | 57 std::unique_ptr<crypto::RSAPrivateKey> key_original( |
57 crypto::RSAPrivateKey::Create(1024)); | 58 crypto::RSAPrivateKey::Create(1024)); |
58 ASSERT_TRUE(key_original.get()); | 59 ASSERT_TRUE(key_original.get()); |
59 | 60 |
60 std::vector<uint8_t> key_info; | 61 std::vector<uint8_t> key_info; |
61 key_original->ExportPrivateKey(&key_info); | 62 key_original->ExportPrivateKey(&key_info); |
62 scoped_ptr<crypto::RSAPrivateKey> key( | 63 std::unique_ptr<crypto::RSAPrivateKey> key( |
63 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); | 64 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); |
64 ASSERT_TRUE(key.get()); | 65 ASSERT_TRUE(key.get()); |
65 | 66 |
66 std::string data("Hello, World!"); | 67 std::string data("Hello, World!"); |
67 std::string sha1 = base::SHA1HashString(data); | 68 std::string sha1 = base::SHA1HashString(data); |
68 // Sign sha1 of the input data. | 69 // Sign sha1 of the input data. |
69 std::vector<uint8_t> signature; | 70 std::vector<uint8_t> signature; |
70 ASSERT_TRUE(crypto::SignatureCreator::Sign( | 71 ASSERT_TRUE(crypto::SignatureCreator::Sign( |
71 key.get(), crypto::SignatureCreator::SHA1, | 72 key.get(), crypto::SignatureCreator::SHA1, |
72 reinterpret_cast<const uint8_t*>(sha1.c_str()), sha1.size(), &signature)); | 73 reinterpret_cast<const uint8_t*>(sha1.c_str()), sha1.size(), &signature)); |
73 | 74 |
74 std::vector<uint8_t> public_key_info; | 75 std::vector<uint8_t> public_key_info; |
75 ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); | 76 ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); |
76 | 77 |
77 // Verify the input data. | 78 // Verify the input data. |
78 crypto::SignatureVerifier verifier; | 79 crypto::SignatureVerifier verifier; |
79 ASSERT_TRUE(verifier.VerifyInit( | 80 ASSERT_TRUE(verifier.VerifyInit( |
80 crypto::SignatureVerifier::RSA_PKCS1_SHA1, &signature.front(), | 81 crypto::SignatureVerifier::RSA_PKCS1_SHA1, &signature.front(), |
81 signature.size(), &public_key_info.front(), public_key_info.size())); | 82 signature.size(), &public_key_info.front(), public_key_info.size())); |
82 | 83 |
83 verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), | 84 verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), |
84 data.size()); | 85 data.size()); |
85 ASSERT_TRUE(verifier.VerifyFinal()); | 86 ASSERT_TRUE(verifier.VerifyFinal()); |
86 } | 87 } |
87 | 88 |
88 TEST(SignatureCreatorTest, SignSHA256DigestTest) { | 89 TEST(SignatureCreatorTest, SignSHA256DigestTest) { |
89 // Do a verify round trip. | 90 // Do a verify round trip. |
90 scoped_ptr<crypto::RSAPrivateKey> key_original( | 91 std::unique_ptr<crypto::RSAPrivateKey> key_original( |
91 crypto::RSAPrivateKey::Create(1024)); | 92 crypto::RSAPrivateKey::Create(1024)); |
92 ASSERT_TRUE(key_original.get()); | 93 ASSERT_TRUE(key_original.get()); |
93 | 94 |
94 std::vector<uint8_t> key_info; | 95 std::vector<uint8_t> key_info; |
95 key_original->ExportPrivateKey(&key_info); | 96 key_original->ExportPrivateKey(&key_info); |
96 scoped_ptr<crypto::RSAPrivateKey> key( | 97 std::unique_ptr<crypto::RSAPrivateKey> key( |
97 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); | 98 crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(key_info)); |
98 ASSERT_TRUE(key.get()); | 99 ASSERT_TRUE(key.get()); |
99 | 100 |
100 std::string data("Hello, World!"); | 101 std::string data("Hello, World!"); |
101 std::string sha256 = crypto::SHA256HashString(data); | 102 std::string sha256 = crypto::SHA256HashString(data); |
102 // Sign sha256 of the input data. | 103 // Sign sha256 of the input data. |
103 std::vector<uint8_t> signature; | 104 std::vector<uint8_t> signature; |
104 ASSERT_TRUE(crypto::SignatureCreator::Sign( | 105 ASSERT_TRUE(crypto::SignatureCreator::Sign( |
105 key.get(), crypto::SignatureCreator::HashAlgorithm::SHA256, | 106 key.get(), crypto::SignatureCreator::HashAlgorithm::SHA256, |
106 reinterpret_cast<const uint8_t*>(sha256.c_str()), sha256.size(), | 107 reinterpret_cast<const uint8_t*>(sha256.c_str()), sha256.size(), |
107 &signature)); | 108 &signature)); |
108 | 109 |
109 std::vector<uint8_t> public_key_info; | 110 std::vector<uint8_t> public_key_info; |
110 ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); | 111 ASSERT_TRUE(key_original->ExportPublicKey(&public_key_info)); |
111 | 112 |
112 // Verify the input data. | 113 // Verify the input data. |
113 crypto::SignatureVerifier verifier; | 114 crypto::SignatureVerifier verifier; |
114 ASSERT_TRUE(verifier.VerifyInit( | 115 ASSERT_TRUE(verifier.VerifyInit( |
115 crypto::SignatureVerifier::RSA_PKCS1_SHA256, &signature.front(), | 116 crypto::SignatureVerifier::RSA_PKCS1_SHA256, &signature.front(), |
116 signature.size(), &public_key_info.front(), public_key_info.size())); | 117 signature.size(), &public_key_info.front(), public_key_info.size())); |
117 | 118 |
118 verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), | 119 verifier.VerifyUpdate(reinterpret_cast<const uint8_t*>(data.c_str()), |
119 data.size()); | 120 data.size()); |
120 ASSERT_TRUE(verifier.VerifyFinal()); | 121 ASSERT_TRUE(verifier.VerifyFinal()); |
121 } | 122 } |
OLD | NEW |