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