Add fwTPM HAL unit tests for clock and NV

Author: dgarske

tests/fwtpm_unit_tests.c

@@ -1937,6 +1937,146 @@ static void test_fwtpm_clock_set(void)
     printf("Test fwTPM:\tClockSet/ClockRateAdjust:\tPassed\n");
 }
 
+/* ================================================================== */
+/* HAL registration tests                                              */
+/* ================================================================== */
+
+/* Mock clock HAL state */
+static UINT64 gMockClockMs;
+static int    gMockClockCalls;
+static void*  gMockClockCtxSeen;
+
+static UINT64 mock_clock_get_ms(void* ctx)
+{
+    gMockClockCalls++;
+    gMockClockCtxSeen = ctx;
+    return gMockClockMs;
+}
+
+static void test_fwtpm_clock_sethal(void)
+{
+    FWTPM_CTX ctx;
+    int rc;
+    UINT64 v;
+    void* halCtx = (void*)0xC0FFEE;
+
+    memset(&ctx, 0, sizeof(ctx));
+    rc = FWTPM_Init(&ctx);
+    AssertIntEQ(rc, 0);
+
+    /* Register mock clock HAL */
+    gMockClockMs = 0x12345678ULL;
+    gMockClockCalls = 0;
+    gMockClockCtxSeen = NULL;
+    rc = FWTPM_Clock_SetHAL(&ctx, mock_clock_get_ms, halCtx);
+    AssertIntEQ(rc, 0);
+
+    /* Verify callback fires. FWTPM_Clock_GetMs returns
+     * clockHal.get_ms() + ctx->clockOffset — so verify the relative
+     * contribution of the mock, not the absolute value. */
+    v = FWTPM_Clock_GetMs(&ctx);
+    AssertIntGT(gMockClockCalls, 0);
+    AssertTrue(gMockClockCtxSeen == halCtx);
+    AssertIntEQ((int)((v - ctx.clockOffset) & 0xFFFFFFFFU), 0x12345678);
+
+    /* Confirm the HAL is re-read on every call: change mock value,
+     * verify next call reflects it. */
+    gMockClockMs = 0xABCDEF00ULL;
+    v = FWTPM_Clock_GetMs(&ctx);
+    AssertIntEQ((int)((v - ctx.clockOffset) & 0xFFFFFFFFU), (int)0xABCDEF00);
+
+    /* Error path: NULL ctx must be rejected */
+    rc = FWTPM_Clock_SetHAL(NULL, mock_clock_get_ms, NULL);
+    AssertIntNE(rc, 0);
+
+    FWTPM_Cleanup(&ctx);
+    printf("Test fwTPM:\tClock HAL:\t\t\tPassed\n");
+}
+
+/* Mock NV HAL backend: 64 KB byte buffer with per-call counters. */
+#define MOCK_NV_SIZE (64 * 1024)
+static byte gMockNvStore[MOCK_NV_SIZE];
+static int  gMockNvReads;
+static int  gMockNvWrites;
+static int  gMockNvErases;
+
+static int mock_nv_read(void* c, word32 off, byte* buf, word32 sz)
+{
+    (void)c;
+    if ((size_t)off + sz > MOCK_NV_SIZE) {
+        return -1;
+    }
+    memcpy(buf, gMockNvStore + off, sz);
+    gMockNvReads++;
+    return TPM_RC_SUCCESS;
+}
+static int mock_nv_write(void* c, word32 off, const byte* buf, word32 sz)
+{
+    (void)c;
+    if ((size_t)off + sz > MOCK_NV_SIZE) {
+        return -1;
+    }
+    memcpy(gMockNvStore + off, buf, sz);
+    gMockNvWrites++;
+    return TPM_RC_SUCCESS;
+}
+static int mock_nv_erase(void* c, word32 off, word32 sz)
+{
+    (void)c;
+    if ((size_t)off + sz > MOCK_NV_SIZE) {
+        return -1;
+    }
+    memset(gMockNvStore + off, 0xFF, sz);
+    gMockNvErases++;
+    return TPM_RC_SUCCESS;
+}
+
+/* Register a mock NV HAL before FWTPM_Init and verify that NV writes
+ * go to the mock backend rather than the default file. */
+static void test_fwtpm_nv_sethal_mock(void)
+{
+#ifndef FWTPM_NO_NV
+    FWTPM_CTX ctx;
+    FWTPM_NV_HAL hal;
+    int rc;
+
+    /* Fresh mock store: erased-flash pattern */
+    memset(gMockNvStore, 0xFF, sizeof(gMockNvStore));
+    gMockNvReads = gMockNvWrites = gMockNvErases = 0;
+
+    memset(&ctx, 0, sizeof(ctx));
+    memset(&hal, 0, sizeof(hal));
+    hal.read   = mock_nv_read;
+    hal.write  = mock_nv_write;
+    hal.erase  = mock_nv_erase;
+    hal.ctx    = NULL;
+    hal.maxSize = MOCK_NV_SIZE;
+
+    /* SetHAL before Init: FWTPM_Init preserves pre-set HAL */
+    rc = FWTPM_NV_SetHAL(&ctx, &hal);
+    AssertIntEQ(rc, 0);
+
+    rc = FWTPM_Init(&ctx);
+    AssertIntEQ(rc, 0);
+
+    /* Fresh init must have written the journal header + seed state via
+     * the mock HAL. If this fails, the mock was not wired up. */
+    AssertIntGT(gMockNvWrites, 0);
+    AssertIntGT(gMockNvReads, 0);
+
+    /* Error paths */
+    rc = FWTPM_NV_SetHAL(NULL, &hal);
+    AssertIntNE(rc, 0);
+    rc = FWTPM_NV_SetHAL(&ctx, NULL);
+    AssertIntNE(rc, 0);
+
+    FWTPM_Cleanup(&ctx);
+    printf("Test fwTPM:\tNV HAL (mock backend):\t\tPassed\n");
+#else
+    printf("Test fwTPM:\tNV HAL (mock backend):\t\tSkipped\n");
+#endif
+}
+
 /* ================================================================== */
 /* main                                                                */
 /* ================================================================== */
@@ -1995,6 +2135,13 @@ int fwtpm_unit_tests(int argc, char *argv[])
     test_fwtpm_readclock();
     test_fwtpm_clock_set();
 
+    /* HAL registration (clock + NV). The NV HAL test uses a mock
+     * backend and must not leave the default file in a half-written
+     * state, so remove FWTPM_NV_FILE afterwards. */
+    test_fwtpm_clock_sethal();
+    test_fwtpm_nv_sethal_mock();
+    remove(FWTPM_NV_FILE);
+
     /* Key operations */
 #if !defined(NO_RSA) && defined(WOLFSSL_KEY_GEN)
     test_fwtpm_create_primary_rsa();