OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 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 | 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/symmetric_key.h" | 5 #include "crypto/symmetric_key.h" |
6 | 6 |
| 7 #include <memory> |
7 #include <string> | 8 #include <string> |
8 | 9 |
9 #include "base/memory/scoped_ptr.h" | |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
11 #include "base/strings/string_util.h" | 11 #include "base/strings/string_util.h" |
12 #include "testing/gtest/include/gtest/gtest.h" | 12 #include "testing/gtest/include/gtest/gtest.h" |
13 | 13 |
14 TEST(SymmetricKeyTest, GenerateRandomKey) { | 14 TEST(SymmetricKeyTest, GenerateRandomKey) { |
15 scoped_ptr<crypto::SymmetricKey> key( | 15 std::unique_ptr<crypto::SymmetricKey> key( |
16 crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256)); | 16 crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256)); |
17 ASSERT_TRUE(NULL != key.get()); | 17 ASSERT_TRUE(NULL != key.get()); |
18 std::string raw_key; | 18 std::string raw_key; |
19 EXPECT_TRUE(key->GetRawKey(&raw_key)); | 19 EXPECT_TRUE(key->GetRawKey(&raw_key)); |
20 EXPECT_EQ(32U, raw_key.size()); | 20 EXPECT_EQ(32U, raw_key.size()); |
21 | 21 |
22 // Do it again and check that the keys are different. | 22 // Do it again and check that the keys are different. |
23 // (Note: this has a one-in-10^77 chance of failure!) | 23 // (Note: this has a one-in-10^77 chance of failure!) |
24 scoped_ptr<crypto::SymmetricKey> key2( | 24 std::unique_ptr<crypto::SymmetricKey> key2( |
25 crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256)); | 25 crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256)); |
26 ASSERT_TRUE(NULL != key2.get()); | 26 ASSERT_TRUE(NULL != key2.get()); |
27 std::string raw_key2; | 27 std::string raw_key2; |
28 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); | 28 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); |
29 EXPECT_EQ(32U, raw_key2.size()); | 29 EXPECT_EQ(32U, raw_key2.size()); |
30 EXPECT_NE(raw_key, raw_key2); | 30 EXPECT_NE(raw_key, raw_key2); |
31 } | 31 } |
32 | 32 |
33 TEST(SymmetricKeyTest, ImportGeneratedKey) { | 33 TEST(SymmetricKeyTest, ImportGeneratedKey) { |
34 scoped_ptr<crypto::SymmetricKey> key1( | 34 std::unique_ptr<crypto::SymmetricKey> key1( |
35 crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256)); | 35 crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256)); |
36 ASSERT_TRUE(NULL != key1.get()); | 36 ASSERT_TRUE(NULL != key1.get()); |
37 std::string raw_key1; | 37 std::string raw_key1; |
38 EXPECT_TRUE(key1->GetRawKey(&raw_key1)); | 38 EXPECT_TRUE(key1->GetRawKey(&raw_key1)); |
39 | 39 |
40 scoped_ptr<crypto::SymmetricKey> key2( | 40 std::unique_ptr<crypto::SymmetricKey> key2( |
41 crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, raw_key1)); | 41 crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, raw_key1)); |
42 ASSERT_TRUE(NULL != key2.get()); | 42 ASSERT_TRUE(NULL != key2.get()); |
43 | 43 |
44 std::string raw_key2; | 44 std::string raw_key2; |
45 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); | 45 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); |
46 | 46 |
47 EXPECT_EQ(raw_key1, raw_key2); | 47 EXPECT_EQ(raw_key1, raw_key2); |
48 } | 48 } |
49 | 49 |
50 TEST(SymmetricKeyTest, ImportDerivedKey) { | 50 TEST(SymmetricKeyTest, ImportDerivedKey) { |
51 scoped_ptr<crypto::SymmetricKey> key1( | 51 std::unique_ptr<crypto::SymmetricKey> key1( |
52 crypto::SymmetricKey::DeriveKeyFromPassword( | 52 crypto::SymmetricKey::DeriveKeyFromPassword( |
53 crypto::SymmetricKey::HMAC_SHA1, "password", "somesalt", 1024, 160)); | 53 crypto::SymmetricKey::HMAC_SHA1, "password", "somesalt", 1024, 160)); |
54 ASSERT_TRUE(NULL != key1.get()); | 54 ASSERT_TRUE(NULL != key1.get()); |
55 std::string raw_key1; | 55 std::string raw_key1; |
56 EXPECT_TRUE(key1->GetRawKey(&raw_key1)); | 56 EXPECT_TRUE(key1->GetRawKey(&raw_key1)); |
57 | 57 |
58 scoped_ptr<crypto::SymmetricKey> key2( | 58 std::unique_ptr<crypto::SymmetricKey> key2( |
59 crypto::SymmetricKey::Import(crypto::SymmetricKey::HMAC_SHA1, raw_key1)); | 59 crypto::SymmetricKey::Import(crypto::SymmetricKey::HMAC_SHA1, raw_key1)); |
60 ASSERT_TRUE(NULL != key2.get()); | 60 ASSERT_TRUE(NULL != key2.get()); |
61 | 61 |
62 std::string raw_key2; | 62 std::string raw_key2; |
63 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); | 63 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); |
64 | 64 |
65 EXPECT_EQ(raw_key1, raw_key2); | 65 EXPECT_EQ(raw_key1, raw_key2); |
66 } | 66 } |
67 | 67 |
68 struct PBKDF2TestVector { | 68 struct PBKDF2TestVector { |
(...skipping 13 matching lines...) Expand all Loading... |
82 PBKDF2TestVector test_data(GetParam()); | 82 PBKDF2TestVector test_data(GetParam()); |
83 #if defined(OS_MACOSX) && !defined(OS_IOS) | 83 #if defined(OS_MACOSX) && !defined(OS_IOS) |
84 // The OS X crypto libraries have minimum salt and iteration requirements | 84 // The OS X crypto libraries have minimum salt and iteration requirements |
85 // so some of the tests below will cause them to barf. Skip these. | 85 // so some of the tests below will cause them to barf. Skip these. |
86 if (strlen(test_data.salt) < 8 || test_data.rounds < 1000) { | 86 if (strlen(test_data.salt) < 8 || test_data.rounds < 1000) { |
87 VLOG(1) << "Skipped test vector for " << test_data.expected; | 87 VLOG(1) << "Skipped test vector for " << test_data.expected; |
88 return; | 88 return; |
89 } | 89 } |
90 #endif // OS_MACOSX | 90 #endif // OS_MACOSX |
91 | 91 |
92 scoped_ptr<crypto::SymmetricKey> key( | 92 std::unique_ptr<crypto::SymmetricKey> key( |
93 crypto::SymmetricKey::DeriveKeyFromPassword( | 93 crypto::SymmetricKey::DeriveKeyFromPassword( |
94 test_data.algorithm, | 94 test_data.algorithm, test_data.password, test_data.salt, |
95 test_data.password, test_data.salt, | |
96 test_data.rounds, test_data.key_size_in_bits)); | 95 test_data.rounds, test_data.key_size_in_bits)); |
97 ASSERT_TRUE(NULL != key.get()); | 96 ASSERT_TRUE(NULL != key.get()); |
98 | 97 |
99 std::string raw_key; | 98 std::string raw_key; |
100 key->GetRawKey(&raw_key); | 99 key->GetRawKey(&raw_key); |
101 EXPECT_EQ(test_data.key_size_in_bits / 8, raw_key.size()); | 100 EXPECT_EQ(test_data.key_size_in_bits / 8, raw_key.size()); |
102 EXPECT_EQ(test_data.expected, | 101 EXPECT_EQ(test_data.expected, |
103 base::ToLowerASCII(base::HexEncode(raw_key.data(), | 102 base::ToLowerASCII(base::HexEncode(raw_key.data(), |
104 raw_key.size()))); | 103 raw_key.size()))); |
105 } | 104 } |
(...skipping 110 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
216 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", | 215 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", |
217 "pass phrase exceeds block size", | 216 "pass phrase exceeds block size", |
218 20, | 217 20, |
219 256, | 218 256, |
220 "e0739745dc28b8721ba402e05214d2ac1eab54cf72bee1fba388297a09eb493c", | 219 "e0739745dc28b8721ba402e05214d2ac1eab54cf72bee1fba388297a09eb493c", |
221 }, | 220 }, |
222 }; | 221 }; |
223 | 222 |
224 INSTANTIATE_TEST_CASE_P(, SymmetricKeyDeriveKeyFromPasswordTest, | 223 INSTANTIATE_TEST_CASE_P(, SymmetricKeyDeriveKeyFromPasswordTest, |
225 testing::ValuesIn(kTestVectors)); | 224 testing::ValuesIn(kTestVectors)); |
OLD | NEW |