Debian Codegraph @

external/boringssl/crypto/evp/pbkdf_test.cc

raw
1 /* Copyright (c) 2015, Google Inc.
2 *
3 * Permission to use, copy, modify, and/or distribute this software for any
4 * purpose with or without fee is hereby granted, provided that the above
5 * copyright notice and this permission notice appear in all copies.
6 *
7 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
8 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
9 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
10 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
11 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
12 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
13 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
14
15 #include <stdio.h>
16 #include <string.h>
17
18 #include <openssl/crypto.h>
19 #include <openssl/digest.h>
20 #include <openssl/err.h>
21 #include <openssl/evp.h>
22
23
24 // Prints out the data buffer as a sequence of hex bytes.
25 static void PrintDataHex(const void *data, size_t len) {
26 for (size_t i = 0; i < len; ++i) {
27 fprintf(stderr, "%02x", (int)((const uint8_t *)data)[i]);
28 }
29 }
30
31 // Helper for testing that PBKDF2 derives the expected key from the given
32 // inputs. Returns 1 on success, 0 otherwise.
33 static bool TestPBKDF2(const void *password, size_t password_len,
34 const void *salt, size_t salt_len, unsigned iterations,
35 const EVP_MD *digest, size_t key_len,
36 const uint8_t *expected_key) {
37 uint8_t key[64];
38
39 if (key_len > sizeof(key)) {
40 fprintf(stderr, "Output buffer is not large enough.\n");
41 return false;
42 }
43
44 if (!PKCS5_PBKDF2_HMAC((const char *)password, password_len,
45 (const uint8_t *)salt, salt_len, iterations, digest,
46 key_len, key)) {
47 fprintf(stderr, "Call to PKCS5_PBKDF2_HMAC failed\n");
48 ERR_print_errors_fp(stderr);
49 return false;
50 }
51
52 if (memcmp(key, expected_key, key_len) != 0) {
53 fprintf(stderr, "Resulting key material does not match expectation\n");
54 fprintf(stderr, "Expected:\n ");
55 PrintDataHex(expected_key, key_len);
56 fprintf(stderr, "\nActual:\n ");
57 PrintDataHex(key, key_len);
58 fprintf(stderr, "\n");
59 return false;
60 }
61
62 return true;
63 }
64
65 // Tests deriving a key using an empty password (specified both as NULL and as
66 // non-NULL). Note that NULL has special meaning to HMAC initialization.
67 static bool TestEmptyPassword() {
68 const uint8_t kKey[] = {0xa3, 0x3d, 0xdd, 0xc3, 0x04, 0x78, 0x18,
69 0x55, 0x15, 0x31, 0x1f, 0x87, 0x52, 0x89,
70 0x5d, 0x36, 0xea, 0x43, 0x63, 0xa2};
71
72 if (!TestPBKDF2(NULL, 0, "salt", 4, 1, EVP_sha1(), sizeof(kKey), kKey) ||
73 !TestPBKDF2("", 0, "salt", 4, 1, EVP_sha1(), sizeof(kKey), kKey)) {
74 return false;
75 }
76
77 return true;
78 }
79
80 // Tests deriving a key using an empty salt. Note that the expectation was
81 // generated using OpenSSL itself, and hence is not verified.
82 static bool TestEmptySalt() {
83 const uint8_t kKey[] = {0x8b, 0xc2, 0xf9, 0x16, 0x7a, 0x81, 0xcd, 0xcf,
84 0xad, 0x12, 0x35, 0xcd, 0x90, 0x47, 0xf1, 0x13,
85 0x62, 0x71, 0xc1, 0xf9, 0x78, 0xfc, 0xfc, 0xb3,
86 0x5e, 0x22, 0xdb, 0xea, 0xfa, 0x46, 0x34, 0xf6};
87
88 if (!TestPBKDF2("password", 8, NULL, 0, 2, EVP_sha256(), sizeof(kKey),
89 kKey) ||
90 !TestPBKDF2("password", 8, "", 0, 2, EVP_sha256(), sizeof(kKey), kKey)) {
91 return false;
92 }
93
94 return true;
95 }
96
97 // Exercises test vectors taken from https://tools.ietf.org/html/rfc6070.
98 // Note that each of these test vectors uses SHA-1 as the digest.
99 static bool TestRFC6070Vectors() {
100 const uint8_t kKey1[] = {0x0c, 0x60, 0xc8, 0x0f, 0x96, 0x1f, 0x0e,
101 0x71, 0xf3, 0xa9, 0xb5, 0x24, 0xaf, 0x60,
102 0x12, 0x06, 0x2f, 0xe0, 0x37, 0xa6};
103 const uint8_t kKey2[] = {0xea, 0x6c, 0x01, 0x4d, 0xc7, 0x2d, 0x6f,
104 0x8c, 0xcd, 0x1e, 0xd9, 0x2a, 0xce, 0x1d,
105 0x41, 0xf0, 0xd8, 0xde, 0x89, 0x57};
106 const uint8_t kKey3[] = {0x56, 0xfa, 0x6a, 0xa7, 0x55, 0x48, 0x09, 0x9d,
107 0xcc, 0x37, 0xd7, 0xf0, 0x34, 0x25, 0xe0, 0xc3};
108
109 if (!TestPBKDF2("password", 8, "salt", 4, 1, EVP_sha1(), sizeof(kKey1),
110 kKey1) ||
111 !TestPBKDF2("password", 8, "salt", 4, 2, EVP_sha1(), sizeof(kKey2),
112 kKey2) ||
113 !TestPBKDF2("pass\0word", 9, "sa\0lt", 5, 4096, EVP_sha1(),
114 sizeof(kKey3), kKey3)) {
115 return false;
116 }
117
118 return true;
119 }
120
121 // Tests key derivation using SHA-2 digests.
122 static bool TestSHA2() {
123 // This test was taken from:
124 // http://stackoverflow.com/questions/5130513/pbkdf2-hmac-sha2-test-vectors.
125 const uint8_t kKey1[] = {0xae, 0x4d, 0x0c, 0x95, 0xaf, 0x6b, 0x46, 0xd3,
126 0x2d, 0x0a, 0xdf, 0xf9, 0x28, 0xf0, 0x6d, 0xd0,
127 0x2a, 0x30, 0x3f, 0x8e, 0xf3, 0xc2, 0x51, 0xdf,
128 0xd6, 0xe2, 0xd8, 0x5a, 0x95, 0x47, 0x4c, 0x43};
129
130 // This test was taken from:
131 // http://stackoverflow.com/questions/15593184/pbkdf2-hmac-sha-512-test-vectors.
132 const uint8_t kKey2[] = {
133 0x8c, 0x05, 0x11, 0xf4, 0xc6, 0xe5, 0x97, 0xc6, 0xac, 0x63, 0x15,
134 0xd8, 0xf0, 0x36, 0x2e, 0x22, 0x5f, 0x3c, 0x50, 0x14, 0x95, 0xba,
135 0x23, 0xb8, 0x68, 0xc0, 0x05, 0x17, 0x4d, 0xc4, 0xee, 0x71, 0x11,
136 0x5b, 0x59, 0xf9, 0xe6, 0x0c, 0xd9, 0x53, 0x2f, 0xa3, 0x3e, 0x0f,
137 0x75, 0xae, 0xfe, 0x30, 0x22, 0x5c, 0x58, 0x3a, 0x18, 0x6c, 0xd8,
138 0x2b, 0xd4, 0xda, 0xea, 0x97, 0x24, 0xa3, 0xd3, 0xb8};
139
140 if (!TestPBKDF2("password", 8, "salt", 4, 2, EVP_sha256(), sizeof(kKey1),
141 kKey1) ||
142 !TestPBKDF2("passwordPASSWORDpassword", 24,
143 "saltSALTsaltSALTsaltSALTsaltSALTsalt", 36, 4096,
144 EVP_sha512(), sizeof(kKey2), kKey2)) {
145 return false;
146 }
147
148 return true;
149 }
150
151 // Tests key derivation using iterations=0.
152 //
153 // RFC 2898 defines the iteration count (c) as a "positive integer". So doing a
154 // key derivation with iterations=0 is ill-defined and should result in a
155 // failure.
156 static bool TestZeroIterations() {
157 static const char kPassword[] = "password";
158 const size_t password_len = strlen(kPassword);
159 static const uint8_t kSalt[] = {1, 2, 3, 4};
160 const size_t salt_len = sizeof(kSalt);
161 const EVP_MD *digest = EVP_sha1();
162
163 uint8_t key[10] = {0};
164 const size_t key_len = sizeof(key);
165
166 // Verify that calling with iterations=1 works.
167 if (!PKCS5_PBKDF2_HMAC(kPassword, password_len, kSalt, salt_len,
168 1 /* iterations */, digest, key_len, key)) {
169 fprintf(stderr, "PBKDF2 failed with iterations=1\n");
170 return false;
171 }
172
173 // Flip the first key byte (so can later test if it got set).
174 const uint8_t expected_first_byte = key[0];
175 key[0] = ~key[0];
176
177 // However calling it with iterations=0 fails.
178 if (PKCS5_PBKDF2_HMAC(kPassword, password_len, kSalt, salt_len,
179 0 /* iterations */, digest, key_len, key)) {
180 fprintf(stderr, "PBKDF2 returned zero with iterations=0\n");
181 return false;
182 }
183
184 // For backwards compatibility, the iterations == 0 case still fills in
185 // the out key.
186 return key[0] == expected_first_byte;
187 }
188
189 int main(void) {
190 CRYPTO_library_init();
191
192 if (!TestEmptyPassword()) {
193 fprintf(stderr, "TestEmptyPassword failed\n");
194 return 1;
195 }
196
197 if (!TestEmptySalt()) {
198 fprintf(stderr, "TestEmptySalt failed\n");
199 return 1;
200 }
201
202 if (!TestRFC6070Vectors()) {
203 fprintf(stderr, "TestRFC6070Vectors failed\n");
204 return 1;
205 }
206
207 if (!TestSHA2()) {
208 fprintf(stderr, "TestSHA2 failed\n");
209 return 1;
210 }
211
212 if (!TestZeroIterations()) {
213 fprintf(stderr, "TestZeroIterations failed\n");
214 return 1;
215 }
216
217 printf("PASS\n");
218 ERR_free_strings();
219 return 0;
220 }