/src/spdm-rs/spdmlib/src/error.rs

Source
// Copyright (c) 2023 Intel Corporation
//
// SPDX-License-Identifier: Apache-2.0 or MIT

use core::{
    convert::{TryFrom, TryInto},
    fmt::{self, Debug},
};

/// Reference: https://github.com/DMTF/libspdm/blob/main/include/library/spdm_return_status.h
#[repr(u8)]
#[allow(dead_code)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum StatusSeverity {
    SUCCESS = 0,
    #[default]
    ERROR = 8,
}

impl TryFrom<u8> for StatusSeverity {
    type Error = ();

    fn try_from(value: u8) -> core::result::Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::SUCCESS),
            8 => Ok(Self::ERROR),
            _ => Err(()),
        }
    }
}

#[repr(u16)]
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum StatusCodeCore {
    SUCCESS = 0,
    #[default]
    INVALID_PARAMETER = 1,
    UNSUPPORTED_CAP = 2,
    INVALID_STATE_LOCAL = 3,
    INVALID_STATE_PEER = 4,
    INVALID_MSG_FIELD = 5,
    INVALID_MSG_SIZE = 6,
    NEGOTIATION_FAIL = 7,
    BUSY_PEER = 8,
    NOT_READY_PEER = 9,
    ERROR_PEER = 10,
    RESYNCH_PEER = 11,
    BUFFER_FULL = 12,
    BUFFER_TOO_SMALL = 13,
    SESSION_NUMBER_EXCEED = 14,
    SESSION_MSG_ERROR = 15,
    ACQUIRE_FAIL = 16,
    SESSION_TRY_DISCARD_KEY_UPDATE = 17,

    // only in spdm-rs
    DECODE_AEAD_FAIL = 0xFE,
}

impl TryFrom<u16> for StatusCodeCore {
    type Error = ();

    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::SUCCESS),
            1 => Ok(Self::INVALID_PARAMETER),
            2 => Ok(Self::UNSUPPORTED_CAP),
            3 => Ok(Self::INVALID_STATE_LOCAL),
            4 => Ok(Self::INVALID_STATE_PEER),
            5 => Ok(Self::INVALID_MSG_FIELD),
            6 => Ok(Self::INVALID_MSG_SIZE),
            7 => Ok(Self::NEGOTIATION_FAIL),
            8 => Ok(Self::BUSY_PEER),
            9 => Ok(Self::NOT_READY_PEER),
            10 => Ok(Self::ERROR_PEER),
            11 => Ok(Self::RESYNCH_PEER),
            12 => Ok(Self::BUFFER_FULL),
            13 => Ok(Self::BUFFER_TOO_SMALL),
            14 => Ok(Self::SESSION_NUMBER_EXCEED),
            15 => Ok(Self::SESSION_MSG_ERROR),
            16 => Ok(Self::ACQUIRE_FAIL),
            17 => Ok(Self::SESSION_TRY_DISCARD_KEY_UPDATE),
            0xFE => Ok(Self::DECODE_AEAD_FAIL),
            _ => Err(()),
        }
    }
}

#[repr(u16)]
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum StatusCodeCrypto {
    #[default]
    CRYPTO_ERROR = 0,
    VERIF_FAIL = 1,
    SEQUENCE_NUMBER_OVERFLOW = 2,
    VERIF_NO_AUTHORITY = 3,
    FIPS_SELF_TEST_FAIL = 4,
}

impl TryFrom<u16> for StatusCodeCrypto {
    type Error = ();

    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::CRYPTO_ERROR),
            1 => Ok(Self::VERIF_FAIL),
            2 => Ok(Self::SEQUENCE_NUMBER_OVERFLOW),
            3 => Ok(Self::VERIF_NO_AUTHORITY),
            4 => Ok(Self::FIPS_SELF_TEST_FAIL),
            _ => Err(()),
        }
    }
}

#[repr(u16)]
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum StatusCodeCertParse {
    #[default]
    INVALID_CERT = 0,
}

impl TryFrom<u16> for StatusCodeCertParse {
    type Error = ();

    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::INVALID_CERT),
            _ => Err(()),
        }
    }
}

#[repr(u16)]
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum StatusCodeTransport {
    #[default]
    SEND_FAIL = 0,
    RECEIVE_FAIL = 1,

    // only in spdm-rs
    DECAP_FAIL = 0xFE,
    DECAP_APP_FAIL = 0xFD,
    ENCAP_FAIL = 0xFC,
    ENCAP_APP_FAIL = 0xFB,
}

impl TryFrom<u16> for StatusCodeTransport {
    type Error = ();

    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::SEND_FAIL),
            1 => Ok(Self::RECEIVE_FAIL),
            0xFE => Ok(Self::DECAP_FAIL),
            0xFD => Ok(Self::DECAP_APP_FAIL),
            0xFC => Ok(Self::ENCAP_FAIL),
            0xFB => Ok(Self::ENCAP_APP_FAIL),
            _ => Err(()),
        }
    }
}

#[repr(u16)]
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum StatusCodeMeasCollect {
    MEAS_INVALID_INDEX = 0,
    #[default]
    MEAS_INTERNAL_ERROR = 1,
}

impl TryFrom<u16> for StatusCodeMeasCollect {
    type Error = ();

    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::MEAS_INVALID_INDEX),
            1 => Ok(Self::MEAS_INTERNAL_ERROR),
            _ => Err(()),
        }
    }
}

#[repr(u16)]
#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub enum StatusCodeRNG {
    #[default]
    LOW_ENTROPY = 0,
}

impl TryFrom<u16> for StatusCodeRNG {
    type Error = ();

    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::LOW_ENTROPY),
            _ => Err(()),
        }
    }
}

#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
pub struct StatusCodeVdmError {
    pub vdm_error_code: u16,
}

impl TryFrom<u16> for StatusCodeVdmError {
    type Error = ();

    fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
        Ok(Self {
            vdm_error_code: value,
        })
    }
}

#[allow(dead_code)]
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum StatusCode {
    SUCCESS,
    CORE(StatusCodeCore),
    CRYPTO(StatusCodeCrypto),
    CERT_PARSE(StatusCodeCertParse),
    TRANSPORT(StatusCodeTransport),
    MEAS_COLLECT(StatusCodeMeasCollect),
    RNG(StatusCodeRNG),
    VDM(StatusCodeVdmError),
}

impl Default for StatusCode {
    fn default() -> Self {
        Self::CORE(StatusCodeCore::default())
    }
}

impl TryFrom<u24> for StatusCode {
    type Error = ();

    fn try_from(value: u24) -> core::result::Result<Self, Self::Error> {
        let source: u8 = ((value.get() & 0xFF_00_00) >> 16) as u8;
        let code: u16 = (value.get() & 0x00_00_FF_FF) as u16;
        match source {
            0 => Ok(StatusCode::SUCCESS),
            1 => Ok(StatusCode::CORE(StatusCodeCore::try_from(code)?)),
            2 => Ok(StatusCode::CRYPTO(StatusCodeCrypto::try_from(code)?)),
            3 => Ok(StatusCode::CERT_PARSE(StatusCodeCertParse::try_from(code)?)),
            4 => Ok(StatusCode::TRANSPORT(StatusCodeTransport::try_from(code)?)),
            5 => Ok(StatusCode::MEAS_COLLECT(StatusCodeMeasCollect::try_from(
                code,
            )?)),
            6 => Ok(StatusCode::RNG(StatusCodeRNG::try_from(code)?)),
            7 => Ok(StatusCode::VDM(StatusCodeVdmError::try_from(code)?)),
            _ => Err(()),
        }
    }
}

impl TryInto<u24> for StatusCode {
    type Error = ();

    fn try_into(self) -> Result<u24, Self::Error> {
        match self {
            StatusCode::SUCCESS => Ok(u24::new(0)),
            StatusCode::CORE(c) => Ok(u24::new((1 << 16) as u32 + (c as u16) as u32)),
            StatusCode::CRYPTO(c) => Ok(u24::new((2 << 16) as u32 + (c as u16) as u32)),
            StatusCode::CERT_PARSE(c) => Ok(u24::new((3 << 16) as u32 + (c as u16) as u32)),
            StatusCode::TRANSPORT(t) => Ok(u24::new((4 << 16) as u32 + (t as u16) as u32)),
            StatusCode::MEAS_COLLECT(m) => Ok(u24::new((5 << 16) as u32 + (m as u16) as u32)),
            StatusCode::RNG(r) => Ok(u24::new((6 << 16) as u32 + (r as u16) as u32)),
            StatusCode::VDM(v) => Ok(u24::new((7 << 16) as u32 + (v.vdm_error_code) as u32)),
        }
    }
}

pub const SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH: usize = 36; // "SPDM error response message format":
                                                          //     'SPDMVersion' (1B) +
                                                          //     'RequestResponseCode' (1B) +
                                                          //     'Param1' (1B) +
                                                          //     'Param1' (1B) +
                                                          //     'ExtendedErrorData' (0-32B)
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct SpdmErrorMessageData {
    pub length: usize,
    pub data: [u8; SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH],
}
impl Default for SpdmErrorMessageData {
    fn default() -> Self {
        SpdmErrorMessageData {
            length: Default::default(),
            data: [Default::default(); SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH],
        }
    }
}

#[derive(Copy, Clone, Debug, Eq, Default)]
pub struct SpdmStatus {
    pub severity: StatusSeverity,
    pub status_code: StatusCode,
    pub error_data: Option<SpdmErrorMessageData>,
}
impl PartialEq for SpdmStatus {
    fn eq(&self, other: &Self) -> bool {
        // SpdmStatus with same serverity and status_code but different error_data shall be
        // considered as same SpdmStatus.
        // Thus, do not care about the error_data here.
        self.severity == other.severity && self.status_code == other.status_code
    }
}

impl Codec for SpdmStatus {
    fn encode(&self, bytes: &mut codec::Writer) -> Result<usize, codec::EncodeErr> {
        let mut sc = 0u32;
        sc += (((self.severity as u8) & 0x0F) as u32) << 28;
        sc += <StatusCode as TryInto<u24>>::try_into(self.status_code)
            .map_err(|_| codec::EncodeErr)?
            .get();
        sc.encode(bytes)?;
        Ok(4)
    }

    fn read(r: &mut codec::Reader) -> Option<Self> {
        let sc = u32::read(r)?;
        let severity = ((sc & 0xF0_00_00_00) >> 28) as u8;
        let severity = StatusSeverity::try_from(severity).ok()?;
        if (sc & 0x0F_00_00_00) != 0 {
            return None; //the reserve field
        }
        let status_code = u24::new(sc & 0x00_FF_FF_FF);
        let status_code = StatusCode::try_from(status_code).ok()?;

        Some(Self {
            severity,
            status_code,
            error_data: None,
        })
    }
}

impl SpdmStatus {
    /// return the u32 encoding
    pub fn get_u32(&self) -> u32 {
        let mut r = [0u8; 4];
        let _ = self.encode(&mut Writer::init(&mut r));
        u32::from_le_bytes(r)
    }

    /// get SpdmStatus structure from u32 value
    pub fn from_u32(status: u32) -> Option<Self> {
        Self::read_bytes(&status.to_le_bytes())
    }

    /// Returns true if severity is StatusSeverity::SUCCESS else it returns false.
    pub fn spdm_status_is_success(&self) -> bool {
        self.severity == StatusSeverity::SUCCESS
    }

    /// Returns true if severity is StatusSeverity::ERROR else it returns false.
    pub fn spdm_status_is_error(&self) -> bool {
        self.severity == StatusSeverity::ERROR
    }

    pub fn spdm_status_set_error_data(&mut self, error_data: &[u8]) {
        // Ensure the slice has no more data than SpdmErrorMessageData  capacity
        if error_data.len() <= SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH {
            let mut ed = SpdmErrorMessageData {
                length: error_data.len(),
                ..Default::default()
            };
            ed.data[..ed.length].copy_from_slice(error_data);
            self.error_data = Some(ed);
        } else {
            // Do not expect more data than SpdmErrorMessageData  capacity.
            self.error_data = None;
        }
    }
}

impl fmt::Display for SpdmStatus {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "Severity: {:?}, Status: {:?}, Code: {})",
            self.severity,
            self.status_code,
            self.get_u32()
        )
    }
}

#[macro_export]
macro_rules! spdm_return_status {
    ($severity:expr,  $status_code:expr) => {
        SpdmStatus {
            severity: $severity,
            status_code: $status_code,
            error_data: None,
        }
    };
}

use codec::{u24, Codec, Writer};
pub use spdm_return_status;

pub const SPDM_STATUS_SUCCESS: SpdmStatus =
    spdm_return_status!(StatusSeverity::SUCCESS, StatusCode::SUCCESS);

/* - Core Errors - */

/* The function input parameter is invalid. */
pub const SPDM_STATUS_INVALID_PARAMETER: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::INVALID_STATE_LOCAL)
);

/* Unable to complete operation due to unsupported capabilities by either the caller, the peer,
 * or both. */
pub const SPDM_STATUS_UNSUPPORTED_CAP: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::UNSUPPORTED_CAP)
);

/* Unable to complete operation due to caller's state. */
pub const SPDM_STATUS_INVALID_STATE_LOCAL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::INVALID_STATE_LOCAL)
);

/* Unable to complete operation due to peer's state. */
pub const SPDM_STATUS_INVALID_STATE_PEER: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::INVALID_STATE_PEER)
);

/* The received message contains one or more invalid message fields. */
pub const SPDM_STATUS_INVALID_MSG_FIELD: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::INVALID_MSG_FIELD)
);

/* The received message's size is invalid. */
pub const SPDM_STATUS_INVALID_MSG_SIZE: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::INVALID_MSG_SIZE)
);

/* Unable to derive a common set of versions, algorithms, etc. */
pub const SPDM_STATUS_NEGOTIATION_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::NEGOTIATION_FAIL)
);

/* Received a Busy error message. */
pub const SPDM_STATUS_BUSY_PEER: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::BUSY_PEER)
);

/* Received a NotReady error message. */
pub const SPDM_STATUS_NOT_READY_PEER: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::NOT_READY_PEER)
);

/* Received an unexpected error message. */
pub const SPDM_STATUS_ERROR_PEER: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::ERROR_PEER)
);

/* Received a RequestResynch error message. */
pub const SPDM_STATUS_RESYNCH_PEER: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::RESYNCH_PEER)
);

/* Unable to append new data to buffer due to resource exhaustion. */
pub const SPDM_STATUS_BUFFER_FULL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::BUFFER_FULL)
);

/* Unable to return data because caller does not provide big enough buffer. */
pub const SPDM_STATUS_BUFFER_TOO_SMALL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::BUFFER_TOO_SMALL)
);

/* Unable to allocate more session. */
pub const SPDM_STATUS_SESSION_NUMBER_EXCEED: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::SESSION_NUMBER_EXCEED)
);

/* Decrypt error from peer. */
pub const SPDM_STATUS_SESSION_MSG_ERROR: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::SESSION_MSG_ERROR)
);

/*  Unable to acquire resource. */
pub const SPDM_STATUS_ACQUIRE_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::ACQUIRE_FAIL)
);

/*  Re-triable decrypt error from peer - must rollback to backup keys. */
pub const SPDM_STATUS_SESSION_TRY_DISCARD_KEY_UPDATE: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::SESSION_TRY_DISCARD_KEY_UPDATE)
);

/*  Failed to decode AEAD. */
pub const SPDM_STATUS_DECODE_AEAD_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CORE(StatusCodeCore::DECODE_AEAD_FAIL)
);

/* - Cryptography Errors - */

/*  Generic failure originating from the cryptography module. */
pub const SPDM_STATUS_CRYPTO_ERROR: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CRYPTO(StatusCodeCrypto::CRYPTO_ERROR)
);

/*  Verification of the provided signature digest, signature, or AEAD tag failed. */
pub const SPDM_STATUS_VERIF_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CRYPTO(StatusCodeCrypto::VERIF_FAIL)
);

/*  AEAD sequence number overflow. */
pub const SPDM_STATUS_SEQUENCE_NUMBER_OVERFLOW: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CRYPTO(StatusCodeCrypto::SEQUENCE_NUMBER_OVERFLOW)
);

/*  Provided cert is valid but is not authoritative(mismatch the root cert). */
pub const SPDM_STATUS_VERIF_NO_AUTHORITY: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CRYPTO(StatusCodeCrypto::VERIF_NO_AUTHORITY)
);

/*  FIPS self test failed. */
pub const SPDM_STATUS_FIPS_SELF_TEST_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CRYPTO(StatusCodeCrypto::FIPS_SELF_TEST_FAIL)
);

/* - Certificate Parsing Errors - */

/*  Certificate is malformed or does not comply to x.509 standard. */
pub const SPDM_STATUS_INVALID_CERT: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::CERT_PARSE(StatusCodeCertParse::INVALID_CERT)
);

/* - Transport Errors - */

/*  Unable to send message to peer. */
pub const SPDM_STATUS_SEND_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::TRANSPORT(StatusCodeTransport::SEND_FAIL)
);

/*  Unable to receive message from peer. */
pub const SPDM_STATUS_RECEIVE_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::TRANSPORT(StatusCodeTransport::RECEIVE_FAIL)
);

/*  Unable to decap transport buffer. */
pub const SPDM_STATUS_DECAP_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::TRANSPORT(StatusCodeTransport::DECAP_FAIL)
);

/*  Unable to decap app buffer. */
pub const SPDM_STATUS_DECAP_APP_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::TRANSPORT(StatusCodeTransport::DECAP_APP_FAIL)
);

/*  Unable to encap transport buffer. */
pub const SPDM_STATUS_ENCAP_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::TRANSPORT(StatusCodeTransport::ENCAP_FAIL)
);

/*  Unable to encap app buffer. */
pub const SPDM_STATUS_ENCAP_APP_FAIL: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::TRANSPORT(StatusCodeTransport::ENCAP_APP_FAIL)
);

/* - Measurement Collection Errors - */

/*  Unable to collect measurement because of invalid index. */
pub const SPDM_STATUS_MEAS_INVALID_INDEX: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::MEAS_COLLECT(StatusCodeMeasCollect::MEAS_INVALID_INDEX)
);

/*  Unable to collect measurement because of internal error. */
pub const SPDM_STATUS_MEAS_INTERNAL_ERROR: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::MEAS_COLLECT(StatusCodeMeasCollect::MEAS_INTERNAL_ERROR)
);

/* - Random Number Generation Errors - */

/*  Unable to produce random number due to lack of entropy. */
pub const SPDM_STATUS_LOW_ENTROPY: SpdmStatus = spdm_return_status!(
    StatusSeverity::ERROR,
    StatusCode::RNG(StatusCodeRNG::LOW_ENTROPY)
);

#[macro_export]
macro_rules! SPDM_STATUS_VDM_DEFINED_ERROR {
    ($vdm_error_code:expr) => {
        SpdmStatus {
            severity: StatusSeverity::ERROR,
            status_code: StatusCode::VDM(StatusCodeVdmError {
                vdm_error_code: $vdm_error_code,
            }),
            error_data: None,
        };
    };
}

pub type SpdmResult<T = ()> = core::result::Result<T, SpdmStatus>;

Coverage Report

Created: 2026-09-14 06:27

Line	Count	Source
1		// Copyright (c) 2023 Intel Corporation
2		//
3		// SPDX-License-Identifier: Apache-2.0 or MIT
4
5		use core::{
6		convert::{TryFrom, TryInto},
7		fmt::{self, Debug},
8		};
9
10		/// Reference: https://github.com/DMTF/libspdm/blob/main/include/library/spdm_return_status.h
11		#[repr(u8)]
12		#[allow(dead_code)]
13		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
14		pub enum StatusSeverity {
15		SUCCESS = 0,
16		#[default]
17		ERROR = 8,
18		}
19
20		impl TryFrom<u8> for StatusSeverity {
21		type Error = ();
22
23	0	fn try_from(value: u8) -> core::result::Result<Self, Self::Error> {
24	0	match value {
25	0	0 => Ok(Self::SUCCESS),
26	0	8 => Ok(Self::ERROR),
27	0	_ => Err(()),
28		}
29	0	}
30		}
31
32		#[repr(u16)]
33		#[allow(dead_code)]
34		#[allow(non_camel_case_types)]
35		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
36		pub enum StatusCodeCore {
37		SUCCESS = 0,
38		#[default]
39		INVALID_PARAMETER = 1,
40		UNSUPPORTED_CAP = 2,
41		INVALID_STATE_LOCAL = 3,
42		INVALID_STATE_PEER = 4,
43		INVALID_MSG_FIELD = 5,
44		INVALID_MSG_SIZE = 6,
45		NEGOTIATION_FAIL = 7,
46		BUSY_PEER = 8,
47		NOT_READY_PEER = 9,
48		ERROR_PEER = 10,
49		RESYNCH_PEER = 11,
50		BUFFER_FULL = 12,
51		BUFFER_TOO_SMALL = 13,
52		SESSION_NUMBER_EXCEED = 14,
53		SESSION_MSG_ERROR = 15,
54		ACQUIRE_FAIL = 16,
55		SESSION_TRY_DISCARD_KEY_UPDATE = 17,
56
57		// only in spdm-rs
58		DECODE_AEAD_FAIL = 0xFE,
59		}
60
61		impl TryFrom<u16> for StatusCodeCore {
62		type Error = ();
63
64	0	fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
65	0	match value {
66	0	0 => Ok(Self::SUCCESS),
67	0	1 => Ok(Self::INVALID_PARAMETER),
68	0	2 => Ok(Self::UNSUPPORTED_CAP),
69	0	3 => Ok(Self::INVALID_STATE_LOCAL),
70	0	4 => Ok(Self::INVALID_STATE_PEER),
71	0	5 => Ok(Self::INVALID_MSG_FIELD),
72	0	6 => Ok(Self::INVALID_MSG_SIZE),
73	0	7 => Ok(Self::NEGOTIATION_FAIL),
74	0	8 => Ok(Self::BUSY_PEER),
75	0	9 => Ok(Self::NOT_READY_PEER),
76	0	10 => Ok(Self::ERROR_PEER),
77	0	11 => Ok(Self::RESYNCH_PEER),
78	0	12 => Ok(Self::BUFFER_FULL),
79	0	13 => Ok(Self::BUFFER_TOO_SMALL),
80	0	14 => Ok(Self::SESSION_NUMBER_EXCEED),
81	0	15 => Ok(Self::SESSION_MSG_ERROR),
82	0	16 => Ok(Self::ACQUIRE_FAIL),
83	0	17 => Ok(Self::SESSION_TRY_DISCARD_KEY_UPDATE),
84	0	0xFE => Ok(Self::DECODE_AEAD_FAIL),
85	0	_ => Err(()),
86		}
87	0	}
88		}
89
90		#[repr(u16)]
91		#[allow(dead_code)]
92		#[allow(non_camel_case_types)]
93		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
94		pub enum StatusCodeCrypto {
95		#[default]
96		CRYPTO_ERROR = 0,
97		VERIF_FAIL = 1,
98		SEQUENCE_NUMBER_OVERFLOW = 2,
99		VERIF_NO_AUTHORITY = 3,
100		FIPS_SELF_TEST_FAIL = 4,
101		}
102
103		impl TryFrom<u16> for StatusCodeCrypto {
104		type Error = ();
105
106	0	fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
107	0	match value {
108	0	0 => Ok(Self::CRYPTO_ERROR),
109	0	1 => Ok(Self::VERIF_FAIL),
110	0	2 => Ok(Self::SEQUENCE_NUMBER_OVERFLOW),
111	0	3 => Ok(Self::VERIF_NO_AUTHORITY),
112	0	4 => Ok(Self::FIPS_SELF_TEST_FAIL),
113	0	_ => Err(()),
114		}
115	0	}
116		}
117
118		#[repr(u16)]
119		#[allow(dead_code)]
120		#[allow(non_camel_case_types)]
121		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
122		pub enum StatusCodeCertParse {
123		#[default]
124		INVALID_CERT = 0,
125		}
126
127		impl TryFrom<u16> for StatusCodeCertParse {
128		type Error = ();
129
130	0	fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
131	0	match value {
132	0	0 => Ok(Self::INVALID_CERT),
133	0	_ => Err(()),
134		}
135	0	}
136		}
137
138		#[repr(u16)]
139		#[allow(dead_code)]
140		#[allow(non_camel_case_types)]
141		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
142		pub enum StatusCodeTransport {
143		#[default]
144		SEND_FAIL = 0,
145		RECEIVE_FAIL = 1,
146
147		// only in spdm-rs
148		DECAP_FAIL = 0xFE,
149		DECAP_APP_FAIL = 0xFD,
150		ENCAP_FAIL = 0xFC,
151		ENCAP_APP_FAIL = 0xFB,
152		}
153
154		impl TryFrom<u16> for StatusCodeTransport {
155		type Error = ();
156
157	0	fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
158	0	match value {
159	0	0 => Ok(Self::SEND_FAIL),
160	0	1 => Ok(Self::RECEIVE_FAIL),
161	0	0xFE => Ok(Self::DECAP_FAIL),
162	0	0xFD => Ok(Self::DECAP_APP_FAIL),
163	0	0xFC => Ok(Self::ENCAP_FAIL),
164	0	0xFB => Ok(Self::ENCAP_APP_FAIL),
165	0	_ => Err(()),
166		}
167	0	}
168		}
169
170		#[repr(u16)]
171		#[allow(dead_code)]
172		#[allow(non_camel_case_types)]
173		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
174		pub enum StatusCodeMeasCollect {
175		MEAS_INVALID_INDEX = 0,
176		#[default]
177		MEAS_INTERNAL_ERROR = 1,
178		}
179
180		impl TryFrom<u16> for StatusCodeMeasCollect {
181		type Error = ();
182
183	0	fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
184	0	match value {
185	0	0 => Ok(Self::MEAS_INVALID_INDEX),
186	0	1 => Ok(Self::MEAS_INTERNAL_ERROR),
187	0	_ => Err(()),
188		}
189	0	}
190		}
191
192		#[repr(u16)]
193		#[allow(dead_code)]
194		#[allow(non_camel_case_types)]
195		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
196		pub enum StatusCodeRNG {
197		#[default]
198		LOW_ENTROPY = 0,
199		}
200
201		impl TryFrom<u16> for StatusCodeRNG {
202		type Error = ();
203
204	0	fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
205	0	match value {
206	0	0 => Ok(Self::LOW_ENTROPY),
207	0	_ => Err(()),
208		}
209	0	}
210		}
211
212		#[allow(dead_code)]
213		#[allow(non_camel_case_types)]
214		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default)]
215		pub struct StatusCodeVdmError {
216		pub vdm_error_code: u16,
217		}
218
219		impl TryFrom<u16> for StatusCodeVdmError {
220		type Error = ();
221
222	0	fn try_from(value: u16) -> core::result::Result<Self, Self::Error> {
223	0	Ok(Self {
224	0	vdm_error_code: value,
225	0	})
226	0	}
227		}
228
229		#[allow(dead_code)]
230		#[allow(non_camel_case_types)]
231		#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
232		pub enum StatusCode {
233		SUCCESS,
234		CORE(StatusCodeCore),
235		CRYPTO(StatusCodeCrypto),
236		CERT_PARSE(StatusCodeCertParse),
237		TRANSPORT(StatusCodeTransport),
238		MEAS_COLLECT(StatusCodeMeasCollect),
239		RNG(StatusCodeRNG),
240		VDM(StatusCodeVdmError),
241		}
242
243		impl Default for StatusCode {
244	0	fn default() -> Self {
245	0	Self::CORE(StatusCodeCore::default())
246	0	}
247		}
248
249		impl TryFrom<u24> for StatusCode {
250		type Error = ();
251
252	0	fn try_from(value: u24) -> core::result::Result<Self, Self::Error> {
253	0	let source: u8 = ((value.get() & 0xFF_00_00) >> 16) as u8;
254	0	let code: u16 = (value.get() & 0x00_00_FF_FF) as u16;
255	0	match source {
256	0	0 => Ok(StatusCode::SUCCESS),
257	0	1 => Ok(StatusCode::CORE(StatusCodeCore::try_from(code)?)),
258	0	2 => Ok(StatusCode::CRYPTO(StatusCodeCrypto::try_from(code)?)),
259	0	3 => Ok(StatusCode::CERT_PARSE(StatusCodeCertParse::try_from(code)?)),
260	0	4 => Ok(StatusCode::TRANSPORT(StatusCodeTransport::try_from(code)?)),
261	0	5 => Ok(StatusCode::MEAS_COLLECT(StatusCodeMeasCollect::try_from(
262	0	code,
263	0	)?)),
264	0	6 => Ok(StatusCode::RNG(StatusCodeRNG::try_from(code)?)),
265	0	7 => Ok(StatusCode::VDM(StatusCodeVdmError::try_from(code)?)),
266	0	_ => Err(()),
267		}
268	0	}
269		}
270
271		impl TryInto<u24> for StatusCode {
272		type Error = ();
273
274	0	fn try_into(self) -> Result<u24, Self::Error> {
275	0	match self {
276	0	StatusCode::SUCCESS => Ok(u24::new(0)),
277	0	StatusCode::CORE(c) => Ok(u24::new((1 << 16) as u32 + (c as u16) as u32)),
278	0	StatusCode::CRYPTO(c) => Ok(u24::new((2 << 16) as u32 + (c as u16) as u32)),
279	0	StatusCode::CERT_PARSE(c) => Ok(u24::new((3 << 16) as u32 + (c as u16) as u32)),
280	0	StatusCode::TRANSPORT(t) => Ok(u24::new((4 << 16) as u32 + (t as u16) as u32)),
281	0	StatusCode::MEAS_COLLECT(m) => Ok(u24::new((5 << 16) as u32 + (m as u16) as u32)),
282	0	StatusCode::RNG(r) => Ok(u24::new((6 << 16) as u32 + (r as u16) as u32)),
283	0	StatusCode::VDM(v) => Ok(u24::new((7 << 16) as u32 + (v.vdm_error_code) as u32)),
284		}
285	0	}
286		}
287
288		pub const SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH: usize = 36; // "SPDM error response message format":
289		// 'SPDMVersion' (1B) +
290		// 'RequestResponseCode' (1B) +
291		// 'Param1' (1B) +
292		// 'Param1' (1B) +
293		// 'ExtendedErrorData' (0-32B)
294		#[derive(Copy, Clone, Debug, PartialEq, Eq)]
295		pub struct SpdmErrorMessageData {
296		pub length: usize,
297		pub data: [u8; SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH],
298		}
299		impl Default for SpdmErrorMessageData {
300	0	fn default() -> Self {
301	0	SpdmErrorMessageData {
302	0	length: Default::default(),
303	0	data: [Default::default(); SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH],
304	0	}
305	0	}
306		}
307
308		#[derive(Copy, Clone, Debug, Eq, Default)]
309		pub struct SpdmStatus {
310		pub severity: StatusSeverity,
311		pub status_code: StatusCode,
312		pub error_data: Option<SpdmErrorMessageData>,
313		}
314		impl PartialEq for SpdmStatus {
315	0	fn eq(&self, other: &Self) -> bool {
316		// SpdmStatus with same serverity and status_code but different error_data shall be
317		// considered as same SpdmStatus.
318		// Thus, do not care about the error_data here.
319	0	self.severity == other.severity && self.status_code == other.status_code
320	0	}
321		}
322
323		impl Codec for SpdmStatus {
324	0	fn encode(&self, bytes: &mut codec::Writer) -> Result<usize, codec::EncodeErr> {
325	0	let mut sc = 0u32;
326	0	sc += (((self.severity as u8) & 0x0F) as u32) << 28;
327	0	sc += <StatusCode as TryInto<u24>>::try_into(self.status_code)
328	0	.map_err(\|_\| codec::EncodeErr)?
329	0	.get();
330	0	sc.encode(bytes)?;
331	0	Ok(4)
332	0	}
333
334	0	fn read(r: &mut codec::Reader) -> Option<Self> {
335	0	let sc = u32::read(r)?;
336	0	let severity = ((sc & 0xF0_00_00_00) >> 28) as u8;
337	0	let severity = StatusSeverity::try_from(severity).ok()?;
338	0	if (sc & 0x0F_00_00_00) != 0 {
339	0	return None; //the reserve field
340	0	}
341	0	let status_code = u24::new(sc & 0x00_FF_FF_FF);
342	0	let status_code = StatusCode::try_from(status_code).ok()?;
343
344	0	Some(Self {
345	0	severity,
346	0	status_code,
347	0	error_data: None,
348	0	})
349	0	}
350		}
351
352		impl SpdmStatus {
353		/// return the u32 encoding
354	0	pub fn get_u32(&self) -> u32 {
355	0	let mut r = [0u8; 4];
356	0	let _ = self.encode(&mut Writer::init(&mut r));
357	0	u32::from_le_bytes(r)
358	0	}
359
360		/// get SpdmStatus structure from u32 value
361	0	pub fn from_u32(status: u32) -> Option<Self> {
362	0	Self::read_bytes(&status.to_le_bytes())
363	0	}
364
365		/// Returns true if severity is StatusSeverity::SUCCESS else it returns false.
366	0	pub fn spdm_status_is_success(&self) -> bool {
367	0	self.severity == StatusSeverity::SUCCESS
368	0	}
369
370		/// Returns true if severity is StatusSeverity::ERROR else it returns false.
371	0	pub fn spdm_status_is_error(&self) -> bool {
372	0	self.severity == StatusSeverity::ERROR
373	0	}
374
375	0	pub fn spdm_status_set_error_data(&mut self, error_data: &[u8]) {
376		// Ensure the slice has no more data than SpdmErrorMessageData capacity
377	0	if error_data.len() <= SPDM_ERROR_MESSAGE_DATA_MAX_LENGTH {
378	0	let mut ed = SpdmErrorMessageData {
379	0	length: error_data.len(),
380	0	..Default::default()
381	0	};
382	0	ed.data[..ed.length].copy_from_slice(error_data);
383	0	self.error_data = Some(ed);
384	0	} else {
385	0	// Do not expect more data than SpdmErrorMessageData capacity.
386	0	self.error_data = None;
387	0	}
388	0	}
389		}
390
391		impl fmt::Display for SpdmStatus {
392	0	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
393	0	write!(
394	0	f,
395	0	"Severity: {:?}, Status: {:?}, Code: {})",
396		self.severity,
397		self.status_code,
398	0	self.get_u32()
399		)
400	0	}
401		}
402
403		#[macro_export]
404		macro_rules! spdm_return_status {
405		($severity:expr, $status_code:expr) => {
406		SpdmStatus {
407		severity: $severity,
408		status_code: $status_code,
409		error_data: None,
410		}
411		};
412		}
413
414		use codec::{u24, Codec, Writer};
415		pub use spdm_return_status;
416
417		pub const SPDM_STATUS_SUCCESS: SpdmStatus =
418		spdm_return_status!(StatusSeverity::SUCCESS, StatusCode::SUCCESS);
419
420		/* - Core Errors - */
421
422		/* The function input parameter is invalid. */
423		pub const SPDM_STATUS_INVALID_PARAMETER: SpdmStatus = spdm_return_status!(
424		StatusSeverity::ERROR,
425		StatusCode::CORE(StatusCodeCore::INVALID_STATE_LOCAL)
426		);
427
428		/* Unable to complete operation due to unsupported capabilities by either the caller, the peer,
429		* or both. */
430		pub const SPDM_STATUS_UNSUPPORTED_CAP: SpdmStatus = spdm_return_status!(
431		StatusSeverity::ERROR,
432		StatusCode::CORE(StatusCodeCore::UNSUPPORTED_CAP)
433		);
434
435		/* Unable to complete operation due to caller's state. */
436		pub const SPDM_STATUS_INVALID_STATE_LOCAL: SpdmStatus = spdm_return_status!(
437		StatusSeverity::ERROR,
438		StatusCode::CORE(StatusCodeCore::INVALID_STATE_LOCAL)
439		);
440
441		/* Unable to complete operation due to peer's state. */
442		pub const SPDM_STATUS_INVALID_STATE_PEER: SpdmStatus = spdm_return_status!(
443		StatusSeverity::ERROR,
444		StatusCode::CORE(StatusCodeCore::INVALID_STATE_PEER)
445		);
446
447		/* The received message contains one or more invalid message fields. */
448		pub const SPDM_STATUS_INVALID_MSG_FIELD: SpdmStatus = spdm_return_status!(
449		StatusSeverity::ERROR,
450		StatusCode::CORE(StatusCodeCore::INVALID_MSG_FIELD)
451		);
452
453		/* The received message's size is invalid. */
454		pub const SPDM_STATUS_INVALID_MSG_SIZE: SpdmStatus = spdm_return_status!(
455		StatusSeverity::ERROR,
456		StatusCode::CORE(StatusCodeCore::INVALID_MSG_SIZE)
457		);
458
459		/* Unable to derive a common set of versions, algorithms, etc. */
460		pub const SPDM_STATUS_NEGOTIATION_FAIL: SpdmStatus = spdm_return_status!(
461		StatusSeverity::ERROR,
462		StatusCode::CORE(StatusCodeCore::NEGOTIATION_FAIL)
463		);
464
465		/* Received a Busy error message. */
466		pub const SPDM_STATUS_BUSY_PEER: SpdmStatus = spdm_return_status!(
467		StatusSeverity::ERROR,
468		StatusCode::CORE(StatusCodeCore::BUSY_PEER)
469		);
470
471		/* Received a NotReady error message. */
472		pub const SPDM_STATUS_NOT_READY_PEER: SpdmStatus = spdm_return_status!(
473		StatusSeverity::ERROR,
474		StatusCode::CORE(StatusCodeCore::NOT_READY_PEER)
475		);
476
477		/* Received an unexpected error message. */
478		pub const SPDM_STATUS_ERROR_PEER: SpdmStatus = spdm_return_status!(
479		StatusSeverity::ERROR,
480		StatusCode::CORE(StatusCodeCore::ERROR_PEER)
481		);
482
483		/* Received a RequestResynch error message. */
484		pub const SPDM_STATUS_RESYNCH_PEER: SpdmStatus = spdm_return_status!(
485		StatusSeverity::ERROR,
486		StatusCode::CORE(StatusCodeCore::RESYNCH_PEER)
487		);
488
489		/* Unable to append new data to buffer due to resource exhaustion. */
490		pub const SPDM_STATUS_BUFFER_FULL: SpdmStatus = spdm_return_status!(
491		StatusSeverity::ERROR,
492		StatusCode::CORE(StatusCodeCore::BUFFER_FULL)
493		);
494
495		/* Unable to return data because caller does not provide big enough buffer. */
496		pub const SPDM_STATUS_BUFFER_TOO_SMALL: SpdmStatus = spdm_return_status!(
497		StatusSeverity::ERROR,
498		StatusCode::CORE(StatusCodeCore::BUFFER_TOO_SMALL)
499		);
500
501		/* Unable to allocate more session. */
502		pub const SPDM_STATUS_SESSION_NUMBER_EXCEED: SpdmStatus = spdm_return_status!(
503		StatusSeverity::ERROR,
504		StatusCode::CORE(StatusCodeCore::SESSION_NUMBER_EXCEED)
505		);
506
507		/* Decrypt error from peer. */
508		pub const SPDM_STATUS_SESSION_MSG_ERROR: SpdmStatus = spdm_return_status!(
509		StatusSeverity::ERROR,
510		StatusCode::CORE(StatusCodeCore::SESSION_MSG_ERROR)
511		);
512
513		/* Unable to acquire resource. */
514		pub const SPDM_STATUS_ACQUIRE_FAIL: SpdmStatus = spdm_return_status!(
515		StatusSeverity::ERROR,
516		StatusCode::CORE(StatusCodeCore::ACQUIRE_FAIL)
517		);
518
519		/* Re-triable decrypt error from peer - must rollback to backup keys. */
520		pub const SPDM_STATUS_SESSION_TRY_DISCARD_KEY_UPDATE: SpdmStatus = spdm_return_status!(
521		StatusSeverity::ERROR,
522		StatusCode::CORE(StatusCodeCore::SESSION_TRY_DISCARD_KEY_UPDATE)
523		);
524
525		/* Failed to decode AEAD. */
526		pub const SPDM_STATUS_DECODE_AEAD_FAIL: SpdmStatus = spdm_return_status!(
527		StatusSeverity::ERROR,
528		StatusCode::CORE(StatusCodeCore::DECODE_AEAD_FAIL)
529		);
530
531		/* - Cryptography Errors - */
532
533		/* Generic failure originating from the cryptography module. */
534		pub const SPDM_STATUS_CRYPTO_ERROR: SpdmStatus = spdm_return_status!(
535		StatusSeverity::ERROR,
536		StatusCode::CRYPTO(StatusCodeCrypto::CRYPTO_ERROR)
537		);
538
539		/* Verification of the provided signature digest, signature, or AEAD tag failed. */
540		pub const SPDM_STATUS_VERIF_FAIL: SpdmStatus = spdm_return_status!(
541		StatusSeverity::ERROR,
542		StatusCode::CRYPTO(StatusCodeCrypto::VERIF_FAIL)
543		);
544
545		/* AEAD sequence number overflow. */
546		pub const SPDM_STATUS_SEQUENCE_NUMBER_OVERFLOW: SpdmStatus = spdm_return_status!(
547		StatusSeverity::ERROR,
548		StatusCode::CRYPTO(StatusCodeCrypto::SEQUENCE_NUMBER_OVERFLOW)
549		);
550
551		/* Provided cert is valid but is not authoritative(mismatch the root cert). */
552		pub const SPDM_STATUS_VERIF_NO_AUTHORITY: SpdmStatus = spdm_return_status!(
553		StatusSeverity::ERROR,
554		StatusCode::CRYPTO(StatusCodeCrypto::VERIF_NO_AUTHORITY)
555		);
556
557		/* FIPS self test failed. */
558		pub const SPDM_STATUS_FIPS_SELF_TEST_FAIL: SpdmStatus = spdm_return_status!(
559		StatusSeverity::ERROR,
560		StatusCode::CRYPTO(StatusCodeCrypto::FIPS_SELF_TEST_FAIL)
561		);
562
563		/* - Certificate Parsing Errors - */
564
565		/* Certificate is malformed or does not comply to x.509 standard. */
566		pub const SPDM_STATUS_INVALID_CERT: SpdmStatus = spdm_return_status!(
567		StatusSeverity::ERROR,
568		StatusCode::CERT_PARSE(StatusCodeCertParse::INVALID_CERT)
569		);
570
571		/* - Transport Errors - */
572
573		/* Unable to send message to peer. */
574		pub const SPDM_STATUS_SEND_FAIL: SpdmStatus = spdm_return_status!(
575		StatusSeverity::ERROR,
576		StatusCode::TRANSPORT(StatusCodeTransport::SEND_FAIL)
577		);
578
579		/* Unable to receive message from peer. */
580		pub const SPDM_STATUS_RECEIVE_FAIL: SpdmStatus = spdm_return_status!(
581		StatusSeverity::ERROR,
582		StatusCode::TRANSPORT(StatusCodeTransport::RECEIVE_FAIL)
583		);
584
585		/* Unable to decap transport buffer. */
586		pub const SPDM_STATUS_DECAP_FAIL: SpdmStatus = spdm_return_status!(
587		StatusSeverity::ERROR,
588		StatusCode::TRANSPORT(StatusCodeTransport::DECAP_FAIL)
589		);
590
591		/* Unable to decap app buffer. */
592		pub const SPDM_STATUS_DECAP_APP_FAIL: SpdmStatus = spdm_return_status!(
593		StatusSeverity::ERROR,
594		StatusCode::TRANSPORT(StatusCodeTransport::DECAP_APP_FAIL)
595		);
596
597		/* Unable to encap transport buffer. */
598		pub const SPDM_STATUS_ENCAP_FAIL: SpdmStatus = spdm_return_status!(
599		StatusSeverity::ERROR,
600		StatusCode::TRANSPORT(StatusCodeTransport::ENCAP_FAIL)
601		);
602
603		/* Unable to encap app buffer. */
604		pub const SPDM_STATUS_ENCAP_APP_FAIL: SpdmStatus = spdm_return_status!(
605		StatusSeverity::ERROR,
606		StatusCode::TRANSPORT(StatusCodeTransport::ENCAP_APP_FAIL)
607		);
608
609		/* - Measurement Collection Errors - */
610
611		/* Unable to collect measurement because of invalid index. */
612		pub const SPDM_STATUS_MEAS_INVALID_INDEX: SpdmStatus = spdm_return_status!(
613		StatusSeverity::ERROR,
614		StatusCode::MEAS_COLLECT(StatusCodeMeasCollect::MEAS_INVALID_INDEX)
615		);
616
617		/* Unable to collect measurement because of internal error. */
618		pub const SPDM_STATUS_MEAS_INTERNAL_ERROR: SpdmStatus = spdm_return_status!(
619		StatusSeverity::ERROR,
620		StatusCode::MEAS_COLLECT(StatusCodeMeasCollect::MEAS_INTERNAL_ERROR)
621		);
622
623		/* - Random Number Generation Errors - */
624
625		/* Unable to produce random number due to lack of entropy. */
626		pub const SPDM_STATUS_LOW_ENTROPY: SpdmStatus = spdm_return_status!(
627		StatusSeverity::ERROR,
628		StatusCode::RNG(StatusCodeRNG::LOW_ENTROPY)
629		);
630
631		#[macro_export]
632		macro_rules! SPDM_STATUS_VDM_DEFINED_ERROR {
633		($vdm_error_code:expr) => {
634		SpdmStatus {
635		severity: StatusSeverity::ERROR,
636		status_code: StatusCode::VDM(StatusCodeVdmError {
637		vdm_error_code: $vdm_error_code,
638		}),
639		error_data: None,
640		};
641		};
642		}
643
644		pub type SpdmResult<T = ()> = core::result::Result<T, SpdmStatus>;