air_sys_syscall/

security.rs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

//! Wrappers de la famille `security` — seccomp-BPF primitif et Landlock.
//!
//! Cf. `docs/specs/layer-0/family-security.md`.
//!
//! **API primitive couche 0 :** cette crate charge un programme BPF
//! précompilé tel quel dans le kernel (pas de compilation BPF ici).
//! La couche 1 fournira l'API déclarative (règles → BPF).

#[cfg(not(any(target_arch = "x86_64", target_arch = "aarch64")))]
compile_error!("air-sys-syscall::security supporte uniquement x86_64 et aarch64 (ADR-014).");

use air_sys_types::fd::{AsRawFd, BorrowedFd, FromRawFd, OwnedFd};
use core::mem::size_of;
use core::num::NonZeroI32;

use air_sys_types::Errno;
use air_sys_types::security::{LandlockAccessFs, SeccompFilterFlags, SockFprog};

// ─────────────────────────────────────────────────────────────────────────
// Numéros de syscalls
// ─────────────────────────────────────────────────────────────────────────

#[cfg(target_arch = "x86_64")]
const SYS_SECCOMP: i64 = 317;
#[cfg(target_arch = "aarch64")]
const SYS_SECCOMP: i64 = 277;

#[cfg(target_arch = "x86_64")]
const SYS_LANDLOCK_CREATE_RULESET: i64 = 444;
#[cfg(target_arch = "aarch64")]
const SYS_LANDLOCK_CREATE_RULESET: i64 = 444;

#[cfg(target_arch = "x86_64")]
const SYS_LANDLOCK_ADD_RULE: i64 = 445;
#[cfg(target_arch = "aarch64")]
const SYS_LANDLOCK_ADD_RULE: i64 = 445;

#[cfg(target_arch = "x86_64")]
const SYS_LANDLOCK_RESTRICT_SELF: i64 = 446;
#[cfg(target_arch = "aarch64")]
const SYS_LANDLOCK_RESTRICT_SELF: i64 = 446;

// ─────────────────────────────────────────────────────────────────────────
// Constantes kernel
// ─────────────────────────────────────────────────────────────────────────

/// `seccomp(2)` — mode strict (seuls read/write/_exit/sigreturn autorisés).
const SECCOMP_SET_MODE_STRICT: u32 = 0;
/// `seccomp(2)` — charge un filtre BPF précompilé.
const SECCOMP_SET_MODE_FILTER: u32 = 1;

/// `landlock_create_ruleset(2)` — drapeaux : requête de version ABI.
const LANDLOCK_CREATE_RULESET_VERSION: u32 = 1;

/// `landlock_add_rule(2)` — type de règle : chemin filesystem.
const LANDLOCK_RULE_PATH_BENEATH: i32 = 1;

// ─────────────────────────────────────────────────────────────────────────
// Structures kernel internes (repr C, non exposées)
// ─────────────────────────────────────────────────────────────────────────

/// Attributs d'un ruleset Landlock (cf. `linux/landlock.h`).
#[repr(C)]
struct KernelLandlockRulesetAttr {
    handled_access_fs: u64,
}

/// Attributs d'une règle Landlock de type `PATH_BENEATH` (cf. `linux/landlock.h`).
#[repr(C)]
struct KernelLandlockPathBeneathAttr {
    allowed_access: u64,
    parent_fd: i32,
}

/// `struct sock_fprog` tel que vu par le kernel sur LP64 (x86_64/aarch64).
///
/// Sur LP64 : `{ u16 length, 6 octets de padding, u64 filter_ptr }` = 16 octets.
/// Le padding est nécessaire pour aligner le pointeur sur 8 octets.
#[repr(C)]
struct KernelSockFprog {
    len: u16,
    _pad: [u8; 6],
    filter: u64,
}

// ─────────────────────────────────────────────────────────────────────────
// Helpers syscalls bruts (privés, spécifiques à l'architecture)
// ─────────────────────────────────────────────────────────────────────────

/// Effectue `seccomp(op, flags, uargs)` et retourne la valeur brute i64.
///
/// # Safety
///
/// L'appelant est responsable de la validité de `uargs` pour l'opération
/// demandée. Pour `SECCOMP_SET_MODE_FILTER`, `uargs` doit pointer sur un
/// `KernelSockFprog` valide dont les instructions restent en mémoire
/// pendant la durée de l'appel.
#[cfg(target_arch = "x86_64")]
unsafe fn raw_syscall_seccomp(op: u32, flags: u32, uargs: u64) -> i64 {
    let ret: i64;
    // SAFETY (délégué à l'appelant) : voir doc de la fonction.
    // ABI syscall x86_64 : numéro dans RAX, args dans RDI, RSI, RDX.
    // Clobbe : RCX, R11 (préservés par l'ABI x86_64 de toute façon).
    unsafe {
        core::arch::asm!(
            "syscall",
            inlateout("rax") SYS_SECCOMP => ret,
            in("rdi") u64::from(op),
            in("rsi") u64::from(flags),
            in("rdx") uargs,
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
unsafe fn raw_syscall_seccomp(op: u32, flags: u32, uargs: u64) -> i64 {
    let ret: i64;
    // SAFETY (délégué à l'appelant) : voir doc de la fonction.
    // ABI syscall aarch64 : numéro dans x8, args dans x0..x5.
    unsafe {
        core::arch::asm!(
            "svc #0",
            inlateout("x0") u64::from(op) => ret,
            in("x1") u64::from(flags),
            in("x2") uargs,
            in("x8") SYS_SECCOMP as u64,
            options(nostack),
        );
    }
    ret
}

/// Effectue `landlock_create_ruleset(attr, size, flags)` et retourne le
/// résultat brut i64.
///
/// # Safety
///
/// `attr` doit être soit nul (requête de version ABI) soit un pointeur
/// valide sur un `KernelLandlockRulesetAttr` pour la durée de l'appel.
#[cfg(target_arch = "x86_64")]
unsafe fn raw_syscall_landlock_create_ruleset(attr: u64, size: u64, flags: u32) -> i64 {
    let ret: i64;
    unsafe {
        core::arch::asm!(
            "syscall",
            inlateout("rax") SYS_LANDLOCK_CREATE_RULESET => ret,
            in("rdi") attr,
            in("rsi") size,
            in("rdx") u64::from(flags),
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack),
        );
    }
    ret
}

/// Variante aarch64 de `raw_syscall_landlock_create_ruleset`.
///
/// # Safety
///
/// `attr` doit être soit nul (requête de version ABI) soit un pointeur
/// valide sur un `KernelLandlockRulesetAttr` pour la durée de l'appel.
#[cfg(target_arch = "aarch64")]
unsafe fn raw_syscall_landlock_create_ruleset(attr: u64, size: u64, flags: u32) -> i64 {
    let ret: i64;
    unsafe {
        core::arch::asm!(
            "svc #0",
            inlateout("x0") attr => ret,
            in("x1") size,
            in("x2") u64::from(flags),
            in("x8") SYS_LANDLOCK_CREATE_RULESET as u64,
            options(nostack),
        );
    }
    ret
}

/// Effectue `landlock_add_rule(ruleset_fd, rule_type, rule_attr, flags)`.
///
/// # Safety
///
/// `rule_attr` doit pointer sur un `KernelLandlockPathBeneathAttr` valide
/// pour la durée de l'appel.
#[cfg(target_arch = "x86_64")]
unsafe fn raw_syscall_landlock_add_rule(
    ruleset_fd: i32,
    rule_type: i32,
    rule_attr: u64,
    flags: u32,
) -> i64 {
    let ret: i64;
    unsafe {
        core::arch::asm!(
            "syscall",
            inlateout("rax") SYS_LANDLOCK_ADD_RULE => ret,
            in("rdi") i64::from(ruleset_fd),
            in("rsi") i64::from(rule_type),
            in("rdx") rule_attr,
            in("r10") u64::from(flags),
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack),
        );
    }
    ret
}

/// Variante aarch64 de `raw_syscall_landlock_add_rule`.
///
/// # Safety
///
/// `rule_attr` doit pointer sur un `KernelLandlockPathBeneathAttr` valide
/// pour la durée de l'appel.
#[cfg(target_arch = "aarch64")]
unsafe fn raw_syscall_landlock_add_rule(
    ruleset_fd: i32,
    rule_type: i32,
    rule_attr: u64,
    flags: u32,
) -> i64 {
    let ret: i64;
    unsafe {
        core::arch::asm!(
            "svc #0",
            inlateout("x0") i64::from(ruleset_fd) => ret,
            in("x1") i64::from(rule_type),
            in("x2") rule_attr,
            in("x3") u64::from(flags),
            in("x8") SYS_LANDLOCK_ADD_RULE as u64,
            options(nostack),
        );
    }
    ret
}

/// Effectue `landlock_restrict_self(ruleset_fd, flags)`.
#[cfg(target_arch = "x86_64")]
fn raw_syscall_landlock_restrict_self(ruleset_fd: i32, flags: u32) -> i64 {
    let ret: i64;
    // SAFETY:
    // - SYS_LANDLOCK_RESTRICT_SELF ne touche à aucune mémoire utilisateur.
    // - ABI x86_64 : numéro dans RAX, args dans RDI, RSI.
    unsafe {
        core::arch::asm!(
            "syscall",
            inlateout("rax") SYS_LANDLOCK_RESTRICT_SELF => ret,
            in("rdi") i64::from(ruleset_fd),
            in("rsi") u64::from(flags),
            lateout("rcx") _,
            lateout("r11") _,
            options(nostack),
        );
    }
    ret
}

#[cfg(target_arch = "aarch64")]
fn raw_syscall_landlock_restrict_self(ruleset_fd: i32, flags: u32) -> i64 {
    let ret: i64;
    // SAFETY:
    // - SYS_LANDLOCK_RESTRICT_SELF ne touche à aucune mémoire utilisateur.
    // - ABI aarch64 : numéro dans x8, args dans x0, x1.
    unsafe {
        core::arch::asm!(
            "svc #0",
            inlateout("x0") i64::from(ruleset_fd) => ret,
            in("x1") u64::from(flags),
            in("x8") SYS_LANDLOCK_RESTRICT_SELF as u64,
            options(nostack),
        );
    }
    ret
}

// ─────────────────────────────────────────────────────────────────────────
// Helper commun : interprétation du retour i64 d'un syscall.
// ─────────────────────────────────────────────────────────────────────────

/// Convertit un retour brut de syscall en `Result<i64, Errno>`.
///
/// Linux indique une erreur avec un retour dans `[-4095, -1]`.
fn syscall_result(raw: i64) -> Result<i64, Errno> {
    if (-4095..0_i64).contains(&raw) {
        // raw est dans [-4095, -1] : c'est un code errno négatif.
        // On calcule l'inverse via wrapping_neg : pas de risque d'overflow
        // car raw != i64::MIN (borné à -4095). Le résultat est dans [1, 4095],
        // valide pour un i32 et non nul.
        let errno_raw_i64 = raw.wrapping_neg();
        // errno_raw_i64 est dans [1, 4095] : la troncature i64 → i32 est
        // sans perte (4095 < i32::MAX) et le signe ne change pas.
        #[allow(clippy::cast_possible_truncation)]
        let errno_raw = errno_raw_i64 as i32;
        let nz =
            NonZeroI32::new(errno_raw).expect("errno dans [-4095,-1] est nécessairement non nul");
        Err(Errno::from_nonzero(nz))
    } else {
        Ok(raw)
    }
}

// ─────────────────────────────────────────────────────────────────────────
// LandlockRuleset — type RAII autour du FD ruleset Landlock.
// ─────────────────────────────────────────────────────────────────────────

/// Ruleset Landlock (cf. `landlock_create_ruleset(2)`).
///
/// Encapsule un FD ruleset Landlock qui accumule des règles d'accès
/// filesystem avant d'être appliqué au thread courant via
/// [`LandlockRuleset::restrict_self`].
///
/// Les restrictions sont **irréversibles** : une fois
/// `restrict_self` appelé, le thread ne peut plus voir les permissions
/// augmenter (Landlock est monotone).
#[derive(Debug)]
pub struct LandlockRuleset(OwnedFd);

impl LandlockRuleset {
    /// Vue empruntée du FD ruleset.
    #[must_use]
    pub fn as_fd(&self) -> BorrowedFd<'_> {
        use air_sys_types::fd::AsFd;
        self.0.as_fd()
    }

    /// Ajoute une règle d'accès pour un chemin filesystem et ses descendants.
    ///
    /// Wrappeur de `landlock_add_rule(2)` avec `LANDLOCK_RULE_PATH_BENEATH`.
    /// La règle s'applique au chemin référencé par `path` et à tous ses
    /// descendants. `path` doit être ouvert avec `O_PATH | O_DIRECTORY`
    /// (ou `O_PATH` seul pour un fichier).
    ///
    /// **Sémantique additive :** les règles ne peuvent qu'étendre les accès
    /// autorisés au sein de ce ruleset. `restrict_self` appliquera
    /// l'intersection de tous les rulesets cumulés.
    ///
    /// # Parameters
    ///
    /// - `path` : FD du chemin cible (typiquement ouvert avec `O_PATH`).
    /// - `allowed_access` : permissions autorisées sur ce chemin et ses
    ///   descendants.
    ///
    /// # Errors
    ///
    /// - `EINVAL` : `allowed_access` contient un bit non géré par ce ruleset,
    ///   ou `path` n'est pas un FD valide.
    /// - `ENOMEM` : mémoire kernel insuffisante.
    /// - `EBADFD` : `path` n'est pas un FD de fichier ou répertoire.
    /// - `EINTR` : interruption par signal (ADR-021 convention 2 — remonté
    ///   tel quel, sans retry automatique).
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use air_sys_syscall::security::landlock_create_ruleset;
    /// use air_sys_types::security::LandlockAccessFs;
    /// use air_sys_types::fd::BorrowedFd;
    ///
    /// # fn example(path_fd: BorrowedFd<'_>) {
    /// let mut ruleset = landlock_create_ruleset(
    ///     LandlockAccessFs::READ_FILE | LandlockAccessFs::EXECUTE,
    /// ).expect("create_ruleset");
    /// ruleset.add_rule_path_beneath(path_fd, LandlockAccessFs::READ_FILE)
    ///     .expect("add_rule");
    /// # }
    /// ```
    pub fn add_rule_path_beneath(
        &mut self,
        path: BorrowedFd<'_>,
        allowed_access: LandlockAccessFs,
    ) -> Result<(), Errno> {
        let attr = KernelLandlockPathBeneathAttr {
            allowed_access: allowed_access.bits(),
            parent_fd: path.as_raw_fd(),
        };
        let ruleset_fd = self.0.as_raw_fd();
        // SAFETY:
        // - `attr` est une variable locale valide pour toute la durée de l'appel.
        // - `LANDLOCK_RULE_PATH_BENEATH` est la seule valeur de type règle
        //   actuellement définie et acceptée par le kernel pour `attr` de
        //   type `KernelLandlockPathBeneathAttr`.
        // - `flags` = 0 : aucun drapeau défini pour cette opération à ce jour.
        let ret = unsafe {
            raw_syscall_landlock_add_rule(
                ruleset_fd,
                LANDLOCK_RULE_PATH_BENEATH,
                &raw const attr as u64,
                0,
            )
        };
        syscall_result(ret).map(|_| ())
    }

    /// Applique le ruleset au thread courant.
    ///
    /// Wrappeur de `landlock_restrict_self(2)`. **Irréversible.** Après
    /// cet appel, le thread ne peut plus accéder aux chemins filesystem
    /// non couverts par les règles du ruleset (pour les accès dans
    /// `handled_access` du ruleset).
    ///
    /// Prérequis : avoir appelé [`crate::process::set_no_new_privs`] ou
    /// posséder `CAP_SYS_ADMIN`.
    ///
    /// # Errors
    ///
    /// - `EPERM` : `no_new_privs` non positionné et `CAP_SYS_ADMIN` absent.
    /// - `EINVAL` : flags invalides.
    /// - `EINTR` : interruption par signal (ADR-021 convention 2 — remonté
    ///   tel quel, sans retry automatique).
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use air_sys_syscall::security::landlock_create_ruleset;
    /// use air_sys_syscall::process::set_no_new_privs;
    /// use air_sys_types::security::LandlockAccessFs;
    ///
    /// let ruleset = landlock_create_ruleset(LandlockAccessFs::READ_FILE)
    ///     .expect("create_ruleset");
    /// set_no_new_privs().expect("no_new_privs");
    /// ruleset.restrict_self().expect("restrict_self");
    /// ```
    pub fn restrict_self(&self) -> Result<(), Errno> {
        let ruleset_fd = self.0.as_raw_fd();
        let ret = raw_syscall_landlock_restrict_self(ruleset_fd, 0);
        syscall_result(ret).map(|_| ())
    }
}

// ─────────────────────────────────────────────────────────────────────────
// Fonctions publiques
// ─────────────────────────────────────────────────────────────────────────

/// Retourne la version ABI Landlock supportée par le kernel courant.
///
/// Utilise `landlock_create_ruleset(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION)`.
/// Retourne `ENOSYS` si le kernel ne supporte pas Landlock (< 5.13).
///
/// | Valeur retournée | Version Landlock | Kernel minimum |
/// |---|---|---|
/// | 1 | v1 | Linux 5.13 |
/// | 2 | v2 (REFER) | Linux 5.19 |
/// | 3 | v3 (TRUNCATE) | Linux 6.2 |
/// | 5 | v5 (IOCTL_DEV) | Linux 6.10 |
///
/// # Errors
///
/// - `ENOSYS` : Landlock non supporté ou non compilé dans le kernel.
///
/// # Examples
///
/// ```no_run
/// use air_sys_syscall::security::landlock_supported_abi;
///
/// match landlock_supported_abi() {
///     Ok(v) => println!("Landlock ABI v{v}"),
///     Err(_) => println!("Landlock non disponible"),
/// }
/// ```
pub fn landlock_supported_abi() -> Result<u32, Errno> {
    // SAFETY:
    // - attr = 0 (NULL) et size = 0 sont les valeurs attendues pour la
    //   requête de version ABI (drapeaux LANDLOCK_CREATE_RULESET_VERSION).
    // - Le kernel ne déréférence pas le pointeur quand flags = VERSION.
    let ret = unsafe { raw_syscall_landlock_create_ruleset(0, 0, LANDLOCK_CREATE_RULESET_VERSION) };
    let version = syscall_result(ret)?;
    // La version ABI est un entier positif <= quelques dizaines ; la
    // troncature i64 → u32 est sans perte sur les valeurs réalistes.
    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
    Ok(version as u32)
}

/// Crée un ruleset Landlock pour les accès filesystem spécifiés.
///
/// Wrappeur de `landlock_create_ruleset(2)` (Linux 5.13+). Le ruleset
/// gérera les permissions listées dans `handled_access` — toute
/// permission dans `handled_access` qui n'est pas couverte par une règle
/// sera **refusée** par défaut après `restrict_self`.
///
/// # Parameters
///
/// - `handled_access` : ensemble des permissions filesystem que ce
///   ruleset va gérer. Doit être un sous-ensemble des bits supportés
///   par la version ABI du kernel (voir [`landlock_supported_abi`]).
///
/// # Errors
///
/// - `EINVAL` : `handled_access` contient un bit non supporté par la
///   version ABI courante.
/// - `ENOMEM` : mémoire kernel insuffisante.
/// - `ENOSYS` : Landlock non disponible sur ce kernel.
///
/// # Examples
///
/// ```no_run
/// use air_sys_syscall::security::landlock_create_ruleset;
/// use air_sys_types::security::LandlockAccessFs;
///
/// let ruleset = landlock_create_ruleset(
///     LandlockAccessFs::READ_FILE | LandlockAccessFs::READ_DIR | LandlockAccessFs::EXECUTE,
/// ).expect("create_ruleset");
/// ```
pub fn landlock_create_ruleset(handled_access: LandlockAccessFs) -> Result<LandlockRuleset, Errno> {
    let attr = KernelLandlockRulesetAttr {
        handled_access_fs: handled_access.bits(),
    };
    // SAFETY:
    // - `attr` est une variable locale valide pour toute la durée de l'appel.
    // - `size_of::<KernelLandlockRulesetAttr>()` est la taille exacte de la
    //   structure attendue par le kernel pour les versions ABI connues.
    // - `flags` = 0 : création normale (pas requête de version ABI).
    let ret = unsafe {
        raw_syscall_landlock_create_ruleset(
            &raw const attr as u64,
            size_of::<KernelLandlockRulesetAttr>() as u64,
            0,
        )
    };
    let fd_raw = syscall_result(ret)?;
    // SAFETY : le syscall a réussi (ret >= 0) ; le kernel garantit qu'un
    // fd retourné est valide et appartient maintenant au processus.
    // La troncature i64 → i32 est sans perte : les numéros de fd Linux
    // tiennent dans un i32.
    #[allow(clippy::cast_possible_truncation)]
    let owned_fd = unsafe { OwnedFd::from_raw_fd(fd_raw as i32) };
    Ok(LandlockRuleset(owned_fd))
}

/// Applique un filtre seccomp-BPF précompilé au thread courant.
///
/// Wrappeur de `seccomp(SECCOMP_SET_MODE_FILTER, flags, prog)`.
/// Charge le programme BPF tel quel dans le kernel — aucune compilation
/// BPF n'est effectuée ici (API primitive couche 0).
///
/// **L'opération est irréversible.** Une fois chargé, le filtre ne peut
/// pas être retiré. Des filtres successifs peuvent être ajoutés mais
/// seulement pour restreindre davantage (jamais pour assouplir).
///
/// # Safety
///
/// - L'appelant doit avoir appelé `set_no_new_privs()` OU posséder
///   `CAP_SYS_ADMIN`.
/// - Le programme BPF doit autoriser tous les syscalls nécessaires au
///   runtime Rust (au minimum : `read`, `write`, `mmap`, `munmap`,
///   `futex`, `exit_group`, `rt_sigreturn`).
/// - Un programme BPF incorrect peut bloquer le processus ou le tuer.
/// - Irréversible.
///
/// # Errors
///
/// - `EPERM` : `no_new_privs` non positionné et `CAP_SYS_ADMIN` absent.
/// - `EINVAL` : programme BPF invalide ou flags non reconnus.
/// - `ENOMEM` : mémoire insuffisante.
/// - `ENOSYS` : seccomp non compilé dans ce kernel.
///
/// # Examples
///
/// ```no_run
/// use air_sys_syscall::security::seccomp_set_mode_filter;
/// use air_sys_types::security::{SeccompFilterFlags, SockFilter, SockFprog};
///
/// // Instruction BPF RET ALLOW (0x7fff0000 = SECCOMP_RET_ALLOW).
/// let allow_all = [SockFilter { code: 0x0006, jt: 0, jf: 0, k: 0x7fff_0000 }];
/// let prog = SockFprog::new(&allow_all).expect("programme valide");
///
/// // unsafe : charge un filtre irréversible dans le kernel.
/// unsafe {
///     seccomp_set_mode_filter(&prog, SeccompFilterFlags::empty())
///         .expect("seccomp_set_mode_filter");
/// }
/// ```
pub unsafe fn seccomp_set_mode_filter(
    prog: &SockFprog<'_>,
    flags: SeccompFilterFlags,
) -> Result<(), Errno> {
    // Construction du struct sock_fprog attendu par le kernel sur LP64.
    // Sur x86_64 et aarch64 (les deux archs supportées, ADR-014), la ABI
    // LP64 impose : u16 length, 6 octets de padding, puis le pointeur aligné
    // sur 8 octets — total 16 octets.
    let kfprog = KernelSockFprog {
        len: prog.len(),
        _pad: [0u8; 6],
        filter: prog.as_ptr() as u64,
    };
    // SAFETY (préconditions héritées de l'appelant) :
    // - Le programme BPF pointé par `prog` reste valide pendant l'appel.
    // - `kfprog` est une variable locale valide pour toute la durée
    //   de l'appel syscall.
    // - `SECCOMP_SET_MODE_FILTER` avec un `sock_fprog` valide ne cause
    //   pas d'UB intrinsèquement — c'est un appel kernel ordinaire.
    let ret = unsafe {
        raw_syscall_seccomp(
            SECCOMP_SET_MODE_FILTER,
            flags.bits(),
            &raw const kfprog as u64,
        )
    };
    syscall_result(ret).map(|_| ())
}

/// Active le mode seccomp strict.
///
/// En mode strict, seuls `read(2)`, `write(2)`, `_exit(2)` et
/// `sigreturn(2)` sont autorisés pour le thread courant. Tout autre
/// syscall entraîne un `SIGKILL`.
///
/// **L'opération est irréversible.**
///
/// # Errors
///
/// - `EPERM` : les threads du processus utilisent déjà des filtres
///   incompatibles (cas rare).
/// - `ENOSYS` : seccomp non compilé dans ce kernel.
///
/// # Examples
///
/// ```no_run
/// use air_sys_syscall::security::seccomp_set_mode_strict;
///
/// // N'appeler que dans un sous-processus dédié ; irréversible.
/// seccomp_set_mode_strict().expect("seccomp_set_mode_strict");
/// ```
pub fn seccomp_set_mode_strict() -> Result<(), Errno> {
    // SAFETY:
    // - `SECCOMP_SET_MODE_STRICT` avec flags=0 et uargs=0 est l'appel
    //   canonique documenté dans seccomp(2). Aucune mémoire utilisateur
    //   n'est déréférencée par le kernel pour cette opération.
    let ret = unsafe { raw_syscall_seccomp(SECCOMP_SET_MODE_STRICT, 0, 0) };
    syscall_result(ret).map(|_| ())
}

// ─────────────────────────────────────────────────────────────────────────
// Tests
// ─────────────────────────────────────────────────────────────────────────

#[cfg(test)]
mod tests {
    use super::*;
    use air_sys_types::security::{SockFilter, SockFprog};

    // ── landlock_supported_abi ────────────────────────────────────────────

    #[cfg(target_os = "linux")]
    #[test]
    fn landlock_supported_abi_returns_version() {
        // Air cible des noyaux Linux tier-1 avec Landlock activé (>= 5.13) : la
        // sonde de capacité exige donc la capacité (pas de tolérance ENOSYS, qui
        // laisserait une branche morte sur les noyaux cibles).
        let v = landlock_supported_abi().expect("Landlock requis sur les noyaux cibles Air");
        assert!(v >= 1, "version ABI Landlock doit être >= 1, obtenu {v}");
    }

    // ── landlock_create_ruleset ───────────────────────────────────────────

    #[cfg(target_os = "linux")]
    #[test]
    fn landlock_create_ruleset_succeeds() {
        use air_sys_types::fd::AsRawFd;
        let ruleset =
            landlock_create_ruleset(LandlockAccessFs::READ_FILE | LandlockAccessFs::READ_DIR)
                .expect("Landlock requis sur les noyaux cibles Air");
        assert!(
            ruleset.0.as_raw_fd() >= 0,
            "le FD ruleset doit être positif"
        );
    }

    // ── seccomp_set_mode_strict ──────────────────────────────────────────
    //
    // AVERTISSEMENT : `seccomp_set_mode_strict` est irréversible et restreint
    // les syscalls disponibles à read/write/_exit/sigreturn. On ne peut PAS
    // l'appeler dans le processus de test standard (cela tuerait le test runner
    // Rust à la première allocation mémoire post-appel). Ce test vérifie
    // uniquement que la fonction est compilable et que le chemin non-Linux
    // est cohérent. Un test en subprocess séparé est nécessaire pour valider
    // le comportement réel.

    #[cfg(target_os = "linux")]
    #[test]
    fn seccomp_set_mode_strict_returns_ok_or_enosys_in_subprocess() {
        // On utilise un fork via std::process::Command pour isoler l'appel.
        // L'exécutable de test re-invoqué avec une variable d'environnement
        // spéciale active le mode strict et vérifie le code de sortie.
        //
        // Implémentation simplifiée : on vérifie que la fonction existe et
        // est appelable syntaxiquement. Le test d'intégration réel (subprocess
        // fork + seccomp) sera dans la suite d'intégration de couche 0.
        //
        // Pour l'instant : on vérifie que sur un kernel Linux, seccomp(2) est
        // bien disponible (ENOSYS ne doit pas être retourné sur tout kernel
        // Linux >= 3.5 avec CONFIG_SECCOMP=y).
        let prog_instructions = [SockFilter {
            code: 0x0006,
            jt: 0,
            jf: 0,
            k: 0x7fff_0000,
        }];
        let prog = SockFprog::new(&prog_instructions).expect("programme valide");
        // On teste seccomp_set_mode_filter dans un sous-processus pour ne
        // pas altérer le processus de test courant.
        // Ici on vérifie simplement que SockFprog::new et les conversions
        // de pointeur sont correctes sans appeler le syscall effectivement.
        assert_eq!(prog.len(), 1);
        assert!(!prog.is_empty());
        // Vérification que le pointeur est non-nul.
        assert!(!prog.as_ptr().is_null());
    }

    // ── SockFprog validation ──────────────────────────────────────────────
    //
    // Les tests de validation de SockFprog sont dans air-sys-types::security.
    // On ajoute ici des tests qui vérifient l'intégration avec le syscall.

    #[test]
    fn sock_fprog_new_single_instruction_pointer_stable() {
        let instructions = [
            SockFilter {
                code: 0x0006,
                jt: 0,
                jf: 0,
                k: 0x7fff_0000,
            },
            SockFilter {
                code: 0x0006,
                jt: 0,
                jf: 0,
                k: 0x0000_0000,
            },
        ];
        let prog = SockFprog::new(&instructions).expect("2 instructions valides");
        assert_eq!(prog.len(), 2);
        // Le pointeur doit pointer sur le premier élément de la tranche.
        assert_eq!(prog.as_ptr(), instructions.as_ptr());
    }

    // ── KernelSockFprog layout ────────────────────────────────────────────

    #[test]
    fn kernel_sock_fprog_size_is_16_bytes() {
        // Sur LP64 (x86_64/aarch64) : u16 + 6 bytes padding + u64 = 16 bytes.
        assert_eq!(core::mem::size_of::<KernelSockFprog>(), 16);
    }

    #[test]
    fn kernel_sock_fprog_alignment_is_8_bytes() {
        assert_eq!(core::mem::align_of::<KernelSockFprog>(), 8);
    }

    // ── KernelLandlockRulesetAttr layout ─────────────────────────────────

    #[test]
    fn kernel_landlock_ruleset_attr_size() {
        // struct landlock_ruleset_attr : un seul champ u64.
        assert_eq!(core::mem::size_of::<KernelLandlockRulesetAttr>(), 8);
    }

    // ── KernelLandlockPathBeneathAttr layout ──────────────────────────────

    #[test]
    fn kernel_landlock_path_beneath_attr_size() {
        // struct landlock_path_beneath_attr : u64 + i32 = 12 bytes (+ padding?).
        // Le kernel définit : __u64 allowed_access (8) + __s32 parent_fd (4) = 12.
        // Pas de padding final car l'alignement max est 8 (u64), et 12 % 8 != 0,
        // donc le compilateur ajoute 4 bytes de padding pour aligner = 16 bytes.
        // Mais le kernel lui-même a exactement 12 bytes en packed? Non : le kernel
        // C utilise le padding naturel. Sur x86_64 et aarch64, alignof(u64) = 8,
        // donc { u64 (8 bytes), i32 (4 bytes) } → taille = 16 avec padding final.
        // Vérifions la valeur réelle au runtime.
        let size = core::mem::size_of::<KernelLandlockPathBeneathAttr>();
        // Valeur attendue : 16 (padding pour aligner sur 8 bytes).
        assert_eq!(
            size, 16,
            "KernelLandlockPathBeneathAttr doit faire 16 bytes sur LP64"
        );
    }

    // ── Harnais sous-processus : opérations irréversibles ────────────────
    //
    // `seccomp_set_mode_filter` et `LandlockRuleset::restrict_self` sont
    // irréversibles : on les exerce dans un enfant forké via `clone3`, le
    // parent observant le statut de sortie via `waitid`. L'enfant sort via
    // `exit_group` (ni le filtre allow-all ni Landlock ne le bloquent).
    //
    // **Couverture (cf. docs/COVERAGE-EXCEPTIONS.md) :** l'enfant sort par
    // `exit_group`, qui bypasse l'atexit LLVM → il n'écrit pas son `.profraw`.
    // La branche « succès » de ces fonctions reste donc une exception de
    // couverture légitime, mais elle est **fonctionnellement prouvée** ici.

    /// Écrit le profil de couverture LLVM de l'enfant forké.
    ///
    /// `exit_group` (et `raw_exit`) court-circuitent le handler `atexit` de LLVM :
    /// sans ce flush explicite, les compteurs de l'enfant sont perdus et le corps
    /// des wrappers exécutés dans l'enfant (landlock/seccomp/…) apparaît non
    /// couvert. `LLVM_PROFILE_FILE` contient `%p` → chaque enfant écrit un
    /// `.profraw` distinct, fusionné ensuite par `cargo-llvm-cov`.
    ///
    /// À appeler tant que l'I/O fichier de l'enfant est encore permise : après un
    /// filtre seccomp allow-all ou un ruleset Landlock qui ne *gère* pas l'écriture
    /// l'I/O reste possible ; **avant** un verrou seccomp-strict qui, lui, tuerait
    /// le flush (il appelle `open`/`write`).
    // Intentionnellement VIDE — **async-signal-safety** (flaky deadlock couche 0) :
    // `__llvm_profile_write_file` alloue, et un enfant forké via `clone3` peut
    // hériter d'un lock `malloc` copié VERROUILLÉ → deadlock. Les lignes exécutées
    // dans l'enfant sont des exceptions CHILD-EXIT (ADR-035), prouvées par le code
    // de sortie. NE PAS réintroduire de flush ici.
    #[cfg(target_os = "linux")]
    fn flush_child_coverage() {}

    /// Exécute `body` dans un enfant forké ; retourne l'événement de sortie
    /// observé par le parent. `body` renvoie le code de sortie de l'enfant.
    #[cfg(target_os = "linux")]
    fn run_in_forked_child(body: impl FnOnce() -> i32) -> air_sys_types::WaitEvent {
        use crate::process::{clone3, exit_group, waitid};
        use air_sys_types::{CloneArgs, CloneFlags, CloneResult, Signal, WaitOptions, WaitTarget};
        let args = CloneArgs {
            flags: CloneFlags::PIDFD,
            exit_signal: Some(Signal::SIGCHLD),
            stack: None,
            child_tid: None,
            parent_tid: None,
            tls: None,
        };
        // SAFETY: fork classique + CLONE_PIDFD ; pas de mémoire partagée.
        match unsafe { clone3(&args) }.expect("clone3 doit réussir") {
            CloneResult::Child => {
                let code = body();
                // Flush du profil avant exit_group (qui bypasse l'atexit LLVM).
                // Les corps qui verrouillent l'I/O (seccomp-strict) flushent
                // eux-mêmes plus tôt et sortent sans repasser ici.
                flush_child_coverage();
                exit_group(code);
            }
            CloneResult::Parent { child_pidfd, .. } => {
                let pidfd = child_pidfd.expect("CLONE_PIDFD demandé");
                let st = waitid(WaitTarget::PidFd(pidfd.as_fd()), WaitOptions::EXITED)
                    .expect("waitid")
                    .expect("événement EXITED disponible");
                st.event
            }
        }
    }

    /// `seccomp_set_mode_filter` avec un filtre allow-all, appliqué dans un
    /// enfant forké. Prouve le chargement réel du programme BPF.
    #[cfg(target_os = "linux")]
    #[test]
    fn seccomp_set_mode_filter_allow_all_in_forked_child() {
        use air_sys_types::WaitEvent;
        let event = run_in_forked_child(|| {
            // `no_new_privs` est requis sans CAP_SYS_ADMIN.
            if crate::process::set_no_new_privs().is_err() {
                return 10;
            }
            // Instruction unique : RET SECCOMP_RET_ALLOW (0x7fff_0000).
            let insns = [SockFilter {
                code: 0x0006,
                jt: 0,
                jf: 0,
                k: 0x7fff_0000,
            }];
            let prog = match SockFprog::new(&insns) {
                Ok(p) => p,
                Err(_) => return 11,
            };
            // SAFETY: no_new_privs posé ; filtre allow-all → aucun syscall
            // ultérieur (dont exit_group) n'est bloqué.
            match unsafe { seccomp_set_mode_filter(&prog, SeccompFilterFlags::empty()) } {
                Ok(()) => 0,
                Err(Errno::ENOSYS) => 42, // seccomp indisponible : skip toléré
                Err(_) => 12,
            }
        });
        match event {
            WaitEvent::Exited { code: 0 } => {}  // filtre chargé avec succès
            WaitEvent::Exited { code: 42 } => {} // seccomp indisponible
            other => panic!("enfant seccomp_filter : statut inattendu {other:?}"),
        }
    }

    /// `LandlockRuleset::restrict_self` appliqué dans un enfant forké.
    /// Prouve le chemin create_ruleset → restrict_self réel.
    #[cfg(target_os = "linux")]
    #[test]
    fn landlock_restrict_self_in_forked_child() {
        use air_sys_types::WaitEvent;
        let event = run_in_forked_child(|| {
            let ruleset = match landlock_create_ruleset(LandlockAccessFs::READ_FILE) {
                Ok(r) => r,
                Err(Errno::ENOSYS) => return 42, // Landlock indisponible : skip
                Err(_) => return 11,
            };
            if crate::process::set_no_new_privs().is_err() {
                return 12;
            }
            // Flush AVANT restrict_self : ensuite l'ouverture O_RDWR du .profraw
            // (mode merge `%m`) serait refusée par Landlock (READ_FILE géré).
            flush_child_coverage();
            match ruleset.restrict_self() {
                Ok(()) => 0,
                Err(_) => 13,
            }
        });
        match event {
            WaitEvent::Exited { code: 0 } => {}  // restriction appliquée
            WaitEvent::Exited { code: 42 } => {} // Landlock indisponible
            other => panic!("enfant landlock_restrict_self : statut inattendu {other:?}"),
        }
    }

    /// `add_rule_path_beneath` + `restrict_self` dans un enfant forké.
    /// Prouve le chemin complet : create_ruleset → add_rule → restrict_self.
    #[cfg(target_os = "linux")]
    #[test]
    fn landlock_add_rule_and_restrict_self_in_forked_child() {
        use air_sys_types::WaitEvent;
        use air_sys_types::fd::AsFd;
        let event = run_in_forked_child(|| {
            let mut ruleset = match landlock_create_ruleset(
                LandlockAccessFs::READ_FILE | LandlockAccessFs::READ_DIR,
            ) {
                Ok(r) => r,
                Err(Errno::ENOSYS) => return 42,
                Err(_) => return 11,
            };
            // Ouvre /tmp en O_PATH | O_DIRECTORY pour la règle.
            // O_PATH = 0o10000000 (x86_64/aarch64), O_DIRECTORY = 0o200000.
            let o_path: u64 = 0o10_000_000;
            let o_rdonly: u64 = 0;
            let o_directory: u64 = 0o200_000;
            let o_cloexec: u64 = 0o2_000_000;
            let path_fd_raw = {
                #[cfg(target_arch = "x86_64")]
                {
                    let ret: i64;
                    let path = c"/tmp";
                    // SAFETY: openat (x86_64 = 257). `path` est une chaîne C statique
                    // valide et NUL-terminée ; le kernel ne lit que ce pointeur et
                    // retourne un FD ≥ 0 ou un errno négatif (aucune écriture mémoire).
                    unsafe {
                        core::arch::asm!(
                            "syscall",
                            in("rax") 257_i64, // openat
                            in("rdi") (-100_i64).cast_unsigned(), // AT_FDCWD
                            in("rsi") path.as_ptr() as u64,
                            in("rdx") o_rdonly | o_path | o_directory | o_cloexec,
                            in("r10") 0_u64,
                            lateout("rax") ret,
                            lateout("rcx") _,
                            lateout("r11") _,
                            options(nostack, preserves_flags),
                        );
                    }
                    ret
                }
                #[cfg(target_arch = "aarch64")]
                {
                    let ret: i64;
                    let path = c"/tmp";
                    // SAFETY: openat (aarch64 = 56). `path` est une chaîne C statique
                    // valide et NUL-terminée ; le kernel ne lit que ce pointeur et
                    // retourne un FD ≥ 0 ou un errno négatif (aucune écriture mémoire).
                    unsafe {
                        core::arch::asm!(
                            "svc 0",
                            in("x8") 56_i64, // openat
                            inout("x0") (-100_i64).cast_unsigned() => ret,
                            in("x1") path.as_ptr() as u64,
                            in("x2") o_rdonly | o_path | o_directory | o_cloexec,
                            in("x3") 0_u64,
                            options(nostack, preserves_flags),
                        );
                    }
                    ret
                }
            };
            if path_fd_raw < 0 {
                return 14;
            }
            #[allow(clippy::cast_possible_truncation)]
            // SAFETY: `path_fd_raw >= 0` (vérifié juste au-dessus), donc c'est un FD
            // fraîchement ouvert par openat, non possédé ailleurs : on en prend la
            // propriété exclusive.
            let path_fd = unsafe { OwnedFd::from_raw_fd(path_fd_raw as i32) };
            match ruleset.add_rule_path_beneath(path_fd.as_fd(), LandlockAccessFs::READ_FILE) {
                Ok(()) => {}
                Err(Errno::ENOSYS) => return 42,
                Err(_) => return 15,
            }
            if crate::process::set_no_new_privs().is_err() {
                return 12;
            }
            // Flush AVANT restrict_self (cf. landlock_restrict_self_in_forked_child) :
            // capture create_ruleset + add_rule pendant que l'I/O est permise.
            flush_child_coverage();
            match ruleset.restrict_self() {
                Ok(()) => 0,
                Err(_) => 13,
            }
        });
        match event {
            WaitEvent::Exited { code: 0 } => {}
            WaitEvent::Exited { code: 42 } => {}
            other => panic!("landlock add_rule+restrict_self : {other:?}"),
        }
    }

    /// `seccomp_set_mode_strict` dans un enfant forké.
    /// Mode strict : seuls read/write/_exit/sigreturn autorisés.
    #[cfg(target_os = "linux")]
    #[test]
    fn seccomp_set_mode_strict_in_forked_child() {
        use air_sys_types::WaitEvent;
        let event = run_in_forked_child(|| {
            // Flush AVANT le mode strict : ensuite `open`/`write` (donc le flush
            // lui-même) seraient tués. Les lignes après ce point dans l'enfant
            // restent non couvertes (exception CHILD-EXIT résiduelle assumée).
            flush_child_coverage();
            // Après seccomp strict, seuls read/write/exit/sigreturn restent
            // autorisés : `exit_group` (utilisé par le harnais) déclencherait
            // un SIGKILL. On sort donc via le syscall `exit` (NR 60/93), seul
            // moyen de terminer proprement en mode strict — ce qui prouve à la
            // fois que le filtre est actif et qu'il laisse passer `exit`.
            match seccomp_set_mode_strict() {
                // SAFETY: `raw_exit` invoque le syscall `exit` (seul moyen de
                // terminer proprement en mode seccomp strict) ; il ne retourne
                // jamais et ne touche à aucune mémoire utilisateur.
                Ok(()) => unsafe { raw_exit(0) },
                Err(Errno::ENOSYS) => 42, // seccomp indisponible
                Err(_) => 11,
            }
        });
        match event {
            WaitEvent::Exited { code: 0 } => {}
            WaitEvent::Exited { code: 42 } => {}
            other => panic!("seccomp_set_mode_strict : {other:?}"),
        }
    }

    /// Termine le processus courant via le syscall `exit` (terminaison du
    /// thread appelant), seul code de sortie autorisé sous `SECCOMP_MODE_STRICT`
    /// — contrairement à `exit_group`. Utilisé uniquement par le test strict.
    #[cfg(target_arch = "x86_64")]
    unsafe fn raw_exit(code: i32) -> ! {
        // SAFETY: `exit` (NR 60) ne revient jamais ; aucun argument mémoire.
        unsafe {
            core::arch::asm!(
                "syscall",
                in("rax") 60_i64, // exit
                in("rdi") i64::from(code),
                options(noreturn, nostack),
            );
        }
    }

    /// Variante aarch64 (NR 93) de [`raw_exit`].
    #[cfg(target_arch = "aarch64")]
    unsafe fn raw_exit(code: i32) -> ! {
        // SAFETY: `exit` (NR 93) ne revient jamais ; aucun argument mémoire.
        unsafe {
            core::arch::asm!(
                "svc 0",
                in("x8") 93_i64, // exit
                in("x0") i64::from(code),
                options(noreturn, nostack),
            );
        }
    }

    /// `landlock_create_ruleset` accepte le masque d'accès maximal.
    #[cfg(target_os = "linux")]
    #[test]
    fn landlock_create_ruleset_accepts_all_known_access_bits() {
        // Tous les bits de `LandlockAccessFs` sont des accès ABI connus : le
        // noyau cible les accepte (chemin succès avec le masque maximal). La
        // branche d'erreur de create_ruleset (via syscall_result) est couverte
        // par `add_rule_path_beneath_bad_fd_covers_syscall_result_error`.
        landlock_create_ruleset(LandlockAccessFs::all())
            .expect("tous les bits LandlockAccessFs sont des accès ABI valides");
    }

    /// La branche d'erreur de `syscall_result` (chemin Landlock), couverte
    /// **en in-process** (sans fork) : ruleset valide mais fd de chemin invalide.
    #[cfg(target_os = "linux")]
    #[test]
    fn add_rule_path_beneath_bad_fd_covers_syscall_result_error() {
        use air_sys_types::fd::BorrowedFd;
        let mut ruleset =
            landlock_create_ruleset(LandlockAccessFs::READ_FILE).expect("Landlock requis");
        // SAFETY: i32::MAX n'est jamais un fd ouvert ; transmis au kernel
        // uniquement pour être rejeté (EBADF), couvrant la branche erreur.
        let bad = unsafe { BorrowedFd::borrow_raw(i32::MAX) };
        let err = ruleset
            .add_rule_path_beneath(bad, LandlockAccessFs::READ_FILE)
            .expect_err("un fd de chemin invalide doit échouer");
        assert_eq!(err, Errno::EBADF);
    }

    /// `LandlockRuleset::as_fd` retourne un BorrowedFd valide.
    #[cfg(target_os = "linux")]
    #[test]
    fn landlock_ruleset_as_fd_valid() {
        let ruleset =
            landlock_create_ruleset(LandlockAccessFs::READ_FILE).expect("Landlock requis");
        let fd = ruleset.as_fd();
        assert!(fd.as_raw_fd() >= 0);
    }
}