fix(policy): align wildcard and sigv4 body validation

Signed-off-by: Russell Bryant <rbryant@redhat.com>

Author: russellb

crates/openshell-policy/src/lib.rs

@@ -935,7 +935,10 @@ pub fn validate_sandbox_policy(
 }
 
 fn host_wildcard_shape_invalid(host: &str) -> bool {
-    if !host.contains('*') || host == "*" || host == "**" {
+    if host == "*" || host == "**" {
+        return true;
+    }
+    if !host.contains('*') {
         return false;
     }
     let labels: Vec<&str> = host.split('.').collect();
@@ -1447,6 +1450,33 @@ network_policies:
         );
     }
 
+    #[test]
+    fn validate_rejects_all_host_star_wildcards() {
+        for host in ["*", "**"] {
+            let mut policy = restrictive_default_policy();
+            policy.network_policies.insert(
+                "bad".into(),
+                NetworkPolicyRule {
+                    name: "bad-rule".into(),
+                    endpoints: vec![NetworkEndpoint {
+                        host: host.into(),
+                        port: 443,
+                        ..Default::default()
+                    }],
+                    ..Default::default()
+                },
+            );
+
+            let violations = validate_sandbox_policy(&policy).unwrap_err();
+            assert!(
+                violations
+                    .iter()
+                    .any(|v| matches!(v, PolicyViolation::InvalidHostWildcard { .. })),
+                "expected bare host wildcard {host:?} to be rejected, got {violations:?}"
+            );
+        }
+    }
+
     #[test]
     fn validate_accepts_subdomain_wildcard() {
         let mut policy = restrictive_default_policy();

crates/openshell-supervisor-network/src/l7/rest.rs

@@ -560,11 +560,17 @@ where
                         // route chunked requests to the streaming path, but
                         // guard here as defense-in-depth.
                         let body_length = parse_body_length(header_str)?;
-                        if matches!(body_length, BodyLength::Chunked) {
-                            return Err(miette!(
-                                "SigV4 body signing requires Content-Length; \
-                                 chunked transfer encoding is not supported in this mode"
-                            ));
+                        match body_length {
+                            BodyLength::ContentLength(_) => {}
+                            BodyLength::Chunked => {
+                                return Err(miette!(
+                                    "SigV4 body signing requires Content-Length; \
+                                     chunked transfer encoding is not supported in this mode"
+                                ));
+                            }
+                            BodyLength::None => {
+                                return Err(miette!("SigV4 body signing requires Content-Length"));
+                            }
                         }
                         // NOTE(defense-in-depth): Build the full request from
                         // rewritten headers + body. `rewrite_result.rewritten`
@@ -5262,6 +5268,87 @@ mod tests {
         assert!(!forwarded.contains("openshell:resolve:env:"));
     }
 
+    #[tokio::test]
+    async fn relay_sigv4_body_signing_rejects_missing_content_length() {
+        let (_, resolver) = SecretResolver::from_provider_env(
+            [
+                ("AWS_ACCESS_KEY_ID".to_string(), "AKIATESTKEY".to_string()),
+                (
+                    "AWS_SECRET_ACCESS_KEY".to_string(),
+                    "test-secret-key".to_string(),
+                ),
+            ]
+            .into_iter()
+            .collect(),
+        );
+        let resolver = resolver.expect("resolver");
+
+        let raw_header =
+            b"PUT /bucket/key HTTP/1.1\r\nHost: s3.us-east-1.amazonaws.com\r\n\r\n".to_vec();
+        let req = L7Request {
+            action: "PUT".to_string(),
+            target: "/bucket/key".to_string(),
+            query_params: HashMap::new(),
+            raw_header,
+            body_length: BodyLength::None,
+        };
+        let (mut proxy_to_upstream, mut upstream_side) = tokio::io::duplex(8192);
+        let (mut _app_side, mut proxy_to_client) = tokio::io::duplex(8192);
+
+        let upstream_task = tokio::spawn(async move {
+            let mut buf = vec![0u8; 8192];
+            let mut total = 0usize;
+            loop {
+                let n = upstream_side.read(&mut buf[total..]).await.unwrap();
+                if n == 0 {
+                    break;
+                }
+                total += n;
+                if buf[..total].windows(4).any(|w| w == b"\r\n\r\n") {
+                    upstream_side
+                        .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
+                        .await
+                        .unwrap();
+                    upstream_side.flush().await.unwrap();
+                    break;
+                }
+            }
+            String::from_utf8_lossy(&buf[..total]).to_string()
+        });
+
+        let relay_result = tokio::time::timeout(
+            std::time::Duration::from_secs(5),
+            relay_http_request_with_options_guarded(
+                &req,
+                &mut proxy_to_client,
+                &mut proxy_to_upstream,
+                RelayRequestOptions {
+                    resolver: Some(&resolver),
+                    credential_signing: crate::l7::CredentialSigning::SigV4Body,
+                    signing_service: "s3",
+                    signing_region: "us-east-1",
+                    host: "s3.us-east-1.amazonaws.com",
+                    port: 443,
+                    ..Default::default()
+                },
+            ),
+        )
+        .await
+        .expect("relay must not deadlock");
+        drop(proxy_to_upstream);
+        let forwarded = upstream_task.await.expect("upstream task should complete");
+
+        let err = relay_result.expect_err("missing Content-Length should fail closed");
+        assert!(
+            err.to_string().contains("requires Content-Length"),
+            "unexpected error: {err}"
+        );
+        assert!(
+            forwarded.is_empty(),
+            "request missing Content-Length must not reach upstream: {forwarded}"
+        );
+    }
+
     #[tokio::test]
     async fn relay_injects_url_path_credential_telegram_style() {
         let (child_env, resolver) = SecretResolver::from_provider_env(