[cov] Add corner case unit tests for uncovered code

sw/device/lib/base/memory_unittest.cc

@@ -245,6 +245,54 @@ TEST_P(MemCmpTest, Properties) {
   EXPECT_GT(memcmp_func(zs, xs, kLen), 0);
 }
 
+TEST_P(MemCmpTest, UnalignedHeadTest) {
+  auto memcmp_func = GetParam();
+
+  constexpr size_t kLen = 8;
+  alignas(uint32_t) constexpr uint8_t xs[kLen] = {0, 0, 0, 0, 0, 0, 0, 0};
+  alignas(uint32_t) constexpr uint8_t ys[kLen] = {0, 1, 0, 0, 0, 0, 0, 0};
+
+  // Reflexive property.
+  EXPECT_EQ(memcmp_func(xs + 1, xs + 1, kLen - 1), 0);
+  EXPECT_EQ(memcmp_func(ys + 1, ys + 1, kLen - 1), 0);
+  // Transitive property for less-than result.
+  EXPECT_LT(memcmp_func(xs + 1, ys + 1, kLen - 1), 0);
+  // Transitive property for greater-than result.
+  EXPECT_GT(memcmp_func(ys + 1, xs + 1, kLen - 1), 0);
+}
+
+TEST_P(MemCmpTest, UnalignedTailTest) {
+  auto memcmp_func = GetParam();
+
+  constexpr size_t kLen = 6;
+  alignas(uint32_t) constexpr uint8_t xs[kLen] = {0, 0, 0, 0, 0, 0};
+  alignas(uint32_t) constexpr uint8_t ys[kLen] = {0, 0, 0, 0, 0, 1};
+
+  // Reflexive property.
+  EXPECT_EQ(memcmp_func(xs, xs, kLen), 0);
+  EXPECT_EQ(memcmp_func(ys, ys, kLen), 0);
+  // Transitive property for less-than result.
+  EXPECT_LT(memcmp_func(xs, ys, kLen), 0);
+  // Transitive property for greater-than result.
+  EXPECT_GT(memcmp_func(ys, xs, kLen), 0);
+}
+
+TEST_P(MemCmpTest, AlignedBodyTest) {
+  auto memcmp_func = GetParam();
+
+  constexpr size_t kLen = 4;
+  alignas(uint32_t) constexpr uint8_t xs[kLen] = {0, 0, 0, 0};
+  alignas(uint32_t) constexpr uint8_t ys[kLen] = {0, 0, 0, 1};
+
+  // Reflexive property.
+  EXPECT_EQ(memcmp_func(xs, xs, kLen), 0);
+  EXPECT_EQ(memcmp_func(ys, ys, kLen), 0);
+  // Transitive property for less-than result.
+  EXPECT_LT(memcmp_func(xs, ys, kLen), 0);
+  // Transitive property for greater-than result.
+  EXPECT_GT(memcmp_func(ys, xs, kLen), 0);
+}
+
 TEST_P(MemCmpTest, DoesNotUseSystemEndianness) {
   auto memcmp_func = GetParam();
 

sw/device/silicon_creator/lib/BUILD

@@ -251,13 +251,10 @@ cc_library(
     ],
 )
 
-cc_test(
-    name = "dbg_print_unittest",
-    srcs = [
-        "dbg_print.c",
-        "dbg_print.h",
-        "dbg_print_unittest.cc",
-    ],
+cc_library(
+    name = "dbg_print_unittest_variant",
+    srcs = ["dbg_print.c"],
+    hdrs = ["dbg_print.h"],
     local_defines = ["DBG_PRINT_UNIT_TEST_"],
     deps = [
         ":epmp_defs",
@@ -266,6 +263,16 @@ cc_test(
         "//sw/device/lib/base:csr",
         "//sw/device/lib/base:macros",
         "//sw/device/silicon_creator/lib/drivers:uart",
+    ],
+)
+
+cc_test(
+    name = "dbg_print_unittest",
+    srcs = [
+        "dbg_print_unittest.cc",
+    ],
+    deps = [
+        ":dbg_print_unittest_variant",
         "@googletest//:gtest_main",
     ],
 )

sw/device/silicon_creator/lib/cert/cert_unittest.cc

@@ -87,6 +87,11 @@ TEST_F(CertTest, DecodeSize) {
             expected_cert_size_);
 }
 
+TEST_F(CertTest, DecodeSizeFailed) {
+  uint8_t zero_cert_bytes[32] = {0};
+  EXPECT_EQ(cert_x509_asn1_decode_size_header(zero_cert_bytes), 0);
+}
+
 /**
  * Here we test if a flash page has been erased (i.e., is all 1s) but the page
  * has never been provisioned with a certificate.
@@ -129,6 +134,15 @@ TEST_F(CertTest, BadSerialNumberLength) {
   valid_dice_cert_bytes_[kCertX509Asn1SerialNumberLengthByteOffset] = backup;
 }
 
+TEST_F(CertTest, BufferTooSmall) {
+  hardened_bool_t matches = kHardenedBoolFalse;
+  EXPECT_EQ(cert_x509_asn1_check_serial_number(valid_dice_cert_bytes_,
+                                               /*size=*/1, &expected_sn_bytes_,
+                                               &matches),
+            kErrorCertInvalidSize);
+  EXPECT_EQ(matches, kHardenedBoolFalse);
+}
+
 TEST_F(CertTest, CertOutdated) {
   hardened_bool_t matches = kHardenedBoolFalse;
   uint8_t empty_sn[kCertX509Asn1SerialNumberSizeInBytes] = {0};

sw/device/silicon_creator/lib/dbg_print_unittest.cc

@@ -69,6 +69,20 @@ TEST(LogTest, PrintfHex) {
   EXPECT_EQ(*uart_buf, "0x0102030405060708");
 }
 
+TEST(LogTest, PrintfPointer) {
+  uart_buf->clear();
+  dbg_printf("%p", 0xabcdef01);
+  EXPECT_EQ(*uart_buf, "abcdef01");
+
+  uart_buf->clear();
+  dbg_printf("%p", 0);
+  EXPECT_EQ(*uart_buf, "00000000");
+
+  uart_buf->clear();
+  dbg_printf("0x%p%p", 0x01020304, 0x05060708);
+  EXPECT_EQ(*uart_buf, "0x0102030405060708");
+}
+
 TEST(LogTest, PrintfString) {
   uart_buf->clear();
   dbg_printf("Hello, %s!", "World");

sw/device/silicon_creator/lib/drivers/alert_unittest.cc

@@ -43,6 +43,13 @@ TEST_F(InitTest, AlertConfigureAlertBadClass) {
       kErrorAlertBadClass);
 }
 
+TEST_F(InitTest, LocalAlertConfigureAlertBadIndex) {
+  EXPECT_EQ(alert_local_configure(
+                ALERT_HANDLER_LOC_ALERT_CLASS_SHADOWED_MULTIREG_COUNT,
+                kAlertClassX, kAlertEnableNone),
+            kErrorAlertBadIndex);
+}
+
 TEST_F(InitTest, LocalAlertConfigureAlertBadClass) {
   EXPECT_EQ(alert_local_configure(0, static_cast<alert_class_t>(-1),
                                   kAlertEnableNone),
@@ -74,6 +81,18 @@ TEST_F(InitTest, LocalAlertConfigureAlertClassXNoOperation) {
   EXPECT_EQ(alert_local_configure(0, kAlertClassX, kAlertEnableNone), kErrorOk);
 }
 
+TEST_F(InitTest, AlertConfigureNotEnable) {
+  EXPECT_ABS_WRITE32_SHADOWED(
+      base_ + ALERT_HANDLER_ALERT_CLASS_SHADOWED_0_REG_OFFSET, 0);
+  EXPECT_EQ(alert_configure(0, kAlertClassA, kAlertEnableNone), kErrorOk);
+}
+
+TEST_F(InitTest, LocalAlertConfigureNotEnable) {
+  EXPECT_ABS_WRITE32_SHADOWED(
+      base_ + ALERT_HANDLER_LOC_ALERT_CLASS_SHADOWED_0_REG_OFFSET, 0);
+  EXPECT_EQ(alert_local_configure(0, kAlertClassA, kAlertEnableNone), kErrorOk);
+}
+
 TEST_F(InitTest, AlertConfigure0AsClassA) {
   EXPECT_ABS_WRITE32_SHADOWED(
       base_ + ALERT_HANDLER_ALERT_CLASS_SHADOWED_0_REG_OFFSET, 0);

sw/device/silicon_creator/lib/drivers/flash_ctrl_unittest.cc

@@ -93,6 +93,14 @@ struct InitCase {
    * Configuration settings to be read from OTP.
    */
   flash_ctrl_cfg_t cfg;
+  /**
+   * Configuration override settings to be read from OTP.
+   */
+  uint32_t override_val;
+  /**
+   * Expected value to be written to the cfg override register.
+   */
+  uint32_t override_write_val;
   /**
    * Expected value to be written to the info config register.
    */
@@ -118,7 +126,12 @@ TEST_P(InitTest, Initialize) {
   EXPECT_CALL(
       otp_,
       read32(OTP_CTRL_PARAM_CREATOR_SW_CFG_FLASH_HW_INFO_CFG_OVERRIDE_OFFSET))
-      .WillOnce(Return(0));
+      .WillOnce(Return(GetParam().override_val));
+
+  if (GetParam().override_val != 0) {
+    EXPECT_SEC_WRITE32(base_ + FLASH_CTRL_HW_INFO_CFG_OVERRIDE_REG_OFFSET,
+                       GetParam().override_write_val);
+  }
 
   EXPECT_ABS_WRITE32(base_ + FLASH_CTRL_INIT_REG_OFFSET,
                      {{FLASH_CTRL_INIT_VAL_BIT, true}});
@@ -155,6 +168,8 @@ INSTANTIATE_TEST_SUITE_P(AllCases, InitTest,
                                  .cfg = {.scrambling = kMultiBitBool4True,
                                          .ecc = kMultiBitBool4False,
                                          .he = kMultiBitBool4False},
+                                 .override_val = 0,
+                                 .override_write_val = 0,
                                  .info_write_val = 0x9969996,
                                  .data_write_val = 0x996999,
                              },
@@ -163,6 +178,8 @@ INSTANTIATE_TEST_SUITE_P(AllCases, InitTest,
                                  .cfg = {.scrambling = kMultiBitBool4False,
                                          .ecc = kMultiBitBool4True,
                                          .he = kMultiBitBool4False},
+                                 .override_val = 0,
+                                 .override_write_val = 0,
                                  .info_write_val = 0x9699996,
                                  .data_write_val = 0x969999,
                              },
@@ -171,6 +188,8 @@ INSTANTIATE_TEST_SUITE_P(AllCases, InitTest,
                                  .cfg = {.scrambling = kMultiBitBool4False,
                                          .ecc = kMultiBitBool4False,
                                          .he = kMultiBitBool4True},
+                                 .override_val = 0,
+                                 .override_write_val = 0,
                                  .info_write_val = 0x6999996,
                                  .data_write_val = 0x699999,
                              },
@@ -179,6 +198,38 @@ INSTANTIATE_TEST_SUITE_P(AllCases, InitTest,
                                  .cfg = {.scrambling = kMultiBitBool4True,
                                          .ecc = kMultiBitBool4True,
                                          .he = kMultiBitBool4False},
+                                 .override_val = 0,
+                                 .override_write_val = 0,
+                                 .info_write_val = 0x9669996,
+                                 .data_write_val = 0x966999,
+                             },
+                             // Override scrambling disable.
+                             InitCase{
+                                 .cfg = {.scrambling = kMultiBitBool4True,
+                                         .ecc = kMultiBitBool4False,
+                                         .he = kMultiBitBool4False},
+                                 .override_val = 0x0006,
+                                 .override_write_val = 0x96,
+                                 .info_write_val = 0x9969996,
+                                 .data_write_val = 0x996999,
+                             },
+                             // Override ECC disable.
+                             InitCase{
+                                 .cfg = {.scrambling = kMultiBitBool4False,
+                                         .ecc = kMultiBitBool4True,
+                                         .he = kMultiBitBool4False},
+                                 .override_val = 0x0600,
+                                 .override_write_val = 0x69,
+                                 .info_write_val = 0x9699996,
+                                 .data_write_val = 0x969999,
+                             },
+                             // Override scrambling and ECC disable.
+                             InitCase{
+                                 .cfg = {.scrambling = kMultiBitBool4True,
+                                         .ecc = kMultiBitBool4True,
+                                         .he = kMultiBitBool4False},
+                                 .override_val = 0x0606,
+                                 .override_write_val = 0x66,
                                  .info_write_val = 0x9669996,
                                  .data_write_val = 0x966999,
                              }));

sw/device/silicon_creator/lib/manifest_unittest.cc

@@ -38,6 +38,16 @@ TEST_F(ManifestTest, DigestRegionGet) {
             manifest_.signed_region_end - digest_region_offset);
 }
 
+TEST_F(ManifestTest, BadMajorVersion) {
+  manifest_.manifest_version.major = kManifestVersionMajor2 + 1;
+  EXPECT_EQ(manifest_check(&manifest_), kErrorManifestBadVersionMajor);
+}
+
+TEST_F(ManifestTest, SignedRegionOutsideImage) {
+  manifest_.length = 0;
+  EXPECT_EQ(manifest_check(&manifest_), kErrorManifestBadSignedRegion);
+}
+
 TEST_F(ManifestTest, CodeRegionGet) {
   epmp_region_t code_region = manifest_code_region_get(&manifest_);
 

sw/device/silicon_creator/lib/ownership/BUILD

@@ -114,6 +114,23 @@ cc_library(
     ],
 )
 
+cc_test(
+    name = "ownership_unittest",
+    srcs = [
+        "ownership_unittest.cc",
+    ],
+    deps = [
+        ":datatypes",
+        ":ownership",
+        ":ownership_key",
+        "//sw/device/lib/base:hardened",
+        "//sw/device/silicon_creator/lib:boot_data",
+        "//sw/device/silicon_creator/lib/boot_svc:boot_svc_header",
+        "//sw/device/silicon_creator/testing:rom_test",
+        "@googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "owner_block",
     srcs = ["owner_block.c"],

sw/device/silicon_creator/lib/ownership/isfb_unittest.cc

@@ -209,4 +209,37 @@ TEST_F(IsfbTest, ProductAssociationError) {
   EXPECT_EQ(checks_performed_count, UINT32_MAX);
 }
 
+TEST_F(IsfbTest, ErasePolicyOwnershipIsfbNotPreset) {
+  const manifest_ext_isfb_erase_t ext = {
+      .header =
+          {
+              .identifier = kManifestExtIdIsfbErase,
+              .name = kManifestExtIdIsfbErase,
+          },
+  };
+  owner_config_t owner_config = {
+      .isfb = (owner_isfb_config_t *)kHardenedBoolFalse,
+  };
+  hardened_bool_t erase_en = kHardenedBoolFalse;
+  rom_error_t error = isfb_info_flash_erase_policy_get(
+      &owner_config, 0, kHardenedBoolTrue, &ext, &erase_en);
+  EXPECT_EQ(error, kErrorOwnershipISFBNotPresent);
+}
+
+TEST_F(IsfbTest, ErasePolicyDisableExpectedCheck) {
+  const manifest_ext_isfb_erase_t ext = {
+      .header =
+          {
+              .identifier = kManifestExtIdIsfbErase,
+              .name = kManifestExtIdIsfbErase,
+          },
+  };
+  isfb_config_.erase_conditions = 0x99999999;
+  hardened_bool_t erase_en = kHardenedBoolFalse;
+  rom_error_t error = isfb_info_flash_erase_policy_get(
+      &owner_config_, 0, kHardenedBoolTrue, &ext, &erase_en);
+  EXPECT_EQ(error, kErrorOk);
+  EXPECT_EQ(erase_en, kHardenedBoolTrue);
+}
+
 }  // namespace

sw/device/silicon_creator/lib/ownership/ownership.h

@@ -12,6 +12,10 @@
 #include "sw/device/silicon_creator/lib/ownership/datatypes.h"
 #include "sw/device/silicon_creator/lib/ownership/owner_block.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /**
  * Initialize the owner pages from flash
  */
@@ -37,4 +41,8 @@ rom_error_t ownership_flash_lockdown(boot_data_t *bootdata, boot_log_t *bootlog,
  */
 void ownership_pages_lockdown(boot_data_t *bootdata, hardened_bool_t rescue);
 
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
 #endif  // OPENTITAN_SW_DEVICE_SILICON_CREATOR_LIB_OWNERSHIP_OWNERSHIP_H_