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()) {
  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())
  78                 g_print("Result   = %s\n", key);
  79
  80         g_assert(strcmp(test->key, key) == 0);
  81 }
  82
  83 static const struct pbkdf2_data pbkdf2_test_vector_1 = {
  84         .password       = "password",
  85         .salt           = "salt",
  86         .count          = 1,
  87         .key            = "0c60c80f961f0e71f3a9b524af6012062fe037a6",
  88         .key_len        = 20,
  89 };
  90
  91 static const struct pbkdf2_data pbkdf2_test_vector_2 = {
  92         .password       = "password",
  93         .salt           = "salt",
  94         .count          = 2,
  95         .key            = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957",
  96         .key_len        = 20,
  97 };
  98
  99 static const struct pbkdf2_data pbkdf2_test_vector_3 = {
 100         .password       = "password",
 101         .salt           = "salt",
 102         .count          = 4096,
 103         .key            = "4b007901b765489abead49d926f721d065a429c1",
 104         .key_len        = 20,
 105 };
 106
 107 static const struct pbkdf2_data pbkdf2_test_vector_4 = {
 108         .password       = "password",
 109         .salt           = "salt",
 110         .count          = 16777216,
 111         .key            = "eefe3d61cd4da4e4e9945b3d6ba2158c2634e984",
 112         .key_len        = 20,
 113 };
 114
 115 static const struct pbkdf2_data pbkdf2_test_vector_5 = {
 116         .password       = "passwordPASSWORDpassword",
 117         .salt           = "saltSALTsaltSALTsaltSALTsaltSALTsalt",
 118         .count          = 4096,
 119         .key            = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038",
 120         .key_len        = 25,
 121 };
 122
 123 static const struct pbkdf2_data pbkdf2_test_vector_6 = {
 124         .password       = "pass\0word",
 125         .password_len   = 9,
 126         .salt           = "sa\0lt",
 127         .salt_len       = 5,
 128         .count          = 4096,
 129         .key            = "56fa6aa75548099dcc37d7f03425e0c3",
 130         .key_len        = 16,
 131 };
 132
 133 static const struct pbkdf2_data athena_test_vector_1 = {
 134         .password       = "password",
 135         .salt           = "ATHENA.MIT.EDUraeburn",
 136         .count          = 1,
 137         .key            = "cdedb5281bb2f801565a1122b2563515",
 138 };
 139
 140 static const struct pbkdf2_data athena_test_vector_2 = {
 141         .password       = "password",
 142         .salt           = "ATHENA.MIT.EDUraeburn",
 143         .count          = 2,
 144         .key            = "01dbee7f4a9e243e988b62c73cda935d",
 145 };
 146
 147 static const struct pbkdf2_data athena_test_vector_3 = {
 148         .password       = "password",
 149         .salt           = "ATHENA.MIT.EDUraeburn",
 150         .count          = 1200,
 151         .key            = "5c08eb61fdf71e4e4ec3cf6ba1f5512b",
 152 };
 153
 154 static const struct pbkdf2_data athena_test_vector_4 = {
 155         .password       = "password",
 156         .salt           = "\x12\x34\x56\x78\x78\x56\x34\x12",
 157         .count          = 5,
 158         .key            = "d1daa78615f287e6a1c8b120d7062a49",
 159 };
 160
 161 static const struct pbkdf2_data athena_test_vector_5 = {
 162         .password       = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 163                           "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 164         .salt           = "pass phrase equals block size",
 165         .count          = 1200,
 166         .key            = "139c30c0966bc32ba55fdbf212530ac9",
 167 };
 168
 169 static const struct pbkdf2_data athena_test_vector_6 = {
 170         .password       = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
 171                           "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
 172         .salt           = "pass phrase exceeds block size",
 173         .count          = 1200,
 174         .key            = "9ccad6d468770cd51b10e6a68721be61",
 175 };
 176
 177 static const struct pbkdf2_data athena_test_vector_7 = {
 178         .password       = "\xf0\x9d\x84\x9e",   /* g-clef (0xf09d849e) */
 179         .salt           = "EXAMPLE.COMpianist",
 180         .count          = 50,
 181         .key            = "6b9cf26d45455a43a5b8bb276a403b39",
 182 };
 183
 184 struct psk_data {
 185         const char *passphrase;
 186         const unsigned char *ssid;
 187         size_t ssid_len;
 188         const char *network;
 189         const char *psk;
 190 };
 191
 192 static void psk_test(gconstpointer data)
 193 {
 194         const struct psk_data *test = data;
 195         unsigned char ssid[32];
 196         size_t ssid_len;
 197         unsigned char output[32];
 198         char psk[65];
 199         unsigned int i;
 200         int result;
 201
 202         if (!test->network) {
 203                 memcpy(ssid, test->ssid, test->ssid_len);
 204                 ssid_len = test->ssid_len;
 205         } else {
 206                 ssid_len = strlen(test->network);
 207                 memcpy(ssid, test->network, ssid_len);
 208         }
 209
 210         if (g_test_verbose()) {
 211                 g_print("Passphrase  = \"%s\"\n", test->passphrase);
 212                 g_print("SSID        = {");
 213                 for (i = 0; i < ssid_len; i++)
 214                         g_print("%s'%c'", i == 0 ? " " : ", ",
 215                                                 ssid[i]);
 216                 g_print(" }\n");
 217                 g_print("SSID Length = %zd\n", ssid_len);
 218                 g_print("PSK         = %s\n", test->psk);
 219         }
 220
 221         result = pbkdf2_sha1(test->passphrase, strlen(test->passphrase),
 222                                                 ssid, ssid_len, 4096,
 223                                                 output, sizeof(output));
 224
 225         g_assert(result == 0);
 226
 227         for (i = 0; i < sizeof(output); i++)
 228                 sprintf(psk + (i * 2), "%02x", output[i]);
 229
 230         if (g_test_verbose())
 231                 g_print("Result      = %s\n", psk);
 232
 233         g_assert(strcmp(test->psk, psk) == 0);
 234 }
 235
 236 static const unsigned char psk_test_case_1_ssid[] = { 'I', 'E', 'E', 'E' };
 237
 238 static const struct psk_data psk_test_case_1 = {
 239         .passphrase     = "password",
 240         .ssid           = psk_test_case_1_ssid,
 241         .ssid_len       = sizeof(psk_test_case_1_ssid),
 242         .psk            = "f42c6fc52df0ebef9ebb4b90b38a5f90"
 243                           "2e83fe1b135a70e23aed762e9710a12e",
 244 };
 245
 246 static const unsigned char psk_test_case_2_ssid[] = { 'T', 'h', 'i', 's',
 247                                         'I', 's', 'A', 'S', 'S', 'I', 'D' };
 248
 249 static const struct psk_data psk_test_case_2 = {
 250         .passphrase     = "ThisIsAPassword",
 251         .ssid           = psk_test_case_2_ssid,
 252         .ssid_len       = sizeof(psk_test_case_2_ssid),
 253         .psk            = "0dc0d6eb90555ed6419756b9a15ec3e3"
 254                           "209b63df707dd508d14581f8982721af",
 255 };
 256
 257 static const unsigned char psk_test_case_3_ssid[] = {
 258                                 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z',
 259                                 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z',
 260                                 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z',
 261                                 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z', 'Z' };
 262
 263 static const struct psk_data psk_test_case_3 = {
 264         .passphrase     = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
 265         .ssid           = psk_test_case_3_ssid,
 266         .ssid_len       = sizeof(psk_test_case_3_ssid),
 267         .psk            = "becb93866bb8c3832cb777c2f559807c"
 268                           "8c59afcb6eae734885001300a981cc62",
 269 };
 270
 271 int main(int argc, char *argv[])
 272 {
 273         g_test_init(&argc, &argv, NULL);
 274
 275         g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 1",
 276                                         &pbkdf2_test_vector_1, pbkdf2_test);
 277         g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 2",
 278                                         &pbkdf2_test_vector_2, pbkdf2_test);
 279         g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 3",
 280                                         &pbkdf2_test_vector_3, pbkdf2_test);
 281         g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 4",
 282                                         &pbkdf2_test_vector_4, pbkdf2_test);
 283         g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 5",
 284                                         &pbkdf2_test_vector_5, pbkdf2_test);
 285         g_test_add_data_func("/pbkdf2-sha1/PBKDF2 Test vector 6",
 286                                         &pbkdf2_test_vector_6, pbkdf2_test);
 287
 288         g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 1",
 289                                         &athena_test_vector_1, pbkdf2_test);
 290         g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 2",
 291                                         &athena_test_vector_2, pbkdf2_test);
 292         g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 3",
 293                                         &athena_test_vector_3, pbkdf2_test);
 294         g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 4",
 295                                         &athena_test_vector_4, pbkdf2_test);
 296         g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 5",
 297                                         &athena_test_vector_5, pbkdf2_test);
 298         g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 6",
 299                                         &athena_test_vector_6, pbkdf2_test);
 300         g_test_add_data_func("/pbkdf2-sha1/ATHENA Test vector 7",
 301                                         &athena_test_vector_7, pbkdf2_test);
 302
 303         g_test_add_data_func("/pbkdf2-sha1/PSK Test case 1",
 304                                         &psk_test_case_1, psk_test);
 305         g_test_add_data_func("/pbkdf2-sha1/PSK Test case 2",
 306                                         &psk_test_case_2, psk_test);
 307         g_test_add_data_func("/pbkdf2-sha1/PSK Test case 3",
 308                                         &psk_test_case_3, psk_test);
 309
 310         return g_test_run();
 311 }