Ensure valid wasms when publishing app

Signed-off-by: Brian Hardock <[email protected]>

Author: fibonacci1729

Cargo.lock

@@ -30,6 +30,7 @@ tokio = { workspace = true, features = ["fs"] }
 tokio-util = { version = "0.7", features = ["compat"] }
 tracing = { workspace = true }
 walkdir = { workspace = true }
+wasmparser = { workspace = true }
 
 [dev-dependencies]
 wasm-encoder = { workspace = true }

crates/oci/Cargo.toml

@@ -24,6 +24,7 @@ use tokio::fs;
 use walkdir::WalkDir;
 
 use crate::auth::AuthConfig;
+use crate::validate;
 
 // TODO: the media types for application, data and archive layer are not final
 /// Media type for a layer representing a locked Spin application configuration
@@ -149,6 +150,12 @@ impl Client {
         )
         .await?;
 
+        // Ensure that all Spin components specify valid wasm binaries in both the `source`
+        // field and for each dependency.
+        for locked_component in &locked.components {
+            validate::ensure_wasms(locked_component).await?;
+        }
+
         self.push_locked_core(
             locked,
             auth,

crates/oci/src/client.rs

@@ -5,6 +5,7 @@ mod auth;
 pub mod client;
 mod loader;
 pub mod utils;
+mod validate;
 
 pub use client::{Client, ComposeMode};
 pub use loader::OciLoader;

crates/oci/src/lib.rs

@@ -0,0 +1,186 @@
+use anyhow::{bail, Context, Result};
+use spin_locked_app::locked::LockedComponent;
+use tokio::fs;
+
+// Validate that all Spin components specify valid wasm binaries in both the `source`
+// field and for each dependency.
+pub async fn ensure_wasms(component: &LockedComponent) -> Result<()> {
+    // Ensure that the component source is a valid wasm binary.
+    if let Some(source) = &component.source.content.source {
+        let bytes = fs::read(&source)
+            .await
+            .with_context(|| format!("Failed to read component `{}` source", component.id))?;
+
+        if !is_wasm_binary(&bytes) {
+            bail!(
+                "Component {} source is not a valid .wasm file",
+                component.id,
+            );
+        }
+    }
+    // Ensure that each dependency is a valid wasm binary.
+    for (dep_name, dep) in &component.dependencies {
+        if let Some(source) = &dep.source.content.source {
+            let bytes = fs::read(&source).await.with_context(|| {
+                format!(
+                    "Failed to read dependency `{}` for component `{}`",
+                    dep_name, component.id
+                )
+            })?;
+            if !is_wasm_binary(&bytes) {
+                bail!(
+                    "Dependency {} for component {} is not a valid .wasm file",
+                    dep_name,
+                    component.id,
+                );
+            }
+        }
+    }
+    Ok(())
+}
+
+fn is_wasm_binary(bytes: &[u8]) -> bool {
+    wasmparser::Parser::is_component(bytes) || wasmparser::Parser::is_core_wasm(bytes)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::from_json;
+    use spin_locked_app::locked::LockedComponent;
+    use tokio::io::AsyncWriteExt;
+
+    #[tokio::test]
+    async fn ensures_valid_wasm_binaries() {
+        let working_dir = tempfile::tempdir().unwrap();
+        let _ = tokio::fs::create_dir(working_dir.path()).await;
+
+        // valid component source
+        let mut valid_wasm_component_file =
+            tokio::fs::File::create(working_dir.path().join("component.wasm"))
+                .await
+                .expect("should create component file");
+        valid_wasm_component_file
+            .write_all(b"\x00\x61\x73\x6D\x0D\x00\x01\x00")
+            .await
+            .expect("should write file contents");
+
+        // valid core module source
+        let mut valid_wasm_core_module_file =
+            tokio::fs::File::create(working_dir.path().join("module.wasm"))
+                .await
+                .expect("should create core module file");
+        valid_wasm_core_module_file
+            .write_all(b"\x00\x61\x73\x6D\x01\x00\x00\x00")
+            .await
+            .expect("should write file contents");
+
+        // invalid wasm binary
+        let mut invalid_wasm_binary = tokio::fs::File::create(working_dir.path().join("invalid"))
+            .await
+            .expect("should create file");
+        invalid_wasm_binary
+            .write_all(b"not a wasm file")
+            .await
+            .expect("should write file contents");
+
+        #[derive(Clone)]
+        struct TestCase {
+            name: &'static str,
+            locked_component: LockedComponent,
+            valid: bool,
+        }
+
+        let tests: Vec<TestCase> = vec![
+            TestCase {
+                name: "Valid Spin component source field with component",
+                locked_component: from_json!({
+                    "id": "component",
+                    "source": {
+                        "content_type": "application/wasm",
+                        "source": working_dir.path().join("component.wasm").to_str().unwrap().to_string(),
+                        "digest": "digest",
+                    }
+                }),
+                valid: true,
+            },
+            TestCase {
+                name: "Valid Spin component source field with core module",
+                locked_component: from_json!({
+                    "id": "component",
+                    "source": {
+                        "content_type": "application/wasm",
+                        "source": working_dir.path().join("module.wasm").to_str().unwrap().to_string(),
+                        "digest": "digest",
+                    }
+                }),
+                valid: true,
+            },
+            TestCase {
+                name: "Valid Spin component source field with valid wasm dependency",
+                locked_component: from_json!({
+                    "id": "component",
+                    "source": {
+                        "content_type": "application/wasm",
+                        "source": working_dir.path().join("component.wasm").to_str().unwrap().to_string(),
+                        "digest": "digest",
+                    },
+                    "dependencies": {
+                        "test:comp2": {
+                            "source": {
+                                "content_type": "application/wasm",
+                                "source": working_dir.path().join("component.wasm").to_str().unwrap().to_string(),
+                                "digest": "digest",
+                            },
+                            "export": null,
+                        }
+                    }
+                }),
+                valid: true,
+            },
+            TestCase {
+                name: "Invalid Spin component source field with invalid wasm binary",
+                locked_component: from_json!({
+                    "id": "component",
+                    "source": {
+                        "content_type": "application/wasm",
+                        "source": working_dir.path().join("invalid").to_str().unwrap().to_string(),
+                        "digest": "digest",
+                    }
+                }),
+                valid: false,
+            },
+            TestCase {
+                name: "Valid Spin component source field with invalid wasm dependency",
+                locked_component: from_json!({
+                    "id": "component",
+                    "source": {
+                        "content_type": "application/wasm",
+                        "source": working_dir.path().join("component.wasm").to_str().unwrap().to_string(),
+                        "digest": "digest",
+                    },
+                    "dependencies": {
+                        "test:comp2": {
+                            "source": {
+                                "content_type": "application/wasm",
+                                "source": working_dir.path().join("invalid").to_str().unwrap().to_string(),
+                                "digest": "digest",
+                            },
+                            "export": null,
+                        }
+                    }
+                }),
+                valid: false,
+            },
+        ];
+
+        for tc in tests {
+            let result = ensure_wasms(&tc.locked_component).await;
+            if tc.valid {
+                assert!(result.is_ok(), "Test failed: {}", tc.name);
+            } else {
+                assert!(result.is_err(), "Test should have failed: {}", tc.name);
+            }
+        }
+    }
+}