Branch data Line data Source code
1 : : /**
2 : : * \file lib/hmac.c
3 : : *
4 : : * \brief Provide HMAC support to SPA communications
5 : : */
6 : :
7 : : /* Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
8 : : * Copyright (C) 2009-2015 fwknop developers and contributors. For a full
9 : : * list of contributors, see the file 'CREDITS'.
10 : : *
11 : : * License (GNU General Public License):
12 : : *
13 : : * This program is free software; you can redistribute it and/or
14 : : * modify it under the terms of the GNU General Public License
15 : : * as published by the Free Software Foundation; either version 2
16 : : * of the License, or (at your option) any later version.
17 : : *
18 : : * This program is distributed in the hope that it will be useful,
19 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 : : * GNU General Public License for more details.
22 : : *
23 : : * You should have received a copy of the GNU General Public License
24 : : * along with this program; if not, write to the Free Software
25 : : * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
26 : : * USA
27 : : *
28 : : *****************************************************************************
29 : : */
30 : :
31 : : #include "hmac.h"
32 : : #ifdef HAVE_C_UNIT_TESTS /* LCOV_EXCL_START */
33 : : DECLARE_TEST_SUITE(hmac_test, "hmac functions test suite");
34 : : #endif /* LCOV_EXCL_STOP */
35 : :
36 : : /**
37 : : * /brief populate the inner and outer pads
38 : : *
39 : : *
40 : : */
41 : : static void
42 : 1522888 : pad_init(unsigned char *inner_pad, unsigned char *outer_pad,
43 : : const unsigned char * const key, const int key_len)
44 : : {
45 : 1522888 : int i = 0;
46 : :
47 [ + + ]: 50247648 : for (i=0; i < MAX_DIGEST_BLOCK_LEN && i < key_len; i++) {
48 : 48724760 : inner_pad[i] = key[i] ^ 0x36;
49 : 48724760 : outer_pad[i] = key[i] ^ 0x5c;
50 : : }
51 : :
52 [ + - ]: 1522888 : if(i < MAX_DIGEST_BLOCK_LEN)
53 : : {
54 [ + + ]: 159910896 : while(i < MAX_DIGEST_BLOCK_LEN)
55 : : {
56 : 158388008 : inner_pad[i] = 0x36;
57 : 158388008 : outer_pad[i] = 0x5c;
58 : 158388008 : i++;
59 : : }
60 : : }
61 : 1522888 : return;
62 : : }
63 : :
64 : : int
65 : 58 : hmac_md5(const char *msg, const unsigned int msg_len,
66 : : unsigned char *hmac, const char *hmac_key, const int hmac_key_len)
67 : : {
68 : 58 : unsigned char inner_hash[MD5_DIGEST_LEN] = {0};
69 : 58 : unsigned char block_inner_pad[MAX_DIGEST_BLOCK_LEN] = {0};
70 : 58 : unsigned char block_outer_pad[MAX_DIGEST_BLOCK_LEN] = {0};
71 : 58 : unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
72 : 58 : unsigned char padded_hash[MD5_BLOCK_LEN + MD5_DIGEST_LEN + 1] = {0};
73 : 58 : unsigned char *padded_msg = calloc(1, msg_len + MAX_DIGEST_BLOCK_LEN + 1);
74 : 58 : int final_len = hmac_key_len;
75 : :
76 [ + - ]: 58 : if (padded_msg == NULL)
77 : : return FKO_ERROR_MEMORY_ALLOCATION;
78 : :
79 [ + + ]: 58 : if(MD5_BLOCK_LEN < hmac_key_len)
80 : : {
81 : : /* Calculate the digest of the key
82 : : */
83 : 5 : md5(final_key, (unsigned char *)hmac_key, final_len);
84 : 5 : final_len = MD5_DIGEST_LEN;
85 : : }
86 : : else
87 : : {
88 : 53 : memcpy(final_key, hmac_key, hmac_key_len);
89 : : }
90 : 58 : pad_init(block_inner_pad, block_outer_pad, final_key, final_len);
91 : :
92 : : //The first step is to hash the inner_pad + message
93 : : memcpy(padded_msg, block_inner_pad, MD5_BLOCK_LEN);
94 : 58 : memcpy(padded_msg + MD5_BLOCK_LEN, msg, msg_len);
95 : :
96 : : //Calculate the inner hash
97 : 58 : md5(inner_hash, padded_msg, msg_len + MD5_BLOCK_LEN);
98 : :
99 : : //Then hash the outer pad + inner hash
100 : : memcpy(padded_hash, block_outer_pad, MD5_BLOCK_LEN);
101 : : memcpy(padded_hash + MD5_BLOCK_LEN, inner_hash, MD5_DIGEST_LEN);
102 : :
103 : : //the outer hash is the final hmac
104 : 58 : md5(hmac, padded_hash, MD5_BLOCK_LEN + MD5_DIGEST_LEN);
105 : :
106 : 58 : free(padded_msg);
107 : 58 : return FKO_SUCCESS;
108 : : }
109 : :
110 : : int
111 : 96 : hmac_sha1(const char *msg, const unsigned int msg_len,
112 : : unsigned char *hmac, const char *hmac_key, const int hmac_key_len)
113 : : {
114 : 96 : unsigned char inner_hash[SHA1_DIGEST_LEN] = {0};
115 : 96 : unsigned char block_inner_pad[MAX_DIGEST_BLOCK_LEN] = {0};
116 : 96 : unsigned char block_outer_pad[MAX_DIGEST_BLOCK_LEN] = {0};
117 : 96 : unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
118 : 96 : unsigned char padded_hash[SHA1_BLOCK_LEN + SHA1_DIGEST_LEN + 1] = {0};
119 : 96 : unsigned char *padded_msg = calloc(1, msg_len + MAX_DIGEST_BLOCK_LEN + 1);
120 : 96 : int final_len = hmac_key_len;
121 : :
122 [ + - ]: 96 : if (padded_msg == NULL)
123 : : return FKO_ERROR_MEMORY_ALLOCATION;
124 : :
125 [ + + ]: 96 : if(SHA1_BLOCK_LEN < hmac_key_len)
126 : : {
127 : : /* Calculate the digest of the key
128 : : */
129 : 5 : sha1(final_key, (unsigned char *)hmac_key, final_len);
130 : 5 : final_len = SHA1_DIGEST_LEN;
131 : : }
132 : : else
133 : : {
134 : 91 : memcpy(final_key, hmac_key, hmac_key_len);
135 : : }
136 : 96 : pad_init(block_inner_pad, block_outer_pad, final_key, final_len);
137 : :
138 : : //The first step is to hash the inner_pad + message
139 : : memcpy(padded_msg, block_inner_pad, SHA1_BLOCK_LEN);
140 : 96 : memcpy(padded_msg + SHA1_BLOCK_LEN, msg, msg_len);
141 : :
142 : : //Calculate the inner hash
143 : 96 : sha1(inner_hash, padded_msg, msg_len + SHA1_BLOCK_LEN);
144 : :
145 : : //Then hash the outer pad + inner hash
146 : : memcpy(padded_hash, block_outer_pad, SHA1_BLOCK_LEN);
147 : : memcpy(padded_hash + SHA1_BLOCK_LEN, inner_hash, SHA1_DIGEST_LEN);
148 : :
149 : : //the outer hash is the final hmac
150 : 96 : sha1(hmac, padded_hash, SHA1_BLOCK_LEN + SHA1_DIGEST_LEN);
151 : :
152 : 96 : free(padded_msg);
153 : 96 : return FKO_SUCCESS;
154 : : }
155 : :
156 : : int
157 : 1522603 : hmac_sha256(const char *msg, const unsigned int msg_len,
158 : : unsigned char *hmac, const char *hmac_key, const int hmac_key_len)
159 : : {
160 : 1522603 : unsigned char inner_hash[SHA256_DIGEST_LEN] = {0};
161 : 1522603 : unsigned char block_inner_pad[MAX_DIGEST_BLOCK_LEN] = {0};
162 : 1522603 : unsigned char block_outer_pad[MAX_DIGEST_BLOCK_LEN] = {0};
163 : 1522603 : unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
164 : 1522603 : unsigned char padded_hash[SHA256_BLOCK_LEN + SHA256_DIGEST_LEN + 1] = {0};
165 : 1522603 : unsigned char *padded_msg = calloc(1, msg_len + MAX_DIGEST_BLOCK_LEN + 1);
166 : 1522603 : int final_len = hmac_key_len;
167 : :
168 [ + + ]: 1522603 : if (padded_msg == NULL)
169 : : return FKO_ERROR_MEMORY_ALLOCATION;
170 : :
171 [ + + ]: 1522582 : if(SHA256_BLOCK_LEN < hmac_key_len)
172 : : {
173 : : /* Calculate the digest of the key
174 : : */
175 : 1503556 : sha256(final_key, (unsigned char *)hmac_key, final_len);
176 : 1503556 : final_len = SHA256_DIGEST_LEN;
177 : : }
178 : : else
179 : : {
180 : 19026 : memcpy(final_key, hmac_key, hmac_key_len);
181 : : }
182 : 1522582 : pad_init(block_inner_pad, block_outer_pad, final_key, final_len);
183 : :
184 : : //The first step is to hash the inner_pad + message
185 : : memcpy(padded_msg, block_inner_pad, SHA256_BLOCK_LEN);
186 : 1522582 : memcpy(padded_msg + SHA256_BLOCK_LEN, msg, msg_len);
187 : :
188 : : //Calculate the inner hash
189 : 1522582 : sha256(inner_hash, padded_msg, msg_len + SHA256_BLOCK_LEN);
190 : :
191 : : //Then hash the outer pad + inner hash
192 : : memcpy(padded_hash, block_outer_pad, SHA256_BLOCK_LEN);
193 : : memcpy(padded_hash + SHA256_BLOCK_LEN, inner_hash, SHA256_DIGEST_LEN);
194 : :
195 : : //the outer hash is the final hmac
196 : 1522582 : sha256(hmac, padded_hash, SHA256_BLOCK_LEN + SHA256_DIGEST_LEN);
197 : :
198 : 1522582 : free(padded_msg);
199 : 1522582 : return FKO_SUCCESS;
200 : : }
201 : :
202 : : int
203 : 58 : hmac_sha384(const char *msg, const unsigned int msg_len,
204 : : unsigned char *hmac, const char *hmac_key, const int hmac_key_len)
205 : : {
206 : 58 : unsigned char inner_hash[SHA384_DIGEST_LEN] = {0};
207 : 58 : unsigned char block_inner_pad[MAX_DIGEST_BLOCK_LEN] = {0};
208 : 58 : unsigned char block_outer_pad[MAX_DIGEST_BLOCK_LEN] = {0};
209 : 58 : unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
210 : 58 : unsigned char padded_hash[SHA384_BLOCK_LEN + SHA384_DIGEST_LEN + 1] = {0};
211 : 58 : unsigned char *padded_msg = calloc(1, msg_len + MAX_DIGEST_BLOCK_LEN + 1);
212 : 58 : int final_len = hmac_key_len;
213 : :
214 [ + - ]: 58 : if (padded_msg == NULL)
215 : : return FKO_ERROR_MEMORY_ALLOCATION;
216 : :
217 [ + + ]: 58 : if(SHA384_BLOCK_LEN < hmac_key_len)
218 : : {
219 : : /* Calculate the digest of the key
220 : : */
221 : 2 : sha384(final_key, (unsigned char *)hmac_key, final_len);
222 : 2 : final_len = SHA384_DIGEST_LEN;
223 : : }
224 : : else
225 : : {
226 : 56 : memcpy(final_key, hmac_key, hmac_key_len);
227 : : }
228 : 58 : pad_init(block_inner_pad, block_outer_pad, final_key, final_len);
229 : :
230 : : //The first step is to hash the inner_pad + message
231 : : memcpy(padded_msg, block_inner_pad, SHA384_BLOCK_LEN);
232 : 58 : memcpy(padded_msg + SHA384_BLOCK_LEN, msg, msg_len);
233 : :
234 : : //Calculate the inner hash
235 : 58 : sha384(inner_hash, padded_msg, msg_len + SHA384_BLOCK_LEN);
236 : :
237 : : //Then hash the outer pad + inner hash
238 : : memcpy(padded_hash, block_outer_pad, SHA384_BLOCK_LEN);
239 : : memcpy(padded_hash + SHA384_BLOCK_LEN, inner_hash, SHA384_DIGEST_LEN);
240 : :
241 : : //the outer hash is the final hmac
242 : 58 : sha384(hmac, padded_hash, SHA384_BLOCK_LEN + SHA384_DIGEST_LEN);
243 : :
244 : 58 : free(padded_msg);
245 : 58 : return FKO_SUCCESS;
246 : : }
247 : :
248 : : int
249 : 64 : hmac_sha512(const char *msg, const unsigned int msg_len,
250 : : unsigned char *hmac, const char *hmac_key, const int hmac_key_len)
251 : : {
252 : 64 : unsigned char inner_hash[SHA512_DIGEST_LEN] = {0};
253 : 64 : unsigned char block_inner_pad[MAX_DIGEST_BLOCK_LEN] = {0};
254 : 64 : unsigned char block_outer_pad[MAX_DIGEST_BLOCK_LEN] = {0};
255 : 64 : unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
256 : 64 : unsigned char padded_hash[SHA512_BLOCK_LEN + SHA512_DIGEST_LEN + 1] = {0};
257 : 64 : unsigned char *padded_msg = calloc(1, msg_len + MAX_DIGEST_BLOCK_LEN + 1);
258 : 64 : int final_len = hmac_key_len;
259 : :
260 [ + - ]: 64 : if (padded_msg == NULL)
261 : : return FKO_ERROR_MEMORY_ALLOCATION;
262 : :
263 [ + + ]: 64 : if(SHA512_BLOCK_LEN < hmac_key_len)
264 : : {
265 : : /* Calculate the digest of the key
266 : : */
267 : 2 : sha512(final_key, (unsigned char *)hmac_key, final_len);
268 : 2 : final_len = SHA512_DIGEST_LEN;
269 : : }
270 : : else
271 : : {
272 : 62 : memcpy(final_key, hmac_key, hmac_key_len);
273 : : }
274 : 64 : pad_init(block_inner_pad, block_outer_pad, final_key, final_len);
275 : :
276 : : //The first step is to hash the inner_pad + message
277 : : memcpy(padded_msg, block_inner_pad, SHA512_BLOCK_LEN);
278 : 64 : memcpy(padded_msg + SHA512_BLOCK_LEN, msg, msg_len);
279 : :
280 : : //Calculate the inner hash
281 : 64 : sha512(inner_hash, padded_msg, msg_len + SHA512_BLOCK_LEN);
282 : :
283 : : //Then hash the outer pad + inner hash
284 : : memcpy(padded_hash, block_outer_pad, SHA512_BLOCK_LEN);
285 : : memcpy(padded_hash + SHA512_BLOCK_LEN, inner_hash, SHA512_DIGEST_LEN);
286 : :
287 : : //the outer hash is the final hmac
288 : 64 : sha512(hmac, padded_hash, SHA512_BLOCK_LEN + SHA512_DIGEST_LEN);
289 : :
290 : 64 : free(padded_msg);
291 : 64 : return FKO_SUCCESS;
292 : : }
293 : :
294 : : int
295 : 11 : hmac_sha3_256(const char *msg, const unsigned int msg_len,
296 : : unsigned char *hmac, const char *hmac_key, const int hmac_key_len)
297 : : {
298 : 11 : unsigned char inner_hash[SHA3_256_DIGEST_LEN] = {0};
299 : 11 : unsigned char block_inner_pad[MAX_DIGEST_BLOCK_LEN] = {0};
300 : 11 : unsigned char block_outer_pad[MAX_DIGEST_BLOCK_LEN] = {0};
301 : 11 : unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
302 : 11 : unsigned char padded_hash[SHA3_256_BLOCK_LEN + SHA3_256_DIGEST_LEN + 1] = {0};
303 : 11 : unsigned char *padded_msg = calloc(1, msg_len + MAX_DIGEST_BLOCK_LEN + 1);
304 : 11 : int final_len = hmac_key_len;
305 : :
306 [ + - ]: 11 : if (padded_msg == NULL)
307 : : return FKO_ERROR_MEMORY_ALLOCATION;
308 : :
309 [ + + ]: 11 : if(SHA3_256_BLOCK_LEN < hmac_key_len)
310 : : {
311 : : /* Calculate the digest of the key
312 : : */
313 : 2 : FIPS202_SHA3_256((unsigned char *)hmac_key, final_len, final_key);
314 : 2 : final_len = SHA3_256_DIGEST_LEN;
315 : : }
316 : : else
317 : : {
318 : 9 : memcpy(final_key, hmac_key, hmac_key_len);
319 : : }
320 : 11 : pad_init(block_inner_pad, block_outer_pad, final_key, final_len);
321 : :
322 : : //The first step is to hash the inner_pad + message
323 : : memcpy(padded_msg, block_inner_pad, SHA3_256_BLOCK_LEN);
324 : 11 : memcpy(padded_msg + SHA3_256_BLOCK_LEN, msg, msg_len);
325 : :
326 : : //Calculate the inner hash
327 : 11 : FIPS202_SHA3_256(padded_msg, msg_len + SHA3_256_BLOCK_LEN, inner_hash);
328 : :
329 : : //Then hash the outer pad + inner hash
330 : : memcpy(padded_hash, block_outer_pad, SHA3_256_BLOCK_LEN);
331 : : memcpy(padded_hash + SHA3_256_BLOCK_LEN, inner_hash, SHA3_256_DIGEST_LEN);
332 : :
333 : : //the outer hash is the final hmac
334 : 11 : FIPS202_SHA3_256(padded_hash, SHA3_256_BLOCK_LEN + SHA3_256_DIGEST_LEN, hmac);
335 : :
336 : 11 : free(padded_msg);
337 : 11 : return FKO_SUCCESS;
338 : : }
339 : :
340 : : int
341 : 19 : hmac_sha3_512(const char *msg, const unsigned int msg_len,
342 : : unsigned char *hmac, const char *hmac_key, const int hmac_key_len)
343 : : {
344 : 19 : unsigned char inner_hash[SHA3_512_DIGEST_LEN] = {0};
345 : 19 : unsigned char block_inner_pad[MAX_DIGEST_BLOCK_LEN] = {0};
346 : 19 : unsigned char block_outer_pad[MAX_DIGEST_BLOCK_LEN] = {0};
347 : 19 : unsigned char final_key[MAX_DIGEST_BLOCK_LEN] = {0};
348 : 19 : unsigned char padded_hash[SHA3_512_BLOCK_LEN + SHA3_512_DIGEST_LEN + 1] = {0};
349 : 19 : unsigned char *padded_msg = calloc(1, msg_len + MAX_DIGEST_BLOCK_LEN + 1);
350 : 19 : int final_len = hmac_key_len;
351 : :
352 [ + - ]: 19 : if (padded_msg == NULL)
353 : : return FKO_ERROR_MEMORY_ALLOCATION;
354 : :
355 [ + + ]: 19 : if(SHA3_512_BLOCK_LEN < hmac_key_len)
356 : : {
357 : : /* Calculate the digest of the key
358 : : */
359 : 6 : FIPS202_SHA3_512((unsigned char *)hmac_key, final_len, final_key);
360 : 6 : final_len = SHA3_512_DIGEST_LEN;
361 : : }
362 : : else
363 : : {
364 : 13 : memcpy(final_key, hmac_key, hmac_key_len);
365 : : }
366 : 19 : pad_init(block_inner_pad, block_outer_pad, final_key, final_len);
367 : :
368 : : //The first step is to hash the inner_pad + message
369 : : memcpy(padded_msg, block_inner_pad, SHA3_512_BLOCK_LEN);
370 : 19 : memcpy(padded_msg + SHA3_512_BLOCK_LEN, msg, msg_len);
371 : :
372 : : //Calculate the inner hash
373 : 19 : FIPS202_SHA3_512(padded_msg, msg_len + SHA3_512_BLOCK_LEN, inner_hash);
374 : :
375 : : //Then hash the outer pad + inner hash
376 : : memcpy(padded_hash, block_outer_pad, SHA3_512_BLOCK_LEN);
377 : : memcpy(padded_hash + SHA3_512_BLOCK_LEN, inner_hash, SHA3_512_DIGEST_LEN);
378 : :
379 : : //the outer hash is the final hmac
380 : 19 : FIPS202_SHA3_512(padded_hash, SHA3_512_BLOCK_LEN + SHA3_512_DIGEST_LEN, hmac);
381 : :
382 : 19 : free(padded_msg);
383 : 19 : return FKO_SUCCESS;
384 : : }
385 : :
386 : : #ifdef HAVE_C_UNIT_TESTS /* LCOV_EXCL_START */
387 : :
388 : : DECLARE_UTEST(test_hmac_md5, "hmac_md5 test vectors") // https://tools.ietf.org/html/rfc2202
389 : : {
390 : : char msg[1024] = {0};
391 : : unsigned char hmac[1024] = {0};
392 : : char hmac_txt[1024] = {0};
393 : : char hmac_key[1024] = {0};
394 : : char expected_hmac1[1024] = {0};
395 : : char expected_hmac2[1024] = {0};
396 : : char expected_hmac3[1024] = {0};
397 : : char expected_hmac4[1024] = {0};
398 : : char expected_hmac5[1024] = {0};
399 : : char expected_hmac6[1024] = {0};
400 : : char expected_hmac7[1024] = {0};
401 : : int msg_len, key_len;
402 : : int i = 0;
403 : :
404 : : //vector 1
405 : : for ( i = 0; i < 16; i++)
406 : : {
407 : : hmac_key[i] = 0x0b;
408 : : }
409 : : key_len = 16;
410 : : strcpy(msg, "Hi There");
411 : : msg_len = 8;
412 : : strcpy(expected_hmac1, "9294727a3638bb1c13f48ef8158bfc9d");
413 : :
414 : : hmac_md5(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
415 : :
416 : : for ( i = 0; i < MD5_DIGEST_LEN; i++)
417 : : {
418 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
419 : : }
420 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac1, MD5_DIGEST_LEN) == 0);
421 : :
422 : : //vector 2
423 : : strcpy(hmac_key, "Jefe");
424 : : key_len = 4;
425 : : strcpy(msg, "what do ya want for nothing?");
426 : : msg_len = 28;
427 : : strcpy(expected_hmac2, "750c783e6ab0b503eaa86e310a5db738");
428 : :
429 : : hmac_md5(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
430 : :
431 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
432 : : {
433 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
434 : : }
435 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac2, MD5_DIGEST_LEN) == 0);
436 : :
437 : : //vector 3
438 : : for ( i = 0; i < 16; i++)
439 : : {
440 : : hmac_key[i] = 0xaa;
441 : : }
442 : : key_len = 16;
443 : : for ( i = 0; i < 50; i++)
444 : : {
445 : : msg[i] = 0xdd;
446 : : }
447 : : msg_len = 50;
448 : : strcpy(expected_hmac3, "56be34521d144c88dbb8c733f0e8b3f6");
449 : :
450 : : hmac_md5(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
451 : :
452 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
453 : : {
454 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
455 : : }
456 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac3, MD5_DIGEST_LEN) == 0);
457 : :
458 : : //vector 4
459 : : strcpy(hmac_key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19");
460 : : key_len = 25;
461 : : for ( i = 0; i < 50; i++)
462 : : {
463 : : msg[i] = 0xcd;
464 : : }
465 : : msg_len = 50;
466 : : strcpy(expected_hmac4, "697eaf0aca3a3aea3a75164746ffaa79");
467 : :
468 : : hmac_md5(msg, 50, (unsigned char *)hmac, hmac_key, strlen(hmac_key));
469 : :
470 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
471 : : {
472 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
473 : : }
474 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac4, MD5_DIGEST_LEN) == 0);
475 : :
476 : : //vector 5
477 : : for ( i = 0; i < 16; i++)
478 : : {
479 : : hmac_key[i] = 0x0c;
480 : : }
481 : : key_len = 16;
482 : : strcpy(msg, "Test With Truncation");
483 : : msg_len = 20;
484 : : strcpy(expected_hmac5, "56461ef2342edc00f9bab995690efd4c");
485 : :
486 : : hmac_md5(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
487 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
488 : : {
489 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
490 : : }
491 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac5, MD5_DIGEST_LEN) == 0);
492 : :
493 : : //vector 6
494 : : for ( i = 0; i < 80; i++)
495 : : {
496 : : hmac_key[i] = 0xaa;
497 : : }
498 : : key_len = 80;
499 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
500 : : msg_len = 54;
501 : : strcpy(expected_hmac6, "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd");
502 : :
503 : : hmac_md5(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
504 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
505 : : {
506 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
507 : : }
508 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6, MD5_DIGEST_LEN) == 0);
509 : :
510 : : //vector 7
511 : : for ( i = 0; i < 80; i++)
512 : : {
513 : : hmac_key[i] = 0xaa;
514 : : }
515 : : key_len = 80;
516 : : strcpy(msg, "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data");
517 : : msg_len = 73;
518 : : strcpy(expected_hmac7, "6f630fad67cda0ee1fb1f562db3aa53e");
519 : :
520 : : hmac_md5(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
521 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
522 : : {
523 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
524 : : }
525 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7, MD5_DIGEST_LEN) == 0);
526 : :
527 : : }
528 : :
529 : : DECLARE_UTEST(test_hmac_sha1, "hmac_sha1 test vectors") // https://tools.ietf.org/html/rfc2202
530 : : {
531 : : char msg[1024] = {0};
532 : : unsigned char hmac[1024] = {0};
533 : : char hmac_txt[1024] = {0};
534 : : char hmac_key[1024] = {0};
535 : : char expected_hmac1[1024] = {0};
536 : : char expected_hmac2[1024] = {0};
537 : : char expected_hmac3[1024] = {0};
538 : : char expected_hmac4[1024] = {0};
539 : : char expected_hmac5[1024] = {0};
540 : : char expected_hmac6[1024] = {0};
541 : : char expected_hmac7[1024] = {0};
542 : : int msg_len, key_len;
543 : : int i = 0;
544 : :
545 : : //vector 1
546 : : for ( i = 0; i < 20; i++)
547 : : {
548 : : hmac_key[i] = 0x0b;
549 : : }
550 : : key_len = 20;
551 : : strcpy(msg, "Hi There");
552 : : msg_len = 8;
553 : : strcpy(expected_hmac1, "b617318655057264e28bc0b6fb378c8ef146be00");
554 : :
555 : : hmac_sha1(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
556 : :
557 : : for ( i = 0; i < SHA1_DIGEST_LEN; i++)
558 : : {
559 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
560 : : }
561 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac1, SHA1_DIGEST_LEN) == 0);
562 : :
563 : : //vector 2
564 : : strcpy(hmac_key, "Jefe");
565 : : key_len = 4;
566 : : strcpy(msg, "what do ya want for nothing?");
567 : : msg_len = 28;
568 : : strcpy(expected_hmac2, "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79");
569 : :
570 : : hmac_sha1(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
571 : :
572 : : for ( i = 0; i < SHA1_DIGEST_LEN; i++)
573 : : {
574 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
575 : : }
576 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac2, SHA1_DIGEST_LEN) == 0);
577 : :
578 : : //vector 3
579 : : for ( i = 0; i < 20; i++)
580 : : {
581 : : hmac_key[i] = 0xaa;
582 : : }
583 : : key_len = 20;
584 : : for ( i = 0; i < 50; i++)
585 : : {
586 : : msg[i] = 0xdd;
587 : : }
588 : : msg_len = 50;
589 : : strcpy(expected_hmac3, "125d7342b9ac11cd91a39af48aa17b4f63f175d3");
590 : :
591 : : hmac_sha1(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
592 : :
593 : : for ( i = 0; i < SHA1_DIGEST_LEN; i++)
594 : : {
595 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
596 : : }
597 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac3, SHA1_DIGEST_LEN) == 0);
598 : :
599 : : //vector 4
600 : : strcpy(hmac_key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19");
601 : : key_len = 25;
602 : : for ( i = 0; i < 50; i++)
603 : : {
604 : : msg[i] = 0xcd;
605 : : }
606 : : msg_len = 50;
607 : : strcpy(expected_hmac4, "4c9007f4026250c6bc8414f9bf50c86c2d7235da");
608 : :
609 : : hmac_sha1(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
610 : :
611 : : for ( i = 0; i < SHA1_DIGEST_LEN; i++)
612 : : {
613 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
614 : : }
615 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac4, SHA1_DIGEST_LEN) == 0);
616 : :
617 : : //vector 5
618 : : for ( i = 0; i < 20; i++)
619 : : {
620 : : hmac_key[i] = 0x0c;
621 : : }
622 : : key_len = 20;
623 : : strcpy(msg, "Test With Truncation");
624 : : msg_len = 20;
625 : : strcpy(expected_hmac5, "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04");
626 : :
627 : : hmac_sha1(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
628 : :
629 : : for ( i = 0; i < SHA1_DIGEST_LEN; i++)
630 : : {
631 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
632 : : }
633 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac5, SHA1_DIGEST_LEN) == 0);
634 : :
635 : : //vector 6
636 : : for ( i = 0; i < 80; i++)
637 : : {
638 : : hmac_key[i] = 0xaa;
639 : : }
640 : : key_len = 80;
641 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
642 : : msg_len = 54;
643 : : strcpy(expected_hmac6, "aa4ae5e15272d00e95705637ce8a3b55ed402112");
644 : :
645 : : hmac_sha1(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
646 : :
647 : : for ( i = 0; i < SHA1_DIGEST_LEN; i++)
648 : : {
649 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
650 : : }
651 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6, SHA1_DIGEST_LEN) == 0);
652 : :
653 : : //vector 7
654 : : for ( i = 0; i < 80; i++)
655 : : {
656 : : hmac_key[i] = 0xaa;
657 : : }
658 : : key_len = 80;
659 : : strcpy(msg, "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data");
660 : : msg_len = 73;
661 : : strcpy(expected_hmac7, "e8e99d0f45237d786d6bbaa7965c7808bbff1a91");
662 : :
663 : : hmac_sha1(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
664 : :
665 : : for ( i = 0; i < SHA1_DIGEST_LEN; i++)
666 : : {
667 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
668 : : }
669 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7, SHA1_DIGEST_LEN) == 0);
670 : : }
671 : :
672 : : DECLARE_UTEST(test_hmac_sha256, "hmac_sha256 test vectors") // https://tools.ietf.org/html/rfc4231
673 : : {
674 : : char msg[1024] = {0};
675 : : unsigned char hmac[1024] = {0};
676 : : char hmac_txt[1024] = {0};
677 : : char hmac_key[1024] = {0};
678 : : char expected_hmac1[1024] = {0};
679 : : char expected_hmac2[1024] = {0};
680 : : char expected_hmac3[1024] = {0};
681 : : char expected_hmac4[1024] = {0};
682 : : char expected_hmac5[1024] = {0};
683 : : char expected_hmac6[1024] = {0};
684 : : char expected_hmac7[1024] = {0};
685 : : int msg_len, key_len;
686 : : int i = 0;
687 : :
688 : : //vector 1
689 : : for ( i = 0; i < 20; i++)
690 : : {
691 : : hmac_key[i] = 0x0b;
692 : : }
693 : : key_len = 20;
694 : : strcpy(msg, "Hi There");
695 : : msg_len = 8;
696 : : strcpy(expected_hmac1, "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
697 : :
698 : : hmac_sha256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
699 : :
700 : : for ( i = 0; i < SHA256_DIGEST_LEN; i++)
701 : : {
702 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
703 : : }
704 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac1, SHA256_DIGEST_LEN) == 0);
705 : :
706 : : //vector 2
707 : : strcpy(hmac_key, "Jefe");
708 : : key_len = 4;
709 : : strcpy(msg, "what do ya want for nothing?");
710 : : msg_len = 28;
711 : : strcpy(expected_hmac2, "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843");
712 : :
713 : : hmac_sha256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
714 : :
715 : : for ( i = 0; i < SHA256_DIGEST_LEN; i++)
716 : : {
717 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
718 : : }
719 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac2, SHA256_DIGEST_LEN) == 0);
720 : :
721 : : //vector 3
722 : : for ( i = 0; i < 20; i++)
723 : : {
724 : : hmac_key[i] = 0xaa;
725 : : }
726 : : key_len = 20;
727 : : for ( i = 0; i < 50; i++)
728 : : {
729 : : msg[i] = 0xdd;
730 : : }
731 : : msg_len = 50;
732 : : strcpy(expected_hmac3, "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe");
733 : :
734 : : hmac_sha256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
735 : :
736 : : for ( i = 0; i < SHA256_DIGEST_LEN; i++)
737 : : {
738 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
739 : : }
740 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac3, SHA256_DIGEST_LEN) == 0);
741 : :
742 : : //vector 4
743 : : strcpy(hmac_key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19");
744 : : key_len = 25;
745 : : for ( i = 0; i < 50; i++)
746 : : {
747 : : msg[i] = 0xcd;
748 : : }
749 : : msg_len = 50;
750 : : strcpy(expected_hmac4, "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b");
751 : :
752 : : hmac_sha256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
753 : :
754 : : for ( i = 0; i < SHA256_DIGEST_LEN; i++)
755 : : {
756 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
757 : : }
758 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac4, SHA256_DIGEST_LEN) == 0);
759 : :
760 : : //vector 5
761 : : for ( i = 0; i < 20; i++)
762 : : {
763 : : hmac_key[i] = 0x0c;
764 : : }
765 : : key_len = 20;
766 : : strcpy(msg, "Test With Truncation");
767 : : msg_len = 20;
768 : : strcpy(expected_hmac5, "a3b6167473100ee06e0c796c2955552b");
769 : :
770 : : hmac_sha256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
771 : :
772 : : for ( i = 0; i < 16; i++)
773 : : {
774 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
775 : : }
776 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac5, 16) == 0); //test specifies truncated output
777 : :
778 : : //vector 6
779 : : for ( i = 0; i < 131; i++)
780 : : {
781 : : hmac_key[i] = 0xaa;
782 : : }
783 : : key_len = 131;
784 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
785 : : msg_len = 54;
786 : : strcpy(expected_hmac6, "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54");
787 : :
788 : : hmac_sha256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
789 : :
790 : : for ( i = 0; i < SHA256_DIGEST_LEN; i++)
791 : : {
792 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
793 : : }
794 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6, SHA256_DIGEST_LEN) == 0);
795 : :
796 : : //vector 7
797 : : for ( i = 0; i < 131; i++)
798 : : {
799 : : hmac_key[i] = 0xaa;
800 : : }
801 : : key_len = 131;
802 : : strcpy(msg, "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.");
803 : : msg_len = strlen(msg);
804 : : strcpy(expected_hmac7, "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2");
805 : :
806 : : hmac_sha256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
807 : :
808 : : for ( i = 0; i < SHA256_DIGEST_LEN; i++)
809 : : {
810 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
811 : : }
812 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7, SHA256_DIGEST_LEN) == 0);
813 : : }
814 : :
815 : : DECLARE_UTEST(test_hmac_sha384, "hmac_sha384 test vectors")
816 : : {
817 : : char msg[1024] = {0};
818 : : unsigned char hmac[1024] = {0};
819 : : char hmac_txt[1024] = {0};
820 : : char hmac_key[1024] = {0};
821 : : char expected_hmac1[1024] = {0};
822 : : char expected_hmac2[1024] = {0};
823 : : char expected_hmac3[1024] = {0};
824 : : char expected_hmac4[1024] = {0};
825 : : char expected_hmac5[1024] = {0};
826 : : char expected_hmac6[1024] = {0};
827 : : char expected_hmac7[1024] = {0};
828 : : int msg_len, key_len;
829 : : int i = 0;
830 : :
831 : : //vector 1
832 : : for ( i = 0; i < 20; i++)
833 : : {
834 : : hmac_key[i] = 0x0b;
835 : : }
836 : : key_len = 20;
837 : : strcpy(msg, "Hi There");
838 : : msg_len = 8;
839 : : strcpy(expected_hmac1, "afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4af152e8b2fa9cb6");
840 : :
841 : : hmac_sha384(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
842 : :
843 : : for ( i = 0; i < SHA384_DIGEST_LEN; i++)
844 : : {
845 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
846 : : }
847 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac1, SHA384_DIGEST_LEN) == 0);
848 : :
849 : : //vector 2
850 : : strcpy(hmac_key, "Jefe");
851 : : key_len = 4;
852 : : strcpy(msg, "what do ya want for nothing?");
853 : : msg_len = 28;
854 : : strcpy(expected_hmac2, "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649");
855 : :
856 : : hmac_sha384(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
857 : :
858 : : for ( i = 0; i < SHA384_DIGEST_LEN; i++)
859 : : {
860 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
861 : : }
862 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac2, SHA384_DIGEST_LEN) == 0);
863 : :
864 : : //vector 3
865 : : for ( i = 0; i < 20; i++)
866 : : {
867 : : hmac_key[i] = 0xaa;
868 : : }
869 : : key_len = 20;
870 : : for ( i = 0; i < 50; i++)
871 : : {
872 : : msg[i] = 0xdd;
873 : : }
874 : : msg_len = 50;
875 : : strcpy(expected_hmac3, "88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27");
876 : :
877 : : hmac_sha384(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
878 : :
879 : : for ( i = 0; i < SHA384_DIGEST_LEN; i++)
880 : : {
881 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
882 : : }
883 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac3, SHA384_DIGEST_LEN) == 0);
884 : :
885 : : //vector 4
886 : : strcpy(hmac_key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19");
887 : : key_len = 25;
888 : : for ( i = 0; i < 50; i++)
889 : : {
890 : : msg[i] = 0xcd;
891 : : }
892 : : msg_len = 50;
893 : : strcpy(expected_hmac4, "3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb");
894 : :
895 : : hmac_sha384(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
896 : :
897 : : for ( i = 0; i < SHA384_DIGEST_LEN; i++)
898 : : {
899 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
900 : : }
901 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac4, SHA384_DIGEST_LEN) == 0);
902 : :
903 : : //vector 5
904 : : for ( i = 0; i < 20; i++)
905 : : {
906 : : hmac_key[i] = 0x0c;
907 : : }
908 : : key_len = 20;
909 : : strcpy(msg, "Test With Truncation");
910 : : msg_len = 20;
911 : : strcpy(expected_hmac5, "3abf34c3503b2a23a46efc619baef897");
912 : :
913 : : hmac_sha384(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
914 : :
915 : : for ( i = 0; i < 16; i++)
916 : : {
917 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
918 : : }
919 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac5, 16) == 0); //test specifies truncated output
920 : :
921 : : //vector 6
922 : : for ( i = 0; i < 131; i++)
923 : : {
924 : : hmac_key[i] = 0xaa;
925 : : }
926 : : key_len = 131;
927 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
928 : : msg_len = 54;
929 : : strcpy(expected_hmac6, "4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c60c2ef6ab4030fe8296248df163f44952");
930 : :
931 : : hmac_sha384(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
932 : :
933 : : for ( i = 0; i < SHA384_DIGEST_LEN; i++)
934 : : {
935 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
936 : : }
937 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6, SHA384_DIGEST_LEN) == 0);
938 : :
939 : : //vector 7
940 : : for ( i = 0; i < 131; i++)
941 : : {
942 : : hmac_key[i] = 0xaa;
943 : : }
944 : : key_len = 131;
945 : : strcpy(msg, "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.");
946 : : msg_len = strlen(msg);
947 : : strcpy(expected_hmac7, "6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5a678cc31e799176d3860e6110c46523e");
948 : :
949 : : hmac_sha384(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
950 : :
951 : : for ( i = 0; i < SHA384_DIGEST_LEN; i++)
952 : : {
953 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
954 : : }
955 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7, SHA384_DIGEST_LEN) == 0);
956 : : }
957 : :
958 : : DECLARE_UTEST(test_hmac_sha512, "hmac_sha512 test vectors")
959 : : {
960 : : char msg[1024] = {0};
961 : : unsigned char hmac[1024] = {0};
962 : : char hmac_txt[1024] = {0};
963 : : char hmac_key[1024] = {0};
964 : : char expected_hmac1[1024] = {0};
965 : : char expected_hmac2[1024] = {0};
966 : : char expected_hmac3[1024] = {0};
967 : : char expected_hmac4[1024] = {0};
968 : : char expected_hmac5[1024] = {0};
969 : : char expected_hmac6[1024] = {0};
970 : : char expected_hmac7[1024] = {0};
971 : : int msg_len, key_len;
972 : : int i = 0;
973 : :
974 : : //vector 1
975 : : for ( i = 0; i < 20; i++)
976 : : {
977 : : hmac_key[i] = 0x0b;
978 : : }
979 : : key_len = 20;
980 : : strcpy(msg, "Hi There");
981 : : msg_len = 8;
982 : : strcpy(expected_hmac1, "87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854");
983 : :
984 : : hmac_sha512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
985 : :
986 : : for ( i = 0; i < SHA512_DIGEST_LEN; i++)
987 : : {
988 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
989 : : }
990 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac1, SHA512_DIGEST_LEN) == 0);
991 : :
992 : : //vector 2
993 : : strcpy(hmac_key, "Jefe");
994 : : key_len = 4;
995 : : strcpy(msg, "what do ya want for nothing?");
996 : : msg_len = 28;
997 : : strcpy(expected_hmac2, "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737");
998 : :
999 : : hmac_sha512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1000 : :
1001 : : for ( i = 0; i < SHA512_DIGEST_LEN; i++)
1002 : : {
1003 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1004 : : }
1005 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac2, SHA512_DIGEST_LEN) == 0);
1006 : :
1007 : : //vector 3
1008 : : for ( i = 0; i < 20; i++)
1009 : : {
1010 : : hmac_key[i] = 0xaa;
1011 : : }
1012 : : key_len = 20;
1013 : : for ( i = 0; i < 50; i++)
1014 : : {
1015 : : msg[i] = 0xdd;
1016 : : }
1017 : : msg_len = 50;
1018 : : strcpy(expected_hmac3, "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb");
1019 : :
1020 : : hmac_sha512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1021 : :
1022 : : for ( i = 0; i < SHA512_DIGEST_LEN; i++)
1023 : : {
1024 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1025 : : }
1026 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac3, SHA512_DIGEST_LEN) == 0);
1027 : :
1028 : : //vector 4
1029 : : strcpy(hmac_key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19");
1030 : : key_len = 25;
1031 : : for ( i = 0; i < 50; i++)
1032 : : {
1033 : : msg[i] = 0xcd;
1034 : : }
1035 : : msg_len = 50;
1036 : : strcpy(expected_hmac4, "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd");
1037 : :
1038 : : hmac_sha512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1039 : :
1040 : : for ( i = 0; i < SHA512_DIGEST_LEN; i++)
1041 : : {
1042 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1043 : : }
1044 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac4, SHA512_DIGEST_LEN) == 0);
1045 : :
1046 : : //vector 5
1047 : : for ( i = 0; i < 20; i++)
1048 : : {
1049 : : hmac_key[i] = 0x0c;
1050 : : }
1051 : : key_len = 20;
1052 : : strcpy(msg, "Test With Truncation");
1053 : : msg_len = 20;
1054 : : strcpy(expected_hmac5, "415fad6271580a531d4179bc891d87a6");
1055 : :
1056 : : hmac_sha512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1057 : :
1058 : : for ( i = 0; i < 16; i++)
1059 : : {
1060 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1061 : : }
1062 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac5, 16) == 0); //test specifies truncated output
1063 : :
1064 : : //vector 6
1065 : : for ( i = 0; i < 131; i++)
1066 : : {
1067 : : hmac_key[i] = 0xaa;
1068 : : }
1069 : : key_len = 131;
1070 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
1071 : : msg_len = 54;
1072 : : strcpy(expected_hmac6, "80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598");
1073 : :
1074 : : hmac_sha512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1075 : :
1076 : : for ( i = 0; i < SHA512_DIGEST_LEN; i++)
1077 : : {
1078 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1079 : : }
1080 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6, SHA512_DIGEST_LEN) == 0);
1081 : :
1082 : : //vector 7
1083 : : for ( i = 0; i < 131; i++)
1084 : : {
1085 : : hmac_key[i] = 0xaa;
1086 : : }
1087 : : key_len = 131;
1088 : : strcpy(msg, "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.");
1089 : : msg_len = strlen(msg);
1090 : : strcpy(expected_hmac7, "e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58");
1091 : :
1092 : : hmac_sha512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1093 : :
1094 : : for ( i = 0; i < SHA512_DIGEST_LEN; i++)
1095 : : {
1096 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1097 : : }
1098 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7, SHA512_DIGEST_LEN) == 0);
1099 : : }
1100 : :
1101 : : DECLARE_UTEST(test_hmac_sha3_256, "hmac_sha3_256 test vectors") //http://wolfgang-ehrhardt.de/hmac-sha3-testvectors.html
1102 : : {
1103 : : char msg[1024] = {0};
1104 : : unsigned char hmac[1024] = {0};
1105 : : char hmac_txt[1024] = {0};
1106 : : char hmac_key[1024] = {0};
1107 : : char expected_hmac1[1024] = {0};
1108 : : char expected_hmac2[1024] = {0};
1109 : : char expected_hmac3[1024] = {0};
1110 : : char expected_hmac4[1024] = {0};
1111 : : char expected_hmac5[1024] = {0};
1112 : : char expected_hmac6[1024] = {0};
1113 : : char expected_hmac6a[1024] = {0};
1114 : : char expected_hmac7[1024] = {0};
1115 : : char expected_hmac7a[1024] = {0};
1116 : : int msg_len, key_len;
1117 : : int i = 0;
1118 : :
1119 : : //vector 1
1120 : : for ( i = 0; i < 20; i++)
1121 : : {
1122 : : hmac_key[i] = 0x0b;
1123 : : }
1124 : : key_len = 20;
1125 : : strcpy(msg, "Hi There");
1126 : : msg_len = 8;
1127 : : strcpy(expected_hmac1, "ba85192310dffa96e2a3a40e69774351140bb7185e1202cdcc917589f95e16bb");
1128 : :
1129 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1130 : :
1131 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1132 : : {
1133 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1134 : : }
1135 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac1, SHA3_256_DIGEST_LEN) == 0);
1136 : :
1137 : : //vector 2
1138 : : strcpy(hmac_key, "Jefe");
1139 : : key_len = 4;
1140 : : strcpy(msg, "what do ya want for nothing?");
1141 : : msg_len = 28;
1142 : : strcpy(expected_hmac2, "c7d4072e788877ae3596bbb0da73b887c9171f93095b294ae857fbe2645e1ba5");
1143 : :
1144 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1145 : :
1146 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1147 : : {
1148 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1149 : : }
1150 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac2, SHA3_256_DIGEST_LEN) == 0);
1151 : :
1152 : : //vector 3
1153 : : for ( i = 0; i < 20; i++)
1154 : : {
1155 : : hmac_key[i] = 0xaa;
1156 : : }
1157 : : key_len = 20;
1158 : : for ( i = 0; i < 50; i++)
1159 : : {
1160 : : msg[i] = 0xdd;
1161 : : }
1162 : : msg_len = 50;
1163 : : strcpy(expected_hmac3, "84ec79124a27107865cedd8bd82da9965e5ed8c37b0ac98005a7f39ed58a4207");
1164 : :
1165 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1166 : :
1167 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1168 : : {
1169 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1170 : : }
1171 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac3, SHA3_256_DIGEST_LEN) == 0);
1172 : :
1173 : : //vector 4
1174 : : strcpy(hmac_key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19");
1175 : : key_len = 25;
1176 : : for ( i = 0; i < 50; i++)
1177 : : {
1178 : : msg[i] = 0xcd;
1179 : : }
1180 : : msg_len = 50;
1181 : : strcpy(expected_hmac4, "57366a45e2305321a4bc5aa5fe2ef8a921f6af8273d7fe7be6cfedb3f0aea6d7");
1182 : :
1183 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1184 : :
1185 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1186 : : {
1187 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1188 : : }
1189 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac4, SHA3_256_DIGEST_LEN) == 0);
1190 : :
1191 : : //vector 5
1192 : : for ( i = 0; i < 20; i++)
1193 : : {
1194 : : hmac_key[i] = 0x0c;
1195 : : }
1196 : : key_len = 20;
1197 : : strcpy(msg, "Test With Truncation");
1198 : : msg_len = 20;
1199 : : strcpy(expected_hmac5, "6e02c64537fb118057abb7fb66a23b3c");
1200 : :
1201 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1202 : :
1203 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1204 : : {
1205 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1206 : : }
1207 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac5, 16) == 0); //test specifies truncated output
1208 : :
1209 : : //vector 6
1210 : : for ( i = 0; i < 131; i++)
1211 : : {
1212 : : hmac_key[i] = 0xaa;
1213 : : }
1214 : : key_len = 131;
1215 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
1216 : : msg_len = 54;
1217 : : strcpy(expected_hmac6, "ed73a374b96c005235f948032f09674a58c0ce555cfc1f223b02356560312c3b");
1218 : :
1219 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1220 : :
1221 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1222 : : {
1223 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1224 : : }
1225 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6, SHA3_256_DIGEST_LEN) == 0);
1226 : :
1227 : : //vector 6a
1228 : : for ( i = 0; i < 147; i++)
1229 : : {
1230 : : hmac_key[i] = 0xaa;
1231 : : }
1232 : : key_len = 147;
1233 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
1234 : : msg_len = 54;
1235 : : strcpy(expected_hmac6a, "a6072f86de52b38bb349fe84cd6d97fb6a37c4c0f62aae93981193a7229d3467");
1236 : :
1237 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1238 : :
1239 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1240 : : {
1241 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1242 : : }
1243 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6a, SHA3_256_DIGEST_LEN) == 0);
1244 : :
1245 : : //vector 7
1246 : : for ( i = 0; i < 131; i++)
1247 : : {
1248 : : hmac_key[i] = 0xaa;
1249 : : }
1250 : : key_len = 131;
1251 : : strcpy(msg, "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.");
1252 : : msg_len = strlen(msg);
1253 : : strcpy(expected_hmac7, "65c5b06d4c3de32a7aef8763261e49adb6e2293ec8e7c61e8de61701fc63e123");
1254 : :
1255 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1256 : :
1257 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1258 : : {
1259 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1260 : : }
1261 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7, SHA3_256_DIGEST_LEN) == 0);
1262 : :
1263 : : //vector 7a
1264 : : for ( i = 0; i < 147; i++)
1265 : : {
1266 : : hmac_key[i] = 0xaa;
1267 : : }
1268 : : key_len = 147;
1269 : : strcpy(msg, "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.");
1270 : : msg_len = strlen(msg);
1271 : : strcpy(expected_hmac7a, "e6a36d9b915f86a093cac7d110e9e04cf1d6100d30475509c2475f571b758b5a");
1272 : :
1273 : : hmac_sha3_256(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1274 : :
1275 : : for ( i = 0; i < SHA3_256_DIGEST_LEN; i++)
1276 : : {
1277 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1278 : : }
1279 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7a, SHA3_256_DIGEST_LEN) == 0);
1280 : : }
1281 : :
1282 : : DECLARE_UTEST(test_hmac_sha3_512, "hmac_sha3_512 test vectors")
1283 : : {
1284 : : char msg[1024] = {0};
1285 : : unsigned char hmac[1024] = {0};
1286 : : char hmac_txt[1024] = {0};
1287 : : char hmac_key[1024] = {0};
1288 : : char expected_hmac1[1024] = {0};
1289 : : char expected_hmac2[1024] = {0};
1290 : : char expected_hmac3[1024] = {0};
1291 : : char expected_hmac4[1024] = {0};
1292 : : char expected_hmac5[1024] = {0};
1293 : : char expected_hmac6[1024] = {0};
1294 : : char expected_hmac6a[1024] = {0};
1295 : : char expected_hmac7[1024] = {0};
1296 : : char expected_hmac7a[1024] = {0};
1297 : : int msg_len, key_len;
1298 : : int i = 0;
1299 : :
1300 : : //vector 1
1301 : : for ( i = 0; i < 20; i++)
1302 : : {
1303 : : hmac_key[i] = 0x0b;
1304 : : }
1305 : : key_len = 20;
1306 : : strcpy(msg, "Hi There");
1307 : : msg_len = 8;
1308 : : strcpy(expected_hmac1, "eb3fbd4b2eaab8f5c504bd3a41465aacec15770a7cabac531e482f860b5ec7ba47ccb2c6f2afce8f88d22b6dc61380f23a668fd3888bb80537c0a0b86407689e");
1309 : :
1310 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1311 : :
1312 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1313 : : {
1314 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1315 : : }
1316 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac1, SHA3_512_DIGEST_LEN) == 0);
1317 : :
1318 : : //vector 2
1319 : : strcpy(hmac_key, "Jefe");
1320 : : key_len = 4;
1321 : : strcpy(msg, "what do ya want for nothing?");
1322 : : msg_len = 28;
1323 : : strcpy(expected_hmac2, "5a4bfeab6166427c7a3647b747292b8384537cdb89afb3bf5665e4c5e709350b287baec921fd7ca0ee7a0c31d022a95e1fc92ba9d77df883960275beb4e62024");
1324 : :
1325 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1326 : :
1327 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1328 : : {
1329 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1330 : : }
1331 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac2, SHA3_512_DIGEST_LEN) == 0);
1332 : :
1333 : : //vector 3
1334 : : for ( i = 0; i < 20; i++)
1335 : : {
1336 : : hmac_key[i] = 0xaa;
1337 : : }
1338 : : key_len = 20;
1339 : : for ( i = 0; i < 50; i++)
1340 : : {
1341 : : msg[i] = 0xdd;
1342 : : }
1343 : : msg_len = 50;
1344 : : strcpy(expected_hmac3, "309e99f9ec075ec6c6d475eda1180687fcf1531195802a99b5677449a8625182851cb332afb6a89c411325fbcbcd42afcb7b6e5aab7ea42c660f97fd8584bf03");
1345 : :
1346 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1347 : :
1348 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1349 : : {
1350 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1351 : : }
1352 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac3, SHA3_512_DIGEST_LEN) == 0);
1353 : :
1354 : : //vector 4
1355 : : strcpy(hmac_key, "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19");
1356 : : key_len = 25;
1357 : : for ( i = 0; i < 50; i++)
1358 : : {
1359 : : msg[i] = 0xcd;
1360 : : }
1361 : : msg_len = 50;
1362 : : strcpy(expected_hmac4, "b27eab1d6e8d87461c29f7f5739dd58e98aa35f8e823ad38c5492a2088fa0281993bbfff9a0e9c6bf121ae9ec9bb09d84a5ebac817182ea974673fb133ca0d1d");
1363 : :
1364 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1365 : :
1366 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1367 : : {
1368 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1369 : : }
1370 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac4, SHA3_512_DIGEST_LEN) == 0);
1371 : :
1372 : : //vector 5
1373 : : for ( i = 0; i < 20; i++)
1374 : : {
1375 : : hmac_key[i] = 0x0c;
1376 : : }
1377 : : key_len = 20;
1378 : : strcpy(msg, "Test With Truncation");
1379 : : msg_len = 20;
1380 : : strcpy(expected_hmac5, "0fa7475948f43f48ca0516671e18978c");
1381 : :
1382 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1383 : :
1384 : : for ( i = 0; i < 16; i++)
1385 : : {
1386 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1387 : : }
1388 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac5, 16) == 0); //test specifies truncated output
1389 : :
1390 : : //vector 6
1391 : : for ( i = 0; i < 131; i++)
1392 : : {
1393 : : hmac_key[i] = 0xaa;
1394 : : }
1395 : : key_len = 131;
1396 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
1397 : : msg_len = 54;
1398 : : strcpy(expected_hmac6, "00f751a9e50695b090ed6911a4b65524951cdc15a73a5d58bb55215ea2cd839ac79d2b44a39bafab27e83fde9e11f6340b11d991b1b91bf2eee7fc872426c3a4");
1399 : :
1400 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1401 : :
1402 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1403 : : {
1404 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1405 : : }
1406 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6, SHA3_512_DIGEST_LEN) == 0);
1407 : :
1408 : : //vector 6a
1409 : : for ( i = 0; i < 147; i++)
1410 : : {
1411 : : hmac_key[i] = 0xaa;
1412 : : }
1413 : : key_len = 147;
1414 : : strcpy(msg, "Test Using Larger Than Block-Size Key - Hash Key First");
1415 : : msg_len = 54;
1416 : : strcpy(expected_hmac6a, "b14835c819a290efb010ace6d8568dc6b84de60bc49b004c3b13eda763589451e5dd74292884d1bdce64e6b919dd61dc9c56a282a81c0bd14f1f365b49b83a5b");
1417 : :
1418 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1419 : :
1420 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1421 : : {
1422 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1423 : : }
1424 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac6a, SHA3_512_DIGEST_LEN) == 0);
1425 : :
1426 : : //vector 7
1427 : : for ( i = 0; i < 131; i++)
1428 : : {
1429 : : hmac_key[i] = 0xaa;
1430 : : }
1431 : : key_len = 131;
1432 : : strcpy(msg, "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.");
1433 : : msg_len = strlen(msg);
1434 : : strcpy(expected_hmac7, "38a456a004bd10d32c9ab8336684112862c3db61adcca31829355eaf46fd5c73d06a1f0d13fec9a652fb3811b577b1b1d1b9789f97ae5b83c6f44dfcf1d67eba");
1435 : :
1436 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1437 : :
1438 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1439 : : {
1440 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1441 : : }
1442 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7, SHA3_512_DIGEST_LEN) == 0);
1443 : :
1444 : : //vector 7a
1445 : : for ( i = 0; i < 147; i++)
1446 : : {
1447 : : hmac_key[i] = 0xaa;
1448 : : }
1449 : : key_len = 147;
1450 : : strcpy(msg, "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.");
1451 : : msg_len = strlen(msg);
1452 : : strcpy(expected_hmac7a, "dc030ee7887034f32cf402df34622f311f3e6cf04860c6bbd7fa488674782b4659fdbdf3fd877852885cfe6e22185fe7b2ee952043629bc9d5f3298a41d02c66");
1453 : :
1454 : : hmac_sha3_512(msg, msg_len, (unsigned char *)hmac, hmac_key, key_len);
1455 : :
1456 : : for ( i = 0; i < SHA3_512_DIGEST_LEN; i++)
1457 : : {
1458 : : sprintf(hmac_txt + (2 * i), "%02x", hmac[i]);
1459 : : }
1460 : : CU_ASSERT(memcmp(hmac_txt, expected_hmac7a, SHA3_512_DIGEST_LEN) == 0);
1461 : : }
1462 : :
1463 : : int register_ts_hmac_test(void)
1464 : : {
1465 : : ts_init(&TEST_SUITE(hmac_test), TEST_SUITE_DESCR(hmac_test), NULL, NULL);
1466 : : ts_add_utest(&TEST_SUITE(hmac_test), UTEST_FCT(test_hmac_md5), UTEST_DESCR(test_hmac_md5));
1467 : : ts_add_utest(&TEST_SUITE(hmac_test), UTEST_FCT(test_hmac_sha1), UTEST_DESCR(test_hmac_sha1));
1468 : : ts_add_utest(&TEST_SUITE(hmac_test), UTEST_FCT(test_hmac_sha256), UTEST_DESCR(test_hmac_sha256));
1469 : : ts_add_utest(&TEST_SUITE(hmac_test), UTEST_FCT(test_hmac_sha384), UTEST_DESCR(test_hmac_sha384));
1470 : : ts_add_utest(&TEST_SUITE(hmac_test), UTEST_FCT(test_hmac_sha512), UTEST_DESCR(test_hmac_sha512));
1471 : : ts_add_utest(&TEST_SUITE(hmac_test), UTEST_FCT(test_hmac_sha3_256), UTEST_DESCR(test_hmac_sha3_256));
1472 : : ts_add_utest(&TEST_SUITE(hmac_test), UTEST_FCT(test_hmac_sha3_512), UTEST_DESCR(test_hmac_sha3_512));
1473 : :
1474 : : return register_ts(&TEST_SUITE(hmac_test));
1475 : : }
1476 : :
1477 : : #endif /* HAVE_C_UNIT_TESTS */ /* LCOV_EXCL_STOP */
|
