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