Add measurements, challenge, heartbeat, key update, and cert chain validation

  Implement core SPDM 1.2 protocol features for production device attestation:
  - GET_MEASUREMENTS with signature verification (L1/L2 transcript, DSP0274)
  - CHALLENGE/CHALLENGE_AUTH sessionless attestation with signature verification
  - Certificate chain validation against trusted root CAs via wolfSPDM_SetTrustedCAs()
  - HEARTBEAT/HEARTBEAT_ACK session keep-alive
  - KEY_UPDATE/KEY_UPDATE_ACK session key rotation (DSP0277 traffic upd label)
  - Application data send/receive over encrypted sessions
  - Fix IV XOR position for MCTP to leftmost bytes per DSP0277

  All 6 spdm-emu integration tests pass. Bumps WOLFSPDM_CTX_STATIC_SIZE to 32KB.

Author: aidangarske

README.md

@@ -6,8 +6,14 @@ Lightweight SPDM 1.2+ requester-only stack implementation using wolfSSL/wolfCryp
 
 - SPDM 1.2 requester implementation
 - Algorithm Set B (FIPS 140-3 Level 3): ECDSA/ECDHE P-384, SHA-384, AES-256-GCM, HKDF-SHA384
-- **Zero-malloc by default** — fully static memory, ideal for constrained/embedded environments
+- **Zero-malloc by default** — fully static memory (~32 KB context), ideal for constrained/embedded environments
 - Optional `--enable-dynamic-mem` for heap-allocated contexts (useful for small-stack platforms)
+- Session establishment with full key exchange and encrypted messaging
+- Device attestation via signed/unsigned measurements (GET_MEASUREMENTS)
+- Sessionless attestation via CHALLENGE/CHALLENGE_AUTH with signature verification
+- Certificate chain validation against trusted root CAs
+- Session keep-alive via HEARTBEAT/HEARTBEAT_ACK
+- Session key rotation via KEY_UPDATE/KEY_UPDATE_ACK (DSP0277)
 - Hardware SPDM via wolfTPM + Nuvoton TPM
 - Full transcript tracking for TH1/TH2 computation
 - Compatible with DMTF spdm-emu for interoperability testing
@@ -53,7 +59,7 @@ make
 ### Memory Modes
 
 **Static (default):** Zero heap allocation. The caller provides a buffer
-(`WOLFSPDM_CTX_STATIC_SIZE` bytes, ~22 KB) and wolfSPDM operates entirely
+(`WOLFSPDM_CTX_STATIC_SIZE` bytes, ~32 KB) and wolfSPDM operates entirely
 within it. This is ideal for embedded and constrained environments where
 malloc is unavailable or undesirable.
 
@@ -68,7 +74,7 @@ wolfSPDM_Free(ctx);
 ```
 
 **Dynamic (`--enable-dynamic-mem`):** Context is heap-allocated via
-`wolfSPDM_New()`. Useful on platforms with small stacks where a ~22 KB
+`wolfSPDM_New()`. Useful on platforms with small stacks where a ~32 KB
 local variable is impractical.
 
 ```c
@@ -98,17 +104,15 @@ cd wolfTPM
 ./configure --enable-spdm --enable-swtpm --with-wolfspdm=path/to/wolfspdm
 make
 
-# Terminal 1: Start responder with Algorithm Set B
-cd spdm-emu
-./bin/spdm_responder_emu --ver 1.2 \
-    --hash SHA_384 --asym ECDSA_P384 \
-    --dhe SECP_384_R1 --aead AES_256_GCM
-
-# Terminal 2: Run wolfTPM example
+# Run emulator tests (starts/stops emulator automatically)
 cd wolfTPM
-./examples/spdm/spdm_demo --emu
+./examples/spdm/spdm_test.sh --emu
 ```
 
+The test script automatically finds `spdm_responder_emu` in `../spdm-emu/build/bin/`,
+starts it for each test, and runs session establishment, signed measurements,
+unsigned measurements, challenge authentication, heartbeat, and key update.
+
 ## Testing with Nuvoton NPCT75x
 
 ```bash
@@ -122,8 +126,8 @@ cd wolfTPM
 ./configure --enable-spdm --enable-nuvoton --with-wolfspdm=path/to/wolfspdm
 make
 
-# Run test suite
-./examples/spdm/spdm_test.sh
+# Run Nuvoton test suite
+./examples/spdm/spdm_test.sh --nuvoton
 ```
 
 ## API Reference
@@ -143,6 +147,15 @@ make
 | `wolfSPDM_EncryptMessage()` | Encrypt outgoing message |
 | `wolfSPDM_DecryptMessage()` | Decrypt incoming message |
 | `wolfSPDM_SecuredExchange()` | Combined send/receive |
+| `wolfSPDM_SetTrustedCAs()` | Load trusted root CA certificates for chain validation |
+| `wolfSPDM_GetMeasurements()` | Retrieve device measurements with optional signature verification |
+| `wolfSPDM_GetMeasurementCount()` | Get number of measurement blocks retrieved |
+| `wolfSPDM_GetMeasurementBlock()` | Access individual measurement block data |
+| `wolfSPDM_Challenge()` | Sessionless device attestation via CHALLENGE/CHALLENGE_AUTH |
+| `wolfSPDM_Heartbeat()` | Session keep-alive (HEARTBEAT/HEARTBEAT_ACK) |
+| `wolfSPDM_KeyUpdate()` | Rotate session encryption keys (KEY_UPDATE/KEY_UPDATE_ACK) |
+| `wolfSPDM_SendData()` | Send application data over established session |
+| `wolfSPDM_ReceiveData()` | Receive application data over established session |
 
 ## License
 

src/spdm_context.c

@@ -102,6 +102,19 @@ void wolfSPDM_Free(WOLFSPDM_CTX* ctx)
         wc_ecc_free(&ctx->ephemeralKey);
     }
 
+    /* Free responder public key (used for measurement/challenge verification) */
+    if (ctx->hasResponderPubKey) {
+        wc_ecc_free(&ctx->responderPubKey);
+    }
+
+#ifndef NO_WOLFSPDM_CHALLENGE
+    /* Free M1/M2 challenge hash if still initialized */
+    if (ctx->m1m2HashInit) {
+        wc_Sha384Free(&ctx->m1m2Hash);
+        ctx->m1m2HashInit = 0;
+    }
+#endif
+
     /* Zero entire struct (covers all sensitive key material) */
     wc_ForceZero(ctx, sizeof(WOLFSPDM_CTX));
 
@@ -203,6 +216,24 @@ int wolfSPDM_SetRequesterKeyTPMT(WOLFSPDM_CTX* ctx,
 }
 #endif /* WOLFSPDM_NUVOTON */
 
+int wolfSPDM_SetTrustedCAs(WOLFSPDM_CTX* ctx, const byte* derCerts,
+    word32 derCertsSz)
+{
+    if (ctx == NULL || derCerts == NULL || derCertsSz == 0) {
+        return WOLFSPDM_E_INVALID_ARG;
+    }
+
+    if (derCertsSz > WOLFSPDM_MAX_CERT_CHAIN) {
+        return WOLFSPDM_E_BUFFER_SMALL;
+    }
+
+    XMEMCPY(ctx->trustedCAs, derCerts, derCertsSz);
+    ctx->trustedCAsSz = derCertsSz;
+    ctx->hasTrustedCAs = 1;
+
+    return WOLFSPDM_SUCCESS;
+}
+
 void wolfSPDM_SetDebug(WOLFSPDM_CTX* ctx, int enable)
 {
     if (ctx != NULL) {
@@ -339,6 +370,22 @@ static int wolfSPDM_ConnectStandard(WOLFSPDM_CTX* ctx)
         return rc;
     }
 
+    /* Validate certificate chain if trusted CAs are loaded.
+     * Public key extraction now happens automatically in GetCertificate. */
+    if (ctx->hasTrustedCAs) {
+        rc = wolfSPDM_ValidateCertChain(ctx);
+        if (rc != WOLFSPDM_SUCCESS) {
+            wolfSPDM_DebugPrint(ctx,
+                "Certificate chain validation failed (%d)\n", rc);
+            ctx->state = WOLFSPDM_STATE_ERROR;
+            return rc;
+        }
+    }
+    else if (!ctx->hasResponderPubKey) {
+        wolfSPDM_DebugPrint(ctx,
+            "Warning: No trusted CAs loaded — chain not validated\n");
+    }
+
     /* Step 6: KEY_EXCHANGE / KEY_EXCHANGE_RSP */
     wolfSPDM_DebugPrint(ctx, "Step 6: KEY_EXCHANGE\n");
     rc = wolfSPDM_KeyExchange(ctx);
@@ -482,6 +529,58 @@ void wolfSPDM_DebugHex(WOLFSPDM_CTX* ctx, const char* label,
     fflush(stdout);
 }
 
+/* ==========================================================================
+ * Measurement Accessors
+ * ========================================================================== */
+
+#ifndef NO_WOLFSPDM_MEAS
+
+int wolfSPDM_GetMeasurementCount(WOLFSPDM_CTX* ctx)
+{
+    if (ctx == NULL || !ctx->hasMeasurements) {
+        return 0;
+    }
+    return (int)ctx->measBlockCount;
+}
+
+int wolfSPDM_GetMeasurementBlock(WOLFSPDM_CTX* ctx, int blockIdx,
+    byte* measIndex, byte* measType, byte* value, word32* valueSz)
+{
+    WOLFSPDM_MEAS_BLOCK* blk;
+
+    if (ctx == NULL || !ctx->hasMeasurements) {
+        return WOLFSPDM_E_INVALID_ARG;
+    }
+    if (blockIdx < 0 || blockIdx >= (int)ctx->measBlockCount) {
+        return WOLFSPDM_E_INVALID_ARG;
+    }
+    if (valueSz == NULL) {
+        return WOLFSPDM_E_INVALID_ARG;
+    }
+
+    blk = &ctx->measBlocks[blockIdx];
+
+    if (measIndex != NULL) {
+        *measIndex = blk->index;
+    }
+    if (measType != NULL) {
+        *measType = blk->dmtfType;
+    }
+
+    if (value != NULL) {
+        word32 copySize = blk->valueSize;
+        if (copySize > *valueSz) {
+            copySize = *valueSz;
+        }
+        XMEMCPY(value, blk->value, copySize);
+    }
+    *valueSz = blk->valueSize;
+
+    return WOLFSPDM_SUCCESS;
+}
+
+#endif /* !NO_WOLFSPDM_MEAS */
+
 /* ==========================================================================
  * Error String
  * ========================================================================== */
@@ -510,6 +609,12 @@ const char* wolfSPDM_GetErrorString(int error)
         case WOLFSPDM_E_ALGO_MISMATCH:    return "Algorithm mismatch";
         case WOLFSPDM_E_SESSION_INVALID:  return "Invalid session";
         case WOLFSPDM_E_KEY_EXCHANGE:     return "Key exchange failed";
+        case WOLFSPDM_E_MEASUREMENT:     return "Measurement retrieval failed";
+        case WOLFSPDM_E_MEAS_NOT_VERIFIED: return "Measurements not signature-verified";
+        case WOLFSPDM_E_MEAS_SIG_FAIL:   return "Measurement signature verification failed";
+        case WOLFSPDM_E_CERT_PARSE:      return "Failed to parse responder certificate";
+        case WOLFSPDM_E_CHALLENGE:       return "Challenge authentication failed";
+        case WOLFSPDM_E_KEY_UPDATE:      return "Key update failed";
         default:                          return "Unknown error";
     }
 }

src/spdm_internal.h

@@ -45,6 +45,7 @@
 #include <wolfssl/wolfcrypt/kdf.h>
 #include <wolfssl/wolfcrypt/aes.h>
 #include <wolfssl/wolfcrypt/memory.h>
+#include <wolfssl/wolfcrypt/asn_public.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -64,6 +65,23 @@ extern "C" {
 #define WOLFSPDM_STATE_FINISH       7   /* FINISH complete */
 #define WOLFSPDM_STATE_CONNECTED    8   /* Session established */
 #define WOLFSPDM_STATE_ERROR        9   /* Error state */
+#ifndef NO_WOLFSPDM_MEAS
+#define WOLFSPDM_STATE_MEASURED     10  /* Measurements retrieved */
+#endif
+
+/* ==========================================================================
+ * Measurement Block Structure
+ * ========================================================================== */
+
+#ifndef NO_WOLFSPDM_MEAS
+typedef struct WOLFSPDM_MEAS_BLOCK {
+    byte   index;                                   /* SPDM measurement index (1-based) */
+    byte   measurementSpec;                         /* Measurement specification (1=DMTF) */
+    byte   dmtfType;                                /* DMTFSpecMeasurementValueType */
+    word16 valueSize;                               /* Actual value size in bytes */
+    byte   value[WOLFSPDM_MAX_MEAS_VALUE_SIZE];     /* Measurement value (digest/raw) */
+} WOLFSPDM_MEAS_BLOCK;
+#endif /* !NO_WOLFSPDM_MEAS */
 
 /* ==========================================================================
  * Internal Context Structure
@@ -117,6 +135,7 @@ struct WOLFSPDM_CTX {
     /* Transcript hash for TH1/TH2 computation */
     byte transcript[WOLFSPDM_MAX_TRANSCRIPT];
     word32 transcriptLen;
+    word32 vcaLen;  /* VCA transcript size (after ALGORITHMS, used by measurement sig) */
 
     /* Certificate chain buffer for Ct computation */
     byte certChain[WOLFSPDM_MAX_CERT_CHAIN];
@@ -164,6 +183,52 @@ struct WOLFSPDM_CTX {
     /* Message buffers */
     byte sendBuf[WOLFSPDM_MAX_MSG_SIZE + WOLFSPDM_AEAD_TAG_SIZE];
     byte recvBuf[WOLFSPDM_MAX_MSG_SIZE + WOLFSPDM_AEAD_TAG_SIZE];
+
+#ifndef NO_WOLFSPDM_MEAS
+    /* Measurement data */
+    WOLFSPDM_MEAS_BLOCK measBlocks[WOLFSPDM_MAX_MEAS_BLOCKS];
+    word32 measBlockCount;
+    byte   measNonce[32];                           /* Nonce for signed measurements */
+    byte   measSummaryHash[WOLFSPDM_HASH_SIZE];     /* Summary hash from response */
+    byte   measSignature[WOLFSPDM_ECC_SIG_SIZE];    /* Captured signature (96 bytes P-384) */
+    word32 measSignatureSize;                       /* 0 if unsigned, 96 if signed */
+    int    hasMeasurements;
+
+#ifndef NO_WOLFSPDM_MEAS_VERIFY
+    /* Saved GET_MEASUREMENTS request for L1/L2 transcript */
+    byte            measReqMsg[48];                 /* Saved request (max 37 bytes) */
+    word32          measReqMsgSz;
+#endif /* !NO_WOLFSPDM_MEAS_VERIFY */
+#endif /* !NO_WOLFSPDM_MEAS */
+
+    /* Responder identity for signature verification (measurements + challenge) */
+    ecc_key         responderPubKey;                /* Extracted from cert chain leaf */
+    int             hasResponderPubKey;             /* 1 if key extracted successfully */
+
+    /* Certificate chain validation */
+    byte   trustedCAs[WOLFSPDM_MAX_CERT_CHAIN];    /* DER-encoded root CAs */
+    word32 trustedCAsSz;
+    int    hasTrustedCAs;                           /* 1 if CAs loaded */
+
+#ifndef NO_WOLFSPDM_CHALLENGE
+    /* Challenge authentication */
+    byte   challengeNonce[32];                      /* Saved nonce from CHALLENGE request */
+    byte   challengeMeasHashType;                   /* MeasurementSummaryHashType from req */
+
+    /* Running M1/M2 hash for CHALLENGE_AUTH signature verification.
+     * Per DSP0274, M1/M2 = A || B || C where:
+     *   A = VCA (GET_VERSION..ALGORITHMS)
+     *   B = GET_DIGESTS + DIGESTS + GET_CERTIFICATE + CERTIFICATE (all chunks)
+     *   C = CHALLENGE + CHALLENGE_AUTH (before sig)
+     * This hash accumulates A+B during NegAlgo/GetDigests/GetCertificate,
+     * then C is added in VerifyChallengeAuthSig. */
+    wc_Sha384 m1m2Hash;
+    int       m1m2HashInit;                         /* 1 if m1m2Hash is initialized */
+#endif
+
+    /* Key update state — app secrets for re-derivation */
+    byte   reqAppSecret[WOLFSPDM_HASH_SIZE];        /* 48 bytes */
+    byte   rspAppSecret[WOLFSPDM_HASH_SIZE];        /* 48 bytes */
 };
 
 /* ==========================================================================
@@ -315,6 +380,81 @@ void wolfSPDM_DebugPrint(WOLFSPDM_CTX* ctx, const char* fmt, ...);
 void wolfSPDM_DebugHex(WOLFSPDM_CTX* ctx, const char* label,
     const byte* data, word32 len);
 
+/* ==========================================================================
+ * Internal Function Declarations - Measurements
+ * ========================================================================== */
+
+#ifndef NO_WOLFSPDM_MEAS
+/* Build GET_MEASUREMENTS request */
+int wolfSPDM_BuildGetMeasurements(WOLFSPDM_CTX* ctx, byte* buf, word32* bufSz,
+    byte operation, byte requestSig);
+
+/* Parse MEASUREMENTS response */
+int wolfSPDM_ParseMeasurements(WOLFSPDM_CTX* ctx, const byte* buf, word32 bufSz);
+
+#ifndef NO_WOLFSPDM_MEAS_VERIFY
+/* Verify measurement signature (L1/L2 transcript) */
+int wolfSPDM_VerifyMeasurementSig(WOLFSPDM_CTX* ctx,
+    const byte* rspBuf, word32 rspBufSz,
+    const byte* reqMsg, word32 reqMsgSz);
+#endif /* !NO_WOLFSPDM_MEAS_VERIFY */
+#endif /* !NO_WOLFSPDM_MEAS */
+
+/* ==========================================================================
+ * Internal Function Declarations - Certificate Chain Validation
+ * ========================================================================== */
+
+/* Extract responder's public key from certificate chain leaf cert */
+int wolfSPDM_ExtractResponderPubKey(WOLFSPDM_CTX* ctx);
+
+/* Validate certificate chain using trusted CAs and extract public key */
+int wolfSPDM_ValidateCertChain(WOLFSPDM_CTX* ctx);
+
+/* ==========================================================================
+ * Internal Function Declarations - Challenge
+ * ========================================================================== */
+
+#ifndef NO_WOLFSPDM_CHALLENGE
+/* Build CHALLENGE request */
+int wolfSPDM_BuildChallenge(WOLFSPDM_CTX* ctx, byte* buf, word32* bufSz,
+    int slotId, byte measHashType);
+
+/* Parse CHALLENGE_AUTH response */
+int wolfSPDM_ParseChallengeAuth(WOLFSPDM_CTX* ctx, const byte* buf,
+    word32 bufSz, word32* sigOffset);
+
+/* Verify CHALLENGE_AUTH signature */
+int wolfSPDM_VerifyChallengeAuthSig(WOLFSPDM_CTX* ctx,
+    const byte* rspBuf, word32 rspBufSz,
+    const byte* reqMsg, word32 reqMsgSz, word32 sigOffset);
+#endif /* !NO_WOLFSPDM_CHALLENGE */
+
+/* ==========================================================================
+ * Internal Function Declarations - Heartbeat
+ * ========================================================================== */
+
+/* Build HEARTBEAT request */
+int wolfSPDM_BuildHeartbeat(WOLFSPDM_CTX* ctx, byte* buf, word32* bufSz);
+
+/* Parse HEARTBEAT_ACK response */
+int wolfSPDM_ParseHeartbeatAck(WOLFSPDM_CTX* ctx, const byte* buf,
+    word32 bufSz);
+
+/* ==========================================================================
+ * Internal Function Declarations - Key Update
+ * ========================================================================== */
+
+/* Build KEY_UPDATE request */
+int wolfSPDM_BuildKeyUpdate(WOLFSPDM_CTX* ctx, byte* buf, word32* bufSz,
+    byte operation, byte* tag);
+
+/* Parse KEY_UPDATE_ACK response */
+int wolfSPDM_ParseKeyUpdateAck(WOLFSPDM_CTX* ctx, const byte* buf,
+    word32 bufSz, byte operation, byte tag);
+
+/* Derive updated keys from saved app secrets */
+int wolfSPDM_DeriveUpdatedKeys(WOLFSPDM_CTX* ctx, int updateAll);
+
 #ifdef __cplusplus
 }
 #endif