Fix ST33 generation 1 manifest size and refuse oversized commands (ZD 22193)

Author: dgarske

examples/firmware/README.md

@@ -2,7 +2,7 @@
 
 Currently wolfTPM supports firmware update capability for:
 - Infineon SLB9672 (SPI) and SLB9673 (I2C) TPM 2.0 modules. Infineon has open sourced their firmware update.
-- STMicroelectronics ST33KTPM TPM 2.0 modules. Support includes both Generation 1 firmware versions (< 512, without LMS signature) and Generation 2 firmware versions (>= 512, with LMS signature requirement).
+- STMicroelectronics ST33KTPM TPM 2.0 modules. Support covers generation 1 firmware (RSA signed manifest), generation 9 firmware below 512 (ECDSA signed manifest) and generation 9 firmware at 512 and above (LMS signature requirement).
 
 ## Infineon Firmware
 
@@ -117,15 +117,19 @@ KeyGroupId 0x7, FwCounter 1253 (254 same)
 
 ST33KTPM firmware update automatically detects the required format based on TPM firmware version:
 
-- **Legacy firmware (< 512, e.g., 9.257)**: Non-LMS format
-  - Manifest size: 177 bytes
-  - Generation 1 firmware (ECC-only)
+The manifest (blob0) is a 33 byte fixed header followed by the firmware digest and the signature over it, so its size follows the algorithms that generation signs with:
 
-- **Modern firmware (>= 512, e.g., 9.512)**: LMS format
+- **Generation 1 (major version 1, e.g., 1.257 or 1.771)**: Non-LMS format
+  - Manifest size: 321 bytes (SHA-256 digest, RSAPSS-2048 signature)
+  - Always non-LMS, no matter how high the minor version goes
+
+- **Generation 9 below 512 (e.g., 9.257)**: Non-LMS format
+  - Manifest size: 177 bytes (SHA-384 digest, ECDSA P-384 signature)
+
+- **Generation 9 at 512 and above (e.g., 9.512)**: LMS format
   - Manifest size: 2697 bytes (includes embedded LMS signature)
-  - Generation 2 firmware (LMS mandatory)
 
-The firmware version is automatically detected from `fwVerMinor` in TPM capabilities. The correct manifest size is determined automatically - no manual format selection is needed.
+The LMS requirement is a generation 9 rule, so both `fwVerMajor` and `fwVerMinor` from TPM capabilities are consulted. The example confirms its choice against the file itself: everything after blob0 is a chain of `[type][length]` records that ends exactly at end of file, and only the correct manifest size lands on the final byte. No manual format selection is needed.
 
 ### Updating the firmware
 
@@ -145,9 +149,10 @@ Policy options (caller-supplied authorization):
 	--policyor  provision+satisfy a PolicyOR (multi-branch)
 	--sha256|--sha384|--sha512  policy hash (default SHA-256)
 
-Firmware format is auto-detected from TPM firmware version:
-      - Firmware < 512: Non-LMS format (177 byte manifest)
-      - Firmware >= 512: LMS format (2697 byte manifest with embedded signature)
+Firmware format is auto-detected from TPM firmware version and the file:
+      - Generation 1 (e.g. 1.771): Non-LMS format (321 byte manifest)
+      - Generation 9 below 512: Non-LMS format (177 byte manifest)
+      - Generation 9 at 512 and above: LMS format (2697 byte manifest)
 
 # Run without arguments to display the current firmware information
 ./st33_fw_update

examples/firmware/st33_fw_update.c

@@ -51,8 +51,67 @@
 /******************************************************************************/
 
 /* Manifest sizes per ST33 firmware format */
-#define ST33_BLOB0_SIZE_NON_LMS  177   /* Non-LMS manifest size */
-#define ST33_BLOB0_SIZE_LMS      2697  /* LMS manifest size (includes embedded signature) */
+/* The manifest is a 33 byte fixed header plus the firmware digest and the
+ * signature over it, so its size follows the algorithms of that generation. */
+/* gen 1: SHA-256 + RSAPSS-2048 */
+#define ST33_BLOB0_SIZE_NON_LMS_RSA 321
+/* gen 9 below 512: SHA-384 + ECDSA P-384 */
+#define ST33_BLOB0_SIZE_NON_LMS     177
+/* gen 9 at 512 and above: embedded LMS signature */
+#define ST33_BLOB0_SIZE_LMS         2697
+
+static const size_t st33_blob0_sizes[] = {
+    ST33_BLOB0_SIZE_NON_LMS_RSA,
+    ST33_BLOB0_SIZE_NON_LMS,
+    ST33_BLOB0_SIZE_LMS
+};
+#define ST33_BLOB0_SIZE_CNT \
+    (sizeof(st33_blob0_sizes) / sizeof(st33_blob0_sizes[0]))
+
+/* Confirm a candidate blob0 size by walking the block chain that follows it.
+ * Every byte after blob0 is a [type:1][len:2 big-endian][payload] record and
+ * the chain ends exactly at end of file, so only the correct size lands on
+ * the final byte. Candidates are tried in the supplied order, so the size the
+ * TPM firmware version implies wins when more than one could fit. Returns the
+ * blob0 size, or 0 when the file does not parse with any known size. */
+static size_t st33_detect_blob0(const byte* buf, size_t bufSz,
+    const size_t* cand, size_t candCnt)
+{
+    size_t i, off, len;
+
+    for (i = 0; i < candCnt; i++) {
+        if (bufSz <= cand[i]) {
+            continue;
+        }
+        off = cand[i];
+        while (off + 3 <= bufSz) {
+            if (buf[off] == 0) {
+                break; /* end marker, not a record */
+            }
+            len = ((size_t)buf[off + 1] << 8) | buf[off + 2];
+            if (len == 0) {
+                break;
+            }
+            off += 3 + len;
+        }
+        if (off == bufSz) {
+            return cand[i];
+        }
+    }
+    return 0;
+}
+
+/* Manifest size the running firmware expects for its next update */
+static size_t st33_expected_blob0(WOLFTPM2_CAPS* caps)
+{
+    if (caps->fwVerMajor < 9) {
+        return ST33_BLOB0_SIZE_NON_LMS_RSA;
+    }
+    if (caps->fwVerMinor < 512) {
+        return ST33_BLOB0_SIZE_NON_LMS;
+    }
+    return ST33_BLOB0_SIZE_LMS;
+}
 
 static void usage(void)
 {
@@ -203,6 +262,9 @@ int TPM2_ST33_Firmware_Update(void* userCtx, int argc, char *argv[])
     fw_info_t fwinfo;
     int abandon = 0;
     size_t blob0_size;
+    size_t cand[ST33_BLOB0_SIZE_CNT + 1];
+    size_t candCnt;
+    size_t idx;
     int i;
 #ifdef WOLFTPM_HAVE_FW_POLICY
     int policytest = 0;
@@ -372,50 +434,39 @@ int TPM2_ST33_Firmware_Update(void* userCtx, int argc, char *argv[])
     }
 
 load_firmware:
-    /* Determine blob0 (manifest) size based on firmware version.
-     * In upgrade mode (caps not available), auto-detect from file size. */
-    if (fwinfo.in_upgrade_mode) {
-        /* In upgrade mode, we don't have caps. Load file first to detect format. */
-        rc = loadFile(fi_file, &fwinfo.fi_buf, &fwinfo.fi_bufSz);
-        if (rc != 0) {
-            printf("Failed to load firmware file: %s\n", fi_file);
-            goto exit;
-        }
-        /* Auto-detect format from file size: LMS files are larger due to
-         * 2697 byte manifest vs 177 byte manifest */
-        if (fwinfo.fi_bufSz > ST33_BLOB0_SIZE_LMS + 1000) {
-            /* File large enough to potentially be LMS format.
-             * Check if blob header at LMS offset looks valid. */
-            if (fwinfo.fi_buf[ST33_BLOB0_SIZE_LMS] != 0 &&
-                fwinfo.fi_buf[ST33_BLOB0_SIZE_LMS] != 0xFF) {
-                blob0_size = ST33_BLOB0_SIZE_LMS;
-                printf("\tFormat: LMS (auto-detected from file)\n");
-            }
-            else {
-                blob0_size = ST33_BLOB0_SIZE_NON_LMS;
-                printf("\tFormat: Non-LMS (auto-detected from file)\n");
-            }
-        }
-        else {
-            blob0_size = ST33_BLOB0_SIZE_NON_LMS;
-            printf("\tFormat: Non-LMS (auto-detected from file)\n");
-        }
+    /* Load the complete .fi file, then determine the blob0 (manifest) size.
+     * In upgrade mode caps are unavailable, so no size is preferred and the
+     * block chain alone decides. */
+    rc = loadFile(fi_file, &fwinfo.fi_buf, &fwinfo.fi_bufSz);
+    if (rc != 0) {
+        printf("Failed to load firmware file: %s\n", fi_file);
+        goto exit;
     }
-    else {
-        /* Normal mode: determine format from firmware version */
-        blob0_size = (caps.fwVerMinor >= 512) ?
-            ST33_BLOB0_SIZE_LMS : ST33_BLOB0_SIZE_NON_LMS;
-        printf("\tFormat: %s (from TPM firmware version)\n",
-            (caps.fwVerMinor >= 512) ? "LMS" : "Non-LMS");
-
-        /* Load the complete .fi file */
-        rc = loadFile(fi_file, &fwinfo.fi_buf, &fwinfo.fi_bufSz);
-        if (rc != 0) {
-            printf("Failed to load firmware file: %s\n", fi_file);
-            goto exit;
+
+    candCnt = 0;
+    if (!fwinfo.in_upgrade_mode) {
+        cand[candCnt++] = st33_expected_blob0(&caps);
+    }
+    for (idx = 0; idx < ST33_BLOB0_SIZE_CNT; idx++) {
+        if (candCnt == 0 || cand[0] != st33_blob0_sizes[idx]) {
+            cand[candCnt++] = st33_blob0_sizes[idx];
         }
     }
 
+    blob0_size = st33_detect_blob0(fwinfo.fi_buf, fwinfo.fi_bufSz, cand,
+        candCnt);
+    if (blob0_size == 0) {
+        printf("Error: could not determine the manifest (blob0) size of %s\n",
+            fi_file);
+        printf("  The %zu byte file does not parse as an ST33 firmware image "
+            "with a\n  321, 177 or 2697 byte manifest.\n", fwinfo.fi_bufSz);
+        rc = BAD_FUNC_ARG;
+        goto exit;
+    }
+    printf("\tFormat: %s (blob0 %zu bytes, verified against the block "
+        "chain)\n",
+        (blob0_size == ST33_BLOB0_SIZE_LMS) ? "LMS" : "Non-LMS", blob0_size);
+
     /* Validate file size */
     if (fwinfo.fi_bufSz <= blob0_size) {
         printf("Error: Firmware file too small. Expected > %zu bytes, got %zu bytes.\n",

src/tpm2.c

@@ -521,6 +521,19 @@ static TPM_RC TPM2_DispatchCommand(TPM2_CTX* ctx, TPM2_Packet* packet)
 {
     TPM_RC rc;
 
+    /* A command that did not fit the packet buffer would otherwise go out
+     * silently truncated, since the marshalling helpers drop what does not
+     * fit and TPM2_Packet_Finalize then stamps the short length. The buffer
+     * is MAX_COMMAND_SIZE / MAX_RESPONSE_SIZE, which --enable-smallstack
+     * lowers to 1024 / 1350, so this is reachable on a normal build. */
+    if (packet->overflow) {
+    #ifdef DEBUG_WOLFTPM
+        printf("Command exceeds the %d byte packet buffer "
+            "(MAX_COMMAND_SIZE)\n", packet->size);
+    #endif
+        return (TPM_RC)BUFFER_E;
+    }
+
 #ifdef WOLFTPM_SPDM
     rc = TPM2_SPDM_SendCommand(ctx, packet);
     if (rc >= 0)

src/tpm2_packet.c

@@ -1738,6 +1738,9 @@ int TPM2_Packet_RetryRestore(TPM_RC rc, int* retries, TPM2_Packet* packet,
      * restore the clobbered header and the buffer size for an identical resend */
     XMEMCPY(packet->buf, cmdHdr, TPM2_HEADER_SIZE);
     packet->size = origSize;
+    /* The command body is intact again, so any overflow flagged while parsing
+     * the truncated retry response does not belong to the resend */
+    packet->overflow = 0;
     return 1;
 }
 #endif /* !WOLFTPM_NO_RETRY */

src/tpm2_wrap.c

@@ -11949,15 +11949,34 @@ int wolfTPM2_FirmwareUpgradeCancel(WOLFTPM2_DEV* dev)
 /* Maximum size of firmware chunks for ST33 */
 #define ST33_FW_MAX_CHUNK_SZ 2048  /* Must be large enough for firmware blobs */
 
-/* ST33 firmware version threshold for LMS requirement:
- * < 512: Non-LMS format required (legacy, e.g., 9.257)
- * >= 512: LMS format required (modern, e.g., 9.512) */
+/* ST33 firmware version threshold for LMS requirement. LMS is a generation 9
+ * feature: on those parts a minor version >= 512 requires the LMS format
+ * (e.g. 9.512), below that the ECDSA format (e.g. 9.257). Generation 1 parts
+ * are always non-LMS no matter how high the minor version goes (e.g. 1.771). */
+#define ST33_FW_GENERATION_LMS_CAPABLE 9
 #define ST33_FW_VERSION_LMS_REQUIRED   512
 
-/* ST33 manifest (blob0) sizes determine firmware format.
- * The manifest size is used for auto-detection of LMS vs non-LMS format. */
-#define ST33_MANIFEST_SIZE_NON_LMS     177   /* Non-LMS manifest size */
-#define ST33_MANIFEST_SIZE_LMS         2697  /* LMS manifest size (includes embedded signature) */
+/* ST33 manifest (blob0) sizes determine firmware format. The manifest is a
+ * 33 byte fixed header followed by the firmware digest and the signature over
+ * it, so its size follows the algorithms that generation signs with. */
+/* gen 1: SHA-256 + RSAPSS-2048 */
+#define ST33_MANIFEST_SIZE_NON_LMS_RSA 321
+/* gen 9 below 512: SHA-384 + ECDSA P-384 */
+#define ST33_MANIFEST_SIZE_NON_LMS     177
+/* gen 9 at 512 and above: embedded LMS signature */
+#define ST33_MANIFEST_SIZE_LMS         2697
+
+/* Manifest size the running firmware expects for its next update */
+static uint32_t tpm2_st33_expected_manifest_sz(const WOLFTPM2_CAPS* caps)
+{
+    if (caps->fwVerMajor < ST33_FW_GENERATION_LMS_CAPABLE) {
+        return ST33_MANIFEST_SIZE_NON_LMS_RSA;
+    }
+    if (caps->fwVerMinor < ST33_FW_VERSION_LMS_REQUIRED) {
+        return ST33_MANIFEST_SIZE_NON_LMS;
+    }
+    return ST33_MANIFEST_SIZE_LMS;
+}
 
 /* ST33 uses password auth (TPM_RS_PW) for firmware update, not policy */
 
@@ -12139,10 +12158,11 @@ static int tpm2_st33_firmware_data(WOLFTPM2_DEV* dev,
 }
 
 
-/* Main ST33 firmware upgrade function with auto-detection from manifest size.
- * The manifest size determines whether LMS format is used:
- * - 177 bytes: Non-LMS format (legacy firmware < 512)
- * - 2697 bytes: LMS format (modern firmware >= 512, LMS signature embedded)
+/* Main ST33 firmware upgrade function. The manifest size selects the format
+ * and must match what the running firmware generation expects:
+ * - 321 bytes:  Non-LMS, generation 1 (e.g. 1.257, 1.771)
+ * - 177 bytes:  Non-LMS, generation 9 below 512 (e.g. 9.257)
+ * - 2697 bytes: LMS, generation 9 at 512 and above
  */
 static int tpm2_st33_firmware_upgrade_hash(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg,
     uint8_t* manifest_hash, uint32_t manifest_hash_sz,
@@ -12152,6 +12172,7 @@ static int tpm2_st33_firmware_upgrade_hash(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg
     int rc;
     WOLFTPM2_CAPS caps;
     int is_lms;
+    uint32_t expected_sz;
 
     /* ST33 sends full manifest directly, not hash */
     (void)hashAlg;
@@ -12162,13 +12183,16 @@ static int tpm2_st33_firmware_upgrade_hash(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg
     if (manifest_sz == ST33_MANIFEST_SIZE_LMS) {
         is_lms = 1;
     }
-    else if (manifest_sz == ST33_MANIFEST_SIZE_NON_LMS) {
+    else if (manifest_sz == ST33_MANIFEST_SIZE_NON_LMS ||
+             manifest_sz == ST33_MANIFEST_SIZE_NON_LMS_RSA) {
         is_lms = 0;
     }
     else {
     #ifdef DEBUG_WOLFTPM
-        printf("ST33 Error: Invalid manifest size %u (expected %d for non-LMS or %d for LMS)\n",
-            manifest_sz, ST33_MANIFEST_SIZE_NON_LMS, ST33_MANIFEST_SIZE_LMS);
+        printf("ST33 Error: Invalid manifest size %u (expected %d or %d "
+            "for non-LMS or %d for LMS)\n", manifest_sz,
+            ST33_MANIFEST_SIZE_NON_LMS_RSA, ST33_MANIFEST_SIZE_NON_LMS,
+            ST33_MANIFEST_SIZE_LMS);
     #endif
         return BAD_FUNC_ARG;
     }
@@ -12190,34 +12214,15 @@ static int tpm2_st33_firmware_upgrade_hash(WOLFTPM2_DEV* dev, TPM_ALG_ID hashAlg
         manifest_sz, is_lms ? "LMS" : "non-LMS");
 #endif
 
-    /* Validate manifest format matches firmware version requirement */
-    if (caps.fwVerMinor < ST33_FW_VERSION_LMS_REQUIRED) {
-        /* Legacy firmware (< 512): non-LMS only */
-        if (is_lms) {
-        #ifdef DEBUG_WOLFTPM
-            printf("ST33 Error: LMS manifest provided but firmware version %u < %d requires non-LMS\n",
-                caps.fwVerMinor, ST33_FW_VERSION_LMS_REQUIRED);
-        #endif
-            return BAD_FUNC_ARG;
-        }
+    /* Validate the manifest matches what this firmware generation expects */
+    expected_sz = tpm2_st33_expected_manifest_sz(&caps);
+    if (manifest_sz != expected_sz) {
     #ifdef DEBUG_WOLFTPM
-        printf("ST33 Using non-LMS path (fwVerMinor < %d)\n",
-            ST33_FW_VERSION_LMS_REQUIRED);
-    #endif
-    }
-    else {
-        /* Modern firmware (>= 512): LMS required */
-        if (!is_lms) {
-        #ifdef DEBUG_WOLFTPM
-            printf("ST33 Error: Non-LMS manifest provided but firmware version %u >= %d requires LMS\n",
-                caps.fwVerMinor, ST33_FW_VERSION_LMS_REQUIRED);
-        #endif
-            return BAD_FUNC_ARG;
-        }
-    #ifdef DEBUG_WOLFTPM
-        printf("ST33 Using LMS path (fwVerMinor >= %d, LMS required)\n",
-            ST33_FW_VERSION_LMS_REQUIRED);
+        printf("ST33 Error: manifest size %u does not match the %u bytes "
+            "firmware %u.%u expects\n", manifest_sz, expected_sz,
+            caps.fwVerMajor, caps.fwVerMinor);
     #endif
+        return BAD_FUNC_ARG;
     }
 
     /* Send manifest - the common function handles both LMS and non-LMS */