Enum ProcessPermission 

pub enum ProcessPermission {
    DynTransition,
    ExecHeap,
    ExecMem,
    ExecStack,
    Fork,
    GetCap,
    GetPgid,
    GetRlimit,
    GetSched,
    GetSession,
    NoAtSecure,
    Ptrace,
    RlimitInh,
    SetCap,
    SetCurrent,
    SetExec,
    SetFsCreate,
    SetKeyCreate,
    SetPgid,
    SetRlimit,
    SetSched,
    SetSockCreate,
    Share,
    SigChld,
    SigInh,
    SigKill,
    SigStop,
    Signal,
    Transition,
}

A well-known “process” class permission in SELinux policy that has a particular meaning in policy enforcement hooks.

Variants

DynTransition

Permission to dynamically transition a process to a different security domain.

ExecHeap

Permission to execute arbitrary code from the heap.

ExecMem

Permission to execute arbitrary code from memory.

ExecStack

Permission to execute arbitrary code from the stack.

Fork

Permission to fork the current running process.

GetCap

Permission to get Linux capabilities of a process.

GetPgid

Permission to get the process group ID.

GetRlimit

Permission to get the resource limits on a process.

GetSched

Permission to get scheduling policy currently applied to a process.

GetSession

Permission to get the session ID.

NoAtSecure

Permission to exec into a new security domain without setting the AT_SECURE entry in the executable’s auxiliary vector.

Ptrace

Permission to trace a process.

RlimitInh

Permission to inherit the parent process’s resource limits on exec.

SetCap

Permission to set Linux capabilities of a process.

SetCurrent

Permission to set the calling task’s current Security Context. The “dyntransition” permission separately limits which Contexts “setcurrent” may be used to transition to.

SetExec

Permission to set the Security Context used by exec().

SetFsCreate

Permission to set the Security Context used when creating filesystem objects.

SetKeyCreate

Permission to set the Security Context used when creating kernel keyrings.

SetPgid

Permission to set the process group ID.

SetRlimit

Permission to set the resource limits on a process.

SetSched

Permission to set scheduling policy for a process.

SetSockCreate

Permission to set the Security Context used when creating new labeled sockets.

Share

Permission to share resources (e.g. FD table, address-space, etc) with a process.

SigChld

Permission to send SIGCHLD to a process.

SigInh

Permission to inherit the parent process’s signal state.

SigKill

Permission to send SIGKILL to a process.

SigStop

Permission to send SIGSTOP to a process.

Signal

Permission to send a signal other than SIGKILL, SIGSTOP, or SIGCHLD to a process.

Transition

Permission to transition to a different security domain.

Implementations

impl ProcessPermission

pub fn all_variants() -> impl Iterator<Item = Self>

Trait Implementations

impl ClassPermission for ProcessPermission

fn class(&self) -> KernelClass

impl Clone for ProcessPermission

fn clone(&self) -> ProcessPermission

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessPermission

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

Formats the value using the given formatter.

impl From<ProcessPermission> for KernelPermission

fn from(v: ProcessPermission) -> Self

Converts to this type from the input type.

impl Hash for ProcessPermission

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 ProcessPermission

fn eq(&self, other: &ProcessPermission) -> 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 Eq for ProcessPermission

impl StructuralPartialEq for ProcessPermission