improve docs

Signed-off-by: Jun Kimura <[email protected]>

Author: bluele

modules/attestation-report/src/dcap.rs

@@ -10,43 +10,34 @@ use serde_with::serde_as;
 #[serde_as]
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct DCAPQuote {
+    /// Raw quote from the DCAP library
     #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Lowercase>")]
     pub raw: Vec<u8>,
+    /// Family Model Specific Platform Configuration (FMSPC) of the processor/platform
     #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Lowercase>")]
     pub fmspc: [u8; 6],
+    /// TCB status of the processor/platform
     pub tcb_status: String,
+    /// Advisory IDs of the processor/platform
     pub advisory_ids: Vec<String>,
+    /// Time when the quote was attested
     pub attested_at: Time,
+    /// Collateral data used to verify the quote
     pub collateral: DcapCollateral,
 }
 
 impl DCAPQuote {
-    pub fn new(
-        raw_quote: Vec<u8>,
-        fmspc: [u8; 6],
-        tcb_status: String,
-        advisory_ids: Vec<String>,
-        attested_at: Time,
-        collateral: DcapCollateral,
-    ) -> Self {
-        DCAPQuote {
-            raw: raw_quote,
-            fmspc,
-            tcb_status,
-            advisory_ids,
-            attested_at,
-            collateral,
-        }
-    }
-
+    /// Converts the quote to a RAQuote
     pub fn to_json(&self) -> Result<String, Error> {
         serde_json::to_string(self).map_err(Error::serde_json)
     }
 
+    /// Parses the quote from a JSON string
     pub fn from_json(json: &str) -> Result<Self, Error> {
         serde_json::from_str(json).map_err(Error::serde_json)
     }
 
+    /// Returns the report data from the quote
     #[cfg(feature = "std")]
     pub fn report_data(&self) -> Result<crate::ReportData, Error> {
         use dcap_quote_verifier::types::quotes::version_3::QuoteV3;
@@ -62,25 +53,43 @@ pub enum ZKVMProof {
 }
 
 impl ZKVMProof {
+    /// Returns the commit corresponding to the proof
     pub fn commit(&self) -> &[u8] {
         match self {
             ZKVMProof::Risc0(ref proof) => &proof.commit,
         }
     }
+
+    /// Returns true if the proof is a mock proof
+    pub fn is_mock(&self) -> bool {
+        match self {
+            ZKVMProof::Risc0(ref proof) => proof.is_mock(),
+        }
+    }
 }
 
 /// Risc0ZKVMProof represents a zkVM proof for RISC Zero
 #[serde_as]
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Risc0ZKVMProof {
+    /// A small cryptographic identifier that indicates the method or boot image for zkVM execution
     #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Lowercase>")]
     pub image_id: [u8; 32],
     #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Lowercase>")]
+    /// A Groth16 proof for the correct execution of the guest program.
     pub seal: Vec<u8>,
+    /// The public outputs of dcap-quote-verifier program executed inside the zkVM
     #[serde_as(as = "serde_with::hex::Hex<serde_with::formats::Lowercase>")]
     pub commit: Vec<u8>,
 }
 
+impl Risc0ZKVMProof {
+    /// Returns true if the proof is a mock proof
+    pub fn is_mock(&self) -> bool {
+        self.seal.len() >= 4 && self.seal[0..4] == [0, 0, 0, 0]
+    }
+}
+
 /// ZKDCAPQuote represents a DCAP quote with a zkVM proof
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct ZKDCAPQuote {
@@ -90,7 +99,7 @@ pub struct ZKDCAPQuote {
     pub zkp: ZKVMProof,
     /// if true, `zkp` is a mock proof
     /// otherwise, `zkp` is a zkVM proof
-    pub mock: bool,
+    mock: bool,
 }
 
 impl From<ZKDCAPQuote> for RAQuote {
@@ -100,27 +109,37 @@ impl From<ZKDCAPQuote> for RAQuote {
 }
 
 impl ZKDCAPQuote {
-    pub fn new(dcap_quote: DCAPQuote, zkp: ZKVMProof, mock: bool) -> Self {
+    /// Creates a new ZKDCAPQuote
+    pub fn new(dcap_quote: DCAPQuote, zkp: ZKVMProof) -> Self {
         ZKDCAPQuote {
             dcap_quote,
+            mock: zkp.is_mock(),
             zkp,
-            mock,
         }
     }
 
+    /// Returns true if the proof is a mock proof
+    pub fn is_mock_zkp(&self) -> bool {
+        self.mock
+    }
+
+    /// Converts the quote to a JSON string
     pub fn to_json(&self) -> Result<String, Error> {
         serde_json::to_string(self).map_err(Error::serde_json)
     }
 
+    /// Parses the quote from a JSON string
     pub fn from_json(json: &str) -> Result<Self, Error> {
         serde_json::from_str(json).map_err(Error::serde_json)
     }
 
+    /// Returns the report data from the quote
     #[cfg(feature = "std")]
     pub fn report_data(&self) -> Result<crate::ReportData, Error> {
         self.dcap_quote.report_data()
     }
 
+    /// Returns the commit corresponding to the zkVM proof
     #[cfg(feature = "std")]
     pub fn commit(&self) -> Result<dcap_quote_verifier::verifier::VerifiedOutput, Error> {
         dcap_quote_verifier::verifier::VerifiedOutput::from_bytes(self.zkp.commit())

modules/attestation-report/src/report.rs

@@ -157,7 +157,7 @@ impl RAQuote {
             RAQuote::DCAP(_) => RAType::DCAP,
             RAQuote::ZKDCAP(quote) => {
                 // currently only support Risc0
-                if quote.mock {
+                if quote.is_mock_zkp() {
                     RAType::MockZKDCAPRisc0
                 } else {
                     RAType::ZKDCAPRisc0

modules/remote-attestation/src/dcap_utils.rs

@@ -13,20 +13,20 @@ pub struct DCAPRemoteAttestationResult {
 
 impl DCAPRemoteAttestationResult {
     pub fn get_ra_quote(&self, attested_at: Time) -> DCAPQuote {
-        DCAPQuote::new(
-            self.raw_quote.clone(),
-            self.output.fmspc,
-            self.output.tcb_status.to_string(),
-            self.output.advisory_ids.clone(),
+        DCAPQuote {
+            raw: self.raw_quote.clone(),
+            fmspc: self.output.fmspc,
+            tcb_status: self.output.tcb_status.to_string(),
+            advisory_ids: self.output.advisory_ids.clone(),
             attested_at,
-            DcapCollateral {
+            collateral: DcapCollateral {
                 tcbinfo_bytes: self.collateral.tcbinfo_bytes.clone(),
                 qeidentity_bytes: self.collateral.qeidentity_bytes.clone(),
                 sgx_intel_root_ca_der: self.collateral.sgx_intel_root_ca_der.clone(),
                 sgx_tcb_signing_der: self.collateral.sgx_tcb_signing_der.clone(),
                 sgx_intel_root_ca_crl_der: self.collateral.sgx_intel_root_ca_crl_der.clone(),
                 sgx_pck_crl_der: self.collateral.sgx_pck_crl_der.clone(),
             },
-        )
+        }
     }
 }

modules/remote-attestation/src/zkdcap.rs

@@ -184,7 +184,6 @@ fn zkdcap_ra(
                     seal,
                     commit: prover_info.receipt.journal.bytes,
                 }),
-                prover_mode.is_dev_mode(),
             )
             .into(),
         )