Merge pull request #82 from Phala-Network/reject-unknown

kvinwang · web-flow · commit befd2df4041c · 2026-01-08T17:28:15.000+08:00
Add rejection for Revoked TCB status
diff --git a/cli/src/bin/generate_all_samples.rs b/cli/src/bin/generate_all_samples.rs
@@ -1878,13 +1878,13 @@ fn main() -> Result<()> {
         name: "unknown_tcb_status".to_string(),
         description: "Quote with no matching TCB level (empty tcbLevels array)".to_string(),
         should_succeed: false,
-        expected_error: Some("TCB status is Unknown".to_string()),
+        expected_error: Some("No matching TCB level found".to_string()),
         quote_generator: Box::new(|| generate_base_quote(3, 2, false)),
         collateral_modifier: Some(Box::new(|collateral| {
             // Use empty tcbLevels array - no matching level will be found
             if let Some(tcb_str) = collateral["tcb_info"].as_str() {
                 if let Ok(mut tcb) = serde_json::from_str::<serde_json::Value>(tcb_str) {
-                    tcb["tcbLevels"] = json!([]);  // Empty array
+                    tcb["tcbLevels"] = json!([]); // Empty array
                     let new_tcb_info = serde_json::to_string(&tcb)?;
 
                     let key_path = &format!("{}/tcb_signing.pkcs8.key", CERT_DIR);
@@ -1899,6 +1899,64 @@ fn main() -> Result<()> {
         })),
     });
 
+    samples.push(TestSample {
+        name: "revoked_platform_tcb".to_string(),
+        description: "Quote with Revoked platform TCB status".to_string(),
+        should_succeed: false,
+        expected_error: Some("TCB status is invalid: Revoked".to_string()),
+        quote_generator: Box::new(|| generate_base_quote(3, 2, false)),
+        collateral_modifier: Some(Box::new(|collateral| {
+            // Set platform TCB status to Revoked
+            if let Some(tcb_str) = collateral["tcb_info"].as_str() {
+                if let Ok(mut tcb) = serde_json::from_str::<serde_json::Value>(tcb_str) {
+                    if let Some(levels) = tcb["tcbLevels"].as_array_mut() {
+                        for level in levels {
+                            level["tcbStatus"] = json!("Revoked");
+                        }
+                    }
+                    let new_tcb_info = serde_json::to_string(&tcb)?;
+
+                    let key_path = &format!("{}/tcb_signing.pkcs8.key", CERT_DIR);
+                    let key_pair = load_private_key(key_path)?;
+                    let tcb_signature = sign_data(&key_pair, new_tcb_info.as_bytes())?;
+
+                    collateral["tcb_info"] = json!(new_tcb_info);
+                    collateral["tcb_info_signature"] = json!(hex::encode(tcb_signature));
+                }
+            }
+            Ok(())
+        })),
+    });
+
+    samples.push(TestSample {
+        name: "revoked_qe_tcb".to_string(),
+        description: "Quote with Revoked QE TCB status".to_string(),
+        should_succeed: false,
+        expected_error: Some("TCB status is invalid: Revoked".to_string()),
+        quote_generator: Box::new(|| generate_base_quote(3, 2, false)),
+        collateral_modifier: Some(Box::new(|collateral| {
+            // Set QE TCB status to Revoked
+            if let Some(qe_str) = collateral["qe_identity"].as_str() {
+                if let Ok(mut qe_identity) = serde_json::from_str::<serde_json::Value>(qe_str) {
+                    if let Some(levels) = qe_identity["tcbLevels"].as_array_mut() {
+                        for level in levels {
+                            level["tcbStatus"] = json!("Revoked");
+                        }
+                    }
+                    let new_qe_identity = serde_json::to_string(&qe_identity)?;
+
+                    let key_path = &format!("{}/tcb_signing.pkcs8.key", CERT_DIR);
+                    let key_pair = load_private_key(key_path)?;
+                    let qe_signature = sign_data(&key_pair, new_qe_identity.as_bytes())?;
+
+                    collateral["qe_identity"] = json!(new_qe_identity);
+                    collateral["qe_identity_signature"] = json!(hex::encode(qe_signature));
+                }
+            }
+            Ok(())
+        })),
+    });
+
     // Category 13: PCK certificate chain in collateral (cert_type 3 support)
     println!("\nCategory 13: PCK certificate chain in collateral");
 
diff --git a/cli/src/bin/test_case.rs b/cli/src/bin/test_case.rs
@@ -109,7 +109,7 @@ fn run_verify(quote_file: PathBuf, collateral_file: PathBuf, root_ca_file: Optio
     match verifier.verify(&quote_bytes, &collateral, now) {
         Ok(verified_report) => {
             println!("Verification successful");
-            println!("Status: {}", verified_report.status);
+            println!("Status: {:?}", verified_report.status);
             0
         }
         Err(e) => {
diff --git a/dcap-qvl-js/src/tcb_info.js b/dcap-qvl-js/src/tcb_info.js
@@ -90,6 +90,23 @@ class TcbStatus {
         return new TcbStatus('Unknown', []);
     }
 
+    // Check if the TCB status is valid (not Revoked)
+    isValid() {
+        switch (this.status) {
+            case 'UpToDate':
+            case 'SWHardeningNeeded':
+            case 'ConfigurationNeeded':
+            case 'ConfigurationAndSWHardeningNeeded':
+            case 'OutOfDate':
+            case 'OutOfDateConfigurationNeeded':
+                return true;
+            case 'Revoked':
+                return false;
+            default:
+                return false; // Unknown or other statuses are invalid
+        }
+    }
+
     // Merge two TCB statuses, taking the worse status and combining advisory IDs
     merge(other) {
         const finalStatus = tcbStatusSeverity(other.status) > tcbStatusSeverity(this.status)
diff --git a/dcap-qvl-js/src/verify.js b/dcap-qvl-js/src/verify.js
@@ -293,9 +293,9 @@ function verifyImpl(rawQuote, collateral, nowSecs, rootCaDer) {
     // Step 9 & 10: QE TCB matching is done in verifyQeIdentityPolicy, merge statuses
     const finalStatus = platformTcbStatus.merge(qeTcbStatus);
 
-    // Reject Unknown TCB status
-    if (finalStatus.status === 'Unknown') {
-        throw new Error('TCB status is Unknown - no matching TCB level found');
+    // Reject invalid TCB status (including Revoked)
+    if (!finalStatus.isValid()) {
+        throw new Error(`TCB status is invalid: ${finalStatus.status}`);
     }
 
     // Validate attributes
@@ -343,7 +343,7 @@ function matchPlatformTcb(tcbInfo, quote, cpuSvn, pceSvn) {
         return new TcbStatus(tcbLevel.tcbStatus, [...tcbLevel.advisoryIDs]);
     }
 
-    return TcbStatus.unknown();
+    throw new Error('No matching TCB level found');
 }
 
 // Step 6 & 9: Verify QE Report policy and match QE TCB
@@ -398,7 +398,7 @@ function matchQeTcbLevel(isvSvn, tcbLevels) {
 
     // No matching level found
     if (tcbLevels.length === 0) {
-        return TcbStatus.unknown();
+        throw new Error('No TCB levels found in QE Identity');
     }
 
     // ISVSVN is below all defined TCB levels
diff --git a/src/lib.rs b/src/lib.rs
@@ -84,7 +84,7 @@ pub mod oids;
 mod constants;
 pub mod intel;
 mod qe_identity;
-mod tcb_info;
+pub mod tcb_info;
 mod utils;
 
 pub mod quote;
diff --git a/src/python.rs b/src/python.rs
@@ -7,6 +7,7 @@ use serde_json;
 use crate::{
     collateral::get_collateral_for_fmspc,
     quote::Quote,
+    tcb_info::TcbStatus,
     verify::{verify, VerifiedReport},
     QuoteCollateralV3,
 };
@@ -115,7 +116,15 @@ pub struct PyVerifiedReport {
 impl PyVerifiedReport {
     #[getter]
     fn status(&self) -> &str {
-        &self.inner.status
+        match self.inner.status {
+            TcbStatus::UpToDate => "UpToDate",
+            TcbStatus::OutOfDateConfigurationNeeded => "OutOfDateConfigurationNeeded",
+            TcbStatus::OutOfDate => "OutOfDate",
+            TcbStatus::ConfigurationAndSWHardeningNeeded => "ConfigurationAndSWHardeningNeeded",
+            TcbStatus::ConfigurationNeeded => "ConfigurationNeeded",
+            TcbStatus::SWHardeningNeeded => "SWHardeningNeeded",
+            TcbStatus::Revoked => "Revoked",
+        }
     }
 
     #[getter]
diff --git a/src/qe_identity.rs b/src/qe_identity.rs
@@ -7,6 +7,8 @@ use borsh::BorshSchema;
 #[cfg(feature = "borsh")]
 use borsh::{BorshDeserialize, BorshSerialize};
 
+use crate::tcb_info::TcbStatus;
+
 /// QE Identity structure as returned by Intel's PCCS
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -44,7 +46,7 @@ pub struct QeIdentity {
 pub struct QeTcbLevel {
     pub tcb: QeTcb,
     pub tcb_date: String,
-    pub tcb_status: String,
+    pub tcb_status: TcbStatus,
     #[serde(rename = "advisoryIDs", default)]
     pub advisory_ids: Vec<String>,
 }
diff --git a/src/tcb_info.rs b/src/tcb_info.rs
@@ -30,7 +30,7 @@ pub struct TcbInfo {
 pub struct TcbLevel {
     pub tcb: Tcb,
     pub tcb_date: String,
-    pub tcb_status: String,
+    pub tcb_status: TcbStatus,
     #[serde(rename = "advisoryIDs", default)]
     pub advisory_ids: Vec<String>,
 }
@@ -56,43 +56,68 @@ pub struct TcbComponents {
     pub svn: u8,
 }
 
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))]
+#[cfg_attr(feature = "borsh_schema", derive(BorshSchema))]
+pub enum TcbStatus {
+    UpToDate,
+    OutOfDateConfigurationNeeded,
+    OutOfDate,
+    ConfigurationAndSWHardeningNeeded,
+    ConfigurationNeeded,
+    SWHardeningNeeded,
+    Revoked,
+}
+
+impl TcbStatus {
+    fn severity(&self) -> u8 {
+        match self {
+            Self::UpToDate => 0,
+            Self::SWHardeningNeeded => 1,
+            Self::ConfigurationNeeded => 2,
+            Self::ConfigurationAndSWHardeningNeeded => 3,
+            Self::OutOfDate => 4,
+            Self::OutOfDateConfigurationNeeded => 5,
+            Self::Revoked => 6,
+        }
+    }
+
+    pub fn is_valid(&self) -> bool {
+        match self {
+            Self::UpToDate => true,
+            Self::SWHardeningNeeded => true,
+            Self::ConfigurationNeeded => true,
+            Self::ConfigurationAndSWHardeningNeeded => true,
+            Self::OutOfDate => true,
+            Self::OutOfDateConfigurationNeeded => true,
+            Self::Revoked => false,
+        }
+    }
+}
+
 /// TCB status with advisory IDs
 ///
 /// This is the result of matching a TCB level, used by both
 /// platform TCB matching and QE Identity verification.
-#[derive(Clone, Debug, Default)]
-pub struct TcbStatus {
-    pub status: String,
+#[derive(Clone, Debug)]
+pub struct TcbStatusWithAdvisory {
+    pub status: TcbStatus,
     pub advisory_ids: Vec<String>,
 }
 
-impl TcbStatus {
+impl TcbStatusWithAdvisory {
     /// Create a new TcbStatus with the given status and advisory IDs
-    pub fn new(status: impl Into<String>, advisory_ids: Vec<String>) -> Self {
+    pub fn new(status: TcbStatus, advisory_ids: Vec<String>) -> Self {
         Self {
-            status: status.into(),
+            status,
             advisory_ids,
         }
     }
 
-    /// Create an unknown status (no matching TCB level found)
-    pub fn unknown() -> Self {
-        Self {
-            status: "Unknown".into(),
-            advisory_ids: vec![],
-        }
-    }
-
-    /// Check if the TCB status is unknown
-    pub fn is_unknown(&self) -> bool {
-        self.status == "Unknown"
-    }
-
     /// Merge two TCB statuses, taking the worse status and combining advisory IDs
-    pub fn merge(self, other: &TcbStatus) -> Self {
-        let final_status = if tcb_status_severity(&other.status) > tcb_status_severity(&self.status)
-        {
-            other.status.clone()
+    pub fn merge(self, other: &TcbStatusWithAdvisory) -> Self {
+        let final_status = if other.status.severity() > self.status.severity() {
+            other.status
         } else {
             self.status
         };
@@ -111,48 +136,35 @@ impl TcbStatus {
     }
 }
 
-/// TCB status severity ordering (higher number = worse status)
-fn tcb_status_severity(status: &str) -> u8 {
-    match status {
-        "UpToDate" => 0,
-        "SWHardeningNeeded" => 1,
-        "ConfigurationNeeded" => 2,
-        "ConfigurationAndSWHardeningNeeded" => 3,
-        "OutOfDate" => 4,
-        "OutOfDateConfigurationNeeded" => 5,
-        "Revoked" => 6,
-        _ => 100, // Unknown status treated as worst
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
+    use TcbStatus::*;
 
     #[test]
     fn test_tcb_status_merge_both_up_to_date() {
-        let a = TcbStatus::new("UpToDate", vec![]);
-        let b = TcbStatus::new("UpToDate", vec![]);
+        let a = TcbStatusWithAdvisory::new(UpToDate, vec![]);
+        let b = TcbStatusWithAdvisory::new(UpToDate, vec![]);
         let result = a.merge(&b);
-        assert_eq!(result.status, "UpToDate");
+        assert_eq!(result.status, UpToDate);
         assert!(result.advisory_ids.is_empty());
     }
 
     #[test]
     fn test_tcb_status_merge_takes_worse() {
-        let a = TcbStatus::new("UpToDate", vec![]);
-        let b = TcbStatus::new("OutOfDate", vec!["INTEL-SA-00001".into()]);
+        let a = TcbStatusWithAdvisory::new(UpToDate, vec![]);
+        let b = TcbStatusWithAdvisory::new(OutOfDate, vec!["INTEL-SA-00001".into()]);
         let result = a.merge(&b);
-        assert_eq!(result.status, "OutOfDate");
+        assert_eq!(result.status, OutOfDate);
         assert_eq!(result.advisory_ids, vec!["INTEL-SA-00001"]);
     }
 
     #[test]
     fn test_tcb_status_merge_combines_advisories() {
-        let a = TcbStatus::new("OutOfDate", vec!["INTEL-SA-00001".into()]);
-        let b = TcbStatus::new("SWHardeningNeeded", vec!["INTEL-SA-00002".into()]);
+        let a = TcbStatusWithAdvisory::new(OutOfDate, vec!["INTEL-SA-00001".into()]);
+        let b = TcbStatusWithAdvisory::new(SWHardeningNeeded, vec!["INTEL-SA-00002".into()]);
         let result = a.merge(&b);
-        assert_eq!(result.status, "OutOfDate");
+        assert_eq!(result.status, OutOfDate);
         assert_eq!(
             result.advisory_ids,
             vec!["INTEL-SA-00001", "INTEL-SA-00002"]
@@ -161,31 +173,9 @@ mod tests {
 
     #[test]
     fn test_tcb_status_merge_deduplicates_advisories() {
-        let a = TcbStatus::new("OutOfDate", vec!["INTEL-SA-00001".into()]);
-        let b = TcbStatus::new("OutOfDate", vec!["INTEL-SA-00001".into()]);
+        let a = TcbStatusWithAdvisory::new(OutOfDate, vec!["INTEL-SA-00001".into()]);
+        let b = TcbStatusWithAdvisory::new(OutOfDate, vec!["INTEL-SA-00001".into()]);
         let result = a.merge(&b);
         assert_eq!(result.advisory_ids, vec!["INTEL-SA-00001"]);
     }
-
-    #[test]
-    fn test_tcb_status_severity_ordering() {
-        assert!(tcb_status_severity("UpToDate") < tcb_status_severity("SWHardeningNeeded"));
-        assert!(
-            tcb_status_severity("SWHardeningNeeded") < tcb_status_severity("ConfigurationNeeded")
-        );
-        assert!(
-            tcb_status_severity("ConfigurationNeeded")
-                < tcb_status_severity("ConfigurationAndSWHardeningNeeded")
-        );
-        assert!(
-            tcb_status_severity("ConfigurationAndSWHardeningNeeded")
-                < tcb_status_severity("OutOfDate")
-        );
-        assert!(
-            tcb_status_severity("OutOfDate") < tcb_status_severity("OutOfDateConfigurationNeeded")
-        );
-        assert!(
-            tcb_status_severity("OutOfDateConfigurationNeeded") < tcb_status_severity("Revoked")
-        );
-    }
 }
diff --git a/src/verify.rs b/src/verify.rs
diff --git a/tests/test_suite.sh b/tests/test_suite.sh
diff --git a/tests/verify_quote.rs b/tests/verify_quote.rs

Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ fn run_verify(quote_file: PathBuf, collateral_file: PathBuf, root_ca_file: Optio`
`109`	`109`	`match verifier.verify(&quote_bytes, &collateral, now) {`
`110`	`110`	`Ok(verified_report) => {`
`111`	`111`	`println!("Verification successful");`
`112`		`- println!("Status: {}", verified_report.status);`
	`112`	`+ println!("Status: {:?}", verified_report.status);`
`113`	`113`	`0`
`114`	`114`	`}`
`115`	`115`	`Err(e) => {`
Original file line number	Diff line number	Diff line change
`@@ -293,9 +293,9 @@ function verifyImpl(rawQuote, collateral, nowSecs, rootCaDer) {`
`293`	`293`	`// Step 9 & 10: QE TCB matching is done in verifyQeIdentityPolicy, merge statuses`
`294`	`294`	`const finalStatus = platformTcbStatus.merge(qeTcbStatus);`
`295`	`295`
`296`		`- // Reject Unknown TCB status`
`297`		`- if (finalStatus.status === 'Unknown') {`
`298`		`- throw new Error('TCB status is Unknown - no matching TCB level found');`
	`296`	`+ // Reject invalid TCB status (including Revoked)`
	`297`	`+ if (!finalStatus.isValid()) {`
	`298`	+ throw new Error(`TCB status is invalid: ${finalStatus.status}`);
`299`	`299`	`}`
`300`	`300`
`301`	`301`	`// Validate attributes`
`@@ -343,7 +343,7 @@ function matchPlatformTcb(tcbInfo, quote, cpuSvn, pceSvn) {`
`343`	`343`	`return new TcbStatus(tcbLevel.tcbStatus, [...tcbLevel.advisoryIDs]);`
`344`	`344`	`}`
`345`	`345`
`346`		`- return TcbStatus.unknown();`
	`346`	`+ throw new Error('No matching TCB level found');`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`// Step 6 & 9: Verify QE Report policy and match QE TCB`
`@@ -398,7 +398,7 @@ function matchQeTcbLevel(isvSvn, tcbLevels) {`
`398`	`398`
`399`	`399`	`// No matching level found`
`400`	`400`	`if (tcbLevels.length === 0) {`
`401`		`- return TcbStatus.unknown();`
	`401`	`+ throw new Error('No TCB levels found in QE Identity');`
`402`	`402`	`}`
`403`	`403`
`404`	`404`	`// ISVSVN is below all defined TCB levels`