From e2fc8e037ea6bb5de92b25ec9c12a624737ac5ca Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 8 Apr 2024 18:41:29 +0200 Subject: Merging upstream version 1:9.18.24. Signed-off-by: Daniel Baumann --- tests/isc/Makefile.in | 2 - tests/isc/hmac_test.c | 212 ++++++++++++++++++++++++------------------------ tests/isc/ht_test.c | 50 ++++++++++++ tests/isc/netmgr_test.c | 178 +++++++++++++++++++++++++++++++++++++++- 4 files changed, 333 insertions(+), 109 deletions(-) (limited to 'tests/isc') diff --git a/tests/isc/Makefile.in b/tests/isc/Makefile.in index 1060d23..424a589 100644 --- a/tests/isc/Makefile.in +++ b/tests/isc/Makefile.in @@ -124,11 +124,9 @@ am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_compile_flag.m4 \ $(top_srcdir)/m4/ax_gcc_func_attribute.m4 \ $(top_srcdir)/m4/ax_jemalloc.m4 \ $(top_srcdir)/m4/ax_lib_lmdb.m4 \ - $(top_srcdir)/m4/ax_perl_module.m4 \ $(top_srcdir)/m4/ax_posix_shell.m4 \ $(top_srcdir)/m4/ax_prog_cc_for_build.m4 \ $(top_srcdir)/m4/ax_pthread.m4 \ - $(top_srcdir)/m4/ax_python_module.m4 \ $(top_srcdir)/m4/ax_restore_flags.m4 \ $(top_srcdir)/m4/ax_save_flags.m4 $(top_srcdir)/m4/ax_tls.m4 \ $(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \ diff --git a/tests/isc/hmac_test.c b/tests/isc/hmac_test.c index 093c6b2..a1715b0 100644 --- a/tests/isc/hmac_test.c +++ b/tests/isc/hmac_test.c @@ -45,11 +45,11 @@ static int _setup(void **state) { - isc_hmac_t *hmac = isc_hmac_new(); - if (hmac == NULL) { + isc_hmac_t *hmac_st = isc_hmac_new(); + if (hmac_st == NULL) { return (-1); } - *state = hmac; + *state = hmac_st; return (0); } @@ -76,31 +76,32 @@ _reset(void **state) { ISC_RUN_TEST_IMPL(isc_hmac_new) { UNUSED(state); - isc_hmac_t *hmac = isc_hmac_new(); - assert_non_null(hmac); - isc_hmac_free(hmac); /* Cleanup */ + isc_hmac_t *hmac_st = isc_hmac_new(); + assert_non_null(hmac_st); + isc_hmac_free(hmac_st); /* Cleanup */ } ISC_RUN_TEST_IMPL(isc_hmac_free) { UNUSED(state); - isc_hmac_t *hmac = isc_hmac_new(); - assert_non_null(hmac); - isc_hmac_free(hmac); /* Test freeing valid message digest context */ - isc_hmac_free(NULL); /* Test freeing NULL argument */ + isc_hmac_t *hmac_st = isc_hmac_new(); + assert_non_null(hmac_st); + isc_hmac_free(hmac_st); /* Test freeing valid message digest context */ + isc_hmac_free(NULL); /* Test freeing NULL argument */ } static void -isc_hmac_test(isc_hmac_t *hmac, const void *key, size_t keylen, +isc_hmac_test(isc_hmac_t *hmac_st, const void *key, size_t keylen, const isc_md_type_t *type, const char *buf, size_t buflen, const char *result, const size_t repeats) { isc_result_t res; - assert_non_null(hmac); - assert_int_equal(isc_hmac_init(hmac, key, keylen, type), ISC_R_SUCCESS); + assert_non_null(hmac_st); + assert_int_equal(isc_hmac_init(hmac_st, key, keylen, type), + ISC_R_SUCCESS); for (size_t i = 0; i < repeats; i++) { - assert_int_equal(isc_hmac_update(hmac, + assert_int_equal(isc_hmac_update(hmac_st, (const unsigned char *)buf, buflen), ISC_R_SUCCESS); @@ -108,7 +109,7 @@ isc_hmac_test(isc_hmac_t *hmac, const void *key, size_t keylen, unsigned char digest[ISC_MAX_MD_SIZE]; unsigned int digestlen = sizeof(digest); - assert_int_equal(isc_hmac_final(hmac, digest, &digestlen), + assert_int_equal(isc_hmac_final(hmac_st, digest, &digestlen), ISC_R_SUCCESS); char hexdigest[ISC_MAX_MD_SIZE * 2 + 3]; @@ -121,73 +122,76 @@ isc_hmac_test(isc_hmac_t *hmac, const void *key, size_t keylen, assert_return_code(res, ISC_R_SUCCESS); assert_memory_equal(hexdigest, result, (result ? strlen(result) : 0)); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); } ISC_RUN_TEST_IMPL(isc_hmac_init) { - isc_hmac_t *hmac = *state; - assert_non_null(hmac); + isc_hmac_t *hmac_st = *state; + assert_non_null(hmac_st); expect_assert_failure(isc_hmac_init(NULL, "", 0, ISC_MD_MD5)); - assert_int_equal(isc_hmac_init(hmac, "", 0, NULL), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, NULL), ISC_R_NOTIMPLEMENTED); - expect_assert_failure(isc_hmac_init(hmac, NULL, 0, ISC_MD_MD5)); + expect_assert_failure(isc_hmac_init(hmac_st, NULL, 0, ISC_MD_MD5)); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_MD5), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_MD5), + ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_SHA1), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_SHA1), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_SHA224), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_SHA224), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_SHA256), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_SHA256), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_SHA384), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_SHA384), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_SHA512), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_SHA512), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); } ISC_RUN_TEST_IMPL(isc_hmac_update) { - isc_hmac_t *hmac = *state; - assert_non_null(hmac); + isc_hmac_t *hmac_st = *state; + assert_non_null(hmac_st); /* Uses message digest context initialized in isc_hmac_init_test() */ expect_assert_failure(isc_hmac_update(NULL, NULL, 0)); - assert_int_equal(isc_hmac_update(hmac, NULL, 100), ISC_R_SUCCESS); - assert_int_equal(isc_hmac_update(hmac, (const unsigned char *)"", 0), + assert_int_equal(isc_hmac_update(hmac_st, NULL, 100), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_update(hmac_st, (const unsigned char *)"", 0), ISC_R_SUCCESS); } ISC_RUN_TEST_IMPL(isc_hmac_reset) { - isc_hmac_t *hmac = *state; + isc_hmac_t *hmac_st = *state; #if 0 unsigned char digest[ISC_MAX_MD_SIZE] __attribute((unused)); unsigned int digestlen __attribute((unused)); #endif /* if 0 */ - assert_non_null(hmac); + assert_non_null(hmac_st); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_SHA512), - ISC_R_SUCCESS); - assert_int_equal(isc_hmac_update(hmac, (const unsigned char *)"a", 1), - ISC_R_SUCCESS); - assert_int_equal(isc_hmac_update(hmac, (const unsigned char *)"b", 1), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_SHA512), ISC_R_SUCCESS); + assert_int_equal( + isc_hmac_update(hmac_st, (const unsigned char *)"a", 1), + ISC_R_SUCCESS); + assert_int_equal( + isc_hmac_update(hmac_st, (const unsigned char *)"b", 1), + ISC_R_SUCCESS); - assert_int_equal(isc_hmac_reset(hmac), ISC_R_SUCCESS); + assert_int_equal(isc_hmac_reset(hmac_st), ISC_R_SUCCESS); #if 0 /* @@ -195,13 +199,13 @@ ISC_RUN_TEST_IMPL(isc_hmac_reset) { * so this could be only manually checked that the test will * segfault when called by hand */ - expect_assert_failure(isc_hmac_final(hmac, digest, &digestlen)); + expect_assert_failure(isc_hmac_final(hmac_st, digest, &digestlen)); #endif /* if 0 */ } ISC_RUN_TEST_IMPL(isc_hmac_final) { - isc_hmac_t *hmac = *state; - assert_non_null(hmac); + isc_hmac_t *hmac_st = *state; + assert_non_null(hmac_st); unsigned char digest[ISC_MAX_MD_SIZE]; unsigned int digestlen = sizeof(digest); @@ -209,23 +213,23 @@ ISC_RUN_TEST_IMPL(isc_hmac_final) { /* Fail when message digest context is empty */ expect_assert_failure(isc_hmac_final(NULL, digest, &digestlen)); /* Fail when output buffer is empty */ - expect_assert_failure(isc_hmac_final(hmac, NULL, &digestlen)); + expect_assert_failure(isc_hmac_final(hmac_st, NULL, &digestlen)); - assert_int_equal(isc_hmac_init(hmac, "", 0, ISC_MD_SHA512), + assert_int_equal(isc_hmac_init(hmac_st, "", 0, ISC_MD_SHA512), ISC_R_SUCCESS); /* Fail when the digest length pointer is empty */ - expect_assert_failure(isc_hmac_final(hmac, digest, NULL)); + expect_assert_failure(isc_hmac_final(hmac_st, digest, NULL)); } ISC_RUN_TEST_IMPL(isc_hmac_md5) { - isc_hmac_t *hmac = *state; + isc_hmac_t *hmac_st = *state; /* Test 0 */ - isc_hmac_test(hmac, TEST_INPUT(""), ISC_MD_MD5, TEST_INPUT(""), + isc_hmac_test(hmac_st, TEST_INPUT(""), ISC_MD_MD5, TEST_INPUT(""), "74E6F7298A9C2D168935F58C001BAD88", 1); /* Test 1 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" "\x0b\x0b\x0b\x0b\x0b\x0b"), ISC_MD_MD5, @@ -233,14 +237,14 @@ ISC_RUN_TEST_IMPL(isc_hmac_md5) { "9294727A3638BB1C13F48EF8158BFC9D", 1); /* Test 2 */ - isc_hmac_test(hmac, TEST_INPUT("Jefe"), ISC_MD_MD5, + isc_hmac_test(hmac_st, TEST_INPUT("Jefe"), ISC_MD_MD5, TEST_INPUT("\x77\x68\x61\x74\x20\x64\x6f\x20\x79" "\x61\x20\x77\x61\x6e\x74\x20\x66\x6f" "\x72\x20\x6e\x6f\x74\x68\x69\x6e\x67\x3f"), "750C783E6AB0B503EAA86E310A5DB738", 1); /* Test 3 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa"), ISC_MD_MD5, @@ -251,7 +255,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_md5) { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"), "56BE34521D144C88DBB8C733F0E8B3F6", 1); /* Test 4 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\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"), @@ -264,7 +268,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_md5) { "697EAF0ACA3A3AEA3A75164746FFAA79", 1); #if 0 /* Test 5 -- unimplemented optional functionality */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"), ISC_MD_MD5, @@ -272,7 +276,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_md5) { "4C1A03424B55E07FE7F27BE1", 1); /* Test 6 -- unimplemented optional functionality */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -292,7 +296,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_md5) { "AA4AE5E15272D00E95705637CE8A3B55ED402112", 1); /* Test 7 -- unimplemented optional functionality */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -315,27 +319,27 @@ ISC_RUN_TEST_IMPL(isc_hmac_md5) { } ISC_RUN_TEST_IMPL(isc_hmac_sha1) { - isc_hmac_t *hmac = *state; + isc_hmac_t *hmac_st = *state; /* Test 0 */ - isc_hmac_test(hmac, TEST_INPUT(""), ISC_MD_SHA1, TEST_INPUT(""), + isc_hmac_test(hmac_st, TEST_INPUT(""), ISC_MD_SHA1, TEST_INPUT(""), "FBDB1D1B18AA6C08324B7D64B71FB76370690E1D", 1); /* Test 1 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"), ISC_MD_SHA1, TEST_INPUT("\x48\x69\x20\x54\x68\x65\x72\x65"), "B617318655057264E28BC0B6FB378C8EF146BE00", 1); /* Test 2 */ - isc_hmac_test(hmac, TEST_INPUT("Jefe"), ISC_MD_SHA1, + isc_hmac_test(hmac_st, TEST_INPUT("Jefe"), ISC_MD_SHA1, TEST_INPUT("\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61" "\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20" "\x6e\x6f\x74\x68\x69\x6e\x67\x3f"), "EFFCDF6AE5EB2FA2D27416D5F184DF9C259A7C79", 1); /* Test 3 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"), ISC_MD_SHA1, @@ -346,7 +350,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha1) { "\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD\xDD"), "125D7342B9AC11CD91A39AF48AA17B4F63F175D3", 1); /* Test 4 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\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"), @@ -359,7 +363,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha1) { "4C9007F4026250C6BC8414F9BF50C86C2D7235DA", 1); #if 0 /* Test 5 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"), ISC_MD_SHA1, @@ -368,7 +372,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha1) { 1); #endif /* if 0 */ /* Test 6 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -382,7 +386,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha1) { "Hash Key First"), "AA4AE5E15272D00E95705637CE8A3B55ED402112", 1); /* Test 7 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -398,16 +402,16 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha1) { } ISC_RUN_TEST_IMPL(isc_hmac_sha224) { - isc_hmac_t *hmac = *state; + isc_hmac_t *hmac_st = *state; /* Test 0 */ - isc_hmac_test(hmac, TEST_INPUT(""), ISC_MD_SHA224, TEST_INPUT(""), + isc_hmac_test(hmac_st, TEST_INPUT(""), ISC_MD_SHA224, TEST_INPUT(""), "5CE14F72894662213E2748D2A6BA234B74263910CEDDE2F5" "A9271524", 1); /* Test 1 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"), ISC_MD_SHA224, @@ -416,7 +420,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha224) { "4F53684B22", 1); /* Test 2 */ - isc_hmac_test(hmac, TEST_INPUT("Jefe"), ISC_MD_SHA224, + isc_hmac_test(hmac_st, TEST_INPUT("Jefe"), ISC_MD_SHA224, TEST_INPUT("\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61" "\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20" "\x6e\x6f\x74\x68\x69\x6e\x67\x3f"), @@ -424,7 +428,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha224) { "08FD05E44", 1); /* Test 3 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"), ISC_MD_SHA224, @@ -437,7 +441,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha224) { "D1EC8333EA", 1); /* Test 4 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\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"), @@ -452,7 +456,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha224) { 1); #if 0 /* Test 5 -- unimplemented optional functionality */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"), ISC_MD_SHA224, @@ -461,7 +465,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha224) { 1); #endif /* if 0 */ /* Test 6 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -483,7 +487,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha224) { "273FA6870E", 1); /* Test 7 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -521,16 +525,16 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha224) { } ISC_RUN_TEST_IMPL(isc_hmac_sha256) { - isc_hmac_t *hmac = *state; + isc_hmac_t *hmac_st = *state; /* Test 0 */ - isc_hmac_test(hmac, TEST_INPUT(""), ISC_MD_SHA256, TEST_INPUT(""), + isc_hmac_test(hmac_st, TEST_INPUT(""), ISC_MD_SHA256, TEST_INPUT(""), "B613679A0814D9EC772F95D778C35FC5FF1697C493715653" "C6C712144292C5AD", 1); /* Test 1 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"), ISC_MD_SHA256, @@ -539,7 +543,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha256) { "A726E9376C2E32CFF7", 1); /* Test 2 */ - isc_hmac_test(hmac, TEST_INPUT("Jefe"), ISC_MD_SHA256, + isc_hmac_test(hmac_st, TEST_INPUT("Jefe"), ISC_MD_SHA256, TEST_INPUT("\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61" "\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20" "\x6e\x6f\x74\x68\x69\x6e\x67\x3f"), @@ -547,7 +551,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha256) { "839DEC58B964EC3843", 1); /* Test 3 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"), ISC_MD_SHA256, @@ -560,7 +564,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha256) { "22D9635514CED565FE", 1); /* Test 4 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\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"), @@ -575,7 +579,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha256) { 1); #if 0 /* Test 5 -- unimplemented optional functionality */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"), ISC_MD_SHA256, @@ -584,7 +588,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha256) { 1); #endif /* if 0 */ /* Test 6 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -606,7 +610,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha256) { "140546040F0EE37F54", 1); /* Test 7 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -644,16 +648,16 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha256) { } ISC_RUN_TEST_IMPL(isc_hmac_sha384) { - isc_hmac_t *hmac = *state; + isc_hmac_t *hmac_st = *state; /* Test 0 */ - isc_hmac_test(hmac, TEST_INPUT(""), ISC_MD_SHA384, TEST_INPUT(""), + isc_hmac_test(hmac_st, TEST_INPUT(""), ISC_MD_SHA384, TEST_INPUT(""), "6C1F2EE938FAD2E24BD91298474382CA218C75DB3D83E114" "B3D4367776D14D3551289E75E8209CD4B792302840234ADC", 1); /* Test 1 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"), ISC_MD_SHA384, @@ -663,7 +667,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha384) { "E8B2FA9CB6", 1); /* Test 2 */ - isc_hmac_test(hmac, TEST_INPUT("Jefe"), ISC_MD_SHA384, + isc_hmac_test(hmac_st, TEST_INPUT("Jefe"), ISC_MD_SHA384, TEST_INPUT("\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61" "\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20" "\x6e\x6f\x74\x68\x69\x6e\x67\x3f"), @@ -672,7 +676,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha384) { "ECFAB21649", 1); /* Test 3 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"), ISC_MD_SHA384, @@ -686,7 +690,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha384) { "E101A34F27", 1); /* Test 4 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\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"), @@ -702,7 +706,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha384) { 1); #if 0 /* Test 5 -- unimplemented optional functionality */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"), ISC_MD_SHA384, @@ -711,7 +715,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha384) { 1); #endif /* if 0 */ /* Test 6 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -734,7 +738,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha384) { "F163F44952", 1); /* Test 7 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -773,17 +777,17 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha384) { } ISC_RUN_TEST_IMPL(isc_hmac_sha512) { - isc_hmac_t *hmac = *state; + isc_hmac_t *hmac_st = *state; /* Test 0 */ - isc_hmac_test(hmac, TEST_INPUT(""), ISC_MD_SHA512, TEST_INPUT(""), + isc_hmac_test(hmac_st, TEST_INPUT(""), ISC_MD_SHA512, TEST_INPUT(""), "B936CEE86C9F87AA5D3C6F2E84CB5A4239A5FE50480A6EC6" "6B70AB5B1F4AC6730C6C515421B327EC1D69402E53DFB49A" "D7381EB067B338FD7B0CB22247225D47", 1); /* Test 1 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b" "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"), ISC_MD_SHA512, @@ -793,7 +797,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha512) { "4EAEA3F4E4BE9D914EEB61F1702E696C203A126854", 1); /* Test 2 */ - isc_hmac_test(hmac, TEST_INPUT("Jefe"), ISC_MD_SHA512, + isc_hmac_test(hmac_st, TEST_INPUT("Jefe"), ISC_MD_SHA512, TEST_INPUT("\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61" "\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20" "\x6e\x6f\x74\x68\x69\x6e\x67\x3f"), @@ -802,7 +806,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha512) { "65F8F0E6FDCAEAB1A34D4A6B4B636E070A38BCE737", 1); /* Test 3 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"), ISC_MD_SHA512, @@ -816,7 +820,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha512) { "A47E67C807B946A337BEE8942674278859E13292FB", 1); /* Test 4 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\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"), @@ -832,7 +836,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha512) { 1); #if 0 /* Test 5 -- unimplemented optional functionality */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c" "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"), ISC_MD_SHA512, @@ -841,7 +845,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha512) { 1); #endif /* if 0 */ /* Test 6 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" @@ -864,7 +868,7 @@ ISC_RUN_TEST_IMPL(isc_hmac_sha512) { "215D6A1E5295E64F73F63F0AEC8B915A985D786598", 1); /* Test 7 */ - isc_hmac_test(hmac, + isc_hmac_test(hmac_st, TEST_INPUT("\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa" diff --git a/tests/isc/ht_test.c b/tests/isc/ht_test.c index 89e18f3..64efa9d 100644 --- a/tests/isc/ht_test.c +++ b/tests/isc/ht_test.c @@ -312,7 +312,57 @@ ISC_RUN_TEST_IMPL(isc_ht_iterator) { test_ht_iterator(); } +ISC_RUN_TEST_IMPL(isc_ht_case) { + isc_ht_t *ht = NULL; + void *f = NULL; + isc_result_t result = ISC_R_UNSET; + + unsigned char lower[16] = { "test case" }; + unsigned char same[16] = { "test case" }; + unsigned char upper[16] = { "TEST CASE" }; + unsigned char mixed[16] = { "tEsT CaSe" }; + + isc_ht_init(&ht, mctx, 8, ISC_HT_CASE_SENSITIVE); + assert_non_null(ht); + + result = isc_ht_add(ht, lower, 16, (void *)lower); + assert_int_equal(result, ISC_R_SUCCESS); + + result = isc_ht_add(ht, same, 16, (void *)same); + assert_int_equal(result, ISC_R_EXISTS); + + result = isc_ht_add(ht, upper, 16, (void *)upper); + assert_int_equal(result, ISC_R_SUCCESS); + + result = isc_ht_find(ht, mixed, 16, &f); + assert_int_equal(result, ISC_R_NOTFOUND); + assert_null(f); + + isc_ht_destroy(&ht); + assert_null(ht); + + isc_ht_init(&ht, mctx, 8, ISC_HT_CASE_INSENSITIVE); + assert_non_null(ht); + + result = isc_ht_add(ht, lower, 16, (void *)lower); + assert_int_equal(result, ISC_R_SUCCESS); + + result = isc_ht_add(ht, same, 16, (void *)same); + assert_int_equal(result, ISC_R_EXISTS); + + result = isc_ht_add(ht, upper, 16, (void *)upper); + assert_int_equal(result, ISC_R_EXISTS); + + result = isc_ht_find(ht, mixed, 16, &f); + assert_int_equal(result, ISC_R_SUCCESS); + assert_ptr_equal(f, &lower); + + isc_ht_destroy(&ht); + assert_null(ht); +} + ISC_TEST_LIST_START +ISC_TEST_ENTRY(isc_ht_case) ISC_TEST_ENTRY(isc_ht_20) ISC_TEST_ENTRY(isc_ht_8) ISC_TEST_ENTRY(isc_ht_1) diff --git a/tests/isc/netmgr_test.c b/tests/isc/netmgr_test.c index a20db6b..49e5e01 100644 --- a/tests/isc/netmgr_test.c +++ b/tests/isc/netmgr_test.c @@ -393,8 +393,8 @@ noop_recv_cb(isc_nmhandle_t *handle, isc_result_t eresult, isc_region_t *region, UNUSED(cbarg); } -static unsigned int -noop_accept_cb(isc_nmhandle_t *handle, unsigned int result, void *cbarg) { +static isc_result_t +noop_accept_cb(isc_nmhandle_t *handle, isc_result_t result, void *cbarg) { UNUSED(handle); UNUSED(cbarg); @@ -402,7 +402,7 @@ noop_accept_cb(isc_nmhandle_t *handle, unsigned int result, void *cbarg) { (void)atomic_fetch_add(&saccepts, 1); } - return (0); + return (ISC_R_SUCCESS); } static void @@ -2401,6 +2401,176 @@ ISC_RUN_TEST_IMPL(tlsdns_recv_one) { atomic_assert_int_eq(ssends, 0); } +static void +tlsdns_many_listen_read_cb(isc_nmhandle_t *handle, isc_result_t eresult, + isc_region_t *region, void *cbarg) { + uint64_t magic = 0; + isc_nmhandle_t *sendhandle = NULL; + isc_buffer_t *send_data = (isc_buffer_t *)cbarg; + isc_region_t send_messages = { 0 }; + + assert_non_null(handle); + assert_non_null(send_data); + + F(); + + if (eresult != ISC_R_SUCCESS) { + goto unref; + } + + atomic_fetch_add(&sreads, 1); + + assert_true(region->length >= sizeof(magic)); + + memmove(&magic, region->base + sizeof(uint16_t), sizeof(magic)); + assert_true(magic == stop_magic || magic == send_magic); + + isc_nmhandle_attach(handle, &sendhandle); + isc_refcount_increment0(&active_ssends); + isc_nmhandle_setwritetimeout(sendhandle, T_IDLE); + /* send multiple DNS messages at once */ + isc_buffer_usedregion(send_data, &send_messages); + isc_nm_send(sendhandle, &send_messages, listen_send_cb, cbarg); +unref: + isc_refcount_decrement(&active_sreads); + isc_nmhandle_detach(&handle); +} + +static isc_result_t +tlsdns_many_listen_accept_cb(isc_nmhandle_t *handle, isc_result_t eresult, + void *cbarg) { + isc_nmhandle_t *readhandle = NULL; + + UNUSED(cbarg); + + F(); + + if (eresult != ISC_R_SUCCESS) { + return (eresult); + } + + atomic_fetch_add(&saccepts, 1); + + isc_refcount_increment0(&active_sreads); + isc_nmhandle_attach(handle, &readhandle); + isc_nm_read(handle, tlsdns_many_listen_read_cb, cbarg); + + return (ISC_R_SUCCESS); +} + +static void +tlsdns_many_connect_read_cb(isc_nmhandle_t *handle, isc_result_t eresult, + isc_region_t *region, void *cbarg) { + isc_nmhandle_t *sendhandle = NULL; + uint64_t magic = 0; + + UNUSED(cbarg); + + assert_non_null(handle); + + F(); + + if (eresult != ISC_R_SUCCESS) { + goto unref; + } + + assert_true(region->length >= sizeof(magic)); + + atomic_fetch_add(&creads, 1); + + memmove(&magic, region->base, sizeof(magic)); + + assert_true(magic == stop_magic || magic == send_magic); + + isc_refcount_increment0(&active_csends); + isc_nmhandle_attach(handle, &sendhandle); + isc_nmhandle_setwritetimeout(handle, T_IDLE); + /* + * At this point the read is completed, so we should stop that - + * but the sending code will make a cycling through input + * attempt. When not properly handled, this situation will cause + * excessive reads. + */ + isc_nm_send(sendhandle, &send_msg, connect_send_cb, NULL); + +unref: + isc_refcount_decrement(&active_creads); + isc_nmhandle_detach(&handle); +} + +/* + * A unit test *VERY* specific to #4487 - it would crash the unit test + * suite without the related fix due to excessive/unexpected reads. + * + * The intention behind the test is to (needlessly ;-)) prove that the + * author of the fix is not fantasising and excessive reads are + * possible in principle. Also, it proves that there is more than one + * way to do that. + * + * It is *not* reproducing the situation from the bug report 1:1, as + * it is impossible to understand what exactly was going on with this + * custom/proprietary server without having access to it (and even in + * that case the bug was hard to reproduce to the point, where the + * reporters considered it to be fixed for a while). There are far too + * many things a play. + */ +ISC_RUN_TEST_IMPL(tlsdns_server_send_many_recv_one) { + isc_result_t result = ISC_R_SUCCESS; + isc_nmsocket_t *listen_sock = NULL; + uint8_t buf[512]; + isc_buffer_t server_send_buf = { 0 }; + + isc_buffer_init(&server_send_buf, buf, sizeof(buf)); + + /* + * Prepare a buffer with three "DNS" messages which we will send + * at once (our code does not normally do that do that). + */ + isc_buffer_putuint16(&server_send_buf, (uint16_t)send_msg.length); + isc_buffer_putmem(&server_send_buf, send_msg.base, send_msg.length); + isc_buffer_putuint16(&server_send_buf, (uint16_t)send_msg.length); + isc_buffer_putmem(&server_send_buf, send_msg.base, send_msg.length); + isc_buffer_putuint16(&server_send_buf, (uint16_t)send_msg.length); + isc_buffer_putmem(&server_send_buf, send_msg.base, send_msg.length); + + atomic_store(&nsends, 1); + + result = isc_nm_listentls( + listen_nm, &tcp_listen_addr, tlsdns_many_listen_accept_cb, + &server_send_buf, 0, 0, NULL, tcp_listen_tlsctx, &listen_sock); + assert_int_equal(result, ISC_R_SUCCESS); + + connect_readcb = tlsdns_many_connect_read_cb; + isc_refcount_increment0(&active_cconnects); + isc_nm_tlsdnsconnect(connect_nm, &tcp_connect_addr, &tcp_listen_addr, + connect_connect_cb, NULL, T_CONNECT, 0, + tcp_connect_tlsctx, tcp_tlsctx_client_sess_cache); + + WAIT_FOR_EQ(cconnects, 1); + WAIT_FOR_LE(nsends, 0); + WAIT_FOR_EQ(csends, 2); + WAIT_FOR_EQ(sreads, 1); + WAIT_FOR_EQ(ssends, 1); + WAIT_FOR_EQ(creads, 1); + + isc_nm_stoplistening(listen_sock); + isc_nmsocket_close(&listen_sock); + assert_null(listen_sock); + isc__netmgr_shutdown(connect_nm); + + X(cconnects); + X(csends); + X(creads); + X(sreads); + X(ssends); + + atomic_assert_int_eq(cconnects, 1); + atomic_assert_int_eq(csends, 2); + atomic_assert_int_eq(creads, 1); + atomic_assert_int_eq(sreads, 1); + atomic_assert_int_eq(ssends, 1); +} + ISC_RUN_TEST_IMPL(tlsdns_recv_two) { isc_result_t result = ISC_R_SUCCESS; isc_nmsocket_t *listen_sock = NULL; @@ -2879,6 +3049,8 @@ ISC_TEST_ENTRY_CUSTOM(tls_half_recv_half_send_quota_sendback, setup_test, /* TLSDNS */ ISC_TEST_ENTRY_CUSTOM(tlsdns_recv_one, setup_test, teardown_test) +ISC_TEST_ENTRY_CUSTOM(tlsdns_server_send_many_recv_one, setup_test, + teardown_test) ISC_TEST_ENTRY_CUSTOM(tlsdns_recv_two, setup_test, teardown_test) ISC_TEST_ENTRY_CUSTOM(tlsdns_noop, setup_test, teardown_test) ISC_TEST_ENTRY_CUSTOM(tlsdns_noresponse, setup_test, teardown_test) -- cgit v1.2.3