intel-dcap-api 0.6.0

Intel DCAP API Client
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2025 Matter Labs

use std::fmt;

/// Represents the type of Certificate Authority (CA) for Intel Trusted Services.
///
/// This enum defines the different types of Certificate Authorities used in the Intel DCAP API,
/// specifically distinguishing between processor and platform CAs.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CaType {
    /// Represents a processor-specific Certificate Authority.
    Processor,
    /// Represents a platform-wide Certificate Authority.
    Platform,
}

impl fmt::Display for CaType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CaType::Processor => write!(f, "processor"),
            CaType::Platform => write!(f, "platform"),
        }
    }
}

/// Represents the encoding format for Certificate Revocation Lists (CRLs).
///
/// This enum defines the supported encoding formats for CRLs in the Intel DCAP API,
/// distinguishing between PEM (Privacy Enhanced Mail) and DER (Distinguished Encoding Rules) formats.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CrlEncoding {
    /// Represents the PEM (Privacy Enhanced Mail) encoding format.
    Pem,
    /// Represents the DER (Distinguished Encoding Rules) encoding format.
    Der,
}

impl fmt::Display for CrlEncoding {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CrlEncoding::Pem => write!(f, "pem"),
            CrlEncoding::Der => write!(f, "der"),
        }
    }
}

/// Represents the type of update for Intel Trusted Services.
///
/// This enum defines different update types, distinguishing between early and standard updates
/// in the Intel DCAP (Data Center Attestation Primitives) API.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UpdateType {
    /// Represents early updates, typically used for preview or beta releases.
    Early,
    /// Represents standard updates, which are the regular release cycle.
    Standard,
}

impl fmt::Display for UpdateType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            UpdateType::Early => write!(f, "early"),
            UpdateType::Standard => write!(f, "standard"),
        }
    }
}

/// Represents the platform filter options for Intel DCAP (Data Center Attestation Primitives) API.
///
/// This enum allows filtering platforms based on different criteria,
/// such as selecting all platforms, client-specific platforms, or specific Intel processor generations.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PlatformFilter {
    /// Represents a selection of all available platforms.
    All,
    /// Represents a selection of client-specific platforms.
    Client,
    /// Represents platforms with Intel E3 processors.
    E3,
    /// Represents platforms with Intel E5 processors.
    E5,
}

impl fmt::Display for PlatformFilter {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PlatformFilter::All => write!(f, "all"),
            PlatformFilter::Client => write!(f, "client"),
            PlatformFilter::E3 => write!(f, "E3"),
            PlatformFilter::E5 => write!(f, "E5"),
        }
    }
}

/// Represents the version of the Intel Trusted Services API to target.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ApiVersion {
    /// Represents version 3 of the Intel Trusted Services API.
    V3,
    /// Represents version 4 of the Intel Trusted Services API.
    V4,
}

impl ApiVersion {
    /// Returns the string representation of the version for URL paths.
    pub fn path_segment(&self) -> &'static str {
        match self {
            ApiVersion::V3 => "v3",
            ApiVersion::V4 => "v4",
        }
    }
}

impl fmt::Display for ApiVersion {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ApiVersion::V3 => write!(f, "v3"),
            ApiVersion::V4 => write!(f, "v4"),
        }
    }
}