1 /* LibTomCrypt, modular cryptographic library -- Tom St Denis */
2 /* SPDX-License-Identifier: Unlicense */
3 #include "tomcrypt_private.h"
4
5 /**
6 @file hmac_test.c
7 HMAC support, self-test, Tom St Denis/Dobes Vandermeer/Steffen Jaeckel
8 */
9
10 #ifdef LTC_HMAC
11
12 /*
13 TEST CASES SOURCE:
14
15 Network Working Group P. Cheng
16 Request for Comments: 2202 IBM
17 Category: Informational R. Glenn
18 NIST
19 September 1997
20
21 Test Cases for HMAC-MD5 and HMAC-SHA-1
22
23 *******************************************************************************
24
25 Network Working Group J. Kapp
26 Request for Comments: 2286 Reaper Technologies
27 Category: Informational February 1998
28
29 Test Cases for HMAC-RIPEMD160 and HMAC-RIPEMD128
30
31 *******************************************************************************
32
33 Network Working Group M. Nystrom
34 Request for Comments: 4231 RSA Security
35 Category: Standards Track December 2005
36
37 Identifiers and Test Vectors for HMAC-SHA-224, HMAC-SHA-256,
38 HMAC-SHA-384, and HMAC-SHA-512
39 */
40
41 /**
42 HMAC self-test
43 @return CRYPT_OK if successful, CRYPT_NOP if tests have been disabled.
44 */
hmac_test(void)45 int hmac_test(void)
46 {
47 #ifndef LTC_TEST
48 return CRYPT_NOP;
49 #else
50 unsigned char digest[MAXBLOCKSIZE];
51 int i;
52
53 static const unsigned char hmac_test_case_keys[][136] = {
54 { /* 1 */
55 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
56 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
57 0x0b, 0x0b, 0x0b, 0x0b
58 },
59 #ifdef LTC_TEST_EXT
60 { /* 2 */
61 0x4a, 0x65, 0x66, 0x65
62 },
63 { /* 4 */
64 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
65 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
66 0x15, 0x16, 0x17, 0x18, 0x19
67 },
68 { /* 5 */
69 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
70 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
71 0x0c, 0x0c, 0x0c, 0x0c
72 },
73 { /* 3, 6, 7 */
74 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
75 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
76 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
77 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
78 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
79
80 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
81 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
82 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
83 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
84 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
85
86 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
87 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
88 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
89 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
90 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
91
92 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
93 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
94 }
95 #endif /* LTC_TEST_EXT */
96 };
97
98
99 static const unsigned char hmac_test_case_data[][153] = {
100 {
101 "Hi There"
102 },
103 #ifdef LTC_TEST_EXT
104 {
105 "what do ya want for nothing?"
106 },
107 {
108 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
109 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
110 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
111 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
112 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd
113 },
114 {
115 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
116 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
117 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
118 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
119 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd
120 },
121 {
122 "Test With Truncation"
123 },
124 {
125 "Test Using Larger Than Block-Size Key - Hash Key First"
126 },
127 {
128 "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"
129 },
130 {
131 "This is a test using a larger than block-size key and a larger than block-size data. The key needs to be hashed before being used by the HMAC algorithm."
132 }
133 #endif /* LTC_TEST_EXT */
134 };
135
136 static const struct hmac_test_case {
137 const char *num;
138 const char *algo;
139 const unsigned char *key;
140 unsigned long keylen;
141 const unsigned char *data;
142 unsigned long datalen;
143 unsigned char digest[MAXBLOCKSIZE];
144 } cases[] = {
145 /*
146 RFC 2202 3. Test Cases for HMAC-SHA-1
147 */
148 { "rfc2202 3.1", "sha1",
149 hmac_test_case_keys[0], 20,
150 hmac_test_case_data[0], 8,
151 {0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
152 0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e,
153 0xf1, 0x46, 0xbe, 0x00} },
154
155 #ifdef LTC_TEST_EXT
156 { "rfc2202 3.2", "sha1",
157 hmac_test_case_keys[1], 4,
158 hmac_test_case_data[1], 28,
159 {0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2,
160 0xd2, 0x74, 0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c,
161 0x25, 0x9a, 0x7c, 0x79} },
162
163 { "rfc2202 3.3", "sha1",
164 hmac_test_case_keys[4], 20,
165 hmac_test_case_data[2], 50,
166 {0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd,
167 0x91, 0xa3, 0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f,
168 0x63, 0xf1, 0x75, 0xd3} },
169
170 { "rfc2202 3.4", "sha1",
171 hmac_test_case_keys[2], 25,
172 hmac_test_case_data[3], 50,
173 {0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6,
174 0xbc, 0x84, 0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c,
175 0x2d, 0x72, 0x35, 0xda} },
176
177 { "rfc2202 3.5", "sha1",
178 hmac_test_case_keys[3], 20,
179 hmac_test_case_data[4], 20,
180 {0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f, 0xe7, 0xf2,
181 0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32, 0x4a, 0x9a, 0x5a, 0x04} },
182
183 { "rfc2202 3.6", "sha1",
184 hmac_test_case_keys[4], 80,
185 hmac_test_case_data[5], 54,
186 {0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e,
187 0x95, 0x70, 0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55,
188 0xed, 0x40, 0x21, 0x12} },
189
190 { "rfc2202 3.7", "sha1",
191 hmac_test_case_keys[4], 80,
192 hmac_test_case_data[6], 73,
193 {0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78, 0x6d,
194 0x6b, 0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08, 0xbb, 0xff, 0x1a, 0x91} },
195 #endif /* LTC_TEST_EXT */
196
197 /*
198 RFC 2202 2. Test Cases for HMAC-MD5
199 */
200 { "rfc2202 2.1", "md5",
201 hmac_test_case_keys[0], 16,
202 hmac_test_case_data[0], 8,
203 {0x92, 0x94, 0x72, 0x7a, 0x36, 0x38, 0xbb, 0x1c,
204 0x13, 0xf4, 0x8e, 0xf8, 0x15, 0x8b, 0xfc, 0x9d} },
205
206 #ifdef LTC_TEST_EXT
207 { "rfc2202 2.2", "md5",
208 hmac_test_case_keys[1], 4,
209 hmac_test_case_data[1], 28,
210 {0x75, 0x0c, 0x78, 0x3e, 0x6a, 0xb0, 0xb5, 0x03,
211 0xea, 0xa8, 0x6e, 0x31, 0x0a, 0x5d, 0xb7, 0x38} },
212
213 { "rfc2202 2.3", "md5",
214 hmac_test_case_keys[4], 16,
215 hmac_test_case_data[2], 50,
216 {0x56, 0xbe, 0x34, 0x52, 0x1d, 0x14, 0x4c, 0x88,
217 0xdb, 0xb8, 0xc7, 0x33, 0xf0, 0xe8, 0xb3, 0xf6} },
218
219 { "rfc2202 2.4", "md5",
220 hmac_test_case_keys[2], 25,
221 hmac_test_case_data[3], 50,
222 {0x69, 0x7e, 0xaf, 0x0a, 0xca, 0x3a, 0x3a, 0xea,
223 0x3a, 0x75, 0x16, 0x47, 0x46, 0xff, 0xaa, 0x79} },
224
225 { "rfc2202 2.5", "md5",
226 hmac_test_case_keys[3], 16,
227 hmac_test_case_data[4], 20,
228 {0x56, 0x46, 0x1e, 0xf2, 0x34, 0x2e, 0xdc, 0x00,
229 0xf9, 0xba, 0xb9, 0x95, 0x69, 0x0e, 0xfd, 0x4c} },
230
231 { "rfc2202 2.6", "md5",
232 hmac_test_case_keys[4], 80,
233 hmac_test_case_data[5], 54,
234 {0x6b, 0x1a, 0xb7, 0xfe, 0x4b, 0xd7, 0xbf, 0x8f,
235 0x0b, 0x62, 0xe6, 0xce, 0x61, 0xb9, 0xd0, 0xcd} },
236
237 { "rfc2202 2.7", "md5",
238 hmac_test_case_keys[4], 80,
239 hmac_test_case_data[6], 73,
240 {0x6f, 0x63, 0x0f, 0xad, 0x67, 0xcd, 0xa0, 0xee,
241 0x1f, 0xb1, 0xf5, 0x62, 0xdb, 0x3a, 0xa5, 0x3e} },
242 #endif /* LTC_TEST_EXT */
243
244 /*
245 RFC 2286 2. Test Cases for HMAC-RIPEMD160
246 */
247 { "rfc2286 2.1", "rmd160",
248 hmac_test_case_keys[0], 20,
249 hmac_test_case_data[0], 8,
250 {0x24, 0xcb, 0x4b, 0xd6, 0x7d, 0x20, 0xfc, 0x1a,
251 0x5d, 0x2e, 0xd7, 0x73, 0x2d, 0xcc, 0x39, 0x37,
252 0x7f, 0x0a, 0x56, 0x68} },
253
254 #ifdef LTC_TEST_EXT
255 { "rfc2286 2.2", "rmd160",
256 hmac_test_case_keys[1], 4,
257 hmac_test_case_data[1], 28,
258 {0xdd, 0xa6, 0xc0, 0x21, 0x3a, 0x48, 0x5a, 0x9e,
259 0x24, 0xf4, 0x74, 0x20, 0x64, 0xa7, 0xf0, 0x33,
260 0xb4, 0x3c, 0x40, 0x69} },
261
262 { "rfc2286 2.3", "rmd160",
263 hmac_test_case_keys[4], 20,
264 hmac_test_case_data[2], 50,
265 {0xb0, 0xb1, 0x05, 0x36, 0x0d, 0xe7, 0x59, 0x96,
266 0x0a, 0xb4, 0xf3, 0x52, 0x98, 0xe1, 0x16, 0xe2,
267 0x95, 0xd8, 0xe7, 0xc1} },
268
269 { "rfc2286 2.4", "rmd160",
270 hmac_test_case_keys[2], 25,
271 hmac_test_case_data[3], 50,
272 {0xd5, 0xca, 0x86, 0x2f, 0x4d, 0x21, 0xd5, 0xe6,
273 0x10, 0xe1, 0x8b, 0x4c, 0xf1, 0xbe, 0xb9, 0x7a,
274 0x43, 0x65, 0xec, 0xf4} },
275
276 { "rfc2286 2.5", "rmd160",
277 hmac_test_case_keys[3], 20,
278 hmac_test_case_data[4], 20,
279 {0x76, 0x19, 0x69, 0x39, 0x78, 0xf9, 0x1d, 0x90,
280 0x53, 0x9a, 0xe7, 0x86, 0x50, 0x0f, 0xf3, 0xd8,
281 0xe0, 0x51, 0x8e, 0x39} },
282
283 { "rfc2286 2.6", "rmd160",
284 hmac_test_case_keys[4], 80,
285 hmac_test_case_data[5], 54,
286 {0x64, 0x66, 0xca, 0x07, 0xac, 0x5e, 0xac, 0x29,
287 0xe1, 0xbd, 0x52, 0x3e, 0x5a, 0xda, 0x76, 0x05,
288 0xb7, 0x91, 0xfd, 0x8b} },
289
290 { "rfc2286 2.7", "rmd160",
291 hmac_test_case_keys[4], 80,
292 hmac_test_case_data[6], 73,
293 {0x69, 0xea, 0x60, 0x79, 0x8d, 0x71, 0x61, 0x6c,
294 0xce, 0x5f, 0xd0, 0x87, 0x1e, 0x23, 0x75, 0x4c,
295 0xd7, 0x5d, 0x5a, 0x0a} },
296 #endif /* LTC_TEST_EXT */
297
298 /*
299 RFC 2286 3. Test Cases for HMAC-RIPEMD128
300 */
301 { "rfc2286 3.1", "rmd128",
302 hmac_test_case_keys[0], 16,
303 hmac_test_case_data[0], 8,
304 {0xfb, 0xf6, 0x1f, 0x94, 0x92, 0xaa, 0x4b, 0xbf,
305 0x81, 0xc1, 0x72, 0xe8, 0x4e, 0x07, 0x34, 0xdb} },
306
307 #ifdef LTC_TEST_EXT
308 { "rfc2286 3.2", "rmd128",
309 hmac_test_case_keys[1], 4,
310 hmac_test_case_data[1], 28,
311 {0x87, 0x5f, 0x82, 0x88, 0x62, 0xb6, 0xb3, 0x34,
312 0xb4, 0x27, 0xc5, 0x5f, 0x9f, 0x7f, 0xf0, 0x9b} },
313
314 { "rfc2286 3.3", "rmd128",
315 hmac_test_case_keys[4], 16,
316 hmac_test_case_data[2], 50,
317 {0x09, 0xf0, 0xb2, 0x84, 0x6d, 0x2f, 0x54, 0x3d,
318 0xa3, 0x63, 0xcb, 0xec, 0x8d, 0x62, 0xa3, 0x8d} },
319
320 { "rfc2286 3.4", "rmd128",
321 hmac_test_case_keys[2], 25,
322 hmac_test_case_data[3], 50,
323 {0xbd, 0xbb, 0xd7, 0xcf, 0x03, 0xe4, 0x4b, 0x5a,
324 0xa6, 0x0a, 0xf8, 0x15, 0xbe, 0x4d, 0x22, 0x94} },
325
326 { "rfc2286 3.5", "rmd128",
327 hmac_test_case_keys[3], 16,
328 hmac_test_case_data[4], 20,
329 {0xe7, 0x98, 0x08, 0xf2, 0x4b, 0x25, 0xfd, 0x03,
330 0x1c, 0x15, 0x5f, 0x0d, 0x55, 0x1d, 0x9a, 0x3a} },
331
332 { "rfc2286 3.6", "rmd128",
333 hmac_test_case_keys[4], 80,
334 hmac_test_case_data[5], 54,
335 {0xdc, 0x73, 0x29, 0x28, 0xde, 0x98, 0x10, 0x4a,
336 0x1f, 0x59, 0xd3, 0x73, 0xc1, 0x50, 0xac, 0xbb} },
337
338 { "rfc2286 3.7", "rmd128",
339 hmac_test_case_keys[4], 80,
340 hmac_test_case_data[6], 73,
341 {0x5c, 0x6b, 0xec, 0x96, 0x79, 0x3e, 0x16, 0xd4,
342 0x06, 0x90, 0xc2, 0x37, 0x63, 0x5f, 0x30, 0xc5} },
343 #endif /* LTC_TEST_EXT */
344
345 /*
346 RFC 4231 4. Test Vectors
347 Ch. 4.6 with truncated output left out to simplify tests
348 */
349 { "rfc4231 4.2", "sha224",
350 hmac_test_case_keys[0], 20,
351 hmac_test_case_data[0], 8,
352 {0x89, 0x6f, 0xb1, 0x12, 0x8a, 0xbb, 0xdf, 0x19,
353 0x68, 0x32, 0x10, 0x7c, 0xd4, 0x9d, 0xf3, 0x3f,
354 0x47, 0xb4, 0xb1, 0x16, 0x99, 0x12, 0xba, 0x4f,
355 0x53, 0x68, 0x4b, 0x22} },
356
357 #ifdef LTC_TEST_EXT
358 { "rfc4231 4.3", "sha224",
359 hmac_test_case_keys[1], 4,
360 hmac_test_case_data[1], 28,
361 {0xa3, 0x0e, 0x01, 0x09, 0x8b, 0xc6, 0xdb, 0xbf,
362 0x45, 0x69, 0x0f, 0x3a, 0x7e, 0x9e, 0x6d, 0x0f,
363 0x8b, 0xbe, 0xa2, 0xa3, 0x9e, 0x61, 0x48, 0x00,
364 0x8f, 0xd0, 0x5e, 0x44} },
365
366 { "rfc4231 4.4", "sha224",
367 hmac_test_case_keys[4], 20,
368 hmac_test_case_data[2], 50,
369 {0x7f, 0xb3, 0xcb, 0x35, 0x88, 0xc6, 0xc1, 0xf6,
370 0xff, 0xa9, 0x69, 0x4d, 0x7d, 0x6a, 0xd2, 0x64,
371 0x93, 0x65, 0xb0, 0xc1, 0xf6, 0x5d, 0x69, 0xd1,
372 0xec, 0x83, 0x33, 0xea} },
373
374 { "rfc4231 4.5", "sha224",
375 hmac_test_case_keys[2], 25,
376 hmac_test_case_data[3], 50,
377 {0x6c, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3c, 0xac,
378 0x6a, 0x2a, 0xbc, 0x1b, 0xb3, 0x82, 0x62, 0x7c,
379 0xec, 0x6a, 0x90, 0xd8, 0x6e, 0xfc, 0x01, 0x2d,
380 0xe7, 0xaf, 0xec, 0x5a} },
381
382 { "rfc4231 4.7", "sha224",
383 hmac_test_case_keys[4], 131,
384 hmac_test_case_data[5], 54,
385 {0x95, 0xe9, 0xa0, 0xdb, 0x96, 0x20, 0x95, 0xad,
386 0xae, 0xbe, 0x9b, 0x2d, 0x6f, 0x0d, 0xbc, 0xe2,
387 0xd4, 0x99, 0xf1, 0x12, 0xf2, 0xd2, 0xb7, 0x27,
388 0x3f, 0xa6, 0x87, 0x0e} },
389
390 { "rfc4231 4.8", "sha224",
391 hmac_test_case_keys[4], 131,
392 hmac_test_case_data[7], 152,
393 {0x3a, 0x85, 0x41, 0x66, 0xac, 0x5d, 0x9f, 0x02,
394 0x3f, 0x54, 0xd5, 0x17, 0xd0, 0xb3, 0x9d, 0xbd,
395 0x94, 0x67, 0x70, 0xdb, 0x9c, 0x2b, 0x95, 0xc9,
396 0xf6, 0xf5, 0x65, 0xd1} },
397 #endif /* LTC_TEST_EXT */
398
399 { "rfc4231 4.2", "sha256",
400 hmac_test_case_keys[0], 20,
401 hmac_test_case_data[0], 8,
402 {0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
403 0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
404 0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
405 0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7} },
406
407 #ifdef LTC_TEST_EXT
408 { "rfc4231 4.3", "sha256",
409 hmac_test_case_keys[1], 4,
410 hmac_test_case_data[1], 28,
411 {0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
412 0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
413 0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
414 0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43} },
415
416 { "rfc4231 4.4", "sha256",
417 hmac_test_case_keys[4], 20,
418 hmac_test_case_data[2], 50,
419 {0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
420 0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7,
421 0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
422 0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe} },
423
424 { "rfc4231 4.5", "sha256",
425 hmac_test_case_keys[2], 25,
426 hmac_test_case_data[3], 50,
427 {0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e,
428 0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a,
429 0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
430 0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b} },
431
432 { "rfc4231 4.7", "sha256",
433 hmac_test_case_keys[4], 131,
434 hmac_test_case_data[5], 54,
435 {0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f,
436 0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f,
437 0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
438 0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54} },
439
440 { "rfc4231 4.8", "sha256",
441 hmac_test_case_keys[4], 131,
442 hmac_test_case_data[7], 152,
443 {0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb,
444 0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44,
445 0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
446 0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2} },
447 #endif /* LTC_TEST_EXT */
448
449 { "rfc4231 4.2", "sha384",
450 hmac_test_case_keys[0], 20,
451 hmac_test_case_data[0], 8,
452 {0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62,
453 0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
454 0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6,
455 0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
456 0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f,
457 0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6} },
458
459 #ifdef LTC_TEST_EXT
460 { "rfc4231 4.3", "sha384",
461 hmac_test_case_keys[1], 4,
462 hmac_test_case_data[1], 28,
463 {0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31,
464 0x61, 0x7f, 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b,
465 0x9c, 0x7e, 0xf4, 0x64, 0xf5, 0xa0, 0x1b, 0x47,
466 0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, 0x44, 0x5e,
467 0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7,
468 0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49} },
469
470 { "rfc4231 4.4", "sha384",
471 hmac_test_case_keys[4], 20,
472 hmac_test_case_data[2], 50,
473 {0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a,
474 0x0a, 0xa2, 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f,
475 0x0a, 0xa6, 0x35, 0xd9, 0x47, 0xac, 0x9f, 0xeb,
476 0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, 0x14, 0x4b,
477 0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9,
478 0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27} },
479
480 { "rfc4231 4.5", "sha384",
481 hmac_test_case_keys[2], 25,
482 hmac_test_case_data[3], 50,
483 {0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85,
484 0x19, 0x33, 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7,
485 0x7a, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9c,
486 0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, 0x3b, 0x4e,
487 0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79,
488 0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb} },
489
490 { "rfc4231 4.7", "sha384",
491 hmac_test_case_keys[4], 131,
492 hmac_test_case_data[5], 54,
493 {0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90,
494 0x88, 0xd2, 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4,
495 0x4f, 0x9e, 0xf1, 0x01, 0x2a, 0x2b, 0x58, 0x8f,
496 0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, 0xc4, 0xc6,
497 0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82,
498 0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52} },
499
500 { "rfc4231 4.8", "sha384",
501 hmac_test_case_keys[4], 131,
502 hmac_test_case_data[7], 152,
503 {0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d,
504 0x35, 0x1e, 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c,
505 0x60, 0x24, 0x20, 0xfe, 0xb0, 0xb8, 0xfb, 0x9a,
506 0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, 0x99, 0xc5,
507 0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d,
508 0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e} },
509 #endif /* LTC_TEST_EXT */
510
511 { "rfc4231 4.2", "sha512",
512 hmac_test_case_keys[0], 20,
513 hmac_test_case_data[0], 8,
514 {0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
515 0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
516 0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
517 0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde,
518 0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02,
519 0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4,
520 0xbe, 0x9d, 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70,
521 0x2e, 0x69, 0x6c, 0x20, 0x3a, 0x12, 0x68, 0x54} },
522
523 #ifdef LTC_TEST_EXT
524 { "rfc4231 4.3", "sha512",
525 hmac_test_case_keys[1], 4,
526 hmac_test_case_data[1], 28,
527 {0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2,
528 0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
529 0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6,
530 0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54,
531 0x97, 0x58, 0xbf, 0x75, 0xc0, 0x5a, 0x99, 0x4a,
532 0x6d, 0x03, 0x4f, 0x65, 0xf8, 0xf0, 0xe6, 0xfd,
533 0xca, 0xea, 0xb1, 0xa3, 0x4d, 0x4a, 0x6b, 0x4b,
534 0x63, 0x6e, 0x07, 0x0a, 0x38, 0xbc, 0xe7, 0x37} },
535
536 { "rfc4231 4.4", "sha512",
537 hmac_test_case_keys[4], 20,
538 hmac_test_case_data[2], 50,
539 {0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84,
540 0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
541 0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36,
542 0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39,
543 0xbf, 0x3e, 0x84, 0x82, 0x79, 0xa7, 0x22, 0xc8,
544 0x06, 0xb4, 0x85, 0xa4, 0x7e, 0x67, 0xc8, 0x07,
545 0xb9, 0x46, 0xa3, 0x37, 0xbe, 0xe8, 0x94, 0x26,
546 0x74, 0x27, 0x88, 0x59, 0xe1, 0x32, 0x92, 0xfb} },
547
548 { "rfc4231 4.5", "sha512",
549 hmac_test_case_keys[2], 25,
550 hmac_test_case_data[3], 50,
551 {0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69,
552 0x90, 0xe5, 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7,
553 0xe5, 0x76, 0xd9, 0x7f, 0xf9, 0x4b, 0x87, 0x2d,
554 0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, 0xe3, 0xdb,
555 0xa9, 0x1c, 0xa5, 0xc1, 0x1a, 0xa2, 0x5e, 0xb4,
556 0xd6, 0x79, 0x27, 0x5c, 0xc5, 0x78, 0x80, 0x63,
557 0xa5, 0xf1, 0x97, 0x41, 0x12, 0x0c, 0x4f, 0x2d,
558 0xe2, 0xad, 0xeb, 0xeb, 0x10, 0xa2, 0x98, 0xdd} },
559
560 { "rfc4231 4.7", "sha512",
561 hmac_test_case_keys[4], 131,
562 hmac_test_case_data[5], 54,
563 {0x80, 0xb2, 0x42, 0x63, 0xc7, 0xc1, 0xa3, 0xeb,
564 0xb7, 0x14, 0x93, 0xc1, 0xdd, 0x7b, 0xe8, 0xb4,
565 0x9b, 0x46, 0xd1, 0xf4, 0x1b, 0x4a, 0xee, 0xc1,
566 0x12, 0x1b, 0x01, 0x37, 0x83, 0xf8, 0xf3, 0x52,
567 0x6b, 0x56, 0xd0, 0x37, 0xe0, 0x5f, 0x25, 0x98,
568 0xbd, 0x0f, 0xd2, 0x21, 0x5d, 0x6a, 0x1e, 0x52,
569 0x95, 0xe6, 0x4f, 0x73, 0xf6, 0x3f, 0x0a, 0xec,
570 0x8b, 0x91, 0x5a, 0x98, 0x5d, 0x78, 0x65, 0x98} },
571
572 { "rfc4231 4.8", "sha512",
573 hmac_test_case_keys[4], 131,
574 hmac_test_case_data[7], 152,
575 {0xe3, 0x7b, 0x6a, 0x77, 0x5d, 0xc8, 0x7d, 0xba,
576 0xa4, 0xdf, 0xa9, 0xf9, 0x6e, 0x5e, 0x3f, 0xfd,
577 0xde, 0xbd, 0x71, 0xf8, 0x86, 0x72, 0x89, 0x86,
578 0x5d, 0xf5, 0xa3, 0x2d, 0x20, 0xcd, 0xc9, 0x44,
579 0xb6, 0x02, 0x2c, 0xac, 0x3c, 0x49, 0x82, 0xb1,
580 0x0d, 0x5e, 0xeb, 0x55, 0xc3, 0xe4, 0xde, 0x15,
581 0x13, 0x46, 0x76, 0xfb, 0x6d, 0xe0, 0x44, 0x60,
582 0x65, 0xc9, 0x74, 0x40, 0xfa, 0x8c, 0x6a, 0x58} },
583 #endif /* LTC_TEST_EXT */
584
585 };
586
587 unsigned long outlen;
588 int err;
589 int tested=0,failed=0;
590 for(i=0; i < (int)(sizeof(cases) / sizeof(cases[0])); i++) {
591 int hash = find_hash(cases[i].algo);
592 if (hash == -1) continue;
593 ++tested;
594 outlen = sizeof(digest);
595 if((err = hmac_memory(hash, cases[i].key, cases[i].keylen, cases[i].data, cases[i].datalen, digest, &outlen)) != CRYPT_OK) {
596 #ifdef LTC_TEST_DBG
597 printf("HMAC-%s test %s, %s\n", cases[i].algo, cases[i].num, error_to_string(err));
598 #endif
599 return err;
600 }
601
602 if(compare_testvector(digest, outlen, cases[i].digest, (size_t)hash_descriptor[hash]->hashsize, cases[i].num, i)) {
603 failed++;
604 }
605 }
606
607 if (failed != 0) {
608 return CRYPT_FAIL_TESTVECTOR;
609 }
610 if (tested == 0) {
611 return CRYPT_NOP;
612 }
613 return CRYPT_OK;
614 #endif
615 }
616
617 #endif
618
619