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_005_007.py

Description: SPDM responder shall return valid CERTIFICATE portions with Param1.LargeCertChain=1, if it receives GET_CERTIFICATE requests with Param1.LargeCertChain=1 that read the certificate chain by LargeOffset and LargeLength.

SPDM Version: 1.4+

Ported from DMTF SPDM-Responder-Validator case 5.7 (spdm_test_case_certificate_large_resp). The validator build on the appliance predates it.

Note: a portion larger than the DataTransferSize this requester advertised is answered with ERROR(LargeResponse) and collected with CHUNK_GET before the assertions run.

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,
   Flags.LARGE_RESP_CAP=1, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.LARGE_RESP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   CertChainBuffer = empty, LargeLength = 0x40000

   Repeat until SpdmMessage.LargeRemainderLength == 0:

      4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
         Param1.SlotID=SlotID, Param1.LargeCertChain=1, Param2=0, Offset=0,
         Length=0, LargeOffset=sizeof(CertChainBuffer),
         LargeLength=LargeLength}
      5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
         answers ERROR(LargeResponse)

      Assertion 5.7.1:
          sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain)

      Assertion 5.7.2:
          SpdmMessage.RequestResponseCode == CERTIFICATE

      Assertion 5.7.3:
          SpdmMessage.SPDMVersion == NegotiatedVersion

      Assertion 5.7.4:
          SpdmMessage.Param1.LargeCertChain == 1

      Assertion 5.7.5:
          0 < SpdmMessage.LargePortionLength <= LargeLength

      6. Append SpdmMessage.LargeCertChain to CertChainBuffer,
         LargeLength = 0xFFFFFFFF

   Assertion 5.7.6:
       sizeof(CertChainBuffer) > offset(CertChain, RootHash) + HashSize &&
       sizeof(CertChainBuffer) == CertChainBuffer.Length

   Assertion 5.7.7:
       Hash(CertChainBuffer) == DIGESTS.Digest[SlotID]

   Assertion 5.7.8:
       SpdmMessage.Param2.CertificateInfo <= 3

SPDM_DOE_V1_4_Test_005_008.py

Description: SPDM responder shall return the entire certificate chain in one CERTIFICATE, if it receives a GET_CERTIFICATE with Offset=0 and Length=0xFFFF and chunking is supported.

SPDM Version: 1.2+

Ported from DMTF SPDM-Responder-Validator case 5.8 (spdm_test_case_certificate_no_partial_chain). The validator build on the appliance predates it.

Note: this requester advertises DataTransferSize = 0x400, so a certificate chain does not fit in one transfer. The responder has to answer ERROR(LargeResponse), and the CERTIFICATE is collected with CHUNK_GET before the assertions run. The DMTF case keeps the libspdm default DataTransferSize and so only chunks a large chain. Assertion 5.8.8 is not in the DMTF case.

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,
   Flags.CHUNK_CAP=1, DataTransferSize=0x400, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
      Param1.SlotID=SlotID, Param2=0, Offset=0, Length=0xFFFF}
   5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
      answers ERROR(LargeResponse)

Assertion 5.8.1:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, CertChain)

Assertion 5.8.2:
    SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.8.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.8.4:
    SpdmMessage.RemainderLength == 0

Assertion 5.8.5:
    SpdmMessage.PortionLength == SpdmMessage.CertChain.Length

Assertion 5.8.6:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, CertChain) + CertChain.Length

Assertion 5.8.7:
    Hash(SpdmMessage.CertChain) == DIGESTS.Digest[SlotID]

Assertion 5.8.8:
    If SpdmMessage was not collected with CHUNK_GET,
    sizeof(SpdmMessage) <= DataTransferSize

SPDM_DOE_V1_4_Test_005_009.py

Description: SPDM responder shall return the entire certificate chain in one CERTIFICATE, if it receives a GET_CERTIFICATE with Param1.LargeCertChain=1, LargeOffset=0 and LargeLength=0xFFFFFFFF and chunking is supported.

SPDM Version: 1.4+

Ported from DMTF SPDM-Responder-Validator case 5.9 (spdm_test_case_certificate_no_partial_chain_large). The validator build on the appliance predates it.

Note: this requester advertises DataTransferSize = 0x400, so a certificate chain does not fit in one transfer. The responder has to answer ERROR(LargeResponse), and the CERTIFICATE is collected with CHUNK_GET before the assertions run. The DMTF case keeps the libspdm default DataTransferSize and so only chunks a large chain. Assertion 5.9.9 is not in the DMTF case.

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,
   Flags.CHUNK_CAP=1, Flags.LARGE_RESP_CAP=1, DataTransferSize=0x400, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.CHUNK_CAP == 0 ||
   Flags.LARGE_RESP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
      Param1.SlotID=SlotID, Param1.LargeCertChain=1, Param2=0, Offset=0,
      Length=0, LargeOffset=0, LargeLength=0xFFFFFFFF}
   5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
      answers ERROR(LargeResponse)

Assertion 5.9.1:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain)

Assertion 5.9.2:
    SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.9.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.9.4:
    SpdmMessage.Param1.LargeCertChain == 1

Assertion 5.9.5:
    SpdmMessage.LargeRemainderLength == 0

Assertion 5.9.6:
    SpdmMessage.LargePortionLength == SpdmMessage.LargeCertChain.Length

Assertion 5.9.7:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain) +
    LargeCertChain.Length

Assertion 5.9.8:
    Hash(SpdmMessage.LargeCertChain) == DIGESTS.Digest[SlotID]

Assertion 5.9.9:
    If SpdmMessage was not collected with CHUNK_GET,
    sizeof(SpdmMessage) <= DataTransferSize

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_001.py

Description: SPDM responder shall return valid HEARTBEAT_ACK, if it receives a HEARTBEAT in DHE session.

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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

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

18. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 12.1.1:

sizeof(SpdmMessage) >= sizeof(HEARTBEAT_ACK)

Assertion 12.1.2:

SpdmMessage.RequestResponseCode == HEARTBEAT_ACK

Assertion 12.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_DOE_V1_4_Test_012_002.py

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

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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

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

18. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 12.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 12.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 12.2.*.

###

SPDM_DOE_V1_4_Test_012_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a HEARTBEAT in 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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 12.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 12.3.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_001.py

Description: SPDM responder shall return valid KEY_UPDATE_ACK, if it receives a KEY_UPDATE in DHE session.

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateKey, Param2=Tag1} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.1.1:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.2:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.4:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.5:

SpdmMessage.Param2 == KEY_UPDATE.Param2

3. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=VerifyNewKey, Param2=Tag2} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.1.6:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.7:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.8:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.9:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.10:

SpdmMessage.Param2 == KEY_UPDATE.Param2

5. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateAllKeys, Param2=Tag3} in session-X

6. SpdmMessage <- Responder in session-X

Assertion 13.1.11:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.12:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.13:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.14:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.15:

SpdmMessage.Param2 == KEY_UPDATE.Param2

7. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=VerifyNewKey, Param2=Tag4} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 13.1.16:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.17:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.18:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.19:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.20:

SpdmMessage.Param2 == KEY_UPDATE.Param2

###

SPDM_DOE_V1_4_Test_013_002.py

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

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 13.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.2.*.

###

SPDM_DOE_V1_4_Test_013_003.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a KEY_UPDATE with invalid field in DHE session.

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=(UpdateKey-1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.3.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 13.3.5:

SpdmMessage.Param2 == 0.

3. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=(VerifyNewKey+1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.3.*.

###

SPDM_DOE_V1_4_Test_013_004.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a KEY_UPDATE in 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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 13.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.4.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 13.4.5:

SpdmMessage.Param2 == 0.

###

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.

Pass: the responder returns ENCAPSULATED_REQUEST and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.ENCAP_CAP is 0, or the responder

answers GET_ENCAPSULATED_REQUEST with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired), 0x45 (NoPendingRequests). An accepted ERROR is Skipped rather than Passed because no ENCAPSULATED_REQUEST was returned to validate.

Failed: any other ErrorCode, a ENCAPSULATED_REQUEST that fails an assertion, or

no SPDM response.

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.

Pass: the responder returns ENCAPSULATED_RESPONSE_ACK and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.ENCAP_CAP is 0, or the responder

answers DELIVER_ENCAPSULATED_RESPONSE with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired), 0x45 (NoPendingRequests). An accepted ERROR is Skipped rather than Passed because no ENCAPSULATED_RESPONSE_ACK was returned to validate.

Failed: any other ErrorCode, a ENCAPSULATED_RESPONSE_ACK that fails an

assertion, or no SPDM response.

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_001.py

Description: SPDM responder shall return valid END_SESSION_ACK, if it receives a END_SESSION in DHE session.

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.KEY_EX_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, …}

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 -> END_SESSION {SPDMVersion=NegotiatedVersion, Param1.StatePreservation=0, Param2=0} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 16.1.1:

sizeof(SpdmMessage) >= sizeof(END_SESSION_ACK)

Assertion 16.1.2:

SpdmMessage.RequestResponseCode == END_SESSION_ACK

Assertion 16.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_DOE_V1_4_Test_016_002.py

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

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.KEY_EX_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, …}

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 -> END_SESSION {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 16.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 16.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> END_SESSION {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 16.2.*.

###

SPDM_DOE_V1_4_Test_016_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a END_SESSION in 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.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 16.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 16.3.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.

• Pass: the responder returns CHUNK_SEND_ACK and every assertion below holds.

• Skipped: 1.2 or above is not in VERSION, Flags.CHUNK_CAP is 0, or the responder answers CHUNK_SEND with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no CHUNK_SEND_ACK was returned to validate.

• Failed: any other ErrorCode, a CHUNK_SEND_ACK that fails an assertion, or no SPDM response.

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.

• Pass: the responder returns CHUNK_RESPONSE and every assertion below holds.

• Skipped: 1.2 or above is not in VERSION, Flags.CHUNK_CAP is 0, or the responder answers CHUNK_GET with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no CHUNK_RESPONSE was returned to validate.

• Failed: any other ErrorCode, a CHUNK_RESPONSE that fails an assertion, or no SPDM response.

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.

Pass: the responder returns SET_KEY_PAIR_INFO_ACK and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.SET_KEY_PAIR_INFO_CAP is 0, or

the responder answers SET_KEY_PAIR_INFO with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SET_KEY_PAIR_INFO_ACK was returned to validate.

Failed: any other ErrorCode, a SET_KEY_PAIR_INFO_ACK that fails an assertion,

or no SPDM response.

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.

Pass: the responder returns SUPPORTED_EVENT_TYPES and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder

answers GET_SUPPORTED_EVENT_TYPES with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SUPPORTED_EVENT_TYPES was returned to validate.

Failed: any other ErrorCode, a SUPPORTED_EVENT_TYPES that fails an assertion,

or no SPDM response.

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.

Pass: the responder returns SUBSCRIBE_EVENT_TYPES_ACK and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder

answers SUBSCRIBE_EVENT_TYPES with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SUBSCRIBE_EVENT_TYPES_ACK was returned to validate.

Failed: any other ErrorCode, a SUBSCRIBE_EVENT_TYPES_ACK that fails an

assertion, or no SPDM response.

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.

• Pass: the responder returns EVENT_ACK and every assertion below holds.

• Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder answers SEND_EVENT with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no EVENT_ACK was returned to validate.

• Failed: any other ErrorCode, a EVENT_ACK that fails an assertion, or no SPDM response.

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+

Note: the BankID=0xFF request is answered with one BankDetails per Bank, so the response grows with the number of Banks and slots and is often larger than the DataTransferSize the requester advertised. The responder then answers with ERROR(LargeResponse) and the response is collected with CHUNK_GET before the assertions run. A response 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, 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 == UnsupportedSubCode, or SLOT_MANAGEMENT (0x88).

DSP0274 1.4.0 Table 65 gives the error data for UnsupportedRequest as “RequestResponseCode or the SubCode in the request message”. Both are permitted. SLOT_MGMT_CAP is 1 here and SLOT_MANAGEMENT itself is supported – only the SubCode is not – so the responder may return either 0x88 or the SubCode it rejected. The SubCode differs per sub-case, so this assertion is not one constant.

Skipped when 27.7.4 recorded Param1 = InvalidRequest, whose error data is 0: there is no echoed SubCode to check, and requiring one would report a second error against a value DSP0274 forbids the responder to set.

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), or SupportedSubCodes (0x00).

DSP0274 1.4.0 Table 65 gives the error data for UnsupportedRequest as “RequestResponseCode or the SubCode in the request message”. Both are permitted, and the request above sends SubCode=SupportedSubCodes (0x00), so a responder may return either 0x88 or 0x00.

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 a certificate slot and is exchanged inside a secure session. The request carries no CertChain, so the slot is never provisioned. 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.

Pass: the responder returns SET_CERTIFICATE_RSP and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.SET_CERT_CAP is 0, or the

responder answers SET_CERTIFICATE with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SET_CERTIFICATE_RSP was returned to validate.

Failed: any other ErrorCode, a SET_CERTIFICATE_RSP that fails an assertion, or

no SPDM response.

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_005_007.py

Description: SPDM responder shall return valid CERTIFICATE portions with Param1.LargeCertChain=1, if it receives GET_CERTIFICATE requests with Param1.LargeCertChain=1 that read the certificate chain by LargeOffset and LargeLength.

SPDM Version: 1.4+

Ported from DMTF SPDM-Responder-Validator case 5.7 (spdm_test_case_certificate_large_resp). The validator build on the appliance predates it.

Note: a portion larger than the DataTransferSize this requester advertised is answered with ERROR(LargeResponse) and collected with CHUNK_GET before the assertions run.

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,
   Flags.LARGE_RESP_CAP=1, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.LARGE_RESP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   CertChainBuffer = empty, LargeLength = 0x40000

   Repeat until SpdmMessage.LargeRemainderLength == 0:

      4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
         Param1.SlotID=SlotID, Param1.LargeCertChain=1, Param2=0, Offset=0,
         Length=0, LargeOffset=sizeof(CertChainBuffer),
         LargeLength=LargeLength}
      5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
         answers ERROR(LargeResponse)

      Assertion 5.7.1:
          sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain)

      Assertion 5.7.2:
          SpdmMessage.RequestResponseCode == CERTIFICATE

      Assertion 5.7.3:
          SpdmMessage.SPDMVersion == NegotiatedVersion

      Assertion 5.7.4:
          SpdmMessage.Param1.LargeCertChain == 1

      Assertion 5.7.5:
          0 < SpdmMessage.LargePortionLength <= LargeLength

      6. Append SpdmMessage.LargeCertChain to CertChainBuffer,
         LargeLength = 0xFFFFFFFF

   Assertion 5.7.6:
       sizeof(CertChainBuffer) > offset(CertChain, RootHash) + HashSize &&
       sizeof(CertChainBuffer) == CertChainBuffer.Length

   Assertion 5.7.7:
       Hash(CertChainBuffer) == DIGESTS.Digest[SlotID]

   Assertion 5.7.8:
       SpdmMessage.Param2.CertificateInfo <= 3

SPDM_SMBUS_V1_4_Test_005_008.py

Description: SPDM responder shall return the entire certificate chain in one CERTIFICATE, if it receives a GET_CERTIFICATE with Offset=0 and Length=0xFFFF and chunking is supported.

SPDM Version: 1.2+

Ported from DMTF SPDM-Responder-Validator case 5.8 (spdm_test_case_certificate_no_partial_chain). The validator build on the appliance predates it.

Note: this requester advertises DataTransferSize = 0x400, so a certificate chain does not fit in one transfer. The responder has to answer ERROR(LargeResponse), and the CERTIFICATE is collected with CHUNK_GET before the assertions run. The DMTF case keeps the libspdm default DataTransferSize and so only chunks a large chain. Assertion 5.8.8 is not in the DMTF case.

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,
   Flags.CHUNK_CAP=1, DataTransferSize=0x400, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
      Param1.SlotID=SlotID, Param2=0, Offset=0, Length=0xFFFF}
   5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
      answers ERROR(LargeResponse)

Assertion 5.8.1:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, CertChain)

Assertion 5.8.2:
    SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.8.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.8.4:
    SpdmMessage.RemainderLength == 0

Assertion 5.8.5:
    SpdmMessage.PortionLength == SpdmMessage.CertChain.Length

Assertion 5.8.6:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, CertChain) + CertChain.Length

Assertion 5.8.7:
    Hash(SpdmMessage.CertChain) == DIGESTS.Digest[SlotID]

Assertion 5.8.8:
    If SpdmMessage was not collected with CHUNK_GET,
    sizeof(SpdmMessage) <= DataTransferSize

SPDM_SMBUS_V1_4_Test_005_009.py

Description: SPDM responder shall return the entire certificate chain in one CERTIFICATE, if it receives a GET_CERTIFICATE with Param1.LargeCertChain=1, LargeOffset=0 and LargeLength=0xFFFFFFFF and chunking is supported.

SPDM Version: 1.4+

Ported from DMTF SPDM-Responder-Validator case 5.9 (spdm_test_case_certificate_no_partial_chain_large). The validator build on the appliance predates it.

Note: this requester advertises DataTransferSize = 0x400, so a certificate chain does not fit in one transfer. The responder has to answer ERROR(LargeResponse), and the CERTIFICATE is collected with CHUNK_GET before the assertions run. The DMTF case keeps the libspdm default DataTransferSize and so only chunks a large chain. Assertion 5.9.9 is not in the DMTF case.

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,
   Flags.CHUNK_CAP=1, Flags.LARGE_RESP_CAP=1, DataTransferSize=0x400, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.CHUNK_CAP == 0 ||
   Flags.LARGE_RESP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
      Param1.SlotID=SlotID, Param1.LargeCertChain=1, Param2=0, Offset=0,
      Length=0, LargeOffset=0, LargeLength=0xFFFFFFFF}
   5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
      answers ERROR(LargeResponse)

Assertion 5.9.1:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain)

Assertion 5.9.2:
    SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.9.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.9.4:
    SpdmMessage.Param1.LargeCertChain == 1

Assertion 5.9.5:
    SpdmMessage.LargeRemainderLength == 0

Assertion 5.9.6:
    SpdmMessage.LargePortionLength == SpdmMessage.LargeCertChain.Length

Assertion 5.9.7:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain) +
    LargeCertChain.Length

Assertion 5.9.8:
    Hash(SpdmMessage.LargeCertChain) == DIGESTS.Digest[SlotID]

Assertion 5.9.9:
    If SpdmMessage was not collected with CHUNK_GET,
    sizeof(SpdmMessage) <= DataTransferSize

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_001.py

Description: SPDM responder shall return valid HEARTBEAT_ACK, if it receives a HEARTBEAT in DHE session.

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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

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

18. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 12.1.1:

sizeof(SpdmMessage) >= sizeof(HEARTBEAT_ACK)

Assertion 12.1.2:

SpdmMessage.RequestResponseCode == HEARTBEAT_ACK

Assertion 12.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_SMBUS_V1_4_Test_012_002.py

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

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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

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

18. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 12.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 12.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 12.2.*.

###

SPDM_SMBUS_V1_4_Test_012_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a HEARTBEAT in 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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 12.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 12.3.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_001.py

Description: SPDM responder shall return valid KEY_UPDATE_ACK, if it receives a KEY_UPDATE in DHE session.

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateKey, Param2=Tag1} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.1.1:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.2:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.4:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.5:

SpdmMessage.Param2 == KEY_UPDATE.Param2

3. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=VerifyNewKey, Param2=Tag2} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.1.6:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.7:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.8:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.9:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.10:

SpdmMessage.Param2 == KEY_UPDATE.Param2

5. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateAllKeys, Param2=Tag3} in session-X

6. SpdmMessage <- Responder in session-X

Assertion 13.1.11:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.12:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.13:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.14:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.15:

SpdmMessage.Param2 == KEY_UPDATE.Param2

7. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=VerifyNewKey, Param2=Tag4} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 13.1.16:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.17:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.18:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.19:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.20:

SpdmMessage.Param2 == KEY_UPDATE.Param2

###

SPDM_SMBUS_V1_4_Test_013_002.py

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

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 13.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.2.*.

###

SPDM_SMBUS_V1_4_Test_013_003.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a KEY_UPDATE with invalid field in DHE session.

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=(UpdateKey-1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.3.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 13.3.5:

SpdmMessage.Param2 == 0.

3. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=(VerifyNewKey+1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.3.*.

###

SPDM_SMBUS_V1_4_Test_013_004.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a KEY_UPDATE in 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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 13.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.4.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 13.4.5:

SpdmMessage.Param2 == 0.

###

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.

Pass: the responder returns ENCAPSULATED_REQUEST and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.ENCAP_CAP is 0, or the responder

answers GET_ENCAPSULATED_REQUEST with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired), 0x45 (NoPendingRequests). An accepted ERROR is Skipped rather than Passed because no ENCAPSULATED_REQUEST was returned to validate.

Failed: any other ErrorCode, a ENCAPSULATED_REQUEST that fails an assertion, or

no SPDM response.

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.

Pass: the responder returns ENCAPSULATED_RESPONSE_ACK and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.ENCAP_CAP is 0, or the responder

answers DELIVER_ENCAPSULATED_RESPONSE with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired), 0x45 (NoPendingRequests). An accepted ERROR is Skipped rather than Passed because no ENCAPSULATED_RESPONSE_ACK was returned to validate.

Failed: any other ErrorCode, a ENCAPSULATED_RESPONSE_ACK that fails an

assertion, or no SPDM response.

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_001.py

Description: SPDM responder shall return valid END_SESSION_ACK, if it receives a END_SESSION in DHE session.

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.KEY_EX_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, …}

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 -> END_SESSION {SPDMVersion=NegotiatedVersion, Param1.StatePreservation=0, Param2=0} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 16.1.1:

sizeof(SpdmMessage) >= sizeof(END_SESSION_ACK)

Assertion 16.1.2:

SpdmMessage.RequestResponseCode == END_SESSION_ACK

Assertion 16.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_SMBUS_V1_4_Test_016_002.py

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

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.KEY_EX_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, …}

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 -> END_SESSION {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 16.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 16.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> END_SESSION {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 16.2.*.

###

SPDM_SMBUS_V1_4_Test_016_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a END_SESSION in 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.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 16.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 16.3.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.

• Pass: the responder returns CHUNK_SEND_ACK and every assertion below holds.

• Skipped: 1.2 or above is not in VERSION, Flags.CHUNK_CAP is 0, or the responder answers CHUNK_SEND with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no CHUNK_SEND_ACK was returned to validate.

• Failed: any other ErrorCode, a CHUNK_SEND_ACK that fails an assertion, or no SPDM response.

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.

• Pass: the responder returns CHUNK_RESPONSE and every assertion below holds.

• Skipped: 1.2 or above is not in VERSION, Flags.CHUNK_CAP is 0, or the responder answers CHUNK_GET with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no CHUNK_RESPONSE was returned to validate.

• Failed: any other ErrorCode, a CHUNK_RESPONSE that fails an assertion, or no SPDM response.

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.

Pass: the responder returns SET_KEY_PAIR_INFO_ACK and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.SET_KEY_PAIR_INFO_CAP is 0, or

the responder answers SET_KEY_PAIR_INFO with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SET_KEY_PAIR_INFO_ACK was returned to validate.

Failed: any other ErrorCode, a SET_KEY_PAIR_INFO_ACK that fails an assertion,

or no SPDM response.

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.

Pass: the responder returns SUPPORTED_EVENT_TYPES and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder

answers GET_SUPPORTED_EVENT_TYPES with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SUPPORTED_EVENT_TYPES was returned to validate.

Failed: any other ErrorCode, a SUPPORTED_EVENT_TYPES that fails an assertion,

or no SPDM response.

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.

Pass: the responder returns SUBSCRIBE_EVENT_TYPES_ACK and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder

answers SUBSCRIBE_EVENT_TYPES with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SUBSCRIBE_EVENT_TYPES_ACK was returned to validate.

Failed: any other ErrorCode, a SUBSCRIBE_EVENT_TYPES_ACK that fails an

assertion, or no SPDM response.

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.

• Pass: the responder returns EVENT_ACK and every assertion below holds.

• Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder answers SEND_EVENT with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no EVENT_ACK was returned to validate.

• Failed: any other ErrorCode, a EVENT_ACK that fails an assertion, or no SPDM response.

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+

Note: the BankID=0xFF request is answered with one BankDetails per Bank, so the response grows with the number of Banks and slots and is often larger than the DataTransferSize the requester advertised. The responder then answers with ERROR(LargeResponse) and the response is collected with CHUNK_GET before the assertions run. A response 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, 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 == UnsupportedSubCode, or SLOT_MANAGEMENT (0x88).

DSP0274 1.4.0 Table 65 gives the error data for UnsupportedRequest as “RequestResponseCode or the SubCode in the request message”. Both are permitted. SLOT_MGMT_CAP is 1 here and SLOT_MANAGEMENT itself is supported – only the SubCode is not – so the responder may return either 0x88 or the SubCode it rejected. The SubCode differs per sub-case, so this assertion is not one constant.

Skipped when 27.7.4 recorded Param1 = InvalidRequest, whose error data is 0: there is no echoed SubCode to check, and requiring one would report a second error against a value DSP0274 forbids the responder to set.

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), or SupportedSubCodes (0x00).

DSP0274 1.4.0 Table 65 gives the error data for UnsupportedRequest as “RequestResponseCode or the SubCode in the request message”. Both are permitted, and the request above sends SubCode=SupportedSubCodes (0x00), so a responder may return either 0x88 or 0x00.

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 a certificate slot and is exchanged inside a secure session. The request carries no CertChain, so the slot is never provisioned. 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.

Pass: the responder returns SET_CERTIFICATE_RSP and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.SET_CERT_CAP is 0, or the

responder answers SET_CERTIFICATE with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SET_CERTIFICATE_RSP was returned to validate.

Failed: any other ErrorCode, a SET_CERTIFICATE_RSP that fails an assertion, or

no SPDM response.

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_005_007.py

Description: SPDM responder shall return valid CERTIFICATE portions with Param1.LargeCertChain=1, if it receives GET_CERTIFICATE requests with Param1.LargeCertChain=1 that read the certificate chain by LargeOffset and LargeLength.

SPDM Version: 1.4+

Ported from DMTF SPDM-Responder-Validator case 5.7 (spdm_test_case_certificate_large_resp). The validator build on the appliance predates it.

Note: a portion larger than the DataTransferSize this requester advertised is answered with ERROR(LargeResponse) and collected with CHUNK_GET before the assertions run.

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,
   Flags.LARGE_RESP_CAP=1, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.LARGE_RESP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   CertChainBuffer = empty, LargeLength = 0x40000

   Repeat until SpdmMessage.LargeRemainderLength == 0:

      4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
         Param1.SlotID=SlotID, Param1.LargeCertChain=1, Param2=0, Offset=0,
         Length=0, LargeOffset=sizeof(CertChainBuffer),
         LargeLength=LargeLength}
      5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
         answers ERROR(LargeResponse)

      Assertion 5.7.1:
          sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain)

      Assertion 5.7.2:
          SpdmMessage.RequestResponseCode == CERTIFICATE

      Assertion 5.7.3:
          SpdmMessage.SPDMVersion == NegotiatedVersion

      Assertion 5.7.4:
          SpdmMessage.Param1.LargeCertChain == 1

      Assertion 5.7.5:
          0 < SpdmMessage.LargePortionLength <= LargeLength

      6. Append SpdmMessage.LargeCertChain to CertChainBuffer,
         LargeLength = 0xFFFFFFFF

   Assertion 5.7.6:
       sizeof(CertChainBuffer) > offset(CertChain, RootHash) + HashSize &&
       sizeof(CertChainBuffer) == CertChainBuffer.Length

   Assertion 5.7.7:
       Hash(CertChainBuffer) == DIGESTS.Digest[SlotID]

   Assertion 5.7.8:
       SpdmMessage.Param2.CertificateInfo <= 3

SPDM_VDM_V1_4_Test_005_008.py

Description: SPDM responder shall return the entire certificate chain in one CERTIFICATE, if it receives a GET_CERTIFICATE with Offset=0 and Length=0xFFFF and chunking is supported.

SPDM Version: 1.2+

Ported from DMTF SPDM-Responder-Validator case 5.8 (spdm_test_case_certificate_no_partial_chain). The validator build on the appliance predates it.

Note: this requester advertises DataTransferSize = 0x400, so a certificate chain does not fit in one transfer. The responder has to answer ERROR(LargeResponse), and the CERTIFICATE is collected with CHUNK_GET before the assertions run. The DMTF case keeps the libspdm default DataTransferSize and so only chunks a large chain. Assertion 5.8.8 is not in the DMTF case.

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,
   Flags.CHUNK_CAP=1, DataTransferSize=0x400, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.CHUNK_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
      Param1.SlotID=SlotID, Param2=0, Offset=0, Length=0xFFFF}
   5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
      answers ERROR(LargeResponse)

Assertion 5.8.1:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, CertChain)

Assertion 5.8.2:
    SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.8.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.8.4:
    SpdmMessage.RemainderLength == 0

Assertion 5.8.5:
    SpdmMessage.PortionLength == SpdmMessage.CertChain.Length

Assertion 5.8.6:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, CertChain) + CertChain.Length

Assertion 5.8.7:
    Hash(SpdmMessage.CertChain) == DIGESTS.Digest[SlotID]

Assertion 5.8.8:
    If SpdmMessage was not collected with CHUNK_GET,
    sizeof(SpdmMessage) <= DataTransferSize

SPDM_VDM_V1_4_Test_005_009.py

Description: SPDM responder shall return the entire certificate chain in one CERTIFICATE, if it receives a GET_CERTIFICATE with Param1.LargeCertChain=1, LargeOffset=0 and LargeLength=0xFFFFFFFF and chunking is supported.

SPDM Version: 1.4+

Ported from DMTF SPDM-Responder-Validator case 5.9 (spdm_test_case_certificate_no_partial_chain_large). The validator build on the appliance predates it.

Note: this requester advertises DataTransferSize = 0x400, so a certificate chain does not fit in one transfer. The responder has to answer ERROR(LargeResponse), and the CERTIFICATE is collected with CHUNK_GET before the assertions run. The DMTF case keeps the libspdm default DataTransferSize and so only chunks a large chain. Assertion 5.9.9 is not in the DMTF case.

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,
   Flags.CHUNK_CAP=1, Flags.LARGE_RESP_CAP=1, DataTransferSize=0x400, ...}
5. CAPABILITIES <- Responder
6. If Flags.CERT_CAP == 0 || Flags.CHUNK_CAP == 0 ||
   Flags.LARGE_RESP_CAP == 0, then skip this case.
7. Requester -> NEGOTIATE_ALGORITHMS {SPDMVersion=NegotiatedVersion, ...}
8. ALGORITHMS <- Responder

TestTeardown: None

Steps:

1. Requester -> GET_DIGESTS {SPDMVersion=NegotiatedVersion, Param1=0, Param2=0}
2. DIGESTS <- Responder
3. ValidSlotIDs[] = SlotIDs set in DIGESTS.Param2, leaving out any slot whose
   CertModel == 0 when MULTI_KEY_CONN_RSP is true.

For each SlotID in ValidSlotIDs[]:

   4. Requester -> GET_CERTIFICATE {SPDMVersion=NegotiatedVersion,
      Param1.SlotID=SlotID, Param1.LargeCertChain=1, Param2=0, Offset=0,
      Length=0, LargeOffset=0, LargeLength=0xFFFFFFFF}
   5. SpdmMessage <- Responder, collected with CHUNK_GET if the responder
      answers ERROR(LargeResponse)

Assertion 5.9.1:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain)

Assertion 5.9.2:
    SpdmMessage.RequestResponseCode == CERTIFICATE

Assertion 5.9.3:
    SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.9.4:
    SpdmMessage.Param1.LargeCertChain == 1

Assertion 5.9.5:
    SpdmMessage.LargeRemainderLength == 0

Assertion 5.9.6:
    SpdmMessage.LargePortionLength == SpdmMessage.LargeCertChain.Length

Assertion 5.9.7:
    sizeof(SpdmMessage) >= offset(CERTIFICATE, LargeCertChain) +
    LargeCertChain.Length

Assertion 5.9.8:
    Hash(SpdmMessage.LargeCertChain) == DIGESTS.Digest[SlotID]

Assertion 5.9.9:
    If SpdmMessage was not collected with CHUNK_GET,
    sizeof(SpdmMessage) <= DataTransferSize

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_001.py

Description: SPDM responder shall return valid HEARTBEAT_ACK, if it receives a HEARTBEAT in DHE session.

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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

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

18. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 12.1.1:

sizeof(SpdmMessage) >= sizeof(HEARTBEAT_ACK)

Assertion 12.1.2:

SpdmMessage.RequestResponseCode == HEARTBEAT_ACK

Assertion 12.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_VDM_V1_4_Test_012_002.py

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

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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

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

18. FINISH_RSP <- Responder in session-X

TestTeardown:

None

Steps:

1. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 12.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 12.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 12.2.*.

###

SPDM_VDM_V1_4_Test_012_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a HEARTBEAT in 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.HBEAT_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

16. If KEY_EXCHANGE_RSP.Param1.HeartbeatPeriod == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 12.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 12.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 12.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 12.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 12.3.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_001.py

Description: SPDM responder shall return valid KEY_UPDATE_ACK, if it receives a KEY_UPDATE in DHE session.

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateKey, Param2=Tag1} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.1.1:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.2:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.4:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.5:

SpdmMessage.Param2 == KEY_UPDATE.Param2

3. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=VerifyNewKey, Param2=Tag2} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.1.6:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.7:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.8:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.9:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.10:

SpdmMessage.Param2 == KEY_UPDATE.Param2

5. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=UpdateAllKeys, Param2=Tag3} in session-X

6. SpdmMessage <- Responder in session-X

Assertion 13.1.11:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.12:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.13:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.14:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.15:

SpdmMessage.Param2 == KEY_UPDATE.Param2

7. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=VerifyNewKey, Param2=Tag4} in session-X

8. SpdmMessage <- Responder in session-X

Assertion 13.1.16:

sizeof(SpdmMessage) >= sizeof(KEY_UPDATE_ACK)

Assertion 13.1.17:

SpdmMessage.RequestResponseCode == KEY_UPDATE_ACK

Assertion 13.1.18:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.1.19:

SpdmMessage.Param1 == KEY_UPDATE.Param1

Assertion 13.1.20:

SpdmMessage.Param2 == KEY_UPDATE.Param2

###

SPDM_VDM_V1_4_Test_013_002.py

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

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 13.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> HEARTBEAT {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.2.*.

###

SPDM_VDM_V1_4_Test_013_003.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a KEY_UPDATE with invalid field in DHE session.

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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

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 -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=(UpdateKey-1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 13.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.3.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 13.3.5:

SpdmMessage.Param2 == 0.

3. Requester -> KEY_UPDATE {SPDMVersion=NegotiatedVersion, Param1=(VerifyNewKey+1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 13.3.*.

###

SPDM_VDM_V1_4_Test_013_004.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a KEY_UPDATE in 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.KEY_UPD_CAP == 0 || Flags.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 13.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 13.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 13.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 13.4.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 13.4.5:

SpdmMessage.Param2 == 0.

###

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.

Pass: the responder returns ENCAPSULATED_REQUEST and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.ENCAP_CAP is 0, or the responder

answers GET_ENCAPSULATED_REQUEST with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired), 0x45 (NoPendingRequests). An accepted ERROR is Skipped rather than Passed because no ENCAPSULATED_REQUEST was returned to validate.

Failed: any other ErrorCode, a ENCAPSULATED_REQUEST that fails an assertion, or

no SPDM response.

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.

Pass: the responder returns ENCAPSULATED_RESPONSE_ACK and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.ENCAP_CAP is 0, or the responder

answers DELIVER_ENCAPSULATED_RESPONSE with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired), 0x45 (NoPendingRequests). An accepted ERROR is Skipped rather than Passed because no ENCAPSULATED_RESPONSE_ACK was returned to validate.

Failed: any other ErrorCode, a ENCAPSULATED_RESPONSE_ACK that fails an

assertion, or no SPDM response.

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_001.py

Description: SPDM responder shall return valid END_SESSION_ACK, if it receives a END_SESSION in DHE session.

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.KEY_EX_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, …}

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 -> END_SESSION {SPDMVersion=NegotiatedVersion, Param1.StatePreservation=0, Param2=0} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 16.1.1:

sizeof(SpdmMessage) >= sizeof(END_SESSION_ACK)

Assertion 16.1.2:

SpdmMessage.RequestResponseCode == END_SESSION_ACK

Assertion 16.1.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

###

SPDM_VDM_V1_4_Test_016_002.py

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

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.KEY_EX_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, …}

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 -> END_SESSION {SPDMVersion=(NegotiatedVersion+1), …} in session-X

2. SpdmMessage <- Responder in session-X

Assertion 16.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 16.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> END_SESSION {SPDMVersion=(NegotiatedVersion-1), …} in session-X

4. SpdmMessage <- Responder in session-X

Assertion 16.2.*.

###

SPDM_VDM_V1_4_Test_016_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a END_SESSION in 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.KEY_EX_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, …}

15. KEY_EXCHANGE_RSP <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder in session-X

Assertion 16.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 16.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 16.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 16.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 16.3.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.

• Pass: the responder returns CHUNK_SEND_ACK and every assertion below holds.

• Skipped: 1.2 or above is not in VERSION, Flags.CHUNK_CAP is 0, or the responder answers CHUNK_SEND with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no CHUNK_SEND_ACK was returned to validate.

• Failed: any other ErrorCode, a CHUNK_SEND_ACK that fails an assertion, or no SPDM response.

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.

• Pass: the responder returns CHUNK_RESPONSE and every assertion below holds.

• Skipped: 1.2 or above is not in VERSION, Flags.CHUNK_CAP is 0, or the responder answers CHUNK_GET with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no CHUNK_RESPONSE was returned to validate.

• Failed: any other ErrorCode, a CHUNK_RESPONSE that fails an assertion, or no SPDM response.

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.

Pass: the responder returns SET_KEY_PAIR_INFO_ACK and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.SET_KEY_PAIR_INFO_CAP is 0, or

the responder answers SET_KEY_PAIR_INFO with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SET_KEY_PAIR_INFO_ACK was returned to validate.

Failed: any other ErrorCode, a SET_KEY_PAIR_INFO_ACK that fails an assertion,

or no SPDM response.

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.

Pass: the responder returns SUPPORTED_EVENT_TYPES and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder

answers GET_SUPPORTED_EVENT_TYPES with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SUPPORTED_EVENT_TYPES was returned to validate.

Failed: any other ErrorCode, a SUPPORTED_EVENT_TYPES that fails an assertion,

or no SPDM response.

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.

Pass: the responder returns SUBSCRIBE_EVENT_TYPES_ACK and every assertion below

holds.

Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder

answers SUBSCRIBE_EVENT_TYPES with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SUBSCRIBE_EVENT_TYPES_ACK was returned to validate.

Failed: any other ErrorCode, a SUBSCRIBE_EVENT_TYPES_ACK that fails an

assertion, or no SPDM response.

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.

• Pass: the responder returns EVENT_ACK and every assertion below holds.

• Skipped: 1.3 or above is not in VERSION, Flags.EVENT_CAP is 0, or the responder answers SEND_EVENT with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x07 (UnsupportedRequest), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no EVENT_ACK was returned to validate.

• Failed: any other ErrorCode, a EVENT_ACK that fails an assertion, or no SPDM response.

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+

Note: the BankID=0xFF request is answered with one BankDetails per Bank, so the response grows with the number of Banks and slots and is often larger than the DataTransferSize the requester advertised. The responder then answers with ERROR(LargeResponse) and the response is collected with CHUNK_GET before the assertions run. A response 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, 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 == UnsupportedSubCode, or SLOT_MANAGEMENT (0x88).

DSP0274 1.4.0 Table 65 gives the error data for UnsupportedRequest as “RequestResponseCode or the SubCode in the request message”. Both are permitted. SLOT_MGMT_CAP is 1 here and SLOT_MANAGEMENT itself is supported – only the SubCode is not – so the responder may return either 0x88 or the SubCode it rejected. The SubCode differs per sub-case, so this assertion is not one constant.

Skipped when 27.7.4 recorded Param1 = InvalidRequest, whose error data is 0: there is no echoed SubCode to check, and requiring one would report a second error against a value DSP0274 forbids the responder to set.

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), or SupportedSubCodes (0x00).

DSP0274 1.4.0 Table 65 gives the error data for UnsupportedRequest as “RequestResponseCode or the SubCode in the request message”. Both are permitted, and the request above sends SubCode=SupportedSubCodes (0x00), so a responder may return either 0x88 or 0x00.

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 a certificate slot and is exchanged inside a secure session. The request carries no CertChain, so the slot is never provisioned. 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.

Pass: the responder returns SET_CERTIFICATE_RSP and every assertion below

holds.

Skipped: 1.2 or above is not in VERSION, Flags.SET_CERT_CAP is 0, or the

responder answers SET_CERTIFICATE with ERROR and one of these ErrorCodes: 0x01 (InvalidRequest), 0x04 (UnexpectedRequest), 0x05 (Unspecified), 0x0B (SessionRequired). An accepted ERROR is Skipped rather than Passed because no SET_CERTIFICATE_RSP was returned to validate.

Failed: any other ErrorCode, a SET_CERTIFICATE_RSP that fails an assertion, or

no SPDM response.

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