5 * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "src/shared/sha1.h"
35 unsigned int password_len;
37 unsigned int salt_len;
43 static void pbkdf2_test(gconstpointer data)
45 const struct pbkdf2_data *test = data;
46 unsigned int password_len;
47 unsigned int salt_len;
49 unsigned char output[25];
54 password_len = test->password_len ? : strlen(test->password);
55 salt_len = test->salt_len ? : strlen(test->salt);
57 key_len = test->key_len ? : (strlen(test->key) / 2);
59 if (g_test_verbose() == TRUE) {
60 g_print("Password = \"%s\" (%d octects)\n",
61 test->password, password_len);
62 g_print("Salt = \"%s\" (%d octects)\n",
63 test->salt, salt_len);
64 g_print("Count = %d\n", test->count);
65 g_print("Key = %s (%d octects)\n", test->key, key_len);
68 result = pbkdf2_sha1(test->password, password_len,
70 test->count, output, key_len);
72 g_assert(result == 0);
74 for (i = 0; i < key_len; i++)
75 sprintf(key + (i * 2), "%02x", output[i]);
77 if (g_test_verbose() == TRUE) {
78 g_print("Result = %s\n", key);
81 g_assert(strcmp(test->key, key) == 0);
84 static const struct pbkdf2_data pbkdf2_test_vector_1 = {
85 .password = "password",
88 .key = "0c60c80f961f0e71f3a9b524af6012062fe037a6",
92 static const struct pbkdf2_data pbkdf2_test_vector_2 = {
93 .password = "password",
96 .key = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957",
100 static const struct pbkdf2_data pbkdf2_test_vector_3 = {
101 .password = "password",
104 .key = "4b007901b765489abead49d926f721d065a429c1",
108 static const struct pbkdf2_data pbkdf2_test_vector_4 = {
109 .password = "password",
112 .key = "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984",
116 static const struct pbkdf2_data pbkdf2_test_vector_5 = {
117 .password = "passwordPASSWORDpassword",
118 .salt = "saltSALTsaltSALTsaltSALTsaltSALTsalt",
120 .key = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038",
124 static const struct pbkdf2_data pbkdf2_test_vector_6 = {
125 .password = "pass\0word",
130 .key = "56fa6aa75548099dcc37d7f03425e0c3",
134 static const struct pbkdf2_data athena_test_vector_1 = {
135 .password = "password",
136 .salt = "ATHENA.MIT.EDUraeburn",
138 .key = "cdedb5281bb2f801565a1122b2563515",
141 static const struct pbkdf2_data athena_test_vector_2 = {
142 .password = "password",
143 .salt = "ATHENA.MIT.EDUraeburn",
145 .key = "01dbee7f4a9e243e988b62c73cda935d",
148 static const struct pbkdf2_data athena_test_vector_3 = {
149 .password = "password",
150 .salt = "ATHENA.MIT.EDUraeburn",
152 .key = "5c08eb61fdf71e4e4ec3cf6ba1f5512b",
155 static const struct pbkdf2_data athena_test_vector_4 = {
156 .password = "password",
157 .salt = "\x12\x34\x56\x78\x78\x56\x34\x12",
159 .key = "d1daa78615f287e6a1c8b120d7062a49",
162 static const struct pbkdf2_data athena_test_vector_5 = {
163 .password = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
164 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
165 .salt = "pass phrase equals block size",
167 .key = "139c30c0966bc32ba55fdbf212530ac9",
170 static const struct pbkdf2_data athena_test_vector_6 = {
171 .password = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
172 "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
173 .salt = "pass phrase exceeds block size",
175 .key = "9ccad6d468770cd51b10e6a68721be61",
178 static const struct pbkdf2_data athena_test_vector_7 = {
179 .password = "\xf0\x9d\x84\x9e", /* g-clef (0xf09d849e) */
180 .salt = "EXAMPLE.COMpianist",
182 .key = "6b9cf26d45455a43a5b8bb276a403b39",
186 const char *passphrase;
187 const unsigned char *ssid;
193 static void psk_test(gconstpointer data)
195 const struct psk_data *test = data;
196 unsigned char ssid[32];
198 unsigned char output[32];
203 if (test->network == NULL) {
204 memcpy(ssid, test->ssid, test->ssid_len);
205 ssid_len = test->ssid_len;
207 ssid_len = strlen(test->network);
208 memcpy(ssid, test->network, ssid_len);
211 if (g_test_verbose() == TRUE) {
212 g_print("Passphrase = \"%s\"\n", test->passphrase);
214 for (i = 0; i < ssid_len; i++)
215 g_print("%s'%c'", i == 0 ? " " : ", ",
218 g_print("SSID Length = %zd\n", ssid_len);
219 g_print("PSK = %s\n", test->psk);
222 result = pbkdf2_sha1(test->passphrase, strlen(test->passphrase),
223 ssid, ssid_len, 4096,
224 output, sizeof(output));
226 g_assert(result == 0);
228 for (i = 0; i < sizeof(output); i++)
229 sprintf(psk + (i * 2), "%02x", output[i]);
231 if (g_test_verbose() == TRUE) {
232 g_print("Result = %s\n", psk);
235 g_assert(strcmp(test->psk, psk) == 0);
238 static const unsigned char psk_test_case_1_ssid[] = { 'I', 'E', 'E', 'E' };
240 static const struct psk_data psk_test_case_1 = {
241 .passphrase = "password",
242 .ssid = psk_test_case_1_ssid,
243 .ssid_len = sizeof(psk_test_case_1_ssid),
244 .psk = "f42c6fc52df0ebef9ebb4b90b38a5f90"
245 "2e83fe1b135a70e23aed762e9710a12e",
248 static const unsigned char psk_test_case_2_ssid[] = { 'T', 'h', 'i', 's',
249 'I', 's', 'A', 'S', 'S', 'I', 'D' };
251 static const struct psk_data psk_test_case_2 = {
252 .passphrase = "ThisIsAPassword",
253 .ssid = psk_test_case_2_ssid,
254 .ssid_len = sizeof(psk_test_case_2_ssid),
255 .psk = "0dc0d6eb90555ed6419756b9a15ec3e3"
256 "209b63df707dd508d14581f8982721af",
259 static const unsigned char psk_test_case_3_ssid[] = {
260 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z',
261 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z',
262 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z',
263 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z' };
265 static const struct psk_data psk_test_case_3 = {
266 .passphrase = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
267 .ssid = psk_test_case_3_ssid,
268 .ssid_len = sizeof(psk_test_case_3_ssid),
269 .psk = "becb93866bb8c3832cb777c2f559807c"
270 "8c59afcb6eae734885001300a981cc62",
273 int main(int argc, char *argv[])
275 g_test_init(&argc, &argv, NULL);
277 g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 1",
278 &pbkdf2_test_vector_1, pbkdf2_test);
279 g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 2",
280 &pbkdf2_test_vector_2, pbkdf2_test);
281 g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 3",
282 &pbkdf2_test_vector_3, pbkdf2_test);
283 g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 4",
284 &pbkdf2_test_vector_4, pbkdf2_test);
285 g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 5",
286 &pbkdf2_test_vector_5, pbkdf2_test);
287 g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 6",
288 &pbkdf2_test_vector_6, pbkdf2_test);
290 g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 1",
291 &athena_test_vector_1, pbkdf2_test);
292 g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 2",
293 &athena_test_vector_2, pbkdf2_test);
294 g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 3",
295 &athena_test_vector_3, pbkdf2_test);
296 g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 4",
297 &athena_test_vector_4, pbkdf2_test);
298 g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 5",
299 &athena_test_vector_5, pbkdf2_test);
300 g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 6",
301 &athena_test_vector_6, pbkdf2_test);
302 g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 7",
303 &athena_test_vector_7, pbkdf2_test);
305 g_test_add_data_func("/pbkdf2-sha1/PSK Test case 1",
306 &psk_test_case_1, psk_test);
307 g_test_add_data_func("/pbkdf2-sha1/PSK Test case 2",
308 &psk_test_case_2, psk_test);
309 g_test_add_data_func("/pbkdf2-sha1/PSK Test case 3",
310 &psk_test_case_3, psk_test);