tdx-quote 0.0.5

Parses and verifies Intel TDX quotes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use core::{
    error::Error,
    fmt::{self, Display},
    num::TryFromIntError,
};

/// An error when parsing a quote
#[derive(Debug, Eq, PartialEq)]
pub enum QuoteParseError {
    Parse,
    Verification,
    UnknownCertificationDataType,
    UnknownQuoteVersion,
    IntConversionError,
    UnsupportedAttestationKeyType,
    AttestationKeyDoesNotMatch,
}

impl Display for QuoteParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            QuoteParseError::Parse => f.write_str("Cannot parse quote"),
            QuoteParseError::Verification => f.write_str("Signature is invalid"),
            QuoteParseError::UnknownCertificationDataType => {
                f.write_str("Unknown certification data type")
            }
            QuoteParseError::UnknownQuoteVersion => f.write_str("Unknown quote version"),
            QuoteParseError::IntConversionError => f.write_str("Integer conversion error"),
            QuoteParseError::UnsupportedAttestationKeyType => {
                f.write_str("Unsupported attestion key type")
            }
            QuoteParseError::AttestationKeyDoesNotMatch => {
                f.write_str("Attestation key does not match hash in QE report")
            }
        }
    }
}

impl From<nom::Err<nom::error::Error<&[u8]>>> for QuoteParseError {
    fn from(_: nom::Err<nom::error::Error<&[u8]>>) -> QuoteParseError {
        QuoteParseError::Parse
    }
}

impl From<p256::ecdsa::Error> for QuoteParseError {
    fn from(_: p256::ecdsa::Error) -> QuoteParseError {
        QuoteParseError::Verification
    }
}

impl From<TryFromIntError> for QuoteParseError {
    fn from(_: TryFromIntError) -> QuoteParseError {
        QuoteParseError::IntConversionError
    }
}

impl Error for QuoteParseError {}

/// An error when verifying a quote with a provisioning certification key (PCK)
#[derive(Debug, Eq, PartialEq)]
pub enum QuoteVerificationError {
    NoQeReportCertificationData,
    BadSignature,
    NoPckCertChain,
    #[cfg(feature = "pck")]
    PckParseVerify(crate::pck::PckParseVerifyError),
}

impl Display for QuoteVerificationError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            QuoteVerificationError::NoQeReportCertificationData => {
                f.write_str("Quote has no QE report certification data")
            }
            QuoteVerificationError::BadSignature => {
                f.write_str("Quote signature verification failed")
            }
            QuoteVerificationError::NoPckCertChain => {
                f.write_str("Quote has no PCK certificate chain")
            }
            #[cfg(feature = "pck")]
            QuoteVerificationError::PckParseVerify(error) => {
                write!(f, "PCK certificate: {error}")
            }
        }
    }
}

impl From<p256::ecdsa::Error> for QuoteVerificationError {
    fn from(_: p256::ecdsa::Error) -> QuoteVerificationError {
        QuoteVerificationError::BadSignature
    }
}

#[cfg(feature = "pck")]
impl From<crate::pck::PckParseVerifyError> for QuoteVerificationError {
    fn from(error: crate::pck::PckParseVerifyError) -> QuoteVerificationError {
        QuoteVerificationError::PckParseVerify(error)
    }
}

impl Error for QuoteVerificationError {}

/// An error when handling a verifying key
#[derive(Debug, Eq, PartialEq)]
pub enum VerifyingKeyError {
    DecodeEncodedPoint,
    EncodedPointToVerifyingKey,
    BadSize,
}

impl Display for VerifyingKeyError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            VerifyingKeyError::DecodeEncodedPoint => {
                f.write_str("Could not decode to encoded point")
            }
            VerifyingKeyError::EncodedPointToVerifyingKey => {
                f.write_str("Could not convert encoded point to verifying key")
            }
            VerifyingKeyError::BadSize => f.write_str("Compressed point has unexpected size"),
        }
    }
}

impl Error for VerifyingKeyError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        None
    }
}