[Cryptech-Commits] [user/sra/libhal] 10/15: First pass on hash test code.
git at cryptech.is
git at cryptech.is
Mon May 25 21:04:25 UTC 2015
This is an automated email from the git hooks/post-receive script.
sra at hactrn.net pushed a commit to branch master
in repository user/sra/libhal.
commit e4a7f76368954edb2622d9b9f333f6b6ef6001e1
Author: Rob Austein <sra at hactrn.net>
Date: Sun May 24 16:31:12 2015 -0400
First pass on hash test code.
---
tests/Makefile.in | 2 +-
tests/test-hash.c | 196 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 197 insertions(+), 1 deletion(-)
diff --git a/tests/Makefile.in b/tests/Makefile.in
index f63e4fc..ba45a57 100644
--- a/tests/Makefile.in
+++ b/tests/Makefile.in
@@ -2,7 +2,7 @@
INC = ../cryptech.h
LIB = ../libcryptech.a
-BIN = test-aes-key-wrap
+BIN = test-aes-key-wrap test-hash
CC = @CC@
CFLAGS = @CFLAGS@ -I..
diff --git a/tests/test-hash.c b/tests/test-hash.c
new file mode 100644
index 0000000..c13e49c
--- /dev/null
+++ b/tests/test-hash.c
@@ -0,0 +1,196 @@
+/*
+ * Test code for hash cores.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+#include <cryptech.h>
+
+/* Usual NIST sample messages. */
+
+static const uint8_t nist_512_single[] = { /* 3 bytes */
+ 0x61, 0x62, 0x63
+};
+
+static const uint8_t sha1_single_digest[] = { /* 40 bytes */
+ 0x61, 0x39, 0x39, 0x39, 0x33, 0x65, 0x33, 0x36, 0x34, 0x37, 0x30, 0x36,
+ 0x38, 0x31, 0x36, 0x61, 0x62, 0x61, 0x33, 0x65, 0x32, 0x35, 0x37, 0x31,
+ 0x37, 0x38, 0x35, 0x30, 0x63, 0x32, 0x36, 0x63, 0x39, 0x63, 0x64, 0x30,
+ 0x64, 0x38, 0x39, 0x64
+};
+
+static const uint8_t sha256_single_digest[] = { /* 64 bytes */
+ 0x62, 0x61, 0x37, 0x38, 0x31, 0x36, 0x62, 0x66, 0x38, 0x66, 0x30, 0x31,
+ 0x63, 0x66, 0x65, 0x61, 0x34, 0x31, 0x34, 0x31, 0x34, 0x30, 0x64, 0x65,
+ 0x35, 0x64, 0x61, 0x65, 0x32, 0x32, 0x32, 0x33, 0x62, 0x30, 0x30, 0x33,
+ 0x36, 0x31, 0x61, 0x33, 0x39, 0x36, 0x31, 0x37, 0x37, 0x61, 0x39, 0x63,
+ 0x62, 0x34, 0x31, 0x30, 0x66, 0x66, 0x36, 0x31, 0x66, 0x32, 0x30, 0x30,
+ 0x31, 0x35, 0x61, 0x64
+};
+
+static const uint8_t nist_512_double[] = { /* 56 bytes */
+ 0x61, 0x62, 0x63, 0x64, 0x62, 0x63, 0x64, 0x65, 0x63, 0x64, 0x65, 0x66,
+ 0x64, 0x65, 0x66, 0x67, 0x65, 0x66, 0x67, 0x68, 0x66, 0x67, 0x68, 0x69,
+ 0x67, 0x68, 0x69, 0x6a, 0x68, 0x69, 0x6a, 0x6b, 0x69, 0x6a, 0x6b, 0x6c,
+ 0x6a, 0x6b, 0x6c, 0x6d, 0x6b, 0x6c, 0x6d, 0x6e, 0x6c, 0x6d, 0x6e, 0x6f,
+ 0x6d, 0x6e, 0x6f, 0x70, 0x6e, 0x6f, 0x70, 0x71
+};
+
+static const uint8_t sha1_double_digest[] = { /* 40 bytes */
+ 0x38, 0x34, 0x39, 0x38, 0x33, 0x65, 0x34, 0x34, 0x31, 0x63, 0x33, 0x62,
+ 0x64, 0x32, 0x36, 0x65, 0x62, 0x61, 0x61, 0x65, 0x34, 0x61, 0x61, 0x31,
+ 0x66, 0x39, 0x35, 0x31, 0x32, 0x39, 0x65, 0x35, 0x65, 0x35, 0x34, 0x36,
+ 0x37, 0x30, 0x66, 0x31
+};
+
+static const uint8_t sha256_double_digest[] = { /* 64 bytes */
+ 0x32, 0x34, 0x38, 0x64, 0x36, 0x61, 0x36, 0x31, 0x64, 0x32, 0x30, 0x36,
+ 0x33, 0x38, 0x62, 0x38, 0x65, 0x35, 0x63, 0x30, 0x32, 0x36, 0x39, 0x33,
+ 0x30, 0x63, 0x33, 0x65, 0x36, 0x30, 0x33, 0x39, 0x61, 0x33, 0x33, 0x63,
+ 0x65, 0x34, 0x35, 0x39, 0x36, 0x34, 0x66, 0x66, 0x32, 0x31, 0x36, 0x37,
+ 0x66, 0x36, 0x65, 0x63, 0x65, 0x64, 0x64, 0x34, 0x31, 0x39, 0x64, 0x62,
+ 0x30, 0x36, 0x63, 0x31
+};
+
+static const uint8_t nist_1024_single[] = { /* 3 bytes */
+ 0x61, 0x62, 0x63
+};
+
+static const uint8_t sha384_single_digest[] = { /* 96 bytes */
+ 0x63, 0x62, 0x30, 0x30, 0x37, 0x35, 0x33, 0x66, 0x34, 0x35, 0x61, 0x33,
+ 0x35, 0x65, 0x38, 0x62, 0x62, 0x35, 0x61, 0x30, 0x33, 0x64, 0x36, 0x39,
+ 0x39, 0x61, 0x63, 0x36, 0x35, 0x30, 0x30, 0x37, 0x32, 0x37, 0x32, 0x63,
+ 0x33, 0x32, 0x61, 0x62, 0x30, 0x65, 0x64, 0x65, 0x64, 0x31, 0x36, 0x33,
+ 0x31, 0x61, 0x38, 0x62, 0x36, 0x30, 0x35, 0x61, 0x34, 0x33, 0x66, 0x66,
+ 0x35, 0x62, 0x65, 0x64, 0x38, 0x30, 0x38, 0x36, 0x30, 0x37, 0x32, 0x62,
+ 0x61, 0x31, 0x65, 0x37, 0x63, 0x63, 0x32, 0x33, 0x35, 0x38, 0x62, 0x61,
+ 0x65, 0x63, 0x61, 0x31, 0x33, 0x34, 0x63, 0x38, 0x32, 0x35, 0x61, 0x37
+};
+
+static const uint8_t sha512_single_digest[] = { /* 128 bytes */
+ 0x64, 0x64, 0x61, 0x66, 0x33, 0x35, 0x61, 0x31, 0x39, 0x33, 0x36, 0x31,
+ 0x37, 0x61, 0x62, 0x61, 0x63, 0x63, 0x34, 0x31, 0x37, 0x33, 0x34, 0x39,
+ 0x61, 0x65, 0x32, 0x30, 0x34, 0x31, 0x33, 0x31, 0x31, 0x32, 0x65, 0x36,
+ 0x66, 0x61, 0x34, 0x65, 0x38, 0x39, 0x61, 0x39, 0x37, 0x65, 0x61, 0x32,
+ 0x30, 0x61, 0x39, 0x65, 0x65, 0x65, 0x65, 0x36, 0x34, 0x62, 0x35, 0x35,
+ 0x64, 0x33, 0x39, 0x61, 0x32, 0x31, 0x39, 0x32, 0x39, 0x39, 0x32, 0x61,
+ 0x32, 0x37, 0x34, 0x66, 0x63, 0x31, 0x61, 0x38, 0x33, 0x36, 0x62, 0x61,
+ 0x33, 0x63, 0x32, 0x33, 0x61, 0x33, 0x66, 0x65, 0x65, 0x62, 0x62, 0x64,
+ 0x34, 0x35, 0x34, 0x64, 0x34, 0x34, 0x32, 0x33, 0x36, 0x34, 0x33, 0x63,
+ 0x65, 0x38, 0x30, 0x65, 0x32, 0x61, 0x39, 0x61, 0x63, 0x39, 0x34, 0x66,
+ 0x61, 0x35, 0x34, 0x63, 0x61, 0x34, 0x39, 0x66
+};
+
+static const uint8_t nist_1024_double[] = { /* 112 bytes */
+ 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x62, 0x63, 0x64, 0x65,
+ 0x66, 0x67, 0x68, 0x69, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
+ 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x65, 0x66, 0x67, 0x68,
+ 0x69, 0x6a, 0x6b, 0x6c, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
+ 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x68, 0x69, 0x6a, 0x6b,
+ 0x6c, 0x6d, 0x6e, 0x6f, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70,
+ 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x6b, 0x6c, 0x6d, 0x6e,
+ 0x6f, 0x70, 0x71, 0x72, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
+ 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x6e, 0x6f, 0x70, 0x71,
+ 0x72, 0x73, 0x74, 0x75
+};
+
+static const uint8_t sha384_double_digest[] = { /* 96 bytes */
+ 0x30, 0x39, 0x33, 0x33, 0x30, 0x63, 0x33, 0x33, 0x66, 0x37, 0x31, 0x31,
+ 0x34, 0x37, 0x65, 0x38, 0x33, 0x64, 0x31, 0x39, 0x32, 0x66, 0x63, 0x37,
+ 0x38, 0x32, 0x63, 0x64, 0x31, 0x62, 0x34, 0x37, 0x35, 0x33, 0x31, 0x31,
+ 0x31, 0x62, 0x31, 0x37, 0x33, 0x62, 0x33, 0x62, 0x30, 0x35, 0x64, 0x32,
+ 0x32, 0x66, 0x61, 0x30, 0x38, 0x30, 0x38, 0x36, 0x65, 0x33, 0x62, 0x30,
+ 0x66, 0x37, 0x31, 0x32, 0x66, 0x63, 0x63, 0x37, 0x63, 0x37, 0x31, 0x61,
+ 0x35, 0x35, 0x37, 0x65, 0x32, 0x64, 0x62, 0x39, 0x36, 0x36, 0x63, 0x33,
+ 0x65, 0x39, 0x66, 0x61, 0x39, 0x31, 0x37, 0x34, 0x36, 0x30, 0x33, 0x39
+};
+
+static const uint8_t sha512_double_digest[] = { /* 128 bytes */
+ 0x38, 0x65, 0x39, 0x35, 0x39, 0x62, 0x37, 0x35, 0x64, 0x61, 0x65, 0x33,
+ 0x31, 0x33, 0x64, 0x61, 0x38, 0x63, 0x66, 0x34, 0x66, 0x37, 0x32, 0x38,
+ 0x31, 0x34, 0x66, 0x63, 0x31, 0x34, 0x33, 0x66, 0x38, 0x66, 0x37, 0x37,
+ 0x37, 0x39, 0x63, 0x36, 0x65, 0x62, 0x39, 0x66, 0x37, 0x66, 0x61, 0x31,
+ 0x37, 0x32, 0x39, 0x39, 0x61, 0x65, 0x61, 0x64, 0x62, 0x36, 0x38, 0x38,
+ 0x39, 0x30, 0x31, 0x38, 0x35, 0x30, 0x31, 0x64, 0x32, 0x38, 0x39, 0x65,
+ 0x34, 0x39, 0x30, 0x30, 0x66, 0x37, 0x65, 0x34, 0x33, 0x33, 0x31, 0x62,
+ 0x39, 0x39, 0x64, 0x65, 0x63, 0x34, 0x62, 0x35, 0x34, 0x33, 0x33, 0x61,
+ 0x63, 0x37, 0x64, 0x33, 0x32, 0x39, 0x65, 0x65, 0x62, 0x36, 0x64, 0x64,
+ 0x32, 0x36, 0x35, 0x34, 0x35, 0x65, 0x39, 0x36, 0x65, 0x35, 0x35, 0x62,
+ 0x38, 0x37, 0x34, 0x62, 0x65, 0x39, 0x30, 0x39
+};
+
+static int test_hash(hal_error_t (*hash)(void *, const uint8_t *, const size_t, uint8_t *, const size_t),
+ const uint8_t * const data, const size_t data_len,
+ const uint8_t * const result, const size_t result_len,
+ const char * const comment)
+{
+ uint8_t state[512], digest[512];
+ hal_error_t err;
+
+ assert(hash != NULL && data != NULL && result != NULL);
+
+ assert(result_len <= sizeof(digest) && hal_hash_state_size() <= sizeof(state));
+
+ if (comment != NULL)
+ printf("%s\n", comment);
+
+ printf("Initializing state\n");
+ hal_hash_state_initialize(state);
+
+ printf("Hashing data %lu bytes of data\n", (unsigned long) data_len);
+ if ((err = hash(state, data, data_len, NULL, 0)) != HAL_OK) {
+ printf("Failed: %s\n", hal_error_string(err));
+ return 0;
+ }
+
+ printf("Finalizing hash and reading %lu bytes of result\n", (unsigned long) result_len);
+ if ((err = hash(state, NULL, 0, digest, sizeof(digest))) != HAL_OK) {
+ printf("Failed: %s\n", hal_error_string(err));
+ return 0;
+ }
+
+ printf("Comparing result with known value");
+ if (memcmp(result, digest, result_len)) {
+ printf("MISMATCH\n");
+ return 0;
+ }
+
+ printf("OK\n");
+ return 1;
+}
+
+int main (int argc, char *argv[])
+{
+ int ok = 1;
+
+ /*
+ * Missing some tests here because I started from the Cryptlib test
+ * script, which skips the 224 and 256 options of the SHA-512 core.
+ */
+
+ ok &= test_hash(hal_hash_sha1, nist_512_single, sizeof(nist_512_single), sha1_single_digest, sizeof(sha1_single_digest),
+ "SHA-1 single block test");
+ ok &= test_hash(hal_hash_sha1, nist_512_double, sizeof(nist_512_double), sha1_double_digest, sizeof(sha1_double_digest),
+ "SHA-1 double block test");
+
+ ok &= test_hash(hal_hash_sha256, nist_512_single, sizeof(nist_512_single), sha256_single_digest, sizeof(sha256_single_digest),
+ "SHA-256 single block test");
+ ok &= test_hash(hal_hash_sha256, nist_512_double, sizeof(nist_512_double), sha256_double_digest, sizeof(sha256_double_digest),
+ "SHA-256 double block test");
+
+ ok &= test_hash(hal_hash_sha384, nist_1024_single, sizeof(nist_1024_single), sha384_single_digest, sizeof(sha384_single_digest),
+ "SHA-384 single block test");
+ ok &= test_hash(hal_hash_sha384, nist_1024_double, sizeof(nist_1024_double), sha384_double_digest, sizeof(sha384_double_digest),
+ "SHA-384 double block test");
+
+ ok &= test_hash(hal_hash_sha512, nist_1024_single, sizeof(nist_1024_single), sha512_single_digest, sizeof(sha512_single_digest),
+ "SHA-512 single block test");
+ ok &= test_hash(hal_hash_sha512, nist_1024_double, sizeof(nist_1024_double), sha512_double_digest, sizeof(sha512_double_digest),
+ "SHA-512 double block test");
+
+ return !ok;
+}
More information about the Commits
mailing list