guest: address review feedback on compose version policy

- Allow requirements on any manifest_version >= 3 instead of == 3, so a
  future v4 guest does not reject v4 manifests carrying requirements
- Reject non-canonical manifest_version strings like "03" and "+3"
- Rewrite unquote_os_release_value with single-pass escape handling
  (fixes backslash-before-quote mishandling; single quotes take no
  escapes, matching shell semantics)
- Add tests for the above

Author: kvinwang

dstack-types/src/lib.rs

@@ -197,6 +197,11 @@ fn parse_manifest_version_string(value: &str) -> Result<String, String> {
     if parsed == 0 {
         return Err("manifest_version must be greater than 0".to_string());
     }
+    if parsed.to_string() != value {
+        return Err(format!(
+            "manifest_version must be a canonical integer string, got {value:?}"
+        ));
+    }
     Ok(parsed.to_string())
 }
 
@@ -346,6 +351,28 @@ mod app_compose_tests {
         assert!(err.to_string().contains("legacy versions 1 and 2"));
     }
 
+    #[test]
+    fn manifest_version_rejects_invalid_numeric_values() {
+        let err = parse_compose(serde_json::json!(0)).unwrap_err();
+        assert!(err.to_string().contains("legacy versions 1 and 2"));
+        let err = parse_compose(serde_json::json!(-1)).unwrap_err();
+        assert!(err.to_string().contains("positive integer"));
+        assert!(parse_compose(serde_json::json!(2.5)).is_err());
+    }
+
+    #[test]
+    fn manifest_version_rejects_non_canonical_strings() {
+        let err = parse_compose(serde_json::json!("0")).unwrap_err();
+        assert!(err.to_string().contains("greater than 0"));
+        let err = parse_compose(serde_json::json!("03")).unwrap_err();
+        assert!(err.to_string().contains("canonical integer string"));
+        let err = parse_compose(serde_json::json!("+3")).unwrap_err();
+        assert!(err.to_string().contains("canonical integer string"));
+        let err = parse_compose(serde_json::json!("")).unwrap_err();
+        assert!(err.to_string().contains("must not be empty"));
+        assert!(parse_compose(serde_json::json!("3.0")).is_err());
+    }
+
     #[test]
     fn requirements_support_os_version_and_platforms() {
         let compose: AppCompose = serde_json::from_value(serde_json::json!({

dstack-util/src/system_setup.rs

@@ -797,9 +797,9 @@ fn verify_app_compose_policy(app_compose: &AppCompose) -> Result<()> {
 
 fn verify_manifest_feature_requirements(app_compose: &AppCompose) -> Result<()> {
     let manifest_version = verify_manifest_version(app_compose)?;
-    if app_compose.requirements.is_some() && manifest_version != MANIFEST_VERSION_3 {
+    if app_compose.requirements.is_some() && manifest_version < MANIFEST_VERSION_3 {
         bail!(
-            "requirements requires manifest_version == {MANIFEST_VERSION_3}; use string manifest_version \"{MANIFEST_VERSION_3}\" so older guests fail closed"
+            "requirements requires manifest_version >= {MANIFEST_VERSION_3}; use string manifest_version \"{MANIFEST_VERSION_3}\" so older guests fail closed"
         );
     }
     Ok(())
@@ -900,16 +900,21 @@ fn os_release_value(content: &str, key: &str) -> Option<String> {
 
 fn unquote_os_release_value(value: &str) -> String {
     let value = value.trim();
-    let bytes = value.as_bytes();
-    if bytes.len() >= 2
-        && ((bytes[0] == b'"' && bytes[bytes.len() - 1] == b'"')
-            || (bytes[0] == b'\'' && bytes[bytes.len() - 1] == b'\''))
-    {
-        let inner = &value[1..value.len() - 1];
-        return inner
-            .replace("\\\"", "\"")
-            .replace("\\'", "'")
-            .replace("\\\\", "\\");
+    if let Some(inner) = value.strip_prefix('"').and_then(|v| v.strip_suffix('"')) {
+        // Double-quoted: a backslash escapes the next character.
+        let mut unescaped = String::with_capacity(inner.len());
+        let mut chars = inner.chars();
+        while let Some(c) = chars.next() {
+            match c {
+                '\\' => unescaped.push(chars.next().unwrap_or('\\')),
+                _ => unescaped.push(c),
+            }
+        }
+        return unescaped;
+    }
+    if let Some(inner) = value.strip_prefix('\'').and_then(|v| v.strip_suffix('\'')) {
+        // Single-quoted: shell single quotes have no escape sequences.
+        return inner.to_string();
     }
     value.to_string()
 }
@@ -2204,3 +2209,19 @@ VERSION_ID="0.6.1"
         Some("0.6.1")
     );
 }
+
+#[test]
+fn test_unquote_os_release_value_handles_quoting_styles() {
+    assert_eq!(unquote_os_release_value("0.6.1"), "0.6.1");
+    assert_eq!(unquote_os_release_value("\"0.6.1\""), "0.6.1");
+    assert_eq!(unquote_os_release_value("'0.6.1'"), "0.6.1");
+    // Double-quoted: backslash escapes the next character.
+    assert_eq!(unquote_os_release_value(r#""a\"b""#), "a\"b");
+    assert_eq!(unquote_os_release_value(r#""a\\b""#), r"a\b");
+    assert_eq!(unquote_os_release_value(r#""a\\\"b""#), r#"a\"b"#);
+    // Single-quoted: no escape sequences.
+    assert_eq!(unquote_os_release_value(r"'a\\b'"), r"a\\b");
+    // Unbalanced/degenerate quotes are returned verbatim.
+    assert_eq!(unquote_os_release_value("\""), "\"");
+    assert_eq!(unquote_os_release_value("\"a"), "\"a");
+}