feat(vmm): support tdx acpi table requirement

Author: kvinwang

dstack-types/src/lib.rs

@@ -126,11 +126,18 @@ pub struct Requirements {
     /// an explicit empty list means no platform is allowed.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub platforms: Option<Vec<String>>,
+    /// TDX-only ACPI table measurement requirement. When set, this overrides
+    /// the VMM-side TDX lite attestation policy: `true` requires legacy mode
+    /// with ACPI tables measured, while `false` requires lite mode.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tdx_measure_acpi_tables: Option<bool>,
 }
 
 impl Requirements {
     pub fn is_empty(&self) -> bool {
-        self.os_version.is_none() && self.platforms.is_none()
+        self.os_version.is_none()
+            && self.platforms.is_none()
+            && self.tdx_measure_acpi_tables.is_none()
     }
 }
 
@@ -381,7 +388,8 @@ mod app_compose_tests {
             "runner": "docker-compose",
             "requirements": {
                 "os_version": ">=0.6.1",
-                "platforms": ["dstack-gcp-tdx", "dstack-tdx"]
+                "platforms": ["dstack-gcp-tdx", "dstack-tdx"],
+                "tdx_measure_acpi_tables": true
             }
         }))
         .unwrap();
@@ -391,6 +399,7 @@ mod app_compose_tests {
             requirements.platforms,
             Some(vec!["dstack-gcp-tdx".to_string(), "dstack-tdx".to_string()])
         );
+        assert_eq!(requirements.tdx_measure_acpi_tables, Some(true));
 
         let err = serde_json::from_value::<AppCompose>(serde_json::json!({
             "manifest_version": "3",
@@ -429,6 +438,19 @@ mod app_compose_tests {
         let requirements = explicit_empty.requirements.as_ref().unwrap();
         assert_eq!(requirements.platforms, Some(vec![]));
         assert!(!requirements.is_empty());
+
+        let acpi_tables: AppCompose = serde_json::from_value(serde_json::json!({
+            "manifest_version": "3",
+            "name": "test",
+            "runner": "docker-compose",
+            "requirements": {
+                "tdx_measure_acpi_tables": false
+            }
+        }))
+        .unwrap();
+        let requirements = acpi_tables.requirements.as_ref().unwrap();
+        assert_eq!(requirements.tdx_measure_acpi_tables, Some(false));
+        assert!(!requirements.is_empty());
     }
 }
 

dstack-util/src/system_setup.rs

@@ -774,7 +774,7 @@ fn verify_manifest_version(app_compose: &AppCompose) -> Result<u32> {
     Ok(manifest_version)
 }
 
-fn verify_app_compose_policy(app_compose: &AppCompose) -> Result<()> {
+fn verify_app_compose_policy(app_compose: &AppCompose, sys_config: &SysConfig) -> Result<()> {
     verify_manifest_feature_requirements(app_compose)?;
     let Some(requirements) = app_compose.requirements.as_ref() else {
         return Ok(());
@@ -789,9 +789,18 @@ fn verify_app_compose_policy(app_compose: &AppCompose) -> Result<()> {
             bail!("Unsupported attestation platform: requirements.platforms is empty");
         }
         let current_platform =
-            AttestationMode::detect().context("Failed to detect current attestation platform")?;
+            AttestationMode::detect().context("failed to detect current attestation platform")?;
         verify_platform_requirements(app_compose, current_platform)?;
     }
+    if requirements.tdx_measure_acpi_tables.is_some() {
+        let current_platform =
+            AttestationMode::detect().context("failed to detect current attestation platform")?;
+        verify_tdx_measure_acpi_tables_requirement(
+            app_compose,
+            &sys_config.vm_config,
+            current_platform,
+        )?;
+    }
     Ok(())
 }
 
@@ -867,6 +876,41 @@ fn format_requirement_platforms(platforms: &[String]) -> String {
     platforms.join(", ")
 }
 
+fn verify_tdx_measure_acpi_tables_requirement(
+    app_compose: &AppCompose,
+    vm_config: &str,
+    current_platform: AttestationMode,
+) -> Result<()> {
+    let Some(measure_acpi_tables) = app_compose
+        .requirements
+        .as_ref()
+        .and_then(|requirements| requirements.tdx_measure_acpi_tables)
+    else {
+        return Ok(());
+    };
+    if current_platform != AttestationMode::DstackTdx {
+        return Ok(());
+    }
+    let vm_config: dstack_types::VmConfig = serde_json::from_str(vm_config)
+        .context("failed to parse vm_config for requirements.tdx_measure_acpi_tables")?;
+    let uses_lite = vm_config.tdx_attestation_variant.is_lite();
+    if measure_acpi_tables && uses_lite {
+        bail!(
+            "unsupported TDX attestation mode: requirements.tdx_measure_acpi_tables=true requires ACPI table measurement"
+        );
+    }
+    if !measure_acpi_tables && !uses_lite {
+        bail!(
+            "unsupported TDX attestation mode: requirements.tdx_measure_acpi_tables=false requires TDX lite attestation"
+        );
+    }
+    info!(
+        "tdx ACPI table measurement requirement satisfied: measure_acpi_tables={}",
+        measure_acpi_tables
+    );
+    Ok(())
+}
+
 fn read_current_os_version() -> Result<String> {
     const OS_RELEASE_PATHS: &[&str] = &["/etc/os-release", "/usr/lib/os-release"];
     for path in OS_RELEASE_PATHS {
@@ -930,7 +974,7 @@ pub async fn cmd_sys_setup(args: SetupArgs) -> Result<()> {
 }
 
 async fn do_sys_setup(stage0: Stage0<'_>) -> Result<()> {
-    verify_app_compose_policy(&stage0.shared.app_compose)
+    verify_app_compose_policy(&stage0.shared.app_compose, &stage0.shared.sys_config)
         .context("Failed to verify app-compose policy")?;
     if stage0.shared.app_compose.secure_time {
         info!("Waiting for the system time to be synchronized");
@@ -2198,6 +2242,70 @@ fn test_platform_requirements_reject_invalid_platform_value() {
         .contains("Invalid requirements.platforms[0]"));
 }
 
+#[test]
+fn test_tdx_measure_acpi_tables_requirement_matches_vm_config() {
+    let app_compose: AppCompose = serde_json::from_value(serde_json::json!({
+        "manifest_version": "3",
+        "name": "test",
+        "runner": "docker-compose",
+        "requirements": {
+            "tdx_measure_acpi_tables": true
+        }
+    }))
+    .unwrap();
+    verify_tdx_measure_acpi_tables_requirement(&app_compose, r#"{}"#, AttestationMode::DstackTdx)
+        .unwrap();
+    let err = verify_tdx_measure_acpi_tables_requirement(
+        &app_compose,
+        r#"{"tdx_attestation_variant":"lite"}"#,
+        AttestationMode::DstackTdx,
+    )
+    .unwrap_err();
+    assert!(err.to_string().contains("tdx_measure_acpi_tables=true"));
+
+    let app_compose: AppCompose = serde_json::from_value(serde_json::json!({
+        "manifest_version": "3",
+        "name": "test",
+        "runner": "docker-compose",
+        "requirements": {
+            "tdx_measure_acpi_tables": false
+        }
+    }))
+    .unwrap();
+    verify_tdx_measure_acpi_tables_requirement(
+        &app_compose,
+        r#"{"tdx_attestation_variant":"lite"}"#,
+        AttestationMode::DstackTdx,
+    )
+    .unwrap();
+    let err = verify_tdx_measure_acpi_tables_requirement(
+        &app_compose,
+        r#"{}"#,
+        AttestationMode::DstackTdx,
+    )
+    .unwrap_err();
+    assert!(err.to_string().contains("tdx_measure_acpi_tables=false"));
+}
+
+#[test]
+fn test_tdx_measure_acpi_tables_requirement_ignored_on_non_tdx() {
+    let app_compose: AppCompose = serde_json::from_value(serde_json::json!({
+        "manifest_version": "3",
+        "name": "test",
+        "runner": "docker-compose",
+        "requirements": {
+            "tdx_measure_acpi_tables": true
+        }
+    }))
+    .unwrap();
+    verify_tdx_measure_acpi_tables_requirement(
+        &app_compose,
+        r#"{"tdx_attestation_variant":"lite"}"#,
+        AttestationMode::DstackAmdSevSnp,
+    )
+    .unwrap();
+}
+
 #[test]
 fn test_os_release_value_parses_quoted_version_id() {
     let content = r#"

sdk/go/dstack/compose_hash.go

@@ -39,8 +39,9 @@ const (
 
 // Requirements represents guest-side requirements.
 type Requirements struct {
-	OsVersion string                 `json:"os_version,omitempty"`
-	Platforms *[]RequirementPlatform `json:"platforms,omitempty"`
+	OsVersion            string                 `json:"os_version,omitempty"`
+	Platforms            *[]RequirementPlatform `json:"platforms,omitempty"`
+	TdxMeasureAcpiTables *bool                  `json:"tdx_measure_acpi_tables,omitempty"`
 }
 
 // AppCompose represents the application composition structure

sdk/js/src/get-compose-hash.ts

@@ -51,6 +51,7 @@ export interface DockerConfig extends SortableObject {
 export interface Requirements extends SortableObject {
   os_version?: string;
   platforms?: RequirementPlatform[];
+  tdx_measure_acpi_tables?: boolean;
 }
 
 export interface AppCompose extends SortableObject {

sdk/python/src/dstack_sdk/get_compose_hash.py

@@ -53,10 +53,12 @@ def __init__(
         self,
         os_version: Optional[str] = None,
         platforms: Optional[List[str]] = None,
+        tdx_measure_acpi_tables: Optional[bool] = None,
     ) -> None:
         """Initialize a new ``Requirements`` instance."""
         self.os_version = os_version
         self.platforms = platforms
+        self.tdx_measure_acpi_tables = tdx_measure_acpi_tables
 
     def to_dict(self) -> Dict[str, Any]:
         """Return a dictionary representation excluding ``None`` fields."""
@@ -65,6 +67,8 @@ def to_dict(self) -> Dict[str, Any]:
             result["os_version"] = self.os_version
         if self.platforms is not None:
             result["platforms"] = self.platforms
+        if self.tdx_measure_acpi_tables is not None:
+            result["tdx_measure_acpi_tables"] = self.tdx_measure_acpi_tables
         return result