[keymgr_dpe, sw] Add keymgr_dpe crypto lib test

This commit introduces the test for the `keymgr_dpe` driver inside
the crypto lib. It covers the basic `keymgr_dpe` features.

Add source / header file **without** linking them in the
appropriate BUILD file as some dependencies do not exist yet!

Signed-off-by: Raphael Roth <rroth@lowrisc.org>

Author: rroth-lowrisc

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

@@ -0,0 +1,212 @@
+// Copyright lowRISC contributors (OpenTitan project).
+// Licensed under the Apache License, Version 2.0, see LICENSE for details.
+// SPDX-License-Identifier: Apache-2.0
+
+#include "sw/device/lib/crypto/drivers/keymgr_dpe.h"
+
+#include "sw/device/lib/base/memory.h"
+#include "sw/device/lib/crypto/drivers/entropy.h"
+#include "sw/device/lib/crypto/impl/status.h"
+#include "sw/device/lib/runtime/log.h"
+#include "sw/device/lib/testing/keymgr_dpe_testutils.h"
+#include "sw/device/lib/testing/test_framework/check.h"
+#include "sw/device/lib/testing/test_framework/ottf_main.h"
+
+// Module ID for status codes.
+#define MODULE_ID MAKE_MODULE_ID('t', 's', 't')
+
+// Key diversification data for testing
+static const keymgr_dpe_diversification_t kTestDiversification = {
+    .salt =
+        {
+            0x00112233,
+            0x44556677,
+            0x8899aabb,
+            0xccddeeff,
+            0x00010203,
+            0x04050607,
+            0x08090a0b,
+            0x0c0d0e0f,
+        },
+    .version = 0x9,
+    // Need to match kOwnerKeyParams.slot_dst_sel in keymgr_dpe testutils
+    .slot_src_sel = 1};
+
+/**
+ * Setup keymgr dpe / entropy complex and advance to the OwnerRootKey.
+ *
+ * Run this test before any others.
+ */
+status_t test_setup(void) {
+  dif_keymgr_dpe_t keymgr_dpe;
+  dif_kmac_t kmac;
+  // Initialize the keymgr dpe and generate CreatorRootKey
+  TRY(keymgr_dpe_testutils_startup(&keymgr_dpe, &kmac));
+  // After startup the keymgr dpe state should be available
+  TRY(keymgr_dpe_testutils_check_state(&keymgr_dpe,
+                                       kDifKeymgrDpeStateAvailable));
+  // Generate Owner Int Key (Only one key).
+  TRY(keymgr_dpe_testutils_advance_state(&keymgr_dpe, &kOwnerIntKeyParams));
+  // Generate Owner Key (Only one key).
+  TRY(keymgr_dpe_testutils_advance_state(&keymgr_dpe, &kOwnerKeyParams));
+  // Initialize entropy complex, which the key manager dpe uses to clear
+  // sideloaded keys. The `keymgr_dpe_testutils_startup` function restarts the
+  // device, so this should happen afterwards.
+  return entropy_complex_init();
+}
+
+/**
+ * Test generating a single software-visible key.
+ *
+ * This test just checks that the key generation process finished without
+ * errors, without performing any validation on the key.
+ */
+status_t sw_single_key_test(void) {
+  keymgr_dpe_output_t key;
+  return keymgr_dpe_generate_key_sw(kTestDiversification, &key);
+}
+
+/**
+ * Test generating a single sideloaded AES key.
+ *
+ * This test just checks that the key generation process finished without
+ * errors, without actually attempting to use the key.
+ */
+status_t aes_basic_test(void) {
+  return keymgr_dpe_generate_key_aes(kTestDiversification);
+}
+
+/**
+ * Test generating a single sideloaded KMAC key.
+ *
+ * This test just checks that the key generation process finished without
+ * errors, without actually attempting to use the key.
+ */
+status_t kmac_basic_test(void) {
+  return keymgr_dpe_generate_key_kmac(kTestDiversification);
+}
+
+/**
+ * Test generating a single sideloaded OTBN key.
+ *
+ * This test just checks that the key generation process finished without
+ * errors, without actually attempting to use the key.
+ */
+status_t otbn_basic_test(void) {
+  return keymgr_dpe_generate_key_otbn(kTestDiversification);
+}
+
+/**
+ * Check whether two key manager dpe output values are equivalent.
+ *
+ * Unmasks both keys and compares their unmasked values; masking should not
+ * affect this comparison.
+ *
+ * @param key1 First key manager output.
+ * @param key2 Second key manager output.
+ * @return true if the keys are equivalent, false otherwise.
+ */
+static bool output_equiv(keymgr_dpe_output_t key1, keymgr_dpe_output_t key2) {
+  for (size_t i = 0; i < kKeymgrDPEOutputShareNumWords; i++) {
+    uint32_t word1 = key1.share0[i] ^ key1.share1[i];
+    uint32_t word2 = key2.share0[i] ^ key2.share1[i];
+    if (word1 != word2) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Test generating software-visible keys with different salts.
+ *
+ * Different salts should produce different keys; the same salt should produce
+ * the same key but with different masking.
+ */
+status_t sw_keys_change_salt_test(void) {
+  // Copy the test data into a mutable structure.
+  keymgr_dpe_diversification_t div;
+  memcpy(div.salt, kTestDiversification.salt, sizeof(div.salt));
+  div.version = kTestDiversification.version;
+  div.slot_src_sel = kTestDiversification.slot_src_sel;
+
+  // Generate a key.
+  keymgr_dpe_output_t key1;
+  TRY(keymgr_dpe_generate_key_sw(div, &key1));
+
+  // Change the salt and generate the key again.
+  div.salt[0]++;
+  keymgr_dpe_output_t key2;
+  TRY(keymgr_dpe_generate_key_sw(div, &key2));
+
+  // Check that the keys are distinct.
+  TRY_CHECK(!output_equiv(key1, key2));
+
+  // Change the salt back to its original value and generate a third time.
+  div.salt[0]--;
+  keymgr_dpe_output_t key3;
+  TRY(keymgr_dpe_generate_key_sw(div, &key3));
+
+  // Check that the key is the equivalent to the first key when unmasked.
+  TRY_CHECK(output_equiv(key1, key3));
+
+  // Check that the masking on the equivalent keys is different.
+  TRY_CHECK_ARRAYS_NE(key1.share0, key3.share0, sizeof(key1.share0));
+
+  return OK_STATUS();
+}
+
+/**
+ * Test generating software-visible keys with different versions.
+ *
+ * Different versions should produce different keys; the same version should
+ * produce the same key but with different masking.
+ */
+status_t sw_keys_change_version_test(void) {
+  // Copy the test data into a mutable structure.
+  keymgr_dpe_diversification_t div;
+  memcpy(div.salt, kTestDiversification.salt, sizeof(div.salt));
+  div.version = kTestDiversification.version;
+  div.slot_src_sel = kTestDiversification.slot_src_sel;
+
+  // Generate a key.
+  keymgr_dpe_output_t key1;
+  TRY(keymgr_dpe_generate_key_sw(div, &key1));
+
+  // Change the version and generate the key again.
+  div.version++;
+  keymgr_dpe_output_t key2;
+  TRY(keymgr_dpe_generate_key_sw(div, &key2));
+
+  // Check that the keys are distinct.
+  TRY_CHECK(!output_equiv(key1, key2));
+
+  // Change the version back to its original value and generate a third time.
+  div.version--;
+  keymgr_dpe_output_t key3;
+  TRY(keymgr_dpe_generate_key_sw(div, &key3));
+
+  // Check that the key is the equivalent to the first key when unmasked.
+  TRY_CHECK(output_equiv(key1, key3));
+
+  // Check that the masking on the equivalent keys is different.
+  TRY_CHECK_ARRAYS_NE(key1.share0, key3.share0, sizeof(key1.share0));
+
+  return OK_STATUS();
+}
+
+OTTF_DEFINE_TEST_CONFIG();
+
+bool test_main(void) {
+  static status_t result;
+
+  EXECUTE_TEST(result, test_setup);
+  EXECUTE_TEST(result, sw_single_key_test);
+  EXECUTE_TEST(result, sw_keys_change_salt_test);
+  EXECUTE_TEST(result, sw_keys_change_version_test);
+  EXECUTE_TEST(result, aes_basic_test);
+  EXECUTE_TEST(result, kmac_basic_test);
+  EXECUTE_TEST(result, otbn_basic_test);
+
+  return status_ok(result);
+}