dif_keymgr_unittest.cc

// 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/dif/dif_keymgr.h"
 
#include <array>
 
#include "gtest/gtest.h"
#include "sw/device/lib/base/mmio.h"
#include "sw/device/lib/base/mock_mmio.h"
#include "sw/device/lib/dif/dif_base.h"
#include "sw/device/lib/dif/dif_test_base.h"
 
#include "keymgr_regs.h"  // Generated
 
namespace dif_keymgr_unittest {
namespace {
 
/**
 * Returns a `uint32_t` with a single zero bit.
 */
uint32_t AllOnesExcept(uint32_t index) { return ~(1u << index); }
 
/**
 * Returns a vector of values for a given enum type.
 *
 * Assumes that the values are sequential and the first value is 0. `last` must
 * be the last valid value for the given enum and is included in the returned
 * vector.
 */
template <typename T>
std::vector<T> CreateEnumVector(T last) {
  using TT = typename std::underlying_type<T>::type;
  std::vector<T> res;
  for (TT i = 0; i <= static_cast<TT>(last); ++i) {
    res.push_back(static_cast<T>(i));
  }
  return res;
}
 
/**
 * Returns a seemingly valid, i.e. nonzero, pointer for the given type or a
 * `nullptr`.
 */
template <typename T>
T *GetGoodBadPtrArg(bool is_good) {
  if (is_good) {
    return reinterpret_cast<T *>(alignof(T));
  } else {
    return nullptr;
  }
}
 
/**
 * Returns a valid or invalid value for the given enum type.
 *
 * `last` must be the last valid value of the given enum type and `last+1` must
 * be an invalid value.
 */
template <typename T>
T GetGoodBadEnumArg(bool is_good, T last) {
  if (is_good) {
    return last;
  } else {
    return static_cast<T>(last + 1);
  }
}
 
/**
 * Constants used in tests.
 */
static constexpr std::array<uint32_t, 3> kStatesWithOperationalNextStates{
    KEYMGR_WORKING_STATE_STATE_VALUE_INIT,
    KEYMGR_WORKING_STATE_STATE_VALUE_CREATOR_ROOT_KEY,
    KEYMGR_WORKING_STATE_STATE_VALUE_OWNER_INTERMEDIATE_KEY,
};
static constexpr std::array<uint32_t, 4> kStatesWithNonOperationalNextStates{
    KEYMGR_WORKING_STATE_STATE_VALUE_RESET,
    KEYMGR_WORKING_STATE_STATE_VALUE_OWNER_KEY,
    KEYMGR_WORKING_STATE_STATE_VALUE_DISABLED,
    KEYMGR_WORKING_STATE_STATE_VALUE_INVALID,
};
 
class DifKeymgrTest : public testing::Test, public mock_mmio::MmioTest {};
 
/**
 * Class for parameterizing bad argument tests for functions with two arguments.
 */
class BadArgsTwo : public DifKeymgrTest,
                   public testing::WithParamInterface<std::tuple<bool, bool>> {
 protected:
  bool AllParamsGood() {
    return std::get<0>(GetParam()) && std::get<1>(GetParam());
  }
 
  void SetUp() override {
    if (AllParamsGood()) {
      // Only test negative cases.
      GTEST_SKIP();
    }
  }
};
 
INSTANTIATE_TEST_SUITE_P(
    BadArgsTwo, BadArgsTwo, testing::Combine(testing::Bool(), testing::Bool()),
    [&](testing::TestParamInfo<std::tuple<bool, bool>> info) {
      auto stringify = [](bool foo) { return foo ? "Good" : "Bad"; };
      std::stringstream ss;
      ss << stringify(std::get<0>(info.param))
         << stringify(std::get<1>(info.param));
      return ss.str();
    });
 
/**
 * Base class for the rest of the tests in this file, provides a
 * `dif_keymgr_t` instance and some methods for common expectations.
 */
class DifKeymgrInitialized : public DifKeymgrTest {
 protected:
  /**
   * Expectations for an idle key manager.
   */
  void ExpectIdle() {
    EXPECT_READ32(KEYMGR_OP_STATUS_REG_OFFSET,
                  {{
                      .offset = KEYMGR_OP_STATUS_STATUS_OFFSET,
                      .value = KEYMGR_OP_STATUS_STATUS_VALUE_IDLE,
                  }});
    EXPECT_READ32(KEYMGR_CFG_REGWEN_REG_OFFSET,
                  {{
                      .offset = KEYMGR_CFG_REGWEN_EN_BIT,
                      .value = 1,
                  }});
  }
 
  /**
   * Expectations for an idle key manager at a given state.
   */
  void ExpectIdleAtState(uint32_t state) {
    ExpectIdle();
    EXPECT_READ32(KEYMGR_WORKING_STATE_REG_OFFSET,
                  {{
                      .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                      .value = state,
                  }});
  }
 
  /**
   * Expectations for a busy key manager.
   */
  void ExpectBusy() {
    EXPECT_READ32(KEYMGR_OP_STATUS_REG_OFFSET,
                  {{
                      .offset = KEYMGR_OP_STATUS_STATUS_OFFSET,
                      .value = KEYMGR_OP_STATUS_STATUS_VALUE_WIP,
                  }});
  }
 
  /**
   * Expectations for a locked CONFIG register.
   */
  void ExpectLockedConfig() {
    EXPECT_READ32(KEYMGR_OP_STATUS_REG_OFFSET,
                  {{
                      .offset = KEYMGR_OP_STATUS_STATUS_OFFSET,
                      .value = KEYMGR_OP_STATUS_STATUS_VALUE_IDLE,
                  }});
    EXPECT_READ32(KEYMGR_CFG_REGWEN_REG_OFFSET,
                  AllOnesExcept(KEYMGR_CFG_REGWEN_EN_BIT));
  }
 
  struct OperationStartParams {
    uint32_t dest_sel;
    uint32_t operation;
    dif_keymgr_cdi_type_t cdi_type;
  };
 
  /**
   * Expectations for starting an operation.
   */
  void ExpectOperationStart(const OperationStartParams &params) {
    EXPECT_WRITE32_SHADOWED(
        KEYMGR_CONTROL_SHADOWED_REG_OFFSET,
        {{
             .offset = KEYMGR_CONTROL_SHADOWED_DEST_SEL_OFFSET,
             .value = params.dest_sel,
         },
         {
             .offset = KEYMGR_CONTROL_SHADOWED_OPERATION_OFFSET,
             .value = params.operation,
         },
         {
             .offset = KEYMGR_CONTROL_SHADOWED_CDI_SEL_BIT,
             .value = params.cdi_type,
         }});
 
    EXPECT_WRITE32(KEYMGR_START_REG_OFFSET, {{
                                                .offset = KEYMGR_START_EN_BIT,
                                                .value = 1,
                                            }});
  }
 
  /**
   * Initialized `dif_keymgr_t` used in tests.
   */
  const dif_keymgr_t keymgr_ = {.base_addr = dev().region()};
};
 
class ConfigureTest : public DifKeymgrInitialized {};
 
TEST_F(ConfigureTest, BadArgs) {
  EXPECT_DIF_BADARG(dif_keymgr_configure(nullptr, {}));
}
 
TEST_F(ConfigureTest, Configure) {
  constexpr dif_keymgr_config_t kConfig = {.entropy_reseed_interval = 0xA5A5};
 
  EXPECT_WRITE32_SHADOWED(KEYMGR_RESEED_INTERVAL_SHADOWED_REG_OFFSET,
                          kConfig.entropy_reseed_interval);
 
  EXPECT_DIF_OK(dif_keymgr_configure(&keymgr_, kConfig));
}
 
class AdvanceStateTest : public DifKeymgrInitialized {
 protected:
  dif_keymgr_state_params_t kStateParams{
      .binding_value = {0xFF, 0xC3, 0xB9, 0xA5, 0x00, 0x3C, 0x46, 0x5A},
      .max_key_version = 0xA5A5A5A5,
  };
 
  struct MaxKeyVersionRegInfo {
    uint32_t offset;
    uint32_t wen_offset;
    uint32_t wen_bit_index;
  };
 
  /**
   * Returns max key version register information for the given state.
   */
  MaxKeyVersionRegInfo GetMaxKeyVersionRegInfo(uint32_t state) {
    switch (state) {
      case KEYMGR_WORKING_STATE_STATE_VALUE_INIT:
        return {
            .offset = KEYMGR_MAX_CREATOR_KEY_VER_SHADOWED_REG_OFFSET,
            .wen_offset = KEYMGR_MAX_CREATOR_KEY_VER_REGWEN_REG_OFFSET,
            .wen_bit_index = KEYMGR_MAX_CREATOR_KEY_VER_REGWEN_EN_BIT,
        };
      case KEYMGR_WORKING_STATE_STATE_VALUE_CREATOR_ROOT_KEY:
        return {
            .offset = KEYMGR_MAX_OWNER_INT_KEY_VER_SHADOWED_REG_OFFSET,
            .wen_offset = KEYMGR_MAX_OWNER_INT_KEY_VER_REGWEN_REG_OFFSET,
            .wen_bit_index = KEYMGR_MAX_OWNER_INT_KEY_VER_REGWEN_EN_BIT,
        };
      case KEYMGR_WORKING_STATE_STATE_VALUE_OWNER_INTERMEDIATE_KEY:
        return {
            .offset = KEYMGR_MAX_OWNER_KEY_VER_SHADOWED_REG_OFFSET,
            .wen_offset = KEYMGR_MAX_OWNER_KEY_VER_REGWEN_REG_OFFSET,
            .wen_bit_index = KEYMGR_MAX_OWNER_KEY_VER_REGWEN_EN_BIT,
        };
      default:
        ADD_FAILURE();
        abort();
        break;
    }
  }
};
 
TEST_F(AdvanceStateTest, BadArgsNoKeymgr) {
  EXPECT_DIF_BADARG(dif_keymgr_advance_state(nullptr, &kStateParams));
  EXPECT_DIF_BADARG(dif_keymgr_advance_state(nullptr, nullptr));
}
 
class AdvanceToOperational : public AdvanceStateTest,
                             public testing::WithParamInterface<uint32_t> {};
 
TEST_P(AdvanceToOperational, BadArgsToOperationalWithoutParams) {
  ExpectIdleAtState(GetParam());
 
  EXPECT_DIF_BADARG(dif_keymgr_advance_state(&keymgr_, nullptr));
}
 
INSTANTIATE_TEST_SUITE_P(AdvanceToOperational, AdvanceToOperational,
                         testing::ValuesIn(kStatesWithOperationalNextStates));
 
class AdvanceToNonOperational : public AdvanceStateTest,
                                public testing::WithParamInterface<uint32_t> {};
 
TEST_P(AdvanceToNonOperational, BadArgsToNonOperationalWithParams) {
  ExpectIdleAtState(GetParam());
 
  EXPECT_DIF_BADARG(dif_keymgr_advance_state(&keymgr_, &kStateParams));
}
 
INSTANTIATE_TEST_SUITE_P(
    AdvanceToNonOperational, AdvanceToNonOperational,
    testing::ValuesIn(kStatesWithNonOperationalNextStates));
 
TEST_F(AdvanceStateTest, LockedBusy) {
  ExpectBusy();
 
  EXPECT_EQ(dif_keymgr_advance_state(&keymgr_, &kStateParams), kDifLocked);
}
 
TEST_F(AdvanceStateTest, LockedConfig) {
  ExpectLockedConfig();
 
  EXPECT_EQ(dif_keymgr_advance_state(&keymgr_, &kStateParams), kDifLocked);
}
 
TEST_P(AdvanceToOperational, LockedBinding) {
  ExpectIdleAtState(GetParam());
  EXPECT_READ32(KEYMGR_SW_BINDING_REGWEN_REG_OFFSET, 0);
 
  EXPECT_EQ(dif_keymgr_advance_state(&keymgr_, &kStateParams), kDifLocked);
}
 
TEST_P(AdvanceToOperational, LockedMaxKeyVersion) {
  ExpectIdleAtState(GetParam());
  EXPECT_READ32(KEYMGR_SW_BINDING_REGWEN_REG_OFFSET,
                {{
                    .offset = KEYMGR_SW_BINDING_REGWEN_EN_BIT,
                    .value = 1,
                }});
  EXPECT_READ32(GetMaxKeyVersionRegInfo(GetParam()).wen_offset, 0);
 
  EXPECT_EQ(dif_keymgr_advance_state(&keymgr_, &kStateParams), kDifLocked);
}
 
TEST_P(AdvanceToOperational, Success) {
  ExpectIdleAtState(GetParam());
  EXPECT_READ32(KEYMGR_SW_BINDING_REGWEN_REG_OFFSET,
                {{
                    .offset = KEYMGR_SW_BINDING_REGWEN_EN_BIT,
                    .value = 1,
                }});
  auto reg_info = GetMaxKeyVersionRegInfo(GetParam());
  EXPECT_READ32(reg_info.wen_offset, {{
                                         .offset = reg_info.wen_bit_index,
                                         .value = 1,
                                     }});
  size_t binding_len = sizeof(kStateParams.binding_value) /
                       sizeof(kStateParams.binding_value[0]);
  for (size_t i = 0; i < binding_len; ++i) {
    EXPECT_WRITE32(KEYMGR_SEALING_SW_BINDING_0_REG_OFFSET + i * 4,
                   kStateParams.binding_value[i]);
  }
  EXPECT_WRITE32(KEYMGR_SW_BINDING_REGWEN_REG_OFFSET, 0);
  EXPECT_WRITE32_SHADOWED(reg_info.offset, kStateParams.max_key_version);
  EXPECT_WRITE32(reg_info.wen_offset, 0);
  ExpectOperationStart({
      .dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_NONE,
      .operation = KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_ADVANCE,
  });
 
  EXPECT_DIF_OK(dif_keymgr_advance_state(&keymgr_, &kStateParams));
}
 
TEST_P(AdvanceToNonOperational, Success) {
  ExpectIdleAtState(GetParam());
  ExpectOperationStart({
      .dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_NONE,
      .operation = KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_ADVANCE,
  });
 
  EXPECT_DIF_OK(dif_keymgr_advance_state(&keymgr_, nullptr));
}
 
class DisableTest : public DifKeymgrInitialized {};
 
TEST_F(DisableTest, BadArgs) { EXPECT_DIF_BADARG(dif_keymgr_disable(nullptr)); }
 
TEST_F(DisableTest, LockedBusy) {
  ExpectBusy();
  EXPECT_EQ(dif_keymgr_disable(&keymgr_), kDifLocked);
}
 
TEST_F(DisableTest, LockedConfig) {
  ExpectLockedConfig();
 
  EXPECT_EQ(dif_keymgr_disable(&keymgr_), kDifLocked);
}
 
TEST_F(DisableTest, Disable) {
  ExpectIdle();
  ExpectOperationStart({
      .dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_NONE,
      .operation = KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_DISABLE,
  });
 
  EXPECT_DIF_OK(dif_keymgr_disable(&keymgr_));
}
 
TEST_P(BadArgsTwo, GetStatusCodes) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto status_codes =
      GetGoodBadPtrArg<dif_keymgr_status_codes_t>(std::get<1>(GetParam()));
 
  EXPECT_DIF_BADARG(dif_keymgr_get_status_codes(keymgr, status_codes));
}
 
struct GetStatusCodesTestCase {
  /**
   * Values of OP_STATUS or ERR_CODE registers.
   */
  std::vector<mock_mmio::BitField> reg_val;
  /**
   * Expected output of `dif_keymgr_get_status_codes()`.
   */
  dif_keymgr_status_codes_t exp_val;
};
 
class GetStatusCodesNoError
    : public DifKeymgrInitialized,
      public testing::WithParamInterface<GetStatusCodesTestCase> {};
 
TEST_P(GetStatusCodesNoError, Success) {
  uint32_t reg_val = mock_mmio::ToInt<uint32_t>(GetParam().reg_val);
  EXPECT_READ32(KEYMGR_OP_STATUS_REG_OFFSET, reg_val);
  if (reg_val == KEYMGR_OP_STATUS_STATUS_VALUE_DONE_SUCCESS ||
      reg_val == KEYMGR_OP_STATUS_STATUS_VALUE_DONE_ERROR) {
    EXPECT_WRITE32(KEYMGR_OP_STATUS_REG_OFFSET, reg_val);
  }
 
  if (reg_val == KEYMGR_OP_STATUS_STATUS_VALUE_DONE_ERROR) {
    EXPECT_READ32(KEYMGR_ERR_CODE_REG_OFFSET, 5);
    EXPECT_WRITE32(KEYMGR_ERR_CODE_REG_OFFSET, 5);
  }
 
  dif_keymgr_status_codes_t act_val;
  EXPECT_DIF_OK(dif_keymgr_get_status_codes(&keymgr_, &act_val));
  EXPECT_EQ(GetParam().exp_val, act_val);
}
 
INSTANTIATE_TEST_SUITE_P(
    GetStatusCodesNoError, GetStatusCodesNoError,
    testing::Values(
        GetStatusCodesTestCase{
            .reg_val = {{
                .offset = KEYMGR_OP_STATUS_STATUS_OFFSET,
                .value = KEYMGR_OP_STATUS_STATUS_VALUE_IDLE,
            }},
            .exp_val = kDifKeymgrStatusCodeIdle,
        },
        GetStatusCodesTestCase{
            .reg_val = {{
                .offset = KEYMGR_OP_STATUS_STATUS_OFFSET,
                .value = KEYMGR_OP_STATUS_STATUS_VALUE_DONE_SUCCESS,
            }},
            .exp_val = kDifKeymgrStatusCodeIdle,
        },
        GetStatusCodesTestCase{
            .reg_val = {{
                .offset = KEYMGR_OP_STATUS_STATUS_OFFSET,
                .value = KEYMGR_OP_STATUS_STATUS_VALUE_DONE_ERROR,
            }},
            .exp_val = kDifKeymgrStatusCodeIdle |
                       kDifKeymgrStatusCodeInvalidKmacOutput |
                       kDifKeymgrStatusCodeInvalidOperation,
        },
        GetStatusCodesTestCase{
            .reg_val = {{
                .offset = KEYMGR_OP_STATUS_STATUS_OFFSET,
                .value = KEYMGR_OP_STATUS_STATUS_VALUE_WIP,
            }},
            .exp_val = 0,
        }));
 
class GetStatusCodesWithError
    : public DifKeymgrInitialized,
      public testing::WithParamInterface<GetStatusCodesTestCase> {};
 
TEST_P(GetStatusCodesWithError, Success) {
  EXPECT_READ32(KEYMGR_OP_STATUS_REG_OFFSET,
                KEYMGR_OP_STATUS_STATUS_VALUE_DONE_ERROR);
  EXPECT_WRITE32(KEYMGR_OP_STATUS_REG_OFFSET,
                 KEYMGR_OP_STATUS_STATUS_VALUE_DONE_ERROR);
  EXPECT_READ32(KEYMGR_ERR_CODE_REG_OFFSET, GetParam().reg_val);
  EXPECT_WRITE32(KEYMGR_ERR_CODE_REG_OFFSET, GetParam().reg_val);
 
  dif_keymgr_status_codes_t act_val;
  EXPECT_DIF_OK(dif_keymgr_get_status_codes(&keymgr_, &act_val));
  EXPECT_EQ(GetParam().exp_val, act_val);
}
 
INSTANTIATE_TEST_SUITE_P(
    GetStatusCodesWithError, GetStatusCodesWithError,
    testing::Values(
        GetStatusCodesTestCase{
            .reg_val = {{
                .offset = KEYMGR_ERR_CODE_INVALID_OP_BIT,
                .value = 1,
            }},
            .exp_val = kDifKeymgrStatusCodeIdle |
                       kDifKeymgrStatusCodeInvalidOperation,
        },
        GetStatusCodesTestCase{
            .reg_val = {{
                .offset = KEYMGR_ERR_CODE_INVALID_KMAC_INPUT_BIT,
                .value = 1,
            }},
            .exp_val = kDifKeymgrStatusCodeIdle |
                       kDifKeymgrStatusCodeInvalidKmacInput,
        },
        GetStatusCodesTestCase{
            .reg_val = {{
                            .offset = KEYMGR_ERR_CODE_INVALID_OP_BIT,
                            .value = 1,
                        },
                        {
                            .offset = KEYMGR_ERR_CODE_INVALID_KMAC_INPUT_BIT,
                            .value = 1,
                        }},
            .exp_val = kDifKeymgrStatusCodeIdle |
                       kDifKeymgrStatusCodeInvalidOperation |
                       kDifKeymgrStatusCodeInvalidKmacInput,
        }));
 
class GetStateTest : public DifKeymgrInitialized {};
 
TEST_P(BadArgsTwo, GetState) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto state = GetGoodBadPtrArg<dif_keymgr_state_t>(std::get<1>(GetParam()));
 
  EXPECT_DIF_BADARG(dif_keymgr_get_state(keymgr, state));
}
 
struct GetStateTestCase {
  /**
   * Value of the WORKING_STATE register.
   */
  std::vector<mock_mmio::BitField> reg_val;
  /**
   * Expected output of `dif_keymgr_get_state()`.
   */
  dif_keymgr_state_t exp_output;
};
 
class GetState : public GetStateTest,
                 public testing::WithParamInterface<GetStateTestCase> {};
 
TEST_P(GetState, Success) {
  EXPECT_READ32(KEYMGR_WORKING_STATE_REG_OFFSET, GetParam().reg_val);
 
  dif_keymgr_state_t state;
  EXPECT_DIF_OK(dif_keymgr_get_state(&keymgr_, &state));
  EXPECT_EQ(state, GetParam().exp_output);
}
 
INSTANTIATE_TEST_SUITE_P(
    AllValidStates, GetState,
    testing::Values(
        GetStateTestCase{
            .reg_val = {{
                .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                .value = KEYMGR_WORKING_STATE_STATE_VALUE_RESET,
            }},
            .exp_output = kDifKeymgrStateReset,
        },
        GetStateTestCase{
            .reg_val = {{
                .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                .value = KEYMGR_WORKING_STATE_STATE_VALUE_INIT,
            }},
            .exp_output = kDifKeymgrStateInitialized,
        },
        GetStateTestCase{
            .reg_val = {{
                .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                .value = KEYMGR_WORKING_STATE_STATE_VALUE_CREATOR_ROOT_KEY,
            }},
            .exp_output = kDifKeymgrStateCreatorRootKey,
        },
        GetStateTestCase{
            .reg_val = {{
                .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                .value =
                    KEYMGR_WORKING_STATE_STATE_VALUE_OWNER_INTERMEDIATE_KEY,
            }},
            .exp_output = kDifKeymgrStateOwnerIntermediateKey,
        },
        GetStateTestCase{
            .reg_val = {{
                .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                .value = KEYMGR_WORKING_STATE_STATE_VALUE_OWNER_KEY,
            }},
            .exp_output = kDifKeymgrStateOwnerRootKey,
        },
        GetStateTestCase{
            .reg_val = {{
                .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                .value = KEYMGR_WORKING_STATE_STATE_VALUE_DISABLED,
            }},
            .exp_output = kDifKeymgrStateDisabled,
        },
        GetStateTestCase{
            .reg_val = {{
                .offset = KEYMGR_WORKING_STATE_STATE_OFFSET,
                .value = KEYMGR_WORKING_STATE_STATE_VALUE_INVALID,
            }},
            .exp_output = kDifKeymgrStateInvalid,
        }));
 
TEST_F(GetStateTest, UnexpectedState) {
  EXPECT_READ32(KEYMGR_WORKING_STATE_REG_OFFSET,
                KEYMGR_WORKING_STATE_STATE_MASK);
 
  dif_keymgr_state_t state;
  EXPECT_EQ(dif_keymgr_get_state(&keymgr_, &state), kDifError);
}
 
class GenerateIdentityTest : public DifKeymgrInitialized {};
 
TEST_F(GenerateIdentityTest, BadArgs) {
  EXPECT_DIF_BADARG(dif_keymgr_generate_identity_seed(nullptr, {}));
}
 
TEST_F(GenerateIdentityTest, LockedBusy) {
  ExpectBusy();
 
  EXPECT_EQ(dif_keymgr_generate_identity_seed(&keymgr_, {}), kDifLocked);
}
 
TEST_F(GenerateIdentityTest, LockedConfig) {
  ExpectLockedConfig();
 
  EXPECT_EQ(dif_keymgr_generate_identity_seed(&keymgr_, {}), kDifLocked);
}
 
TEST_F(GenerateIdentityTest, GenerateSealing) {
  ExpectIdle();
  ExpectOperationStart({
      .dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_NONE,
      .operation = KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_ID,
      .cdi_type = kDifKeymgrSealingCdi,
  });
 
  EXPECT_DIF_OK(dif_keymgr_generate_identity_seed(
      &keymgr_, {.cdi_type = kDifKeymgrSealingCdi}));
}
 
TEST_F(GenerateIdentityTest, GenerateAttestation) {
  ExpectIdle();
  ExpectOperationStart({
      .dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_NONE,
      .operation = KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_ID,
      .cdi_type = kDifKeymgrAttestationCdi,
  });
 
  EXPECT_DIF_OK(dif_keymgr_generate_identity_seed(
      &keymgr_, {.cdi_type = kDifKeymgrAttestationCdi}));
}
 
class GenerateVersionedKeyTest : public DifKeymgrInitialized {};
 
TEST_P(BadArgsTwo, GenerateVersionedKey) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto dest = GetGoodBadEnumArg<dif_keymgr_versioned_key_dest_t>(
      std::get<1>(GetParam()), kDifKeymgrVersionedKeyDestLast);
 
  EXPECT_DIF_BADARG(dif_keymgr_generate_versioned_key(keymgr, {.dest = dest}));
}
 
TEST_F(GenerateVersionedKeyTest, LockedBusy) {
  ExpectBusy();
 
  EXPECT_EQ(dif_keymgr_generate_versioned_key(&keymgr_, {}), kDifLocked);
}
 
TEST_F(GenerateVersionedKeyTest, LockedConfig) {
  ExpectLockedConfig();
 
  EXPECT_EQ(dif_keymgr_generate_versioned_key(&keymgr_, {}), kDifLocked);
}
 
struct GenerateVersionedKeyTestCase {
  /**
   * Destination of the generated key.
   */
  dif_keymgr_versioned_key_dest_t dest;
  /**
   * Expected DEST_SEL value to be written to the CONTROL register.
   */
  uint32_t exp_dest_sel;
  /**
   * Expected OPERATION values to be written to the CONTROL register.
   */
  uint32_t exp_operation;
  /**
   * Expected CDI_SEL value to be written to the CONTROL register.
   */
  dif_keymgr_cdi_type_t cdi_type;
};
 
class GenerateVersionedKey
    : public GenerateVersionedKeyTest,
      public testing::WithParamInterface<GenerateVersionedKeyTestCase> {};
 
TEST_P(GenerateVersionedKey, Success) {
  dif_keymgr_versioned_key_params_t params{
      .dest = GetParam().dest,
      .salt = {0x5A, 0x46, 0x3C, 0x00, 0xA5, 0xB9, 0xC3, 0xFF},
      .version = 0xA5A5A5A5,
  };
 
  ExpectIdle();
  size_t salt_len = sizeof(params.salt) / sizeof(params.salt[0]);
  for (size_t i = 0; i < salt_len; ++i) {
    EXPECT_WRITE32(KEYMGR_SALT_0_REG_OFFSET + i * 4, params.salt[i]);
  }
  EXPECT_WRITE32(KEYMGR_KEY_VERSION_REG_OFFSET, params.version);
  ExpectOperationStart({
      .dest_sel = GetParam().exp_dest_sel,
      .operation = GetParam().exp_operation,
  });
 
  EXPECT_DIF_OK(dif_keymgr_generate_versioned_key(&keymgr_, params));
}
 
INSTANTIATE_TEST_SUITE_P(
    GenerateVersionedKeyAllDests, GenerateVersionedKey,
    testing::Values(
        GenerateVersionedKeyTestCase{
            .dest = kDifKeymgrVersionedKeyDestSw,
            .exp_dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_NONE,
            .exp_operation =
                KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_SW_OUTPUT,
            .cdi_type = kDifKeymgrSealingCdi,
        },
        GenerateVersionedKeyTestCase{
            .dest = kDifKeymgrVersionedKeyDestAes,
            .exp_dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_AES,
            .exp_operation =
                KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_HW_OUTPUT,
            .cdi_type = kDifKeymgrSealingCdi,
        },
        GenerateVersionedKeyTestCase{
            .dest = kDifKeymgrVersionedKeyDestKmac,
            .exp_dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_KMAC,
            .exp_operation =
                KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_HW_OUTPUT,
            .cdi_type = kDifKeymgrSealingCdi,
        },
        GenerateVersionedKeyTestCase{
            .dest = kDifKeymgrVersionedKeyDestSw,
            .exp_dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_NONE,
            .exp_operation =
                KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_SW_OUTPUT,
            .cdi_type = kDifKeymgrAttestationCdi,
        },
        GenerateVersionedKeyTestCase{
            .dest = kDifKeymgrVersionedKeyDestAes,
            .exp_dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_AES,
            .exp_operation =
                KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_HW_OUTPUT,
            .cdi_type = kDifKeymgrAttestationCdi,
        },
        GenerateVersionedKeyTestCase{
            .dest = kDifKeymgrVersionedKeyDestKmac,
            .exp_dest_sel = KEYMGR_CONTROL_SHADOWED_DEST_SEL_VALUE_KMAC,
            .exp_operation =
                KEYMGR_CONTROL_SHADOWED_OPERATION_VALUE_GENERATE_HW_OUTPUT,
            .cdi_type = kDifKeymgrAttestationCdi,
        }));
 
class SideloadClearTest : public DifKeymgrInitialized {};
 
TEST_P(BadArgsTwo, GetBadArg) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto state = GetGoodBadPtrArg<dif_toggle_t>(std::get<1>(GetParam()));
 
  EXPECT_DIF_BADARG(dif_keymgr_sideload_clear_get_enabled(keymgr, state));
}
 
TEST_P(BadArgsTwo, SetBadArg) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto state = GetGoodBadEnumArg<dif_toggle_t>(std::get<1>(GetParam()),
                                               kDifToggleEnabled);
 
  EXPECT_DIF_BADARG(dif_keymgr_sideload_clear_set_enabled(keymgr, state));
}
 
TEST_F(SideloadClearTest, Set) {
  EXPECT_WRITE32(KEYMGR_SIDELOAD_CLEAR_REG_OFFSET,
                 {{
                     .offset = KEYMGR_SIDELOAD_CLEAR_VAL_OFFSET,
                     .value = kDifKeyMgrSideLoadClearAll,
                 }});
  EXPECT_DIF_OK(
      dif_keymgr_sideload_clear_set_enabled(&keymgr_, kDifToggleEnabled));
 
  EXPECT_WRITE32(KEYMGR_SIDELOAD_CLEAR_REG_OFFSET,
                 {{
                     .offset = KEYMGR_SIDELOAD_CLEAR_VAL_OFFSET,
                     .value = kDifKeyMgrSideLoadClearNone,
                 }});
  EXPECT_DIF_OK(
      dif_keymgr_sideload_clear_set_enabled(&keymgr_, kDifToggleDisabled));
}
 
TEST_F(SideloadClearTest, Get) {
  EXPECT_READ32(KEYMGR_SIDELOAD_CLEAR_REG_OFFSET,
                {{
                    .offset = KEYMGR_SIDELOAD_CLEAR_VAL_OFFSET,
                    .value = kDifKeyMgrSideLoadClearAll,
                }});
  dif_toggle_t state = kDifToggleDisabled;
  EXPECT_DIF_OK(dif_keymgr_sideload_clear_get_enabled(&keymgr_, &state));
  EXPECT_EQ(state, kDifToggleEnabled);
 
  EXPECT_READ32(KEYMGR_SIDELOAD_CLEAR_REG_OFFSET,
                {{
                    .offset = KEYMGR_SIDELOAD_CLEAR_VAL_OFFSET,
                    .value = kDifKeyMgrSideLoadClearNone,
                }});
  state = kDifToggleEnabled;
  EXPECT_DIF_OK(dif_keymgr_sideload_clear_get_enabled(&keymgr_, &state));
  EXPECT_EQ(state, kDifToggleDisabled);
}
 
class ReadOutputTest : public DifKeymgrInitialized {};
 
TEST_P(BadArgsTwo, ReadOutput) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto output = GetGoodBadPtrArg<dif_keymgr_output_t>(std::get<1>(GetParam()));
 
  EXPECT_DIF_BADARG(dif_keymgr_read_output(keymgr, output));
}
 
TEST_F(ReadOutputTest, Read) {
  constexpr size_t kNumShares = 2;
  constexpr size_t kNumShareWords = 8;
  constexpr std::array<std::array<uint32_t, kNumShareWords>, kNumShares>
      kExpected{{{0x8D, 0x25, 0x44, 0x0A, 0xEC, 0x1C, 0xAC, 0x0E},
                 {0x44, 0x5B, 0x90, 0x39, 0x24, 0x72, 0xA7, 0xCB}}};
  constexpr std::array<uint32_t, kNumShares> kShareRegOffsets{
      {KEYMGR_SW_SHARE0_OUTPUT_0_REG_OFFSET,
       KEYMGR_SW_SHARE1_OUTPUT_0_REG_OFFSET}};
 
  for (size_t i = 0; i < kNumShares; ++i) {
    for (size_t j = 0; j < kNumShareWords; ++j) {
      EXPECT_READ32(kShareRegOffsets[i] + j * 4, kExpected[i][j]);
    }
  }
 
  dif_keymgr_output_t output;
  EXPECT_DIF_OK(dif_keymgr_read_output(&keymgr_, &output));
  for (size_t i = 0; i < kNumShares; ++i) {
    EXPECT_THAT(kExpected[i], ::testing::ElementsAreArray(output.value[i]));
  }
}
 
class ReadBindingTest : public DifKeymgrInitialized {};
 
TEST_P(BadArgsTwo, ReadBinding) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto output =
      GetGoodBadPtrArg<dif_keymgr_binding_value_t>(std::get<1>(GetParam()));
 
  EXPECT_DIF_BADARG(dif_keymgr_read_binding(keymgr, output));
}
 
TEST_F(ReadBindingTest, Read) {
  constexpr size_t kNumBindingWords = 8;
  constexpr size_t kNumBindings = 2;
  constexpr std::array<std::array<uint32_t, kNumBindingWords>, kNumBindings>
      kExpected{{{0x8D, 0x25, 0x44, 0x0A, 0xEC, 0x1C, 0xAC, 0x0E},
                 {0x44, 0x5B, 0x90, 0x39, 0x24, 0x72, 0xA7, 0xCB}}};
  constexpr std::array<uint32_t, kNumBindings> kShareRegOffsets{
      {KEYMGR_SEALING_SW_BINDING_0_REG_OFFSET,
       KEYMGR_ATTEST_SW_BINDING_0_REG_OFFSET}};
 
  for (size_t i = 0; i < kNumBindings; ++i) {
    for (size_t j = 0; j < kNumBindingWords; ++j) {
      EXPECT_READ32(kShareRegOffsets[i] + j * 4, kExpected[i][j]);
    }
  }
 
  dif_keymgr_binding_value_t output;
  EXPECT_DIF_OK(dif_keymgr_read_binding(&keymgr_, &output));
  EXPECT_THAT(kExpected[0], ::testing::ElementsAreArray(output.sealing));
  EXPECT_THAT(kExpected[1], ::testing::ElementsAreArray(output.attestation));
}
 
class ReadMaxKeyVersionTest : public DifKeymgrInitialized {};
 
TEST_P(BadArgsTwo, ReadMaxKeyVersion) {
  auto keymgr = GetGoodBadPtrArg<dif_keymgr_t>(std::get<0>(GetParam()));
  auto version =
      GetGoodBadPtrArg<dif_keymgr_max_key_version_t>(std::get<1>(GetParam()));
 
  EXPECT_DIF_BADARG(dif_keymgr_read_max_key_version(keymgr, version));
}
 
TEST_F(ReadMaxKeyVersionTest, Read) {
  EXPECT_READ32(KEYMGR_MAX_CREATOR_KEY_VER_SHADOWED_REG_OFFSET, 0xa093ed64);
  EXPECT_READ32(KEYMGR_MAX_OWNER_INT_KEY_VER_SHADOWED_REG_OFFSET, 0x874d53e);
  EXPECT_READ32(KEYMGR_MAX_OWNER_KEY_VER_SHADOWED_REG_OFFSET, 0x874df4a);
 
  dif_keymgr_max_key_version_t versions;
  EXPECT_DIF_OK(dif_keymgr_read_max_key_version(&keymgr_, &versions));
  EXPECT_THAT(0xa093ed64, versions.creator_max_key_version);
  EXPECT_THAT(0x874d53e, versions.owner_int_max_key_version);
  EXPECT_THAT(0x874df4a, versions.owner_max_key_version);
}
}  // namespace
}  // namespace dif_keymgr_unittest