WebAssembly Component Model (WASI 0.2) 線形メモリ境界分離と Capability-Based Security の数理検証

#![forbid(unsafe_code)]

pub const WASM_PAGE_BYTES: u64 = 65_536;
pub const MAX_COMPONENT_HANDLES: usize = 256;

/// Fine-grained WASI 0.2 capability rights bitmask.
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CapabilityRights(pub u32);

impl CapabilityRights {
    pub const NONE: Self = Self(0);
    pub const STREAM_READ: Self = Self(1 << 0);
    pub const STREAM_WRITE: Self = Self(1 << 1);
    pub const HTTP_OUTGOING_GET: Self = Self(1 << 2);
    pub const MONOTONIC_CLOCK: Self = Self(1 << 3);

    #[inline]
    pub const fn contains(self, required: Self) -> bool {
        (self.0 & required.0) == required.0
    }

    /// Monotonic capability attenuation: child rights can never exceed parent rights.
    #[inline]
    pub const fn attenuate(self, mask: Self) -> Self {
        Self(self.0 & mask.0)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ResourceKind {
    MemoryInputStream,
    MemoryOutputStream,
    ScopedHttpEndpoint { allowed_origin_hash: u64 },
}

/// Unforgeable generational handle passed across the Canonical ABI boundary.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct GuestHandle {
    pub slot_index: u16,
    pub generation: u16,
}

#[derive(Clone, Copy, Debug)]
struct HandleSlot {
    generation: u16,
    occupied: bool,
    active_borrows: u16,
    kind: ResourceKind,
    rights: CapabilityRights,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SandboxTrap {
    OutOfBoundsLinearMemory { effective_addr: u64, limit_bytes: u64 },
    MemoryPageQuotaExceeded { requested_pages: u32, max_pages: u32 },
    FuelExhausted { budget: u64 },
    InvalidOrForgedHandle,
    UseAfterDropGenerationMismatch,
    CapabilityRightsDenied { required: CapabilityRights, actual: CapabilityRights },
    CannotDropBorrowedResource { active_borrows: u16 },
    HandleTableCapacityExhausted,
    InvalidUtf8CanonicalLift,
}

/// Isolated WASI 0.2 Component Instance State (Shared-Nothing Memory + Handle Table + Fuel).
pub struct WasiComponentSandbox {
    linear_memory: Vec<u8>,
    current_pages: u32,
    max_pages: u32,
    fuel_remaining: u64,
    initial_fuel_budget: u64,
    handle_table: [HandleSlot; MAX_COMPONENT_HANDLES],
}

impl WasiComponentSandbox {
    pub fn new(initial_pages: u32, max_pages: u32, fuel_budget: u64) -> Result<Self, SandboxTrap> {
        if initial_pages > max_pages {
            return Err(SandboxTrap::MemoryPageQuotaExceeded {
                requested_pages: initial_pages,
                max_pages,
            });
        }
        let byte_len = (initial_pages as usize) * (WASM_PAGE_BYTES as usize);
        let empty_slot = HandleSlot {
            generation: 1,
            occupied: false,
            active_borrows: 0,
            kind: ResourceKind::MemoryInputStream,
            rights: CapabilityRights::NONE,
        };
        Ok(Self {
            linear_memory: vec![0u8; byte_len],
            current_pages: initial_pages,
            max_pages,
            fuel_remaining: fuel_budget,
            initial_fuel_budget: fuel_budget,
            handle_table: [empty_slot; MAX_COMPONENT_HANDLES],
        })
    }

    /// Consumes deterministic instruction fuel; traps immediately on exhaustion.
    #[inline]
    pub fn consume_fuel(&mut self, instructions: u64) -> Result<(), SandboxTrap> {
        if self.fuel_remaining < instructions {
            self.fuel_remaining = 0;
            return Err(SandboxTrap::FuelExhausted {
                budget: self.initial_fuel_budget,
            });
        }
        self.fuel_remaining -= instructions;
        Ok(())
    }

    /// Verifies W3C WebAssembly 2.0 spatial bounds: 0 <= addr + offset + len <= N_pages * 65536.
    #[inline]
    pub fn verify_memory_slice(
        &self,
        base_addr: u32,
        static_offset: u32,
        byte_len: u32,
    ) -> Result<&[u8], SandboxTrap> {
        let effective_addr = (base_addr as u64) + (static_offset as u64);
        let end_addr = effective_addr + (byte_len as u64);
        let limit_bytes = (self.current_pages as u64) * WASM_PAGE_BYTES;

        if end_addr > limit_bytes || end_addr > (self.linear_memory.len() as u64) {
            return Err(SandboxTrap::OutOfBoundsLinearMemory {
                effective_addr: end_addr,
                limit_bytes,
            });
        }
        Ok(&self.linear_memory[(effective_addr as usize)..(end_addr as usize)])
    }

    /// Canonical ABI Lift for UTF-8 strings across Shared-Nothing component boundary.
    pub fn canonical_lift_utf8(
        &mut self,
        ptr: u32,
        len: u32,
    ) -> Result<String, SandboxTrap> {
        self.consume_fuel(16 + (len as u64))?;
        let slice = self.verify_memory_slice(ptr, 0, len)?;
        core::str::from_utf8(slice)
            .map(str::to_owned)
            .map_err(|_| SandboxTrap::InvalidUtf8CanonicalLift)
    }

    /// Grants a scoped resource capability into the component's local handle table.
    pub fn insert_capability(
        &mut self,
        kind: ResourceKind,
        rights: CapabilityRights,
    ) -> Result<GuestHandle, SandboxTrap> {
        for (idx, slot) in self.handle_table.iter_mut().enumerate() {
            if !slot.occupied {
                slot.occupied = true;
                slot.active_borrows = 0;
                slot.kind = kind;
                slot.rights = rights;
                return Ok(GuestHandle {
                    slot_index: idx as u16,
                    generation: slot.generation,
                });
            }
        }
        Err(SandboxTrap::HandleTableCapacityExhausted)
    }

    /// Attenuates an existing handle into a restricted child handle (Rights_child <= Rights_parent).
    pub fn attenuate_handle(
        &mut self,
        parent: GuestHandle,
        mask: CapabilityRights,
    ) -> Result<GuestHandle, SandboxTrap> {
        let (kind, parent_rights) = self.verify_capability(parent, CapabilityRights::NONE)?;
        let child_rights = parent_rights.attenuate(mask);
        self.insert_capability(kind, child_rights)
    }

    /// Validates handle index, generation counter, and required capability rights bitmask.
    pub fn verify_capability(
        &self,
        handle: GuestHandle,
        required: CapabilityRights,
    ) -> Result<(ResourceKind, CapabilityRights), SandboxTrap> {
        let idx = handle.slot_index as usize;
        if idx >= MAX_COMPONENT_HANDLES {
            return Err(SandboxTrap::InvalidOrForgedHandle);
        }
        let slot = &self.handle_table[idx];
        if !slot.occupied {
            return Err(SandboxTrap::UseAfterDropGenerationMismatch);
        }
        if slot.generation != handle.generation {
            return Err(SandboxTrap::UseAfterDropGenerationMismatch);
        }
        if !slot.rights.contains(required) {
            return Err(SandboxTrap::CapabilityRightsDenied {
                required,
                actual: slot.rights,
            });
        }
        Ok((slot.kind, slot.rights))
    }

    /// Drops an owned capability handle and increments slot generation to prevent Use-After-Close.
    pub fn drop_capability(&mut self, handle: GuestHandle) -> Result<(), SandboxTrap> {
        let idx = handle.slot_index as usize;
        if idx >= MAX_COMPONENT_HANDLES {
            return Err(SandboxTrap::InvalidOrForgedHandle);
        }
        let slot = &mut self.handle_table[idx];
        if !slot.occupied || slot.generation != handle.generation {
            return Err(SandboxTrap::UseAfterDropGenerationMismatch);
        }
        if slot.active_borrows > 0 {
            return Err(SandboxTrap::CannotDropBorrowedResource {
                active_borrows: slot.active_borrows,
            });
        }
        slot.occupied = false;
        slot.rights = CapabilityRights::NONE;
        slot.generation = slot.generation.wrapping_add(1).max(1);
        Ok(())
    }
}