unit/test-pbkdf2-sha1.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
   6  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include <glib.h>
  30
  31 #include "src/shared/sha1.h"
  32
  33 struct pbkdf2_data {
  34         const char *password;
  35         unsigned int password_len;
  36         const char *salt;
  37         unsigned int salt_len;
  38         unsigned int count;
  39         unsigned int key_len;
  40         const char *key;
  41 };
  42
  43 static void pbkdf2_test(gconstpointer data)
  44 {
  45         const struct pbkdf2_data *test = data;
  46         unsigned int password_len;
  47         unsigned int salt_len;
  48         unsigned int key_len;
  49         unsigned char output[25];
  50         char key[50];
  51         unsigned int i;
  52         int result;
  53
  54         password_len = test->password_len ? : strlen(test->password);
  55         salt_len = test->salt_len ? : strlen(test->salt);
  56
  57         key_len = test->key_len ? : (strlen(test->key) / 2);
  58
  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);
  66         }
  67
  68         result = pbkdf2_sha1(test->password, password_len,
  69                                         test->salt, salt_len,
  70                                         test->count, output, key_len);
  71
  72         g_assert(result == 0);
  73
  74         for (i = 0; i < key_len; i++)
  75                 sprintf(key + (i * 2), "%02x", output[i]);
  76
  77         if (g_test_verbose() == TRUE) {
  78                 g_print("Result   = %s\n", key);
  79         }
  80
  81         g_assert(strcmp(test->key, key) == 0);
  82 }
  83
  84 static const struct pbkdf2_data pbkdf2_test_vector_1 = {
  85         .password       = "password",
  86         .salt           = "salt",
  87         .count          = 1,
  88         .key            = "0c60c80f961f0e71f3a9b524af6012062fe037a6",
  89         .key_len        = 20,
  90 };
  91
  92 static const struct pbkdf2_data pbkdf2_test_vector_2 = {
  93         .password       = "password",
  94         .salt           = "salt",
  95         .count          = 2,
  96         .key            = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957",
  97         .key_len        = 20,
  98 };
  99
 100 static const struct pbkdf2_data pbkdf2_test_vector_3 = {
 101         .password       = "password",
 102         .salt           = "salt",
 103         .count          = 4096,
 104         .key            = "4b007901b765489abead49d926f721d065a429c1",
 105         .key_len        = 20,
 106 };
 107
 108 static const struct pbkdf2_data pbkdf2_test_vector_4 = {
 109         .password       = "password",
 110         .salt           = "salt",
 111         .count          = 16777216,
 112         .key            = "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984",
 113         .key_len        = 20,
 114 };
 115
 116 static const struct pbkdf2_data pbkdf2_test_vector_5 = {
 117         .password       = "passwordPASSWORDpassword",
 118         .salt           = "saltSALTsaltSALTsaltSALTsaltSALTsalt",
 119         .count          = 4096,
 120         .key            = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038",
 121         .key_len        = 25,
 122 };
 123
 124 static const struct pbkdf2_data pbkdf2_test_vector_6 = {
 125         .password       = "pass\0word",
 126         .password_len   = 9,
 127         .salt           = "sa\0lt",
 128         .salt_len       = 5,
 129         .count          = 4096,
 130         .key            = "56fa6aa75548099dcc37d7f03425e0c3",
 131         .key_len        = 16,
 132 };
 133
 134 static const struct pbkdf2_data athena_test_vector_1 = {
 135         .password       = "password",
 136         .salt           = "ATHENA.MIT.EDUraeburn",
 137         .count          = 1,
 138         .key            = "cdedb5281bb2f801565a1122b2563515",
 139 };
 140
 141 static const struct pbkdf2_data athena_test_vector_2 = {
 142         .password       = "password",
 143         .salt           = "ATHENA.MIT.EDUraeburn",
 144         .count          = 2,
 145         .key            = "01dbee7f4a9e243e988b62c73cda935d",
 146 };
 147
 148 static const struct pbkdf2_data athena_test_vector_3 = {
 149         .password       = "password",
 150         .salt           = "ATHENA.MIT.EDUraeburn",
 151         .count          = 1200,
 152         .key            = "5c08eb61fdf71e4e4ec3cf6ba1f5512b",
 153 };
 154
 155 static const struct pbkdf2_data athena_test_vector_4 = {
 156         .password       = "password",
 157         .salt           = "\x12\x34\x56\x78\x78\x56\x34\x12",
 158         .count          = 5,
 159         .key            = "d1daa78615f287e6a1c8b120d7062a49",
 160 };
 161
 162 static const struct pbkdf2_data athena_test_vector_5 = {
 163         .password       = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 164                           "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 165         .salt           = "pass phrase equals block size",
 166         .count          = 1200,
 167         .key            = "139c30c0966bc32ba55fdbf212530ac9",
 168 };
 169
 170 static const struct pbkdf2_data athena_test_vector_6 = {
 171         .password       = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 172                           "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 173         .salt           = "pass phrase exceeds block size",
 174         .count          = 1200,
 175         .key            = "9ccad6d468770cd51b10e6a68721be61",
 176 };
 177
 178 static const struct pbkdf2_data athena_test_vector_7 = {
 179         .password       = "\xf0\x9d\x84\x9e",   /* g-clef (0xf09d849e) */
 180         .salt           = "EXAMPLE.COMpianist",
 181         .count          = 50,
 182         .key            = "6b9cf26d45455a43a5b8bb276a403b39",
 183 };
 184
 185 struct psk_data {
 186         const char *passphrase;
 187         const unsigned char *ssid;
 188         size_t ssid_len;
 189         const char *network;
 190         const char *psk;
 191 };
 192
 193 static void psk_test(gconstpointer data)
 194 {
 195         const struct psk_data *test = data;
 196         unsigned char ssid[32];
 197         size_t ssid_len;
 198         unsigned char output[32];
 199         char psk[65];
 200         unsigned int i;
 201         int result;
 202
 203         if (test->network == NULL) {
 204                 memcpy(ssid, test->ssid, test->ssid_len);
 205                 ssid_len = test->ssid_len;
 206         } else {
 207                 ssid_len = strlen(test->network);
 208                 memcpy(ssid, test->network, ssid_len);
 209         }
 210
 211         if (g_test_verbose() == TRUE) {
 212                 g_print("Passphrase  = \"%s\"\n", test->passphrase);
 213                 g_print("SSID        = {");
 214                 for (i = 0; i < ssid_len; i++)
 215                         g_print("%s'%c'", i == 0 ? " " : ", ",
 216                                                 ssid[i]);
 217                 g_print(" }\n");
 218                 g_print("SSID Length = %zd\n", ssid_len);
 219                 g_print("PSK         = %s\n", test->psk);
 220         }
 221
 222         result = pbkdf2_sha1(test->passphrase, strlen(test->passphrase),
 223                                                 ssid, ssid_len, 4096,
 224                                                 output, sizeof(output));
 225
 226         g_assert(result == 0);
 227
 228         for (i = 0; i < sizeof(output); i++)
 229                 sprintf(psk + (i * 2), "%02x", output[i]);
 230
 231         if (g_test_verbose() == TRUE) {
 232                 g_print("Result      = %s\n", psk);
 233         }
 234
 235         g_assert(strcmp(test->psk, psk) == 0);
 236 }
 237
 238 static const unsigned char psk_test_case_1_ssid[] = { 'I', 'E', 'E', 'E' };
 239
 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",
 246 };
 247
 248 static const unsigned char psk_test_case_2_ssid[] = { 'T', 'h', 'i', 's',
 249                                         'I', 's', 'A', 'S', 'S', 'I', 'D' };
 250
 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",
 257 };
 258
 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' };
 264
 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",
 271 };
 272
 273 int main(int argc, char *argv[])
 274 {
 275         g_test_init(&argc, &argv, NULL);
 276
 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);
 289
 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);
 304
 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);
 311
 312         return g_test_run();
 313 }