| 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 "base/crypto/symmetric_key.h" | |
| 6 | |
| 7 #include <string> | |
| 8 | |
| 9 #include "base/memory/scoped_ptr.h" | |
| 10 #include "base/string_number_conversions.h" | |
| 11 #include "base/string_util.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 TEST(SymmetricKeyTest, GenerateRandomKey) { | |
| 15 scoped_ptr<base::SymmetricKey> key( | |
| 16 base::SymmetricKey::GenerateRandomKey(base::SymmetricKey::AES, 256)); | |
| 17 ASSERT_TRUE(NULL != key.get()); | |
| 18 std::string raw_key; | |
| 19 EXPECT_TRUE(key->GetRawKey(&raw_key)); | |
| 20 EXPECT_EQ(32U, raw_key.size()); | |
| 21 | |
| 22 // Do it again and check that the keys are different. | |
| 23 // (Note: this has a one-in-10^77 chance of failure!) | |
| 24 scoped_ptr<base::SymmetricKey> key2( | |
| 25 base::SymmetricKey::GenerateRandomKey(base::SymmetricKey::AES, 256)); | |
| 26 ASSERT_TRUE(NULL != key2.get()); | |
| 27 std::string raw_key2; | |
| 28 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); | |
| 29 EXPECT_EQ(32U, raw_key2.size()); | |
| 30 EXPECT_NE(raw_key, raw_key2); | |
| 31 } | |
| 32 | |
| 33 TEST(SymmetricKeyTest, ImportGeneratedKey) { | |
| 34 scoped_ptr<base::SymmetricKey> key1( | |
| 35 base::SymmetricKey::GenerateRandomKey(base::SymmetricKey::AES, 256)); | |
| 36 ASSERT_TRUE(NULL != key1.get()); | |
| 37 std::string raw_key1; | |
| 38 EXPECT_TRUE(key1->GetRawKey(&raw_key1)); | |
| 39 | |
| 40 scoped_ptr<base::SymmetricKey> key2( | |
| 41 base::SymmetricKey::Import(base::SymmetricKey::AES, raw_key1)); | |
| 42 ASSERT_TRUE(NULL != key2.get()); | |
| 43 | |
| 44 std::string raw_key2; | |
| 45 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); | |
| 46 | |
| 47 EXPECT_EQ(raw_key1, raw_key2); | |
| 48 } | |
| 49 | |
| 50 TEST(SymmetricKeyTest, ImportDerivedKey) { | |
| 51 scoped_ptr<base::SymmetricKey> key1( | |
| 52 base::SymmetricKey::DeriveKeyFromPassword(base::SymmetricKey::HMAC_SHA1, | |
| 53 "password", "somesalt", 1024, | |
| 54 160)); | |
| 55 ASSERT_TRUE(NULL != key1.get()); | |
| 56 std::string raw_key1; | |
| 57 EXPECT_TRUE(key1->GetRawKey(&raw_key1)); | |
| 58 | |
| 59 scoped_ptr<base::SymmetricKey> key2( | |
| 60 base::SymmetricKey::Import(base::SymmetricKey::HMAC_SHA1, raw_key1)); | |
| 61 ASSERT_TRUE(NULL != key2.get()); | |
| 62 | |
| 63 std::string raw_key2; | |
| 64 EXPECT_TRUE(key2->GetRawKey(&raw_key2)); | |
| 65 | |
| 66 EXPECT_EQ(raw_key1, raw_key2); | |
| 67 } | |
| 68 | |
| 69 struct PBKDF2TestVector { | |
| 70 base::SymmetricKey::Algorithm algorithm; | |
| 71 const char* password; | |
| 72 const char* salt; | |
| 73 unsigned int rounds; | |
| 74 unsigned int key_size_in_bits; | |
| 75 const char* expected; // ASCII encoded hex bytes | |
| 76 }; | |
| 77 | |
| 78 class SymmetricKeyDeriveKeyFromPasswordTest | |
| 79 : public testing::TestWithParam<PBKDF2TestVector> { | |
| 80 }; | |
| 81 | |
| 82 TEST_P(SymmetricKeyDeriveKeyFromPasswordTest, DeriveKeyFromPassword) { | |
| 83 PBKDF2TestVector test_data(GetParam()); | |
| 84 #if defined(OS_MACOSX) | |
| 85 // The OS X crypto libraries have minimum salt and iteration requirements | |
| 86 // so some of the tests below will cause them to barf. Skip these. | |
| 87 if (strlen(test_data.salt) < 8 || test_data.rounds < 1000) { | |
| 88 VLOG(1) << "Skipped test vector for " << test_data.expected; | |
| 89 return; | |
| 90 } | |
| 91 #endif // OS_MACOSX | |
| 92 | |
| 93 scoped_ptr<base::SymmetricKey> key( | |
| 94 base::SymmetricKey::DeriveKeyFromPassword( | |
| 95 test_data.algorithm, | |
| 96 test_data.password, test_data.salt, | |
| 97 test_data.rounds, test_data.key_size_in_bits)); | |
| 98 ASSERT_TRUE(NULL != key.get()); | |
| 99 | |
| 100 std::string raw_key; | |
| 101 key->GetRawKey(&raw_key); | |
| 102 EXPECT_EQ(test_data.key_size_in_bits / 8, raw_key.size()); | |
| 103 EXPECT_EQ(test_data.expected, | |
| 104 StringToLowerASCII(base::HexEncode(raw_key.data(), | |
| 105 raw_key.size()))); | |
| 106 } | |
| 107 | |
| 108 static const PBKDF2TestVector kTestVectors[] = { | |
| 109 // These tests come from | |
| 110 // http://www.ietf.org/id/draft-josefsson-pbkdf2-test-vectors-00.txt | |
| 111 { | |
| 112 base::SymmetricKey::HMAC_SHA1, | |
| 113 "password", | |
| 114 "salt", | |
| 115 1, | |
| 116 160, | |
| 117 "0c60c80f961f0e71f3a9b524af6012062fe037a6", | |
| 118 }, | |
| 119 { | |
| 120 base::SymmetricKey::HMAC_SHA1, | |
| 121 "password", | |
| 122 "salt", | |
| 123 2, | |
| 124 160, | |
| 125 "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957", | |
| 126 }, | |
| 127 { | |
| 128 base::SymmetricKey::HMAC_SHA1, | |
| 129 "password", | |
| 130 "salt", | |
| 131 4096, | |
| 132 160, | |
| 133 "4b007901b765489abead49d926f721d065a429c1", | |
| 134 }, | |
| 135 // This test takes over 30s to run on the trybots. | |
| 136 #if 0 | |
| 137 { | |
| 138 base::SymmetricKey::HMAC_SHA1, | |
| 139 "password", | |
| 140 "salt", | |
| 141 16777216, | |
| 142 160, | |
| 143 "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984", | |
| 144 }, | |
| 145 #endif | |
| 146 | |
| 147 // These tests come from RFC 3962, via BSD source code at | |
| 148 // http://www.openbsd.org/cgi-bin/cvsweb/src/sbin/bioctl/pbkdf2.c?rev=HEAD&con
tent-type=text/plain | |
| 149 { | |
| 150 base::SymmetricKey::HMAC_SHA1, | |
| 151 "password", | |
| 152 "ATHENA.MIT.EDUraeburn", | |
| 153 1, | |
| 154 160, | |
| 155 "cdedb5281bb2f801565a1122b25635150ad1f7a0", | |
| 156 }, | |
| 157 { | |
| 158 base::SymmetricKey::HMAC_SHA1, | |
| 159 "password", | |
| 160 "ATHENA.MIT.EDUraeburn", | |
| 161 2, | |
| 162 160, | |
| 163 "01dbee7f4a9e243e988b62c73cda935da05378b9", | |
| 164 }, | |
| 165 { | |
| 166 base::SymmetricKey::HMAC_SHA1, | |
| 167 "password", | |
| 168 "ATHENA.MIT.EDUraeburn", | |
| 169 1200, | |
| 170 160, | |
| 171 "5c08eb61fdf71e4e4ec3cf6ba1f5512ba7e52ddb", | |
| 172 }, | |
| 173 { | |
| 174 base::SymmetricKey::HMAC_SHA1, | |
| 175 "password", | |
| 176 "\0224VxxV4\022", /* 0x1234567878563412 */ | |
| 177 5, | |
| 178 160, | |
| 179 "d1daa78615f287e6a1c8b120d7062a493f98d203", | |
| 180 }, | |
| 181 { | |
| 182 base::SymmetricKey::HMAC_SHA1, | |
| 183 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", | |
| 184 "pass phrase equals block size", | |
| 185 1200, | |
| 186 160, | |
| 187 "139c30c0966bc32ba55fdbf212530ac9c5ec59f1", | |
| 188 }, | |
| 189 { | |
| 190 base::SymmetricKey::HMAC_SHA1, | |
| 191 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", | |
| 192 "pass phrase exceeds block size", | |
| 193 1200, | |
| 194 160, | |
| 195 "9ccad6d468770cd51b10e6a68721be611a8b4d28", | |
| 196 }, | |
| 197 { | |
| 198 base::SymmetricKey::HMAC_SHA1, | |
| 199 "\360\235\204\236", /* g-clef (0xf09d849e) */ | |
| 200 "EXAMPLE.COMpianist", | |
| 201 50, | |
| 202 160, | |
| 203 "6b9cf26d45455a43a5b8bb276a403b39e7fe37a0", | |
| 204 }, | |
| 205 | |
| 206 // Regression tests for AES keys, derived from the Linux NSS implementation. | |
| 207 { | |
| 208 base::SymmetricKey::AES, | |
| 209 "A test password", | |
| 210 "saltsalt", | |
| 211 1, | |
| 212 256, | |
| 213 "44899a7777f0e6e8b752f875f02044b8ac593de146de896f2e8a816e315a36de", | |
| 214 }, | |
| 215 { | |
| 216 base::SymmetricKey::AES, | |
| 217 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", | |
| 218 "pass phrase exceeds block size", | |
| 219 20, | |
| 220 256, | |
| 221 "e0739745dc28b8721ba402e05214d2ac1eab54cf72bee1fba388297a09eb493c", | |
| 222 }, | |
| 223 }; | |
| 224 | |
| 225 INSTANTIATE_TEST_CASE_P(, SymmetricKeyDeriveKeyFromPasswordTest, | |
| 226 testing::ValuesIn(kTestVectors)); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 6805019:
Move crypto files out of base, to a top level directory. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src/