[crypto/hmac/kmac] Clean HW upon bad status

Clean the HMAC and KMAC also on errors by using a cleanup attribute.

Signed-off-by: Siemen Dhooghe <sdhooghe@google.com>

Author: siemen11

sw/device/lib/crypto/drivers/hmac.c

@@ -175,6 +175,11 @@ static status_t clear(void) {
   return LAUNDERED_OTCRYPTO_OK;
 }
 
+/**
+ * Hardware wipe guard.
+ */
+static void hmac_wipe_guard(uint32_t *dummy) { (void)clear(); }
+
 /**
  * Write given key to HMAC HWIP.
  *
@@ -438,6 +443,8 @@ static status_t ensure_idle(void) {
 static status_t oneshot(const uint32_t cfg, const hmac_key_t *key,
                         const otcrypto_const_byte_buf_t *msg,
                         size_t digest_wordlen, uint32_t *digest) {
+  uint32_t hw_cleanup_guard __attribute__((cleanup(hmac_wipe_guard))) = 1;
+
   // Check that the block is idle.
   HARDENED_TRY(ensure_idle());
 
@@ -476,7 +483,7 @@ static status_t oneshot(const uint32_t cfg, const hmac_key_t *key,
 
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(msg));
 
-  return clear();
+  return OTCRYPTO_OK;
 }
 
 /**
@@ -825,6 +832,8 @@ hardened_bool_t hmac_key_integrity_checksum_check(const hmac_key_t *key) {
 }
 
 status_t hmac_update(hmac_ctx_t *ctx, const otcrypto_const_byte_buf_t *data) {
+  uint32_t hw_cleanup_guard __attribute__((cleanup(hmac_wipe_guard))) = 1;
+
   // If we don't have enough new bytes to fill a block, just update the partial
   // block and return.
   size_t block_bytelen = ctx->msg_block_wordlen * sizeof(uint32_t);
@@ -877,11 +886,12 @@ status_t hmac_update(hmac_ctx_t *ctx, const otcrypto_const_byte_buf_t *data) {
 
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(data));
 
-  // Clean up.
-  return clear();
+  return OTCRYPTO_OK;
 }
 
 status_t hmac_final(hmac_ctx_t *ctx, otcrypto_word32_buf_t *digest) {
+  uint32_t hw_cleanup_guard __attribute__((cleanup(hmac_wipe_guard))) = 1;
+
   // Restore context will restore the context and also hit start or continue
   // button as necessary.
   HARDENED_TRY(context_restore(ctx));
@@ -908,6 +918,5 @@ status_t hmac_final(hmac_ctx_t *ctx, otcrypto_word32_buf_t *digest) {
 
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(digest));
 
-  // Clean up.
-  return clear();
+  return OTCRYPTO_OK;
 }

sw/device/lib/crypto/drivers/kmac.c

@@ -152,6 +152,16 @@ OT_ASSERT_ENUM_VALUE(ARRAYSIZE(prefix_offsets), KMAC_PREFIX_MULTIREG_COUNT);
 // Ensure each PREFIX register is 4 bytes
 OT_ASSERT_ENUM_VALUE(32, KMAC_PREFIX_PREFIX_FIELD_WIDTH);
 
+/**
+ * Hardware wipe guard.
+ */
+static void kmac_wipe_guard(uint32_t *dummy) {
+  uint32_t cmd_reg = KMAC_CMD_REG_RESVAL;
+  cmd_reg = bitfield_field32_write(cmd_reg, KMAC_CMD_CMD_FIELD,
+                                   KMAC_CMD_CMD_VALUE_DONE);
+  abs_mmio_write32(kKmacBaseAddr + KMAC_CMD_REG_OFFSET, cmd_reg);
+}
+
 /**
  * Return the rate (in bytes) for given security strength.
  *
@@ -618,6 +628,9 @@ OT_WARN_UNUSED_RESULT
 static status_t kmac_process_msg_blocks(
     kmac_operation_t operation, const otcrypto_const_byte_buf_t *message,
     uint32_t *digest, size_t digest_len_bytes, hardened_bool_t masked_digest) {
+  // This variable guarantees kmac_wipe_guard() is called on exit.
+  uint32_t hw_cleanup_guard __attribute__((cleanup(kmac_wipe_guard))) = 1;
+
   // Block until KMAC is idle.
   HARDENED_TRY(wait_status_bit(KMAC_STATUS_SHA3_IDLE_BIT, 1));
 
@@ -756,12 +769,6 @@ static status_t kmac_process_msg_blocks(
   // Poll the status register until in the 'squeeze' state.
   HARDENED_TRY(wait_status_bit(KMAC_STATUS_SHA3_SQUEEZE_BIT, 1));
 
-  // Release the KMAC core, so that it goes back to idle mode
-  cmd_reg = KMAC_CMD_REG_RESVAL;
-  cmd_reg = bitfield_field32_write(cmd_reg, KMAC_CMD_CMD_FIELD,
-                                   KMAC_CMD_CMD_VALUE_DONE);
-  abs_mmio_write32(kKmacBaseAddr + KMAC_CMD_REG_OFFSET, cmd_reg);
-
   // Zero out the trailing bytes in the final word.
   size_t remainder_bytes = digest_len_bytes % sizeof(uint32_t);
   if (remainder_bytes > 0) {

sw/device/lib/crypto/impl/BUILD

@@ -318,6 +318,7 @@ cc_library(
         ":status",
         "//sw/device/lib/base:hardened_memory",
         "//sw/device/lib/base:math",
+        "//sw/device/lib/crypto/drivers:keymgr",
         "//sw/device/lib/crypto/drivers:kmac",
         "//sw/device/lib/crypto/drivers:rv_core_ibex",
         "//sw/device/lib/crypto/include:datatypes",

sw/device/lib/crypto/impl/kmac.c

@@ -14,6 +14,15 @@
 // Module ID for status codes.
 #define MODULE_ID MAKE_MODULE_ID('k', 'm', 'c')
 
+/**
+ * Sideload cleanup guard.
+ */
+static void sideload_wipe_guard(hardened_bool_t *is_sideloaded) {
+  if (*is_sideloaded == kHardenedBoolTrue) {
+    (void)keymgr_sideload_clear_kmac();
+  }
+}
+
 otcrypto_status_t otcrypto_kmac(
     otcrypto_blinded_key_t *key, const otcrypto_const_byte_buf_t *input_message,
     const otcrypto_const_byte_buf_t *customization_string,
@@ -39,6 +48,9 @@ otcrypto_status_t otcrypto_kmac(
   }
 #endif
 
+  hardened_bool_t is_sideloaded __attribute__((cleanup(sideload_wipe_guard))) =
+      kHardenedBoolFalse;
+
   // Ensure that tag buffer length and `required_output_len` match each other.
   size_t required_output_words =
       (required_output_len + sizeof(uint32_t) - 1) / sizeof(uint32_t);
@@ -71,6 +83,8 @@ otcrypto_status_t otcrypto_kmac(
     if (key_len != kKmacSideloadKeyLength / 8) {
       return OTCRYPTO_BAD_ARGS;
     }
+    is_sideloaded = kHardenedBoolTrue;
+
     // Configure keymgr with diversification input and then generate the
     // sideload key.
     keymgr_diversification_t diversification;
@@ -119,10 +133,6 @@ otcrypto_status_t otcrypto_kmac(
   // avoid that multiple cases were executed.
   HARDENED_CHECK_EQ(launder32(key_mode_used), key->config.key_mode);
 
-  if (key->config.hw_backed == kHardenedBoolTrue) {
-    HARDENED_TRY(keymgr_sideload_clear_kmac());
-  }
-
   // Verify the input buffer
   HARDENED_CHECK_EQ(kHardenedBoolTrue,
                     OTCRYPTO_CHECK_BUF(customization_string));

sw/device/lib/crypto/impl/kmac_kdf.c

@@ -6,6 +6,7 @@
 
 #include "sw/device/lib/base/hardened_memory.h"
 #include "sw/device/lib/base/math.h"
+#include "sw/device/lib/crypto/drivers/keymgr.h"
 #include "sw/device/lib/crypto/drivers/kmac.h"
 #include "sw/device/lib/crypto/impl/keyblob.h"
 #include "sw/device/lib/crypto/impl/status.h"
@@ -16,6 +17,15 @@
 // Module ID for status codes.
 #define MODULE_ID MAKE_MODULE_ID('k', 'k', 'd')
 
+/**
+ * Sideload cleanup guard.
+ */
+static void sideload_wipe_guard(hardened_bool_t *is_sideloaded) {
+  if (*is_sideloaded == kHardenedBoolTrue) {
+    (void)keymgr_sideload_clear_kmac();
+  }
+}
+
 otcrypto_status_t otcrypto_kmac_kdf(
     otcrypto_blinded_key_t *key_derivation_key,
     const otcrypto_const_byte_buf_t *label,
@@ -34,6 +44,10 @@ otcrypto_status_t otcrypto_kmac_kdf(
     return OTCRYPTO_BAD_ARGS;
   }
 #endif
+
+  hardened_bool_t is_sideloaded __attribute__((cleanup(sideload_wipe_guard))) =
+      kHardenedBoolFalse;
+
   // Because of KMAC HWIPs prefix limitation, `label` should not exceed
   // `kKmacCustStrMaxSize` bytes.
   if (label->len > kKmacCustStrMaxSize) {
@@ -75,6 +89,9 @@ otcrypto_status_t otcrypto_kmac_kdf(
         kKmacSideloadKeyLength / 8) {
       return OTCRYPTO_BAD_ARGS;
     }
+
+    is_sideloaded = kHardenedBoolTrue;
+
     // Configure keymgr with diversification input and then generate the
     // sideload key.
     keymgr_diversification_t diversification;
@@ -152,6 +169,5 @@ otcrypto_status_t otcrypto_kmac_kdf(
   output_key_material->checksum =
       otcrypto_integrity_blinded_checksum(output_key_material);
 
-  // Clear the KMAC sideload slot in case the key was sideloaded.
-  return otcrypto_eval_exit(keymgr_sideload_clear_kmac());
+  return otcrypto_eval_exit(OTCRYPTO_OK);
 }