SPDM_V1_4

SPDM_DOE_V1_4_Test_001_001.py

Description: SPDM responder shall return valid VERSION, if it receives a GET_VERSION with version 1.0.

SPDM Version: 1.0+

TestSetup: None

TestTeardown: None

Steps: 1. Requester -> GET_VERSION {SPDMVersion=0x10, Param1=0, Param2=0} 2. SpdmMessage <- Responder

Assertion 1.1.1:

sizeof(SpdmMessage) >= offset(VERSION, VersionNumberEntry)

Assertion 1.1.2:

SpdmMessage.RequestResponseCode == VERSION

Assertion 1.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 1.1.4:

SpdmMessage.VersionNumberEntryCount > 0 && SpdmMessage.VersionNumberEntryCount <= (sizeof(SpdmMessage) - offset(VERSION, VersionNumberEntry)) / sizeof(uint16_t)

Assertion 1.1.5:

((SpdmMessage.VersionNumberEntry[i].MajorVersion << 4) + SpdmMessage.VersionNumberEntry[i].MinorVersion) is in {0x10, 0x11, 0x12, 0x13, 0x14}.

SPDM_DOE_V1_4_Test_002_001.py

Description: SPDM responder shall return valid CAPABILITIES(0x10), if it receives a GET_CAPABILITIES with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x10, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 2.1.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.0)

Assertion 2.1.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 2.1.4:

Flags.MEAS_CAP != 3

###

SPDM_DOE_V1_4_Test_002_003.py

Description: SPDM responder shall return valid CAPABILITIES(0x11), if it receives a GET_CAPABILITIES with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x11, Param1=0, Param2=0, CTExponent, Flags=CERT_CAP|CHAL_CAP|ENCRYPT_CAP|MAC_CAP|MUT_AUTH_CAP|KEY_EX_CAP|PSK_CAP=1|ENCAP_CAP|HBEAT_CAP|KEY_UPD_CAP}

2. SpdmMessage <- Responder

Assertion 2.3.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.1)

Assertion 2.3.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.3.3:

SpdmMessage.SPDMVersion == 0x11

Assertion 2.3.4:

Flags.MEAS_CAP != 3

Assertion 2.3.5:

if (Flags.ENCRYPT_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.3.6:

if (Flags.MAC_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.3.7:

if (Flags.KEY_EX_CAP == 1), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.3.8:

Flags.PSK_CAP != 3

Assertion 2.3.9:

if (Flags.PSK_CAP != 0), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.3.10:

if (Flags.MUT_AUTH_CAP == 1), then (Flags.ENCAP_CAP == 1)

Assertion 2.3.11:

if (Flags.HANDSHAKE_IN_THE_CLEAR_CAP == 1), then (Flags.KEY_EX_CAP == 1)

Assertion 2.3.12:

if (Flags.PUB_KEY_ID_CAP == 1), then (Flags.CERT_CAP == 0)

Assertion 2.3.13:

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (CERT_CAP == 1 || PUB_KEY_ID_CAP == 1)

###

SPDM_DOE_V1_4_Test_002_005.py

Description: SPDM responder shall return valid CAPABILITIES(0x12), if it receives a GET_CAPABILITIES with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x12, Param1=0, Param2=0, CTExponent, Flags=CERT_CAP|CHAL_CAP|ENCRYPT_CAP|MAC_CAP|MUT_AUTH_CAP|KEY_EX_CAP|PSK_CAP=1|ENCAP_CAP|HBEAT_CAP|KEY_UPD_CAP|CHUNK_CAP, DataTransferSize, MaxSPDMmsgSize}

2. SpdmMessage <- Responder

Assertion 2.5.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.2)

Assertion 2.5.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.5.3:

SpdmMessage.SPDMVersion == 0x12

Assertion 2.5.4:

Flags.MEAS_CAP != 3

Assertion 2.5.5:

if (Flags.ENCRYPT_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.5.6:

if (Flags.MAC_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.5.7:

if (Flags.KEY_EX_CAP == 1), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.5.8:

Flags.PSK_CAP != 3

Assertion 2.5.9:

if (Flags.PSK_CAP != 0), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.5.10:

if (Flags.MUT_AUTH_CAP == 1), then (Flags.ENCAP_CAP == 1)

Assertion 2.5.11:

if (Flags.HANDSHAKE_IN_THE_CLEAR_CAP == 1), then (Flags.KEY_EX_CAP == 1)

Assertion 2.5.12:

if (Flags.PUB_KEY_ID_CAP == 1), then (Flags.CERT_CAP == 0)

Assertion 2.5.13:

SpdmMessage.DataTransferSize >= MinDataTransferSize

Assertion 2.5.14:

SpdmMessage.MaxSPDMmsgSize >= SpdmMessage.DataTransferSize

Assertion 2.5.15:

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (CERT_CAP == 1 || PUB_KEY_ID_CAP == 1)

###

SPDM_DOE_V1_4_Test_003_001.py

Description: SPDM responder shall return valid ALGORITHMS(0x10), if it receives a GET_ALGORITHMS with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x10, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x10, Param1=0, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0}

2. SpdmMessage <- Responder

Assertion 3.1.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.0)

Assertion 3.1.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 3.1.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.0, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount

Assertion 3.1.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.1.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.1.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.1.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.1.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521}) if (CHAL_CAP == 0 && MEAS_CAP != 2) then (BaseAsymSel == 0)

Assertion 3.1.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (CHAL_CAP == 0 && MEAS_CAP != 2) then (BaseHashSel == 0)

###

SPDM_DOE_V1_4_Test_003_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a NEGOTIATE_ALGORITHMS with non negotiated version.

SPDM Version: 1.0+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
4. CAPABILITIES <- Responder

TestTeardown: None

Steps:
1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=(NegotiatedVersion+1), ...}
2. SpdmMessage <- Responder

Assertion 3.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)
Assertion 3.2.2:
    SpdmMessage.RequestResponseCode == ERROR
Assertion 3.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion
Assertion 3.2.4:
    SpdmMessage.Param1 == VersionMismatch.
Assertion 3.2.5:
    SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=(NegotiatedVersion-1), ...}
4. SpdmMessage <- Responder
Assertion 3.2.*.

SPDM_DOE_V1_4_Test_003_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a NEGOTIATE_ALGORITHMS with invalid field.

SPDM Version: 1.0+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 4. CAPABILITIES <- Responder

TestTeardown: None

Steps: 1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Length-1, …} – if NegotiatedVersion=1.0+ 2. SpdmMessage <- Responder

Assertion 3.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 3.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 3.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 3.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 3.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Length+1, …} – if NegotiatedVersion=1.0+

4. SpdmMessage <- Responder

Assertion 3.4.*.

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ExtAsymCount=21, …} – if NegotiatedVersion=1.0+

6. SpdmMessage <- Responder

Assertion 3.4.*.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ExtHashCount=21, …} – if NegotiatedVersion=1.0+

8. SpdmMessage <- Responder

Assertion 3.4.*.

9. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=1, …} – if NegotiatedVersion=1.1+

10. SpdmMessage <- Responder

Assertion 3.4.*.

11. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=3, …} – if NegotiatedVersion=1.1+

12. SpdmMessage <- Responder

Assertion 3.4.*.

13. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=2, ExtAlgCount=0xF, …} – if NegotiatedVersion=1.1+

14. SpdmMessage <- Responder

Assertion 3.4.*.

SPDM_DOE_V1_4_Test_003_005.py

Description: SPDM responder shall return valid ALGORITHMS(0x11), if it receives a GET_ALGORITHMS with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x11, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x11, Param1.NumOfAlgoStruct=4, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0, ReqAlgStruct[0]{AlgType=DHE, AlgSupported=ffdhe2048|ffdhe3072|ffdhe4096|secp256r1|secp384r1|secp521r1}, ReqAlgStruct[1]{AlgType=AEAD, AlgSupported=AES-128-GCM|AES-256-GCM|CHACHA20_POLY1305}, ReqAlgStruct[2]{AlgType=ReqBaseAsymAlg, AlgSupported=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521}, ReqAlgStruct[3]{AlgType=KeySchedule, AlgSupported=SPDM} }

2. SpdmMessage <- Responder

Assertion 3.5.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.1)

Assertion 3.5.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.5.3:

SpdmMessage.SPDMVersion == 0x11

Assertion 3.5.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.1, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.5.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.5.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.5.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.5.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.5.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0) then (BaseAsymSel == 0)

Assertion 3.5.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0) then (BaseHashSel == 0)

Assertion 3.5.11:

SpdmMessage.Param1 <= 4 SpdmMessage.AlgStructure[i].AlgType is in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule} and no duplication.

Assertion 3.5.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.5.13:

DHE only has one bit at most.

if (KEY_EX_CAP == 1) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1} if (KEY_EX_CAP == 0) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent

Assertion 3.5.14:

AEAD only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305} if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0, or it is absent

Assertion 3.5.15:

ReqBaseAsymAlg only has one bit at most.

if (MUT_AUTH_CAP == 1) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521} if (MUT_AUTH_CAP == 0) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0, or it is absent

Assertion 3.5.16:

KeySchedule only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0, or it is absent

###

SPDM_DOE_V1_4_Test_003_006.py

Description: SPDM responder shall return valid ALGORITHMS(0x12), if it receives a GET_ALGORITHMS with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x12, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x12, Param1.NumOfAlgoStruct=4, Param2=0, MeasurementSpecification=DMTF, OtherParamsSupport=OpaqueDataFmt1, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521|TPM_ALG_SM2_ECC_SM2_P256|EdDSA_ed25519|EdDSA_ed448, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512|TPM_ALG_SM3_256, ExtAsymCount=0, ExtHashCount=0, ReqAlgStruct[0]{AlgType=DHE, AlgSupported=ffdhe2048|ffdhe3072|ffdhe4096|secp256r1|secp384r1|secp521r1|SM2_P256}, ReqAlgStruct[1]{AlgType=AEAD, AlgSupported=AES-128-GCM|AES-256-GCM|CHACHA20_POLY1305|AEAD_SM4_GCM}, ReqAlgStruct[2]{AlgType=ReqBaseAsymAlg, AlgSupported=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521|TPM_ALG_SM2_ECC_SM2_P256|EdDSA_ed25519|EdDSA_ed448}, ReqAlgStruct[3]{AlgType=KeySchedule, AlgSupported=SPDM} }

2. SpdmMessage <- Responder

Assertion 3.6.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.2)

Assertion 3.6.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.6.3:

SpdmMessage.SPDMVersion == 0x12

Assertion 3.6.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.1, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.6.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.6.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.6.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.6.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.6.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0) then (BaseAsymSel == 0)

Assertion 3.6.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0) then (BaseHashSel == 0)

Assertion 3.6.11:

SpdmMessage.Param1 <= 4 SpdmMessage.AlgStructure[i].AlgType is in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule} and no duplication.

Assertion 3.6.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.6.13:

SpdmMessage.AlgStructure[DHE_index] only has one bit at most.

if (KEY_EX_CAP == 1) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1, SM2_P256} if (KEY_EX_CAP == 0) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent

Assertion 3.6.14:

SpdmMessage.AlgStructure[AEAD_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305, AEAD_SM4_GCM} if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0, or it is absent

Assertion 3.6.15:

SpdmMessage.AlgStructure[ReqBaseAsymAlg_index] only has one bit at most.

if (MUT_AUTH_CAP == 1) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448} if (MUT_AUTH_CAP == 0) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0, or it is absent

Assertion 3.6.16:

SpdmMessage.AlgStructure[KeySchedule_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0, or it is absent

Assertion 3.6.17:

SpdmMessage.OpaqueDataFmt only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then OtherParamsSupport.OpaqueDataFmt == OpaqueDataFmt1

###

SPDM_DOE_V1_4_Test_003_007.py

Description: SPDM responder shall return ERROR(UnexpectedRequest) or silent drop, if it receives two non-identical NEGOTIATE_ALGORITHMS.

SPDM Version: 1.0+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
4. CAPABILITIES <- Responder
5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0}
6. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=1, ...} -- if NegotiatedVersion=1.0+
2. SpdmMessage <- Responder
Assertion 3.7.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)
Assertion 3.7.2:
    SpdmMessage.RequestResponseCode == ERROR
Assertion 3.7.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion
Assertion 3.7.4:
    SpdmMessage.Param1 == UnexpectedRequest.
Assertion 3.7.5:
    SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, MeasurementSpecification=DMTF, BaseAsymAlgo=BaseAsymSel, BaseHashAlgo=BaseHashSel, ...} -- if NegotiatedVersion=1.0+
4. SpdmMessage <- Responder
Assertion 3.7.*.

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Dhe=DheSel, Aead=AeadSel, BaseReqAsymAlg=BaseReqAsymSel, ...} -- if NegotiatedVersion=1.1+
6. SpdmMessage <- Responder
Assertion 3.7.*.

SPDM_DOE_V1_4_Test_003_009.py

Description: SPDM responder shall return valid ALGORITHMS(0x14), if it receives a NEGOTIATE_ALGORITHMS with negotiated version 1.4.

SPDM Version: 1.4 only

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=0x14, …} 5. CAPABILITIES <- Responder

TestTeardown: None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {
    SPDMVersion=0x14,
    Param1.NumOfAlgoStruct=6,
    Param2=0,
    MeasurementSpecification=DMTF,
    OtherParamsSupport=OpaqueDataFmt1,
    BaseAsymAlgo=TPM_ALG_RSASSA_2048 |
                TPM_ALG_RSAPSS_2048 |
                TPM_ALG_RSASSA_3072 |
                TPM_ALG_RSAPSS_3072 |
                TPM_ALG_ECDSA_ECC_NIST_P256 |
                TPM_ALG_RSASSA_4096 |
                TPM_ALG_RSAPSS_4096 |
                TPM_ALG_ECDSA_ECC_NIST_P384 |
                TPM_ALG_ECDSA_ECC_NIST_P521 |
                TPM_ALG_SM2_ECC_SM2_P256 |
                EdDSA_ed25519|EdDSA_ed448,
    BaseHashAlgo=TPM_ALG_SHA_256 |
                TPM_ALG_SHA_384 |
                TPM_ALG_SHA_512 |
                TPM_ALG_SHA3_256 |
                TPM_ALG_SHA3_384 |
                TPM_ALG_SHA3_512 |
                TPM_ALG_SM3_256,
    PqcAsymAlgo=ML-DSA-44|ML-DSA-65 |
                ML-DSA-87 |
                SLH-DSA-SHA2-128s |
                SLH-DSA-SHAKE-128s |
                SLH-DSA-SHA2-128f |
                SLH-DSA-SHAKE-128f |
                SLH-DSA-SHA2-192s |
                SLH-DSA-SHAKE-192s |
                SLH-DSA-SHA2-192f |
                SLH-DSA-SHAKE-192f |
                SLH-DSA-SHA2-256s |
                SLH-DSA-SHAKE-256s |
                SLH-DSA-SHA2-256f |
                SLH-DSA-SHAKE-256f,
    ExtAsymCount=0,
    ExtHashCount=0,
    MELspecification=DMTFmelSpec,
    ReqAlgStruct[0..5]={DHE, AEAD, ReqBaseAsymAlg, KeySchedule, ReqPqcAsymAlg, KEMAlg}}

2. SpdmMessage <- Responder

Assertion 3.9.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.4)

Assertion 3.9.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.9.3:

SpdmMessage.SPDMVersion == 0x14

Assertion 3.9.4:

SpdmMessage.Length <= sizeof(SpdmMessage) SpdmMessage.Length == offset(ALGORITHMS_1.4, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.9.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.9.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.9.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || == 0.

if (MEAS_CAP != 0 || MEL_CAP == 1)

then MeasurementSpecificationSel != 0

Assertion 3.9.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) (MeasurementHashAlgo == one of {

Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256})

if (MEAS_CAP == 0) then MeasurementHashAlgo == 0.

Assertion 3.9.9:

SpdmMessage.BaseAsymSel and SpdmMessage.PqcAsymSel only have one bit set at most.

if ((CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) && BaseAsymSel != 0)

then (BaseAsymSel == one of {

TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448})

if ((CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) && PqcAsymSel != 0)

then (PqcAsymSel == one of {

ML-DSA-44, ML-DSA-65, ML-DSA-87, SLH-DSA-SHA2-128s, SLH-DSA-SHAKE-128s, SLH-DSA-SHA2-128f, SLH-DSA-SHAKE-128f, SLH-DSA-SHA2-192s, SLH-DSA-SHAKE-192s, SLH-DSA-SHA2-192f, SLH-DSA-SHAKE-192f, SLH-DSA-SHA2-256s, SLH-DSA-SHAKE-256s, SLH-DSA-SHA2-256f, SLH-DSA-SHAKE-256f})

if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0)

then (BaseAsymSel == 0 && PqcAsymSel == 0)

Assertion 3.9.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0)

then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256})

if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0)

then (BaseHashSel == 0)

Assertion 3.9.11:

SpdmMessage.Param1 <= 6 AlgStructure[i].AlgType in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule, ReqPqcAsymAlg, KEMAlg} and no duplication. AlgStructure[i].AlgType monotonically increases.

Assertion 3.9.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.9.13:

SpdmMessage.AlgStructure[DHE_index] and SpdmMessage.AlgStructure[KEMAlg_index] only have one bit set at most.

if (KEY_EX_CAP == 1)

then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {

ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1, SM2_P256} || KEMAlg.AlgSupported == one of {ML-KEM-512, ML-KEM-768, ML-KEM-1024}

if (KEY_EX_CAP == 0)

then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent && SpdmMessage.AlgStructure[KEMAlg_index].AlgSupported == 0, or it is absent

Assertion 3.9.14:

SpdmMessage.AlgStructure[AEAD_index] only has one bit set at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305, AEAD_SM4_GCM}

else SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0 or it is absent

Assertion 3.9.15:

SpdmMessage.AlgStructure[ReqBaseAsymAlg_index] and SpdmMessage.AlgStructure[ReqPqcAsymAlg_index] only have one bit set at most.

if (MUT_AUTH_CAP == 1)

then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {

TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448}

|| SpdmMessage.AlgStructure[ReqPqcAsymAlg_index].AlgSupported == one of {

ML-DSA-44, ML-DSA-65, ML-DSA-87, SLH-DSA-SHA2-128s, SLH-DSA-SHAKE-128s, SLH-DSA-SHA2-128f, SLH-DSA-SHAKE-128f, SLH-DSA-SHA2-192s, SLH-DSA-SHAKE-192s, SLH-DSA-SHA2-192f, SLH-DSA-SHAKE-192f, SLH-DSA-SHA2-256s, SLH-DSA-SHAKE-256s, SLH-DSA-SHA2-256f, SLH-DSA-SHAKE-256f}.

if (MUT_AUTH_CAP == 0)

then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0 or it is absent && SpdmMessage.AlgStructure[ReqPqcAsymAlg_index].AlgSupported == 0 or it is absent

Assertion 3.9.16:

SpdmMessage.AlgStructure[KeySchedule_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM

else SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0 or it is absent

Assertion 3.9.17:

SpdmMessage.OpaqueDataFmt only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then OtherParamsSupport.OpaqueDataFmt == OpaqueDataFmt1

Assertion 3.9.18:

SpdmMessage.MELspecificationSel only has one bit at most.

if (MEL_CAP == 1)

then SpdmMessage.MELspecificationSel == DMTFmelSpec.

if (MEL_CAP == 0)

then SpdmMessage.MELspecificationSel == 0

SPDM_DOE_V1_4_Test_004_001.py

Description: SPDM responder shall return valid DIGESTS, if it receives a GET_DIGESTS.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 4.1.1:

sizeof(SpdmMessage) >= offset(DIGESTS, Digest[0])

Assertion 4.1.2:

SpdmMessage.RequestResponseCode == DIGESTS

Assertion 4.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.1.4:

SpdmMessage.Param2.SlotMask.bit_0 == 1

Assertion 4.1.5:

SlotCount = bit number of SpdmMessage.Param2.SlotMask sizeof(SpdmMessage) >= offset(DIGESTS, Digest[0]) + HashSize * SlotCount

###

SPDM_DOE_V1_4_Test_004_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_DIGESTS with non negotiated version.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=(NegotiatedVersion+1), …}

2. SpdmMessage <- Responder

Assertion 4.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 4.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 4.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 4.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_DIGESTS {SPDMVersion=(NegotiatedVersion-1), …}

4. SpdmMessage <- Responder

Assertion 4.2.*.

###

SPDM_DOE_V1_4_Test_005_001.py

Description: SPDM responder shall return valid CERTIFICATE, if it receives a GET_CERTIFICATE.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

10. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

11. Digests[] = array of DIGESTS.Digest

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=0, Offset=0, Length=0x400}

2. SpdmMessage <- Responder

Assertion 5.1.1:

sizeof(SpdmMessage) >= sizeof(CERTIFICATE, CertChain)

Assertion 5.1.2:

SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.1.4:

SpdmMessage.PortionLength > 0 SpdmMessage.PortionLength <= GET_CERTIFICATE.Length

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=0, Offset=NextOffset, Length=0x400}, while SpdmMessage.RemainderLength != 0

4. SpdmMessage <- Responder

Assertion 5.1.*.

Assertion 5.1.5:

CertChain.Length == sizeof(CertChain)

Assertion 5.1.6:

Hash(CertChain) == Digests[i]

###

SPDM_DOE_V1_4_Test_005_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_CERTIFICATE with non negotiated version.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=(NegotiatedVersion+1), …}

2. SpdmMessage <- Responder

Assertion 5.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 5.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CERTIFICATE {SPDMVersion=(NegotiatedVersion-1), …}

4. SpdmMessage <- Responder

Assertion 5.2.*.

###

SPDM_DOE_V1_4_Test_005_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a GET_CERTIFICATE with invalid field.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

10. InvalidSlotID[] = array of bit-index that SlotMask[bit-index]=0 from DIGEST.Param2.SlotMask + {0x8 ~ 0xE, 0xF}

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=InvalidSlotID[i], Param2=0, Offset=0, Length=0x400}

2. SpdmMessage <- Responder

Assertion 5.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 5.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=0, Param2=0, Invalid_Offset=0xFFFF, Length=0x400}

4. SpdmMessage <- Responder

Assertion 5.4.*.

###

SPDM_DOE_V1_4_Test_006_001.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B1, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

8. DIGESTS <- Responder

9. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

10. CERTIFICATE <- Responder

11. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

12. SpdmMessage <- Responder

Assertion 6.1.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.1.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.1.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.1.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.1.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.1.7:

13. Repeat (1~12) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.1.*.

14. Repeat (1~12) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.1.*.

###

SPDM_DOE_V1_4_Test_006_002.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B2, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

8. SpdmMessage <- Responder

Assertion 6.2.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.2.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.2.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.2.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.2.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.2.7:

9. Repeat (1~8) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.2.*.

10. Repeat (1~8) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.2.*.

###

SPDM_DOE_V1_4_Test_006_003.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B3, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

8. DIGESTS <- Responder

9. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

10. SpdmMessage <- Responder

Assertion 6.3.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.3.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.3.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.3.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.3.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.3.7:

11. Repeat (1~10) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.3.*.

12. Repeat (1~10) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.3.*.

###

SPDM_DOE_V1_4_Test_006_011.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B1, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

2. DIGESTS <- Responder

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

4. CERTIFICATE <- Responder

5. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

6. SpdmMessage <- Responder

Assertion 6.11.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.11.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.11.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.11.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.11.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.11.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.11.7:

7. Repeat (1~6) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.11.*.

8. Repeat (1~6) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.11.*.

###

SPDM_DOE_V1_4_Test_006_012.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B2, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

2. SpdmMessage <- Responder

Assertion 6.12.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.12.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.12.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.12.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.12.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.12.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.12.7:

3. Repeat (1~2) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.12.*.

4. Repeat (1~2) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.12.*.

###

SPDM_DOE_V1_4_Test_006_013.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B3, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

2. DIGESTS <- Responder

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

4. SpdmMessage <- Responder

Assertion 6.13.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.13.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.13.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.13.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.13.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.13.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.13.7:

5. Repeat (1~4) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.13.*.

6. Repeat (1~4) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.13.*.

###

SPDM_DOE_V1_4_Test_006_014.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B4, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

2. CERTIFICATE <- Responder

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

4. SpdmMessage <- Responder

Assertion 6.14.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.14.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.14.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.14.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.14.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.14.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.14.7:

5. Repeat (1~4) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.14.*.

6. Repeat (1~4) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.14.*.

SPDM_DOE_V1_4_Test_007_001.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements}

2. SpdmMessage <- Responder

Assertion 7.1.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.1.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.1.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.1.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2 SPDMsignatureVerify (PubKey, SpdmMessage.Signature, L1/L2) version 1.0 success, if Flags.MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements}

4. SpdmMessage <- Responder

Assertion 7.1.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.1.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.1.14:

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.1.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.1.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.1.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1]}

8. SpdmMessage <- Responder

Assertion 7.1.{15~20}

Assertion 7.1.21:

###

SPDM_DOE_V1_4_Test_007_006.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]}

2. SpdmMessage <- Responder

Assertion 7.6.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.6.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.6.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.6.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]}

4. SpdmMessage <- Responder

Assertion 7.6.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.6.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.6.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.6.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.6.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.6.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]}

8. SpdmMessage <- Responder

Assertion 7.6.{15~20}

Assertion 7.6.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

###

SPDM_DOE_V1_4_Test_007_007.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS in a DHE session with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

16. Requester -> FINISH {SPDMVersion=NegotiatedVersion, …} in session-X

17. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.7.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.7.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.7.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.7.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 7.7.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.7.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.7.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]} in session-X, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder in session-X

Assertion 7.7.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.7.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.7.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 7.7.{15~20}

Assertion 7.7.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

###

SPDM_DOE_V1_4_Test_007_008.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_MEASUREMENTS in a DHE session handshake.

SPDM Version: 1.1+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 or above is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.8.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.8.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.8.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.8.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 7.8.5:

SpdmMessage.Param2 == 0.

###

SPDM_DOE_V1_4_Test_007_009.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]}

2. SpdmMessage <- Responder

Assertion 7.9.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.9.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.9.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.9.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]}

4. SpdmMessage <- Responder

Assertion 7.9.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.9.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.9.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.9.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.9.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.9.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]}

8. SpdmMessage <- Responder

Assertion 7.9.{15~20}

Assertion 7.9.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

###

SPDM_DOE_V1_4_Test_007_010.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS in a DHE session with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

16. Requester -> FINISH {SPDMVersion=NegotiatedVersion, …} in session-X

17. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.10.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.10.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.10.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.10.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 7.10.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.10.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.10.14:

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]} in session-X, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder in session-X

Assertion 7.10.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.10.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.10.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 7.10.{15~20}

Assertion 7.10.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

SPDM_DOE_V1_4_Test_008_001.py

Description: SPDM responder shall return valid KEY_EXCHANGE_RSP, if it receives a KEY_EXCHANGE with negotiated version 1.1.

SPDM Version: 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], ReqSessionID, RandomData, ExchangeData, OpaqueData}

2. SpdmMessage <- Responder

Assertion 8.1.1:

sizeof(SpdmMessage) >= sizeof(KEY_EXCHANGE_RSP) + SpdmMessage.OpaqueDataLength

Assertion 8.1.2:

SpdmMessage.RequestResponseCode == KEY_EXCHANGE_RSP

Assertion 8.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 8.1.4:

SpdmMessage.MutAuthRequested == 0 && SpdmMessage.SlotIDParam == 0

Assertion 8.1.5:

Assertion 8.1.6:

HMACVerify (finished_key, SpdmMessage.ResponderVerifyData, TH.HMAC.KEY_EXCHANGE_RSP) version 1.1 success

3. Repeat (1~2) and use KEY_EXCHANGE {Param1=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 8.1.*.

4. Repeat (1~2) and use KEY_EXCHANGE {Param1=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 8.1.*.

###

SPDM_DOE_V1_4_Test_008_007.py

Description: SPDM responder shall return valid KEY_EXCHANGE_RSP, if it receives a KEY_EXCHANGE with negotiated version 1.2.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], ReqSessionID, SessionPolicy.TerminationPolicy=1, RandomData, ExchangeData, OpaqueData}

2. SpdmMessage <- Responder

Assertion 8.7.1:

sizeof(SpdmMessage) >= sizeof(KEY_EXCHANGE_RSP) + SpdmMessage.OpaqueDataLength

Assertion 8.7.2:

SpdmMessage.RequestResponseCode == KEY_EXCHANGE_RSP

Assertion 8.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 8.7.4:

SpdmMessage.MutAuthRequested == 0 && SpdmMessage.SlotIDParam == 0

Assertion 8.7.5:

Assertion 8.7.6:

HMACVerify (finished_key, SpdmMessage.ResponderVerifyData, TH.HMAC.KEY_EXCHANGE_RSP) version 1.2 success

3. Repeat (1~2) and use KEY_EXCHANGE {Param1=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 8.7.*.

4. Repeat (1~2) and use KEY_EXCHANGE {Param1=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 8.7.*.

###

SPDM_DOE_V1_4_Test_009_001.py

Description: SPDM responder shall return valid FINISH_RSP, if it receives a FINISH with negotiated version 1.1.

SPDM Version: 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 9.1.1:

sizeof(SpdmMessage) >= sizeof(FINISH_RSP) - HMAC size

Assertion 9.1.2:

SpdmMessage.RequestResponseCode == FINISH_RSP

Assertion 9.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_DOE_V1_4_Test_009_009.py

Description: SPDM responder shall return valid FINISH_RSP, if it receives a FINISH with negotiated version 1.2.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 9.9.1:

sizeof(SpdmMessage) >= sizeof(FINISH_RSP)

Assertion 9.9.2:

SpdmMessage.RequestResponseCode == FINISH_RSP

Assertion 9.9.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_DOE_V1_4_Test_009_011.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a FINISH in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} (not in session-X)

2. SpdmMessage <- Responder (not in session-X)

Assertion 9.11.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 9.11.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 9.11.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 9.11.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_DOE_V1_4_Test_010_001.py

Description: SPDM responder shall return valid PSK_EXCHANGE_RSP, if it receives a PSK_EXCHANGE.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.PSK_CAP != 1, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> PSK_EXCHANGE {SPDMVersion=NegotiatedVersion,
   MeasurementSummaryHashType=0, SessionPolicy=0}
2. SpdmMessage <- Responder

Assertion 10.1.1:
    sizeof(SpdmMessage) >= offset(PSK_EXCHANGE_RSP, Q)

Assertion 10.1.2:
    SpdmMessage.RequestResponseCode == PSK_EXCHANGE_RSP

Assertion 10.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 10.1.4:
    sizeof(SpdmMessage) >= offset(PSK_EXCHANGE_RSP, ResponderContext) +
    SpdmMessage.Q

SPDM_DOE_V1_4_Test_010_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a PSK_EXCHANGE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_EXCHANGE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 10.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 10.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 10.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 10.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 10.2.5:

SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_011_001.py

Description: SPDM responder shall return valid PSK_FINISH_RSP, if it receives a PSK_FINISH.

SPDM Version: 1.2+

Note: PSK_FINISH completes a PSK session handshake and carries an HMAC (RequesterVerifyData) over the session transcript. It is normally issued only after a PSK_EXCHANGE within the same session; issued standalone the responder may return ERROR. This case validates the PSK_FINISH_RSP format when one is returned.

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP != 1, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0} 2. SpdmMessage <- Responder

Assertion 11.1.1:

sizeof(SpdmMessage) >= sizeof(PSK_FINISH_RSP)

Assertion 11.1.2:

SpdmMessage.RequestResponseCode == PSK_FINISH_RSP

Assertion 11.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 11.1.4:

SpdmMessage.Param1 == 0

Assertion 11.1.5:

SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_011_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a PSK_FINISH with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_FINISH {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 11.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 11.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 11.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 11.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 11.2.5:

SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_012_004.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a HEARTBEAT in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.HBEAT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> HEARTBEAT {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 12.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.4.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_DOE_V1_4_Test_013_005.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a KEY_UPDATE in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.HBEAT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateKey, Param2=Tag}

2. SpdmMessage <- Responder

Assertion 13.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.5.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_DOE_V1_4_Test_014_001.py

Description: SPDM responder shall return valid ENCAPSULATED_REQUEST, if it receives a GET_ENCAPSULATED_REQUEST.

SPDM Version: 1.2+

Note: GET_ENCAPSULATED_REQUEST retrieves a request the responder is waiting to send, which only happens inside the encapsulated request flow. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of ENCAPSULATED_REQUEST. This case validates the ENCAPSULATED_REQUEST format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.ENCAP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENCAPSULATED_REQUEST {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 14.1.1:
    sizeof(SpdmMessage) >= offset(ENCAPSULATED_REQUEST, EncapsulatedRequest)

Assertion 14.1.2:
    SpdmMessage.RequestResponseCode == ENCAPSULATED_REQUEST

Assertion 14.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

SPDM_DOE_V1_4_Test_014_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_ENCAPSULATED_REQUEST with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.ENCAP_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> GET_ENCAPSULATED_REQUEST {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 14.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 14.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 14.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 14.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 14.2.5:

SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_015_001.py

Description: SPDM responder shall return valid ENCAPSULATED_RESPONSE_ACK, if it receives a DELIVER_ENCAPSULATED_RESPONSE.

SPDM Version: 1.2+

Note: DELIVER_ENCAPSULATED_RESPONSE is part of the encapsulated request flow and is normally issued in response to a prior ENCAPSULATED_REQUEST. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of ENCAPSULATED_RESPONSE_ACK. This case validates the ENCAPSULATED_RESPONSE_ACK format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.ENCAP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> DELIVER_ENCAPSULATED_RESPONSE {SPDMVersion=NegotiatedVersion,
   RequestID=0}
2. SpdmMessage <- Responder

Assertion 15.1.1:
    sizeof(SpdmMessage) >= offset(ENCAPSULATED_RESPONSE_ACK,
    EncapsulatedRequest)

Assertion 15.1.2:
    SpdmMessage.RequestResponseCode == ENCAPSULATED_RESPONSE_ACK

Assertion 15.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

SPDM_DOE_V1_4_Test_015_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a DELIVER_ENCAPSULATED_RESPONSE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.ENCAP_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> DELIVER_ENCAPSULATED_RESPONSE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 15.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 15.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 15.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 15.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 15.2.5:

SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_016_004.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a END_SESSION in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 && Flags.PSK_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> END_SESSION {SPDMVersion=NegotiatedVersion, Param1.StatePreservation=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 16.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.4.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_DOE_V1_4_Test_017_001.py

Description: SPDM responder shall return valid CSR, if it receives a GET_CSR.

SPDM Version: 1.2+

Note: a CSR is often larger than the DataTransferSize the requester advertised. The responder then answers with ERROR(LargeResponse) and the CSR is collected with CHUNK_GET before the assertions run. A CSR larger than the advertised MaxSPDMmsgSize cannot be received at all; ERROR(ResponseTooLarge) is conformant there and the case is Skipped.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CSR_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_CSR {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0,
   RequesterInfoLength=0, OpaqueDataLength=0}
2. SpdmMessage <- Responder

Assertion 17.1.1:
    sizeof(SpdmMessage) >= offset(CSR, CSRData)

Assertion 17.1.2:
    SpdmMessage.RequestResponseCode == CSR

Assertion 17.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 17.1.4:
    SpdmMessage.CSRLength > 0

Assertion 17.1.5:
    sizeof(SpdmMessage) >= offset(CSR, CSRData) + SpdmMessage.CSRLength

SPDM_DOE_V1_4_Test_017_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_CSR with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.CSR_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> GET_CSR {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 17.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 17.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 17.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 17.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 17.2.5:

SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_018_001.py

Description: SPDM responder shall return valid CHUNK_SEND_ACK, if it receives a CHUNK_SEND.

SPDM Version: 1.2+

Note: CHUNK_SEND belongs to the Large SPDM message transfer mechanism and is only meaningful as part of a genuine large request. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of CHUNK_SEND_ACK. This case validates the CHUNK_SEND_ACK format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_SEND {SPDMVersion=NegotiatedVersion,
   Param1=LastChunk, Handle=0, ChunkSeqNo=0, ChunkSize=0}
2. SpdmMessage <- Responder

Assertion 18.1.1:
    sizeof(SpdmMessage) >= offset(CHUNK_SEND_ACK, ResponseToLargeRequest)

Assertion 18.1.2:
    SpdmMessage.RequestResponseCode == CHUNK_SEND_ACK

Assertion 18.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 18.1.4:
    SpdmMessage.Param2 == requested Handle

SPDM_DOE_V1_4_Test_018_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHUNK_SEND with non negotiated version.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_SEND {SPDMVersion=(NegotiatedVersion+1),
   Param1=LastChunk, Handle=0, ChunkSeqNo=0, ChunkSize=0}
2. SpdmMessage <- Responder

Assertion 18.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 18.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 18.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 18.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 18.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_019_001.py

Description: SPDM responder shall return valid CHUNK_RESPONSE, if it receives a CHUNK_GET during an in-progress large response transfer.

SPDM Version: 1.2+

Note: CHUNK_GET is only meaningful while the responder has a large response pending, identified by Handle. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of CHUNK_RESPONSE. This case validates the CHUNK_RESPONSE format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_GET {SPDMVersion=NegotiatedVersion, Param1=0, Handle=0,
   ChunkSeqNo=0}
2. SpdmMessage <- Responder

Assertion 19.1.1:
    sizeof(SpdmMessage) >= offset(CHUNK_RESPONSE, LargeMessageSize)

Assertion 19.1.2:
    SpdmMessage.RequestResponseCode == CHUNK_RESPONSE

Assertion 19.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 19.1.4:
    sizeof(SpdmMessage) >= offset(CHUNK_RESPONSE, LargeMessageSize) +
    SpdmMessage.ChunkSize

SPDM_DOE_V1_4_Test_019_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHUNK_GET with non negotiated version.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_GET {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Handle=0, ChunkSeqNo=0}
2. SpdmMessage <- Responder

Assertion 19.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 19.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 19.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 19.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 19.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_020_001.py

Description: SPDM responder shall return valid KEY_PAIR_INFO, if it receives a GET_KEY_PAIR_INFO.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.GET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_KEY_PAIR_INFO {SPDMVersion=NegotiatedVersion, Param1=0,
   Param2=0, KeyPairID=1}
2. SpdmMessage <- Responder

Assertion 20.1.1:
    sizeof(SpdmMessage) >= offset(KEY_PAIR_INFO, PublicKeyInfo)

Assertion 20.1.2:
    SpdmMessage.RequestResponseCode == KEY_PAIR_INFO

Assertion 20.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 20.1.4:
    SpdmMessage.KeyPairID == requested KeyPairID

Assertion 20.1.5:
    SpdmMessage.TotalKeyPairs > 0

Assertion 20.1.6:
    sizeof(SpdmMessage) >= offset(KEY_PAIR_INFO, PublicKeyInfo) +
    SpdmMessage.PublicKeyInfoLen

SPDM_DOE_V1_4_Test_020_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_KEY_PAIR_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.GET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_KEY_PAIR_INFO {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Param2=0, KeyPairID=1}
2. SpdmMessage <- Responder

Assertion 20.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 20.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 20.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 20.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 20.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_021_001.py

Description: SPDM responder shall return valid SET_KEY_PAIR_INFO_ACK, if it receives a SET_KEY_PAIR_INFO.

SPDM Version: 1.3+

Note: SET_KEY_PAIR_INFO changes responder key pair configuration and is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SET_KEY_PAIR_INFO_ACK. This case validates the SET_KEY_PAIR_INFO_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of SET_KEY_PAIR_INFO_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_KEY_PAIR_INFO {SPDMVersion=NegotiatedVersion,
   Param1=0 (ParameterChange), KeyPairID=1, DesiredKeyUsage=0,
   DesiredAsymAlgo=0, DesiredAssocCertSlotMask=0}

   A ParameterChange with no bits set does not change the current key pair
   configuration (Table 106), so this exercises the acknowledgement without
   modifying responder state.
2. SpdmMessage <- Responder

Assertion 21.1.1:
    sizeof(SpdmMessage) >= sizeof(SET_KEY_PAIR_INFO_ACK)

Assertion 21.1.2:
    SpdmMessage.RequestResponseCode == SET_KEY_PAIR_INFO_ACK

Assertion 21.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 21.1.4:
    SpdmMessage.Param1 == 0

Assertion 21.1.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_021_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SET_KEY_PAIR_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_KEY_PAIR_INFO {SPDMVersion=(NegotiatedVersion+1),
   Param1=0 (ParameterChange), KeyPairID=1, DesiredKeyUsage=0,
   DesiredAsymAlgo=0, DesiredAssocCertSlotMask=0}
2. SpdmMessage <- Responder

Assertion 21.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 21.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 21.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 21.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 21.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_022_001.py

Description: SPDM Event Notifier shall return valid SUPPORTED_EVENT_TYPES, if it receives a GET_SUPPORTED_EVENT_TYPES.

SPDM Version: 1.3+

Note: GET_SUPPORTED_EVENT_TYPES is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SUPPORTED_EVENT_TYPES. This case validates the SUPPORTED_EVENT_TYPES format when one is returned and is Skipped when the responder answers ERROR. Full validation of SUPPORTED_EVENT_TYPES requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_SUPPORTED_EVENT_TYPES {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 22.1.1:
    sizeof(SpdmMessage) >= offset(SUPPORTED_EVENT_TYPES,
    SupportedEventGroupsList)

Assertion 22.1.2:
    SpdmMessage.RequestResponseCode == SUPPORTED_EVENT_TYPES

Assertion 22.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 22.1.4:
    SpdmMessage.Param2 == 0

Assertion 22.1.5:
    SpdmMessage.SupportedEventGroupsListLen > 0

Assertion 22.1.6:
    sizeof(SpdmMessage) >= offset(SUPPORTED_EVENT_TYPES,
    SupportedEventGroupsList) + SpdmMessage.SupportedEventGroupsListLen

SPDM_DOE_V1_4_Test_022_002.py

Description: SPDM Event Notifier shall return ERROR(VersionMismatch), if it receives a GET_SUPPORTED_EVENT_TYPES with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_SUPPORTED_EVENT_TYPES {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 22.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 22.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 22.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 22.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 22.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_023_001.py

Description: SPDM Event Notifier shall return valid SUBSCRIBE_EVENT_TYPES_ACK, if it receives a SUBSCRIBE_EVENT_TYPES.

SPDM Version: 1.3+

Note: SUBSCRIBE_EVENT_TYPES is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SUBSCRIBE_EVENT_TYPES_ACK. This case validates the SUBSCRIBE_EVENT_TYPES_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of SUBSCRIBE_EVENT_TYPES_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SUBSCRIBE_EVENT_TYPES {SPDMVersion=NegotiatedVersion,
   Param1=0 (SubscribeEventGroupCount, unsubscribe all), Param2=0}
2. SpdmMessage <- Responder

Assertion 23.1.1:
    sizeof(SpdmMessage) >= sizeof(SUBSCRIBE_EVENT_TYPES_ACK)

Assertion 23.1.2:
    SpdmMessage.RequestResponseCode == SUBSCRIBE_EVENT_TYPES_ACK

Assertion 23.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 23.1.4:
    SpdmMessage.Param1 == 0

Assertion 23.1.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_023_002.py

Description: SPDM Event Notifier shall return ERROR(VersionMismatch), if it receives a SUBSCRIBE_EVENT_TYPES with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SUBSCRIBE_EVENT_TYPES {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 23.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 23.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 23.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 23.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 23.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_024_001.py

Description: SPDM Event Recipient shall return valid EVENT_ACK, if it receives a SEND_EVENT.

SPDM Version: 1.3+

Note: SEND_EVENT is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of EVENT_ACK. This case validates the EVENT_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of EVENT_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SEND_EVENT {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0,
   EventCount=1, EventsList=<one DMTF EventLost event>}
2. SpdmMessage <- Responder

Assertion 24.1.1:
    sizeof(SpdmMessage) >= sizeof(EVENT_ACK)

Assertion 24.1.2:
    SpdmMessage.RequestResponseCode == EVENT_ACK

Assertion 24.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 24.1.4:
    SpdmMessage.Param1 == 0

Assertion 24.1.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_024_002.py

Description: SPDM Event Recipient shall return ERROR(VersionMismatch), if it receives a SEND_EVENT with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SEND_EVENT {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Param2=0, EventCount=1, EventsList=<one DMTF EventLost event>}
2. SpdmMessage <- Responder

Assertion 24.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 24.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 24.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 24.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 24.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_025_001.py

Description: SPDM responder shall return valid ENDPOINT_INFO, if it receives a GET_ENDPOINT_INFO.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EP_INFO_CAP != 1 (no-signature capable), then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENDPOINT_INFO {SPDMVersion=NegotiatedVersion,
   Param1=DeviceClassIdentifier, Param2=0, RequestAttributes=0}
2. SpdmMessage <- Responder

Assertion 25.1.1:
    sizeof(SpdmMessage) >= offset(ENDPOINT_INFO, EPInfoLength)

Assertion 25.1.2:
    SpdmMessage.RequestResponseCode == ENDPOINT_INFO

Assertion 25.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 25.1.4:
    SpdmMessage.Param1 == 0

Assertion 25.1.5:
    SpdmMessage.Param2.SlotID == 0

Assertion 25.1.6:
    sizeof(SpdmMessage) >= offset(ENDPOINT_INFO, EPInfo) +
    SpdmMessage.EPInfoLength

SPDM_DOE_V1_4_Test_025_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_ENDPOINT_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EP_INFO_CAP != 1 (no-signature capable), then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENDPOINT_INFO {SPDMVersion=(NegotiatedVersion+1),
   Param1=DeviceClassIdentifier, Param2=0, RequestAttributes=0}
2. SpdmMessage <- Responder

Assertion 25.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 25.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 25.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 25.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 25.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_026_001.py

Description: SPDM responder shall return valid MEASUREMENT_EXTENSION_LOG, if it receives a GET_MEASUREMENT_EXTENSION_LOG.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.MEL_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_MEASUREMENT_EXTENSION_LOG {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0, Offset=0, Length=0xFFFFFFFF}
2. SpdmMessage <- Responder

Assertion 26.1.1:
    sizeof(SpdmMessage) >= offset(MEASUREMENT_EXTENSION_LOG, MEL)

Assertion 26.1.2:
    SpdmMessage.RequestResponseCode == MEASUREMENT_EXTENSION_LOG

Assertion 26.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 26.1.4:
    SpdmMessage.Param1 == 0

Assertion 26.1.5:
    SpdmMessage.Param2 == 0

Assertion 26.1.6:
    sizeof(SpdmMessage) >= offset(MEASUREMENT_EXTENSION_LOG, MEL) +
    SpdmMessage.PortionLength

Assertion 26.1.7:
    if SpdmMessage.RemainderLength == 0 then
    SpdmMessage.PortionLength == offset(MEL, MELEntries) +
    SpdmMessage.MEL.MELEntriesLength

Assertion 26.1.8:
    if SpdmMessage.RemainderLength == 0 && SpdmMessage.MEL.NumberOfEntries > 0
    then SpdmMessage.MEL.MELEntriesLength >=
    SpdmMessage.MEL.NumberOfEntries * sizeof(minimum MEL entry)

SPDM_DOE_V1_4_Test_026_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_MEASUREMENT_EXTENSION_LOG with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.MEL_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_MEASUREMENT_EXTENSION_LOG {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0, Offset=0, Length=0xFFFFFFFF}
2. SpdmMessage <- Responder

Assertion 26.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 26.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 26.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 26.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 26.2.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_027_001.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with SupportedSubCodes structure, if it receives a SLOT_MANAGEMENT with SubCode=SupportedSubCodes.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, …} 2. SpdmMessage <- Responder

Assertion 27.1.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.1.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.1.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (SupportedSubCodes)

Assertion 27.1.5:

SpdmMessage.Param2 == 0

Assertion 27.1.6:

SupportedSubCodes.Reserved == 0

Assertion 27.1.7:

SupportedSubCodes.RespLength == 36

Assertion 27.1.8:

SupportedSubCodes.SubCodeBitmap.Bit[SupportedSubCodes] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetBankInfo] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetBankDetails] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetCertificateChain] == 1

SPDM_DOE_V1_4_Test_027_002.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with BankInfo structure, if it receives a SLOT_MANAGEMENT with SubCode=GetBankInfo.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, …} 2. SpdmMessage <- Responder

Assertion 27.2.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.2.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.2.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (GetBankInfo)

Assertion 27.2.5:

BankInfo.RespLength == offset(BankInfo, BankElements) + (BankInfo.NumBankElements * sizeof(BankElement))

Assertion 27.2.6:

BankInfo.NumBankElements > 0 && BankInfo.NumBankElements <= 240

Assertion 27.2.7:

For every BankElement in BankInfo.BankElements[]:

BankElement.ElementLength == 4 && BankElement.BankID <= 239

Assertion 27.2.8:

For every pair (i, j), i != j, in BankInfo.BankElements[]:

BankElements[i].BankID != BankElements[j].BankID

Assertion 27.2.9:

BankInfo.Reserved == 0

SPDM_DOE_V1_4_Test_027_003.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with BankDetails structure, if it receives a SLOT_MANAGEMENT with SubCode=GetBankDetails for each valid BankID.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SLOT_MANAGEMENT_RESP <- Responder

3. ValidBankID[] = array of BankElement.BankID from BankInfo.BankElements[]

For each BankID in ValidBankID[] and 0xFF:

4. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankDetails, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=0}}

5. SpdmMessage <- Responder

Assertion 27.3.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.3.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.3.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT_RESP.Param1 (GetBankDetails)

Assertion 27.3.5:

If SLOT_MANAGEMENT.SlotAddress.BankID != 0xFF, then

BankDetails.BankID == SLOT_MANAGEMENT.SlotAddress.BankID

else

BankDetails.BankID is one of ValidBankID[]

Assertion 27.3.6:

BankDetails.RespLength == sizeof(BankDetails)

Assertion 27.3.7:

BankDetails.NumSlotElements <= 8

Assertion 27.3.8:

For SlotElement[i]:

BankDetails.SlotElement[i].ElementLength == 16 + H && SlotElement[i].SlotID <= 7 && BankElements[BankDetails.BankID].SlotMask.Bit[SlotElement[i].SlotID] == 1 && (if MULTI_KEY_CONN_RSP == false => KeyPairID == 0) && (if Provisioned == 0 => Digest == 0)

Assertion 27.3.9:

popcount(BankDetails.CurrentAsymAlgo) + popcount(BankDetails.CurrentPqcAsymAlgo) <= 1

Assertion 27.3.10:

(BankDetails.AsymAlgoCapabilities | BankDetails.PqcAsymAlgoCapabilities) != 0

Assertion 27.3.11:

(BankDetails.AvailableAsymAlgo & ~BankDetails.AsymAlgoCapabilities) == 0 && (BankDetails.AvailablePqcAsymAlgo & ~BankDetails.PqcAsymAlgoCapabilities) == 0

Assertion 27.3.12:

(BankDetails.CurrentAsymAlgo & ~BankDetails.AsymAlgoCapabilities) == 0 && (BankDetails.CurrentPqcAsymAlgo & ~BankDetails.PqcAsymAlgoCapabilities) == 0

Assertion 27.3.13:

If BankDetails.BankAttributes.ConfigAlgo == 0, then

BankDetails.AsymAlgoCapabilities == 0 && BankDetails.PqcAsymAlgoCapabilities == 0 && BankDetails.AvailableAsymAlgo == 0 && BankDetails.AvailablePqcAsymAlgo == 0

Assertion 27.3.14:

BankDetails.BankAttributes.Reserved == 0 && BankDetails.Reserved == 0 && every SlotElement.Reserved == 0

Assertion 27.3.15:

BankDetails.BankAttributes.Reserved == 0 && BankDetails.Reserved == 0

Assertion 27.3.16:

BankDetails.NumSlotElements == popcount(BankElements[BankDetails.BankID].SlotMask)

Assertion 27.3.17:

For every pair (m, n), m != n, in BankDetails.SlotElements[]:

SlotElements[m].SlotID != SlotElements[n].SlotID

Assertion 27.3.18:

If BankAttributes.ConfigAlgo == 1 && CurrentAsymAlgo == 0 && CurrentPqcAsymAlgo == 0, then no SlotElement has SlotAttributes.Bit[0] (Provisioned) == 1

SPDM_DOE_V1_4_Test_027_004.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with GetCertificateChain structure, if it receives a SLOT_MANAGEMENT with SubCode=GetCertificateChain for any provisioned slot in any Bank reported by GetBankInfo.

SPDM Version: 1.4+

Note: a certificate chain is often larger than the DataTransferSize the requester advertised, and post-quantum chains always are. The responder then answers with ERROR(LargeResponse) and the chain is collected with CHUNK_GET before the assertions run. A chain larger than the advertised MaxSPDMmsgSize cannot be received at all; ERROR(ResponseTooLarge) is conformant there and the case is Skipped.

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0 || Flags.CERT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SLOT_MANAGEMENT_RESP <- Responder

3. SelectedBankIDs[] = array of BankID where BankAttributes.Bit[0] (Selected) == 1.

For each BankID in SelectedBankIDs[]:

4. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankDetails, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=0}}

5. BankDetails <- Responder

6. ProvisionedPairs[] = array of (BankID, SlotID) for every SlotElement in BankDetails.SlotElements[] where SlotAttributes.Bit[0] (Provisioned) == 1.

For each (BankID, SlotID) in ProvisionedPairs[]:

5. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetCertificateChain, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=SlotID}}

6. SpdmMessage <- Responder

Assertion 27.4.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct) + offset(GetCertificateChain, CertChain)

Assertion 27.4.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.4.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (GetCertificateChain)

Assertion 27.4.5:

SpdmMessage.MgmtStructOffset >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct) && SpdmMessage.MgmtStructOffset + offset(GetCertificateChain, CertChain) <= sizeof(SpdmMessage)

Assertion 27.4.6:

GetCertificateChain.CCLength + SpdmMessage.MgmtStructOffset + offset(GetCertificateChain, CertChain) <= sizeof(SpdmMessage)

Assertion 27.4.7:

GetCertificateChain.Reserved == 0

SPDM_DOE_V1_4_Test_027_005.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SLOT_MANAGEMENT with non negotiated version.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=(NegotiatedVersion+1), Param1.SubCode=SupportedSubCodes, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0} 2. SpdmMessage <- Responder

Assertion 27.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.5.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 27.5.5:

SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_027_006.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a SLOT_MANAGEMENT with a reserved or unknown SubCode value.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=0x05, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SpdmMessage <- Responder

Assertion 27.6.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.6.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.6.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 27.6.5:

SpdmMessage.Param2 == 0.

SPDM_DOE_V1_4_Test_027_007.py

Description: SPDM responder shall return ERROR(UnsupportedRequest), if it receives a SLOT_MANAGEMENT with a valid SubCode that is not in SupportedSubCodes.SubCodeBitmap.

SPDM Version: 1.4+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.SLOT_MGMT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, …}

10. SLOT_MANAGEMENT_RESP <- Responder

11. UnsupportedSubCode = any SubCode in {GetCSR, ManageBank, ManageSlot, SetCertificate} whose bit is 0 in SupportedSubCodes.SubCodeBitmap. If no such SubCode exists, skip this case.

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=UnsupportedSubCode, MgmtStructOffset=<as required>, SlotMgmtReqStruct=<as required>}

2. SpdmMessage <- Responder

Assertion 27.7.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.7.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.7.4:

SpdmMessage.Param1 == UnsupportedRequest.

Assertion 27.7.5:

SpdmMessage.Param2 == SLOT_MANAGEMENT (0x88).

ErrorData for ERROR(UnsupportedRequest) is the RequestResponseCode of the request that was not supported, so the responder echoes back the code it could not serve – 0x88 here, not 0.

SPDM_DOE_V1_4_Test_027_008.py

Description: SPDM responder shall return ERROR(UnsupportedRequest), if it receives a SLOT_MANAGEMENT when SLOT_MGMT_CAP=0 in CAPABILITIES.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 1, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SpdmMessage <- Responder

Assertion 27.8.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.8.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.8.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.8.4:

SpdmMessage.Param1 == UnsupportedRequest.

Assertion 27.8.5:

SpdmMessage.Param2 == SLOT_MANAGEMENT (0x88).

ErrorData for ERROR(UnsupportedRequest) is the RequestResponseCode of the request that was not supported, so the responder echoes back the code it could not serve – 0x88 here, not 0.

SPDM_DOE_V1_4_Test_028_001.py

Description: SPDM responder shall return valid SET_CERTIFICATE_RSP, if it receives a SET_CERTIFICATE.

SPDM Version: 1.2+

Note: SET_CERTIFICATE provisions or erases a certificate slot and is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SET_CERTIFICATE_RSP. This case validates the SET_CERTIFICATE_RSP format when one is returned and is Skipped when the responder answers ERROR. Full validation of SET_CERTIFICATE_RSP requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_CERT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_CERTIFICATE {SPDMVersion=NegotiatedVersion, SlotID=0,
   Param2=0}
2. SpdmMessage <- Responder

Assertion 28.1.1:
    sizeof(SpdmMessage) >= sizeof(SET_CERTIFICATE_RSP)

Assertion 28.1.2:
    SpdmMessage.RequestResponseCode == SET_CERTIFICATE_RSP

Assertion 28.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 28.1.4:
    SpdmMessage.Param1.SlotID == requested SlotID

Assertion 28.1.5:
    SpdmMessage.Param2 == 0

SPDM_DOE_V1_4_Test_028_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SET_CERTIFICATE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SET_CERT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SET_CERTIFICATE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 28.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 28.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 28.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 28.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 28.2.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_001_001.py

Description: SPDM responder shall return valid VERSION, if it receives a GET_VERSION with version 1.0.

SPDM Version: 1.0+

TestSetup: None

TestTeardown: None

Steps: 1. Requester -> GET_VERSION {SPDMVersion=0x10, Param1=0, Param2=0} 2. SpdmMessage <- Responder

Assertion 1.1.1:

sizeof(SpdmMessage) >= offset(VERSION, VersionNumberEntry)

Assertion 1.1.2:

SpdmMessage.RequestResponseCode == VERSION

Assertion 1.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 1.1.4:

SpdmMessage.VersionNumberEntryCount > 0 && SpdmMessage.VersionNumberEntryCount <= (sizeof(SpdmMessage) - offset(VERSION, VersionNumberEntry)) / sizeof(uint16_t)

Assertion 1.1.5:

((SpdmMessage.VersionNumberEntry[i].MajorVersion << 4) + SpdmMessage.VersionNumberEntry[i].MinorVersion) is in {0x10, 0x11, 0x12, 0x13, 0x14}.

SPDM_SMBUS_V1_4_Test_002_001.py

Description: SPDM responder shall return valid CAPABILITIES(0x10), if it receives a GET_CAPABILITIES with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x10, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 2.1.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.0)

Assertion 2.1.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 2.1.4:

Flags.MEAS_CAP != 3

###

SPDM_SMBUS_V1_4_Test_002_003.py

Description: SPDM responder shall return valid CAPABILITIES(0x11), if it receives a GET_CAPABILITIES with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x11, Param1=0, Param2=0, CTExponent, Flags=CERT_CAP|CHAL_CAP|ENCRYPT_CAP|MAC_CAP|MUT_AUTH_CAP|KEY_EX_CAP|PSK_CAP=1|ENCAP_CAP|HBEAT_CAP|KEY_UPD_CAP}

2. SpdmMessage <- Responder

Assertion 2.3.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.1)

Assertion 2.3.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.3.3:

SpdmMessage.SPDMVersion == 0x11

Assertion 2.3.4:

Flags.MEAS_CAP != 3

Assertion 2.3.5:

if (Flags.ENCRYPT_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.3.6:

if (Flags.MAC_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.3.7:

if (Flags.KEY_EX_CAP == 1), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.3.8:

Flags.PSK_CAP != 3

Assertion 2.3.9:

if (Flags.PSK_CAP != 0), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.3.10:

if (Flags.MUT_AUTH_CAP == 1), then (Flags.ENCAP_CAP == 1)

Assertion 2.3.11:

if (Flags.HANDSHAKE_IN_THE_CLEAR_CAP == 1), then (Flags.KEY_EX_CAP == 1)

Assertion 2.3.12:

if (Flags.PUB_KEY_ID_CAP == 1), then (Flags.CERT_CAP == 0)

Assertion 2.3.13:

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (CERT_CAP == 1 || PUB_KEY_ID_CAP == 1)

###

SPDM_SMBUS_V1_4_Test_002_005.py

Description: SPDM responder shall return valid CAPABILITIES(0x12), if it receives a GET_CAPABILITIES with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x12, Param1=0, Param2=0, CTExponent, Flags=CERT_CAP|CHAL_CAP|ENCRYPT_CAP|MAC_CAP|MUT_AUTH_CAP|KEY_EX_CAP|PSK_CAP=1|ENCAP_CAP|HBEAT_CAP|KEY_UPD_CAP|CHUNK_CAP, DataTransferSize, MaxSPDMmsgSize}

2. SpdmMessage <- Responder

Assertion 2.5.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.2)

Assertion 2.5.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.5.3:

SpdmMessage.SPDMVersion == 0x12

Assertion 2.5.4:

Flags.MEAS_CAP != 3

Assertion 2.5.5:

if (Flags.ENCRYPT_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.5.6:

if (Flags.MAC_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.5.7:

if (Flags.KEY_EX_CAP == 1), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.5.8:

Flags.PSK_CAP != 3

Assertion 2.5.9:

if (Flags.PSK_CAP != 0), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.5.10:

if (Flags.MUT_AUTH_CAP == 1), then (Flags.ENCAP_CAP == 1)

Assertion 2.5.11:

if (Flags.HANDSHAKE_IN_THE_CLEAR_CAP == 1), then (Flags.KEY_EX_CAP == 1)

Assertion 2.5.12:

if (Flags.PUB_KEY_ID_CAP == 1), then (Flags.CERT_CAP == 0)

Assertion 2.5.13:

SpdmMessage.DataTransferSize >= MinDataTransferSize

Assertion 2.5.14:

SpdmMessage.MaxSPDMmsgSize >= SpdmMessage.DataTransferSize

Assertion 2.5.15:

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (CERT_CAP == 1 || PUB_KEY_ID_CAP == 1)

###

SPDM_SMBUS_V1_4_Test_003_001.py

Description: SPDM responder shall return valid ALGORITHMS(0x10), if it receives a GET_ALGORITHMS with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x10, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x10, Param1=0, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0}

2. SpdmMessage <- Responder

Assertion 3.1.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.0)

Assertion 3.1.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 3.1.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.0, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount

Assertion 3.1.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.1.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.1.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.1.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.1.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521}) if (CHAL_CAP == 0 && MEAS_CAP != 2) then (BaseAsymSel == 0)

Assertion 3.1.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (CHAL_CAP == 0 && MEAS_CAP != 2) then (BaseHashSel == 0)

###

SPDM_SMBUS_V1_4_Test_003_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a NEGOTIATE_ALGORITHMS with non negotiated version.

SPDM Version: 1.0+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
4. CAPABILITIES <- Responder

TestTeardown: None

Steps:
1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=(NegotiatedVersion+1), ...}
2. SpdmMessage <- Responder

Assertion 3.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)
Assertion 3.2.2:
    SpdmMessage.RequestResponseCode == ERROR
Assertion 3.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion
Assertion 3.2.4:
    SpdmMessage.Param1 == VersionMismatch.
Assertion 3.2.5:
    SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=(NegotiatedVersion-1), ...}
4. SpdmMessage <- Responder
Assertion 3.2.*.

SPDM_SMBUS_V1_4_Test_003_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a NEGOTIATE_ALGORITHMS with invalid field.

SPDM Version: 1.0+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 4. CAPABILITIES <- Responder

TestTeardown: None

Steps: 1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Length-1, …} – if NegotiatedVersion=1.0+ 2. SpdmMessage <- Responder

Assertion 3.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 3.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 3.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 3.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 3.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Length+1, …} – if NegotiatedVersion=1.0+

4. SpdmMessage <- Responder

Assertion 3.4.*.

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ExtAsymCount=21, …} – if NegotiatedVersion=1.0+

6. SpdmMessage <- Responder

Assertion 3.4.*.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ExtHashCount=21, …} – if NegotiatedVersion=1.0+

8. SpdmMessage <- Responder

Assertion 3.4.*.

9. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=1, …} – if NegotiatedVersion=1.1+

10. SpdmMessage <- Responder

Assertion 3.4.*.

11. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=3, …} – if NegotiatedVersion=1.1+

12. SpdmMessage <- Responder

Assertion 3.4.*.

13. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=2, ExtAlgCount=0xF, …} – if NegotiatedVersion=1.1+

14. SpdmMessage <- Responder

Assertion 3.4.*.

SPDM_SMBUS_V1_4_Test_003_005.py

Description: SPDM responder shall return valid ALGORITHMS(0x11), if it receives a GET_ALGORITHMS with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x11, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x11, Param1.NumOfAlgoStruct=4, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0, ReqAlgStruct[0]{AlgType=DHE, AlgSupported=ffdhe2048|ffdhe3072|ffdhe4096|secp256r1|secp384r1|secp521r1}, ReqAlgStruct[1]{AlgType=AEAD, AlgSupported=AES-128-GCM|AES-256-GCM|CHACHA20_POLY1305}, ReqAlgStruct[2]{AlgType=ReqBaseAsymAlg, AlgSupported=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521}, ReqAlgStruct[3]{AlgType=KeySchedule, AlgSupported=SPDM} }

2. SpdmMessage <- Responder

Assertion 3.5.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.1)

Assertion 3.5.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.5.3:

SpdmMessage.SPDMVersion == 0x11

Assertion 3.5.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.1, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.5.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.5.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.5.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.5.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.5.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0) then (BaseAsymSel == 0)

Assertion 3.5.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0) then (BaseHashSel == 0)

Assertion 3.5.11:

SpdmMessage.Param1 <= 4 SpdmMessage.AlgStructure[i].AlgType is in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule} and no duplication.

Assertion 3.5.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.5.13:

DHE only has one bit at most.

if (KEY_EX_CAP == 1) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1} if (KEY_EX_CAP == 0) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent

Assertion 3.5.14:

AEAD only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305} if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0, or it is absent

Assertion 3.5.15:

ReqBaseAsymAlg only has one bit at most.

if (MUT_AUTH_CAP == 1) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521} if (MUT_AUTH_CAP == 0) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0, or it is absent

Assertion 3.5.16:

KeySchedule only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0, or it is absent

###

SPDM_SMBUS_V1_4_Test_003_006.py

Description: SPDM responder shall return valid ALGORITHMS(0x12), if it receives a GET_ALGORITHMS with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x12, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x12, Param1.NumOfAlgoStruct=4, Param2=0, MeasurementSpecification=DMTF, OtherParamsSupport=OpaqueDataFmt1, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521|TPM_ALG_SM2_ECC_SM2_P256|EdDSA_ed25519|EdDSA_ed448, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512|TPM_ALG_SM3_256, ExtAsymCount=0, ExtHashCount=0, ReqAlgStruct[0]{AlgType=DHE, AlgSupported=ffdhe2048|ffdhe3072|ffdhe4096|secp256r1|secp384r1|secp521r1|SM2_P256}, ReqAlgStruct[1]{AlgType=AEAD, AlgSupported=AES-128-GCM|AES-256-GCM|CHACHA20_POLY1305|AEAD_SM4_GCM}, ReqAlgStruct[2]{AlgType=ReqBaseAsymAlg, AlgSupported=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521|TPM_ALG_SM2_ECC_SM2_P256|EdDSA_ed25519|EdDSA_ed448}, ReqAlgStruct[3]{AlgType=KeySchedule, AlgSupported=SPDM} }

2. SpdmMessage <- Responder

Assertion 3.6.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.2)

Assertion 3.6.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.6.3:

SpdmMessage.SPDMVersion == 0x12

Assertion 3.6.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.1, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.6.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.6.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.6.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.6.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.6.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0) then (BaseAsymSel == 0)

Assertion 3.6.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0) then (BaseHashSel == 0)

Assertion 3.6.11:

SpdmMessage.Param1 <= 4 SpdmMessage.AlgStructure[i].AlgType is in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule} and no duplication.

Assertion 3.6.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.6.13:

SpdmMessage.AlgStructure[DHE_index] only has one bit at most.

if (KEY_EX_CAP == 1) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1, SM2_P256} if (KEY_EX_CAP == 0) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent

Assertion 3.6.14:

SpdmMessage.AlgStructure[AEAD_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305, AEAD_SM4_GCM} if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0, or it is absent

Assertion 3.6.15:

SpdmMessage.AlgStructure[ReqBaseAsymAlg_index] only has one bit at most.

if (MUT_AUTH_CAP == 1) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448} if (MUT_AUTH_CAP == 0) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0, or it is absent

Assertion 3.6.16:

SpdmMessage.AlgStructure[KeySchedule_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0, or it is absent

Assertion 3.6.17:

SpdmMessage.OpaqueDataFmt only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then OtherParamsSupport.OpaqueDataFmt == OpaqueDataFmt1

###

SPDM_SMBUS_V1_4_Test_003_007.py

Description: SPDM responder shall return ERROR(UnexpectedRequest) or silent drop, if it receives two non-identical NEGOTIATE_ALGORITHMS.

SPDM Version: 1.0+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
4. CAPABILITIES <- Responder
5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0}
6. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=1, ...} -- if NegotiatedVersion=1.0+
2. SpdmMessage <- Responder
Assertion 3.7.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)
Assertion 3.7.2:
    SpdmMessage.RequestResponseCode == ERROR
Assertion 3.7.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion
Assertion 3.7.4:
    SpdmMessage.Param1 == UnexpectedRequest.
Assertion 3.7.5:
    SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, MeasurementSpecification=DMTF, BaseAsymAlgo=BaseAsymSel, BaseHashAlgo=BaseHashSel, ...} -- if NegotiatedVersion=1.0+
4. SpdmMessage <- Responder
Assertion 3.7.*.

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Dhe=DheSel, Aead=AeadSel, BaseReqAsymAlg=BaseReqAsymSel, ...} -- if NegotiatedVersion=1.1+
6. SpdmMessage <- Responder
Assertion 3.7.*.

SPDM_SMBUS_V1_4_Test_003_009.py

Description: SPDM responder shall return valid ALGORITHMS(0x14), if it receives a NEGOTIATE_ALGORITHMS with negotiated version 1.4.

SPDM Version: 1.4 only

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=0x14, …} 5. CAPABILITIES <- Responder

TestTeardown: None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {
    SPDMVersion=0x14,
    Param1.NumOfAlgoStruct=6,
    Param2=0,
    MeasurementSpecification=DMTF,
    OtherParamsSupport=OpaqueDataFmt1,
    BaseAsymAlgo=TPM_ALG_RSASSA_2048 |
                TPM_ALG_RSAPSS_2048 |
                TPM_ALG_RSASSA_3072 |
                TPM_ALG_RSAPSS_3072 |
                TPM_ALG_ECDSA_ECC_NIST_P256 |
                TPM_ALG_RSASSA_4096 |
                TPM_ALG_RSAPSS_4096 |
                TPM_ALG_ECDSA_ECC_NIST_P384 |
                TPM_ALG_ECDSA_ECC_NIST_P521 |
                TPM_ALG_SM2_ECC_SM2_P256 |
                EdDSA_ed25519|EdDSA_ed448,
    BaseHashAlgo=TPM_ALG_SHA_256 |
                TPM_ALG_SHA_384 |
                TPM_ALG_SHA_512 |
                TPM_ALG_SHA3_256 |
                TPM_ALG_SHA3_384 |
                TPM_ALG_SHA3_512 |
                TPM_ALG_SM3_256,
    PqcAsymAlgo=ML-DSA-44|ML-DSA-65 |
                ML-DSA-87 |
                SLH-DSA-SHA2-128s |
                SLH-DSA-SHAKE-128s |
                SLH-DSA-SHA2-128f |
                SLH-DSA-SHAKE-128f |
                SLH-DSA-SHA2-192s |
                SLH-DSA-SHAKE-192s |
                SLH-DSA-SHA2-192f |
                SLH-DSA-SHAKE-192f |
                SLH-DSA-SHA2-256s |
                SLH-DSA-SHAKE-256s |
                SLH-DSA-SHA2-256f |
                SLH-DSA-SHAKE-256f,
    ExtAsymCount=0,
    ExtHashCount=0,
    MELspecification=DMTFmelSpec,
    ReqAlgStruct[0..5]={DHE, AEAD, ReqBaseAsymAlg, KeySchedule, ReqPqcAsymAlg, KEMAlg}}

2. SpdmMessage <- Responder

Assertion 3.9.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.4)

Assertion 3.9.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.9.3:

SpdmMessage.SPDMVersion == 0x14

Assertion 3.9.4:

SpdmMessage.Length <= sizeof(SpdmMessage) SpdmMessage.Length == offset(ALGORITHMS_1.4, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.9.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.9.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.9.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || == 0.

if (MEAS_CAP != 0 || MEL_CAP == 1)

then MeasurementSpecificationSel != 0

Assertion 3.9.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) (MeasurementHashAlgo == one of {

Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256})

if (MEAS_CAP == 0) then MeasurementHashAlgo == 0.

Assertion 3.9.9:

SpdmMessage.BaseAsymSel and SpdmMessage.PqcAsymSel only have one bit set at most.

if ((CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) && BaseAsymSel != 0)

then (BaseAsymSel == one of {

TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448})

if ((CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) && PqcAsymSel != 0)

then (PqcAsymSel == one of {

ML-DSA-44, ML-DSA-65, ML-DSA-87, SLH-DSA-SHA2-128s, SLH-DSA-SHAKE-128s, SLH-DSA-SHA2-128f, SLH-DSA-SHAKE-128f, SLH-DSA-SHA2-192s, SLH-DSA-SHAKE-192s, SLH-DSA-SHA2-192f, SLH-DSA-SHAKE-192f, SLH-DSA-SHA2-256s, SLH-DSA-SHAKE-256s, SLH-DSA-SHA2-256f, SLH-DSA-SHAKE-256f})

if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0)

then (BaseAsymSel == 0 && PqcAsymSel == 0)

Assertion 3.9.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0)

then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256})

if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0)

then (BaseHashSel == 0)

Assertion 3.9.11:

SpdmMessage.Param1 <= 6 AlgStructure[i].AlgType in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule, ReqPqcAsymAlg, KEMAlg} and no duplication. AlgStructure[i].AlgType monotonically increases.

Assertion 3.9.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.9.13:

SpdmMessage.AlgStructure[DHE_index] and SpdmMessage.AlgStructure[KEMAlg_index] only have one bit set at most.

if (KEY_EX_CAP == 1)

then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {

ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1, SM2_P256} || KEMAlg.AlgSupported == one of {ML-KEM-512, ML-KEM-768, ML-KEM-1024}

if (KEY_EX_CAP == 0)

then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent && SpdmMessage.AlgStructure[KEMAlg_index].AlgSupported == 0, or it is absent

Assertion 3.9.14:

SpdmMessage.AlgStructure[AEAD_index] only has one bit set at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305, AEAD_SM4_GCM}

else SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0 or it is absent

Assertion 3.9.15:

SpdmMessage.AlgStructure[ReqBaseAsymAlg_index] and SpdmMessage.AlgStructure[ReqPqcAsymAlg_index] only have one bit set at most.

if (MUT_AUTH_CAP == 1)

then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {

TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448}

|| SpdmMessage.AlgStructure[ReqPqcAsymAlg_index].AlgSupported == one of {

ML-DSA-44, ML-DSA-65, ML-DSA-87, SLH-DSA-SHA2-128s, SLH-DSA-SHAKE-128s, SLH-DSA-SHA2-128f, SLH-DSA-SHAKE-128f, SLH-DSA-SHA2-192s, SLH-DSA-SHAKE-192s, SLH-DSA-SHA2-192f, SLH-DSA-SHAKE-192f, SLH-DSA-SHA2-256s, SLH-DSA-SHAKE-256s, SLH-DSA-SHA2-256f, SLH-DSA-SHAKE-256f}.

if (MUT_AUTH_CAP == 0)

then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0 or it is absent && SpdmMessage.AlgStructure[ReqPqcAsymAlg_index].AlgSupported == 0 or it is absent

Assertion 3.9.16:

SpdmMessage.AlgStructure[KeySchedule_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM

else SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0 or it is absent

Assertion 3.9.17:

SpdmMessage.OpaqueDataFmt only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then OtherParamsSupport.OpaqueDataFmt == OpaqueDataFmt1

Assertion 3.9.18:

SpdmMessage.MELspecificationSel only has one bit at most.

if (MEL_CAP == 1)

then SpdmMessage.MELspecificationSel == DMTFmelSpec.

if (MEL_CAP == 0)

then SpdmMessage.MELspecificationSel == 0

SPDM_SMBUS_V1_4_Test_004_001.py

Description: SPDM responder shall return valid DIGESTS, if it receives a GET_DIGESTS.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 4.1.1:

sizeof(SpdmMessage) >= offset(DIGESTS, Digest[0])

Assertion 4.1.2:

SpdmMessage.RequestResponseCode == DIGESTS

Assertion 4.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.1.4:

SpdmMessage.Param2.SlotMask.bit_0 == 1

Assertion 4.1.5:

SlotCount = bit number of SpdmMessage.Param2.SlotMask sizeof(SpdmMessage) >= offset(DIGESTS, Digest[0]) + HashSize * SlotCount

###

SPDM_SMBUS_V1_4_Test_004_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_DIGESTS with non negotiated version.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=(NegotiatedVersion+1), …}

2. SpdmMessage <- Responder

Assertion 4.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 4.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 4.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 4.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_DIGESTS {SPDMVersion=(NegotiatedVersion-1), …}

4. SpdmMessage <- Responder

Assertion 4.2.*.

###

SPDM_SMBUS_V1_4_Test_005_001.py

Description: SPDM responder shall return valid CERTIFICATE, if it receives a GET_CERTIFICATE.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

10. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

11. Digests[] = array of DIGESTS.Digest

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=0, Offset=0, Length=0x400}

2. SpdmMessage <- Responder

Assertion 5.1.1:

sizeof(SpdmMessage) >= sizeof(CERTIFICATE, CertChain)

Assertion 5.1.2:

SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.1.4:

SpdmMessage.PortionLength > 0 SpdmMessage.PortionLength <= GET_CERTIFICATE.Length

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=0, Offset=NextOffset, Length=0x400}, while SpdmMessage.RemainderLength != 0

4. SpdmMessage <- Responder

Assertion 5.1.*.

Assertion 5.1.5:

CertChain.Length == sizeof(CertChain)

Assertion 5.1.6:

Hash(CertChain) == Digests[i]

###

SPDM_SMBUS_V1_4_Test_005_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_CERTIFICATE with non negotiated version.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=(NegotiatedVersion+1), …}

2. SpdmMessage <- Responder

Assertion 5.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 5.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CERTIFICATE {SPDMVersion=(NegotiatedVersion-1), …}

4. SpdmMessage <- Responder

Assertion 5.2.*.

###

SPDM_SMBUS_V1_4_Test_005_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a GET_CERTIFICATE with invalid field.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

10. InvalidSlotID[] = array of bit-index that SlotMask[bit-index]=0 from DIGEST.Param2.SlotMask + {0x8 ~ 0xE, 0xF}

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=InvalidSlotID[i], Param2=0, Offset=0, Length=0x400}

2. SpdmMessage <- Responder

Assertion 5.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 5.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=0, Param2=0, Invalid_Offset=0xFFFF, Length=0x400}

4. SpdmMessage <- Responder

Assertion 5.4.*.

###

SPDM_SMBUS_V1_4_Test_006_001.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B1, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

8. DIGESTS <- Responder

9. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

10. CERTIFICATE <- Responder

11. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

12. SpdmMessage <- Responder

Assertion 6.1.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.1.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.1.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.1.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.1.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.1.7:

13. Repeat (1~12) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.1.*.

14. Repeat (1~12) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.1.*.

###

SPDM_SMBUS_V1_4_Test_006_002.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B2, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

8. SpdmMessage <- Responder

Assertion 6.2.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.2.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.2.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.2.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.2.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.2.7:

9. Repeat (1~8) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.2.*.

10. Repeat (1~8) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.2.*.

###

SPDM_SMBUS_V1_4_Test_006_003.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B3, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

8. DIGESTS <- Responder

9. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

10. SpdmMessage <- Responder

Assertion 6.3.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.3.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.3.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.3.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.3.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.3.7:

11. Repeat (1~10) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.3.*.

12. Repeat (1~10) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.3.*.

###

SPDM_SMBUS_V1_4_Test_006_011.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B1, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

2. DIGESTS <- Responder

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

4. CERTIFICATE <- Responder

5. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

6. SpdmMessage <- Responder

Assertion 6.11.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.11.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.11.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.11.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.11.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.11.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.11.7:

7. Repeat (1~6) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.11.*.

8. Repeat (1~6) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.11.*.

###

SPDM_SMBUS_V1_4_Test_006_012.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B2, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

2. SpdmMessage <- Responder

Assertion 6.12.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.12.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.12.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.12.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.12.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.12.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.12.7:

3. Repeat (1~2) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.12.*.

4. Repeat (1~2) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.12.*.

###

SPDM_SMBUS_V1_4_Test_006_013.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B3, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

2. DIGESTS <- Responder

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

4. SpdmMessage <- Responder

Assertion 6.13.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.13.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.13.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.13.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.13.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.13.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.13.7:

5. Repeat (1~4) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.13.*.

6. Repeat (1~4) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.13.*.

###

SPDM_SMBUS_V1_4_Test_006_014.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B4, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

2. CERTIFICATE <- Responder

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

4. SpdmMessage <- Responder

Assertion 6.14.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.14.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.14.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.14.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.14.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.14.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.14.7:

5. Repeat (1~4) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.14.*.

6. Repeat (1~4) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.14.*.

SPDM_SMBUS_V1_4_Test_007_001.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements}

2. SpdmMessage <- Responder

Assertion 7.1.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.1.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.1.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.1.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2 SPDMsignatureVerify (PubKey, SpdmMessage.Signature, L1/L2) version 1.0 success, if Flags.MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements}

4. SpdmMessage <- Responder

Assertion 7.1.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.1.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.1.14:

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.1.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.1.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.1.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1]}

8. SpdmMessage <- Responder

Assertion 7.1.{15~20}

Assertion 7.1.21:

###

SPDM_SMBUS_V1_4_Test_007_006.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]}

2. SpdmMessage <- Responder

Assertion 7.6.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.6.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.6.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.6.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]}

4. SpdmMessage <- Responder

Assertion 7.6.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.6.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.6.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.6.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.6.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.6.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]}

8. SpdmMessage <- Responder

Assertion 7.6.{15~20}

Assertion 7.6.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

###

SPDM_SMBUS_V1_4_Test_007_007.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS in a DHE session with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

16. Requester -> FINISH {SPDMVersion=NegotiatedVersion, …} in session-X

17. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.7.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.7.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.7.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.7.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 7.7.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.7.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.7.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]} in session-X, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder in session-X

Assertion 7.7.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.7.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.7.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 7.7.{15~20}

Assertion 7.7.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

###

SPDM_SMBUS_V1_4_Test_007_008.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_MEASUREMENTS in a DHE session handshake.

SPDM Version: 1.1+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 or above is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.8.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.8.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.8.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.8.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 7.8.5:

SpdmMessage.Param2 == 0.

###

SPDM_SMBUS_V1_4_Test_007_009.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]}

2. SpdmMessage <- Responder

Assertion 7.9.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.9.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.9.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.9.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]}

4. SpdmMessage <- Responder

Assertion 7.9.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.9.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.9.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.9.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.9.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.9.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]}

8. SpdmMessage <- Responder

Assertion 7.9.{15~20}

Assertion 7.9.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

###

SPDM_SMBUS_V1_4_Test_007_010.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS in a DHE session with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

16. Requester -> FINISH {SPDMVersion=NegotiatedVersion, …} in session-X

17. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.10.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.10.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.10.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.10.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 7.10.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.10.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.10.14:

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]} in session-X, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder in session-X

Assertion 7.10.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.10.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.10.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 7.10.{15~20}

Assertion 7.10.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

SPDM_SMBUS_V1_4_Test_008_001.py

Description: SPDM responder shall return valid KEY_EXCHANGE_RSP, if it receives a KEY_EXCHANGE with negotiated version 1.1.

SPDM Version: 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], ReqSessionID, RandomData, ExchangeData, OpaqueData}

2. SpdmMessage <- Responder

Assertion 8.1.1:

sizeof(SpdmMessage) >= sizeof(KEY_EXCHANGE_RSP) + SpdmMessage.OpaqueDataLength

Assertion 8.1.2:

SpdmMessage.RequestResponseCode == KEY_EXCHANGE_RSP

Assertion 8.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 8.1.4:

SpdmMessage.MutAuthRequested == 0 && SpdmMessage.SlotIDParam == 0

Assertion 8.1.5:

Assertion 8.1.6:

HMACVerify (finished_key, SpdmMessage.ResponderVerifyData, TH.HMAC.KEY_EXCHANGE_RSP) version 1.1 success

3. Repeat (1~2) and use KEY_EXCHANGE {Param1=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 8.1.*.

4. Repeat (1~2) and use KEY_EXCHANGE {Param1=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 8.1.*.

###

SPDM_SMBUS_V1_4_Test_008_007.py

Description: SPDM responder shall return valid KEY_EXCHANGE_RSP, if it receives a KEY_EXCHANGE with negotiated version 1.2.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], ReqSessionID, SessionPolicy.TerminationPolicy=1, RandomData, ExchangeData, OpaqueData}

2. SpdmMessage <- Responder

Assertion 8.7.1:

sizeof(SpdmMessage) >= sizeof(KEY_EXCHANGE_RSP) + SpdmMessage.OpaqueDataLength

Assertion 8.7.2:

SpdmMessage.RequestResponseCode == KEY_EXCHANGE_RSP

Assertion 8.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 8.7.4:

SpdmMessage.MutAuthRequested == 0 && SpdmMessage.SlotIDParam == 0

Assertion 8.7.5:

Assertion 8.7.6:

HMACVerify (finished_key, SpdmMessage.ResponderVerifyData, TH.HMAC.KEY_EXCHANGE_RSP) version 1.2 success

3. Repeat (1~2) and use KEY_EXCHANGE {Param1=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 8.7.*.

4. Repeat (1~2) and use KEY_EXCHANGE {Param1=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 8.7.*.

###

SPDM_SMBUS_V1_4_Test_009_001.py

Description: SPDM responder shall return valid FINISH_RSP, if it receives a FINISH with negotiated version 1.1.

SPDM Version: 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 9.1.1:

sizeof(SpdmMessage) >= sizeof(FINISH_RSP) - HMAC size

Assertion 9.1.2:

SpdmMessage.RequestResponseCode == FINISH_RSP

Assertion 9.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_SMBUS_V1_4_Test_009_009.py

Description: SPDM responder shall return valid FINISH_RSP, if it receives a FINISH with negotiated version 1.2.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 9.9.1:

sizeof(SpdmMessage) >= sizeof(FINISH_RSP)

Assertion 9.9.2:

SpdmMessage.RequestResponseCode == FINISH_RSP

Assertion 9.9.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_SMBUS_V1_4_Test_009_011.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a FINISH in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} (not in session-X)

2. SpdmMessage <- Responder (not in session-X)

Assertion 9.11.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 9.11.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 9.11.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 9.11.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_SMBUS_V1_4_Test_010_001.py

Description: SPDM responder shall return valid PSK_EXCHANGE_RSP, if it receives a PSK_EXCHANGE.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.PSK_CAP != 1, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> PSK_EXCHANGE {SPDMVersion=NegotiatedVersion,
   MeasurementSummaryHashType=0, SessionPolicy=0}
2. SpdmMessage <- Responder

Assertion 10.1.1:
    sizeof(SpdmMessage) >= offset(PSK_EXCHANGE_RSP, Q)

Assertion 10.1.2:
    SpdmMessage.RequestResponseCode == PSK_EXCHANGE_RSP

Assertion 10.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 10.1.4:
    sizeof(SpdmMessage) >= offset(PSK_EXCHANGE_RSP, ResponderContext) +
    SpdmMessage.Q

SPDM_SMBUS_V1_4_Test_010_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a PSK_EXCHANGE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_EXCHANGE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 10.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 10.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 10.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 10.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 10.2.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_011_001.py

Description: SPDM responder shall return valid PSK_FINISH_RSP, if it receives a PSK_FINISH.

SPDM Version: 1.2+

Note: PSK_FINISH completes a PSK session handshake and carries an HMAC (RequesterVerifyData) over the session transcript. It is normally issued only after a PSK_EXCHANGE within the same session; issued standalone the responder may return ERROR. This case validates the PSK_FINISH_RSP format when one is returned.

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP != 1, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0} 2. SpdmMessage <- Responder

Assertion 11.1.1:

sizeof(SpdmMessage) >= sizeof(PSK_FINISH_RSP)

Assertion 11.1.2:

SpdmMessage.RequestResponseCode == PSK_FINISH_RSP

Assertion 11.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 11.1.4:

SpdmMessage.Param1 == 0

Assertion 11.1.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_011_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a PSK_FINISH with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_FINISH {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 11.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 11.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 11.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 11.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 11.2.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_012_004.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a HEARTBEAT in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.HBEAT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> HEARTBEAT {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 12.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.4.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_SMBUS_V1_4_Test_013_005.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a KEY_UPDATE in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.HBEAT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateKey, Param2=Tag}

2. SpdmMessage <- Responder

Assertion 13.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.5.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_SMBUS_V1_4_Test_014_001.py

Description: SPDM responder shall return valid ENCAPSULATED_REQUEST, if it receives a GET_ENCAPSULATED_REQUEST.

SPDM Version: 1.2+

Note: GET_ENCAPSULATED_REQUEST retrieves a request the responder is waiting to send, which only happens inside the encapsulated request flow. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of ENCAPSULATED_REQUEST. This case validates the ENCAPSULATED_REQUEST format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.ENCAP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENCAPSULATED_REQUEST {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 14.1.1:
    sizeof(SpdmMessage) >= offset(ENCAPSULATED_REQUEST, EncapsulatedRequest)

Assertion 14.1.2:
    SpdmMessage.RequestResponseCode == ENCAPSULATED_REQUEST

Assertion 14.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

SPDM_SMBUS_V1_4_Test_014_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_ENCAPSULATED_REQUEST with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.ENCAP_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> GET_ENCAPSULATED_REQUEST {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 14.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 14.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 14.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 14.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 14.2.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_015_001.py

Description: SPDM responder shall return valid ENCAPSULATED_RESPONSE_ACK, if it receives a DELIVER_ENCAPSULATED_RESPONSE.

SPDM Version: 1.2+

Note: DELIVER_ENCAPSULATED_RESPONSE is part of the encapsulated request flow and is normally issued in response to a prior ENCAPSULATED_REQUEST. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of ENCAPSULATED_RESPONSE_ACK. This case validates the ENCAPSULATED_RESPONSE_ACK format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.ENCAP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> DELIVER_ENCAPSULATED_RESPONSE {SPDMVersion=NegotiatedVersion,
   RequestID=0}
2. SpdmMessage <- Responder

Assertion 15.1.1:
    sizeof(SpdmMessage) >= offset(ENCAPSULATED_RESPONSE_ACK,
    EncapsulatedRequest)

Assertion 15.1.2:
    SpdmMessage.RequestResponseCode == ENCAPSULATED_RESPONSE_ACK

Assertion 15.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

SPDM_SMBUS_V1_4_Test_015_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a DELIVER_ENCAPSULATED_RESPONSE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.ENCAP_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> DELIVER_ENCAPSULATED_RESPONSE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 15.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 15.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 15.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 15.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 15.2.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_016_004.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a END_SESSION in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 && Flags.PSK_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> END_SESSION {SPDMVersion=NegotiatedVersion, Param1.StatePreservation=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 16.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.4.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_SMBUS_V1_4_Test_017_001.py

Description: SPDM responder shall return valid CSR, if it receives a GET_CSR.

SPDM Version: 1.2+

Note: a CSR is often larger than the DataTransferSize the requester advertised. The responder then answers with ERROR(LargeResponse) and the CSR is collected with CHUNK_GET before the assertions run. A CSR larger than the advertised MaxSPDMmsgSize cannot be received at all; ERROR(ResponseTooLarge) is conformant there and the case is Skipped.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CSR_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_CSR {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0,
   RequesterInfoLength=0, OpaqueDataLength=0}
2. SpdmMessage <- Responder

Assertion 17.1.1:
    sizeof(SpdmMessage) >= offset(CSR, CSRData)

Assertion 17.1.2:
    SpdmMessage.RequestResponseCode == CSR

Assertion 17.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 17.1.4:
    SpdmMessage.CSRLength > 0

Assertion 17.1.5:
    sizeof(SpdmMessage) >= offset(CSR, CSRData) + SpdmMessage.CSRLength

SPDM_SMBUS_V1_4_Test_017_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_CSR with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.CSR_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> GET_CSR {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 17.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 17.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 17.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 17.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 17.2.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_018_001.py

Description: SPDM responder shall return valid CHUNK_SEND_ACK, if it receives a CHUNK_SEND.

SPDM Version: 1.2+

Note: CHUNK_SEND belongs to the Large SPDM message transfer mechanism and is only meaningful as part of a genuine large request. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of CHUNK_SEND_ACK. This case validates the CHUNK_SEND_ACK format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_SEND {SPDMVersion=NegotiatedVersion,
   Param1=LastChunk, Handle=0, ChunkSeqNo=0, ChunkSize=0}
2. SpdmMessage <- Responder

Assertion 18.1.1:
    sizeof(SpdmMessage) >= offset(CHUNK_SEND_ACK, ResponseToLargeRequest)

Assertion 18.1.2:
    SpdmMessage.RequestResponseCode == CHUNK_SEND_ACK

Assertion 18.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 18.1.4:
    SpdmMessage.Param2 == requested Handle

SPDM_SMBUS_V1_4_Test_018_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHUNK_SEND with non negotiated version.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_SEND {SPDMVersion=(NegotiatedVersion+1),
   Param1=LastChunk, Handle=0, ChunkSeqNo=0, ChunkSize=0}
2. SpdmMessage <- Responder

Assertion 18.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 18.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 18.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 18.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 18.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_019_001.py

Description: SPDM responder shall return valid CHUNK_RESPONSE, if it receives a CHUNK_GET during an in-progress large response transfer.

SPDM Version: 1.2+

Note: CHUNK_GET is only meaningful while the responder has a large response pending, identified by Handle. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of CHUNK_RESPONSE. This case validates the CHUNK_RESPONSE format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_GET {SPDMVersion=NegotiatedVersion, Param1=0, Handle=0,
   ChunkSeqNo=0}
2. SpdmMessage <- Responder

Assertion 19.1.1:
    sizeof(SpdmMessage) >= offset(CHUNK_RESPONSE, LargeMessageSize)

Assertion 19.1.2:
    SpdmMessage.RequestResponseCode == CHUNK_RESPONSE

Assertion 19.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 19.1.4:
    sizeof(SpdmMessage) >= offset(CHUNK_RESPONSE, LargeMessageSize) +
    SpdmMessage.ChunkSize

SPDM_SMBUS_V1_4_Test_019_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHUNK_GET with non negotiated version.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_GET {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Handle=0, ChunkSeqNo=0}
2. SpdmMessage <- Responder

Assertion 19.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 19.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 19.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 19.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 19.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_020_001.py

Description: SPDM responder shall return valid KEY_PAIR_INFO, if it receives a GET_KEY_PAIR_INFO.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.GET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_KEY_PAIR_INFO {SPDMVersion=NegotiatedVersion, Param1=0,
   Param2=0, KeyPairID=1}
2. SpdmMessage <- Responder

Assertion 20.1.1:
    sizeof(SpdmMessage) >= offset(KEY_PAIR_INFO, PublicKeyInfo)

Assertion 20.1.2:
    SpdmMessage.RequestResponseCode == KEY_PAIR_INFO

Assertion 20.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 20.1.4:
    SpdmMessage.KeyPairID == requested KeyPairID

Assertion 20.1.5:
    SpdmMessage.TotalKeyPairs > 0

Assertion 20.1.6:
    sizeof(SpdmMessage) >= offset(KEY_PAIR_INFO, PublicKeyInfo) +
    SpdmMessage.PublicKeyInfoLen

SPDM_SMBUS_V1_4_Test_020_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_KEY_PAIR_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.GET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_KEY_PAIR_INFO {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Param2=0, KeyPairID=1}
2. SpdmMessage <- Responder

Assertion 20.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 20.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 20.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 20.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 20.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_021_001.py

Description: SPDM responder shall return valid SET_KEY_PAIR_INFO_ACK, if it receives a SET_KEY_PAIR_INFO.

SPDM Version: 1.3+

Note: SET_KEY_PAIR_INFO changes responder key pair configuration and is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SET_KEY_PAIR_INFO_ACK. This case validates the SET_KEY_PAIR_INFO_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of SET_KEY_PAIR_INFO_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_KEY_PAIR_INFO {SPDMVersion=NegotiatedVersion,
   Param1=0 (ParameterChange), KeyPairID=1, DesiredKeyUsage=0,
   DesiredAsymAlgo=0, DesiredAssocCertSlotMask=0}

   A ParameterChange with no bits set does not change the current key pair
   configuration (Table 106), so this exercises the acknowledgement without
   modifying responder state.
2. SpdmMessage <- Responder

Assertion 21.1.1:
    sizeof(SpdmMessage) >= sizeof(SET_KEY_PAIR_INFO_ACK)

Assertion 21.1.2:
    SpdmMessage.RequestResponseCode == SET_KEY_PAIR_INFO_ACK

Assertion 21.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 21.1.4:
    SpdmMessage.Param1 == 0

Assertion 21.1.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_021_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SET_KEY_PAIR_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_KEY_PAIR_INFO {SPDMVersion=(NegotiatedVersion+1),
   Param1=0 (ParameterChange), KeyPairID=1, DesiredKeyUsage=0,
   DesiredAsymAlgo=0, DesiredAssocCertSlotMask=0}
2. SpdmMessage <- Responder

Assertion 21.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 21.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 21.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 21.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 21.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_022_001.py

Description: SPDM Event Notifier shall return valid SUPPORTED_EVENT_TYPES, if it receives a GET_SUPPORTED_EVENT_TYPES.

SPDM Version: 1.3+

Note: GET_SUPPORTED_EVENT_TYPES is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SUPPORTED_EVENT_TYPES. This case validates the SUPPORTED_EVENT_TYPES format when one is returned and is Skipped when the responder answers ERROR. Full validation of SUPPORTED_EVENT_TYPES requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_SUPPORTED_EVENT_TYPES {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 22.1.1:
    sizeof(SpdmMessage) >= offset(SUPPORTED_EVENT_TYPES,
    SupportedEventGroupsList)

Assertion 22.1.2:
    SpdmMessage.RequestResponseCode == SUPPORTED_EVENT_TYPES

Assertion 22.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 22.1.4:
    SpdmMessage.Param2 == 0

Assertion 22.1.5:
    SpdmMessage.SupportedEventGroupsListLen > 0

Assertion 22.1.6:
    sizeof(SpdmMessage) >= offset(SUPPORTED_EVENT_TYPES,
    SupportedEventGroupsList) + SpdmMessage.SupportedEventGroupsListLen

SPDM_SMBUS_V1_4_Test_022_002.py

Description: SPDM Event Notifier shall return ERROR(VersionMismatch), if it receives a GET_SUPPORTED_EVENT_TYPES with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_SUPPORTED_EVENT_TYPES {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 22.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 22.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 22.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 22.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 22.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_023_001.py

Description: SPDM Event Notifier shall return valid SUBSCRIBE_EVENT_TYPES_ACK, if it receives a SUBSCRIBE_EVENT_TYPES.

SPDM Version: 1.3+

Note: SUBSCRIBE_EVENT_TYPES is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SUBSCRIBE_EVENT_TYPES_ACK. This case validates the SUBSCRIBE_EVENT_TYPES_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of SUBSCRIBE_EVENT_TYPES_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SUBSCRIBE_EVENT_TYPES {SPDMVersion=NegotiatedVersion,
   Param1=0 (SubscribeEventGroupCount, unsubscribe all), Param2=0}
2. SpdmMessage <- Responder

Assertion 23.1.1:
    sizeof(SpdmMessage) >= sizeof(SUBSCRIBE_EVENT_TYPES_ACK)

Assertion 23.1.2:
    SpdmMessage.RequestResponseCode == SUBSCRIBE_EVENT_TYPES_ACK

Assertion 23.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 23.1.4:
    SpdmMessage.Param1 == 0

Assertion 23.1.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_023_002.py

Description: SPDM Event Notifier shall return ERROR(VersionMismatch), if it receives a SUBSCRIBE_EVENT_TYPES with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SUBSCRIBE_EVENT_TYPES {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 23.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 23.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 23.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 23.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 23.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_024_001.py

Description: SPDM Event Recipient shall return valid EVENT_ACK, if it receives a SEND_EVENT.

SPDM Version: 1.3+

Note: SEND_EVENT is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of EVENT_ACK. This case validates the EVENT_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of EVENT_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SEND_EVENT {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0,
   EventCount=1, EventsList=<one DMTF EventLost event>}
2. SpdmMessage <- Responder

Assertion 24.1.1:
    sizeof(SpdmMessage) >= sizeof(EVENT_ACK)

Assertion 24.1.2:
    SpdmMessage.RequestResponseCode == EVENT_ACK

Assertion 24.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 24.1.4:
    SpdmMessage.Param1 == 0

Assertion 24.1.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_024_002.py

Description: SPDM Event Recipient shall return ERROR(VersionMismatch), if it receives a SEND_EVENT with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SEND_EVENT {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Param2=0, EventCount=1, EventsList=<one DMTF EventLost event>}
2. SpdmMessage <- Responder

Assertion 24.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 24.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 24.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 24.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 24.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_025_001.py

Description: SPDM responder shall return valid ENDPOINT_INFO, if it receives a GET_ENDPOINT_INFO.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EP_INFO_CAP != 1 (no-signature capable), then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENDPOINT_INFO {SPDMVersion=NegotiatedVersion,
   Param1=DeviceClassIdentifier, Param2=0, RequestAttributes=0}
2. SpdmMessage <- Responder

Assertion 25.1.1:
    sizeof(SpdmMessage) >= offset(ENDPOINT_INFO, EPInfoLength)

Assertion 25.1.2:
    SpdmMessage.RequestResponseCode == ENDPOINT_INFO

Assertion 25.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 25.1.4:
    SpdmMessage.Param1 == 0

Assertion 25.1.5:
    SpdmMessage.Param2.SlotID == 0

Assertion 25.1.6:
    sizeof(SpdmMessage) >= offset(ENDPOINT_INFO, EPInfo) +
    SpdmMessage.EPInfoLength

SPDM_SMBUS_V1_4_Test_025_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_ENDPOINT_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EP_INFO_CAP != 1 (no-signature capable), then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENDPOINT_INFO {SPDMVersion=(NegotiatedVersion+1),
   Param1=DeviceClassIdentifier, Param2=0, RequestAttributes=0}
2. SpdmMessage <- Responder

Assertion 25.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 25.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 25.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 25.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 25.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_026_001.py

Description: SPDM responder shall return valid MEASUREMENT_EXTENSION_LOG, if it receives a GET_MEASUREMENT_EXTENSION_LOG.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.MEL_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_MEASUREMENT_EXTENSION_LOG {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0, Offset=0, Length=0xFFFFFFFF}
2. SpdmMessage <- Responder

Assertion 26.1.1:
    sizeof(SpdmMessage) >= offset(MEASUREMENT_EXTENSION_LOG, MEL)

Assertion 26.1.2:
    SpdmMessage.RequestResponseCode == MEASUREMENT_EXTENSION_LOG

Assertion 26.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 26.1.4:
    SpdmMessage.Param1 == 0

Assertion 26.1.5:
    SpdmMessage.Param2 == 0

Assertion 26.1.6:
    sizeof(SpdmMessage) >= offset(MEASUREMENT_EXTENSION_LOG, MEL) +
    SpdmMessage.PortionLength

Assertion 26.1.7:
    if SpdmMessage.RemainderLength == 0 then
    SpdmMessage.PortionLength == offset(MEL, MELEntries) +
    SpdmMessage.MEL.MELEntriesLength

Assertion 26.1.8:
    if SpdmMessage.RemainderLength == 0 && SpdmMessage.MEL.NumberOfEntries > 0
    then SpdmMessage.MEL.MELEntriesLength >=
    SpdmMessage.MEL.NumberOfEntries * sizeof(minimum MEL entry)

SPDM_SMBUS_V1_4_Test_026_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_MEASUREMENT_EXTENSION_LOG with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.MEL_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_MEASUREMENT_EXTENSION_LOG {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0, Offset=0, Length=0xFFFFFFFF}
2. SpdmMessage <- Responder

Assertion 26.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 26.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 26.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 26.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 26.2.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_027_001.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with SupportedSubCodes structure, if it receives a SLOT_MANAGEMENT with SubCode=SupportedSubCodes.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, …} 2. SpdmMessage <- Responder

Assertion 27.1.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.1.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.1.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (SupportedSubCodes)

Assertion 27.1.5:

SpdmMessage.Param2 == 0

Assertion 27.1.6:

SupportedSubCodes.Reserved == 0

Assertion 27.1.7:

SupportedSubCodes.RespLength == 36

Assertion 27.1.8:

SupportedSubCodes.SubCodeBitmap.Bit[SupportedSubCodes] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetBankInfo] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetBankDetails] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetCertificateChain] == 1

SPDM_SMBUS_V1_4_Test_027_002.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with BankInfo structure, if it receives a SLOT_MANAGEMENT with SubCode=GetBankInfo.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, …} 2. SpdmMessage <- Responder

Assertion 27.2.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.2.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.2.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (GetBankInfo)

Assertion 27.2.5:

BankInfo.RespLength == offset(BankInfo, BankElements) + (BankInfo.NumBankElements * sizeof(BankElement))

Assertion 27.2.6:

BankInfo.NumBankElements > 0 && BankInfo.NumBankElements <= 240

Assertion 27.2.7:

For every BankElement in BankInfo.BankElements[]:

BankElement.ElementLength == 4 && BankElement.BankID <= 239

Assertion 27.2.8:

For every pair (i, j), i != j, in BankInfo.BankElements[]:

BankElements[i].BankID != BankElements[j].BankID

Assertion 27.2.9:

BankInfo.Reserved == 0

SPDM_SMBUS_V1_4_Test_027_003.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with BankDetails structure, if it receives a SLOT_MANAGEMENT with SubCode=GetBankDetails for each valid BankID.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SLOT_MANAGEMENT_RESP <- Responder

3. ValidBankID[] = array of BankElement.BankID from BankInfo.BankElements[]

For each BankID in ValidBankID[] and 0xFF:

4. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankDetails, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=0}}

5. SpdmMessage <- Responder

Assertion 27.3.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.3.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.3.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT_RESP.Param1 (GetBankDetails)

Assertion 27.3.5:

If SLOT_MANAGEMENT.SlotAddress.BankID != 0xFF, then

BankDetails.BankID == SLOT_MANAGEMENT.SlotAddress.BankID

else

BankDetails.BankID is one of ValidBankID[]

Assertion 27.3.6:

BankDetails.RespLength == sizeof(BankDetails)

Assertion 27.3.7:

BankDetails.NumSlotElements <= 8

Assertion 27.3.8:

For SlotElement[i]:

BankDetails.SlotElement[i].ElementLength == 16 + H && SlotElement[i].SlotID <= 7 && BankElements[BankDetails.BankID].SlotMask.Bit[SlotElement[i].SlotID] == 1 && (if MULTI_KEY_CONN_RSP == false => KeyPairID == 0) && (if Provisioned == 0 => Digest == 0)

Assertion 27.3.9:

popcount(BankDetails.CurrentAsymAlgo) + popcount(BankDetails.CurrentPqcAsymAlgo) <= 1

Assertion 27.3.10:

(BankDetails.AsymAlgoCapabilities | BankDetails.PqcAsymAlgoCapabilities) != 0

Assertion 27.3.11:

(BankDetails.AvailableAsymAlgo & ~BankDetails.AsymAlgoCapabilities) == 0 && (BankDetails.AvailablePqcAsymAlgo & ~BankDetails.PqcAsymAlgoCapabilities) == 0

Assertion 27.3.12:

(BankDetails.CurrentAsymAlgo & ~BankDetails.AsymAlgoCapabilities) == 0 && (BankDetails.CurrentPqcAsymAlgo & ~BankDetails.PqcAsymAlgoCapabilities) == 0

Assertion 27.3.13:

If BankDetails.BankAttributes.ConfigAlgo == 0, then

BankDetails.AsymAlgoCapabilities == 0 && BankDetails.PqcAsymAlgoCapabilities == 0 && BankDetails.AvailableAsymAlgo == 0 && BankDetails.AvailablePqcAsymAlgo == 0

Assertion 27.3.14:

BankDetails.BankAttributes.Reserved == 0 && BankDetails.Reserved == 0 && every SlotElement.Reserved == 0

Assertion 27.3.15:

BankDetails.BankAttributes.Reserved == 0 && BankDetails.Reserved == 0

Assertion 27.3.16:

BankDetails.NumSlotElements == popcount(BankElements[BankDetails.BankID].SlotMask)

Assertion 27.3.17:

For every pair (m, n), m != n, in BankDetails.SlotElements[]:

SlotElements[m].SlotID != SlotElements[n].SlotID

Assertion 27.3.18:

If BankAttributes.ConfigAlgo == 1 && CurrentAsymAlgo == 0 && CurrentPqcAsymAlgo == 0, then no SlotElement has SlotAttributes.Bit[0] (Provisioned) == 1

SPDM_SMBUS_V1_4_Test_027_004.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with GetCertificateChain structure, if it receives a SLOT_MANAGEMENT with SubCode=GetCertificateChain for any provisioned slot in any Bank reported by GetBankInfo.

SPDM Version: 1.4+

Note: a certificate chain is often larger than the DataTransferSize the requester advertised, and post-quantum chains always are. The responder then answers with ERROR(LargeResponse) and the chain is collected with CHUNK_GET before the assertions run. A chain larger than the advertised MaxSPDMmsgSize cannot be received at all; ERROR(ResponseTooLarge) is conformant there and the case is Skipped.

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0 || Flags.CERT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SLOT_MANAGEMENT_RESP <- Responder

3. SelectedBankIDs[] = array of BankID where BankAttributes.Bit[0] (Selected) == 1.

For each BankID in SelectedBankIDs[]:

4. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankDetails, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=0}}

5. BankDetails <- Responder

6. ProvisionedPairs[] = array of (BankID, SlotID) for every SlotElement in BankDetails.SlotElements[] where SlotAttributes.Bit[0] (Provisioned) == 1.

For each (BankID, SlotID) in ProvisionedPairs[]:

5. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetCertificateChain, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=SlotID}}

6. SpdmMessage <- Responder

Assertion 27.4.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct) + offset(GetCertificateChain, CertChain)

Assertion 27.4.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.4.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (GetCertificateChain)

Assertion 27.4.5:

SpdmMessage.MgmtStructOffset >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct) && SpdmMessage.MgmtStructOffset + offset(GetCertificateChain, CertChain) <= sizeof(SpdmMessage)

Assertion 27.4.6:

GetCertificateChain.CCLength + SpdmMessage.MgmtStructOffset + offset(GetCertificateChain, CertChain) <= sizeof(SpdmMessage)

Assertion 27.4.7:

GetCertificateChain.Reserved == 0

SPDM_SMBUS_V1_4_Test_027_005.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SLOT_MANAGEMENT with non negotiated version.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=(NegotiatedVersion+1), Param1.SubCode=SupportedSubCodes, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0} 2. SpdmMessage <- Responder

Assertion 27.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.5.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 27.5.5:

SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_027_006.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a SLOT_MANAGEMENT with a reserved or unknown SubCode value.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=0x05, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SpdmMessage <- Responder

Assertion 27.6.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.6.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.6.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 27.6.5:

SpdmMessage.Param2 == 0.

SPDM_SMBUS_V1_4_Test_027_007.py

Description: SPDM responder shall return ERROR(UnsupportedRequest), if it receives a SLOT_MANAGEMENT with a valid SubCode that is not in SupportedSubCodes.SubCodeBitmap.

SPDM Version: 1.4+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.SLOT_MGMT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, …}

10. SLOT_MANAGEMENT_RESP <- Responder

11. UnsupportedSubCode = any SubCode in {GetCSR, ManageBank, ManageSlot, SetCertificate} whose bit is 0 in SupportedSubCodes.SubCodeBitmap. If no such SubCode exists, skip this case.

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=UnsupportedSubCode, MgmtStructOffset=<as required>, SlotMgmtReqStruct=<as required>}

2. SpdmMessage <- Responder

Assertion 27.7.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.7.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.7.4:

SpdmMessage.Param1 == UnsupportedRequest.

Assertion 27.7.5:

SpdmMessage.Param2 == SLOT_MANAGEMENT (0x88).

ErrorData for ERROR(UnsupportedRequest) is the RequestResponseCode of the request that was not supported, so the responder echoes back the code it could not serve – 0x88 here, not 0.

SPDM_SMBUS_V1_4_Test_027_008.py

Description: SPDM responder shall return ERROR(UnsupportedRequest), if it receives a SLOT_MANAGEMENT when SLOT_MGMT_CAP=0 in CAPABILITIES.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 1, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SpdmMessage <- Responder

Assertion 27.8.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.8.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.8.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.8.4:

SpdmMessage.Param1 == UnsupportedRequest.

Assertion 27.8.5:

SpdmMessage.Param2 == SLOT_MANAGEMENT (0x88).

ErrorData for ERROR(UnsupportedRequest) is the RequestResponseCode of the request that was not supported, so the responder echoes back the code it could not serve – 0x88 here, not 0.

SPDM_SMBUS_V1_4_Test_028_001.py

Description: SPDM responder shall return valid SET_CERTIFICATE_RSP, if it receives a SET_CERTIFICATE.

SPDM Version: 1.2+

Note: SET_CERTIFICATE provisions or erases a certificate slot and is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SET_CERTIFICATE_RSP. This case validates the SET_CERTIFICATE_RSP format when one is returned and is Skipped when the responder answers ERROR. Full validation of SET_CERTIFICATE_RSP requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_CERT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_CERTIFICATE {SPDMVersion=NegotiatedVersion, SlotID=0,
   Param2=0}
2. SpdmMessage <- Responder

Assertion 28.1.1:
    sizeof(SpdmMessage) >= sizeof(SET_CERTIFICATE_RSP)

Assertion 28.1.2:
    SpdmMessage.RequestResponseCode == SET_CERTIFICATE_RSP

Assertion 28.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 28.1.4:
    SpdmMessage.Param1.SlotID == requested SlotID

Assertion 28.1.5:
    SpdmMessage.Param2 == 0

SPDM_SMBUS_V1_4_Test_028_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SET_CERTIFICATE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SET_CERT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SET_CERTIFICATE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 28.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 28.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 28.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 28.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 28.2.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_001_001.py

Description: SPDM responder shall return valid VERSION, if it receives a GET_VERSION with version 1.0.

SPDM Version: 1.0+

TestSetup: None

TestTeardown: None

Steps: 1. Requester -> GET_VERSION {SPDMVersion=0x10, Param1=0, Param2=0} 2. SpdmMessage <- Responder

Assertion 1.1.1:

sizeof(SpdmMessage) >= offset(VERSION, VersionNumberEntry)

Assertion 1.1.2:

SpdmMessage.RequestResponseCode == VERSION

Assertion 1.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 1.1.4:

SpdmMessage.VersionNumberEntryCount > 0 && SpdmMessage.VersionNumberEntryCount <= (sizeof(SpdmMessage) - offset(VERSION, VersionNumberEntry)) / sizeof(uint16_t)

Assertion 1.1.5:

((SpdmMessage.VersionNumberEntry[i].MajorVersion << 4) + SpdmMessage.VersionNumberEntry[i].MinorVersion) is in {0x10, 0x11, 0x12, 0x13, 0x14}.

SPDM_VDM_V1_4_Test_002_001.py

Description: SPDM responder shall return valid CAPABILITIES(0x10), if it receives a GET_CAPABILITIES with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x10, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 2.1.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.0)

Assertion 2.1.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 2.1.4:

Flags.MEAS_CAP != 3

###

SPDM_VDM_V1_4_Test_002_003.py

Description: SPDM responder shall return valid CAPABILITIES(0x11), if it receives a GET_CAPABILITIES with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x11, Param1=0, Param2=0, CTExponent, Flags=CERT_CAP|CHAL_CAP|ENCRYPT_CAP|MAC_CAP|MUT_AUTH_CAP|KEY_EX_CAP|PSK_CAP=1|ENCAP_CAP|HBEAT_CAP|KEY_UPD_CAP}

2. SpdmMessage <- Responder

Assertion 2.3.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.1)

Assertion 2.3.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.3.3:

SpdmMessage.SPDMVersion == 0x11

Assertion 2.3.4:

Flags.MEAS_CAP != 3

Assertion 2.3.5:

if (Flags.ENCRYPT_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.3.6:

if (Flags.MAC_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.3.7:

if (Flags.KEY_EX_CAP == 1), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.3.8:

Flags.PSK_CAP != 3

Assertion 2.3.9:

if (Flags.PSK_CAP != 0), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.3.10:

if (Flags.MUT_AUTH_CAP == 1), then (Flags.ENCAP_CAP == 1)

Assertion 2.3.11:

if (Flags.HANDSHAKE_IN_THE_CLEAR_CAP == 1), then (Flags.KEY_EX_CAP == 1)

Assertion 2.3.12:

if (Flags.PUB_KEY_ID_CAP == 1), then (Flags.CERT_CAP == 0)

Assertion 2.3.13:

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (CERT_CAP == 1 || PUB_KEY_ID_CAP == 1)

###

SPDM_VDM_V1_4_Test_002_005.py

Description: SPDM responder shall return valid CAPABILITIES(0x12), if it receives a GET_CAPABILITIES with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=0x12, Param1=0, Param2=0, CTExponent, Flags=CERT_CAP|CHAL_CAP|ENCRYPT_CAP|MAC_CAP|MUT_AUTH_CAP|KEY_EX_CAP|PSK_CAP=1|ENCAP_CAP|HBEAT_CAP|KEY_UPD_CAP|CHUNK_CAP, DataTransferSize, MaxSPDMmsgSize}

2. SpdmMessage <- Responder

Assertion 2.5.1:

sizeof(SpdmMessage) >= sizeof(CAPABILITIES_1.2)

Assertion 2.5.2:

SpdmMessage.RequestResponseCode == CAPABILITIES

Assertion 2.5.3:

SpdmMessage.SPDMVersion == 0x12

Assertion 2.5.4:

Flags.MEAS_CAP != 3

Assertion 2.5.5:

if (Flags.ENCRYPT_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.5.6:

if (Flags.MAC_CAP == 1), then (Flags.KEY_EX_CAP == 1 || Flags.PSK_CAP == 1 || Flags.PSK_CAP == 2)

Assertion 2.5.7:

if (Flags.KEY_EX_CAP == 1), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.5.8:

Flags.PSK_CAP != 3

Assertion 2.5.9:

if (Flags.PSK_CAP != 0), then (Flags.ENCRYPT_CAP == 1 || Flags.MAC_CAP == 1)

Assertion 2.5.10:

if (Flags.MUT_AUTH_CAP == 1), then (Flags.ENCAP_CAP == 1)

Assertion 2.5.11:

if (Flags.HANDSHAKE_IN_THE_CLEAR_CAP == 1), then (Flags.KEY_EX_CAP == 1)

Assertion 2.5.12:

if (Flags.PUB_KEY_ID_CAP == 1), then (Flags.CERT_CAP == 0)

Assertion 2.5.13:

SpdmMessage.DataTransferSize >= MinDataTransferSize

Assertion 2.5.14:

SpdmMessage.MaxSPDMmsgSize >= SpdmMessage.DataTransferSize

Assertion 2.5.15:

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (CERT_CAP == 1 || PUB_KEY_ID_CAP == 1)

###

SPDM_VDM_V1_4_Test_003_001.py

Description: SPDM responder shall return valid ALGORITHMS(0x10), if it receives a GET_ALGORITHMS with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x10, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x10, Param1=0, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0}

2. SpdmMessage <- Responder

Assertion 3.1.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.0)

Assertion 3.1.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.1.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 3.1.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.0, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount

Assertion 3.1.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.1.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.1.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.1.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.1.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521}) if (CHAL_CAP == 0 && MEAS_CAP != 2) then (BaseAsymSel == 0)

Assertion 3.1.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (CHAL_CAP == 0 && MEAS_CAP != 2) then (BaseHashSel == 0)

###

SPDM_VDM_V1_4_Test_003_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a NEGOTIATE_ALGORITHMS with non negotiated version.

SPDM Version: 1.0+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
4. CAPABILITIES <- Responder

TestTeardown: None

Steps:
1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=(NegotiatedVersion+1), ...}
2. SpdmMessage <- Responder

Assertion 3.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)
Assertion 3.2.2:
    SpdmMessage.RequestResponseCode == ERROR
Assertion 3.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion
Assertion 3.2.4:
    SpdmMessage.Param1 == VersionMismatch.
Assertion 3.2.5:
    SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=(NegotiatedVersion-1), ...}
4. SpdmMessage <- Responder
Assertion 3.2.*.

SPDM_VDM_V1_4_Test_003_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a NEGOTIATE_ALGORITHMS with invalid field.

SPDM Version: 1.0+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 4. CAPABILITIES <- Responder

TestTeardown: None

Steps: 1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Length-1, …} – if NegotiatedVersion=1.0+ 2. SpdmMessage <- Responder

Assertion 3.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 3.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 3.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 3.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 3.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Length+1, …} – if NegotiatedVersion=1.0+

4. SpdmMessage <- Responder

Assertion 3.4.*.

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ExtAsymCount=21, …} – if NegotiatedVersion=1.0+

6. SpdmMessage <- Responder

Assertion 3.4.*.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ExtHashCount=21, …} – if NegotiatedVersion=1.0+

8. SpdmMessage <- Responder

Assertion 3.4.*.

9. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=1, …} – if NegotiatedVersion=1.1+

10. SpdmMessage <- Responder

Assertion 3.4.*.

11. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=3, …} – if NegotiatedVersion=1.1+

12. SpdmMessage <- Responder

Assertion 3.4.*.

13. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, FixedAlgCount=2, ExtAlgCount=0xF, …} – if NegotiatedVersion=1.1+

14. SpdmMessage <- Responder

Assertion 3.4.*.

SPDM_VDM_V1_4_Test_003_005.py

Description: SPDM responder shall return valid ALGORITHMS(0x11), if it receives a GET_ALGORITHMS with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x11, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x11, Param1.NumOfAlgoStruct=4, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0, ReqAlgStruct[0]{AlgType=DHE, AlgSupported=ffdhe2048|ffdhe3072|ffdhe4096|secp256r1|secp384r1|secp521r1}, ReqAlgStruct[1]{AlgType=AEAD, AlgSupported=AES-128-GCM|AES-256-GCM|CHACHA20_POLY1305}, ReqAlgStruct[2]{AlgType=ReqBaseAsymAlg, AlgSupported=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521}, ReqAlgStruct[3]{AlgType=KeySchedule, AlgSupported=SPDM} }

2. SpdmMessage <- Responder

Assertion 3.5.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.1)

Assertion 3.5.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.5.3:

SpdmMessage.SPDMVersion == 0x11

Assertion 3.5.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.1, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.5.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.5.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.5.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.5.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.5.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0) then (BaseAsymSel == 0)

Assertion 3.5.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0) then (BaseHashSel == 0)

Assertion 3.5.11:

SpdmMessage.Param1 <= 4 SpdmMessage.AlgStructure[i].AlgType is in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule} and no duplication.

Assertion 3.5.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.5.13:

DHE only has one bit at most.

if (KEY_EX_CAP == 1) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1} if (KEY_EX_CAP == 0) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent

Assertion 3.5.14:

AEAD only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305} if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0, or it is absent

Assertion 3.5.15:

ReqBaseAsymAlg only has one bit at most.

if (MUT_AUTH_CAP == 1) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521} if (MUT_AUTH_CAP == 0) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0, or it is absent

Assertion 3.5.16:

KeySchedule only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0, or it is absent

###

SPDM_VDM_V1_4_Test_003_006.py

Description: SPDM responder shall return valid ALGORITHMS(0x12), if it receives a GET_ALGORITHMS with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=0x12, …}

5. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=0x12, Param1.NumOfAlgoStruct=4, Param2=0, MeasurementSpecification=DMTF, OtherParamsSupport=OpaqueDataFmt1, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521|TPM_ALG_SM2_ECC_SM2_P256|EdDSA_ed25519|EdDSA_ed448, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512|TPM_ALG_SM3_256, ExtAsymCount=0, ExtHashCount=0, ReqAlgStruct[0]{AlgType=DHE, AlgSupported=ffdhe2048|ffdhe3072|ffdhe4096|secp256r1|secp384r1|secp521r1|SM2_P256}, ReqAlgStruct[1]{AlgType=AEAD, AlgSupported=AES-128-GCM|AES-256-GCM|CHACHA20_POLY1305|AEAD_SM4_GCM}, ReqAlgStruct[2]{AlgType=ReqBaseAsymAlg, AlgSupported=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521|TPM_ALG_SM2_ECC_SM2_P256|EdDSA_ed25519|EdDSA_ed448}, ReqAlgStruct[3]{AlgType=KeySchedule, AlgSupported=SPDM} }

2. SpdmMessage <- Responder

Assertion 3.6.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.2)

Assertion 3.6.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.6.3:

SpdmMessage.SPDMVersion == 0x12

Assertion 3.6.4:

SpdmMessage.Length <= sizeof(SpdmMessage)

SpdmMessage.Length == offset(ALGORITHMS_1.1, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.6.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.6.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.6.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || MeasurementSpecificationSel == 0

Assertion 3.6.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) then (MeasurementHashAlgo == one of {Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256}) if (MEAS_CAP == 0) then (MeasurementHashAlgo == 0)

Assertion 3.6.9:

SpdmMessage.BaseAsymSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) then (BaseAsymSel == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0) then (BaseAsymSel == 0)

Assertion 3.6.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0) then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256}) if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0) then (BaseHashSel == 0)

Assertion 3.6.11:

SpdmMessage.Param1 <= 4 SpdmMessage.AlgStructure[i].AlgType is in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule} and no duplication.

Assertion 3.6.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.6.13:

SpdmMessage.AlgStructure[DHE_index] only has one bit at most.

if (KEY_EX_CAP == 1) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1, SM2_P256} if (KEY_EX_CAP == 0) then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent

Assertion 3.6.14:

SpdmMessage.AlgStructure[AEAD_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305, AEAD_SM4_GCM} if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0, or it is absent

Assertion 3.6.15:

SpdmMessage.AlgStructure[ReqBaseAsymAlg_index] only has one bit at most.

if (MUT_AUTH_CAP == 1) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448} if (MUT_AUTH_CAP == 0) then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0, or it is absent

Assertion 3.6.16:

SpdmMessage.AlgStructure[KeySchedule_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM if (KEY_EX_CAP == 0 && PSK_CAP == 0) then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0, or it is absent

Assertion 3.6.17:

SpdmMessage.OpaqueDataFmt only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0) then OtherParamsSupport.OpaqueDataFmt == OpaqueDataFmt1

###

SPDM_VDM_V1_4_Test_003_007.py

Description: SPDM responder shall return ERROR(UnexpectedRequest) or silent drop, if it receives two non-identical NEGOTIATE_ALGORITHMS.

SPDM Version: 1.0+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
4. CAPABILITIES <- Responder
5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, MeasurementSpecification=DMTF, BaseAsymAlgo=TPM_ALG_RSASSA_2048|TPM_ALG_RSAPSS_2048|TPM_ALG_RSASSA_3072|TPM_ALG_RSAPSS_3072|TPM_ALG_ECDSA_ECC_NIST_P256|TPM_ALG_RSASSA_4096|TPM_ALG_RSAPSS_4096|TPM_ALG_ECDSA_ECC_NIST_P384|TPM_ALG_ECDSA_ECC_NIST_P521, BaseHashAlgo=TPM_ALG_SHA_256|TPM_ALG_SHA_384|TPM_ALG_SHA_512|TPM_ALG_SHA3_256|TPM_ALG_SHA3_384|TPM_ALG_SHA3_512, ExtAsymCount=0, ExtHashCount=0}
6. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=1, ...} -- if NegotiatedVersion=1.0+
2. SpdmMessage <- Responder
Assertion 3.7.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)
Assertion 3.7.2:
    SpdmMessage.RequestResponseCode == ERROR
Assertion 3.7.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion
Assertion 3.7.4:
    SpdmMessage.Param1 == UnexpectedRequest.
Assertion 3.7.5:
    SpdmMessage.Param2 == 0.

3. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, MeasurementSpecification=DMTF, BaseAsymAlgo=BaseAsymSel, BaseHashAlgo=BaseHashSel, ...} -- if NegotiatedVersion=1.0+
4. SpdmMessage <- Responder
Assertion 3.7.*.

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, Dhe=DheSel, Aead=AeadSel, BaseReqAsymAlg=BaseReqAsymSel, ...} -- if NegotiatedVersion=1.1+
6. SpdmMessage <- Responder
Assertion 3.7.*.

SPDM_VDM_V1_4_Test_003_009.py

Description: SPDM responder shall return valid ALGORITHMS(0x14), if it receives a NEGOTIATE_ALGORITHMS with negotiated version 1.4.

SPDM Version: 1.4 only

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=0x14, …} 5. CAPABILITIES <- Responder

TestTeardown: None

Steps:

1. Requester -> NEGOTIATE_ALGORITHMS {
    SPDMVersion=0x14,
    Param1.NumOfAlgoStruct=6,
    Param2=0,
    MeasurementSpecification=DMTF,
    OtherParamsSupport=OpaqueDataFmt1,
    BaseAsymAlgo=TPM_ALG_RSASSA_2048 |
                TPM_ALG_RSAPSS_2048 |
                TPM_ALG_RSASSA_3072 |
                TPM_ALG_RSAPSS_3072 |
                TPM_ALG_ECDSA_ECC_NIST_P256 |
                TPM_ALG_RSASSA_4096 |
                TPM_ALG_RSAPSS_4096 |
                TPM_ALG_ECDSA_ECC_NIST_P384 |
                TPM_ALG_ECDSA_ECC_NIST_P521 |
                TPM_ALG_SM2_ECC_SM2_P256 |
                EdDSA_ed25519|EdDSA_ed448,
    BaseHashAlgo=TPM_ALG_SHA_256 |
                TPM_ALG_SHA_384 |
                TPM_ALG_SHA_512 |
                TPM_ALG_SHA3_256 |
                TPM_ALG_SHA3_384 |
                TPM_ALG_SHA3_512 |
                TPM_ALG_SM3_256,
    PqcAsymAlgo=ML-DSA-44|ML-DSA-65 |
                ML-DSA-87 |
                SLH-DSA-SHA2-128s |
                SLH-DSA-SHAKE-128s |
                SLH-DSA-SHA2-128f |
                SLH-DSA-SHAKE-128f |
                SLH-DSA-SHA2-192s |
                SLH-DSA-SHAKE-192s |
                SLH-DSA-SHA2-192f |
                SLH-DSA-SHAKE-192f |
                SLH-DSA-SHA2-256s |
                SLH-DSA-SHAKE-256s |
                SLH-DSA-SHA2-256f |
                SLH-DSA-SHAKE-256f,
    ExtAsymCount=0,
    ExtHashCount=0,
    MELspecification=DMTFmelSpec,
    ReqAlgStruct[0..5]={DHE, AEAD, ReqBaseAsymAlg, KeySchedule, ReqPqcAsymAlg, KEMAlg}}

2. SpdmMessage <- Responder

Assertion 3.9.1:

sizeof(SpdmMessage) >= sizeof(ALGORITHMS_1.4)

Assertion 3.9.2:

SpdmMessage.RequestResponseCode == ALGORITHMS

Assertion 3.9.3:

SpdmMessage.SPDMVersion == 0x14

Assertion 3.9.4:

SpdmMessage.Length <= sizeof(SpdmMessage) SpdmMessage.Length == offset(ALGORITHMS_1.4, ExtAsymSel) + 4 * SpdmMessage.ExtAsymSelCount + 4 * SpdmMessage.ExtHashSelCount + SpdmMessage.Param1 * sizeof(AlgStructSize)

Assertion 3.9.5:

SpdmMessage.ExtAsymSelCount == 0

Assertion 3.9.6:

SpdmMessage.ExtHashSelCount == 0

Assertion 3.9.7:

SpdmMessage.MeasurementSpecificationSel only has one bit at most. MeasurementSpecificationSel == DMTF || == 0.

if (MEAS_CAP != 0 || MEL_CAP == 1)

then MeasurementSpecificationSel != 0

Assertion 3.9.8:

SpdmMessage.MeasurementHashAlgo only has one bit at most.

if (MEAS_CAP != 0) (MeasurementHashAlgo == one of {

Raw Bit Stream Only, TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256})

if (MEAS_CAP == 0) then MeasurementHashAlgo == 0.

Assertion 3.9.9:

SpdmMessage.BaseAsymSel and SpdmMessage.PqcAsymSel only have one bit set at most.

if ((CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) && BaseAsymSel != 0)

then (BaseAsymSel == one of {

TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448})

if ((CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1) && PqcAsymSel != 0)

then (PqcAsymSel == one of {

ML-DSA-44, ML-DSA-65, ML-DSA-87, SLH-DSA-SHA2-128s, SLH-DSA-SHAKE-128s, SLH-DSA-SHA2-128f, SLH-DSA-SHAKE-128f, SLH-DSA-SHA2-192s, SLH-DSA-SHAKE-192s, SLH-DSA-SHA2-192f, SLH-DSA-SHAKE-192f, SLH-DSA-SHA2-256s, SLH-DSA-SHAKE-256s, SLH-DSA-SHA2-256f, SLH-DSA-SHAKE-256f})

if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0)

then (BaseAsymSel == 0 && PqcAsymSel == 0)

Assertion 3.9.10:

SpdmMessage.BaseHashSel only has one bit at most.

if (CHAL_CAP == 1 || MEAS_CAP == 2 || KEY_EX_CAP == 1 || PSK_EX_CAP != 0)

then (BaseHashSel == one of {TPM_ALG_SHA_256, TPM_ALG_SHA_384, TPM_ALG_SHA_512, TPM_ALG_SHA3_256, TPM_ALG_SHA3_384, TPM_ALG_SHA3_512, TPM_ALG_SM3_256})

if (CHAL_CAP == 0 && MEAS_CAP != 2 && KEY_EX_CAP == 0 && PSK_EX_CAP == 0)

then (BaseHashSel == 0)

Assertion 3.9.11:

SpdmMessage.Param1 <= 6 AlgStructure[i].AlgType in {DHE, AEAD, ReqBaseAsymAlg, KeySchedule, ReqPqcAsymAlg, KEMAlg} and no duplication. AlgStructure[i].AlgType monotonically increases.

Assertion 3.9.12:

SpdmMessage.AlgStructure[i].AlgCount == 0x20

Assertion 3.9.13:

SpdmMessage.AlgStructure[DHE_index] and SpdmMessage.AlgStructure[KEMAlg_index] only have one bit set at most.

if (KEY_EX_CAP == 1)

then SpdmMessage.AlgStructure[DHE_index].AlgSupported == one of {

ffdhe2048, ffdhe3072, ffdhe4096, secp256r1, secp384r1, secp521r1, SM2_P256} || KEMAlg.AlgSupported == one of {ML-KEM-512, ML-KEM-768, ML-KEM-1024}

if (KEY_EX_CAP == 0)

then SpdmMessage.AlgStructure[DHE_index].AlgSupported == 0, or it is absent && SpdmMessage.AlgStructure[KEMAlg_index].AlgSupported == 0, or it is absent

Assertion 3.9.14:

SpdmMessage.AlgStructure[AEAD_index] only has one bit set at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then SpdmMessage.AlgStructure[AEAD_index].AlgSupported == one of {AES-128-GCM, AES-256-GCM, CHACHA20_POLY1305, AEAD_SM4_GCM}

else SpdmMessage.AlgStructure[AEAD_index].AlgSupported == 0 or it is absent

Assertion 3.9.15:

SpdmMessage.AlgStructure[ReqBaseAsymAlg_index] and SpdmMessage.AlgStructure[ReqPqcAsymAlg_index] only have one bit set at most.

if (MUT_AUTH_CAP == 1)

then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == one of {

TPM_ALG_RSASSA_2048, TPM_ALG_RSAPSS_2048, TPM_ALG_RSASSA_3072, TPM_ALG_RSAPSS_3072, TPM_ALG_ECDSA_ECC_NIST_P256, TPM_ALG_RSASSA_4096, TPM_ALG_RSAPSS_4096, TPM_ALG_ECDSA_ECC_NIST_P384, TPM_ALG_ECDSA_ECC_NIST_P521, TPM_ALG_SM2_ECC_SM2_P256, EdDSA_ed25519, EdDSA_ed448}

|| SpdmMessage.AlgStructure[ReqPqcAsymAlg_index].AlgSupported == one of {

ML-DSA-44, ML-DSA-65, ML-DSA-87, SLH-DSA-SHA2-128s, SLH-DSA-SHAKE-128s, SLH-DSA-SHA2-128f, SLH-DSA-SHAKE-128f, SLH-DSA-SHA2-192s, SLH-DSA-SHAKE-192s, SLH-DSA-SHA2-192f, SLH-DSA-SHAKE-192f, SLH-DSA-SHA2-256s, SLH-DSA-SHAKE-256s, SLH-DSA-SHA2-256f, SLH-DSA-SHAKE-256f}.

if (MUT_AUTH_CAP == 0)

then SpdmMessage.AlgStructure[ReqBaseAsymAlg_index].AlgSupported == 0 or it is absent && SpdmMessage.AlgStructure[ReqPqcAsymAlg_index].AlgSupported == 0 or it is absent

Assertion 3.9.16:

SpdmMessage.AlgStructure[KeySchedule_index] only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == SPDM

else SpdmMessage.AlgStructure[KeySchedule_index].AlgSupported == 0 or it is absent

Assertion 3.9.17:

SpdmMessage.OpaqueDataFmt only has one bit at most.

if (KEY_EX_CAP == 1 || PSK_CAP != 0)

then OtherParamsSupport.OpaqueDataFmt == OpaqueDataFmt1

Assertion 3.9.18:

SpdmMessage.MELspecificationSel only has one bit at most.

if (MEL_CAP == 1)

then SpdmMessage.MELspecificationSel == DMTFmelSpec.

if (MEL_CAP == 0)

then SpdmMessage.MELspecificationSel == 0

SPDM_VDM_V1_4_Test_004_001.py

Description: SPDM responder shall return valid DIGESTS, if it receives a GET_DIGESTS.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 4.1.1:

sizeof(SpdmMessage) >= offset(DIGESTS, Digest[0])

Assertion 4.1.2:

SpdmMessage.RequestResponseCode == DIGESTS

Assertion 4.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.1.4:

SpdmMessage.Param2.SlotMask.bit_0 == 1

Assertion 4.1.5:

SlotCount = bit number of SpdmMessage.Param2.SlotMask sizeof(SpdmMessage) >= offset(DIGESTS, Digest[0]) + HashSize * SlotCount

###

SPDM_VDM_V1_4_Test_004_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_DIGESTS with non negotiated version.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=(NegotiatedVersion+1), …}

2. SpdmMessage <- Responder

Assertion 4.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 4.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 4.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 4.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_DIGESTS {SPDMVersion=(NegotiatedVersion-1), …}

4. SpdmMessage <- Responder

Assertion 4.2.*.

###

SPDM_VDM_V1_4_Test_005_001.py

Description: SPDM responder shall return valid CERTIFICATE, if it receives a GET_CERTIFICATE.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

10. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

11. Digests[] = array of DIGESTS.Digest

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=0, Offset=0, Length=0x400}

2. SpdmMessage <- Responder

Assertion 5.1.1:

sizeof(SpdmMessage) >= sizeof(CERTIFICATE, CertChain)

Assertion 5.1.2:

SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.1.4:

SpdmMessage.PortionLength > 0 SpdmMessage.PortionLength <= GET_CERTIFICATE.Length

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=0, Offset=NextOffset, Length=0x400}, while SpdmMessage.RemainderLength != 0

4. SpdmMessage <- Responder

Assertion 5.1.*.

Assertion 5.1.5:

CertChain.Length == sizeof(CertChain)

Assertion 5.1.6:

Hash(CertChain) == Digests[i]

###

SPDM_VDM_V1_4_Test_005_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_CERTIFICATE with non negotiated version.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=(NegotiatedVersion+1), …}

2. SpdmMessage <- Responder

Assertion 5.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 5.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CERTIFICATE {SPDMVersion=(NegotiatedVersion-1), …}

4. SpdmMessage <- Responder

Assertion 5.2.*.

###

SPDM_VDM_V1_4_Test_005_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a GET_CERTIFICATE with invalid field.

SPDM Version: 1.0+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. If Flags.CERT_CAP == 0, then skip this case.

6. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

7. ALGORITHMS <- Responder

8. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

9. DIGESTS <- Responder

10. InvalidSlotID[] = array of bit-index that SlotMask[bit-index]=0 from DIGEST.Param2.SlotMask + {0x8 ~ 0xE, 0xF}

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=InvalidSlotID[i], Param2=0, Offset=0, Length=0x400}

2. SpdmMessage <- Responder

Assertion 5.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 5.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=0, Param2=0, Invalid_Offset=0xFFFF, Length=0x400}

4. SpdmMessage <- Responder

Assertion 5.4.*.

###

SPDM_VDM_V1_4_Test_006_001.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B1, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

8. DIGESTS <- Responder

9. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

10. CERTIFICATE <- Responder

11. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

12. SpdmMessage <- Responder

Assertion 6.1.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.1.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.1.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.1.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.1.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.1.7:

13. Repeat (1~12) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.1.*.

14. Repeat (1~12) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.1.*.

###

SPDM_VDM_V1_4_Test_006_002.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B2, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

8. SpdmMessage <- Responder

Assertion 6.2.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.2.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.2.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.2.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.2.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.2.7:

9. Repeat (1~8) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.2.*.

10. Repeat (1~8) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.2.*.

###

SPDM_VDM_V1_4_Test_006_003.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.0 or 1.1 in (A1, B3, C1).

SPDM Version: 1.0 or 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 or 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

4. CAPABILITIES <- Responder

5. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

6. ALGORITHMS <- Responder

7. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

8. DIGESTS <- Responder

9. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

10. SpdmMessage <- Responder

Assertion 6.3.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.3.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.3.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.3.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.3.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.3.7:

11. Repeat (1~10) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.3.*.

12. Repeat (1~10) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.3.*.

###

SPDM_VDM_V1_4_Test_006_011.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B1, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

2. DIGESTS <- Responder

3. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

4. CERTIFICATE <- Responder

5. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

6. SpdmMessage <- Responder

Assertion 6.11.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.11.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.11.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.11.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.11.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.11.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.11.7:

7. Repeat (1~6) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.11.*.

8. Repeat (1~6) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.11.*.

###

SPDM_VDM_V1_4_Test_006_012.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B2, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

2. SpdmMessage <- Responder

Assertion 6.12.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.12.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.12.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.12.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.12.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.12.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.12.7:

3. Repeat (1~2) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.12.*.

4. Repeat (1~2) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.12.*.

###

SPDM_VDM_V1_4_Test_006_013.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B3, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

2. DIGESTS <- Responder

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

4. SpdmMessage <- Responder

Assertion 6.13.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.13.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.13.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.13.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.13.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.13.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.13.7:

5. Repeat (1~4) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.13.*.

6. Repeat (1~4) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.13.*.

###

SPDM_VDM_V1_4_Test_006_014.py

Description: SPDM responder shall return valid CHALLENGE_AUTH, if it receives a CHALLENGE with negotiated version 1.2 in (A2, B4, C1).

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Digests[] = array of DIGESTS.Digest

13. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

14. CERTIFICATE <- Responder

15. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, …}

16. SpdmMessage <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

2. CERTIFICATE <- Responder

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=NoMeasurement, Nonce}

4. SpdmMessage <- Responder

Assertion 6.14.1:

sizeof(SpdmMessage) >= sizeof(CHALLENGE_AUTH) + SpdmMessage.OpaqueDataLength

Assertion 6.14.2:

SpdmMessage.RequestResponseCode == CHALLENGE_AUTH

Assertion 6.14.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.14.4:

(SpdmMessage.Param1.SlotID & 0xF) == SlotID

Assertion 6.14.5:

(SpdmMessage.Param2.SlotMask & bit_[SlotID]) != 0

Assertion 6.14.6:

SpdmMessage.CertChainHash == Hash(CertChain) SpdmMessage.CertChainHash == Digests[SlotID]

Assertion 6.14.7:

5. Repeat (1~4) and use CHALLENGE {Param2=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 6.14.*.

6. Repeat (1~4) and use CHALLENGE {Param2=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 6.14.*.

SPDM_VDM_V1_4_Test_007_001.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.0.

SPDM Version: 1.0 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.0 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements}

2. SpdmMessage <- Responder

Assertion 7.1.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.1.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.1.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.1.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2 SPDMsignatureVerify (PubKey, SpdmMessage.Signature, L1/L2) version 1.0 success, if Flags.MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements}

4. SpdmMessage <- Responder

Assertion 7.1.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.1.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.1.14:

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.1.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.1.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.1.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.1.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.1.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.1.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1]}

8. SpdmMessage <- Responder

Assertion 7.1.{15~20}

Assertion 7.1.21:

###

SPDM_VDM_V1_4_Test_007_006.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]}

2. SpdmMessage <- Responder

Assertion 7.6.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.6.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.6.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.6.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]}

4. SpdmMessage <- Responder

Assertion 7.6.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.6.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.6.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.6.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.6.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.6.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.6.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.6.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.6.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]}

8. SpdmMessage <- Responder

Assertion 7.6.{15~20}

Assertion 7.6.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

###

SPDM_VDM_V1_4_Test_007_007.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS in a DHE session with negotiated version 1.1.

SPDM Version: 1.1 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

16. Requester -> FINISH {SPDMVersion=NegotiatedVersion, …} in session-X

17. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.7.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.7.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.7.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.7.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 7.7.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.7.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.7.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]} in session-X, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder in session-X

Assertion 7.7.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.7.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.7.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.7.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.7.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.7.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 7.7.{15~20}

Assertion 7.7.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i], if MEAS_CAP == 2

###

SPDM_VDM_V1_4_Test_007_008.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_MEASUREMENTS in a DHE session handshake.

SPDM Version: 1.1+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 or above is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.8.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.8.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.8.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.8.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 7.8.5:

SpdmMessage.Param2 == 0.

###

SPDM_VDM_V1_4_Test_007_009.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}, if Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 1

13. CERTIFICATE <- Responder

14. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], Param2=AllMeasurement, …}, if Flags.MEAS_CAP == 2 && Flags.CHAL_CAP == 1

15. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]}

2. SpdmMessage <- Responder

Assertion 7.9.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.9.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.9.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.9.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]}

4. SpdmMessage <- Responder

Assertion 7.9.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.9.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.9.14:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]}, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder

Assertion 7.9.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.9.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.9.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.9.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.9.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.9.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]}

8. SpdmMessage <- Responder

Assertion 7.9.{15~20}

Assertion 7.9.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

###

SPDM_VDM_V1_4_Test_007_010.py

Description: SPDM responder shall return valid MEASUREMENTS, if it receives a GET_MEASUREMENTS in a DHE session with negotiated version 1.2.

SPDM Version: 1.2 only

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.MEAS_CAP == 0 || Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=AllMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

16. Requester -> FINISH {SPDMVersion=NegotiatedVersion, …} in session-X

17. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=NumberOfMeasurements, SlotID=ValidSlotID[i]} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 7.10.1:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.2:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.4:

SpdmMessage.Param1.NumberOfMeasurements > 0

Assertion 7.10.5:

SpdmMessage.NumberOfBlocks == 0

Assertion 7.10.6:

SpdmMessage.MeasurementRecordLength == 0

Assertion 7.10.7:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=AllMeasurements, SlotID=ValidSlotID[i]} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 7.10.8:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.9:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.10:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.11:

SpdmMessage.NumberOfBlocks == NumberOfMeasurements && number of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.NumberOfBlocks (ValidMeasurementIndex[] = array of index of valid MeasurementBlock) (MeasurementBlock[] = array of valid MeasurementBlock)

Assertion 7.10.12:

SpdmMessage.MeasurementRecordLength > 0 && Sum(size of each MeasurementBlock in SpdmMessage.MeasurementRecord) == SpdmMessage.MeasurementRecordLength

Assertion 7.10.14:

5. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=ValidMeasurementIndex[i], SlotID=ValidSlotID[i]} in session-X, if i < NumberOfMeasurements - 1

6. SpdmMessage <- Responder in session-X

Assertion 7.10.15:

sizeof(SpdmMessage) >= sizeof(MEASUREMENTS) + SpdmMessage.OpaqueDataLength + SpdmMessage.MeasurementRecordLength

Assertion 7.10.16:

SpdmMessage.RequestResponseCode == MEASUREMENTS

Assertion 7.10.17:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.10.18:

SpdmMessage.NumberOfBlocks == 1

Assertion 7.10.19:

SpdmMessage.MeasurementRecordLength > 0 && size of MeasurementBlock in SpdmMessage.MeasurementRecord == SpdmMessage.MeasurementRecordLength

Assertion 7.10.20:

SpdmMessage.MeasurementRecord == MeasurementBlock[i]

7. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1.Sig=(MEAS_CAP == 2), Param2=ValidMeasurementIndex[NumberOfMeasurements - 1], SlotID=ValidSlotID[i]} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 7.10.{15~20}

Assertion 7.10.21:

SpdmMessage.Param2.SlotID == ValidSlotID[i] && (SpdmMessage.Param2.ContentChanged == NotSupported || SpdmMessage.Param2.ContentChanged == NoChange), if MEAS_CAP == 2

SPDM_VDM_V1_4_Test_008_001.py

Description: SPDM responder shall return valid KEY_EXCHANGE_RSP, if it receives a KEY_EXCHANGE with negotiated version 1.1.

SPDM Version: 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], ReqSessionID, RandomData, ExchangeData, OpaqueData}

2. SpdmMessage <- Responder

Assertion 8.1.1:

sizeof(SpdmMessage) >= sizeof(KEY_EXCHANGE_RSP) + SpdmMessage.OpaqueDataLength

Assertion 8.1.2:

SpdmMessage.RequestResponseCode == KEY_EXCHANGE_RSP

Assertion 8.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 8.1.4:

SpdmMessage.MutAuthRequested == 0 && SpdmMessage.SlotIDParam == 0

Assertion 8.1.5:

Assertion 8.1.6:

HMACVerify (finished_key, SpdmMessage.ResponderVerifyData, TH.HMAC.KEY_EXCHANGE_RSP) version 1.1 success

3. Repeat (1~2) and use KEY_EXCHANGE {Param1=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 8.1.*.

4. Repeat (1~2) and use KEY_EXCHANGE {Param1=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 8.1.*.

###

SPDM_VDM_V1_4_Test_008_007.py

Description: SPDM responder shall return valid KEY_EXCHANGE_RSP, if it receives a KEY_EXCHANGE with negotiated version 1.2.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], ReqSessionID, SessionPolicy.TerminationPolicy=1, RandomData, ExchangeData, OpaqueData}

2. SpdmMessage <- Responder

Assertion 8.7.1:

sizeof(SpdmMessage) >= sizeof(KEY_EXCHANGE_RSP) + SpdmMessage.OpaqueDataLength

Assertion 8.7.2:

SpdmMessage.RequestResponseCode == KEY_EXCHANGE_RSP

Assertion 8.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 8.7.4:

SpdmMessage.MutAuthRequested == 0 && SpdmMessage.SlotIDParam == 0

Assertion 8.7.5:

Assertion 8.7.6:

HMACVerify (finished_key, SpdmMessage.ResponderVerifyData, TH.HMAC.KEY_EXCHANGE_RSP) version 1.2 success

3. Repeat (1~2) and use KEY_EXCHANGE {Param1=TcbMeasurements}, if Flags.MEAS_CAP != 0.

Assertion 8.7.*.

4. Repeat (1~2) and use KEY_EXCHANGE {Param1=AllMeasurement}, if Flags.MEAS_CAP != 0.

Assertion 8.7.*.

###

SPDM_VDM_V1_4_Test_009_001.py

Description: SPDM responder shall return valid FINISH_RSP, if it receives a FINISH with negotiated version 1.1.

SPDM Version: 1.1

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.1 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 9.1.1:

sizeof(SpdmMessage) >= sizeof(FINISH_RSP) - HMAC size

Assertion 9.1.2:

SpdmMessage.RequestResponseCode == FINISH_RSP

Assertion 9.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_VDM_V1_4_Test_009_009.py

Description: SPDM responder shall return valid FINISH_RSP, if it receives a FINISH with negotiated version 1.2.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 9.9.1:

sizeof(SpdmMessage) >= sizeof(FINISH_RSP)

Assertion 9.9.2:

SpdmMessage.RequestResponseCode == FINISH_RSP

Assertion 9.9.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_VDM_V1_4_Test_009_011.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a FINISH in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Flags.MUT_AUTH_CAP=0, Flags.HANDSHAKE_IN_THE_CLEAR_CAP=0, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 || Flags.CERT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, …}

10. DIGESTS <- Responder

11. ValidSlotID[] = array of bit-index that SlotMask[bit-index]=1 from DIGEST.Param2.SlotMask

12. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion, Param1.SlotID=ValidSlotID[i], …}

13. CERTIFICATE <- Responder

14. Requester -> KEY_EXCHANGE {SPDMVersion=NegotiatedVersion, Param1=NoMeasurement, Param2.SlotID=ValidSlotID[i], …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

1. Requester -> FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0, RequesterVerifyData} (not in session-X)

2. SpdmMessage <- Responder (not in session-X)

Assertion 9.11.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 9.11.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 9.11.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 9.11.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_VDM_V1_4_Test_010_001.py

Description: SPDM responder shall return valid PSK_EXCHANGE_RSP, if it receives a PSK_EXCHANGE.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.PSK_CAP != 1, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> PSK_EXCHANGE {SPDMVersion=NegotiatedVersion,
   MeasurementSummaryHashType=0, SessionPolicy=0}
2. SpdmMessage <- Responder

Assertion 10.1.1:
    sizeof(SpdmMessage) >= offset(PSK_EXCHANGE_RSP, Q)

Assertion 10.1.2:
    SpdmMessage.RequestResponseCode == PSK_EXCHANGE_RSP

Assertion 10.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 10.1.4:
    sizeof(SpdmMessage) >= offset(PSK_EXCHANGE_RSP, ResponderContext) +
    SpdmMessage.Q

SPDM_VDM_V1_4_Test_010_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a PSK_EXCHANGE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_EXCHANGE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 10.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 10.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 10.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 10.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 10.2.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_011_001.py

Description: SPDM responder shall return valid PSK_FINISH_RSP, if it receives a PSK_FINISH.

SPDM Version: 1.2+

Note: PSK_FINISH completes a PSK session handshake and carries an HMAC (RequesterVerifyData) over the session transcript. It is normally issued only after a PSK_EXCHANGE within the same session; issued standalone the responder may return ERROR. This case validates the PSK_FINISH_RSP format when one is returned.

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP != 1, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_FINISH {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0} 2. SpdmMessage <- Responder

Assertion 11.1.1:

sizeof(SpdmMessage) >= sizeof(PSK_FINISH_RSP)

Assertion 11.1.2:

SpdmMessage.RequestResponseCode == PSK_FINISH_RSP

Assertion 11.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 11.1.4:

SpdmMessage.Param1 == 0

Assertion 11.1.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_011_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a PSK_FINISH with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.PSK_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> PSK_FINISH {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 11.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 11.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 11.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 11.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 11.2.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_012_004.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a HEARTBEAT in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.HBEAT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> HEARTBEAT {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 12.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.4.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_VDM_V1_4_Test_013_005.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a KEY_UPDATE in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.HBEAT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateKey, Param2=Tag}

2. SpdmMessage <- Responder

Assertion 13.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.5.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_VDM_V1_4_Test_014_001.py

Description: SPDM responder shall return valid ENCAPSULATED_REQUEST, if it receives a GET_ENCAPSULATED_REQUEST.

SPDM Version: 1.2+

Note: GET_ENCAPSULATED_REQUEST retrieves a request the responder is waiting to send, which only happens inside the encapsulated request flow. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of ENCAPSULATED_REQUEST. This case validates the ENCAPSULATED_REQUEST format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.ENCAP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENCAPSULATED_REQUEST {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 14.1.1:
    sizeof(SpdmMessage) >= offset(ENCAPSULATED_REQUEST, EncapsulatedRequest)

Assertion 14.1.2:
    SpdmMessage.RequestResponseCode == ENCAPSULATED_REQUEST

Assertion 14.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

SPDM_VDM_V1_4_Test_014_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_ENCAPSULATED_REQUEST with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.ENCAP_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> GET_ENCAPSULATED_REQUEST {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 14.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 14.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 14.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 14.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 14.2.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_015_001.py

Description: SPDM responder shall return valid ENCAPSULATED_RESPONSE_ACK, if it receives a DELIVER_ENCAPSULATED_RESPONSE.

SPDM Version: 1.2+

Note: DELIVER_ENCAPSULATED_RESPONSE is part of the encapsulated request flow and is normally issued in response to a prior ENCAPSULATED_REQUEST. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of ENCAPSULATED_RESPONSE_ACK. This case validates the ENCAPSULATED_RESPONSE_ACK format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.ENCAP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> DELIVER_ENCAPSULATED_RESPONSE {SPDMVersion=NegotiatedVersion,
   RequestID=0}
2. SpdmMessage <- Responder

Assertion 15.1.1:
    sizeof(SpdmMessage) >= offset(ENCAPSULATED_RESPONSE_ACK,
    EncapsulatedRequest)

Assertion 15.1.2:
    SpdmMessage.RequestResponseCode == ENCAPSULATED_RESPONSE_ACK

Assertion 15.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

SPDM_VDM_V1_4_Test_015_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a DELIVER_ENCAPSULATED_RESPONSE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.ENCAP_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> DELIVER_ENCAPSULATED_RESPONSE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 15.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 15.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 15.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 15.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 15.2.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_016_004.py

Description: SPDM responder shall return ERROR(SessionRequired), if it receives a END_SESSION in non-session.

SPDM Version: 1.2

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.2 is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.KEY_EX_CAP == 0 && Flags.PSK_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

TestTeardown:

None

Steps:

1. Requester -> END_SESSION {SPDMVersion=NegotiatedVersion, Param1.StatePreservation=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 16.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.4.4:

SpdmMessage.Param1 == SessionRequired.

SPDM_VDM_V1_4_Test_017_001.py

Description: SPDM responder shall return valid CSR, if it receives a GET_CSR.

SPDM Version: 1.2+

Note: a CSR is often larger than the DataTransferSize the requester advertised. The responder then answers with ERROR(LargeResponse) and the CSR is collected with CHUNK_GET before the assertions run. A CSR larger than the advertised MaxSPDMmsgSize cannot be received at all; ERROR(ResponseTooLarge) is conformant there and the case is Skipped.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CSR_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_CSR {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0,
   RequesterInfoLength=0, OpaqueDataLength=0}
2. SpdmMessage <- Responder

Assertion 17.1.1:
    sizeof(SpdmMessage) >= offset(CSR, CSRData)

Assertion 17.1.2:
    SpdmMessage.RequestResponseCode == CSR

Assertion 17.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 17.1.4:
    SpdmMessage.CSRLength > 0

Assertion 17.1.5:
    sizeof(SpdmMessage) >= offset(CSR, CSRData) + SpdmMessage.CSRLength

SPDM_VDM_V1_4_Test_017_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_CSR with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.CSR_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> GET_CSR {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 17.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 17.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 17.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 17.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 17.2.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_018_001.py

Description: SPDM responder shall return valid CHUNK_SEND_ACK, if it receives a CHUNK_SEND.

SPDM Version: 1.2+

Note: CHUNK_SEND belongs to the Large SPDM message transfer mechanism and is only meaningful as part of a genuine large request. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of CHUNK_SEND_ACK. This case validates the CHUNK_SEND_ACK format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_SEND {SPDMVersion=NegotiatedVersion,
   Param1=LastChunk, Handle=0, ChunkSeqNo=0, ChunkSize=0}
2. SpdmMessage <- Responder

Assertion 18.1.1:
    sizeof(SpdmMessage) >= offset(CHUNK_SEND_ACK, ResponseToLargeRequest)

Assertion 18.1.2:
    SpdmMessage.RequestResponseCode == CHUNK_SEND_ACK

Assertion 18.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 18.1.4:
    SpdmMessage.Param2 == requested Handle

SPDM_VDM_V1_4_Test_018_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHUNK_SEND with non negotiated version.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_SEND {SPDMVersion=(NegotiatedVersion+1),
   Param1=LastChunk, Handle=0, ChunkSeqNo=0, ChunkSize=0}
2. SpdmMessage <- Responder

Assertion 18.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 18.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 18.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 18.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 18.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_019_001.py

Description: SPDM responder shall return valid CHUNK_RESPONSE, if it receives a CHUNK_GET during an in-progress large response transfer.

SPDM Version: 1.2+

Note: CHUNK_GET is only meaningful while the responder has a large response pending, identified by Handle. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of CHUNK_RESPONSE. This case validates the CHUNK_RESPONSE format when one is returned and is Skipped when the responder answers ERROR.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_GET {SPDMVersion=NegotiatedVersion, Param1=0, Handle=0,
   ChunkSeqNo=0}
2. SpdmMessage <- Responder

Assertion 19.1.1:
    sizeof(SpdmMessage) >= offset(CHUNK_RESPONSE, LargeMessageSize)

Assertion 19.1.2:
    SpdmMessage.RequestResponseCode == CHUNK_RESPONSE

Assertion 19.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 19.1.4:
    sizeof(SpdmMessage) >= offset(CHUNK_RESPONSE, LargeMessageSize) +
    SpdmMessage.ChunkSize

SPDM_VDM_V1_4_Test_019_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHUNK_GET with non negotiated version.

SPDM Version: 1.2+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> CHUNK_GET {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Handle=0, ChunkSeqNo=0}
2. SpdmMessage <- Responder

Assertion 19.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 19.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 19.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 19.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 19.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_020_001.py

Description: SPDM responder shall return valid KEY_PAIR_INFO, if it receives a GET_KEY_PAIR_INFO.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.GET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_KEY_PAIR_INFO {SPDMVersion=NegotiatedVersion, Param1=0,
   Param2=0, KeyPairID=1}
2. SpdmMessage <- Responder

Assertion 20.1.1:
    sizeof(SpdmMessage) >= offset(KEY_PAIR_INFO, PublicKeyInfo)

Assertion 20.1.2:
    SpdmMessage.RequestResponseCode == KEY_PAIR_INFO

Assertion 20.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 20.1.4:
    SpdmMessage.KeyPairID == requested KeyPairID

Assertion 20.1.5:
    SpdmMessage.TotalKeyPairs > 0

Assertion 20.1.6:
    sizeof(SpdmMessage) >= offset(KEY_PAIR_INFO, PublicKeyInfo) +
    SpdmMessage.PublicKeyInfoLen

SPDM_VDM_V1_4_Test_020_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_KEY_PAIR_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.GET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_KEY_PAIR_INFO {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Param2=0, KeyPairID=1}
2. SpdmMessage <- Responder

Assertion 20.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 20.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 20.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 20.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 20.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_021_001.py

Description: SPDM responder shall return valid SET_KEY_PAIR_INFO_ACK, if it receives a SET_KEY_PAIR_INFO.

SPDM Version: 1.3+

Note: SET_KEY_PAIR_INFO changes responder key pair configuration and is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SET_KEY_PAIR_INFO_ACK. This case validates the SET_KEY_PAIR_INFO_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of SET_KEY_PAIR_INFO_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_KEY_PAIR_INFO {SPDMVersion=NegotiatedVersion,
   Param1=0 (ParameterChange), KeyPairID=1, DesiredKeyUsage=0,
   DesiredAsymAlgo=0, DesiredAssocCertSlotMask=0}

   A ParameterChange with no bits set does not change the current key pair
   configuration (Table 106), so this exercises the acknowledgement without
   modifying responder state.
2. SpdmMessage <- Responder

Assertion 21.1.1:
    sizeof(SpdmMessage) >= sizeof(SET_KEY_PAIR_INFO_ACK)

Assertion 21.1.2:
    SpdmMessage.RequestResponseCode == SET_KEY_PAIR_INFO_ACK

Assertion 21.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 21.1.4:
    SpdmMessage.Param1 == 0

Assertion 21.1.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_021_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SET_KEY_PAIR_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_KEY_PAIR_INFO_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_KEY_PAIR_INFO {SPDMVersion=(NegotiatedVersion+1),
   Param1=0 (ParameterChange), KeyPairID=1, DesiredKeyUsage=0,
   DesiredAsymAlgo=0, DesiredAssocCertSlotMask=0}
2. SpdmMessage <- Responder

Assertion 21.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 21.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 21.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 21.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 21.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_022_001.py

Description: SPDM Event Notifier shall return valid SUPPORTED_EVENT_TYPES, if it receives a GET_SUPPORTED_EVENT_TYPES.

SPDM Version: 1.3+

Note: GET_SUPPORTED_EVENT_TYPES is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SUPPORTED_EVENT_TYPES. This case validates the SUPPORTED_EVENT_TYPES format when one is returned and is Skipped when the responder answers ERROR. Full validation of SUPPORTED_EVENT_TYPES requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_SUPPORTED_EVENT_TYPES {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 22.1.1:
    sizeof(SpdmMessage) >= offset(SUPPORTED_EVENT_TYPES,
    SupportedEventGroupsList)

Assertion 22.1.2:
    SpdmMessage.RequestResponseCode == SUPPORTED_EVENT_TYPES

Assertion 22.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 22.1.4:
    SpdmMessage.Param2 == 0

Assertion 22.1.5:
    SpdmMessage.SupportedEventGroupsListLen > 0

Assertion 22.1.6:
    sizeof(SpdmMessage) >= offset(SUPPORTED_EVENT_TYPES,
    SupportedEventGroupsList) + SpdmMessage.SupportedEventGroupsListLen

SPDM_VDM_V1_4_Test_022_002.py

Description: SPDM Event Notifier shall return ERROR(VersionMismatch), if it receives a GET_SUPPORTED_EVENT_TYPES with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_SUPPORTED_EVENT_TYPES {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 22.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 22.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 22.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 22.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 22.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_023_001.py

Description: SPDM Event Notifier shall return valid SUBSCRIBE_EVENT_TYPES_ACK, if it receives a SUBSCRIBE_EVENT_TYPES.

SPDM Version: 1.3+

Note: SUBSCRIBE_EVENT_TYPES is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SUBSCRIBE_EVENT_TYPES_ACK. This case validates the SUBSCRIBE_EVENT_TYPES_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of SUBSCRIBE_EVENT_TYPES_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SUBSCRIBE_EVENT_TYPES {SPDMVersion=NegotiatedVersion,
   Param1=0 (SubscribeEventGroupCount, unsubscribe all), Param2=0}
2. SpdmMessage <- Responder

Assertion 23.1.1:
    sizeof(SpdmMessage) >= sizeof(SUBSCRIBE_EVENT_TYPES_ACK)

Assertion 23.1.2:
    SpdmMessage.RequestResponseCode == SUBSCRIBE_EVENT_TYPES_ACK

Assertion 23.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 23.1.4:
    SpdmMessage.Param1 == 0

Assertion 23.1.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_023_002.py

Description: SPDM Event Notifier shall return ERROR(VersionMismatch), if it receives a SUBSCRIBE_EVENT_TYPES with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SUBSCRIBE_EVENT_TYPES {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0}
2. SpdmMessage <- Responder

Assertion 23.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 23.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 23.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 23.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 23.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_024_001.py

Description: SPDM Event Recipient shall return valid EVENT_ACK, if it receives a SEND_EVENT.

SPDM Version: 1.3+

Note: SEND_EVENT is part of the event mechanism, which is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of EVENT_ACK. This case validates the EVENT_ACK format when one is returned and is Skipped when the responder answers ERROR. Full validation of EVENT_ACK requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SEND_EVENT {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0,
   EventCount=1, EventsList=<one DMTF EventLost event>}
2. SpdmMessage <- Responder

Assertion 24.1.1:
    sizeof(SpdmMessage) >= sizeof(EVENT_ACK)

Assertion 24.1.2:
    SpdmMessage.RequestResponseCode == EVENT_ACK

Assertion 24.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 24.1.4:
    SpdmMessage.Param1 == 0

Assertion 24.1.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_024_002.py

Description: SPDM Event Recipient shall return ERROR(VersionMismatch), if it receives a SEND_EVENT with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EVENT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SEND_EVENT {SPDMVersion=(NegotiatedVersion+1), Param1=0,
   Param2=0, EventCount=1, EventsList=<one DMTF EventLost event>}
2. SpdmMessage <- Responder

Assertion 24.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 24.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 24.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 24.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 24.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_025_001.py

Description: SPDM responder shall return valid ENDPOINT_INFO, if it receives a GET_ENDPOINT_INFO.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EP_INFO_CAP != 1 (no-signature capable), then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENDPOINT_INFO {SPDMVersion=NegotiatedVersion,
   Param1=DeviceClassIdentifier, Param2=0, RequestAttributes=0}
2. SpdmMessage <- Responder

Assertion 25.1.1:
    sizeof(SpdmMessage) >= offset(ENDPOINT_INFO, EPInfoLength)

Assertion 25.1.2:
    SpdmMessage.RequestResponseCode == ENDPOINT_INFO

Assertion 25.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 25.1.4:
    SpdmMessage.Param1 == 0

Assertion 25.1.5:
    SpdmMessage.Param2.SlotID == 0

Assertion 25.1.6:
    sizeof(SpdmMessage) >= offset(ENDPOINT_INFO, EPInfo) +
    SpdmMessage.EPInfoLength

SPDM_VDM_V1_4_Test_025_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_ENDPOINT_INFO with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.EP_INFO_CAP != 1 (no-signature capable), then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_ENDPOINT_INFO {SPDMVersion=(NegotiatedVersion+1),
   Param1=DeviceClassIdentifier, Param2=0, RequestAttributes=0}
2. SpdmMessage <- Responder

Assertion 25.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 25.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 25.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 25.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 25.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_026_001.py

Description: SPDM responder shall return valid MEASUREMENT_EXTENSION_LOG, if it receives a GET_MEASUREMENT_EXTENSION_LOG.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.MEL_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_MEASUREMENT_EXTENSION_LOG {SPDMVersion=NegotiatedVersion,
   Param1=0, Param2=0, Offset=0, Length=0xFFFFFFFF}
2. SpdmMessage <- Responder

Assertion 26.1.1:
    sizeof(SpdmMessage) >= offset(MEASUREMENT_EXTENSION_LOG, MEL)

Assertion 26.1.2:
    SpdmMessage.RequestResponseCode == MEASUREMENT_EXTENSION_LOG

Assertion 26.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 26.1.4:
    SpdmMessage.Param1 == 0

Assertion 26.1.5:
    SpdmMessage.Param2 == 0

Assertion 26.1.6:
    sizeof(SpdmMessage) >= offset(MEASUREMENT_EXTENSION_LOG, MEL) +
    SpdmMessage.PortionLength

Assertion 26.1.7:
    if SpdmMessage.RemainderLength == 0 then
    SpdmMessage.PortionLength == offset(MEL, MELEntries) +
    SpdmMessage.MEL.MELEntriesLength

Assertion 26.1.8:
    if SpdmMessage.RemainderLength == 0 && SpdmMessage.MEL.NumberOfEntries > 0
    then SpdmMessage.MEL.MELEntriesLength >=
    SpdmMessage.MEL.NumberOfEntries * sizeof(minimum MEL entry)

SPDM_VDM_V1_4_Test_026_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_MEASUREMENT_EXTENSION_LOG with non negotiated version.

SPDM Version: 1.3+

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.3 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.MEL_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> GET_MEASUREMENT_EXTENSION_LOG {SPDMVersion=(NegotiatedVersion+1),
   Param1=0, Param2=0, Offset=0, Length=0xFFFFFFFF}
2. SpdmMessage <- Responder

Assertion 26.2.1:
    sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 26.2.2:
    SpdmMessage.RequestResponseCode == ERROR

Assertion 26.2.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 26.2.4:
    SpdmMessage.Param1 == VersionMismatch

Assertion 26.2.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_027_001.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with SupportedSubCodes structure, if it receives a SLOT_MANAGEMENT with SubCode=SupportedSubCodes.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, …} 2. SpdmMessage <- Responder

Assertion 27.1.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.1.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.1.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (SupportedSubCodes)

Assertion 27.1.5:

SpdmMessage.Param2 == 0

Assertion 27.1.6:

SupportedSubCodes.Reserved == 0

Assertion 27.1.7:

SupportedSubCodes.RespLength == 36

Assertion 27.1.8:

SupportedSubCodes.SubCodeBitmap.Bit[SupportedSubCodes] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetBankInfo] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetBankDetails] == 1 && SupportedSubCodes.SubCodeBitmap.Bit[GetCertificateChain] == 1

SPDM_VDM_V1_4_Test_027_002.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with BankInfo structure, if it receives a SLOT_MANAGEMENT with SubCode=GetBankInfo.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, …} 2. SpdmMessage <- Responder

Assertion 27.2.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.2.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.2.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (GetBankInfo)

Assertion 27.2.5:

BankInfo.RespLength == offset(BankInfo, BankElements) + (BankInfo.NumBankElements * sizeof(BankElement))

Assertion 27.2.6:

BankInfo.NumBankElements > 0 && BankInfo.NumBankElements <= 240

Assertion 27.2.7:

For every BankElement in BankInfo.BankElements[]:

BankElement.ElementLength == 4 && BankElement.BankID <= 239

Assertion 27.2.8:

For every pair (i, j), i != j, in BankInfo.BankElements[]:

BankElements[i].BankID != BankElements[j].BankID

Assertion 27.2.9:

BankInfo.Reserved == 0

SPDM_VDM_V1_4_Test_027_003.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with BankDetails structure, if it receives a SLOT_MANAGEMENT with SubCode=GetBankDetails for each valid BankID.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SLOT_MANAGEMENT_RESP <- Responder

3. ValidBankID[] = array of BankElement.BankID from BankInfo.BankElements[]

For each BankID in ValidBankID[] and 0xFF:

4. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankDetails, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=0}}

5. SpdmMessage <- Responder

Assertion 27.3.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct)

Assertion 27.3.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.3.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT_RESP.Param1 (GetBankDetails)

Assertion 27.3.5:

If SLOT_MANAGEMENT.SlotAddress.BankID != 0xFF, then

BankDetails.BankID == SLOT_MANAGEMENT.SlotAddress.BankID

else

BankDetails.BankID is one of ValidBankID[]

Assertion 27.3.6:

BankDetails.RespLength == sizeof(BankDetails)

Assertion 27.3.7:

BankDetails.NumSlotElements <= 8

Assertion 27.3.8:

For SlotElement[i]:

BankDetails.SlotElement[i].ElementLength == 16 + H && SlotElement[i].SlotID <= 7 && BankElements[BankDetails.BankID].SlotMask.Bit[SlotElement[i].SlotID] == 1 && (if MULTI_KEY_CONN_RSP == false => KeyPairID == 0) && (if Provisioned == 0 => Digest == 0)

Assertion 27.3.9:

popcount(BankDetails.CurrentAsymAlgo) + popcount(BankDetails.CurrentPqcAsymAlgo) <= 1

Assertion 27.3.10:

(BankDetails.AsymAlgoCapabilities | BankDetails.PqcAsymAlgoCapabilities) != 0

Assertion 27.3.11:

(BankDetails.AvailableAsymAlgo & ~BankDetails.AsymAlgoCapabilities) == 0 && (BankDetails.AvailablePqcAsymAlgo & ~BankDetails.PqcAsymAlgoCapabilities) == 0

Assertion 27.3.12:

(BankDetails.CurrentAsymAlgo & ~BankDetails.AsymAlgoCapabilities) == 0 && (BankDetails.CurrentPqcAsymAlgo & ~BankDetails.PqcAsymAlgoCapabilities) == 0

Assertion 27.3.13:

If BankDetails.BankAttributes.ConfigAlgo == 0, then

BankDetails.AsymAlgoCapabilities == 0 && BankDetails.PqcAsymAlgoCapabilities == 0 && BankDetails.AvailableAsymAlgo == 0 && BankDetails.AvailablePqcAsymAlgo == 0

Assertion 27.3.14:

BankDetails.BankAttributes.Reserved == 0 && BankDetails.Reserved == 0 && every SlotElement.Reserved == 0

Assertion 27.3.15:

BankDetails.BankAttributes.Reserved == 0 && BankDetails.Reserved == 0

Assertion 27.3.16:

BankDetails.NumSlotElements == popcount(BankElements[BankDetails.BankID].SlotMask)

Assertion 27.3.17:

For every pair (m, n), m != n, in BankDetails.SlotElements[]:

SlotElements[m].SlotID != SlotElements[n].SlotID

Assertion 27.3.18:

If BankAttributes.ConfigAlgo == 1 && CurrentAsymAlgo == 0 && CurrentPqcAsymAlgo == 0, then no SlotElement has SlotAttributes.Bit[0] (Provisioned) == 1

SPDM_VDM_V1_4_Test_027_004.py

Description: SPDM responder shall return valid SLOT_MANAGEMENT_RESP with GetCertificateChain structure, if it receives a SLOT_MANAGEMENT with SubCode=GetCertificateChain for any provisioned slot in any Bank reported by GetBankInfo.

SPDM Version: 1.4+

Note: a certificate chain is often larger than the DataTransferSize the requester advertised, and post-quantum chains always are. The responder then answers with ERROR(LargeResponse) and the chain is collected with CHUNK_GET before the assertions run. A chain larger than the advertised MaxSPDMmsgSize cannot be received at all; ERROR(ResponseTooLarge) is conformant there and the case is Skipped.

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0 || Flags.CERT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankInfo, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SLOT_MANAGEMENT_RESP <- Responder

3. SelectedBankIDs[] = array of BankID where BankAttributes.Bit[0] (Selected) == 1.

For each BankID in SelectedBankIDs[]:

4. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetBankDetails, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=0}}

5. BankDetails <- Responder

6. ProvisionedPairs[] = array of (BankID, SlotID) for every SlotElement in BankDetails.SlotElements[] where SlotAttributes.Bit[0] (Provisioned) == 1.

For each (BankID, SlotID) in ProvisionedPairs[]:

5. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=GetCertificateChain, Param2=0, MgmtStructOffset=8, SlotMgmtReqStruct=SlotAddress{ReqLength=8, BankID=BankID, SlotID=SlotID}}

6. SpdmMessage <- Responder

Assertion 27.4.1:

sizeof(SpdmMessage) >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct) + offset(GetCertificateChain, CertChain)

Assertion 27.4.2:

SpdmMessage.RequestResponseCode == SLOT_MANAGEMENT_RESP

Assertion 27.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.4.4:

SpdmMessage.Param1 == SLOT_MANAGEMENT.Param1 (GetCertificateChain)

Assertion 27.4.5:

SpdmMessage.MgmtStructOffset >= offset(SLOT_MANAGEMENT_RESP, SlotMgmtRespStruct) && SpdmMessage.MgmtStructOffset + offset(GetCertificateChain, CertChain) <= sizeof(SpdmMessage)

Assertion 27.4.6:

GetCertificateChain.CCLength + SpdmMessage.MgmtStructOffset + offset(GetCertificateChain, CertChain) <= sizeof(SpdmMessage)

Assertion 27.4.7:

GetCertificateChain.Reserved == 0

SPDM_VDM_V1_4_Test_027_005.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SLOT_MANAGEMENT with non negotiated version.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SLOT_MANAGEMENT {SPDMVersion=(NegotiatedVersion+1), Param1.SubCode=SupportedSubCodes, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0} 2. SpdmMessage <- Responder

Assertion 27.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.5.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 27.5.5:

SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_027_006.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a SLOT_MANAGEMENT with a reserved or unknown SubCode value.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=0x05, Param2=0, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SpdmMessage <- Responder

Assertion 27.6.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.6.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.6.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 27.6.5:

SpdmMessage.Param2 == 0.

SPDM_VDM_V1_4_Test_027_007.py

Description: SPDM responder shall return ERROR(UnsupportedRequest), if it receives a SLOT_MANAGEMENT with a valid SubCode that is not in SupportedSubCodes.SubCodeBitmap.

SPDM Version: 1.4+

TestSetup:

1. Requester -> GET_VERSION {SPDMVersion=0x10}

2. VERSION <- Responder

3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case.

4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …}

5. CAPABILITIES <- Responder

6. If Flags.SLOT_MGMT_CAP == 0, then skip this case.

7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …}

8. ALGORITHMS <- Responder

9. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, …}

10. SLOT_MANAGEMENT_RESP <- Responder

11. UnsupportedSubCode = any SubCode in {GetCSR, ManageBank, ManageSlot, SetCertificate} whose bit is 0 in SupportedSubCodes.SubCodeBitmap. If no such SubCode exists, skip this case.

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=UnsupportedSubCode, MgmtStructOffset=<as required>, SlotMgmtReqStruct=<as required>}

2. SpdmMessage <- Responder

Assertion 27.7.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.7.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.7.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.7.4:

SpdmMessage.Param1 == UnsupportedRequest.

Assertion 27.7.5:

SpdmMessage.Param2 == SLOT_MANAGEMENT (0x88).

ErrorData for ERROR(UnsupportedRequest) is the RequestResponseCode of the request that was not supported, so the responder echoes back the code it could not serve – 0x88 here, not 0.

SPDM_VDM_V1_4_Test_027_008.py

Description: SPDM responder shall return ERROR(UnsupportedRequest), if it receives a SLOT_MANAGEMENT when SLOT_MGMT_CAP=0 in CAPABILITIES.

SPDM Version: 1.4+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.4 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SLOT_MGMT_CAP == 1, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> SLOT_MANAGEMENT {SPDMVersion=NegotiatedVersion, Param1.SubCode=SupportedSubCodes, MgmtStructOffset=0, SlotMgmtReqStruct=0}

2. SpdmMessage <- Responder

Assertion 27.8.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 27.8.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 27.8.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 27.8.4:

SpdmMessage.Param1 == UnsupportedRequest.

Assertion 27.8.5:

SpdmMessage.Param2 == SLOT_MANAGEMENT (0x88).

ErrorData for ERROR(UnsupportedRequest) is the RequestResponseCode of the request that was not supported, so the responder echoes back the code it could not serve – 0x88 here, not 0.

SPDM_VDM_V1_4_Test_028_001.py

Description: SPDM responder shall return valid SET_CERTIFICATE_RSP, if it receives a SET_CERTIFICATE.

SPDM Version: 1.2+

Note: SET_CERTIFICATE provisions or erases a certificate slot and is exchanged inside a secure session. The conformance suite issues it on its own, so a conformant responder may answer ERROR instead of SET_CERTIFICATE_RSP. This case validates the SET_CERTIFICATE_RSP format when one is returned and is Skipped when the responder answers ERROR. Full validation of SET_CERTIFICATE_RSP requires a secure session, which the suite cannot yet establish.

TestSetup:
1. Requester -> GET_VERSION {SPDMVersion=0x10}
2. VERSION <- Responder
3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case.
4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, ...}
5. CAPABILITIES <- Responder
6. If Flags.SET_CERT_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:
1. Requester -> SET_CERTIFICATE {SPDMVersion=NegotiatedVersion, SlotID=0,
   Param2=0}
2. SpdmMessage <- Responder

Assertion 28.1.1:
    sizeof(SpdmMessage) >= sizeof(SET_CERTIFICATE_RSP)

Assertion 28.1.2:
    SpdmMessage.RequestResponseCode == SET_CERTIFICATE_RSP

Assertion 28.1.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 28.1.4:
    SpdmMessage.Param1.SlotID == requested SlotID

Assertion 28.1.5:
    SpdmMessage.Param2 == 0

SPDM_VDM_V1_4_Test_028_002.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a SET_CERTIFICATE with non negotiated version.

SPDM Version: 1.2+

TestSetup: 1. Requester -> GET_VERSION {SPDMVersion=0x10} 2. VERSION <- Responder 3. If 1.2 or above is not in VERSION.VersionNumberEntry, then skip this case. 4. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, …} 5. CAPABILITIES <- Responder 6. If Flags.SET_CERT_CAP == 0, then skip this case. 7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, …} 8. ALGORITHMS <- Responder

TestTeardown: None

Steps: 1. Requester -> SET_CERTIFICATE {SPDMVersion=(NegotiatedVersion+1)} 2. SpdmMessage <- Responder

Assertion 28.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 28.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 28.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 28.2.4:

SpdmMessage.Param1 == VersionMismatch

Assertion 28.2.5:

SpdmMessage.Param2 == 0