1 /*
2  * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
3  *
4  * SPDX-License-Identifier: MPL-2.0
5  *
6  * This Source Code Form is subject to the terms of the Mozilla Public
7  * License, v. 2.0. If a copy of the MPL was not distributed with this
8  * file, you can obtain one at https://mozilla.org/MPL/2.0/.
9  *
10  * See the COPYRIGHT file distributed with this work for additional
11  * information regarding copyright ownership.
12  */
13 
14 #if HAVE_CMOCKA
15 
16 #include <setjmp.h>
17 #include <stdarg.h>
18 #include <stddef.h>
19 #include <string.h>
20 
21 /* For FIPS_mode() */
22 #include <openssl/crypto.h>
23 
24 #define UNIT_TESTING
25 #include <cmocka.h>
26 
27 #include <isc/buffer.h>
28 #include <isc/hex.h>
29 #include <isc/md.h>
30 #include <isc/region.h>
31 #include <isc/result.h>
32 
33 #include "../md.c"
34 
35 #define TEST_INPUT(x) (x), sizeof(x) - 1
36 
37 static int
_setup(void ** state)38 _setup(void **state) {
39 	isc_md_t *md = isc_md_new();
40 	if (md == NULL) {
41 		return (-1);
42 	}
43 	*state = md;
44 	return (0);
45 }
46 
47 static int
_teardown(void ** state)48 _teardown(void **state) {
49 	if (*state == NULL) {
50 		return (-1);
51 	}
52 	isc_md_free(*state);
53 	return (0);
54 }
55 
56 static int
_reset(void ** state)57 _reset(void **state) {
58 	if (*state == NULL) {
59 		return (-1);
60 	}
61 	if (isc_md_reset(*state) != ISC_R_SUCCESS) {
62 		return (-1);
63 	}
64 	return (0);
65 }
66 
67 static void
isc_md_new_test(void ** state)68 isc_md_new_test(void **state) {
69 	UNUSED(state);
70 
71 	isc_md_t *md = isc_md_new();
72 	assert_non_null(md);
73 	isc_md_free(md); /* Cleanup */
74 }
75 
76 static void
isc_md_free_test(void ** state)77 isc_md_free_test(void **state) {
78 	UNUSED(state);
79 
80 	isc_md_t *md = isc_md_new();
81 	assert_non_null(md);
82 	isc_md_free(md);   /* Test freeing valid message digest context */
83 	isc_md_free(NULL); /* Test freeing NULL argument */
84 }
85 
86 static void
isc_md_test(isc_md_t * md,const isc_md_type_t * type,const char * buf,size_t buflen,const char * result,const int repeats)87 isc_md_test(isc_md_t *md, const isc_md_type_t *type, const char *buf,
88 	    size_t buflen, const char *result, const int repeats) {
89 	assert_non_null(md);
90 	assert_int_equal(isc_md_init(md, type), ISC_R_SUCCESS);
91 
92 	int i;
93 
94 	for (i = 0; i < repeats; i++) {
95 		assert_int_equal(
96 			isc_md_update(md, (const unsigned char *)buf, buflen),
97 			ISC_R_SUCCESS);
98 	}
99 
100 	unsigned char digest[ISC_MAX_MD_SIZE];
101 	unsigned int digestlen;
102 	assert_int_equal(isc_md_final(md, digest, &digestlen), ISC_R_SUCCESS);
103 
104 	char hexdigest[ISC_MAX_MD_SIZE * 2 + 3];
105 	isc_region_t r = { .base = digest, .length = digestlen };
106 	isc_buffer_t b;
107 	isc_buffer_init(&b, hexdigest, sizeof(hexdigest));
108 
109 	assert_return_code(isc_hex_totext(&r, 0, "", &b), ISC_R_SUCCESS);
110 
111 	assert_memory_equal(hexdigest, result, (result ? strlen(result) : 0));
112 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
113 }
114 
115 static void
isc_md_init_test(void ** state)116 isc_md_init_test(void **state) {
117 	isc_md_t *md = *state;
118 	assert_non_null(md);
119 
120 	expect_assert_failure(isc_md_init(NULL, ISC_MD_MD5));
121 
122 	assert_int_equal(isc_md_init(md, NULL), ISC_R_NOTIMPLEMENTED);
123 
124 	assert_int_equal(isc_md_init(md, ISC_MD_MD5), ISC_R_SUCCESS);
125 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
126 
127 	assert_int_equal(isc_md_init(md, ISC_MD_SHA1), ISC_R_SUCCESS);
128 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
129 
130 	assert_int_equal(isc_md_init(md, ISC_MD_SHA224), ISC_R_SUCCESS);
131 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
132 
133 	assert_int_equal(isc_md_init(md, ISC_MD_SHA256), ISC_R_SUCCESS);
134 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
135 
136 	assert_int_equal(isc_md_init(md, ISC_MD_SHA384), ISC_R_SUCCESS);
137 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
138 
139 	assert_int_equal(isc_md_init(md, ISC_MD_SHA512), ISC_R_SUCCESS);
140 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
141 }
142 
143 static void
isc_md_update_test(void ** state)144 isc_md_update_test(void **state) {
145 	isc_md_t *md = *state;
146 	assert_non_null(md);
147 
148 	/* Uses message digest context initialized in isc_md_init_test() */
149 	expect_assert_failure(isc_md_update(NULL, NULL, 0));
150 
151 	assert_int_equal(isc_md_update(md, NULL, 100), ISC_R_SUCCESS);
152 	assert_int_equal(isc_md_update(md, (const unsigned char *)"", 0),
153 			 ISC_R_SUCCESS);
154 }
155 
156 static void
isc_md_reset_test(void ** state)157 isc_md_reset_test(void **state) {
158 	isc_md_t *md = *state;
159 #if 0
160 	unsigned char digest[ISC_MAX_MD_SIZE] __attribute((unused));
161 	unsigned int digestlen __attribute((unused));
162 #endif /* if 0 */
163 
164 	assert_non_null(md);
165 
166 	assert_int_equal(isc_md_init(md, ISC_MD_SHA512), ISC_R_SUCCESS);
167 	assert_int_equal(isc_md_update(md, (const unsigned char *)"a", 1),
168 			 ISC_R_SUCCESS);
169 	assert_int_equal(isc_md_update(md, (const unsigned char *)"b", 1),
170 			 ISC_R_SUCCESS);
171 
172 	assert_int_equal(isc_md_reset(md), ISC_R_SUCCESS);
173 
174 #if 0
175 	/*
176 	 * This test would require OpenSSL compiled with mock_assert(),
177 	 * so this could be only manually checked that the test will
178 	 * segfault when called by hand
179 	 */
180 	expect_assert_failure(isc_md_final(md,digest,&digestlen));
181 #endif /* if 0 */
182 }
183 
184 static void
isc_md_final_test(void ** state)185 isc_md_final_test(void **state) {
186 	isc_md_t *md = *state;
187 	assert_non_null(md);
188 
189 	unsigned char digest[ISC_MAX_MD_SIZE];
190 	unsigned int digestlen;
191 
192 	/* Fail when message digest context is empty */
193 	expect_assert_failure(isc_md_final(NULL, digest, &digestlen));
194 	/* Fail when output buffer is empty */
195 	expect_assert_failure(isc_md_final(md, NULL, &digestlen));
196 
197 	assert_int_equal(isc_md_init(md, ISC_MD_SHA512), ISC_R_SUCCESS);
198 	assert_int_equal(isc_md_final(md, digest, NULL), ISC_R_SUCCESS);
199 }
200 
201 static void
isc_md_md5_test(void ** state)202 isc_md_md5_test(void **state) {
203 	isc_md_t *md = *state;
204 	isc_md_test(md, ISC_MD_MD5, NULL, 0, NULL, 0);
205 	isc_md_test(md, ISC_MD_MD5, TEST_INPUT(""),
206 		    "D41D8CD98F00B204E9800998ECF8427E", 1);
207 	isc_md_test(md, ISC_MD_MD5, TEST_INPUT("a"),
208 		    "0CC175B9C0F1B6A831C399E269772661", 1);
209 	isc_md_test(md, ISC_MD_MD5, TEST_INPUT("abc"),
210 		    "900150983CD24FB0D6963F7D28E17F72", 1);
211 	isc_md_test(md, ISC_MD_MD5, TEST_INPUT("message digest"),
212 		    "F96B697D7CB7938D525A2F31AAF161D0", 1);
213 	isc_md_test(md, ISC_MD_MD5, TEST_INPUT("abcdefghijklmnopqrstuvwxyz"),
214 		    "C3FCD3D76192E4007DFB496CCA67E13B", 1);
215 	isc_md_test(md, ISC_MD_MD5,
216 		    TEST_INPUT("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm"
217 			       "nopqrstuvwxyz0123456789"),
218 		    "D174AB98D277D9F5A5611C2C9F419D9F", 1);
219 	isc_md_test(md, ISC_MD_MD5,
220 		    TEST_INPUT("123456789012345678901234567890123456789"
221 			       "01234567890123456789012345678901234567890"),
222 		    "57EDF4A22BE3C955AC49DA2E2107B67A", 1);
223 }
224 
225 static void
isc_md_sha1_test(void ** state)226 isc_md_sha1_test(void **state) {
227 	isc_md_t *md = *state;
228 	isc_md_test(md, ISC_MD_SHA1, NULL, 0, NULL, 0);
229 	isc_md_test(md, ISC_MD_SHA1, TEST_INPUT(""),
230 		    "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709", 1);
231 	isc_md_test(md, ISC_MD_SHA1, TEST_INPUT("abc"),
232 		    "A9993E364706816ABA3E25717850C26C9CD0D89D", 1);
233 	isc_md_test(md, ISC_MD_SHA1,
234 		    TEST_INPUT("abcdbcdecdefdefgefghfghighijhijkijk"
235 			       "ljklmklmnlmnomnopnopq"),
236 		    "84983E441C3BD26EBAAE4AA1F95129E5E54670F1", 1);
237 	isc_md_test(md, ISC_MD_SHA1, TEST_INPUT("a"),
238 		    "34AA973CD4C4DAA4F61EEB2BDBAD27316534016F", 1000000);
239 	isc_md_test(md, ISC_MD_SHA1,
240 		    TEST_INPUT("01234567012345670123456701234567"),
241 		    "DEA356A2CDDD90C7A7ECEDC5EBB563934F460452", 20);
242 	isc_md_test(md, ISC_MD_SHA1, TEST_INPUT("\x5e"),
243 		    "5E6F80A34A9798CAFC6A5DB96CC57BA4C4DB59C2", 1);
244 	isc_md_test(md, ISC_MD_SHA1,
245 		    TEST_INPUT("\x9a\x7d\xfd\xf1\xec\xea\xd0\x6e\xd6\x46"
246 			       "\xaa\x55\xfe\x75\x71\x46"),
247 		    "82ABFF6605DBE1C17DEF12A394FA22A82B544A35", 1);
248 	isc_md_test(md, ISC_MD_SHA1,
249 		    TEST_INPUT("\xf7\x8f\x92\x14\x1b\xcd\x17\x0a\xe8\x9b"
250 			       "\x4f\xba\x15\xa1\xd5\x9f\x3f\xd8\x4d\x22"
251 			       "\x3c\x92\x51\xbd\xac\xbb\xae\x61\xd0\x5e"
252 			       "\xd1\x15\xa0\x6a\x7c\xe1\x17\xb7\xbe\xea"
253 			       "\xd2\x44\x21\xde\xd9\xc3\x25\x92\xbd\x57"
254 			       "\xed\xea\xe3\x9c\x39\xfa\x1f\xe8\x94\x6a"
255 			       "\x84\xd0\xcf\x1f\x7b\xee\xad\x17\x13\xe2"
256 			       "\xe0\x95\x98\x97\x34\x7f\x67\xc8\x0b\x04"
257 			       "\x00\xc2\x09\x81\x5d\x6b\x10\xa6\x83\x83"
258 			       "\x6f\xd5\x56\x2a\x56\xca\xb1\xa2\x8e\x81"
259 			       "\xb6\x57\x66\x54\x63\x1c\xf1\x65\x66\xb8"
260 			       "\x6e\x3b\x33\xa1\x08\xb0\x53\x07\xc0\x0a"
261 			       "\xff\x14\xa7\x68\xed\x73\x50\x60\x6a\x0f"
262 			       "\x85\xe6\xa9\x1d\x39\x6f\x5b\x5c\xbe\x57"
263 			       "\x7f\x9b\x38\x80\x7c\x7d\x52\x3d\x6d\x79"
264 			       "\x2f\x6e\xbc\x24\xa4\xec\xf2\xb3\xa4\x27"
265 			       "\xcd\xbb\xfb"),
266 		    "CB0082C8F197D260991BA6A460E76E202BAD27B3", 1);
267 }
268 
269 static void
isc_md_sha224_test(void ** state)270 isc_md_sha224_test(void **state) {
271 	isc_md_t *md = *state;
272 
273 	isc_md_test(md, ISC_MD_SHA224, NULL, 0, NULL, 0);
274 	isc_md_test(md, ISC_MD_SHA224, TEST_INPUT(""),
275 		    "D14A028C2A3A2BC9476102BB288234C415A2B01F828EA62AC5B3E42F",
276 		    1);
277 	isc_md_test(md, ISC_MD_SHA224, TEST_INPUT("abc"),
278 		    "23097D223405D8228642A477BDA255B32AADBCE4BDA0B3F7"
279 		    "E36C9DA7",
280 		    1);
281 	isc_md_test(md, ISC_MD_SHA224,
282 		    TEST_INPUT("abcdbcdecdefdefgefghfghighijhijkijklj"
283 			       "klmklmnlmnomnopnopq"),
284 		    "75388B16512776CC5DBA5DA1FD890150B0C6455CB4F58B"
285 		    "1952522525",
286 		    1);
287 	isc_md_test(md, ISC_MD_SHA224, TEST_INPUT("a"),
288 		    "20794655980C91D8BBB4C1EA97618A4BF03F42581948B2"
289 		    "EE4EE7AD67",
290 		    1000000);
291 	isc_md_test(md, ISC_MD_SHA224,
292 		    TEST_INPUT("01234567012345670123456701234567"),
293 		    "567F69F168CD7844E65259CE658FE7AADFA25216E68ECA"
294 		    "0EB7AB8262",
295 		    20);
296 	isc_md_test(md, ISC_MD_SHA224, TEST_INPUT("\x07"),
297 		    "00ECD5F138422B8AD74C9799FD826C531BAD2FCABC7450"
298 		    "BEE2AA8C2A",
299 		    1);
300 	isc_md_test(md, ISC_MD_SHA224,
301 		    TEST_INPUT("\x18\x80\x40\x05\xdd\x4f\xbd\x15\x56\x29"
302 			       "\x9d\x6f\x9d\x93\xdf\x62"),
303 		    "DF90D78AA78821C99B40BA4C966921ACCD8FFB1E98AC38"
304 		    "8E56191DB1",
305 		    1);
306 	isc_md_test(md, ISC_MD_SHA224,
307 		    TEST_INPUT("\x55\xb2\x10\x07\x9c\x61\xb5\x3a\xdd\x52"
308 			       "\x06\x22\xd1\xac\x97\xd5\xcd\xbe\x8c\xb3"
309 			       "\x3a\xa0\xae\x34\x45\x17\xbe\xe4\xd7\xba"
310 			       "\x09\xab\xc8\x53\x3c\x52\x50\x88\x7a\x43"
311 			       "\xbe\xbb\xac\x90\x6c\x2e\x18\x37\xf2\x6b"
312 			       "\x36\xa5\x9a\xe3\xbe\x78\x14\xd5\x06\x89"
313 			       "\x6b\x71\x8b\x2a\x38\x3e\xcd\xac\x16\xb9"
314 			       "\x61\x25\x55\x3f\x41\x6f\xf3\x2c\x66\x74"
315 			       "\xc7\x45\x99\xa9\x00\x53\x86\xd9\xce\x11"
316 			       "\x12\x24\x5f\x48\xee\x47\x0d\x39\x6c\x1e"
317 			       "\xd6\x3b\x92\x67\x0c\xa5\x6e\xc8\x4d\xee"
318 			       "\xa8\x14\xb6\x13\x5e\xca\x54\x39\x2b\xde"
319 			       "\xdb\x94\x89\xbc\x9b\x87\x5a\x8b\xaf\x0d"
320 			       "\xc1\xae\x78\x57\x36\x91\x4a\xb7\xda\xa2"
321 			       "\x64\xbc\x07\x9d\x26\x9f\x2c\x0d\x7e\xdd"
322 			       "\xd8\x10\xa4\x26\x14\x5a\x07\x76\xf6\x7c"
323 			       "\x87\x82\x73"),
324 		    "0B31894EC8937AD9B91BDFBCBA294D9ADEFAA18E09305E"
325 		    "9F20D5C3A4",
326 		    1);
327 }
328 
329 static void
isc_md_sha256_test(void ** state)330 isc_md_sha256_test(void **state) {
331 	isc_md_t *md = *state;
332 
333 	isc_md_test(md, ISC_MD_SHA256, NULL, 0, NULL, 0);
334 	isc_md_test(md, ISC_MD_SHA256, TEST_INPUT(""),
335 		    "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B93"
336 		    "4CA495991B7852B855",
337 		    1);
338 
339 	isc_md_test(md, ISC_MD_SHA256, TEST_INPUT("abc"),
340 		    "BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A"
341 		    "9CB410FF61F20015AD",
342 		    1);
343 	isc_md_test(md, ISC_MD_SHA256,
344 		    TEST_INPUT("abcdbcdecdefdefgefghfghighijhijkijkljk"
345 			       "lmklmnlmnomnopnopq"),
346 		    "248D6A61D20638B8E5C026930C3E6039A33CE45964FF21"
347 		    "67F6ECEDD419DB06C1",
348 		    1);
349 	isc_md_test(md, ISC_MD_SHA256, TEST_INPUT("a"),
350 		    "CDC76E5C9914FB9281A1C7E284D73E67F1809A48A49720"
351 		    "0E046D39CCC7112CD0",
352 		    1000000);
353 	isc_md_test(md, ISC_MD_SHA256,
354 		    TEST_INPUT("01234567012345670123456701234567"),
355 		    "594847328451BDFA85056225462CC1D867D877FB388DF0"
356 		    "CE35F25AB5562BFBB5",
357 		    20);
358 	isc_md_test(md, ISC_MD_SHA256, TEST_INPUT("\x19"),
359 		    "68AA2E2EE5DFF96E3355E6C7EE373E3D6A4E17F75F9518"
360 		    "D843709C0C9BC3E3D4",
361 		    1);
362 	isc_md_test(md, ISC_MD_SHA256,
363 		    TEST_INPUT("\xe3\xd7\x25\x70\xdc\xdd\x78\x7c\xe3"
364 			       "\x88\x7a\xb2\xcd\x68\x46\x52"),
365 		    "175EE69B02BA9B58E2B0A5FD13819CEA573F3940A94F82"
366 		    "5128CF4209BEABB4E8",
367 		    1);
368 	isc_md_test(md, ISC_MD_SHA256,
369 		    TEST_INPUT("\x83\x26\x75\x4e\x22\x77\x37\x2f\x4f\xc1"
370 			       "\x2b\x20\x52\x7a\xfe\xf0\x4d\x8a\x05\x69"
371 			       "\x71\xb1\x1a\xd5\x71\x23\xa7\xc1\x37\x76"
372 			       "\x00\x00\xd7\xbe\xf6\xf3\xc1\xf7\xa9\x08"
373 			       "\x3a\xa3\x9d\x81\x0d\xb3\x10\x77\x7d\xab"
374 			       "\x8b\x1e\x7f\x02\xb8\x4a\x26\xc7\x73\x32"
375 			       "\x5f\x8b\x23\x74\xde\x7a\x4b\x5a\x58\xcb"
376 			       "\x5c\x5c\xf3\x5b\xce\xe6\xfb\x94\x6e\x5b"
377 			       "\xd6\x94\xfa\x59\x3a\x8b\xeb\x3f\x9d\x65"
378 			       "\x92\xec\xed\xaa\x66\xca\x82\xa2\x9d\x0c"
379 			       "\x51\xbc\xf9\x33\x62\x30\xe5\xd7\x84\xe4"
380 			       "\xc0\xa4\x3f\x8d\x79\xa3\x0a\x16\x5c\xba"
381 			       "\xbe\x45\x2b\x77\x4b\x9c\x71\x09\xa9\x7d"
382 			       "\x13\x8f\x12\x92\x28\x96\x6f\x6c\x0a\xdc"
383 			       "\x10\x6a\xad\x5a\x9f\xdd\x30\x82\x57\x69"
384 			       "\xb2\xc6\x71\xaf\x67\x59\xdf\x28\xeb\x39"
385 			       "\x3d\x54\xd6"),
386 		    "97DBCA7DF46D62C8A422C941DD7E835B8AD3361763F7E9"
387 		    "B2D95F4F0DA6E1CCBC",
388 		    1);
389 }
390 
391 static void
isc_md_sha384_test(void ** state)392 isc_md_sha384_test(void **state) {
393 	isc_md_t *md = *state;
394 
395 	isc_md_test(md, ISC_MD_SHA384, NULL, 0, NULL, 0);
396 	isc_md_test(md, ISC_MD_SHA384, TEST_INPUT(""),
397 		    "38B060A751AC96384CD9327EB1B1E36A21FDB71114BE07"
398 		    "434C0CC7BF63F6E1DA274EDEBFE76F65FBD51AD2F14898"
399 		    "B95B"
400 		    "",
401 		    1);
402 	isc_md_test(md, ISC_MD_SHA384, TEST_INPUT("abc"),
403 		    "CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED1"
404 		    "631A8B605A43FF5BED8086072BA1E7CC2358BAEC"
405 		    "A134C825A7",
406 		    1);
407 	isc_md_test(md, ISC_MD_SHA384,
408 		    TEST_INPUT("abcdefghbcdefghicdefghijdefghijkefghijkl"
409 			       "fghijklmghijklmnhijklmnoijklmnopjklmnopq"
410 			       "klmnopqrlmnopqrsmnopqrstnopqrstu"),
411 		    "09330C33F71147E83D192FC782CD1B4753111B173B3B05"
412 		    "D22FA08086E3B0F712FCC7C71A557E2DB966C3E9"
413 		    "FA91746039",
414 		    1);
415 	isc_md_test(md, ISC_MD_SHA384, TEST_INPUT("a"),
416 		    "9D0E1809716474CB086E834E310A4A1CED149E9C00F248"
417 		    "527972CEC5704C2A5B07B8B3DC38ECC4EBAE97DD"
418 		    "D87F3D8985",
419 		    1000000);
420 	isc_md_test(md, ISC_MD_SHA384,
421 		    TEST_INPUT("01234567012345670123456701234567"),
422 		    "2FC64A4F500DDB6828F6A3430B8DD72A368EB7F3A8322A"
423 		    "70BC84275B9C0B3AB00D27A5CC3C2D224AA6B61A"
424 		    "0D79FB4596",
425 		    20);
426 	isc_md_test(md, ISC_MD_SHA384, TEST_INPUT("\xb9"),
427 		    "BC8089A19007C0B14195F4ECC74094FEC64F01F9092928"
428 		    "2C2FB392881578208AD466828B1C6C283D2722CF"
429 		    "0AD1AB6938",
430 		    1);
431 	isc_md_test(md, ISC_MD_SHA384,
432 		    TEST_INPUT("\xa4\x1c\x49\x77\x79\xc0\x37\x5f\xf1"
433 			       "\x0a\x7f\x4e\x08\x59\x17\x39"),
434 		    "C9A68443A005812256B8EC76B00516F0DBB74FAB26D665"
435 		    "913F194B6FFB0E91EA9967566B58109CBC675CC2"
436 		    "08E4C823F7",
437 		    1);
438 	isc_md_test(md, ISC_MD_SHA384,
439 		    TEST_INPUT("\x39\x96\x69\xe2\x8f\x6b\x9c\x6d\xbc\xbb"
440 			       "\x69\x12\xec\x10\xff\xcf\x74\x79\x03\x49"
441 			       "\xb7\xdc\x8f\xbe\x4a\x8e\x7b\x3b\x56\x21"
442 			       "\xdb\x0f\x3e\x7d\xc8\x7f\x82\x32\x64\xbb"
443 			       "\xe4\x0d\x18\x11\xc9\xea\x20\x61\xe1\xc8"
444 			       "\x4a\xd1\x0a\x23\xfa\xc1\x72\x7e\x72\x02"
445 			       "\xfc\x3f\x50\x42\xe6\xbf\x58\xcb\xa8\xa2"
446 			       "\x74\x6e\x1f\x64\xf9\xb9\xea\x35\x2c\x71"
447 			       "\x15\x07\x05\x3c\xf4\xe5\x33\x9d\x52\x86"
448 			       "\x5f\x25\xcc\x22\xb5\xe8\x77\x84\xa1\x2f"
449 			       "\xc9\x61\xd6\x6c\xb6\xe8\x95\x73\x19\x9a"
450 			       "\x2c\xe6\x56\x5c\xbd\xf1\x3d\xca\x40\x38"
451 			       "\x32\xcf\xcb\x0e\x8b\x72\x11\xe8\x3a\xf3"
452 			       "\x2a\x11\xac\x17\x92\x9f\xf1\xc0\x73\xa5"
453 			       "\x1c\xc0\x27\xaa\xed\xef\xf8\x5a\xad\x7c"
454 			       "\x2b\x7c\x5a\x80\x3e\x24\x04\xd9\x6d\x2a"
455 			       "\x77\x35\x7b\xda\x1a\x6d\xae\xed\x17\x15"
456 			       "\x1c\xb9\xbc\x51\x25\xa4\x22\xe9\x41\xde"
457 			       "\x0c\xa0\xfc\x50\x11\xc2\x3e\xcf\xfe\xfd"
458 			       "\xd0\x96\x76\x71\x1c\xf3\xdb\x0a\x34\x40"
459 			       "\x72\x0e\x16\x15\xc1\xf2\x2f\xbc\x3c\x72"
460 			       "\x1d\xe5\x21\xe1\xb9\x9b\xa1\xbd\x55\x77"
461 			       "\x40\x86\x42\x14\x7e\xd0\x96"),
462 		    "4F440DB1E6EDD2899FA335F09515AA025EE177A79F4B4A"
463 		    "AF38E42B5C4DE660F5DE8FB2A5B2FBD2A3CBFFD2"
464 		    "0CFF1288C0",
465 		    1);
466 }
467 
468 static void
isc_md_sha512_test(void ** state)469 isc_md_sha512_test(void **state) {
470 	isc_md_t *md = *state;
471 
472 	isc_md_test(md, ISC_MD_SHA512, NULL, 0, NULL, 0);
473 	isc_md_test(md, ISC_MD_SHA512, TEST_INPUT(""),
474 		    "CF83E1357EEFB8BDF1542850D66D8007D620E4050B5715"
475 		    "DC83F4A921D36CE9CE47D0D13C5D85F2B0FF8318D2877E"
476 		    "EC2F63B931BD47417A81A538327AF927DA3E",
477 		    1);
478 	isc_md_test(md, ISC_MD_SHA512, TEST_INPUT("abc"),
479 		    "DDAF35A193617ABACC417349AE20413112E6FA4E89A97E"
480 		    "A20A9EEEE64B55D39A2192992A274FC1A836BA3C"
481 		    "23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F",
482 		    1);
483 	isc_md_test(md, ISC_MD_SHA512,
484 		    TEST_INPUT("abcdefghbcdefghicdefghijdefghijkefghijkl"
485 			       "fghijklmghijklmnhijklmnoijklmnopjklmnopq"
486 			       "klmnopqrlmnopqrsmnopqrstnopqrstu"),
487 		    "8E959B75DAE313DA8CF4F72814FC143F8F7779C6EB9F7F"
488 		    "A17299AEADB6889018501D289E4900F7E4331B99"
489 		    "DEC4B5433AC7D329EEB6DD26545E96E55B874BE909",
490 		    1);
491 	isc_md_test(md, ISC_MD_SHA512, TEST_INPUT("a"),
492 		    "E718483D0CE769644E2E42C7BC15B4638E1F98B13B2044"
493 		    "285632A803AFA973EBDE0FF244877EA60A4CB043"
494 		    "2CE577C31BEB009C5C2C49AA2E4EADB217AD8CC09B",
495 		    1000000);
496 	isc_md_test(md, ISC_MD_SHA512,
497 		    TEST_INPUT("01234567012345670123456701234567"),
498 		    "89D05BA632C699C31231DED4FFC127D5A894DAD412C0E0"
499 		    "24DB872D1ABD2BA8141A0F85072A9BE1E2AA04CF"
500 		    "33C765CB510813A39CD5A84C4ACAA64D3F3FB7BAE9",
501 		    20);
502 	isc_md_test(md, ISC_MD_SHA512, TEST_INPUT("\xD0"),
503 		    "9992202938E882E73E20F6B69E68A0A7149090423D93C8"
504 		    "1BAB3F21678D4ACEEEE50E4E8CAFADA4C85A54EA"
505 		    "8306826C4AD6E74CECE9631BFA8A549B4AB3FBBA15",
506 		    1);
507 	isc_md_test(md, ISC_MD_SHA512,
508 		    TEST_INPUT("\x8d\x4e\x3c\x0e\x38\x89\x19\x14\x91\x81"
509 			       "\x6e\x9d\x98\xbf\xf0\xa0"),
510 		    "CB0B67A4B8712CD73C9AABC0B199E9269B20844AFB75AC"
511 		    "BDD1C153C9828924C3DDEDAAFE669C5FDD0BC66F"
512 		    "630F6773988213EB1B16F517AD0DE4B2F0C95C90F8",
513 		    1);
514 	isc_md_test(md, ISC_MD_SHA512,
515 		    TEST_INPUT("\xa5\x5f\x20\xc4\x11\xaa\xd1\x32\x80\x7a"
516 			       "\x50\x2d\x65\x82\x4e\x31\xa2\x30\x54\x32"
517 			       "\xaa\x3d\x06\xd3\xe2\x82\xa8\xd8\x4e\x0d"
518 			       "\xe1\xde\x69\x74\xbf\x49\x54\x69\xfc\x7f"
519 			       "\x33\x8f\x80\x54\xd5\x8c\x26\xc4\x93\x60"
520 			       "\xc3\xe8\x7a\xf5\x65\x23\xac\xf6\xd8\x9d"
521 			       "\x03\xe5\x6f\xf2\xf8\x68\x00\x2b\xc3\xe4"
522 			       "\x31\xed\xc4\x4d\xf2\xf0\x22\x3d\x4b\xb3"
523 			       "\xb2\x43\x58\x6e\x1a\x7d\x92\x49\x36\x69"
524 			       "\x4f\xcb\xba\xf8\x8d\x95\x19\xe4\xeb\x50"
525 			       "\xa6\x44\xf8\xe4\xf9\x5e\xb0\xea\x95\xbc"
526 			       "\x44\x65\xc8\x82\x1a\xac\xd2\xfe\x15\xab"
527 			       "\x49\x81\x16\x4b\xbb\x6d\xc3\x2f\x96\x90"
528 			       "\x87\xa1\x45\xb0\xd9\xcc\x9c\x67\xc2\x2b"
529 			       "\x76\x32\x99\x41\x9c\xc4\x12\x8b\xe9\xa0"
530 			       "\x77\xb3\xac\xe6\x34\x06\x4e\x6d\x99\x28"
531 			       "\x35\x13\xdc\x06\xe7\x51\x5d\x0d\x73\x13"
532 			       "\x2e\x9a\x0d\xc6\xd3\xb1\xf8\xb2\x46\xf1"
533 			       "\xa9\x8a\x3f\xc7\x29\x41\xb1\xe3\xbb\x20"
534 			       "\x98\xe8\xbf\x16\xf2\x68\xd6\x4f\x0b\x0f"
535 			       "\x47\x07\xfe\x1e\xa1\xa1\x79\x1b\xa2\xf3"
536 			       "\xc0\xc7\x58\xe5\xf5\x51\x86\x3a\x96\xc9"
537 			       "\x49\xad\x47\xd7\xfb\x40\xd2"),
538 		    "C665BEFB36DA189D78822D10528CBF3B12B3EEF7260399"
539 		    "09C1A16A270D48719377966B957A878E72058477"
540 		    "9A62825C18DA26415E49A7176A894E7510FD1451F5",
541 		    1);
542 }
543 
544 int
main(void)545 main(void) {
546 	const struct CMUnitTest tests[] = {
547 		/* isc_md_new() */
548 		cmocka_unit_test(isc_md_new_test),
549 
550 		/* isc_md_init() */
551 		cmocka_unit_test_setup_teardown(isc_md_init_test, _reset,
552 						_reset),
553 
554 		/* isc_md_reset() */
555 		cmocka_unit_test_setup_teardown(isc_md_reset_test, _reset,
556 						_reset),
557 
558 		/* isc_md_init() -> isc_md_update() -> isc_md_final() */
559 		cmocka_unit_test(isc_md_md5_test),
560 		cmocka_unit_test(isc_md_sha1_test),
561 		cmocka_unit_test(isc_md_sha224_test),
562 		cmocka_unit_test(isc_md_sha256_test),
563 		cmocka_unit_test(isc_md_sha384_test),
564 		cmocka_unit_test(isc_md_sha512_test),
565 
566 		cmocka_unit_test_setup_teardown(isc_md_update_test, _reset,
567 						_reset),
568 		cmocka_unit_test_setup_teardown(isc_md_final_test, _reset,
569 						_reset),
570 
571 		cmocka_unit_test(isc_md_free_test),
572 	};
573 
574 	return (cmocka_run_group_tests(tests, _setup, _teardown));
575 }
576 
577 #else /* HAVE_CMOCKA */
578 
579 #include <stdio.h>
580 
581 int
main(void)582 main(void) {
583 	printf("1..0 # Skipped: cmocka not available\n");
584 	return (SKIPPED_TEST_EXIT_CODE);
585 }
586 
587 #endif /* if HAVE_CMOCKA */
588