OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "webcrypto_impl.h" | 5 #include "webcrypto_impl.h" |
6 | 6 |
7 #include "base/basictypes.h" | 7 #include "base/basictypes.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "base/memory/ref_counted.h" | 9 #include "base/memory/ref_counted.h" |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
11 #include "content/public/renderer/content_renderer_client.h" | 11 #include "content/public/renderer/content_renderer_client.h" |
12 #include "content/renderer/renderer_webkitplatformsupport_impl.h" | 12 #include "content/renderer/renderer_webkitplatformsupport_impl.h" |
13 #include "content/renderer/webcrypto_impl.h" | 13 #include "content/renderer/webcrypto_impl.h" |
14 #include "testing/gtest/include/gtest/gtest.h" | 14 #include "testing/gtest/include/gtest/gtest.h" |
15 #include "third_party/WebKit/public/platform/WebArrayBuffer.h" | 15 #include "third_party/WebKit/public/platform/WebArrayBuffer.h" |
16 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h" | 16 #include "third_party/WebKit/public/platform/WebCryptoAlgorithm.h" |
17 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h" | 17 #include "third_party/WebKit/public/platform/WebCryptoAlgorithmParams.h" |
18 | 18 |
19 namespace content { | 19 namespace content { |
20 | 20 |
21 const WebKit::WebCryptoAlgorithmId kAlgorithmIds[] = { | 21 class WebCryptoImplTest : public testing::Test { |
22 WebKit::WebCryptoAlgorithmIdSha1, | 22 protected: |
Ryan Sleevi
2013/09/24 01:17:11
why protected? Visibility rules are meaningless he
eroman
2013/09/24 01:26:41
These are helper methods used by the test classes.
| |
23 WebKit::WebCryptoAlgorithmIdSha224, | 23 WebKit::WebCryptoKey ImportSecretKeyFromRawHexString( |
24 WebKit::WebCryptoAlgorithmIdSha256, | 24 const std::string& key_hex, |
25 WebKit::WebCryptoAlgorithmIdSha384, | 25 const WebKit::WebCryptoAlgorithm& algorithm, |
26 WebKit::WebCryptoAlgorithmIdSha512 | 26 WebKit::WebCryptoKeyUsageMask usage) { |
27 }; | 27 WebKit::WebCryptoKeyType type; |
28 scoped_ptr<WebKit::WebCryptoKeyHandle> handle; | |
28 | 29 |
29 class WebCryptoImplTest : public testing::Test, public WebCryptoImpl { | 30 std::vector<uint8> key_raw = HexStringToBytes(key_hex); |
31 | |
32 EXPECT_TRUE(crypto_.ImportKeyInternal(WebKit::WebCryptoKeyFormatRaw, | |
33 key_raw.data(), | |
34 key_raw.size(), | |
35 algorithm, | |
36 usage, | |
37 &handle, | |
38 &type)); | |
39 | |
40 EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, type); | |
41 EXPECT_TRUE(handle.get()); | |
42 | |
43 WebKit::WebCryptoKey crypto_key = | |
44 WebKit::WebCryptoKey::create(handle.release(), | |
45 type, | |
46 /*extracatable=*/false, | |
Ryan Sleevi
2013/09/24 01:17:11
This is fairly uncommon style in Chromium code to
eroman
2013/09/24 01:26:41
Removed.
| |
47 algorithm, | |
48 WebKit::WebCryptoKeyUsageSign); | |
49 | |
50 return crypto_key; | |
51 } | |
52 | |
53 std::vector<uint8> HexStringToBytes(const std::string& hex) { | |
54 std::vector<uint8> bytes; | |
55 base::HexStringToBytes(hex, &bytes); | |
56 return bytes; | |
57 } | |
58 | |
59 void ExpectArrayBufferMatchesHex(const std::string& expected_hex, | |
60 const WebKit::WebArrayBuffer& array_buffer) { | |
61 EXPECT_STRCASEEQ( | |
62 expected_hex.c_str(), | |
63 base::HexEncode( | |
64 array_buffer.data(), array_buffer.byteLength()).c_str()); | |
65 } | |
66 | |
67 WebKit::WebCryptoAlgorithm CreateAlgorithm(WebKit::WebCryptoAlgorithmId id) { | |
68 return WebKit::WebCryptoAlgorithm::adoptParamsAndCreate(id, NULL); | |
69 } | |
70 | |
71 WebKit::WebCryptoAlgorithm CreateHmacAlgorithm( | |
72 WebKit::WebCryptoAlgorithmId hashId) { | |
73 return WebKit::WebCryptoAlgorithm::adoptParamsAndCreate( | |
74 WebKit::WebCryptoAlgorithmIdHmac, | |
75 new WebKit::WebCryptoHmacParams(CreateAlgorithm(hashId))); | |
76 } | |
Ryan Sleevi
2013/09/24 01:17:11
Seems like these should all be free functions in a
eroman
2013/09/24 01:26:41
Done.
| |
77 | |
78 WebCryptoImpl crypto_; | |
Ryan Sleevi
2013/09/24 01:17:11
You still have this protected, and it works becaus
eroman
2013/09/24 01:26:41
It is protected so that the individual tests can a
| |
30 }; | 79 }; |
31 | 80 |
32 TEST_F(WebCryptoImplTest, DigestSampleSets) { | 81 TEST_F(WebCryptoImplTest, DigestSampleSets) { |
33 // The results are stored here in hex format for readability. | 82 // The results are stored here in hex format for readability. |
34 // | 83 // |
35 // TODO(bryaneyler): Eventually, all these sample test sets should be replaced | 84 // TODO(bryaneyler): Eventually, all these sample test sets should be replaced |
36 // with the sets here: http://csrc.nist.gov/groups/STM/cavp/index.html#03 | 85 // with the sets here: http://csrc.nist.gov/groups/STM/cavp/index.html#03 |
37 struct { | 86 // |
38 const char* input; | 87 // Results were generated using the command sha{1,224,256,384,512}sum. |
39 unsigned input_length; | 88 struct TestCase { |
40 const char* hex_result[arraysize(kAlgorithmIds)]; | 89 WebKit::WebCryptoAlgorithmId algorithm; |
41 } input_set[] = { | 90 const std::string hex_input; |
42 { | 91 const char* hex_result; |
43 "", 0, | 92 }; |
44 { | 93 |
45 // echo -n "" | sha1sum | 94 const TestCase kTests[] = { |
46 "da39a3ee5e6b4b0d3255bfef95601890afd80709", | 95 { WebKit::WebCryptoAlgorithmIdSha1, "", |
47 // echo -n "" | sha224sum | 96 "da39a3ee5e6b4b0d3255bfef95601890afd80709" |
48 "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f", | |
49 // echo -n "" | sha256sum | |
50 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", | |
51 // echo -n "" | sha384sum | |
52 "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274e" | |
53 "debfe76f65fbd51ad2f14898b95b", | |
54 // echo -n "" | sha512sum | |
55 "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0" | |
56 "d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", | |
57 }, | |
58 }, | 97 }, |
59 { | 98 { WebKit::WebCryptoAlgorithmIdSha224, "", |
60 "\000", 1, | 99 "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f" |
61 { | |
62 // echo -n -e "\000" | sha1sum | |
63 "5ba93c9db0cff93f52b521d7420e43f6eda2784f", | |
64 // echo -n -e "\000" | sha224sum | |
65 "fff9292b4201617bdc4d3053fce02734166a683d7d858a7f5f59b073", | |
66 // echo -n -e "\000" | sha256sum | |
67 "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d", | |
68 // echo -n -e "\000" | sha384sum | |
69 "bec021b4f368e3069134e012c2b4307083d3a9bdd206e24e5f0d86e13d6636655933" | |
70 "ec2b413465966817a9c208a11717", | |
71 // echo -n -e "\000" | sha512sum | |
72 "b8244d028981d693af7b456af8efa4cad63d282e19ff14942c246e50d9351d22704a" | |
73 "802a71c3580b6370de4ceb293c324a8423342557d4e5c38438f0e36910ee", | |
74 }, | |
75 }, | 100 }, |
76 { | 101 { WebKit::WebCryptoAlgorithmIdSha256, "", |
77 "\000\001\002\003\004\005", 6, | 102 "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" |
78 { | 103 }, |
79 // echo -n -e "\000\001\002\003\004\005" | sha1sum | 104 { WebKit::WebCryptoAlgorithmIdSha384, "", |
80 "868460d98d09d8bbb93d7b6cdd15cc7fbec676b9", | 105 "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274e" |
81 // echo -n -e "\000\001\002\003\004\005" | sha224sum | 106 "debfe76f65fbd51ad2f14898b95b" |
82 "7d92e7f1cad1818ed1d13ab41f04ebabfe1fef6bb4cbeebac34c29bc", | 107 }, |
83 // echo -n -e "\000\001\002\003\004\005" | sha256sum | 108 { WebKit::WebCryptoAlgorithmIdSha512, "", |
84 "17e88db187afd62c16e5debf3e6527cd006bc012bc90b51a810cd80c2d511f43", | 109 "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0" |
85 // echo -n -e "\000\001\002\003\004\005" | sha384sum | 110 "d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", |
86 "79f4738706fce9650ac60266675c3cd07298b09923850d525604d040e6e448adc7dc" | 111 }, |
87 "22780d7e1b95bfeaa86a678e4552", | 112 { WebKit::WebCryptoAlgorithmIdSha1, "00", |
88 // echo -n -e "\000\001\002\003\004\005" | sha512sum | 113 "5ba93c9db0cff93f52b521d7420e43f6eda2784f", |
89 "2f3831bccc94cf061bcfa5f8c23c1429d26e3bc6b76edad93d9025cb91c903af6cf9" | 114 }, |
90 "c935dc37193c04c2c66e7d9de17c358284418218afea2160147aaa912f4c", | 115 { WebKit::WebCryptoAlgorithmIdSha224, "00", |
91 }, | 116 "fff9292b4201617bdc4d3053fce02734166a683d7d858a7f5f59b073", |
117 }, | |
118 { WebKit::WebCryptoAlgorithmIdSha256, "00", | |
119 "6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d", | |
120 }, | |
121 { WebKit::WebCryptoAlgorithmIdSha384, "00", | |
122 "bec021b4f368e3069134e012c2b4307083d3a9bdd206e24e5f0d86e13d6636655933" | |
123 "ec2b413465966817a9c208a11717", | |
124 }, | |
125 { WebKit::WebCryptoAlgorithmIdSha512, "00", | |
126 "b8244d028981d693af7b456af8efa4cad63d282e19ff14942c246e50d9351d22704a" | |
127 "802a71c3580b6370de4ceb293c324a8423342557d4e5c38438f0e36910ee", | |
128 }, | |
129 { WebKit::WebCryptoAlgorithmIdSha1, "000102030405", | |
130 "868460d98d09d8bbb93d7b6cdd15cc7fbec676b9", | |
131 }, | |
132 { WebKit::WebCryptoAlgorithmIdSha224, "000102030405", | |
133 "7d92e7f1cad1818ed1d13ab41f04ebabfe1fef6bb4cbeebac34c29bc", | |
134 }, | |
135 { WebKit::WebCryptoAlgorithmIdSha256, "000102030405", | |
136 "17e88db187afd62c16e5debf3e6527cd006bc012bc90b51a810cd80c2d511f43", | |
137 }, | |
138 { WebKit::WebCryptoAlgorithmIdSha384, "000102030405", | |
139 "79f4738706fce9650ac60266675c3cd07298b09923850d525604d040e6e448adc7dc" | |
140 "22780d7e1b95bfeaa86a678e4552", | |
141 }, | |
142 { WebKit::WebCryptoAlgorithmIdSha512, "000102030405", | |
143 "2f3831bccc94cf061bcfa5f8c23c1429d26e3bc6b76edad93d9025cb91c903af6cf9" | |
144 "c935dc37193c04c2c66e7d9de17c358284418218afea2160147aaa912f4c", | |
92 }, | 145 }, |
93 }; | 146 }; |
94 | 147 |
95 for (size_t id_index = 0; id_index < arraysize(kAlgorithmIds); id_index++) { | 148 for (size_t test_index = 0; test_index < ARRAYSIZE_UNSAFE(kTests); |
96 SCOPED_TRACE(id_index); | 149 test_index++) { |
150 SCOPED_TRACE(test_index); | |
151 const TestCase& test = kTests[test_index]; | |
97 | 152 |
98 WebKit::WebCryptoAlgorithm algorithm( | 153 WebKit::WebCryptoAlgorithm algorithm = CreateAlgorithm(test.algorithm); |
99 WebKit::WebCryptoAlgorithm::adoptParamsAndCreate( | 154 std::vector<uint8> input = HexStringToBytes(test.hex_input); |
100 kAlgorithmIds[id_index], NULL)); | |
101 | 155 |
102 for (size_t set_index = 0; | 156 WebKit::WebArrayBuffer output; |
103 set_index < ARRAYSIZE_UNSAFE(input_set); | 157 EXPECT_TRUE( |
104 set_index++) { | 158 crypto_.DigestInternal(algorithm, input.data(), input.size(), &output)); |
105 SCOPED_TRACE(set_index); | 159 ExpectArrayBufferMatchesHex(test.hex_result, output); |
106 | |
107 WebKit::WebArrayBuffer array_buffer; | |
108 | |
109 WebCryptoImpl crypto; | |
110 EXPECT_TRUE( | |
111 crypto.DigestInternal( | |
112 algorithm, | |
113 reinterpret_cast<const unsigned char*>( | |
114 input_set[set_index].input), | |
115 input_set[set_index].input_length, | |
116 &array_buffer)); | |
117 | |
118 // Ignore case, it's checking the hex value. | |
119 EXPECT_STRCASEEQ( | |
120 input_set[set_index].hex_result[id_index], | |
121 base::HexEncode( | |
122 array_buffer.data(), array_buffer.byteLength()).c_str()); | |
123 } | |
124 } | 160 } |
125 } | 161 } |
126 | 162 |
127 TEST_F(WebCryptoImplTest, HMACSampleSets) { | 163 TEST_F(WebCryptoImplTest, HMACSampleSets) { |
128 struct { | 164 struct TestCase { |
129 WebKit::WebCryptoAlgorithmId algorithm; | 165 WebKit::WebCryptoAlgorithmId algorithm; |
130 const char* key; | 166 const char* key; |
131 const char* message; | 167 const char* message; |
132 const char* mac; | 168 const char* mac; |
133 } input_set[] = { | 169 }; |
170 | |
171 const TestCase kTests[] = { | |
134 // Empty sets. Result generated via OpenSSL commandline tool. These | 172 // Empty sets. Result generated via OpenSSL commandline tool. These |
135 // particular results are also posted on the Wikipedia page examples: | 173 // particular results are also posted on the Wikipedia page examples: |
136 // http://en.wikipedia.org/wiki/Hash-based_message_authentication_code | 174 // http://en.wikipedia.org/wiki/Hash-based_message_authentication_code |
137 { | 175 { |
138 WebKit::WebCryptoAlgorithmIdSha1, | 176 WebKit::WebCryptoAlgorithmIdSha1, |
139 "", | 177 "", |
140 "", | 178 "", |
141 // openssl dgst -sha1 -hmac "" < /dev/null | 179 // openssl dgst -sha1 -hmac "" < /dev/null |
142 "fbdb1d1b18aa6c08324b7d64b71fb76370690e1d", | 180 "fbdb1d1b18aa6c08324b7d64b71fb76370690e1d", |
143 }, | 181 }, |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
203 // message | 241 // message |
204 "138efc832c64513d11b9873c6fd4d8a65dbf367092a826ddd587d141b401580b798c69" | 242 "138efc832c64513d11b9873c6fd4d8a65dbf367092a826ddd587d141b401580b798c69" |
205 "025ad510cff05fcfbceb6cf0bb03201aaa32e423d5200925bddfadd418d8e30e18050e" | 243 "025ad510cff05fcfbceb6cf0bb03201aaa32e423d5200925bddfadd418d8e30e18050e" |
206 "b4f0618eb9959d9f78c1157d4b3e02cd5961f138afd57459939917d9144c95d8e6a94c" | 244 "b4f0618eb9959d9f78c1157d4b3e02cd5961f138afd57459939917d9144c95d8e6a94c" |
207 "8f6d4eef3418c17b1ef0b46c2a7188305d9811dccb3d99", | 245 "8f6d4eef3418c17b1ef0b46c2a7188305d9811dccb3d99", |
208 // mac | 246 // mac |
209 "4f1ee7cb36c58803a8721d4ac8c4cf8cae5d8832392eed2a96dc59694252801b", | 247 "4f1ee7cb36c58803a8721d4ac8c4cf8cae5d8832392eed2a96dc59694252801b", |
210 }, | 248 }, |
211 }; | 249 }; |
212 | 250 |
213 for (size_t index = 0; index < ARRAYSIZE_UNSAFE(input_set); index++) { | 251 for (size_t test_index = 0; test_index < ARRAYSIZE_UNSAFE(kTests); |
214 SCOPED_TRACE(index); | 252 test_index++) { |
253 SCOPED_TRACE(test_index); | |
254 const TestCase& test = kTests[test_index]; | |
215 | 255 |
216 WebKit::WebCryptoAlgorithm hash_algorithm( | 256 WebKit::WebCryptoAlgorithm algorithm = CreateHmacAlgorithm(test.algorithm); |
217 WebKit::WebCryptoAlgorithm::adoptParamsAndCreate( | |
218 input_set[index].algorithm, NULL)); | |
219 | 257 |
220 scoped_ptr<WebKit::WebCryptoHmacParams> hmac_params( | 258 WebKit::WebCryptoKey key = ImportSecretKeyFromRawHexString( |
221 new WebKit::WebCryptoHmacParams(hash_algorithm)); | 259 test.key, algorithm, WebKit::WebCryptoKeyUsageSign); |
Ryan Sleevi
2013/09/24 01:17:11
No Verify tests yet?
eroman
2013/09/24 01:26:41
Correct. I believe Bryan is working on verify() ne
| |
222 | 260 |
223 WebKit::WebCryptoAlgorithm hmac_algorithm( | 261 std::vector<uint8> message_raw = HexStringToBytes(test.message); |
224 WebKit::WebCryptoAlgorithm::adoptParamsAndCreate( | |
225 WebKit::WebCryptoAlgorithmIdHmac, hmac_params.release())); | |
226 | 262 |
227 WebKit::WebCryptoKeyType type; | 263 WebKit::WebArrayBuffer output; |
228 scoped_ptr<WebKit::WebCryptoKeyHandle> handle; | |
229 | 264 |
230 std::vector<uint8> key_raw; | 265 EXPECT_TRUE(crypto_.SignInternal( |
231 base::HexStringToBytes(input_set[index].key, &key_raw); | 266 algorithm, key, message_raw.data(), message_raw.size(), &output)); |
232 | 267 |
233 WebCryptoImpl crypto; | 268 ExpectArrayBufferMatchesHex(test.mac, output); |
234 | |
235 EXPECT_TRUE( | |
236 crypto.ImportKeyInternal( | |
237 WebKit::WebCryptoKeyFormatRaw, | |
238 key_raw.data(), | |
239 key_raw.size(), | |
240 hmac_algorithm, | |
241 WebKit::WebCryptoKeyUsageSign, | |
242 &handle, | |
243 &type)); | |
244 | |
245 EXPECT_EQ(WebKit::WebCryptoKeyTypeSecret, type); | |
246 ASSERT_TRUE(handle.get()); | |
247 | |
248 WebKit::WebCryptoKey crypto_key = | |
249 WebKit::WebCryptoKey::create( | |
250 handle.release(), | |
251 type, | |
252 false, | |
253 hmac_algorithm, | |
254 WebKit::WebCryptoKeyUsageSign); | |
255 | |
256 std::vector<uint8> message_raw; | |
257 base::HexStringToBytes(input_set[index].message, &message_raw); | |
258 | |
259 WebKit::WebArrayBuffer array_buffer; | |
260 | |
261 EXPECT_TRUE( | |
262 crypto.SignInternal( | |
263 hmac_algorithm, | |
264 crypto_key, | |
265 message_raw.data(), | |
266 message_raw.size(), | |
267 &array_buffer)); | |
268 | |
269 // Ignore case, it's checking the hex value. | |
270 EXPECT_STRCASEEQ( | |
271 input_set[index].mac, | |
272 base::HexEncode( | |
273 array_buffer.data(), array_buffer.byteLength()).c_str()); | |
274 } | 269 } |
275 } | 270 } |
276 | 271 |
277 } // namespace content | 272 } // namespace content |
OLD | NEW |