[drivers] Add hmac/kmac tests for unaligned inputs

Add tests that ensure the hmac and kmac drivers properly handle
unaligned input messages.

Signed-off-by: Ellis Sarza-Nguyen <[email protected]>
(cherry picked from commit 7e07c8b)

Author: esnguyen

sw/device/silicon_creator/lib/drivers/BUILD

@@ -14,6 +14,7 @@ load(
 )
 load(
     "//rules/opentitan:defs.bzl",
+    "EARLGREY_CW340_TEST_ENVS",
     "EARLGREY_SILICON_OWNER_ROM_EXT_ENVS",
     "EARLGREY_TEST_ENVS",
     "fpga_params",
@@ -275,7 +276,10 @@ cc_test(
 opentitan_test(
     name = "hmac_functest",
     srcs = ["hmac_functest.c"],
-    exec_env = EARLGREY_TEST_ENVS,
+    exec_env = dicts.add(
+        EARLGREY_TEST_ENVS,
+        EARLGREY_CW340_TEST_ENVS,
+    ),
     verilator = verilator_params(
         timeout = "long",
     ),
@@ -422,7 +426,10 @@ cc_test(
 opentitan_test(
     name = "kmac_functest",
     srcs = ["kmac_functest.c"],
-    exec_env = EARLGREY_TEST_ENVS,
+    exec_env = dicts.add(
+        EARLGREY_TEST_ENVS,
+        EARLGREY_CW340_TEST_ENVS,
+    ),
     verilator = verilator_params(
         timeout = "long",
     ),

sw/device/silicon_creator/lib/drivers/hmac_functest.c

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
 // SPDX-License-Identifier: Apache-2.0
 
+#include <stdalign.h>
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -19,17 +20,18 @@
 
 #include "hw/top_earlgrey/sw/autogen/top_earlgrey.h"
 
-enum {
-  kSha256BlockBits = 512,
-  kSha256BlockBytes = kSha256BlockBits / 8,
-};
-
 // From: http://www.abrahamlincolnonline.org/lincoln/speeches/gettysburg.htm
-static const char kGettysburgPrelude[] =
+static alignas(uint32_t) const char kGettysburgPrelude[] =
     "Four score and seven years ago our fathers brought forth on this "
     "continent, a new nation, conceived in Liberty, and dedicated to the "
     "proposition that all men are created equal.";
 
+enum {
+  kSha256BlockBits = 512,
+  kSha256BlockBytes = kSha256BlockBits / 8,
+  kGettysburgPreludeSize = sizeof(kGettysburgPrelude),
+};
+
 // The following shell command will produce the sha256sum and convert the
 // digest into valid C hexadecimal constants:
 //
@@ -88,6 +90,21 @@ static const uint32_t kGettysburgHmacSha256Digest[] = {
     0xb54e0af5, 0x9d85e15b, 0xa9a3bafe, 0x9d115197,
 };
 
+// The unaligned version of the kGettysburgPrelude is used to test
+typedef struct unalignedhash {
+  char unused;
+  const char payload[kGettysburgPreludeSize];
+} unalignedhash_t;
+
+// This structure is used to ensure that the kGettysburgPrelude is not aligned
+// on a 4-byte boundary
+static const alignas(uint32_t) unalignedhash_t kGettysburgPreludeUnaligned = {
+    .payload =
+        "Four score and seven years ago our fathers brought forth on this "
+        "continent, a new nation, conceived in Liberty, and dedicated to the "
+        "proposition that all men are created equal.",
+};
+
 rom_error_t hmac_hmac_sha256_test(void) {
   hmac_digest_t digest;
   sc_hmac_hmac_sha256(kGettysburgPrelude, sizeof(kGettysburgPrelude) - 1,
@@ -103,6 +120,21 @@ rom_error_t hmac_hmac_sha256_test(void) {
   return kErrorOk;
 }
 
+rom_error_t hmac_hmac_sha256_unaligned_test(void) {
+  hmac_digest_t digest;
+  sc_hmac_hmac_sha256(kGettysburgPreludeUnaligned.payload,
+                      sizeof(kGettysburgPreludeUnaligned.payload) - 1, kHmacKey,
+                      /*big_endian_digest=*/false, &digest);
+  const size_t len = ARRAYSIZE(digest.digest);
+  for (int i = 0; i < len; ++i) {
+    LOG_INFO("word %d = 0x%08x", i, digest.digest[i]);
+    if (digest.digest[i] != kGettysburgHmacSha256Digest[i]) {
+      return kErrorUnknown;
+    }
+  }
+  return kErrorOk;
+}
+
 rom_error_t hmac_process_nowait_test(void) {
   hmac_digest_t digest;
   hmac_sha256_init();
@@ -292,6 +324,7 @@ OTTF_DEFINE_TEST_CONFIG();
 bool test_main(void) {
   status_t result = OK_STATUS();
   EXECUTE_TEST(result, hmac_sha256_test);
+  EXECUTE_TEST(result, hmac_hmac_sha256_unaligned_test);
   EXECUTE_TEST(result, hmac_hmac_sha256_test);
   EXECUTE_TEST(result, hmac_process_nowait_test);
   EXECUTE_TEST(result, hmac_process_wait_test);

sw/device/silicon_creator/lib/drivers/kmac_functest.c

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
 // SPDX-License-Identifier: Apache-2.0
 
+#include <stdalign.h>
 #include <stdbool.h>
 #include <stdint.h>
 
@@ -19,12 +20,32 @@
 
 OTTF_DEFINE_TEST_CONFIG();
 
+enum {
+  kShortDigestLen = 8,
+  kLongDigestLen = 75,
+  kShortMsgLen = 13,
+  kLongMsgLen = 26 * 4,
+};
+
+typedef struct unalignedhash {
+  char unused;
+  char short_payload[kShortMsgLen];
+  char long_payload[kLongMsgLen];
+} unalignedhash_t;
+
+static const alignas(uint32_t) unalignedhash_t kKmacTestData = {
+    .short_payload = "Test message!",
+    .long_payload =
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqr"
+        "stuv"
+        "wxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+};
+
 /**
  * Test data: short message with short output.
  */
 static const char short_msg[] = "Test message!";
-static const size_t short_msg_len = 13;
-static const uint32_t short_msg_digest[8] = {
+static const uint32_t short_msg_digest[kShortDigestLen] = {
     0x84f1c984, 0x7a0316bb, 0xe404cfed, 0x83f9078a,
     0x21491adc, 0xd6c30988, 0xc6822ff6, 0x20b73405,
 };
@@ -35,8 +56,7 @@ static const uint32_t short_msg_digest[8] = {
 static const char long_msg[] =
     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv"
     "wxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-static const size_t long_msg_len = 26 * 4;
-static const uint32_t long_msg_digest[75] = {
+static const uint32_t long_msg_digest[kLongDigestLen] = {
     0x262992ca, 0xe4790cf1, 0x7681c77f, 0xa5366b52, 0x86490a2f, 0xf072d4c9,
     0xd4ea499a, 0x7a192fd2, 0xe1156b59, 0xb8f00ad5, 0x2ff4ba7c, 0xdec27032,
     0x33624f74, 0x88836d86, 0x4c3c6982, 0xb9e841e1, 0x78acb95a, 0x0bdbc7bc,
@@ -80,14 +100,33 @@ rom_error_t kmac_shake256_test(void) {
   RETURN_IF_ERROR(kmac_shake256_configure());
 
   // Simple test.
-  RETURN_IF_ERROR(shake256_test(short_msg_len, short_msg,
+  RETURN_IF_ERROR(shake256_test(kShortMsgLen, short_msg,
                                 ARRAYSIZE(short_msg_digest), short_msg_digest));
 
   // Test with long input, short output.
-  RETURN_IF_ERROR(shake256_test(long_msg_len, long_msg, 1, long_msg_digest));
+  RETURN_IF_ERROR(shake256_test(kLongMsgLen, long_msg, 1, long_msg_digest));
 
   // Test with long input, long output.
-  RETURN_IF_ERROR(shake256_test(long_msg_len, long_msg,
+  RETURN_IF_ERROR(shake256_test(kLongMsgLen, long_msg,
+                                ARRAYSIZE(long_msg_digest), long_msg_digest));
+
+  return kErrorOk;
+}
+
+rom_error_t kmac_shake256_unalign_test(void) {
+  // Configure KMAC to run SHAKE-256.
+  RETURN_IF_ERROR(kmac_shake256_configure());
+
+  // Simple test for unalign.
+  RETURN_IF_ERROR(shake256_test(kShortMsgLen, kKmacTestData.short_payload,
+                                ARRAYSIZE(short_msg_digest), short_msg_digest));
+
+  // Test with unalign long input, short output.
+  RETURN_IF_ERROR(shake256_test(kLongMsgLen, kKmacTestData.long_payload, 1,
+                                long_msg_digest));
+
+  // Test with unalign long input, long output.
+  RETURN_IF_ERROR(shake256_test(kLongMsgLen, kKmacTestData.long_payload,
                                 ARRAYSIZE(long_msg_digest), long_msg_digest));
 
   return kErrorOk;
@@ -176,6 +215,7 @@ bool test_main(void) {
 
   status_t result = OK_STATUS();
   EXECUTE_TEST(result, kmac_shake256_test);
+  EXECUTE_TEST(result, kmac_shake256_unalign_test);
   EXECUTE_TEST(result, kmac_kmac256_kat_1);
   EXECUTE_TEST(result, kmac_kmac256_kat_2);
   EXECUTE_TEST(result, kmac_kmac256_kat_3);