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

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

use intel_dcap_api::{ApiClient, CaType, CrlEncoding, IntelApiError, PckCrlResponse};
use x509_cert::{
    der::{oid::AssociatedOid, Decode, SliceReader},
    ext::pkix::{
        crl::dp::DistributionPoint,
        name::{DistributionPointName, GeneralName},
        CrlDistributionPoints,
    },
};

#[tokio::main]
async fn main() -> Result<(), IntelApiError> {
    let client = ApiClient::new()?;

    let PckCrlResponse {
        crl_data,
        issuer_chain,
    } = client
        .get_pck_crl(CaType::Platform, Some(CrlEncoding::Der))
        .await?;

    let certs = x509_cert::certificate::CertificateInner::<
        x509_cert::certificate::Rfc5280
    >::load_pem_chain(issuer_chain.as_bytes()).map_err(
        |_| IntelApiError::InvalidParameter("Could not load a PEM chain")
    )?;

    for cert in certs {
        println!("Issuer: {}", cert.tbs_certificate.issuer);
        println!("Subject: {}", cert.tbs_certificate.subject);
        println!("Serial Number: {}", cert.tbs_certificate.serial_number);
        println!("Not Before: {}", cert.tbs_certificate.validity.not_before);
        println!("Not After: {}", cert.tbs_certificate.validity.not_after);

        // Extract and print CRL distribution points
        if let Some(extensions) = &cert.tbs_certificate.extensions {
            for ext in extensions.iter() {
                if ext.extn_id == CrlDistributionPoints::OID {
                    // Create a SliceReader from the byte slice
                    let mut reader = SliceReader::new(ext.extn_value.as_bytes()).map_err(|_| {
                        IntelApiError::InvalidParameter(
                            "Could not create reader from extension value",
                        )
                    })?;

                    // Now pass the reader to decode_value
                    if let Ok(dist_points) = Vec::<DistributionPoint>::decode(&mut reader) {
                        for point in dist_points {
                            if let Some(DistributionPointName::FullName(names)) =
                                point.distribution_point
                            {
                                for name in names {
                                    if let GeneralName::UniformResourceIdentifier(uri) = name {
                                        let uri = uri.as_str();
                                        let crl_bytes = reqwest::get(uri).await?.bytes().await?;
                                        println!("CRL bytes (hex): {}", hex::encode(&crl_bytes));
                                    }
                                }
                            }
                        }
                    } else {
                        println!("Could not decode CRL distribution points");
                    }
                }
            }
        }
    }

    println!("CRL bytes (hex): {}", hex::encode(&crl_data));

    Ok(())
}