kobako 0.29.0 → 0.30.0

data/crates/kobako-wasmtime/src/trap.rs

@@ -9,10 +9,10 @@
 
 use std::time::{Duration, Instant};
 
-use wasmtime::{Store, StoreContextMut, UpdateDeadline};
+use wasmtime::{Store, StoreHookState, UpdateDeadline};
 
 use crate::invocation::Invocation;
-use crate::limiter::MemoryLimitTrap;
+use kobako_runtime::endpoint::MemoryLimitExceeded;
 use kobako_runtime::error::{SetupError, Trap};
 
 /// Marker error returned from the epoch-deadline callback when the
@@ -41,7 +41,7 @@ pub(crate) const NO_TIMEOUT_EPOCH_DELTA: u64 = u64::MAX / 2;
 /// firing; returning the same long extension keeps it inert as a defence
 /// in depth.
 pub(crate) fn epoch_deadline_callback(
-    ctx: StoreContextMut<'_, Invocation>,
+    ctx: StoreHookState<'_, Invocation>,
 ) -> wasmtime::Result<UpdateDeadline> {
     match ctx.data().deadline() {
         Some(deadline) if Instant::now() >= deadline => Err(wasmtime::Error::new(TimeoutTrap)),
@@ -78,7 +78,7 @@ pub(crate) fn cap_trap(err: &wasmtime::Error) -> Option<Trap> {
     if let Some(t) = err.downcast_ref::<TimeoutTrap>() {
         Some(Trap::Timeout(t.to_string()))
     } else {
-        err.downcast_ref::<MemoryLimitTrap>()
+        err.downcast_ref::<MemoryLimitExceeded>()
             .map(|t| Trap::MemoryLimit(t.to_string()))
     }
 }
@@ -107,12 +107,12 @@ pub(crate) fn instantiate_err(err: wasmtime::Error) -> SetupError {
 #[cfg(test)]
 mod tests {
     use super::{other_trap_message, to_trap, TimeoutTrap, NO_TIMEOUT_EPOCH_DELTA};
-    use crate::limiter::MemoryLimitTrap;
+    use kobako_runtime::endpoint::MemoryLimitExceeded;
     use kobako_runtime::error::Trap;
 
     // The no-timeout priming delta is added to the engine's current
     // epoch inside wasmtime, and the process-wide ticker advances that
-    // epoch from the first `shared_engine` call on — so the sum must
+    // epoch from the first `load_engine` call on — so the sum must
     // stay in range for a long-lived engine, not just a fresh one.
     // `increment_epoch` stands in for the ticker to make the ticked
     // state deterministic; under debug overflow checks an overflowing
@@ -120,7 +120,7 @@ mod tests {
     // @behavior S-119
     #[test]
     fn no_timeout_delta_survives_a_ticked_engine_epoch() {
-        let engine = crate::cache::shared_engine().expect("shared engine must be constructible");
+        let engine = crate::cache::load_engine().expect("shared engine must be constructible");
         engine.increment_epoch();
         let mut store = wasmtime::Store::new(engine, ());
         store.set_epoch_deadline(NO_TIMEOUT_EPOCH_DELTA);
@@ -136,8 +136,8 @@ mod tests {
 
     // @behavior OC-033
     #[test]
-    fn to_trap_routes_memory_limit_trap_to_memory_limit() {
-        let trap = MemoryLimitTrap::new(1 << 20, 1 << 19);
+    fn to_trap_routes_memory_limit_exceeded_to_memory_limit() {
+        let trap = MemoryLimitExceeded::new(1 << 20, 1 << 19);
         let expected = trap.to_string();
         let err = wasmtime::Error::new(trap);
         assert!(matches!(to_trap(err), Trap::MemoryLimit(msg) if msg == expected));

data/crates/kobako-wasmtime/src/wasi.rs

@@ -4,18 +4,29 @@
 //! invocation was handed.
 
 use wasmtime_wasi::p1::WasiP1Ctx;
-use wasmtime_wasi::p2::pipe::{MemoryInputPipe, MemoryOutputPipe};
 use wasmtime_wasi::WasiCtxBuilder;
 
 use crate::ambient::{self, Clocks};
 use crate::config::Config;
 use crate::descriptors::Descriptors;
-use crate::{capture, guest_mem};
+use kobako_runtime::endpoint;
 use kobako_runtime::error::Trap;
+use std::sync::Arc;
+
+use kobako_runtime::filesystem::{create_pipe_files, PipeInodeInfo};
 use kobako_runtime::grant::Grant;
 use kobako_runtime::mount::Mount;
 use kobako_runtime::profile::Profile;
-use kobako_transport::abi::FRAME_LEN_SIZE;
+use kobako_runtime::security::prepare_creds_within;
+use kobako_runtime::vfs::Cred;
+
+/// The Cred an invocation's Mounts open as: kobako's own rules, then each
+/// module the Driver was built with, its Filesystems holding at most the
+/// memory the Driver allots, as Linux's `prepare_creds` gives a task the
+/// LSMs it booted with.
+fn prepare_creds(config: &Config) -> Arc<Cred> {
+    prepare_creds_within(&config.security, config.memory_limit)
+}
 
 /// One instance's WASI context: its descriptor table, the clocks its
 /// waits pass on, and the capture pipes stdout and stderr write into, so
@@ -24,8 +35,8 @@ pub(crate) struct Wasi {
     ctx: WasiP1Ctx,
     descriptors: Descriptors,
     clocks: Clocks,
-    stdout: MemoryOutputPipe,
-    stderr: MemoryOutputPipe,
+    stdout: Arc<PipeInodeInfo>,
+    stderr: Arc<PipeInodeInfo>,
 }
 
 impl Wasi {
@@ -34,14 +45,15 @@ impl Wasi {
     /// descriptor 3 in order.
     pub(crate) fn for_invocation(
         config: &Config,
-        preamble: &[u8],
+        stdin: Vec<u8>,
         grants: &[Grant],
     ) -> Result<Self, Trap> {
         Self::new(
-            preamble,
+            stdin,
             config.stdout_limit,
             config.stderr_limit,
             config.open_file_limit,
+            prepare_creds(config),
             config.profile,
             grants.iter().filter_map(to_mount).collect(),
         )
@@ -50,58 +62,61 @@ impl Wasi {
     /// A compile's context, at the strongest posture whatever the Sandbox
     /// requested: compiling the Snippets needs no ambient authority, so
     /// it is granted none.
-    pub(crate) fn for_compile(config: &Config, preamble: &[u8]) -> Result<Self, Trap> {
+    pub(crate) fn for_compile(config: &Config, stdin: Vec<u8>) -> Result<Self, Trap> {
         Self::new(
-            preamble,
+            stdin,
             config.stdout_limit,
             config.stderr_limit,
             config.open_file_limit,
+            prepare_creds(config),
             Profile::Hermetic,
             Vec::new(),
         )
     }
 
     /// The ABI version probe's context. Instantiating it runs the
-    /// artifact's start section, yet reading a version needs no ambient
-    /// authority and no output: the probe takes the strongest posture and
-    /// pipes sized to keep nothing.
+    /// artifact's start section, yet reading a version needs no input, no
+    /// ambient authority, and no output: the probe takes an empty stdin, the
+    /// strongest posture, and pipes sized to keep nothing.
     pub(crate) fn for_probe() -> Result<Self, Trap> {
-        Self::new(&[], Some(0), Some(0), None, Profile::Hermetic, Vec::new())
+        Self::new(
+            Vec::new(),
+            Some(0),
+            Some(0),
+            None,
+            prepare_creds_within(&[], None),
+            Profile::Hermetic,
+            Vec::new(),
+        )
     }
 
     /// An uncapped output channel has no ceiling on the host: a guest
-    /// rewriting one buffer grows the pipe, not its own memory. The 16 MiB
-    /// cap keeps the Preamble's `u32` length prefix from wrapping.
+    /// rewriting one buffer grows the pipe, not its own memory.
     fn new(
-        preamble: &[u8],
+        stdin: Vec<u8>,
         stdout_limit: Option<usize>,
         stderr_limit: Option<usize>,
         open_file_limit: Option<usize>,
+        opener: Arc<Cred>,
         profile: Profile,
         mounts: Vec<Mount>,
     ) -> Result<Self, Trap> {
-        // The Preamble carries the same 16 MiB cap as a downcall request
-        // (`io::write_request`): past it, the length prefix would silently wrap.
-        guest_mem::checked_payload_len(preamble.len())
-            .map_err(|msg| Trap::Other(msg.to_string()))?;
-
-        let mut stdin_content: Vec<u8> = Vec::with_capacity(FRAME_LEN_SIZE + preamble.len());
-        stdin_content.extend_from_slice(&(preamble.len() as u32).to_be_bytes());
-        stdin_content.extend_from_slice(preamble);
-
-        let stdout = MemoryOutputPipe::new(capture::pipe_capacity(stdout_limit));
-        let stderr = MemoryOutputPipe::new(capture::pipe_capacity(stderr_limit));
+        let stdout = PipeInodeInfo::new(endpoint::pipe_capacity(stdout_limit));
+        let stderr = PipeInodeInfo::new(endpoint::pipe_capacity(stderr_limit));
 
         // stdio lives in kobako's descriptor table, which answers every
         // call that reads a descriptor (`crate::preview1`); the builder
         // keeps only what the remaining imports read.
         let descriptors = Descriptors::new(
-            MemoryInputPipe::new(stdin_content),
-            stdout.clone(),
-            stderr.clone(),
+            create_pipe_files(&PipeInodeInfo::from_bytes(stdin), &opener).0,
+            create_pipe_files(&stdout, &opener).1,
+            create_pipe_files(&stderr, &opener).1,
             mounts,
             open_file_limit,
-        );
+            opener,
+            profile,
+        )
+        .map_err(|err| Trap::Other(format!("a Mount's root did not open: {err:?}")))?;
 
         let mut builder = WasiCtxBuilder::new();
         // The profile decides the ambient authority granted: the
@@ -151,11 +166,11 @@ impl Wasi {
     }
 
     pub(crate) fn stdout_bytes(&self) -> Vec<u8> {
-        self.stdout.contents().to_vec()
+        self.stdout.contents()
     }
 
     pub(crate) fn stderr_bytes(&self) -> Vec<u8> {
-        self.stderr.contents().to_vec()
+        self.stderr.contents()
     }
 }
 
@@ -164,7 +179,7 @@ impl Wasi {
 /// frontend from handing one over.
 fn to_mount(grant: &Grant) -> Option<Mount> {
     match grant {
-        Grant::Mount(mount) => Some(mount.for_invocation()),
+        Grant::Mount(mount) => Some(mount.clone()),
         _ => None,
     }
 }
@@ -178,7 +193,7 @@ mod tests {
     use wasmtime::{AsContextMut, Module, Store};
 
     use super::*;
-    use crate::cache::shared_engine;
+    use crate::cache::load_engine;
     use crate::imports;
     use crate::invocation::Invocation;
 
@@ -222,7 +237,7 @@ mod tests {
     /// Instantiate the probe over an invocation's WASI context built at
     /// `profile` and return a reader for its exports.
     fn probe(profile: Profile) -> impl FnMut(&str) -> i64 {
-        let engine = shared_engine().expect("shared engine must be constructible");
+        let engine = load_engine().expect("shared engine must be constructible");
         let config = Config {
             timeout: None,
             setup_timeout: None,
@@ -231,8 +246,9 @@ mod tests {
             stderr_limit: None,
             open_file_limit: None,
             profile,
+            security: Vec::new(),
         };
-        let wasi = Wasi::for_invocation(&config, &[], &[]).expect("WASI context must build");
+        let wasi = Wasi::for_invocation(&config, Vec::new(), &[]).expect("WASI context must build");
         let mut store = Store::new(engine, Invocation::new(None, wasi));
         store.set_epoch_deadline(crate::trap::NO_TIMEOUT_EPOCH_DELTA);