TPM: RoT comparison made Constant time

F/448

Author: danielinux

src/tpm.c

@@ -32,6 +32,7 @@
 #include "spi_drv.h"
 #include "tpm.h"
 #include "wolftpm/tpm2_tis.h" /* for TIS header size and wait state */
+#include <wolfssl/wolfcrypt/misc.h>
 
 WOLFTPM2_DEV     wolftpm_dev;
 #if defined(WOLFBOOT_TPM_KEYSTORE) || defined(WOLFBOOT_TPM_SEAL)
@@ -1515,7 +1516,8 @@ int wolfBoot_check_rot(int key_slot, uint8_t* pubkey_hint)
         if (rc == 0) {
             /* verify the hint (hash) matches */
             if (digestSz == WOLFBOOT_SHA_DIGEST_SIZE &&
-                memcmp(digest, pubkey_hint, WOLFBOOT_SHA_DIGEST_SIZE) == 0) {
+                ConstantCompare(digest, pubkey_hint,
+                    WOLFBOOT_SHA_DIGEST_SIZE) == 0) {
                 wolfBoot_printf("TPM Root of Trust valid (id %d)\n", key_slot);
             }
             else {

tools/unit-tests/unit-tpm-rsa-exp.c

@@ -5,6 +5,7 @@
 
 #include <check.h>
 #include <stdint.h>
+#include <stdio.h>
 #include <string.h>
 
 #ifndef SPI_CS_TPM
@@ -16,6 +17,7 @@
 #ifndef WOLFBOOT_TPM_HASH_ALG
 #define WOLFBOOT_TPM_HASH_ALG TPM_ALG_SHA256
 #endif
+#define WOLFBOOT_TPM_KEYSTORE
 
 #include "wolfboot/wolfboot.h"
 #include "keystore.h"
@@ -24,7 +26,9 @@
 static uint8_t test_hdr[16];
 static uint8_t test_modulus[256];
 static uint8_t test_exponent_der[] = { 0xAA, 0x01, 0x00, 0x01, 0x7B };
+static uint8_t test_nv_digest[WOLFBOOT_SHA_DIGEST_SIZE];
 static uint32_t captured_exponent;
+static int forbidden_memcmp_calls;
 
 int keyslot_id_by_sha(const uint8_t* pubkey_hint)
 {
@@ -79,13 +83,96 @@ int wolfTPM2_LoadRsaPublicKey_ex(WOLFTPM2_DEV* dev, WOLFTPM2_KEY* key,
     return 0;
 }
 
+int wolfTPM2_SetAuthHandle(WOLFTPM2_DEV* dev, int index,
+    const WOLFTPM2_HANDLE* handle)
+{
+    (void)dev;
+    (void)index;
+    (void)handle;
+    return 0;
+}
+
+int wolfTPM2_SetAuthSession(WOLFTPM2_DEV* dev, int index,
+    WOLFTPM2_SESSION* tpmSession, TPMA_SESSION sessionAttributes)
+{
+    (void)dev;
+    (void)index;
+    (void)tpmSession;
+    (void)sessionAttributes;
+    return 0;
+}
+
+int wolfTPM2_UnsetAuth(WOLFTPM2_DEV* dev, int index)
+{
+    (void)dev;
+    (void)index;
+    return 0;
+}
+
+int wolfTPM2_UnsetAuthSession(WOLFTPM2_DEV* dev, int index,
+    WOLFTPM2_SESSION* tpmSession)
+{
+    (void)dev;
+    (void)index;
+    (void)tpmSession;
+    return 0;
+}
+
+int wolfTPM2_NVReadAuth(WOLFTPM2_DEV* dev, WOLFTPM2_NV* nv,
+    word32 nvIndex, byte* dataBuf, word32* pDataSz, word32 offset)
+{
+    (void)dev;
+    (void)nv;
+    (void)nvIndex;
+    (void)offset;
+    ck_assert_uint_eq(*pDataSz, WOLFBOOT_SHA_DIGEST_SIZE);
+    memcpy(dataBuf, test_nv_digest, WOLFBOOT_SHA_DIGEST_SIZE);
+    *pDataSz = WOLFBOOT_SHA_DIGEST_SIZE;
+    return 0;
+}
+
+const char* wolfTPM2_GetRCString(int rc)
+{
+    (void)rc;
+    return "mock";
+}
+
+int ConstantCompare(const byte* a, const byte* b, int length)
+{
+    int diff = 0;
+    int i;
+
+    for (i = 0; i < length; i++) {
+        diff |= a[i] ^ b[i];
+    }
+    return diff;
+}
+
+static int forbidden_memcmp(const void *a, const void *b, size_t n)
+{
+    const uint8_t *lhs = (const uint8_t *)a;
+    const uint8_t *rhs = (const uint8_t *)b;
+    size_t i;
+
+    forbidden_memcmp_calls++;
+    for (i = 0; i < n; i++) {
+        if (lhs[i] != rhs[i])
+            return (int)lhs[i] - (int)rhs[i];
+    }
+    return 0;
+}
+
+#define memcmp forbidden_memcmp
 #include "../../src/tpm.c"
+#undef memcmp
 
 static void setup(void)
 {
     memset(test_hdr, 0x42, sizeof(test_hdr));
     memset(test_modulus, 0x5A, sizeof(test_modulus));
+    memset(test_nv_digest, 0x7C, sizeof(test_nv_digest));
     captured_exponent = 0;
+    forbidden_memcmp_calls = 0;
 }
 
 START_TEST(test_wolfBoot_load_pubkey_decodes_der_exponent_bytes)
@@ -105,6 +192,20 @@ START_TEST(test_wolfBoot_load_pubkey_decodes_der_exponent_bytes)
 }
 END_TEST
 
+START_TEST(test_wolfBoot_check_rot_avoids_memcmp_on_digest_compare)
+{
+    uint8_t hint[WOLFBOOT_SHA_DIGEST_SIZE];
+    int rc;
+
+    memcpy(hint, test_nv_digest, sizeof(hint));
+
+    rc = wolfBoot_check_rot(0, hint);
+
+    ck_assert_int_eq(rc, 0);
+    ck_assert_int_eq(forbidden_memcmp_calls, 0);
+}
+END_TEST
+
 static Suite *tpm_suite(void)
 {
     Suite *s;
@@ -114,6 +215,7 @@ static Suite *tpm_suite(void)
     tc = tcase_create("wolfBoot_load_pubkey");
     tcase_add_checked_fixture(tc, setup, NULL);
     tcase_add_test(tc, test_wolfBoot_load_pubkey_decodes_der_exponent_bytes);
+    tcase_add_test(tc, test_wolfBoot_check_rot_avoids_memcmp_on_digest_compare);
     suite_add_tcase(s, tc);
     return s;
 }