Fix build for no-wolfcrypt and Infineon-only configs

   - Gate wolfTPM2_FirmwareUpgrade and wolfTPM2_FirmwareUpgradeWithLMS
     declarations with WOLFTPM2_NO_WOLFCRYPT (they use wc_Sha384Hash)
   - Fix unit tests to only call wolfcrypt-dependent firmware functions
     when wolfcrypt is enabled
   - Add unused parameter suppressions in FirmwareUpgradeHashWithLMS
     when ST33 is not enabled (fixes -Werror for SLB9672/SLB9673 builds)

Author: aidangarske

.github/workflows/cmake-build.yml

@@ -22,6 +22,9 @@ jobs:
             options: "-DWOLFTPM_INTERFACE=SPI -DWOLFTPM_MODULE=st33"
           - name: "Module ST33 I2C"
             options: "-DWOLFTPM_INTERFACE=I2C -DWOLFTPM_MODULE=st33"
+          # ST33 Firmware
+          - name: "Module ST33 Firmware"
+            options: "-DWOLFTPM_MODULE=st33 -DWOLFTPM_FIRMWARE=yes"
           # Other modules use SPI
           - name: "Module Microchip"
             options: "-DWOLFTPM_INTERFACE=SPI -DWOLFTPM_MODULE=microchip"

.github/workflows/make-test-swtpm.yml

@@ -66,6 +66,9 @@ jobs:
           # STMicro ST33KTPM2
           - name: st33ktpm2
             wolftpm_config: --enable-st33
+          # STMicro ST33KTPM2
+          - name: st33ktpm2 firmware
+            wolftpm_config: --enable-st33 --enable-firmware --enable-st
           # Microchip
           - name: microchip
             wolftpm_config: --enable-microchip

src/tpm2_wrap.c

@@ -32,6 +32,22 @@
 #include <wolftpm/tpm2_packet.h>
 #include <hal/tpm_io.h> /* for default IO callback */
 
+/* Headers for firmware sleep function (needed for pedantic compliance) */
+#if (defined(WOLFTPM_SLB9672) || defined(WOLFTPM_SLB9673) || \
+     defined(WOLFTPM_ST33) || defined(WOLFTPM_AUTODETECT))
+#if defined(WOLFTPM_ZEPHYR)
+    #include <zephyr/kernel.h>
+#elif defined(WOLFSSL_ESPIDF)
+    /* ESP-IDF headers included via tpm2_types.h */
+#elif defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L
+    #include <time.h>
+#elif defined(WIN32)
+    #include <windows.h>
+#elif !defined(FREERTOS)
+    #include <unistd.h>
+#endif
+#endif
+
 /* Local Functions */
 static int wolfTPM2_GetCapabilities_NoDev(WOLFTPM2_CAPS* cap);
 static void wolfTPM2_CopySymmetric(TPMT_SYM_DEF* out, const TPMT_SYM_DEF* in);
@@ -8163,14 +8179,43 @@ int wolfTPM2_SetIdentityAuth(WOLFTPM2_DEV* dev, WOLFTPM2_HANDLE* handle,
 /******************************************************************************/
 
 
-
-
-
 /******************************************************************************/
 /* --- BEGIN Firmware Upgrade Support -- */
 /******************************************************************************/
 
 #ifdef WOLFTPM_FIRMWARE_UPGRADE
+
+/* Helper function to avoid -Wpedantic warning from XSLEEP_MS statement expression.
+ * This function is shared by both Infineon and ST33 firmware update code.
+ * Uses platform-specific sleep functions directly to avoid statement expressions.
+ * Headers for these functions are already included via tpm2_types.h.
+ * Defined early so it's available to both Infineon and ST33 code. */
+#if (defined(WOLFTPM_SLB9672) || defined(WOLFTPM_SLB9673) || \
+     defined(WOLFTPM_ST33) || defined(WOLFTPM_AUTODETECT))
+static void tpm2_firmware_sleep_ms(uint32_t ms)
+{
+#if defined(WOLFTPM_ZEPHYR)
+    k_msleep(ms);
+#elif defined(WOLFSSL_ESPIDF)
+    vTaskDelay(pdMS_TO_TICKS(ms));
+#elif defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L
+    struct timespec ts;
+    ts.tv_sec = ms / 1000;
+    ts.tv_nsec = (ms % 1000) * 1000000;
+    nanosleep(&ts, NULL);
+#elif defined(WIN32)
+    Sleep(ms);
+#elif defined(FREERTOS)
+    vTaskDelay(ms);
+#else
+    /* Default POSIX: use sleep/usleep (unistd.h included via tpm2_types.h) */
+    if (ms >= 1000)
+        sleep(ms / 1000);
+    usleep((ms % 1000) * 1000);
+#endif
+}
+#endif /* WOLFTPM_SLB9672 || WOLFTPM_SLB9673 || WOLFTPM_ST33 || WOLFTPM_AUTODETECT */
+
 #if defined(WOLFTPM_SLB9672) || defined(WOLFTPM_SLB9673)
 
 /* Maximum size of firmware chunks */
@@ -8244,7 +8289,7 @@ static int tpm2_ifx_firmware_start(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg,
         }
         if (rc == TPM_RC_SUCCESS) {
             /* delay to give the TPM time to switch modes */
-            XSLEEP_MS(300);
+            tpm2_firmware_sleep_ms(300);
             /* it is not required to release session handle,
              * since TPM reset into firmware upgrade mode */
 
@@ -8359,7 +8404,7 @@ static int tpm2_ifx_firmware_data(WOLFTPM2_DEV* dev,
 
     if (rc == TPM_RC_SUCCESS) {
         /* Give the TPM time to start the new firmware */
-        XSLEEP_MS(300);
+        tpm2_firmware_sleep_ms(300);
 
     #if !defined(WOLFTPM_LINUX_DEV) && !defined(WOLFTPM_SWTPM) && \
         !defined(WOLFTPM_WINAPI)
@@ -8415,13 +8460,6 @@ static int tpm2_st33_firmware_upgrade_hash(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg
 static int tpm2_st33_firmware_cancel(WOLFTPM2_DEV* dev);
 #endif
 
-/* Forward declaration for LMS firmware upgrade hash function */
-int wolfTPM2_FirmwareUpgradeHashWithLMS(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg,
-    uint8_t* manifest_hash, uint32_t manifest_hash_sz,
-    uint8_t* manifest, uint32_t manifest_sz,
-    wolfTPM2FwDataCb cb, void* cb_ctx,
-    uint8_t* lms_signature, uint32_t lms_signature_sz);
-
 int wolfTPM2_FirmwareUpgradeHash(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg,
     uint8_t* manifest_hash, uint32_t manifest_hash_sz,
     uint8_t* manifest, uint32_t manifest_sz,
@@ -8521,6 +8559,15 @@ int wolfTPM2_FirmwareUpgradeHashWithLMS(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg,
             cb, cb_ctx,
             lms_signature, lms_signature_sz);
     }
+#else
+    /* Suppress unused parameter warnings when ST33 is not enabled */
+    (void)hashAlg;
+    (void)manifest_hash;
+    (void)manifest_hash_sz;
+    (void)manifest;
+    (void)manifest_sz;
+    (void)cb;
+    (void)cb_ctx;
 #endif
 
     /* Unsupported manufacturer or LMS not supported */
@@ -8663,7 +8710,7 @@ static int tpm2_st33_firmware_start(WOLFTPM2_DEV* dev,
 
     if (rc == TPM_RC_SUCCESS) {
         /* delay to give the TPM time to switch modes */
-        XSLEEP_MS(300);
+        tpm2_firmware_sleep_ms(300);
 
     #if !defined(WOLFTPM_LINUX_DEV) && !defined(WOLFTPM_SWTPM) && \
         !defined(WOLFTPM_WINAPI)
@@ -8695,7 +8742,7 @@ static int tpm2_st33_firmware_start_lms(WOLFTPM2_DEV* dev,
 
     if (rc == TPM_RC_SUCCESS) {
         /* delay to give the TPM time to switch modes */
-        XSLEEP_MS(300);
+        tpm2_firmware_sleep_ms(300);
 
     #if !defined(WOLFTPM_LINUX_DEV) && !defined(WOLFTPM_SWTPM) && \
         !defined(WOLFTPM_WINAPI)
@@ -8814,7 +8861,7 @@ static int tpm2_st33_firmware_data(WOLFTPM2_DEV* dev,
 
     if (rc == TPM_RC_SUCCESS) {
         /* Give the TPM time to process */
-        XSLEEP_MS(300);
+        tpm2_firmware_sleep_ms(300);
 
     #if !defined(WOLFTPM_LINUX_DEV) && !defined(WOLFTPM_SWTPM) && \
         !defined(WOLFTPM_WINAPI)

tests/unit_tests.c

@@ -226,6 +226,10 @@ static void test_wolfTPM2_ST33_FirmwareUpgrade(void)
     WOLFTPM2_DEV dev;
     WOLFTPM2_CAPS caps;
     int lms_state = 0; /* 0=non-LMS (< 512), 1=LMS required (>= 512) */
+    uint8_t dummy_sig[1] = {0};
+#ifndef WOLFTPM2_NO_WOLFCRYPT
+    uint8_t dummy_manifest[10] = {0};
+#endif
 
     /* Initialize TPM */
     rc = wolfTPM2_Init(&dev, TPM2_IoCb, NULL);
@@ -249,30 +253,98 @@ static void test_wolfTPM2_ST33_FirmwareUpgrade(void)
     #endif
     }
 
-    /* Test NULL parameter handling */
+    /* ===== Test NULL dev parameter handling ===== */
+
+    /* wolfTPM2_FirmwareUpgradeCancel - NULL dev */
     rc = wolfTPM2_FirmwareUpgradeCancel(NULL);
     AssertIntNE(rc, 0);
 
-    rc = wolfTPM2_FirmwareUpgradeHash(NULL, TPM_ALG_SHA256, NULL, 0, NULL,
+    /* wolfTPM2_FirmwareUpgradeHash - NULL dev */
+    rc = wolfTPM2_FirmwareUpgradeHash(NULL, TPM_ALG_SHA384, NULL, 0, NULL,
         0, NULL, NULL);
     AssertIntNE(rc, 0);
 
-    rc = wolfTPM2_FirmwareUpgradeWithLMS(NULL, NULL, 0, NULL, NULL, NULL, 0);
+    /* wolfTPM2_FirmwareUpgradeHashWithLMS - NULL dev */
+    rc = wolfTPM2_FirmwareUpgradeHashWithLMS(NULL, TPM_ALG_SHA384, NULL, 0,
+        NULL, 0, NULL, NULL, NULL, 0);
+    AssertIntNE(rc, 0);
+
+    /* wolfTPM2_FirmwareUpgradeRecover - NULL dev */
+    rc = wolfTPM2_FirmwareUpgradeRecover(NULL, NULL, 0, NULL, NULL);
     AssertIntNE(rc, 0);
 
 #ifndef WOLFTPM2_NO_WOLFCRYPT
+    /* wolfTPM2_FirmwareUpgrade - NULL dev */
     rc = wolfTPM2_FirmwareUpgrade(NULL, NULL, 0, NULL, NULL);
     AssertIntNE(rc, 0);
 
-    rc = wolfTPM2_FirmwareUpgradeRecover(NULL, NULL, 0, NULL, NULL);
+    /* wolfTPM2_FirmwareUpgradeWithLMS - NULL dev */
+    rc = wolfTPM2_FirmwareUpgradeWithLMS(NULL, NULL, 0, NULL, NULL, NULL, 0);
+    AssertIntNE(rc, 0);
+#endif /* !WOLFTPM2_NO_WOLFCRYPT */
+
+    /* ===== Test NULL/invalid parameter combinations ===== */
+
+    /* wolfTPM2_FirmwareUpgradeHash - valid dev, NULL manifest */
+    rc = wolfTPM2_FirmwareUpgradeHash(&dev, TPM_ALG_SHA384, NULL, 0, NULL,
+        0, NULL, NULL);
+    AssertIntNE(rc, 0);
+
+    /* wolfTPM2_FirmwareUpgradeHashWithLMS - valid dev, NULL lms_signature */
+    rc = wolfTPM2_FirmwareUpgradeHashWithLMS(&dev, TPM_ALG_SHA384, NULL, 0,
+        NULL, 0, NULL, NULL, NULL, 0);
     AssertIntNE(rc, 0);
-#endif
 
+    /* wolfTPM2_FirmwareUpgradeHashWithLMS - valid dev, zero-length lms_signature */
+    rc = wolfTPM2_FirmwareUpgradeHashWithLMS(&dev, TPM_ALG_SHA384, NULL, 0,
+        NULL, 0, NULL, NULL, dummy_sig, 0);
+    AssertIntNE(rc, 0);
+
+    /* wolfTPM2_FirmwareUpgradeRecover - valid dev, NULL manifest */
+    rc = wolfTPM2_FirmwareUpgradeRecover(&dev, NULL, 0, NULL, NULL);
+    AssertIntNE(rc, 0);
+
+    /* wolfTPM2_FirmwareUpgradeCancel - valid dev (may succeed or fail 
+     * depending on TPM state) */
+    rc = wolfTPM2_FirmwareUpgradeCancel(&dev);
+    /* Note: This may return success or error depending on TPM state - 
+     * just verify it doesn't crash */
+    (void)rc;
+
+#ifndef WOLFTPM2_NO_WOLFCRYPT
+    /* wolfTPM2_FirmwareUpgrade - valid dev, NULL manifest */
+    rc = wolfTPM2_FirmwareUpgrade(&dev, NULL, 0, NULL, NULL);
+    AssertIntNE(rc, 0);
+
+    /* wolfTPM2_FirmwareUpgrade - valid dev, NULL callback */
+    rc = wolfTPM2_FirmwareUpgrade(&dev, dummy_manifest, sizeof(dummy_manifest),
+        NULL, NULL);
+    AssertIntNE(rc, 0);
+
+    /* wolfTPM2_FirmwareUpgradeWithLMS - valid dev, NULL lms_signature */
+    rc = wolfTPM2_FirmwareUpgradeWithLMS(&dev, NULL, 0, NULL, NULL, NULL, 0);
+    AssertIntNE(rc, 0);
+
+    /* wolfTPM2_FirmwareUpgradeWithLMS - valid dev, zero-length lms_signature */
+    rc = wolfTPM2_FirmwareUpgradeWithLMS(&dev, NULL, 0, NULL, NULL,
+        dummy_sig, 0);
+    AssertIntNE(rc, 0);
+
+    /* Test ST33-specific path if we have an ST33 TPM */
     if (caps.mfg == TPM_MFG_STM) {
-        rc = wolfTPM2_FirmwareUpgradeWithLMS(&dev, NULL, 0, NULL, NULL, 
-            NULL, 0);
+        /* wolfTPM2_FirmwareUpgradeWithLMS - valid dev with dummy signature 
+         * but NULL manifest */
+        rc = wolfTPM2_FirmwareUpgradeWithLMS(&dev, NULL, 0, NULL, NULL,
+            dummy_sig, sizeof(dummy_sig));
+        AssertIntNE(rc, 0);
+
+        /* wolfTPM2_FirmwareUpgradeWithLMS - valid dev with dummy signature 
+         * but NULL callback */
+        rc = wolfTPM2_FirmwareUpgradeWithLMS(&dev, dummy_manifest,
+            sizeof(dummy_manifest), NULL, NULL, dummy_sig, sizeof(dummy_sig));
         AssertIntNE(rc, 0);
     }
+#endif /* !WOLFTPM2_NO_WOLFCRYPT */
 
     rc = 0;
 

wolftpm/tpm2_wrap.h

@@ -4154,6 +4154,38 @@ WOLFTPM_API int wolfTPM2_FirmwareUpgradeHash(WOLFTPM2_DEV* dev,
     uint8_t* manifest, uint32_t manifest_sz,
     wolfTPM2FwDataCb cb, void* cb_ctx);
 
+/*!
+    \ingroup wolfTPM2_Wrappers
+    \brief Perform TPM firmware upgrade with pre-computed hash and LMS signature
+    \note For ST33KTPM devices with firmware version >= 512, LMS signature required
+    \note This function accepts pre-computed manifest hash (no wolfCrypt needed)
+
+    \return TPM_RC_SUCCESS: successful
+    \return TPM_RC_FAILURE: generic failure (check TPM IO and TPM return code)
+    \return BAD_FUNC_ARG: check the provided arguments
+
+    \param dev pointer to a TPM2_DEV struct
+    \param hashAlg hash algorithm used (TPM_ALG_SHA384 or TPM_ALG_SHA512)
+    \param manifest_hash pre-computed manifest hash
+    \param manifest_hash_sz size of manifest hash
+    \param manifest pointer to firmware manifest data
+    \param manifest_sz size of firmware manifest
+    \param cb callback function for firmware data access
+    \param cb_ctx context pointer passed to callback
+    \param lms_signature pointer to LMS signature data
+    \param lms_signature_sz size of LMS signature
+
+    \sa wolfTPM2_FirmwareUpgradeHash
+    \sa wolfTPM2_FirmwareUpgradeWithLMS
+*/
+WOLFTPM_API int wolfTPM2_FirmwareUpgradeHashWithLMS(WOLFTPM2_DEV* dev,
+    TPM_ALG_ID hashAlg,
+    uint8_t* manifest_hash, uint32_t manifest_hash_sz,
+    uint8_t* manifest, uint32_t manifest_sz,
+    wolfTPM2FwDataCb cb, void* cb_ctx,
+    uint8_t* lms_signature, uint32_t lms_signature_sz);
+
+#ifndef WOLFTPM2_NO_WOLFCRYPT
 /*!
     \ingroup wolfTPM2_Wrappers
     \brief Perform TPM firmware upgrade
@@ -4202,6 +4234,7 @@ WOLFTPM_API int wolfTPM2_FirmwareUpgradeWithLMS(WOLFTPM2_DEV* dev,
     uint8_t* manifest, uint32_t manifest_sz,
     wolfTPM2FwDataCb cb, void* cb_ctx,
     uint8_t* lms_signature, uint32_t lms_signature_sz);
+#endif /* !WOLFTPM2_NO_WOLFCRYPT */
 
 /*!
     \ingroup wolfTPM2_Wrappers