fix to apply snake case

Signed-off-by: Jun Kimura <jun.kimura@datachain.jp>

Author: bluele

crates/collaterals/src/lib.rs

@@ -4,6 +4,6 @@ pub mod enclave_identity;
 pub mod enclave_report;
 pub mod quote;
 pub mod sgx_extensions;
-pub mod tcbinfo;
+pub mod tcb_info;
 pub mod utils;
 pub use openssl;

crates/collaterals/src/tcbinfo.rs crates/collaterals/src/tcb_info.rscrates/collaterals/src/tcbinfo.rs renamed to crates/collaterals/src/tcb_info.rs

@@ -1,4 +1,4 @@
-use dcap_types::tcbinfo::{
+use dcap_types::tcb_info::{
     TcbComponent, TcbInfoV3, TcbInfoV3Inner, TcbInfoV3TcbLevel, TcbInfoV3TcbLevelItem, TdxModule,
     TdxModuleIdentities,
 };

crates/pcs/src/client.rs

@@ -75,7 +75,7 @@ impl PCSClient {
         let update_policy = self.update_policy();
 
         // get the TCB info of the platform
-        let (tcbinfo_json, sgx_tcb_signing_der) = {
+        let (tcb_info_json, sgx_tcb_signing_der) = {
             let fmspc = hex::encode_upper(sgx_extensions.fmspc);
             let res = http_get(format!(
                 "{base_url}/tcb?fmspc={fmspc}&update={update_policy}"
@@ -86,7 +86,7 @@ impl PCSClient {
         };
 
         // get the QE identity
-        let qeidentity_json = http_get(format!("{base_url}/qe/identity?update={update_policy}"))?
+        let qe_identity_json = http_get(format!("{base_url}/qe/identity?update={update_policy}"))?
             .bytes()?
             .to_vec();
 
@@ -111,8 +111,8 @@ impl PCSClient {
                 .to_vec();
 
         Ok(QvCollateral {
-            tcbinfo_json,
-            qeidentity_json,
+            tcb_info_json,
+            qe_identity_json,
             sgx_intel_root_ca_der: sgx_root_cert_der,
             sgx_tcb_signing_der,
             sgx_intel_root_ca_crl_der,

crates/quote-verifier/src/cert.rs

@@ -2,7 +2,7 @@ use crate::crypto::verify_p256_signature_der;
 use anyhow::bail;
 use core::str::FromStr;
 use dcap_types::cert::{SgxExtensionTcbLevel, SgxExtensions};
-use dcap_types::tcbinfo::{TcbComponent, TcbInfoV3};
+use dcap_types::tcb_info::{TcbComponent, TcbInfoV3};
 use dcap_types::TcbInfoV3TcbStatus;
 use dcap_types::{SGX_TEE_TYPE, TDX_TEE_TYPE};
 use x509_parser::prelude::*;
@@ -83,23 +83,23 @@ pub fn get_x509_issuer_cn(cert: &X509Certificate) -> String {
 /// * `tee_type` - The type of TEE (SGX or TDX)
 /// * `tee_tcb_svn` - The TCB SVN of the TEE (only for TDX)
 /// * `sgx_extensions` - The SGX Extensions from the PCK Certificate
-/// * `tcbinfov3` - The TCB Info V3
+/// * `tcb_info_v3` - The TCB Info V3
 /// # Returns
 /// * `(sgx_tcb_status, tdx_tcb_status, advisory_ids)` - The TCB status of the SGX and TDX, and the advisory IDs
 pub fn get_sgx_tdx_tcb_status_v3(
     tee_type: u32,
     tee_tcb_svn: Option<[u8; 16]>,
     sgx_extensions: &SgxExtensions,
-    tcbinfov3: &TcbInfoV3,
+    tcb_info_v3: &TcbInfoV3,
 ) -> crate::Result<(TcbInfoV3TcbStatus, Option<TcbInfoV3TcbStatus>, Vec<String>)> {
     if tee_type == SGX_TEE_TYPE {
-        if tcbinfov3.tcb_info.id != "SGX" {
+        if tcb_info_v3.tcb_info.id != "SGX" {
             bail!("Invalid TCB Info ID for SGX TEE Type");
         } else if tee_tcb_svn.is_some() {
             bail!("SGX TCB SVN is not needed");
         }
     } else if tee_type == TDX_TEE_TYPE {
-        if tcbinfov3.tcb_info.id != "TDX" {
+        if tcb_info_v3.tcb_info.id != "TDX" {
             bail!("Invalid TCB Info ID for TDX TEE Type");
         } else if tee_tcb_svn.is_none() {
             bail!("TDX TCB SVN is missing");
@@ -108,27 +108,27 @@ pub fn get_sgx_tdx_tcb_status_v3(
         bail!("Unsupported TEE type: {}", tee_type);
     }
 
-    if sgx_extensions.fmspc != tcbinfov3.tcb_info.fmspc()? {
+    if sgx_extensions.fmspc != tcb_info_v3.tcb_info.fmspc()? {
         // ref. https://github.com/intel/SGX-TDX-DCAP-QuoteVerificationLibrary/blob/812e0fa140a284b772b2d8b08583c761e23ec3b3/Src/AttestationLibrary/src/Verifiers/QuoteVerifier.cpp#L117
         bail!(
             "FMSPC does not match: {:x?} != {:x?}",
             sgx_extensions.fmspc,
-            tcbinfov3.tcb_info.fmspc()?
+            tcb_info_v3.tcb_info.fmspc()?
         );
-    } else if sgx_extensions.pceid != tcbinfov3.tcb_info.pce_id()? {
+    } else if sgx_extensions.pceid != tcb_info_v3.tcb_info.pce_id()? {
         // ref. https://github.com/intel/SGX-TDX-DCAP-QuoteVerificationLibrary/blob/812e0fa140a284b772b2d8b08583c761e23ec3b3/Src/AttestationLibrary/src/Verifiers/QuoteVerifier.cpp#L124
         bail!(
             "PCE ID does not match: {:x?} != {:x?}",
             sgx_extensions.pceid,
-            tcbinfov3.tcb_info.pce_id()?
+            tcb_info_v3.tcb_info.pce_id()?
         );
     }
 
     let mut sgx_tcb_status: Option<TcbInfoV3TcbStatus> = None;
     let tcb = &sgx_extensions.tcb;
     let extension_pcesvn = tcb.pcesvn;
 
-    for tcb_level in tcbinfov3.tcb_info.tcb_levels.iter() {
+    for tcb_level in tcb_info_v3.tcb_info.tcb_levels.iter() {
         if sgx_tcb_status.is_none()
             && match_sgxtcbcomp(tcb, &tcb_level.tcb.sgxtcbcomponents)
             && extension_pcesvn >= tcb_level.tcb.pcesvn

crates/quote-verifier/src/collateral.rs

@@ -1,6 +1,6 @@
 use anyhow::bail;
 use dcap_types::enclave_identity::EnclaveIdentityV2;
-use dcap_types::tcbinfo::TcbInfoV3;
+use dcap_types::tcb_info::TcbInfoV3;
 use dcap_types::utils::{parse_crl_der, parse_x509_der};
 use x509_parser::{certificate::X509Certificate, revocation_list::CertificateRevocationList};
 
@@ -12,10 +12,10 @@ use crate::Result;
 pub struct QvCollateral {
     /// TCBInfo in JSON format
     /// ref. <https://api.portal.trustedservices.intel.com/content/documentation.html#pcs-tcb-info-model-v3>
-    pub tcbinfo_json: Vec<u8>,
+    pub tcb_info_json: Vec<u8>,
     /// QEIdentity in JSON format
     /// ref. <https://api.portal.trustedservices.intel.com/content/documentation.html#pcs-enclave-identity-model-v2>
-    pub qeidentity_json: Vec<u8>,
+    pub qe_identity_json: Vec<u8>,
     /// SGX Intel Root CA certificate in DER format
     /// ref. <https://certificates.trustedservices.intel.com/Intel_SGX_Provisioning_Certification_RootCA.pem>
     pub sgx_intel_root_ca_der: Vec<u8>,
@@ -42,24 +42,24 @@ impl QvCollateral {
 
         // get the total length
         let total_length = 4 * 6
-            + self.tcbinfo_json.len()
-            + self.qeidentity_json.len()
+            + self.tcb_info_json.len()
+            + self.qe_identity_json.len()
             + self.sgx_intel_root_ca_der.len()
             + self.sgx_tcb_signing_der.len()
             + self.sgx_intel_root_ca_crl_der.len()
             + self.sgx_pck_crl_der.len();
 
         // create the vec and copy the data
         let mut data = Vec::with_capacity(total_length);
-        data.extend_from_slice(&(self.tcbinfo_json.len() as u32).to_le_bytes());
-        data.extend_from_slice(&(self.qeidentity_json.len() as u32).to_le_bytes());
+        data.extend_from_slice(&(self.tcb_info_json.len() as u32).to_le_bytes());
+        data.extend_from_slice(&(self.qe_identity_json.len() as u32).to_le_bytes());
         data.extend_from_slice(&(self.sgx_intel_root_ca_der.len() as u32).to_le_bytes());
         data.extend_from_slice(&(self.sgx_tcb_signing_der.len() as u32).to_le_bytes());
         data.extend_from_slice(&(self.sgx_intel_root_ca_crl_der.len() as u32).to_le_bytes());
         data.extend_from_slice(&(self.sgx_pck_crl_der.len() as u32).to_le_bytes());
 
-        data.extend_from_slice(&self.tcbinfo_json);
-        data.extend_from_slice(&self.qeidentity_json);
+        data.extend_from_slice(&self.tcb_info_json);
+        data.extend_from_slice(&self.qe_identity_json);
         data.extend_from_slice(&self.sgx_intel_root_ca_der);
         data.extend_from_slice(&self.sgx_tcb_signing_der);
         data.extend_from_slice(&self.sgx_intel_root_ca_crl_der);
@@ -77,8 +77,8 @@ impl QvCollateral {
 
         // reverse the serialization process
         // each length is 4 bytes long, we have a total of 6 members
-        let tcbinfo_json_len = u32::from_le_bytes(slice[0..4].try_into()?) as usize;
-        let qeidentity_json_len = u32::from_le_bytes(slice[4..8].try_into()?) as usize;
+        let tcb_info_json_len = u32::from_le_bytes(slice[0..4].try_into()?) as usize;
+        let qe_identity_json_len = u32::from_le_bytes(slice[4..8].try_into()?) as usize;
         let sgx_intel_root_ca_der_len = u32::from_le_bytes(slice[8..12].try_into()?) as usize;
         let sgx_tcb_signing_der_len = u32::from_le_bytes(slice[12..16].try_into()?) as usize;
         let sgx_intel_root_ca_crl_der_len = u32::from_le_bytes(slice[16..20].try_into()?) as usize;
@@ -88,8 +88,8 @@ impl QvCollateral {
 
         if slice.len()
             < offset
-                + tcbinfo_json_len
-                + qeidentity_json_len
+                + tcb_info_json_len
+                + qe_identity_json_len
                 + sgx_intel_root_ca_der_len
                 + sgx_tcb_signing_der_len
                 + sgx_intel_root_ca_crl_der_len
@@ -98,10 +98,10 @@ impl QvCollateral {
             bail!("Invalid QvCollateral length");
         }
 
-        let tcbinfo_json = slice[offset..offset + tcbinfo_json_len].to_vec();
-        offset += tcbinfo_json_len;
-        let qeidentity_json = slice[offset..offset + qeidentity_json_len].to_vec();
-        offset += qeidentity_json_len;
+        let tcb_info_json = slice[offset..offset + tcb_info_json_len].to_vec();
+        offset += tcb_info_json_len;
+        let qe_identity_json = slice[offset..offset + qe_identity_json_len].to_vec();
+        offset += qe_identity_json_len;
         let sgx_intel_root_ca_der = slice[offset..offset + sgx_intel_root_ca_der_len].to_vec();
         offset += sgx_intel_root_ca_der_len;
         let sgx_tcb_signing_der = slice[offset..offset + sgx_tcb_signing_der_len].to_vec();
@@ -113,8 +113,8 @@ impl QvCollateral {
         offset += sgx_pck_crl_der_len;
 
         Ok(QvCollateral {
-            tcbinfo_json,
-            qeidentity_json,
+            tcb_info_json,
+            qe_identity_json,
             sgx_intel_root_ca_der,
             sgx_tcb_signing_der,
             sgx_intel_root_ca_crl_der,
@@ -123,17 +123,17 @@ impl QvCollateral {
     }
 
     /// Returns the TCBInfoV3 struct from the TCBInfo JSON bytes
-    pub fn get_tcbinfov3(&self) -> Result<TcbInfoV3> {
-        let tcbinfo: TcbInfoV3 = serde_json::from_slice(&self.tcbinfo_json)?;
-        if tcbinfo.tcb_info.version != 3 {
-            bail!("Invalid TCB Info version: {}", tcbinfo.tcb_info.version);
+    pub fn get_tcb_info_v3(&self) -> Result<TcbInfoV3> {
+        let tcb_info_v3: TcbInfoV3 = serde_json::from_slice(&self.tcb_info_json)?;
+        if tcb_info_v3.tcb_info.version != 3 {
+            bail!("Invalid TCB Info version: {}", tcb_info_v3.tcb_info.version);
         }
-        Ok(tcbinfo)
+        Ok(tcb_info_v3)
     }
 
     /// Returns the EnclaveIdentityV2 struct from the QEIdentity JSON bytes
-    pub fn get_qeidentityv2(&self) -> Result<EnclaveIdentityV2> {
-        let qe: EnclaveIdentityV2 = serde_json::from_slice(&self.qeidentity_json)?;
+    pub fn get_qe_identity_v2(&self) -> Result<EnclaveIdentityV2> {
+        let qe: EnclaveIdentityV2 = serde_json::from_slice(&self.qe_identity_json)?;
         if qe.enclave_identity.version != 2 {
             bail!(
                 "Invalid QE Identity version: {}",

crates/quote-verifier/src/enclave_identity.rs

@@ -64,9 +64,9 @@ pub fn validate_qe_identityv2(
 /// ref. <https://github.com/intel/SGX-TDX-DCAP-QuoteVerificationLibrary/blob/812e0fa140a284b772b2d8b08583c761e23ec3b3/Src/AttestationLibrary/src/Verifiers/EnclaveIdentityV2.cpp#L326>
 pub fn get_qe_tcb_status(
     qe_report_isv_svn: u16,
-    qeidentityv2_tcb_levels: &[EnclaveIdentityV2TcbLevelItem],
+    qe_identity_v2_tcb_levels: &[EnclaveIdentityV2TcbLevelItem],
 ) -> Result<(EnclaveIdentityV2TcbStatus, Vec<String>)> {
-    for tcb_level in qeidentityv2_tcb_levels {
+    for tcb_level in qe_identity_v2_tcb_levels {
         if tcb_level.tcb.isvsvn <= qe_report_isv_svn {
             return Ok((
                 EnclaveIdentityV2TcbStatus::from_str(&tcb_level.tcb_status)?,

crates/quote-verifier/src/lib.rs

@@ -6,7 +6,7 @@ pub mod enclave_identity;
 pub mod pck;
 pub mod quotes;
 pub mod sgx_extensions;
-pub mod tcbinfo;
+pub mod tcb_info;
 pub mod tdx_module;
 #[cfg(test)]
 pub mod tests;
@@ -23,10 +23,10 @@ mod quote_verifier_tests {
     use crate::collateral::QvCollateral;
     use crate::crypto::keccak256sum;
     use crate::quotes::{version_3::verify_quote_v3, version_4::verify_quote_v4};
-    use crate::tcbinfo::validate_tcbinfov3;
+    use crate::tcb_info::validate_tcb_info_v3;
     use crate::verifier::{QuoteVerificationOutput, Status};
     use dcap_types::quotes::{version_3::QuoteV3, version_4::QuoteV4};
-    use dcap_types::tcbinfo::TcbInfoV3;
+    use dcap_types::tcb_info::TcbInfoV3;
     use dcap_types::utils::{parse_crl_der, parse_pem, parse_x509_der, pem_to_der};
     use dcap_types::{SGX_TEE_TYPE, TDX_TEE_TYPE};
 
@@ -43,25 +43,25 @@ mod quote_verifier_tests {
     }
 
     #[test]
-    fn test_tcbinfov3_sgx() {
-        let tcbinfov3: TcbInfoV3 =
+    fn test_tcb_info_v3_sgx() {
+        let tcb_info_v3: TcbInfoV3 =
             serde_json::from_str(include_str!("../../../data/v3/tcbinfov3_00906ED50000.json"))
                 .unwrap();
         let sgx_signing_cert_pem =
             &parse_pem(include_bytes!("../../../data/v3/signing_cert.pem")).unwrap()[0];
         let sgx_signing_cert = parse_x509_der(&sgx_signing_cert_pem.contents).unwrap();
-        assert!(validate_tcbinfov3(SGX_TEE_TYPE, &tcbinfov3, &sgx_signing_cert).is_ok());
+        assert!(validate_tcb_info_v3(SGX_TEE_TYPE, &tcb_info_v3, &sgx_signing_cert).is_ok());
     }
 
     #[test]
-    fn test_tcbinfov3_tdx() {
-        let tcbinfov3: TcbInfoV3 =
+    fn test_tcb_info_v3_tdx() {
+        let tcb_info_v3: TcbInfoV3 =
             serde_json::from_str(include_str!("../../../data/tcbinfov3_00806f050000.json"))
                 .unwrap();
         let sgx_signing_cert_pem =
             &parse_pem(include_bytes!("../../../data/signing_cert.pem")).unwrap()[0];
         let sgx_signing_cert = parse_x509_der(&sgx_signing_cert_pem.contents).unwrap();
-        assert!(validate_tcbinfov3(TDX_TEE_TYPE, &tcbinfov3, &sgx_signing_cert).is_ok());
+        assert!(validate_tcb_info_v3(TDX_TEE_TYPE, &tcb_info_v3, &sgx_signing_cert).is_ok());
     }
 
     #[test]
@@ -76,8 +76,8 @@ mod quote_verifier_tests {
     #[test]
     fn test_verifyv3() {
         let collaterals = QvCollateral {
-            tcbinfo_json: include_bytes!("../../../data/v3/tcbinfov3_00906ED50000.json").to_vec(),
-            qeidentity_json: include_bytes!("../../../data/v3/qeidentityv2.json").to_vec(),
+            tcb_info_json: include_bytes!("../../../data/v3/tcbinfov3_00906ED50000.json").to_vec(),
+            qe_identity_json: include_bytes!("../../../data/v3/qeidentityv2.json").to_vec(),
             sgx_intel_root_ca_der: include_bytes!(
                 "../../../data/Intel_SGX_Provisioning_Certification_RootCA.cer"
             )
@@ -134,8 +134,8 @@ mod quote_verifier_tests {
     #[test]
     fn test_verifyv4() {
         let collaterals = QvCollateral {
-            tcbinfo_json: include_bytes!("../../../data/v4/tcbinfov3_00806f050000.json").to_vec(),
-            qeidentity_json: include_bytes!("../../../data/v4/qeidentityv2_apiv4.json").to_vec(),
+            tcb_info_json: include_bytes!("../../../data/v4/tcbinfov3_00806f050000.json").to_vec(),
+            qe_identity_json: include_bytes!("../../../data/v4/qeidentityv2_apiv4.json").to_vec(),
             sgx_intel_root_ca_der: include_bytes!(
                 "../../../data/Intel_SGX_Provisioning_Certification_RootCA.cer"
             )