Enum Capability 

pub enum Capability {
    InterfaceAccess {
        name: String,
    },
    NetworkEndpoint {
        url: String,
    },
    KeyAccess {
        key_id: String,
    },
    FilesystemPath {
        path: PathBuf,
        mode: FilesystemMode,
    },
}

A capability a sandboxed plugin may be granted.

Capabilities are explicit, granular, and revocable. The sandbox runtime checks every host-import invocation against the instance’s current capability set; a denied call traps with Error::CapabilityDenied.

For the process sandbox the capability set is enforced host-side: the host refuses to forward a cfm_* call to the subprocess unless the matching capability is present. (A future revision may push the capability gate into a seccomp/AppSandbox profile on the child.)

Variants

InterfaceAccess

Plugin may call the cfm_<name>_* host-import family (e.g. InterfaceAccess { name: "hash" } enables cfm_hash_*).

Fields

name: String

NetworkEndpoint

Plugin may talk to this network endpoint.

Fields

url: String

KeyAccess

Plugin may reference this key (read/use, never reveal bytes).

Fields

key_id: String

FilesystemPath

Plugin may read/write this filesystem path.

Fields

path: PathBuf

mode: FilesystemMode

Trait Implementations

impl Clone for Capability

fn clone(&self) -> Capability

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Capability

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Capability

impl Hash for Capability

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Capability

fn eq(&self, other: &Capability) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Capability