egg/tests/test-hkdf.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
   2 /* test-hkdf.c: Test egg-hkdf.c
   3
   4    Copyright (C) 2011 Collabora Ltd.
   5
   6    The Gnome Keyring Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Library General Public License as
   8    published by the Free Software Foundation; either version 2 of the
   9    License, or (at your option) any later version.
  10
  11    The Gnome Keyring Library 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 GNU
  14    Library General Public License for more details.
  15
  16    You should have received a copy of the GNU Library General Public
  17    License along with the Gnome Library; see the file COPYING.LIB.  If not,
  18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.
  20
  21    Author: Stef Walter <stef@collabora.co.uk>
  22 */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include "egg/egg-hkdf.h"
  31 #include "egg/egg-secure-memory.h"
  32 #include "egg/egg-testing.h"
  33
  34 #include <gcrypt.h>
  35
  36 EGG_SECURE_DEFINE_GLIB_GLOBALS ();
  37
  38 static void
  39 test_hkdf_test_case_1 (void)
  40 {
  41         /* RFC 5869: A.1 Test Case 1 */
  42         const guchar ikm[] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  43                                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
  44                                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
  45         const guchar salt[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  46                                 0x08, 0x09, 0x0a, 0x0b, 0x0c };
  47         const guchar info[] = { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
  48                                 0xf8, 0xf9 };
  49         const guchar okm[] = { 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a,
  50                                0x90, 0x43, 0x4f, 0x64, 0xd0, 0x36, 0x2f, 0x2a,
  51                                0x2d, 0x2d, 0x0a, 0x90, 0xcf, 0x1a, 0x5a, 0x4c,
  52                                0x5d, 0xb0, 0x2d, 0x56, 0xec, 0xc4, 0xc5, 0xbf,
  53                                0x34, 0x00, 0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18,
  54                                0x58, 0x65 };
  55         guchar buffer[sizeof (okm)];
  56         gboolean ret;
  57
  58         egg_assert_cmpsize (sizeof (ikm), ==, 22);
  59         egg_assert_cmpsize (sizeof (salt), ==, 13);
  60         egg_assert_cmpsize (sizeof (info), ==, 10);
  61         egg_assert_cmpsize (sizeof (okm), ==, 42);
  62
  63         memset (buffer, 0, sizeof (buffer));
  64         ret = egg_hkdf_perform ("sha256",
  65                                 ikm, sizeof (ikm),
  66                                 salt, sizeof (salt),
  67                                 info, sizeof (info),
  68                                 buffer, sizeof (buffer));
  69         g_assert (ret);
  70         egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
  71 }
  72
  73 static void
  74 test_hkdf_test_case_2 (void)
  75 {
  76         /* RFC 5869: A.2 Test Case 2 */
  77         const guchar ikm[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  78                                0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  79                                0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  80                                0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  81                                0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
  82                                0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  83                                0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
  84                                0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
  85                                0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
  86                                0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f };
  87         const guchar salt[] = { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  88                                 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  89                                 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
  90                                 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
  91                                 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  92                                 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
  93                                 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
  94                                 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
  95                                 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  96                                 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf };
  97         const guchar info[] = { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
  98                                 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
  99                                 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 100                                 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
 101                                 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
 102                                 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
 103                                 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
 104                                 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
 105                                 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 106                                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff };
 107         const guchar okm[] = { 0xb1, 0x1e, 0x39, 0x8d, 0xc8, 0x03, 0x27, 0xa1,
 108                                0xc8, 0xe7, 0xf7, 0x8c, 0x59, 0x6a, 0x49, 0x34,
 109                                0x4f, 0x01, 0x2e, 0xda, 0x2d, 0x4e, 0xfa, 0xd8,
 110                                0xa0, 0x50, 0xcc, 0x4c, 0x19, 0xaf, 0xa9, 0x7c,
 111                                0x59, 0x04, 0x5a, 0x99, 0xca, 0xc7, 0x82, 0x72,
 112                                0x71, 0xcb, 0x41, 0xc6, 0x5e, 0x59, 0x0e, 0x09,
 113                                0xda, 0x32, 0x75, 0x60, 0x0c, 0x2f, 0x09, 0xb8,
 114                                0x36, 0x77, 0x93, 0xa9, 0xac, 0xa3, 0xdb, 0x71,
 115                                0xcc, 0x30, 0xc5, 0x81, 0x79, 0xec, 0x3e, 0x87,
 116                                0xc1, 0x4c, 0x01, 0xd5, 0xc1, 0xf3, 0x43, 0x4f,
 117                                0x1d, 0x87 };
 118         guchar buffer[sizeof (okm)];
 119         gboolean ret;
 120
 121         egg_assert_cmpsize (sizeof (ikm), ==, 80);
 122         egg_assert_cmpsize (sizeof (salt), ==, 80);
 123         egg_assert_cmpsize (sizeof (info), ==, 80);
 124         egg_assert_cmpsize (sizeof (okm), ==, 82);
 125
 126         memset (buffer, 0, sizeof (buffer));
 127         ret = egg_hkdf_perform ("sha256",
 128                                 ikm, sizeof (ikm),
 129                                 salt, sizeof (salt),
 130                                 info, sizeof (info),
 131                                 buffer, sizeof (buffer));
 132         g_assert (ret);
 133         egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
 134 }
 135
 136 static void
 137 test_hkdf_test_case_3 (void)
 138 {
 139         /* RFC 5869: A.3 Test Case 3 */
 140         const guchar ikm[] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 141                                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 142                                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,};
 143         const guchar salt[] = { };
 144         const guchar info[] = { };
 145         const guchar okm[] = { 0x8d, 0xa4, 0xe7, 0x75, 0xa5, 0x63, 0xc1, 0x8f,
 146                                0x71, 0x5f, 0x80, 0x2a, 0x06, 0x3c, 0x5a, 0x31,
 147                                0xb8, 0xa1, 0x1f, 0x5c, 0x5e, 0xe1, 0x87, 0x9e,
 148                                0xc3, 0x45, 0x4e, 0x5f, 0x3c, 0x73, 0x8d, 0x2d,
 149                                0x9d, 0x20, 0x13, 0x95, 0xfa, 0xa4, 0xb6, 0x1a,
 150                                0x96, 0xc8 };
 151         guchar buffer[sizeof (okm)];
 152         gboolean ret;
 153
 154         egg_assert_cmpsize (sizeof (ikm), ==, 22);
 155         egg_assert_cmpsize (sizeof (salt), ==, 0);
 156         egg_assert_cmpsize (sizeof (info), ==, 0);
 157         egg_assert_cmpsize (sizeof (okm), ==, 42);
 158
 159         memset (buffer, 0, sizeof (buffer));
 160         ret = egg_hkdf_perform ("sha256",
 161                                 ikm, sizeof (ikm),
 162                                 salt, sizeof (salt),
 163                                 info, sizeof (info),
 164                                 buffer, sizeof (buffer));
 165         g_assert (ret);
 166         egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
 167 }
 168
 169 static void
 170 test_hkdf_test_case_4 (void)
 171 {
 172         /* RFC 5869: A.4 Test Case 4 */
 173         const guchar ikm[] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 174                                0x0b, 0x0b, 0x0b };
 175         const guchar salt[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 176                                 0x08, 0x09, 0x0a, 0x0b, 0x0c };
 177         const guchar info[] = { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 178                                 0xf8, 0xf9 };
 179         const guchar okm[] = { 0x08, 0x5a, 0x01, 0xea, 0x1b, 0x10, 0xf3, 0x69,
 180                                0x33, 0x06, 0x8b, 0x56, 0xef, 0xa5, 0xad, 0x81,
 181                                0xa4, 0xf1, 0x4b, 0x82, 0x2f, 0x5b, 0x09, 0x15,
 182                                0x68, 0xa9, 0xcd, 0xd4, 0xf1, 0x55, 0xfd, 0xa2,
 183                                0xc2, 0x2e, 0x42, 0x24, 0x78, 0xd3, 0x05, 0xf3,
 184                                0xf8, 0x96 };
 185         guchar buffer[sizeof (okm)];
 186         gboolean ret;
 187
 188         egg_assert_cmpsize (sizeof (ikm), ==, 11);
 189         egg_assert_cmpsize (sizeof (salt), ==, 13);
 190         egg_assert_cmpsize (sizeof (info), ==, 10);
 191         egg_assert_cmpsize (sizeof (okm), ==, 42);
 192
 193         memset (buffer, 0, sizeof (buffer));
 194         ret = egg_hkdf_perform ("sha1",
 195                                 ikm, sizeof (ikm),
 196                                 salt, sizeof (salt),
 197                                 info, sizeof (info),
 198                                 buffer, sizeof (buffer));
 199         g_assert (ret);
 200         egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
 201 }
 202
 203 static void
 204 test_hkdf_test_case_5 (void)
 205 {
 206         /* RFC 5869: A.5 Test Case 5 */
 207         const guchar ikm[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 208                                0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 209                                0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
 210                                0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
 211                                0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
 212                                0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
 213                                0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
 214                                0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
 215                                0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
 216                                0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f };
 217         const guchar salt[] = { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
 218                                 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
 219                                 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
 220                                 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
 221                                 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
 222                                 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
 223                                 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
 224                                 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
 225                                 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
 226                                 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf };
 227         const guchar info[] = { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
 228                                 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
 229                                 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
 230                                 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
 231                                 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
 232                                 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
 233                                 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
 234                                 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
 235                                 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 236                                 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff };
 237         const guchar okm[] = { 0x0b, 0xd7, 0x70, 0xa7, 0x4d, 0x11, 0x60, 0xf7,
 238                                0xc9, 0xf1, 0x2c, 0xd5, 0x91, 0x2a, 0x06, 0xeb,
 239                                0xff, 0x6a, 0xdc, 0xae, 0x89, 0x9d, 0x92, 0x19,
 240                                0x1f, 0xe4, 0x30, 0x56, 0x73, 0xba, 0x2f, 0xfe,
 241                                0x8f, 0xa3, 0xf1, 0xa4, 0xe5, 0xad, 0x79, 0xf3,
 242                                0xf3, 0x34, 0xb3, 0xb2, 0x02, 0xb2, 0x17, 0x3c,
 243                                0x48, 0x6e, 0xa3, 0x7c, 0xe3, 0xd3, 0x97, 0xed,
 244                                0x03, 0x4c, 0x7f, 0x9d, 0xfe, 0xb1, 0x5c, 0x5e,
 245                                0x92, 0x73, 0x36, 0xd0, 0x44, 0x1f, 0x4c, 0x43,
 246                                0x00, 0xe2, 0xcf, 0xf0, 0xd0, 0x90, 0x0b, 0x52,
 247                                0xd3, 0xb4 };
 248         guchar buffer[sizeof (okm)];
 249         gboolean ret;
 250
 251         egg_assert_cmpsize (sizeof (ikm), ==, 80);
 252         egg_assert_cmpsize (sizeof (salt), ==, 80);
 253         egg_assert_cmpsize (sizeof (info), ==, 80);
 254         egg_assert_cmpsize (sizeof (okm), ==, 82);
 255
 256         memset (buffer, 0, sizeof (buffer));
 257         ret = egg_hkdf_perform ("sha1",
 258                                 ikm, sizeof (ikm),
 259                                 salt, sizeof (salt),
 260                                 info, sizeof (info),
 261                                 buffer, sizeof (buffer));
 262         g_assert (ret);
 263         egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
 264 }
 265
 266 static void
 267 test_hkdf_test_case_6 (void)
 268 {
 269         /* RFC 5869: A.6 Test Case 6 */
 270         const guchar ikm[] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 271                                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 272                                0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b };
 273         const guchar salt[] = { };
 274         const guchar info[] = { };
 275         const guchar okm[] = { 0x0a, 0xc1, 0xaf, 0x70, 0x02, 0xb3, 0xd7, 0x61,
 276                                0xd1, 0xe5, 0x52, 0x98, 0xda, 0x9d, 0x05, 0x06,
 277                                0xb9, 0xae, 0x52, 0x05, 0x72, 0x20, 0xa3, 0x06,
 278                                0xe0, 0x7b, 0x6b, 0x87, 0xe8, 0xdf, 0x21, 0xd0,
 279                                0xea, 0x00, 0x03, 0x3d, 0xe0, 0x39, 0x84, 0xd3,
 280                                0x49, 0x18 };
 281         guchar buffer[sizeof (okm)];
 282         gboolean ret;
 283
 284         egg_assert_cmpsize (sizeof (ikm), ==, 22);
 285         egg_assert_cmpsize (sizeof (salt), ==, 0);
 286         egg_assert_cmpsize (sizeof (info), ==, 0);
 287         egg_assert_cmpsize (sizeof (okm), ==, 42);
 288
 289         memset (buffer, 0, sizeof (buffer));
 290         ret = egg_hkdf_perform ("sha1",
 291                                 ikm, sizeof (ikm),
 292                                 salt, sizeof (salt),
 293                                 info, sizeof (info),
 294                                 buffer, sizeof (buffer));
 295         g_assert (ret);
 296         egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
 297 }
 298
 299 static void
 300 test_hkdf_test_case_7 (void)
 301 {
 302         /* RFC 5869: A.7 Test Case 7 */
 303         const guchar ikm[] = { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 304                                0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
 305                                0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c };
 306         const guchar *salt = NULL;
 307         const guchar info[] = { };
 308         const guchar okm[] = { 0x2c, 0x91, 0x11, 0x72, 0x04, 0xd7, 0x45, 0xf3,
 309                                0x50, 0x0d, 0x63, 0x6a, 0x62, 0xf6, 0x4f, 0x0a,
 310                                0xb3, 0xba, 0xe5, 0x48, 0xaa, 0x53, 0xd4, 0x23,
 311                                0xb0, 0xd1, 0xf2, 0x7e, 0xbb, 0xa6, 0xf5, 0xe5,
 312                                0x67, 0x3a, 0x08, 0x1d, 0x70, 0xcc, 0xe7, 0xac,
 313                                0xfc, 0x48 };
 314         guchar buffer[sizeof (okm)];
 315         gboolean ret;
 316
 317         egg_assert_cmpsize (sizeof (ikm), ==, 22);
 318         egg_assert_cmpsize (sizeof (info), ==, 0);
 319         egg_assert_cmpsize (sizeof (okm), ==, 42);
 320
 321         memset (buffer, 0, sizeof (buffer));
 322         ret = egg_hkdf_perform ("sha1",
 323                                 ikm, sizeof (ikm),
 324                                 salt, sizeof (salt),
 325                                 info, sizeof (info),
 326                                 buffer, sizeof (buffer));
 327         g_assert (ret);
 328         egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
 329 }
 330
 331 int
 332 main (int argc, char **argv)
 333 {
 334         g_test_init (&argc, &argv, NULL);
 335
 336         g_test_add_func ("/hkdf/test-case-1", test_hkdf_test_case_1);
 337         g_test_add_func ("/hkdf/test-case-2", test_hkdf_test_case_2);
 338         g_test_add_func ("/hkdf/test-case-3", test_hkdf_test_case_3);
 339         g_test_add_func ("/hkdf/test-case-4", test_hkdf_test_case_4);
 340         g_test_add_func ("/hkdf/test-case-5", test_hkdf_test_case_5);
 341         g_test_add_func ("/hkdf/test-case-6", test_hkdf_test_case_6);
 342         g_test_add_func ("/hkdf/test-case-7", test_hkdf_test_case_7);
 343
 344         return g_test_run ();
 345 }