crypto/symmetric_key_unittest.cc

   1 // Copyright 2011 The Chromium Authors
   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/symmetric_key.h"
   6
   7 #include <memory>
   8 #include <string>
   9
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/string_util.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 TEST(SymmetricKeyTest, GenerateRandomKey) {
  15   std::unique_ptr<crypto::SymmetricKey> key(
  16       crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256));
  17   ASSERT_TRUE(key);
  18   EXPECT_EQ(32U, key->key().size());
  19
  20   // Do it again and check that the keys are different.
  21   // (Note: this has a one-in-10^77 chance of failure!)
  22   std::unique_ptr<crypto::SymmetricKey> key2(
  23       crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256));
  24   ASSERT_TRUE(key2);
  25   EXPECT_EQ(32U, key2->key().size());
  26   EXPECT_NE(key->key(), key2->key());
  27 }
  28
  29 TEST(SymmetricKeyTest, ImportGeneratedKey) {
  30   std::unique_ptr<crypto::SymmetricKey> key1(
  31       crypto::SymmetricKey::GenerateRandomKey(crypto::SymmetricKey::AES, 256));
  32   ASSERT_TRUE(key1);
  33
  34   std::unique_ptr<crypto::SymmetricKey> key2(
  35       crypto::SymmetricKey::Import(crypto::SymmetricKey::AES, key1->key()));
  36   ASSERT_TRUE(key2);
  37
  38   EXPECT_EQ(key1->key(), key2->key());
  39 }
  40
  41 TEST(SymmetricKeyTest, ImportDerivedKey) {
  42   std::unique_ptr<crypto::SymmetricKey> key1(
  43       crypto::SymmetricKey::DeriveKeyFromPasswordUsingPbkdf2(
  44           crypto::SymmetricKey::HMAC_SHA1, "password", "somesalt", 1024, 160));
  45   ASSERT_TRUE(key1);
  46
  47   std::unique_ptr<crypto::SymmetricKey> key2(crypto::SymmetricKey::Import(
  48       crypto::SymmetricKey::HMAC_SHA1, key1->key()));
  49   ASSERT_TRUE(key2);
  50
  51   EXPECT_EQ(key1->key(), key2->key());
  52 }
  53
  54 struct PBKDF2TestVector {
  55   crypto::SymmetricKey::Algorithm algorithm;
  56   const char* password;
  57   const char* salt;
  58   unsigned int rounds;
  59   unsigned int key_size_in_bits;
  60   const char* expected;  // ASCII encoded hex bytes.
  61 };
  62
  63 struct ScryptTestVector {
  64   crypto::SymmetricKey::Algorithm algorithm;
  65   const char* password;
  66   const char* salt;
  67   unsigned int cost_parameter;
  68   unsigned int block_size;
  69   unsigned int parallelization_parameter;
  70   unsigned int key_size_in_bits;
  71   const char* expected;  // ASCII encoded hex bytes.
  72 };
  73
  74 class SymmetricKeyDeriveKeyFromPasswordUsingPbkdf2Test
  75     : public testing::TestWithParam<PBKDF2TestVector> {};
  76
  77 class SymmetricKeyDeriveKeyFromPasswordUsingScryptTest
  78     : public testing::TestWithParam<ScryptTestVector> {};
  79
  80 TEST_P(SymmetricKeyDeriveKeyFromPasswordUsingPbkdf2Test,
  81        DeriveKeyFromPasswordUsingPbkdf2) {
  82   PBKDF2TestVector test_data(GetParam());
  83   std::unique_ptr<crypto::SymmetricKey> key(
  84       crypto::SymmetricKey::DeriveKeyFromPasswordUsingPbkdf2(
  85           test_data.algorithm, test_data.password, test_data.salt,
  86           test_data.rounds, test_data.key_size_in_bits));
  87   ASSERT_TRUE(key);
  88
  89   const std::string& raw_key = key->key();
  90   EXPECT_EQ(test_data.key_size_in_bits / 8, raw_key.size());
  91   EXPECT_EQ(test_data.expected,
  92             base::ToLowerASCII(base::HexEncode(raw_key.data(),
  93                                                raw_key.size())));
  94 }
  95
  96 TEST_P(SymmetricKeyDeriveKeyFromPasswordUsingScryptTest,
  97        DeriveKeyFromPasswordUsingScrypt) {
  98   const int kScryptMaxMemoryBytes = 128 * 1024 * 1024;  // 128 MiB.
  99
 100   ScryptTestVector test_data(GetParam());
 101   std::unique_ptr<crypto::SymmetricKey> key(
 102       crypto::SymmetricKey::DeriveKeyFromPasswordUsingScrypt(
 103           test_data.algorithm, test_data.password, test_data.salt,
 104           test_data.cost_parameter, test_data.block_size,
 105           test_data.parallelization_parameter, kScryptMaxMemoryBytes,
 106           test_data.key_size_in_bits));
 107   ASSERT_TRUE(key);
 108
 109   const std::string& raw_key = key->key();
 110   EXPECT_EQ(test_data.key_size_in_bits / 8, raw_key.size());
 111   EXPECT_EQ(test_data.expected, base::ToLowerASCII(base::HexEncode(
 112                                     raw_key.data(), raw_key.size())));
 113 }
 114
 115 static const PBKDF2TestVector kTestVectorsPbkdf2[] = {
 116     // These tests come from
 117     // http://www.ietf.org/id/draft-josefsson-pbkdf2-test-vectors-00.txt.
 118     {
 119         crypto::SymmetricKey::HMAC_SHA1, "password", "salt", 1, 160,
 120         "0c60c80f961f0e71f3a9b524af6012062fe037a6",
 121     },
 122     {
 123         crypto::SymmetricKey::HMAC_SHA1, "password", "salt", 2, 160,
 124         "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957",
 125     },
 126     {
 127         crypto::SymmetricKey::HMAC_SHA1, "password", "salt", 4096, 160,
 128         "4b007901b765489abead49d926f721d065a429c1",
 129     },
 130 // This test takes over 30s to run on the trybots.
 131 #if 0
 132   {
 133     crypto::SymmetricKey::HMAC_SHA1,
 134     "password",
 135     "salt",
 136     16777216,
 137     160,
 138     "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984",
 139   },
 140 #endif
 141
 142     // These tests come from RFC 3962, via BSD source code at
 143     // http://www.openbsd.org/cgi-bin/cvsweb/src/sbin/bioctl/pbkdf2.c?rev=HEAD&content-type=text/plain.
 144     {
 145         crypto::SymmetricKey::HMAC_SHA1, "password", "ATHENA.MIT.EDUraeburn", 1,
 146         160, "cdedb5281bb2f801565a1122b25635150ad1f7a0",
 147     },
 148     {
 149         crypto::SymmetricKey::HMAC_SHA1, "password", "ATHENA.MIT.EDUraeburn", 2,
 150         160, "01dbee7f4a9e243e988b62c73cda935da05378b9",
 151     },
 152     {
 153         crypto::SymmetricKey::HMAC_SHA1, "password", "ATHENA.MIT.EDUraeburn",
 154         1200, 160, "5c08eb61fdf71e4e4ec3cf6ba1f5512ba7e52ddb",
 155     },
 156     {
 157         crypto::SymmetricKey::HMAC_SHA1, "password",
 158         "\022"
 159         "4VxxV4\022", /* 0x1234567878563412 */
 160         5, 160, "d1daa78615f287e6a1c8b120d7062a493f98d203",
 161     },
 162     {
 163         crypto::SymmetricKey::HMAC_SHA1,
 164         "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 165         "pass phrase equals block size", 1200, 160,
 166         "139c30c0966bc32ba55fdbf212530ac9c5ec59f1",
 167     },
 168     {
 169         crypto::SymmetricKey::HMAC_SHA1,
 170         "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 171         "pass phrase exceeds block size", 1200, 160,
 172         "9ccad6d468770cd51b10e6a68721be611a8b4d28",
 173     },
 174     {
 175         crypto::SymmetricKey::HMAC_SHA1,
 176         "\360\235\204\236", /* g-clef (0xf09d849e) */
 177         "EXAMPLE.COMpianist", 50, 160,
 178         "6b9cf26d45455a43a5b8bb276a403b39e7fe37a0",
 179     },
 180
 181     // Regression tests for AES keys, derived from the Linux NSS implementation.
 182     {
 183         crypto::SymmetricKey::AES, "A test password", "saltsalt", 1, 256,
 184         "44899a7777f0e6e8b752f875f02044b8ac593de146de896f2e8a816e315a36de",
 185     },
 186     {
 187         crypto::SymmetricKey::AES,
 188         "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 189         "pass phrase exceeds block size", 20, 256,
 190         "e0739745dc28b8721ba402e05214d2ac1eab54cf72bee1fba388297a09eb493c",
 191     },
 192 };
 193
 194 static const ScryptTestVector kTestVectorsScrypt[] = {
 195     // From RFC 7914, "The scrypt Password-Based Key Derivation Function",
 196     // https://tools.ietf.org/html/rfc7914.html. The fourth test vector is
 197     // intentionally not used, as it would make the test significantly slower,
 198     // due to the very high cost parameter.
 199     {crypto::SymmetricKey::HMAC_SHA1, "", "", 16, 1, 1, 512,
 200      "77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442fcd0069de"
 201      "d0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906"},
 202     {crypto::SymmetricKey::HMAC_SHA1, "password", "NaCl", 1024, 8, 16, 512,
 203      "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b3731622eaf30d92"
 204      "e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640"},
 205     {crypto::SymmetricKey::HMAC_SHA1, "pleaseletmein", "SodiumChloride", 16384,
 206      8, 1, 512,
 207      "7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2d54329556"
 208      "13f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887"}};
 209
 210 INSTANTIATE_TEST_SUITE_P(All,
 211                          SymmetricKeyDeriveKeyFromPasswordUsingPbkdf2Test,
 212                          testing::ValuesIn(kTestVectorsPbkdf2));
 213
 214 INSTANTIATE_TEST_SUITE_P(All,
 215                          SymmetricKeyDeriveKeyFromPasswordUsingScryptTest,
 216                          testing::ValuesIn(kTestVectorsScrypt));