aboutsummaryrefslogtreecommitdiff
path: root/contrib/ntp/tests/libntp/digests.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/ntp/tests/libntp/digests.c')
-rw-r--r--contrib/ntp/tests/libntp/digests.c415
1 files changed, 415 insertions, 0 deletions
diff --git a/contrib/ntp/tests/libntp/digests.c b/contrib/ntp/tests/libntp/digests.c
new file mode 100644
index 000000000000..03e9ef1b838e
--- /dev/null
+++ b/contrib/ntp/tests/libntp/digests.c
@@ -0,0 +1,415 @@
+#include "config.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include "unity.h"
+#include "ntp.h"
+#include "ntp_stdlib.h"
+
+/*
+ * tests/libntp/data/ntp.keys has two keys for each algorithm, 50 keyids apart.
+ * The first is 20 random ASCII chars, the 2nd 40 random hex values.
+ */
+#define HEX_KEYID_OFFSET 50
+
+/* in generated srcdir.c */
+extern const char srcdir[];
+
+/* needed by authtrust() */
+u_long current_time;
+
+static bool setup;
+static u_int32 * pkt;
+static size_t pkt_sz;
+static u_char * mac;
+
+/* helper routine */
+void dump_mac(keyid_t keyid, u_char *pmac, size_t octets);
+
+
+/* unity calls setUp before each test routine */
+void setUp(void);
+void
+setUp(void)
+{
+ static bool done_once;
+ const char msg_rel_fname[] = "data/mills,david-03.jpg";
+ const char keys_rel_fname[] = "data/ntp.keys";
+ char msg_fname[PATH_MAX];
+ char keys_fname[PATH_MAX];
+ int msgf;
+ int result;
+ struct stat msg_stat;
+ u_char * msg;
+ size_t msg_sz;
+ size_t pad_sz;
+ ssize_t octets;
+
+ if (done_once) {
+ return;
+ }
+ done_once = TRUE;
+
+ init_auth();
+
+ snprintf(keys_fname, sizeof(keys_fname), "%s/%s", srcdir,
+ keys_rel_fname);
+ if (! authreadkeys(keys_fname)) {
+ fprintf(stderr, "could not load keys %s\n", keys_fname);
+ return;
+ }
+
+ snprintf(msg_fname, sizeof(msg_fname), "%s/%s", srcdir, msg_rel_fname);
+ msgf = open(msg_fname, O_RDONLY);
+ if (msgf < 0) {
+ fprintf(stderr, "could not open msg file %s\n", msg_fname);
+ return;
+ }
+
+ result = fstat(msgf, &msg_stat);
+ if (result < 0) {
+ fprintf(stderr, "could not get msg file %s size\n", msg_fname);
+ return;
+ }
+
+ msg_sz = msg_stat.st_size;
+ /* round up to next multiple of 4 as needed by MD5authencrypt() */
+ pad_sz = sizeof(u_int32) - (msg_sz % sizeof(u_int32));
+ if (sizeof(u_int32) == pad_sz) {
+ pad_sz = 0;
+ }
+ /* allocate room for the message, key ID, and MAC */
+ msg = emalloc_zero(msg_sz + pad_sz + MAX_MAC_LEN);
+ octets = read(msgf, msg, msg_sz);
+ if (octets != msg_sz) {
+ fprintf(stderr, "could not read msg from file %s, %u != %u\n",
+ msg_fname, (u_int)octets, (u_int)msg_sz);
+ return;
+ }
+ zero_mem(msg + msg_sz, pad_sz);
+ pkt_sz = msg_sz + pad_sz;
+ mac = (void *)((u_char *)msg + pkt_sz);
+ pkt = (void *)msg;
+
+ setup = TRUE;
+}
+
+/* reduce code duplication with an ugly macro */
+#define TEST_ONE_DIGEST(key, exp_sz, exp_mac) \
+do { \
+ size_t res_sz; \
+ \
+ zero_mem(mac, MAX_MAC_LEN); \
+ if (!auth_findkey(key)) { \
+ TEST_IGNORE_MESSAGE("MAC unsupported on this system"); \
+ return; \
+ } \
+ authtrust((key), 1); \
+ \
+ res_sz = authencrypt((key), pkt, pkt_sz); \
+ if (KEY_MAC_LEN == res_sz) { \
+ TEST_IGNORE_MESSAGE("Likely OpenSSL 3 failed digest " \
+ "init."); \
+ return; \
+ } \
+ TEST_ASSERT_EQUAL_UINT((u_int)((exp_sz) + KEY_MAC_LEN), res_sz);\
+ dump_mac((key), mac, res_sz); \
+ TEST_ASSERT_EQUAL_HEX8_ARRAY((exp_mac), mac, MAX_MAC_LEN); \
+} while (FALSE)
+
+
+#define AES128CMAC_KEYID 1
+#undef KEYID_A
+#define KEYID_A AES128CMAC_KEYID
+#undef DG_SZ
+#define DG_SZ 16
+#undef KEYID_B
+#define KEYID_B (KEYID_A + HEX_KEYID_OFFSET)
+void test_Digest_AES128CMAC(void);
+void test_Digest_AES128CMAC(void)
+{
+#if defined(OPENSSL) && defined(ENABLE_CMAC)
+ u_char expectedA[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_A,
+ 0x34, 0x5b, 0xcf, 0xa8,
+ 0x85, 0x6e, 0x9d, 0x01,
+ 0xeb, 0x81, 0x25, 0xc2,
+ 0xa4, 0xb8, 0x1b, 0xe0
+ };
+ u_char expectedB[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_B,
+ 0xd1, 0x04, 0x4e, 0xbf,
+ 0x79, 0x2d, 0x3a, 0x40,
+ 0xcd, 0xdc, 0x5a, 0x44,
+ 0xde, 0xe0, 0x0c, 0x84
+ };
+
+ TEST_ASSERT(setup);
+ TEST_ONE_DIGEST(KEYID_A, DG_SZ, expectedA);
+ TEST_ONE_DIGEST(KEYID_B, DG_SZ, expectedB);
+#else /* ! (OPENSSL && ENABLE_CMAC) follows */
+ TEST_IGNORE_MESSAGE("Skipping, no OPENSSL or not ENABLE_CMAC");
+#endif
+}
+
+
+#define MD4_KEYID 2
+#undef KEYID_A
+#define KEYID_A MD4_KEYID
+#undef DG_SZ
+#define DG_SZ 16
+#undef KEYID_B
+#define KEYID_B (KEYID_A + HEX_KEYID_OFFSET)
+void test_Digest_MD4(void);
+void test_Digest_MD4(void)
+{
+#ifdef OPENSSL
+ u_char expectedA[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_A,
+ 0xf3, 0x39, 0x34, 0xca,
+ 0xe0, 0x48, 0x26, 0x0f,
+ 0x13, 0xca, 0x56, 0x9e,
+ 0xbc, 0x53, 0x9c, 0x66
+ };
+ u_char expectedB[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_B,
+ 0x5e, 0xe6, 0x81, 0xf2,
+ 0x57, 0x57, 0x8a, 0x2b,
+ 0xa8, 0x76, 0x8e, 0x7a,
+ 0xc4, 0xf4, 0x34, 0x7e
+ };
+
+ TEST_ASSERT(setup);
+ TEST_ONE_DIGEST(KEYID_A, DG_SZ, expectedA);
+ TEST_ONE_DIGEST(KEYID_B, DG_SZ, expectedB);
+#else /* ! OPENSSL follows */
+ TEST_IGNORE_MESSAGE("Skipping, no OPENSSL");
+#endif
+}
+
+
+#define MD5_KEYID 3
+#undef KEYID_A
+#define KEYID_A MD5_KEYID
+#undef DG_SZ
+#define DG_SZ 16
+#undef KEYID_B
+#define KEYID_B (KEYID_A + HEX_KEYID_OFFSET)
+void test_Digest_MD5(void);
+void test_Digest_MD5(void)
+{
+ u_char expectedA[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_A,
+ 0xa6, 0x8d, 0x3a, 0xfe,
+ 0x52, 0xe5, 0xf7, 0xe9,
+ 0x4c, 0x97, 0x72, 0x16,
+ 0x7c, 0x28, 0x18, 0xaf
+ };
+ u_char expectedB[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_B,
+ 0xd4, 0x11, 0x2c, 0xc6,
+ 0x66, 0x74, 0x46, 0x8b,
+ 0x12, 0xb1, 0x8c, 0x49,
+ 0xb0, 0x06, 0xda, 0x34
+ };
+
+ TEST_ASSERT(setup);
+ TEST_ONE_DIGEST(KEYID_A, DG_SZ, expectedA);
+ TEST_ONE_DIGEST(KEYID_B, DG_SZ, expectedB);
+}
+
+
+#define MDC2_KEYID 4
+#undef KEYID_A
+#define KEYID_A MDC2_KEYID
+#undef DG_SZ
+#define DG_SZ 16
+#undef KEYID_B
+#define KEYID_B (KEYID_A + HEX_KEYID_OFFSET)
+void test_Digest_MDC2(void);
+void test_Digest_MDC2(void)
+{
+#ifdef OPENSSL
+ u_char expectedA[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_A,
+ 0xa0, 0xfc, 0x18, 0xb6,
+ 0xea, 0xba, 0xa5, 0x27,
+ 0xc9, 0x64, 0x0e, 0x41,
+ 0x95, 0x90, 0x5d, 0xf5
+ };
+ u_char expectedB[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_B,
+ 0xe3, 0x2c, 0x1e, 0x64,
+ 0x7f, 0x85, 0x81, 0xe7,
+ 0x3b, 0xc3, 0x93, 0x5e,
+ 0xcd, 0x0e, 0x89, 0xeb
+ };
+
+ TEST_ASSERT(setup);
+ TEST_ONE_DIGEST(KEYID_A, DG_SZ, expectedA);
+ TEST_ONE_DIGEST(KEYID_B, DG_SZ, expectedB);
+#else /* ! OPENSSL follows */
+ TEST_IGNORE_MESSAGE("Skipping, no OPENSSL");
+#endif
+}
+
+
+#define RIPEMD160_KEYID 5
+#undef KEYID_A
+#define KEYID_A RIPEMD160_KEYID
+#undef DG_SZ
+#define DG_SZ 20
+#undef KEYID_B
+#define KEYID_B (KEYID_A + HEX_KEYID_OFFSET)
+void test_Digest_RIPEMD160(void);
+void test_Digest_RIPEMD160(void)
+{
+#ifdef OPENSSL
+ u_char expectedA[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_A,
+ 0x8c, 0x3e, 0x55, 0xbb,
+ 0xec, 0x7c, 0xf6, 0x30,
+ 0xef, 0xd1, 0x45, 0x8c,
+ 0xdd, 0x29, 0x32, 0x7e,
+ 0x04, 0x87, 0x6c, 0xd7
+ };
+ u_char expectedB[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_B,
+ 0x2d, 0x4a, 0x48, 0xdd,
+ 0x28, 0x02, 0xb4, 0x9d,
+ 0xe3, 0x6d, 0x1b, 0x90,
+ 0x2b, 0xc4, 0x3f, 0xe5,
+ 0x19, 0x60, 0x12, 0xbc
+ };
+
+ TEST_ASSERT(setup);
+ TEST_ONE_DIGEST(KEYID_A, DG_SZ, expectedA);
+ TEST_ONE_DIGEST(KEYID_B, DG_SZ, expectedB);
+#else /* ! OPENSSL follows */
+ TEST_IGNORE_MESSAGE("Skipping, no OPENSSL");
+#endif
+}
+
+
+#define SHA1_KEYID 6
+#undef KEYID_A
+#define KEYID_A SHA1_KEYID
+#undef DG_SZ
+#define DG_SZ 20
+#undef KEYID_B
+#define KEYID_B (KEYID_A + HEX_KEYID_OFFSET)
+void test_Digest_SHA1(void);
+void test_Digest_SHA1(void)
+{
+#ifdef OPENSSL
+ u_char expectedA[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_A,
+ 0xe2, 0xc6, 0x17, 0x71,
+ 0x03, 0xc1, 0x85, 0x56,
+ 0x35, 0xc7, 0x4e, 0x75,
+ 0x79, 0x82, 0x9d, 0xcb,
+ 0x2d, 0x06, 0x0e, 0xfa
+ };
+ u_char expectedB[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_B,
+ 0x01, 0x16, 0x37, 0xb4,
+ 0xf5, 0x2d, 0xe0, 0x97,
+ 0xaf, 0xd8, 0x58, 0xf7,
+ 0xad, 0xb3, 0x7e, 0x38,
+ 0x86, 0x85, 0x78, 0x44
+ };
+
+ TEST_ASSERT(setup);
+ TEST_ONE_DIGEST(KEYID_A, DG_SZ, expectedA);
+ TEST_ONE_DIGEST(KEYID_B, DG_SZ, expectedB);
+#else /* ! OPENSSL follows */
+ TEST_IGNORE_MESSAGE("Skipping, no OPENSSL");
+#endif
+}
+
+
+#define SHAKE128_KEYID 7
+#undef KEYID_A
+#define KEYID_A SHAKE128_KEYID
+#undef DG_SZ
+#define DG_SZ 16
+#undef KEYID_B
+#define KEYID_B (KEYID_A + HEX_KEYID_OFFSET)
+void test_Digest_SHAKE128(void);
+void test_Digest_SHAKE128(void)
+{
+#ifdef OPENSSL
+ u_char expectedA[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_A,
+ 0x5c, 0x0c, 0x1a, 0x85,
+ 0xad, 0x03, 0xb2, 0x9a,
+ 0xe4, 0x75, 0x37, 0x93,
+ 0xaa, 0xa6, 0xcd, 0x76
+ };
+ u_char expectedB[MAX_MAC_LEN] =
+ {
+ 0, 0, 0, KEYID_B,
+ 0x07, 0x04, 0x63, 0xcc,
+ 0x46, 0xaf, 0xca, 0x00,
+ 0x7d, 0xd1, 0x5a, 0x39,
+ 0xfd, 0x34, 0xca, 0x10
+ };
+
+ TEST_ASSERT(setup);
+ TEST_ONE_DIGEST(KEYID_A, DG_SZ, expectedA);
+ TEST_ONE_DIGEST(KEYID_B, DG_SZ, expectedB);
+#else /* ! OPENSSL follows */
+ TEST_IGNORE_MESSAGE("Skipping, no OPENSSL");
+#endif
+}
+
+
+/*
+ * Dump a MAC in a form easy to cut and paste into the expected declaration.
+ */
+void dump_mac(
+ keyid_t keyid,
+ u_char * pmac,
+ size_t octets
+ )
+{
+ char dump[128];
+ size_t dc = 0;
+ size_t idx;
+
+ dc += snprintf(dump + dc, sizeof(dump) - dc, "digest with key %u { ", keyid);
+
+ for (idx = 0; idx < octets; idx++) {
+ if (10 == idx) {
+ msyslog(LOG_DEBUG, "%s", dump);
+ dc = 0;
+ }
+ if (dc < sizeof(dump)) {
+ dc += snprintf(dump + dc, sizeof(dump) - dc,
+ "0x%02x, ", pmac[idx]);
+ }
+ }
+
+ if (dc < sizeof(dump)) {
+ dc += snprintf(dump + dc, sizeof(dump) - dc, "}");
+ }
+
+ msyslog(LOG_DEBUG, "%s", dump);
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-03 15:42:52 +0000