1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
2 /* test-hkdf.c: Test egg-hkdf.c
4 Copyright (C) 2011 Collabora Ltd.
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.
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.
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/>.
20 Author: Stef Walter <stef@collabora.co.uk>
29 #include "egg/egg-hkdf.h"
30 #include "egg/egg-secure-memory.h"
31 #include "egg/egg-testing.h"
35 EGG_SECURE_DEFINE_GLIB_GLOBALS ();
38 test_hkdf_test_case_1 (void)
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,
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,
54 guchar buffer[sizeof (okm)];
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);
62 memset (buffer, 0, sizeof (buffer));
63 ret = egg_hkdf_perform ("sha256",
67 buffer, sizeof (buffer));
69 egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
73 test_hkdf_test_case_2 (void)
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,
117 guchar buffer[sizeof (okm)];
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);
125 memset (buffer, 0, sizeof (buffer));
126 ret = egg_hkdf_perform ("sha256",
130 buffer, sizeof (buffer));
132 egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
136 test_hkdf_test_case_3 (void)
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,
150 guchar buffer[sizeof (okm)];
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);
158 memset (buffer, 0, sizeof (buffer));
159 ret = egg_hkdf_perform ("sha256",
163 buffer, sizeof (buffer));
165 egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
169 test_hkdf_test_case_4 (void)
171 /* RFC 5869: A.4 Test Case 4 */
172 const guchar ikm[] = { 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 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,
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,
184 guchar buffer[sizeof (okm)];
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);
192 memset (buffer, 0, sizeof (buffer));
193 ret = egg_hkdf_perform ("sha1",
197 buffer, sizeof (buffer));
199 egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
203 test_hkdf_test_case_5 (void)
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,
247 guchar buffer[sizeof (okm)];
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);
255 memset (buffer, 0, sizeof (buffer));
256 ret = egg_hkdf_perform ("sha1",
260 buffer, sizeof (buffer));
262 egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
266 test_hkdf_test_case_6 (void)
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,
280 guchar buffer[sizeof (okm)];
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);
288 memset (buffer, 0, sizeof (buffer));
289 ret = egg_hkdf_perform ("sha1",
293 buffer, sizeof (buffer));
295 egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
299 test_hkdf_test_case_7 (void)
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,
313 guchar buffer[sizeof (okm)];
316 egg_assert_cmpsize (sizeof (ikm), ==, 22);
317 egg_assert_cmpsize (sizeof (info), ==, 0);
318 egg_assert_cmpsize (sizeof (okm), ==, 42);
320 memset (buffer, 0, sizeof (buffer));
321 ret = egg_hkdf_perform ("sha1",
325 buffer, sizeof (buffer));
327 egg_assert_cmpmem (buffer, sizeof (buffer), ==, okm, sizeof (okm));
331 main (int argc, char **argv)
333 g_test_init (&argc, &argv, NULL);
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);
343 return g_test_run ();