SPDM_V1_0

SPDM_SMBUS_V1_0_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}.

SPDM_SMBUS_V1_0_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_0_Test_002_002.py

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

SPDM Version: 1.0+

TestSetup:

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

2. VERSION <- Responder

3. HighestVersion = Max{SpdmMessage.VersionNumberEntry[0..(n-1)]}

4. LowestVersion = Min{SpdmMessage.VersionNumberEntry[0..(n-1)]}

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=(HighestVersion+1), Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 2.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 2.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 2.2.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 2.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 2.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CAPABILITIES {SPDMVersion=(LowestVersion-1), Param1=0, Param2=0}

4. SpdmMessage <- Responder

Assertion 2.2.*.

###

SPDM_SMBUS_V1_0_Test_002_006.py

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

SPDM Version: 1.0+

TestSetup:

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

2. VERSION <- Responder

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

4. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Param1=0, Param2=1, …} – if NegotiatedVersion=1.0+

2. SpdmMessage <- Responder

Assertion 2.6.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 2.6.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 2.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 2.6.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 2.6.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, CTExponent+1, Flags-HBEAT_CAP, …} – if NegotiatedVersion=1.1+

4. SpdmMessage <- Responder

Assertion 2.6.*.

5. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, DataTransferSize+1, MaxSPDMmsgSize+1, …} – if NegotiatedVersion=1.2

6. SpdmMessage <- Responder

Assertion 2.6.*.

###

SPDM_SMBUS_V1_0_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_0_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_0_Test_003_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a NEGOTIATE_ALGORITHMS before GET_CAPABILITIES.

SPDM Version: 1.0+

TestSetup:

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

2. VERSION <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 3.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 3.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 3.3.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 3.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 3.3.5:

SpdmMessage.Param2 == 0.

###

SPDM_SMBUS_V1_0_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_0_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_0_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_0_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_0_Test_004_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_DIGESTS before 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. If Flags.CERT_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 4.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 4.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 4.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 4.3.5:

SpdmMessage.Param2 == 0.

SPDM_SMBUS_V1_0_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_0_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_0_Test_005_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_CERTIFICATE before 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. If Flags.CERT_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 5.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 5.3.5:

SpdmMessage.Param2 == 0.

###

SPDM_SMBUS_V1_0_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_0_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_0_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_0_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_0_Test_006_004.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHALLENGE 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 || Flags.CHAL_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

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

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 6.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 6.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 6.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.4.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 6.4.5:

SpdmMessage.Param2 == 0.

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

4. SpdmMessage <- Responder

Assertion 6.4.*.

###

SPDM_SMBUS_V1_0_Test_006_005.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_CERTIFICATE before 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. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 6.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 6.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 6.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.5.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 6.5.5:

SpdmMessage.Param2 == 0.

###

SPDM_SMBUS_V1_0_Test_006_006.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a CHALLENGE 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 || Flags.CHAL_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 ~ 0xF, 0xFF}

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 6.6.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 6.6.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 6.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.6.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 6.6.5:

SpdmMessage.Param2 == 0.

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=0, Param2=(TcbMeasurements+1)}

4. SpdmMessage <- Responder

Assertion 6.6.*.

5. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=0, Param2=(AllMeasurements-1)}

6. SpdmMessage <- Responder

Assertion 6.6.*.

###

SPDM_SMBUS_V1_0_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:

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

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_MEASUREMENTS 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.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

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

7. ALGORITHMS <- Responder

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

9. DIGESTS <- Responder

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

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

12. CERTIFICATE <- Responder

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

14. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 7.2.5:

SpdmMessage.Param2 == 0.

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

4. SpdmMessage <- Responder

Assertion 7.2.*.

###

SPDM_SMBUS_V1_0_Test_007_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_MEASUREMENTS before 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. If Flags.CERT_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 7.3.5:

SpdmMessage.Param2 == 0.

###

SPDM_SMBUS_V1_0_Test_007_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a GET_MEASUREMENTS 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.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

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

7. ALGORITHMS <- Responder

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

9. DIGESTS <- Responder

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

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

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

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

17. MEASUREMENTS <- Responder

18. ValidMeasurementIndex[] = array of index in valid MeasurementBlock

19. InvalidMeasurementIndex[] = array of index not in valid MeasurementBlock, excluding 0 and 0xff

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 7.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=1, Param2=ValidMeasurementIndex[i], SlotID=InvalidSlotID[i]} – if NegotiatedVersion=1.1+ && MEAS_CAP == 2

4. SpdmMessage <- Responder

Assertion 7.4.*.

###

SPDM_SMBUS_V1_0_Test_007_005.py

Description: The SPDM Measurement Block from device shall follow SPDM specification.

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.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

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

7. ALGORITHMS <- Responder

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

9. DIGESTS <- Responder

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

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

12. CERTIFICATE <- Responder

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

14. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.5.1:

SpdmMeasurementBlock[i].MeasurementSpecification == DMTF

Assertion 7.5.2:

if (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_7 = 0) then (SpdmMeasurementBlock[i].MeasurementSize == 3 + HashSize)

Assertion 7.5.3:

if (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_7 = 0) then (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueSize == HashSize)

Assertion 7.5.4:

if (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_[6:0] == 0x5) && (SPDMVersion >= SPDM_MESSAGE_VERSION_12) then (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_7 == 1)

###

SPDM_VDM_V1_0_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}.

SPDM_VDM_V1_0_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_0_Test_002_002.py

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

SPDM Version: 1.0+

TestSetup:

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

2. VERSION <- Responder

3. HighestVersion = Max{SpdmMessage.VersionNumberEntry[0..(n-1)]}

4. LowestVersion = Min{SpdmMessage.VersionNumberEntry[0..(n-1)]}

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=(HighestVersion+1), Param1=0, Param2=0}

2. SpdmMessage <- Responder

Assertion 2.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 2.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 2.2.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 2.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 2.2.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CAPABILITIES {SPDMVersion=(LowestVersion-1), Param1=0, Param2=0}

4. SpdmMessage <- Responder

Assertion 2.2.*.

###

SPDM_VDM_V1_0_Test_002_006.py

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

SPDM Version: 1.0+

TestSetup:

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

2. VERSION <- Responder

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

4. CAPABILITIES <- Responder

TestTeardown:

None

Steps:

1. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, Param1=0, Param2=1, …} – if NegotiatedVersion=1.0+

2. SpdmMessage <- Responder

Assertion 2.6.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 2.6.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 2.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 2.6.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 2.6.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, CTExponent+1, Flags-HBEAT_CAP, …} – if NegotiatedVersion=1.1+

4. SpdmMessage <- Responder

Assertion 2.6.*.

5. Requester -> GET_CAPABILITIES {SPDMVersion=NegotiatedVersion, DataTransferSize+1, MaxSPDMmsgSize+1, …} – if NegotiatedVersion=1.2

6. SpdmMessage <- Responder

Assertion 2.6.*.

###

SPDM_VDM_V1_0_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_0_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_0_Test_003_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a NEGOTIATE_ALGORITHMS before GET_CAPABILITIES.

SPDM Version: 1.0+

TestSetup:

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

2. VERSION <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 3.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 3.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 3.3.3:

SpdmMessage.SPDMVersion == 0x10

Assertion 3.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 3.3.5:

SpdmMessage.Param2 == 0.

###

SPDM_VDM_V1_0_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_0_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_0_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_0_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_0_Test_004_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_DIGESTS before 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. If Flags.CERT_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 4.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 4.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 4.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 4.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 4.3.5:

SpdmMessage.Param2 == 0.

SPDM_VDM_V1_0_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_0_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_0_Test_005_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_CERTIFICATE before 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. If Flags.CERT_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 5.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 5.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 5.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 5.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 5.3.5:

SpdmMessage.Param2 == 0.

###

SPDM_VDM_V1_0_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_0_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_0_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_0_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_0_Test_006_004.py

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a CHALLENGE 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 || Flags.CHAL_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

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

13. CERTIFICATE <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 6.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 6.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 6.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.4.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 6.4.5:

SpdmMessage.Param2 == 0.

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

4. SpdmMessage <- Responder

Assertion 6.4.*.

###

SPDM_VDM_V1_0_Test_006_005.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_CERTIFICATE before 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. If Flags.CERT_CAP == 0 || Flags.CHAL_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 6.5.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 6.5.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 6.5.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.5.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 6.5.5:

SpdmMessage.Param2 == 0.

###

SPDM_VDM_V1_0_Test_006_006.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a CHALLENGE 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 || Flags.CHAL_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 ~ 0xF, 0xFF}

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 6.6.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 6.6.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 6.6.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 6.6.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 6.6.5:

SpdmMessage.Param2 == 0.

3. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=0, Param2=(TcbMeasurements+1)}

4. SpdmMessage <- Responder

Assertion 6.6.*.

5. Requester -> CHALLENGE {SPDMVersion=NegotiatedVersion, Param1.SlotID=0, Param2=(AllMeasurements-1)}

6. SpdmMessage <- Responder

Assertion 6.6.*.

###

SPDM_VDM_V1_0_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:

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

Description: SPDM responder shall return ERROR(VersionMismatch), if it receives a GET_MEASUREMENTS 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.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

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

7. ALGORITHMS <- Responder

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

9. DIGESTS <- Responder

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

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

12. CERTIFICATE <- Responder

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

14. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.2.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.2.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.2.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.2.4:

SpdmMessage.Param1 == VersionMismatch.

Assertion 7.2.5:

SpdmMessage.Param2 == 0.

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

4. SpdmMessage <- Responder

Assertion 7.2.*.

###

SPDM_VDM_V1_0_Test_007_003.py

Description: SPDM responder shall return ERROR(UnexpectedRequest), if it receives a GET_MEASUREMENTS before 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. If Flags.CERT_CAP == 0, then skip this case.

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.3.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.3.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.3.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.3.4:

SpdmMessage.Param1 == UnexpectedRequest.

Assertion 7.3.5:

SpdmMessage.Param2 == 0.

###

SPDM_VDM_V1_0_Test_007_004.py

Description: SPDM responder shall return ERROR(InvalidRequest), if it receives a GET_MEASUREMENTS 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.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

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

7. ALGORITHMS <- Responder

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

9. DIGESTS <- Responder

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

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

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

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

17. MEASUREMENTS <- Responder

18. ValidMeasurementIndex[] = array of index in valid MeasurementBlock

19. InvalidMeasurementIndex[] = array of index not in valid MeasurementBlock, excluding 0 and 0xff

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.4.1:

sizeof(SpdmMessage) >= sizeof(ERROR)

Assertion 7.4.2:

SpdmMessage.RequestResponseCode == ERROR

Assertion 7.4.3:

SpdmMessage.SPDMVersion == NegotiatedVersion

Assertion 7.4.4:

SpdmMessage.Param1 == InvalidRequest.

Assertion 7.4.5:

SpdmMessage.Param2 == 0.

3. Requester -> GET_MEASUREMENTS {SPDMVersion=NegotiatedVersion, Param1=1, Param2=ValidMeasurementIndex[i], SlotID=InvalidSlotID[i]} – if NegotiatedVersion=1.1+ && MEAS_CAP == 2

4. SpdmMessage <- Responder

Assertion 7.4.*.

###

SPDM_VDM_V1_0_Test_007_005.py

Description: The SPDM Measurement Block from device shall follow SPDM specification.

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.MEAS_CAP == 0 || (Flags.MEAS_CAP == 2 && Flags.CERT_CAP == 0), then skip this case.

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

7. ALGORITHMS <- Responder

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

9. DIGESTS <- Responder

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

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

12. CERTIFICATE <- Responder

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

14. CHALLENGE_AUTH <- Responder

TestTeardown:

None

Steps:

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

2. SpdmMessage <- Responder

Assertion 7.5.1:

SpdmMeasurementBlock[i].MeasurementSpecification == DMTF

Assertion 7.5.2:

if (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_7 = 0) then (SpdmMeasurementBlock[i].MeasurementSize == 3 + HashSize)

Assertion 7.5.3:

if (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_7 = 0) then (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueSize == HashSize)

Assertion 7.5.4:

if (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_[6:0] == 0x5) && (SPDMVersion >= SPDM_MESSAGE_VERSION_12) then (SpdmMeasurementBlock[i].Measurement.DMTFSpecMeasurementValueType.bit_7 == 1)

###