iPXE
hkdf_test.c
Go to the documentation of this file.
1/*
2 * Copyright (C) 2026 Michael Brown <mbrown@fensystems.co.uk>.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA.
18 *
19 * You can also choose to distribute this program under the terms of
20 * the Unmodified Binary Distribution Licence (as given in the file
21 * COPYING.UBDL), provided that you have satisfied its requirements.
22 */
23
24FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25
26/** @file
27 *
28 * HKDF self-tests
29 *
30 * These test vectors are taken from RFC 5869 Appendix A.
31 */
32
33/* Forcibly enable assertions */
34#undef NDEBUG
35
36#include <string.h>
37#include <ipxe/crypto.h>
38#include <ipxe/sha1.h>
39#include <ipxe/sha256.h>
40#include <ipxe/hkdf.h>
41#include <ipxe/test.h>
42#include "hkdf_test.h"
43
44/**
45 * Report an HKDF test result
46 *
47 * @v test HKDF test
48 * @v file Test code file
49 * @v line Test code line
50 */
51void hkdf_okx ( struct hkdf_test *test, const char *file,
52 unsigned int line ) {
53 size_t digestsize = test->digest->digestsize;
54 union {
55 uint8_t ikm[test->ikm_len];
56 uint8_t salt[test->salt_len];
57 uint8_t info[test->info_len];
58 uint8_t prk[digestsize];
59 uint8_t okm[test->okm_len];
60 } overlap;
61 uint8_t prk[digestsize];
62 uint8_t okm[test->okm_len];
63 size_t check_len;
64
65 /* Sanity checks */
66 okx ( ( test->salt != NULL ) || ( test->salt_len == 0 ), file, line );
67 okx ( ( test->prk_len == 0 ) || ( test->prk_len == digestsize ),
68 file, line );
69
70 /* Test extraction */
71 hkdf_extract ( test->digest, test->salt, test->salt_len, test->ikm,
72 test->ikm_len, prk );
73 if ( test->prk_len )
74 okx ( memcmp ( prk, test->prk, digestsize ) == 0, file, line );
75
76 /* Test expansion */
77 hkdf_expand ( test->digest, prk, test->info, test->info_len,
78 okm, test->okm_len );
79 okx ( memcmp ( okm, test->okm, test->okm_len ) == 0, file, line );
80
81 /* Test overlap between salt and pseudorandom key */
82 if ( test->salt ) {
83 memcpy ( overlap.salt, test->salt, test->salt_len );
84 hkdf_extract ( test->digest, overlap.salt, test->salt_len,
85 test->ikm, test->ikm_len, overlap.prk );
86 okx ( memcmp ( overlap.prk, prk, digestsize ) == 0,
87 file, line );
88 }
89
90 /* Test overlap between input keying material and pseudorandom key */
91 memcpy ( overlap.ikm, test->ikm, test->ikm_len );
92 hkdf_extract ( test->digest, test->salt, test->salt_len, overlap.ikm,
93 test->ikm_len, overlap.prk );
94 okx ( memcmp ( overlap.prk, prk, digestsize ) == 0, file, line );
95
96 /* Calculate length for expansion overlap tests */
97 check_len = test->okm_len;
98 if ( check_len > digestsize )
99 check_len = digestsize;
100
101 /* Test overlap between pseudorandom key and output */
102 memcpy ( overlap.prk, prk, digestsize );
103 hkdf_expand ( test->digest, overlap.prk, test->info, test->info_len,
104 overlap.okm, test->okm_len );
105 okx ( memcmp ( overlap.okm, test->okm, check_len ) == 0, file, line );
106
107 /* Test overlap between additional information and output */
108 memcpy ( overlap.info, test->info, test->info_len );
109 hkdf_expand ( test->digest, prk, overlap.info, test->info_len,
110 overlap.okm, test->okm_len );
111 okx ( memcmp ( overlap.okm, test->okm, check_len ) == 0, file, line );
112}
113
114/** RFC 5869 test case 1: Basic test case with SHA-256 */
115HKDF_TEST ( hkdf_test_1, &sha256_algorithm, 1,
116 IKM ( 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
117 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
118 0x0b, 0x0b ),
119 SALT ( 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
120 0x0a, 0x0b, 0x0c ),
121 INFO ( 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 ),
122 PRK ( 0x07, 0x77, 0x09, 0x36, 0x2c, 0x2e, 0x32, 0xdf, 0x0d, 0xdc,
123 0x3f, 0x0d, 0xc4, 0x7b, 0xba, 0x63, 0x90, 0xb6, 0xc7, 0x3b,
124 0xb5, 0x0f, 0x9c, 0x31, 0x22, 0xec, 0x84, 0x4a, 0xd7, 0xc2,
125 0xb3, 0xe5 ),
126 OKM ( 0x3c, 0xb2, 0x5f, 0x25, 0xfa, 0xac, 0xd5, 0x7a, 0x90, 0x43,
127 0x4f, 0x64, 0xd0, 0x36, 0x2f, 0x2a, 0x2d, 0x2d, 0x0a, 0x90,
128 0xcf, 0x1a, 0x5a, 0x4c, 0x5d, 0xb0, 0x2d, 0x56, 0xec, 0xc4,
129 0xc5, 0xbf, 0x34, 0x00, 0x72, 0x08, 0xd5, 0xb8, 0x87, 0x18,
130 0x58, 0x65 ) );
131
132/** RFC 5869 test case 2: Test with SHA-256 and longer inputs/outputs */
133HKDF_TEST ( hkdf_test_2, &sha256_algorithm, 1,
134 IKM ( 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
135 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
136 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
137 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
138 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
139 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
140 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
141 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f ),
142 SALT ( 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
143 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
144 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d,
145 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
146 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91,
147 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
148 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5,
149 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf ),
150 INFO ( 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
151 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3,
152 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd,
153 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
154 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1,
155 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
156 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5,
157 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff ),
158 PRK ( 0x06, 0xa6, 0xb8, 0x8c, 0x58, 0x53, 0x36, 0x1a, 0x06, 0x10,
159 0x4c, 0x9c, 0xeb, 0x35, 0xb4, 0x5c, 0xef, 0x76, 0x00, 0x14,
160 0x90, 0x46, 0x71, 0x01, 0x4a, 0x19, 0x3f, 0x40, 0xc1, 0x5f,
161 0xc2, 0x44 ),
162 OKM ( 0xb1, 0x1e, 0x39, 0x8d, 0xc8, 0x03, 0x27, 0xa1, 0xc8, 0xe7,
163 0xf7, 0x8c, 0x59, 0x6a, 0x49, 0x34, 0x4f, 0x01, 0x2e, 0xda,
164 0x2d, 0x4e, 0xfa, 0xd8, 0xa0, 0x50, 0xcc, 0x4c, 0x19, 0xaf,
165 0xa9, 0x7c, 0x59, 0x04, 0x5a, 0x99, 0xca, 0xc7, 0x82, 0x72,
166 0x71, 0xcb, 0x41, 0xc6, 0x5e, 0x59, 0x0e, 0x09, 0xda, 0x32,
167 0x75, 0x60, 0x0c, 0x2f, 0x09, 0xb8, 0x36, 0x77, 0x93, 0xa9,
168 0xac, 0xa3, 0xdb, 0x71, 0xcc, 0x30, 0xc5, 0x81, 0x79, 0xec,
169 0x3e, 0x87, 0xc1, 0x4c, 0x01, 0xd5, 0xc1, 0xf3, 0x43, 0x4f,
170 0x1d, 0x87 ) );
171
172/** RFC 5869 test case 3: Test with SHA-256 and zero-length salt/info */
173HKDF_TEST ( hkdf_test_3, &sha256_algorithm, 1,
174 IKM ( 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
175 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
176 0x0b, 0x0b ),
177 SALT(), INFO(),
178 PRK ( 0x19, 0xef, 0x24, 0xa3, 0x2c, 0x71, 0x7b, 0x16, 0x7f, 0x33,
179 0xa9, 0x1d, 0x6f, 0x64, 0x8b, 0xdf, 0x96, 0x59, 0x67, 0x76,
180 0xaf, 0xdb, 0x63, 0x77, 0xac, 0x43, 0x4c, 0x1c, 0x29, 0x3c,
181 0xcb, 0x04 ),
182 OKM ( 0x8d, 0xa4, 0xe7, 0x75, 0xa5, 0x63, 0xc1, 0x8f, 0x71, 0x5f,
183 0x80, 0x2a, 0x06, 0x3c, 0x5a, 0x31, 0xb8, 0xa1, 0x1f, 0x5c,
184 0x5e, 0xe1, 0x87, 0x9e, 0xc3, 0x45, 0x4e, 0x5f, 0x3c, 0x73,
185 0x8d, 0x2d, 0x9d, 0x20, 0x13, 0x95, 0xfa, 0xa4, 0xb6, 0x1a,
186 0x96, 0xc8 ) );
187
188/** RFC 5869 test case 4: Basic test case with SHA-1 */
189HKDF_TEST ( hkdf_test_4, &sha1_algorithm, 1,
190 IKM ( 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
191 0x0b ),
192 SALT ( 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
193 0x0a, 0x0b, 0x0c ),
194 INFO ( 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9 ),
195 PRK ( 0x9b, 0x6c, 0x18, 0xc4, 0x32, 0xa7, 0xbf, 0x8f, 0x0e, 0x71,
196 0xc8, 0xeb, 0x88, 0xf4, 0xb3, 0x0b, 0xaa, 0x2b, 0xa2, 0x43 ),
197 OKM ( 0x08, 0x5a, 0x01, 0xea, 0x1b, 0x10, 0xf3, 0x69, 0x33, 0x06,
198 0x8b, 0x56, 0xef, 0xa5, 0xad, 0x81, 0xa4, 0xf1, 0x4b, 0x82,
199 0x2f, 0x5b, 0x09, 0x15, 0x68, 0xa9, 0xcd, 0xd4, 0xf1, 0x55,
200 0xfd, 0xa2, 0xc2, 0x2e, 0x42, 0x24, 0x78, 0xd3, 0x05, 0xf3,
201 0xf8, 0x96 ) );
202
203/** RFC 5869 test case 5: Test with SHA-1 and longer inputs/outputs */
204HKDF_TEST ( hkdf_test_5, &sha1_algorithm, 1,
205 IKM ( 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
206 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
207 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
208 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
209 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31,
210 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
211 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
212 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f ),
213 SALT ( 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
214 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
215 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d,
216 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
217 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91,
218 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
219 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5,
220 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf ),
221 INFO ( 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9,
222 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3,
223 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd,
224 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
225 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1,
226 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
227 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5,
228 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff ),
229 PRK ( 0x8a, 0xda, 0xe0, 0x9a, 0x2a, 0x30, 0x70, 0x59, 0x47, 0x8d,
230 0x30, 0x9b, 0x26, 0xc4, 0x11, 0x5a, 0x22, 0x4c, 0xfa, 0xf6 ),
231 OKM ( 0x0b, 0xd7, 0x70, 0xa7, 0x4d, 0x11, 0x60, 0xf7, 0xc9, 0xf1,
232 0x2c, 0xd5, 0x91, 0x2a, 0x06, 0xeb, 0xff, 0x6a, 0xdc, 0xae,
233 0x89, 0x9d, 0x92, 0x19, 0x1f, 0xe4, 0x30, 0x56, 0x73, 0xba,
234 0x2f, 0xfe, 0x8f, 0xa3, 0xf1, 0xa4, 0xe5, 0xad, 0x79, 0xf3,
235 0xf3, 0x34, 0xb3, 0xb2, 0x02, 0xb2, 0x17, 0x3c, 0x48, 0x6e,
236 0xa3, 0x7c, 0xe3, 0xd3, 0x97, 0xed, 0x03, 0x4c, 0x7f, 0x9d,
237 0xfe, 0xb1, 0x5c, 0x5e, 0x92, 0x73, 0x36, 0xd0, 0x44, 0x1f,
238 0x4c, 0x43, 0x00, 0xe2, 0xcf, 0xf0, 0xd0, 0x90, 0x0b, 0x52,
239 0xd3, 0xb4 ) );
240
241/** RFC 5869 test case 6: Test with SHA-1 and zero-length salt/info */
242HKDF_TEST ( hkdf_test_6, &sha1_algorithm, 1,
243 IKM ( 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
244 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
245 0x0b, 0x0b ),
246 SALT(), INFO(),
247 PRK ( 0xda, 0x8c, 0x8a, 0x73, 0xc7, 0xfa, 0x77, 0x28, 0x8e, 0xc6,
248 0xf5, 0xe7, 0xc2, 0x97, 0x78, 0x6a, 0xa0, 0xd3, 0x2d, 0x01 ),
249 OKM ( 0x0a, 0xc1, 0xaf, 0x70, 0x02, 0xb3, 0xd7, 0x61, 0xd1, 0xe5,
250 0x52, 0x98, 0xda, 0x9d, 0x05, 0x06, 0xb9, 0xae, 0x52, 0x05,
251 0x72, 0x20, 0xa3, 0x06, 0xe0, 0x7b, 0x6b, 0x87, 0xe8, 0xdf,
252 0x21, 0xd0, 0xea, 0x00, 0x03, 0x3d, 0xe0, 0x39, 0x84, 0xd3,
253 0x49, 0x18 ) );
254
255/** RFC 5869 test case 7: Test with SHA-1, salt not provided */
256HKDF_TEST ( hkdf_test_7, &sha1_algorithm, 0,
257 IKM ( 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
258 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
259 0x0c, 0x0c ),
260 SALT(), INFO(),
261 PRK ( 0x2a, 0xdc, 0xca, 0xda, 0x18, 0x77, 0x9e, 0x7c, 0x20, 0x77,
262 0xad, 0x2e, 0xb1, 0x9d, 0x3f, 0x3e, 0x73, 0x13, 0x85, 0xdd ),
263 OKM ( 0x2c, 0x91, 0x11, 0x72, 0x04, 0xd7, 0x45, 0xf3, 0x50, 0x0d,
264 0x63, 0x6a, 0x62, 0xf6, 0x4f, 0x0a, 0xb3, 0xba, 0xe5, 0x48,
265 0xaa, 0x53, 0xd4, 0x23, 0xb0, 0xd1, 0xf2, 0x7e, 0xbb, 0xa6,
266 0xf5, 0xe5, 0x67, 0x3a, 0x08, 0x1d, 0x70, 0xcc, 0xe7, 0xac,
267 0xfc, 0x48 ) );
268
269/**
270 * Perform HKDF self-tests
271 *
272 */
273static void hkdf_test_exec ( void ) {
274
275 hkdf_ok ( &hkdf_test_1 );
276 hkdf_ok ( &hkdf_test_2 );
277 hkdf_ok ( &hkdf_test_3 );
278 hkdf_ok ( &hkdf_test_4 );
279 hkdf_ok ( &hkdf_test_5 );
280 hkdf_ok ( &hkdf_test_6 );
281 hkdf_ok ( &hkdf_test_7 );
282}
283
284/** HKDF self-test */
285struct self_test hkdf_test __self_test = {
286 .name = "hkdf",
287 .exec = hkdf_test_exec,
288};
NULL
#define NULL
NULL pointer (VOID *).
Definition Base.h:321
info
u32 info
Definition ar9003_mac.h:0
uint8_t
unsigned char uint8_t
Definition stdint.h:10
test
static int test
Definition epic100.c:73
FILE_LICENCE
#define FILE_LICENCE(_licence)
Declare a particular licence as applying to a file.
Definition compiler.h:921
hkdf_expand
void hkdf_expand(struct digest_algorithm *digest, const void *prk, const void *info, size_t info_len, void *out, size_t len)
Expand pseudorandom key.
Definition hkdf.c:95
hkdf_extract
void hkdf_extract(struct digest_algorithm *digest, const void *salt, size_t salt_len, const void *ikm, size_t ikm_len, void *prk)
Extract fixed-length pseudorandom key.
Definition hkdf.c:56
hkdf.h
HMAC-based Extract-and-Expand Key Derivation Function (HKDF).
hkdf_okx
void hkdf_okx(struct hkdf_test *test, const char *file, unsigned int line)
Report an HKDF test result.
Definition hkdf_test.c:51
hkdf_test_exec
static void hkdf_test_exec(void)
Perform HKDF self-tests.
Definition hkdf_test.c:273
hkdf_test.h
HKDF self-tests.
OKM
#define OKM(...)
Define inline expected output keying material.
Definition hkdf_test.h:32
HKDF_TEST
#define HKDF_TEST(name, DIGEST, SALTED, IKM, SALT, INFO, PRK, OKM)
Define an HKDF test.
Definition hkdf_test.h:72
PRK
#define PRK(...)
Define inline expected pseudorandom key.
Definition hkdf_test.h:26
hkdf_ok
#define hkdf_ok(test)
Report an HKDF test result.
Definition hkdf_test.h:100
IKM
#define IKM(...)
Define inline input keying material.
Definition hkdf_test.h:17
SALT
#define SALT(...)
Define inline salt.
Definition hkdf_test.h:20
INFO
#define INFO(...)
Define inline additional information.
Definition hkdf_test.h:23
crypto.h
Cryptographic API.
string.h
String functions.
memcpy
void * memcpy(void *dest, const void *src, size_t len) __nonnull
digestsize
uint32_t digestsize
Digest size (i.e.
Definition pccrr.h:1
sha1.h
SHA-1 algorithm.
sha1_algorithm
struct digest_algorithm sha1_algorithm
sha256.h
SHA-256 algorithm.
sha256_algorithm
struct digest_algorithm sha256_algorithm
memcmp
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition string.c:115
hkdf_test
An HKDF self-test.
Definition hkdf_test.h:35
self_test
A self-test set.
Definition test.h:15
test.h
Self-test infrastructure.
okx
#define okx(success, file, line)
Report test result.
Definition test.h:44
__self_test
#define __self_test
Declare a self-test.
Definition test.h:32
Generated by doxygen 1.16.1