Peer review feedback

Addresses the Skoll multi-scan findings on the caller-supplied firmware
upgrade policy authorization work.

wolfTPM2_PolicyCommandCodeMake: digestSz is now in/out. On input it is the
output buffer capacity and BUFFER_E is returned when it is smaller than the
hash size, checked before the buffer is zeroed or hashed into. Previously the
function wrote hashSz bytes with no capacity known to it and overwrote
*digestSz before hashing, so a short caller buffer was silently overrun.
Updates the doxygen and the callers in the firmware and nvram examples.

wolfTPM2_PolicyOR: require at least two branch digests. TPM 2.0 Part 3
Sec.23.6 mandates a minimum of two and the fwTPM reference implementation
enforces it as TPM_RC_VALUE, so a one-branch list is now rejected with
BAD_FUNC_ARG rather than sent to the TPM.

Firmware upgrade _ex session contract: the vendor FieldUpgradeStart commands
are hand-marshalled with an authorization area carrying only the session
handle - empty nonceCaller, zero attributes and an empty HMAC. That is correct
only for an unsalted, unbound policy session with no auth value, so
wolfTPM2_FirmwareUpgradeHash_ex now validates the caller session up front and
rejects any session needing a computed session HMAC or parameter encryption
(PolicyAuthValue/PolicyPassword, attached auth value, bind, salt,
encrypt/decrypt/audit attributes, or a non-policy session handle). Validation
runs before any TPM traffic. The doxygen and README state the supported
contract and that a successful start consumes the session.

Firmware policy example cleanup: firmware_policy_clear now returns a status
and reports failure instead of silently ignoring it, and is gated on a new
FirmwarePolicyCtx that records what was actually provisioned - previously any
early failure (a missing firmware file, for example) cleared the platform
policy even when the example had never installed one, wiping a policy the
deployment owned. The PolicyOR filler branch is replaced with
PolicyCommandCode(TPM_CC_SetPrimaryPolicy) so the provisioned policy can
authorize its own removal when platformAuth is not the default. A failed
rollback now propagates to the example exit status.

Note the review's premise that cleanup cannot clear the policy it installed is
incorrect: per TPM 2.0 Part 1 Sec.19.7 a hierarchy is authorized by either its
authValue or its authPolicy, so installing an authPolicy does not disable the
password path that firmware_policy_clear uses. Confirmed on an ST33KTPM over
SPI and pinned by a new regression test.

Firmware examples build fix: ifx_fw_update and st33_fw_update drive
wolfTPM2_FirmwareUpgrade_ex, which only exists with wolfCrypt (it hashes the
manifest with SHA-384), but their feature guards did not require it. Building
--enable-firmware with --disable-wolfcrypt failed to compile. The guards now
include !WOLFTPM2_NO_WOLFCRYPT, matching the pattern used by the boot
examples, and the not-compiled-in message says so. This break predates the
policy work.

Tests: minimum PolicyOR branch count, short-buffer and canary coverage for
wolfTPM2_PolicyCommandCodeMake, caller-session rejection for every unsupported
session shape plus an accepted session reaching the manufacturer dispatch, and
a simulator-only regression test that a platform authPolicy is still clearable
with password authorization while a non-matching policy session is refused.

Documentation: README gains the session contract, a rewritten rollback section
explaining which mode can roll back and how, and the policy options that were
missing from the two usage blocks.

Author: dgarske

examples/firmware/README.md

@@ -54,7 +54,13 @@ The TPM has a vendor capability for getting the key group id. This is populated
 Infineon Firmware Update Usage:
         ./ifx_fw_update (get info)
         ./ifx_fw_update --abandon (cancel)
-        ./ifx_fw_update <manifest_file> <firmware_file>
+        ./ifx_fw_update --policytest (safe policy auth self-test)
+        ./ifx_fw_update [policy opts] <manifest_file> <firmware_file>
+        ./ifx_fw_update <manifest_file> <firmware_file> (default auth)
+Policy options (caller-supplied authorization):
+        --policy    provision+satisfy a PolicyCommandCode
+        --policyor  provision+satisfy a PolicyOR (multi-branch)
+        --sha256|--sha384|--sha512  policy hash (default SHA-256)
 
 # Run without arguments to display the current firmware information including key group id and operational mode
 ./ifx_fw_update
@@ -131,7 +137,13 @@ The `st33_fw_update` tool automatically detects the firmware format.
 ST33 Firmware Update Usage:
 	./st33_fw_update (get info)
 	./st33_fw_update --abandon (cancel)
-	./st33_fw_update <firmware.fi>
+	./st33_fw_update --policytest (safe policy auth self-test)
+	./st33_fw_update [policy opts] <firmware.fi>
+	./st33_fw_update <firmware.fi> (default password auth)
+Policy options (caller-supplied authorization):
+	--policy    provision+satisfy a PolicyCommandCode
+	--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)
@@ -206,9 +218,11 @@ By default wolfTPM manages the platform-hierarchy authorization for the firmware
 
 Deployments that gate firmware upgrade behind their own platform policy (for example a signed-policy check, a PCR state, or a multi-branch `PolicyOR`) can supply an already-satisfied authorization session using `wolfTPM2_FirmwareUpgradeHash_ex()`. When a session is supplied:
 
-- **Infineon**: the library does **not** overwrite your platform primary policy. You provision the platform `authPolicy` yourself (via `TPM2_SetPrimaryPolicy` with `authHandle = TPM_RH_PLATFORM`, using SHA2-256 or SHA2-512) and pass a session that satisfies it.
+- **Infineon**: the library does **not** overwrite your platform primary policy. You provision the platform `authPolicy` yourself (via `TPM2_SetPrimaryPolicy` with `authHandle = TPM_RH_PLATFORM`, using SHA2-256 or SHA2-512) and pass a session that satisfies it. Note this applies to the *library*: the `--policy`/`--policyor` example modes are themselves such a caller, and their helper (`examples/firmware/firmware_policy.c`) does overwrite the platform `authPolicy` with a digest it generates. Do not run those modes on a system whose platform hierarchy already carries a policy you need.
 - **ST33**: the supplied session replaces the default `TPM_RS_PW` password authorization.
 
+**Supported session contract**: the vendor `FieldUpgradeStart` command is sent with an authorization area carrying only the session handle - empty `nonceCaller`, zero session attributes and an empty HMAC. The supplied session must therefore be an unsalted, unbound `TPM_SE_POLICY` session with no auth value and no parameter encryption. Policies satisfied with `wolfTPM2_PolicyAuthValue()` or `wolfTPM2_PolicyPassword()` are **not** supported, because the session HMAC they require is not serialized on this path; such a session is rejected with `BAD_FUNC_ARG` before anything is sent to the TPM. `PolicyPCR`, `PolicySigned`, `PolicySecret`, `PolicyAuthorize`, `PolicyCommandCode` and `PolicyOR` branches are all fine.
+
 Both SHA2-256 (non-PQC) and SHA2-512 (PQC) policy digests are supported, because the session hash is chosen with `wolfTPM2_StartSession_ex(..., authHash)` and `wolfTPM2_PolicyOR()` carries per-branch digest sizes.
 
 Example: satisfy a multi-branch `PolicyOR` (up to 8 branches, SHA2-512 shown) and start the upgrade under it:
@@ -228,9 +242,10 @@ rc = wolfTPM2_StartSession_ex(&dev, &session, NULL, NULL,
     TPM_SE_POLICY, TPM_ALG_NULL, TPM_ALG_SHA512);
 if (rc != TPM_RC_SUCCESS) goto cleanup;
 
-/* Satisfy one branch (PCR, PolicySigned/Authorize, PolicyAuthValue, ...), then
- * OR against the full branch list the platform authPolicy encodes. Set count
- * and each digests[i].size/buffer for every branch you populate. */
+/* Satisfy one branch (PCR, PolicySigned, PolicyAuthorize, PolicyCommandCode,
+ * ...), then OR against the full branch list the platform authPolicy encodes.
+ * Set count and each digests[i].size/buffer for every branch you populate.
+ * PolicyOR requires at least 2 branches. */
 orList.count = 2;
 /* orList.digests[0].size = ...; XMEMCPY(orList.digests[0].buffer, ...); */
 /* orList.digests[1].size = ...; XMEMCPY(orList.digests[1].buffer, ...); */
@@ -254,4 +269,12 @@ if (session.handle.hndl != 0)
 
 Passing `NULL` for the final `startSession` argument makes `wolfTPM2_FirmwareUpgradeHash_ex()` behave exactly like `wolfTPM2_FirmwareUpgradeHash()` (library-managed authorization), so existing code is unaffected.
 
-**Note:** the example `--policy`/`--policyor` modes provision the platform hierarchy `authPolicy` via `TPM2_SetPrimaryPolicy` before the upgrade. On failure the example restores the default (clears the policy) so a later default-auth run is not locked out; on success the required TPM reset clears it. If a run is interrupted before that cleanup, the platform hierarchy may still require the policy until the TPM is reset/power-cycled.
+### Rollback of the example-provisioned policy
+
+The example `--policy`/`--policyor` modes provision the platform hierarchy `authPolicy` via `TPM2_SetPrimaryPolicy` before the upgrade. On failure the example clears it again so a later default-auth run is not locked out; on success the required TPM reset clears it.
+
+- Rollback normally uses platform **password** authorization. Per TPM 2.0 Part 1 Sec.19.7 a hierarchy is authorized by *either* its `authValue` *or* its `authPolicy`, so installing an `authPolicy` does not disable the password path. With the default empty `platformAuth` the clear always succeeds.
+- `--policyor` additionally provisions a `PolicyCommandCode(TPM_CC_SetPrimaryPolicy)` branch alongside the firmware-start branch, so the policy can authorize its own removal. If the password path fails (a deployment that set a non-default `platformAuth`), the example retries the clear under that branch.
+- `--policy` provisions a single `PolicyCommandCode(FieldUpgradeStart)` branch and therefore has no policy-based rollback path. It relies entirely on `platformAuth` still being usable.
+- Rollback is attempted only when the example actually installed the policy, so an early failure (a missing firmware file, for example) never clears a policy the deployment provisioned itself.
+- A failed rollback is reported explicitly and becomes the exit status. If a run is interrupted before cleanup, or the clear fails, the platform hierarchy still requires the policy until the TPM is reset/power-cycled.

examples/firmware/firmware_policy.c

@@ -81,11 +81,12 @@ static int firmware_policy_selftest(WOLFTPM2_DEV* dev, TPMI_ALG_HASH hashAlg,
         return rc;
     }
 
-    /* Offline: two distinct PolicyCommandCode branch digests */
-    aSz = hsz;
+    /* Offline: two distinct PolicyCommandCode branch digests. aSz/bSz are
+     * in/out - supply the buffer capacity, get back the digest size. */
+    aSz = (word32)sizeof(branchA);
     rc = wolfTPM2_PolicyCommandCodeMake(hashAlg, branchA, &aSz, TPM_CC_NV_Read);
     if (rc == 0) {
-        bSz = hsz;
+        bSz = (word32)sizeof(branchB);
         rc = wolfTPM2_PolicyCommandCodeMake(hashAlg, branchB, &bSz,
             TPM_CC_Unseal);
     }
@@ -171,33 +172,128 @@ int firmware_policy_selftest_all(WOLFTPM2_DEV* dev)
     return hardFail ? -1 : 0;
 }
 
-void firmware_policy_clear(WOLFTPM2_DEV* dev)
+/* Build the PolicyOR branch list this example provisions. Branch A authorizes
+ * the vendor firmware start; branch B authorizes TPM2_SetPrimaryPolicy so the
+ * policy can be rolled back under itself. */
+static void firmware_policy_or_list(const FirmwarePolicyCtx* ctx,
+    TPML_DIGEST* orList)
 {
-    if (wolfTPM2_SetPrimaryPolicy(dev, TPM_RH_PLATFORM, TPM_ALG_NULL,
-            NULL, 0) == TPM_RC_SUCCESS) {
+    XMEMSET(orList, 0, sizeof(*orList));
+    orList->count = 2;
+    orList->digests[0].size = (UINT16)ctx->branchSz;
+    XMEMCPY(orList->digests[0].buffer, ctx->branchFu, ctx->branchSz);
+    orList->digests[1].size = (UINT16)ctx->branchSz;
+    XMEMCPY(orList->digests[1].buffer, ctx->branchSpp, ctx->branchSz);
+}
+
+/* Clear the platform authPolicy under a policy session that satisfies the
+ * SetPrimaryPolicy branch. Only usable when a PolicyOR was provisioned. */
+static int firmware_policy_clear_by_policy(WOLFTPM2_DEV* dev,
+    FirmwarePolicyCtx* ctx)
+{
+    int rc;
+    int restoreAuth = 0;
+    WOLFTPM2_SESSION sess;
+    TPML_DIGEST orList;
+
+    XMEMSET(&sess, 0, sizeof(sess));
+
+    rc = wolfTPM2_StartSession_ex(dev, &sess, NULL, NULL,
+        TPM_SE_POLICY, TPM_ALG_NULL, ctx->hashAlg);
+    if (rc == 0) {
+        rc = wolfTPM2_PolicyCommandCode(dev, &sess, TPM_CC_SetPrimaryPolicy);
+    }
+    if (rc == 0) {
+        firmware_policy_or_list(ctx, &orList);
+        rc = wolfTPM2_PolicyOR(dev, &sess, &orList);
+    }
+    if (rc == 0) {
+        /* route the next command's authorization through this policy session */
+        rc = wolfTPM2_SetAuthSession(dev, 0, &sess, 0);
+        if (rc == 0) {
+            restoreAuth = 1;
+        }
+    }
+    if (rc == 0) {
+        rc = wolfTPM2_SetPrimaryPolicy(dev, TPM_RH_PLATFORM, TPM_ALG_NULL,
+            NULL, 0);
+    }
+
+    /* restore the default password authorization on session slot 0 */
+    if (restoreAuth) {
+        wolfTPM2_SetAuthPassword(dev, 0, NULL);
+    }
+    if (sess.handle.hndl != 0) {
+        wolfTPM2_UnloadHandle(dev, &sess.handle);
+    }
+    return rc;
+}
+
+int firmware_policy_clear(WOLFTPM2_DEV* dev, FirmwarePolicyCtx* ctx)
+{
+    int rc;
+
+    if (dev == NULL || ctx == NULL) {
+        return BAD_FUNC_ARG;
+    }
+    /* Never touch a policy this example did not install. Without this an early
+     * failure (a bad firmware file, for example) would clear a platform policy
+     * the deployment provisioned itself. */
+    if (!ctx->provisioned) {
+        return 0;
+    }
+
+    /* Default path: platform password authorization. Installing an authPolicy
+     * does not disable the authValue path (TPM 2.0 Part 1 Sec.19.7), so this
+     * succeeds whenever platformAuth is still the default empty password. */
+    rc = wolfTPM2_SetPrimaryPolicy(dev, TPM_RH_PLATFORM, TPM_ALG_NULL, NULL, 0);
+
+    /* Fallback: authorize the clear with the provisioned SetPrimaryPolicy
+     * branch, for a deployment that set a non-default platformAuth. */
+    if (rc != TPM_RC_SUCCESS && ctx->useOr) {
+        printf("Clearing platform policy with default auth failed 0x%x: %s\n",
+            rc, TPM2_GetRCString(rc));
+        printf("  retrying under the SetPrimaryPolicy branch\n");
+        rc = firmware_policy_clear_by_policy(dev, ctx);
+    }
+
+    if (rc == TPM_RC_SUCCESS) {
+        ctx->provisioned = 0;
         printf("Cleared platform policy (restored default auth)\n");
     }
+    else {
+        printf("ERROR: could not clear the platform policy 0x%x: %s\n",
+            rc, TPM2_GetRCString(rc));
+        printf("  The platform hierarchy still requires the provisioned "
+               "policy.\n");
+        printf("  Reset or power cycle the TPM to restore default "
+               "authorization.\n");
+    }
+    return rc;
 }
 
-int firmware_policy_session_setup(WOLFTPM2_DEV* dev,
+int firmware_policy_session_setup(WOLFTPM2_DEV* dev, FirmwarePolicyCtx* ctx,
     TPMI_ALG_HASH hashAlg, int useOr, TPM_CC fuStartCC,
     WOLFTPM2_SESSION* session)
 {
     int rc;
-    int provisioned = 0;
     TPML_DIGEST orList;
     word32 hsz = (word32)TPM2_GetHashDigestSize(hashAlg);
-    byte branchA[TPM_MAX_DIGEST_SIZE];
-    byte branchB[TPM_MAX_DIGEST_SIZE];
     byte concat[2 * TPM_MAX_DIGEST_SIZE];
     byte platformPolicy[TPM_MAX_DIGEST_SIZE];
     word32 aSz, bSz = 0, polSz = 0;
 
+    if (dev == NULL || ctx == NULL || session == NULL) {
+        return BAD_FUNC_ARG;
+    }
     if (hsz == 0 || hsz > TPM_MAX_DIGEST_SIZE) {
         return BAD_FUNC_ARG;
     }
+    XMEMSET(ctx, 0, sizeof(*ctx));
     XMEMSET(session, 0, sizeof(*session));
     XMEMSET(&orList, 0, sizeof(orList));
+    ctx->hashAlg = hashAlg;
+    ctx->useOr = useOr;
 
     /* Fail early (before provisioning) if the TPM can't use this policy hash.
      * rc==0 means not implemented; a negative rc is a query failure. */
@@ -218,27 +314,32 @@ int firmware_policy_session_setup(WOLFTPM2_DEV* dev,
         TPM2_GetAlgName(hashAlg));
 
     /* Branch A: PolicyCommandCode(FieldUpgradeStart) - required to start FU */
-    aSz = hsz;
-    rc = wolfTPM2_PolicyCommandCodeMake(hashAlg, branchA, &aSz, fuStartCC);
+    aSz = (word32)sizeof(ctx->branchFu);
+    rc = wolfTPM2_PolicyCommandCodeMake(hashAlg, ctx->branchFu, &aSz,
+        fuStartCC);
 
     /* Compute the platform authPolicy digest */
     if (rc == 0) {
+        ctx->branchSz = aSz;
         if (useOr) {
-            /* Branch B: a second, distinct policy branch */
-            bSz = hsz;
-            rc = wolfTPM2_PolicyCommandCodeMake(hashAlg, branchB, &bSz,
-                TPM_CC_NV_Read);
+            /* Branch B: PolicyCommandCode(SetPrimaryPolicy). This is the
+             * rollback branch - it lets the provisioned policy authorize its
+             * own removal, so cleanup works even if platformAuth is not the
+             * default empty password. */
+            bSz = (word32)sizeof(ctx->branchSpp);
+            rc = wolfTPM2_PolicyCommandCodeMake(hashAlg, ctx->branchSpp, &bSz,
+                TPM_CC_SetPrimaryPolicy);
             if (rc == 0) {
-                XMEMCPY(concat, branchA, aSz);
-                XMEMCPY(&concat[aSz], branchB, bSz);
+                XMEMCPY(concat, ctx->branchFu, aSz);
+                XMEMCPY(&concat[aSz], ctx->branchSpp, bSz);
                 XMEMSET(platformPolicy, 0, sizeof(platformPolicy));
                 polSz = hsz;
                 rc = wolfTPM2_PolicyHash(hashAlg, platformPolicy, &polSz,
                     TPM_CC_PolicyOR, concat, aSz + bSz);
             }
         }
         else {
-            XMEMCPY(platformPolicy, branchA, aSz);
+            XMEMCPY(platformPolicy, ctx->branchFu, aSz);
             polSz = aSz;
         }
     }
@@ -252,7 +353,7 @@ int firmware_policy_session_setup(WOLFTPM2_DEV* dev,
                 rc, TPM2_GetRCString(rc));
         }
         else {
-            provisioned = 1;
+            ctx->provisioned = 1;
         }
     }
 
@@ -269,11 +370,7 @@ int firmware_policy_session_setup(WOLFTPM2_DEV* dev,
         rc = wolfTPM2_PolicyCommandCode(dev, session, fuStartCC);
     }
     if (rc == 0 && useOr) {
-        orList.count = 2;
-        orList.digests[0].size = (UINT16)aSz;
-        XMEMCPY(orList.digests[0].buffer, branchA, aSz);
-        orList.digests[1].size = (UINT16)bSz;
-        XMEMCPY(orList.digests[1].buffer, branchB, bSz);
+        firmware_policy_or_list(ctx, &orList);
         rc = wolfTPM2_PolicyOR(dev, session, &orList);
     }
 
@@ -283,9 +380,7 @@ int firmware_policy_session_setup(WOLFTPM2_DEV* dev,
         }
         /* Restore default platform auth so a later run is not locked out (the
          * platform policy is otherwise cleared only on TPM reset). */
-        if (provisioned) {
-            firmware_policy_clear(dev);
-        }
+        (void)firmware_policy_clear(dev, ctx);
     }
     return rc;
 }

examples/firmware/firmware_policy.h

@@ -36,6 +36,21 @@
 extern "C" {
 #endif
 
+/* Records what firmware_policy_session_setup actually provisioned, so cleanup
+ * only touches a policy this example installed and can reproduce the branch
+ * digests needed to authorize the rollback. Treat as opaque; zero before
+ * use. */
+typedef struct FirmwarePolicyCtx {
+    TPMI_ALG_HASH hashAlg;    /* policy session / authPolicy hash */
+    int    useOr;             /* 1 = platform policy is a PolicyOR */
+    int    provisioned;       /* 1 = we installed the platform authPolicy */
+    word32 branchSz;          /* size of each branch digest below */
+    /* PolicyOR branch A: PolicyCommandCode(fuStartCC) */
+    byte   branchFu[TPM_MAX_DIGEST_SIZE];
+    /* PolicyOR branch B: PolicyCommandCode(TPM_CC_SetPrimaryPolicy) */
+    byte   branchSpp[TPM_MAX_DIGEST_SIZE];
+} FirmwarePolicyCtx;
+
 /* Non-destructive self-test: exercises wolfTPM2_PolicyOR at SHA-256/384/512 and
  * checks the TPM's running policy digest against an offline computation. A hash
  * the TPM does not implement is reported and skipped. Returns 0 on overall
@@ -45,18 +60,32 @@ int firmware_policy_selftest_all(WOLFTPM2_DEV* dev);
 /* Provision the platform authPolicy and return a session that satisfies it, so
  * the firmware-start command can be authorized by a caller-controlled policy
  * instead of the vendor default. When useOr is set the platform policy is a
- * PolicyOR of two branches; otherwise a single PolicyCommandCode branch.
- * fuStartCC is the vendor FieldUpgrade start command code. On success *session
- * is started and satisfied (the caller passes it to wolfTPM2_FirmwareUpgrade_ex
- * and must UnloadHandle it). On failure any provisioned platform policy is
- * cleared so a later default-auth run is not locked out. */
-int firmware_policy_session_setup(WOLFTPM2_DEV* dev,
+ * PolicyOR of PolicyCommandCode(fuStartCC) and
+ * PolicyCommandCode(TPM_CC_SetPrimaryPolicy); otherwise it is a single
+ * PolicyCommandCode(fuStartCC) branch. fuStartCC is the vendor FieldUpgrade
+ * start command code. ctx records what was provisioned and must be passed to
+ * firmware_policy_clear. On success *session is started and satisfied (the
+ * caller passes it to wolfTPM2_FirmwareUpgrade_ex and must UnloadHandle it).
+ * On failure any provisioned platform policy is cleared so a later default-auth
+ * run is not locked out. */
+int firmware_policy_session_setup(WOLFTPM2_DEV* dev, FirmwarePolicyCtx* ctx,
     TPMI_ALG_HASH hashAlg, int useOr, TPM_CC fuStartCC,
     WOLFTPM2_SESSION* session);
 
-/* Clear the platform authPolicy (restore default auth) so a later default-auth
- * run is not locked out. Call after a failed policy-mode upgrade. */
-void firmware_policy_clear(WOLFTPM2_DEV* dev);
+/* Clear a platform authPolicy this example provisioned, restoring default auth
+ * so a later default-auth run is not locked out. Does nothing (and returns 0)
+ * when ctx reports nothing was provisioned, so an unconditional call on an
+ * error path cannot wipe a policy the deployment installed itself.
+ *
+ * Rollback normally uses platform password authorization: per TPM 2.0 Part 1
+ * Sec.19.7 a hierarchy is authorized by either its authValue or its authPolicy,
+ * so installing an authPolicy does not disable the password path. If the
+ * password path fails (a deployment that set a non-default platformAuth) and a
+ * PolicyOR was provisioned, the SetPrimaryPolicy branch is used to authorize
+ * the clear under policy instead. Returns 0 on success, otherwise the TPM rc;
+ * a non-zero return means the platform hierarchy still requires the policy
+ * until the TPM is reset or power cycled. */
+int firmware_policy_clear(WOLFTPM2_DEV* dev, FirmwarePolicyCtx* ctx);
 
 #ifdef __cplusplus
 }