[crypto/gcm] Cleanup GCM

Cleanup the HW and sensitive variables in the GCM logic also when a bad
status is thrown.

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

Author: siemen11

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

@@ -42,6 +42,28 @@ enum {
   kAesGcmContextNumWords = sizeof(aes_gcm_context_t) / sizeof(uint32_t),
 };
 
+/**
+ * Consolidated state for AES-GCM operations.
+ */
+typedef struct {
+  aes_key_t aes_key;
+  aes_gcm_context_t internal_ctx;
+} aes_gcm_impl_state_t;
+
+static_assert(
+    sizeof(aes_gcm_impl_state_t) % sizeof(uint32_t) == 0,
+    "GCM State struct must be a multiple of the word size for memshred.");
+
+/**
+ * Cleanup function for AES-GCM.
+ */
+static void cleanup_gcm_state(aes_gcm_impl_state_t *state) {
+  (void)aes_clear();
+  (void)keymgr_sideload_clear_aes();
+  hardened_memshred((uint32_t *)state,
+                    sizeof(aes_gcm_impl_state_t) / sizeof(uint32_t));
+}
+
 /**
  * Save an AES-GCM context.
  *
@@ -252,30 +274,6 @@ static status_t load_key_if_sideloaded(const aes_key_t key) {
   return keymgr_generate_key_aes(diversification);
 }
 
-/**
- * Clear the sideload slot if the AES key was sideloaded.
- *
- * It is important to clear the sideload slot before returning to the caller so
- * that other applications can't access the key in between operations.
- *
- * If the key is not a sideloaded key, this function does nothing.
- *
- * @param key Key that was possibly loaded.
- * @return OK or errror.
- */
-static status_t clear_key_if_sideloaded(const aes_key_t key) {
-  if (launder32(key.sideload) == kHardenedBoolFalse) {
-    HARDENED_CHECK_EQ(key.sideload, launder32(kHardenedBoolFalse));
-    return OTCRYPTO_OK;
-  } else if (launder32(key.sideload) != kHardenedBoolTrue) {
-    // COVERAGE (SW ERR) This is an internal function, the aes key's sideload is
-    // set internal by good parameters.
-    return OTCRYPTO_BAD_ARGS;
-  }
-  HARDENED_CHECK_EQ(key.sideload, launder32(kHardenedBoolTrue));
-  return keymgr_sideload_clear_aes();
-}
-
 otcrypto_status_t otcrypto_aes_gcm_encrypt(
     otcrypto_blinded_key_t *key, const otcrypto_const_byte_buf_t *plaintext,
     const otcrypto_const_word32_buf_t *iv, const otcrypto_const_byte_buf_t *aad,
@@ -300,6 +298,8 @@ otcrypto_status_t otcrypto_aes_gcm_encrypt(
   }
 #endif
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Ensure the plaintext and ciphertext lengths match.
   if (launder32(ciphertext->len) != plaintext->len) {
     return OTCRYPTO_BAD_ARGS;
@@ -313,18 +313,15 @@ otcrypto_status_t otcrypto_aes_gcm_encrypt(
   HARDENED_TRY(hardened_memshred(auth_tag->data, auth_tag->len));
 
   // Construct the AES key.
-  aes_key_t aes_key;
-  HARDENED_TRY(aes_gcm_key_construct(key, &aes_key));
-  HARDENED_TRY(load_key_if_sideloaded(aes_key));
+  HARDENED_TRY(aes_gcm_key_construct(key, &state.aes_key));
+  HARDENED_TRY(load_key_if_sideloaded(state.aes_key));
 
   // Call the core encryption operation.
-  HARDENED_TRY(aes_gcm_encrypt(aes_key, iv->len, iv->data, plaintext->len,
+  HARDENED_TRY(aes_gcm_encrypt(state.aes_key, iv->len, iv->data, plaintext->len,
                                plaintext->data, aad->len, aad->data,
                                auth_tag->len, key->config.security_level,
                                auth_tag->data, ciphertext->data));
 
-  HARDENED_TRY(clear_key_if_sideloaded(aes_key));
-
   // Verify the input buffers
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(plaintext));
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(iv));
@@ -359,10 +356,11 @@ otcrypto_status_t otcrypto_aes_gcm_decrypt(
   }
 #endif
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Construct the AES key.
-  aes_key_t aes_key;
-  HARDENED_TRY(aes_gcm_key_construct(key, &aes_key));
-  HARDENED_TRY(load_key_if_sideloaded(aes_key));
+  HARDENED_TRY(aes_gcm_key_construct(key, &state.aes_key));
+  HARDENED_TRY(load_key_if_sideloaded(state.aes_key));
 
   // Ensure the plaintext and ciphertext lengths match.
   if (launder32(ciphertext->len) != plaintext->len) {
@@ -374,12 +372,10 @@ otcrypto_status_t otcrypto_aes_gcm_decrypt(
   HARDENED_TRY(aes_gcm_check_tag_length(auth_tag->len, tag_len));
 
   // Call the core decryption operation.
-  HARDENED_TRY(aes_gcm_decrypt(aes_key, iv->len, iv->data, ciphertext->len,
-                               ciphertext->data, aad->len, aad->data,
-                               auth_tag->len, auth_tag->data, plaintext->data,
-                               key->config.security_level, success));
-
-  HARDENED_TRY(clear_key_if_sideloaded(aes_key));
+  HARDENED_TRY(aes_gcm_decrypt(
+      state.aes_key, iv->len, iv->data, ciphertext->len, ciphertext->data,
+      aad->len, aad->data, auth_tag->len, auth_tag->data, plaintext->data,
+      key->config.security_level, success));
 
   // Verify the input buffers
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(plaintext));
@@ -401,19 +397,19 @@ otcrypto_status_t otcrypto_aes_gcm_encrypt_init(
   }
 #endif
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Construct the AES key.
-  aes_key_t aes_key;
-  HARDENED_TRY(aes_gcm_key_construct(key, &aes_key));
-  HARDENED_TRY(load_key_if_sideloaded(aes_key));
+  HARDENED_TRY(aes_gcm_key_construct(key, &state.aes_key));
+  HARDENED_TRY(load_key_if_sideloaded(state.aes_key));
 
   // Call the internal init operation.
-  aes_gcm_context_t internal_ctx;
-  internal_ctx.security_level = key->config.security_level;
-  HARDENED_TRY(aes_gcm_encrypt_init(aes_key, iv->len, iv->data, &internal_ctx));
+  state.internal_ctx.security_level = key->config.security_level;
+  HARDENED_TRY(aes_gcm_encrypt_init(state.aes_key, iv->len, iv->data,
+                                    &state.internal_ctx));
 
-  // Save the context and clear the key if needed.
-  HARDENED_TRY(gcm_context_save(&internal_ctx, ctx));
-  HARDENED_TRY(clear_key_if_sideloaded(internal_ctx.key));
+  // Save the context.
+  HARDENED_TRY(gcm_context_save(&state.internal_ctx, ctx));
 
   // Verify the input buffer
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(iv));
@@ -431,19 +427,19 @@ otcrypto_status_t otcrypto_aes_gcm_decrypt_init(
   }
 #endif
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Construct the AES key.
-  aes_key_t aes_key;
-  HARDENED_TRY(aes_gcm_key_construct(key, &aes_key));
-  HARDENED_TRY(load_key_if_sideloaded(aes_key));
+  HARDENED_TRY(aes_gcm_key_construct(key, &state.aes_key));
+  HARDENED_TRY(load_key_if_sideloaded(state.aes_key));
 
   // Call the internal init operation.
-  aes_gcm_context_t internal_ctx;
-  internal_ctx.security_level = key->config.security_level;
-  HARDENED_TRY(aes_gcm_decrypt_init(aes_key, iv->len, iv->data, &internal_ctx));
+  state.internal_ctx.security_level = key->config.security_level;
+  HARDENED_TRY(aes_gcm_decrypt_init(state.aes_key, iv->len, iv->data,
+                                    &state.internal_ctx));
 
-  // Save the context and clear the key if needed.
-  HARDENED_TRY(gcm_context_save(&internal_ctx, ctx));
-  HARDENED_TRY(clear_key_if_sideloaded(internal_ctx.key));
+  // Save the context.
+  HARDENED_TRY(gcm_context_save(&state.internal_ctx, ctx));
 
   // Verify the input buffer
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(iv));
@@ -465,17 +461,17 @@ otcrypto_status_t otcrypto_aes_gcm_update_aad(
     return OTCRYPTO_OK;
   }
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Restore the AES-GCM context object and load the key if needed.
-  aes_gcm_context_t internal_ctx;
-  HARDENED_TRY(gcm_context_restore(ctx, &internal_ctx));
-  HARDENED_TRY(load_key_if_sideloaded(internal_ctx.key));
+  HARDENED_TRY(gcm_context_restore(ctx, &state.internal_ctx));
+  HARDENED_TRY(load_key_if_sideloaded(state.internal_ctx.key));
 
   // Call the internal update operation.
-  HARDENED_TRY(aes_gcm_update_aad(&internal_ctx, aad->len, aad->data));
+  HARDENED_TRY(aes_gcm_update_aad(&state.internal_ctx, aad->len, aad->data));
 
-  // Save the context and clear the key if needed.
-  HARDENED_TRY(gcm_context_save(&internal_ctx, ctx));
-  HARDENED_TRY(clear_key_if_sideloaded(internal_ctx.key));
+  // Save the context.
+  HARDENED_TRY(gcm_context_save(&state.internal_ctx, ctx));
 
   // Verify the input buffer
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(aad));
@@ -500,16 +496,17 @@ otcrypto_status_t otcrypto_aes_gcm_update_encrypted_data(
     return OTCRYPTO_OK;
   }
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Restore the AES-GCM context object and load the key if needed.
-  aes_gcm_context_t internal_ctx;
-  HARDENED_TRY(gcm_context_restore(ctx, &internal_ctx));
-  HARDENED_TRY(load_key_if_sideloaded(internal_ctx.key));
+  HARDENED_TRY(gcm_context_restore(ctx, &state.internal_ctx));
+  HARDENED_TRY(load_key_if_sideloaded(state.internal_ctx.key));
   // Remask the key if it is not sideloaded.
-  HARDENED_TRY(gcm_remask_key(&internal_ctx));
+  HARDENED_TRY(gcm_remask_key(&state.internal_ctx));
 
   // The output buffer must be long enough to hold all full blocks that will
   // exist after `input` is added.
-  size_t partial_block_len = internal_ctx.input_len % kAesBlockNumBytes;
+  size_t partial_block_len = state.internal_ctx.input_len % kAesBlockNumBytes;
   if (input->len > UINT32_MAX - partial_block_len) {
     // COVERAGE (MISSING) We do not cover too short output buffers.
     return OTCRYPTO_BAD_ARGS;
@@ -522,13 +519,12 @@ otcrypto_status_t otcrypto_aes_gcm_update_encrypted_data(
   }
 
   // Call the internal update operation.
-  HARDENED_TRY(aes_gcm_update_encrypted_data(&internal_ctx, input->len,
+  HARDENED_TRY(aes_gcm_update_encrypted_data(&state.internal_ctx, input->len,
                                              input->data, output_bytes_written,
                                              output->data));
 
-  // Save the context and clear the key if needed.
-  HARDENED_TRY(gcm_context_save(&internal_ctx, ctx));
-  HARDENED_TRY(clear_key_if_sideloaded(internal_ctx.key));
+  // Save the context.
+  HARDENED_TRY(gcm_context_save(&state.internal_ctx, ctx));
 
   // Verify the input buffers
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(input));
@@ -559,28 +555,28 @@ otcrypto_status_t otcrypto_aes_gcm_encrypt_final(
   // Randomize the tag before the operation.
   HARDENED_TRY(hardened_memshred(auth_tag->data, auth_tag->len));
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Restore the AES-GCM context object and load the key if needed.
-  aes_gcm_context_t internal_ctx;
-  HARDENED_TRY(gcm_context_restore(ctx, &internal_ctx));
-  HARDENED_TRY(load_key_if_sideloaded(internal_ctx.key));
+  HARDENED_TRY(gcm_context_restore(ctx, &state.internal_ctx));
+  HARDENED_TRY(load_key_if_sideloaded(state.internal_ctx.key));
   // Remask the key if it is not sideloaded.
-  HARDENED_TRY(gcm_remask_key(&internal_ctx));
+  HARDENED_TRY(gcm_remask_key(&state.internal_ctx));
 
   // If the partial block is nonempty, the output must be at least as long as
   // the partial block.
-  size_t partial_block_len = internal_ctx.input_len % kAesBlockNumBytes;
+  size_t partial_block_len = state.internal_ctx.input_len % kAesBlockNumBytes;
   if (ciphertext->len < partial_block_len) {
     return OTCRYPTO_BAD_ARGS;
   }
 
   // Call the internal final operation.
-  HARDENED_TRY(aes_gcm_encrypt_final(&internal_ctx, auth_tag->len,
+  HARDENED_TRY(aes_gcm_encrypt_final(&state.internal_ctx, auth_tag->len,
                                      auth_tag->data, ciphertext_bytes_written,
                                      ciphertext->data));
 
-  // Clear the context and the key if needed.
+  // Clear the context
   HARDENED_TRY(hardened_memshred(ctx->data, ARRAYSIZE(ctx->data)));
-  HARDENED_TRY(clear_key_if_sideloaded(internal_ctx.key));
 
   // Verify the input buffers
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(ciphertext));
@@ -609,28 +605,28 @@ otcrypto_status_t otcrypto_aes_gcm_decrypt_final(
   // Check the tag length.
   HARDENED_TRY(aes_gcm_check_tag_length(auth_tag->len, tag_len));
 
+  aes_gcm_impl_state_t state __attribute__((cleanup(cleanup_gcm_state))) = {0};
+
   // Restore the AES-GCM context object and load the key if needed.
-  aes_gcm_context_t internal_ctx;
-  HARDENED_TRY(gcm_context_restore(ctx, &internal_ctx));
-  HARDENED_TRY(load_key_if_sideloaded(internal_ctx.key));
+  HARDENED_TRY(gcm_context_restore(ctx, &state.internal_ctx));
+  HARDENED_TRY(load_key_if_sideloaded(state.internal_ctx.key));
   // Remask the key if it is not sideloaded.
-  HARDENED_TRY(gcm_remask_key(&internal_ctx));
+  HARDENED_TRY(gcm_remask_key(&state.internal_ctx));
 
   // If the partial block is nonempty, the output must be at least as long as
   // the partial block.
-  size_t partial_block_len = internal_ctx.input_len % kAesBlockNumBytes;
+  size_t partial_block_len = state.internal_ctx.input_len % kAesBlockNumBytes;
   if (plaintext->len < partial_block_len) {
     return OTCRYPTO_BAD_ARGS;
   }
 
   // Call the internal final operation.
-  HARDENED_TRY(aes_gcm_decrypt_final(&internal_ctx, auth_tag->len,
+  HARDENED_TRY(aes_gcm_decrypt_final(&state.internal_ctx, auth_tag->len,
                                      auth_tag->data, plaintext_bytes_written,
                                      plaintext->data, success));
 
-  // Clear the context and the key if needed.
+  // Clear the context
   HARDENED_TRY(hardened_memshred(ctx->data, ARRAYSIZE(ctx->data)));
-  HARDENED_TRY(clear_key_if_sideloaded(internal_ctx.key));
 
   // Verify the input buffers
   HARDENED_CHECK_EQ(kHardenedBoolTrue, OTCRYPTO_CHECK_BUF(auth_tag));