air_sys_syscall/io_uring/

sandbox.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/.

//! **Confinement d'un ring** (Temps 3f) — sous-module
//! `air-sys-syscall::io_uring::sandbox`. Matérialise la décision de soundness
//! **S3** : un ring qui ne peut émettre que les opérations explicitement mises
//! en liste blanche, **imposé par le kernel**.
//!
//! Référence normative : `docs/specs/layer-0/io-uring-3f-sandbox.md`.
//!
//! ## Pourquoi
//!
//! io_uring exécute des opérations (`read`, `openat2`, `connect`…) qui **ne
//! passent pas par l'interface syscall classique** : un filtre **seccomp** qui
//! bloque le syscall `openat2` n'empêche **pas** un `IORING_OP_OPENAT2` soumis
//! via le ring — voie de contournement historique des bacs à sable. La réponse :
//! **restreindre le ring lui-même**. Les restrictions io_uring **complètent**
//! seccomp/Landlock (`family-security`), en défense en profondeur ; elles ne les
//! remplacent pas. C'est la brique io_uring du modèle de capabilities d'Air
//! (ADR-001 AirCom, ADR-010 entitlements signés) — la couche 0 fournit le
//! **mécanisme**, la **politique** vit en couche 5.
//!
//! ## Le flux en trois temps (imposé kernel, reflété par l'API)
//!
//! 1. **Créer désactivé** : [`IoUringBuilder::restrict`](super::IoUringBuilder::restrict)
//!    crée le ring `IORING_SETUP_R_DISABLED` et applique la liste blanche
//!    (`REGISTER_RESTRICTIONS`) — possible **uniquement** tant qu'il est désactivé.
//! 2. **Activer** : [`IoUring::enable`](super::IoUring::enable) (`REGISTER_ENABLE_RINGS`).
//! 3. **Immuable ensuite** : après `enable`, les restrictions ne peuvent plus être
//!    assouplies (imposé kernel) ; toute soumission **avant** `enable` est refusée.
//!
//! **Default-deny** : dès qu'un opcode est mis en liste blanche, le kernel refuse
//! **tout le reste** (`-EACCES`).
//!
//! ```
//! use air_sys_syscall::io_uring::{IoUringOpcode, RegisterOp, RestrictionSet, SqeFlagSet};
//!
//! // Un service AirCom « réseau seul » : le ring ne pourra jamais émettre
//! // openat2, unlinkat, etc. — garanti kernel.
//! let policy = RestrictionSet::new()
//!     .allow_op(IoUringOpcode::Socket)
//!     .allow_op(IoUringOpcode::Connect)
//!     .allow_op(IoUringOpcode::Send)
//!     .allow_op(IoUringOpcode::Recv)
//!     .allow_op(IoUringOpcode::Close)
//!     .allow_register(RegisterOp::ProvidedBuffers)
//!     .require_sqe_flags(SqeFlagSet::new().fixed_file());
//! assert_eq!(policy.as_slice().len(), 7);
//! // let mut ring = IoUringBuilder::new(entries).restrict(policy.as_slice()).build()?;
//! // ring.enable()?;  // à partir d'ici, tout opcode hors liste échoue.
//! ```

use super::{IoUringOpcode, Restriction, SubmitOptions};
use alloc::vec::Vec;

// ───────────────────────────────────────────────────────────────────────────
// RestrictionSet — liste blanche default-deny (§3.1)
// ───────────────────────────────────────────────────────────────────────────

/// Liste blanche de ce qu'un ring confiné pourra faire (décision **S3**).
/// **Default-deny** : ce qui n'est pas explicitement autorisé est refusé par le
/// kernel. Construite par combinateurs, puis passée à
/// [`IoUringBuilder::restrict`](super::IoUringBuilder::restrict) via
/// [`as_slice`](Self::as_slice).
///
/// `Default` = ensemble **vide** : aucune restriction (le ring n'est **pas**
/// confiné). Le confinement commence dès la **première** entrée (`allow_*` /
/// `require_*`).
#[derive(Debug, Clone, Default)]
pub struct RestrictionSet {
    restrictions: Vec<Restriction>,
}

impl RestrictionSet {
    /// Ensemble vide (équivaut à [`Default`]).
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Autorise un **opcode de soumission** (`RESTRICTION_SQE_OP`). Dès le premier
    /// `allow_op`, **seuls** les opcodes listés passent (default-deny).
    #[must_use]
    pub fn allow_op(mut self, op: IoUringOpcode) -> Self {
        self.restrictions.push(Restriction::AllowOp(op));
        self
    }

    /// Autorise un **register opcode** (`RESTRICTION_REGISTER_OP`).
    #[must_use]
    pub fn allow_register(mut self, op: RegisterOp) -> Self {
        self.restrictions
            .push(Restriction::AllowRegister(op.number()));
        self
    }

    /// Déclare les **drapeaux SQE autorisés** (`RESTRICTION_SQE_FLAGS_ALLOWED`) :
    /// un SQE ne peut porter que des drapeaux de cet ensemble.
    #[must_use]
    pub fn allow_sqe_flags(mut self, flags: SqeFlagSet) -> Self {
        self.restrictions
            .push(Restriction::SqeFlagsAllowed(flags.into_options()));
        self
    }

    /// Déclare les **drapeaux SQE requis** sur **chaque** soumission
    /// (`RESTRICTION_SQE_FLAGS_REQUIRED`) : un SQE sans ces drapeaux est refusé.
    /// Combiné à [`SqeFlagSet::fixed_file`], impose l'usage de FD **enregistrés**
    /// (interdit les FD bruts — moindre privilège).
    #[must_use]
    pub fn require_sqe_flags(mut self, flags: SqeFlagSet) -> Self {
        self.restrictions
            .push(Restriction::SqeFlagsRequired(flags.into_options()));
        self
    }

    /// **Point d'intégration couche 5** (ADR-010). Un composant de confiance
    /// (`air-launchd`/`air-trust`) traduit les **entitlements signés** du
    /// manifeste d'un `.airservice`/`.airapp` en l'ensemble d'opcodes que le ring
    /// pourra émettre, puis appelle ceci. La **politique** (quel entitlement ⇒
    /// quels opcodes) vit en couche 5 ; la couche 0 ne fournit que le mécanisme
    /// **default-deny**. Équivaut à un `allow_op` répété sur `allowed_ops`.
    #[must_use]
    pub fn from_entitlements<I>(allowed_ops: I) -> Self
    where
        I: IntoIterator<Item = IoUringOpcode>,
    {
        allowed_ops.into_iter().fold(Self::new(), Self::allow_op)
    }

    /// Vue des restrictions, à passer à
    /// [`IoUringBuilder::restrict`](super::IoUringBuilder::restrict).
    #[must_use]
    pub fn as_slice(&self) -> &[Restriction] {
        &self.restrictions
    }

    /// Nombre de restrictions accumulées.
    #[must_use]
    pub fn len(&self) -> usize {
        self.restrictions.len()
    }

    /// `true` si aucune restriction (ring **non** confiné).
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.restrictions.is_empty()
    }
}

// ───────────────────────────────────────────────────────────────────────────
// RegisterOp — register-ops autorisables (§4, RESTRICTION_REGISTER_OP)
// ───────────────────────────────────────────────────────────────────────────

/// Register opcode qu'un ring confiné peut être autorisé à effectuer
/// (`RESTRICTION_REGISTER_OP`). **Newtype typé** plutôt qu'un `u8` magique
/// (ADR-021 conv. 3 : chaque opération est une variante nommée). `#[non_exhaustive]`
/// : de futurs kernels peuvent en ajouter.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum RegisterOp {
    /// `IORING_REGISTER_BUFFERS2` (15) — buffers enregistrés (Temps 3a).
    Buffers,
    /// `IORING_REGISTER_FILES2` (13) — table de FD fixes (Temps 3a).
    Files,
    /// `IORING_REGISTER_EVENTFD` (4) — eventfd de complétion (Temps 3a).
    Eventfd,
    /// `IORING_REGISTER_PERSONALITY` (9) — identité enregistrée (Temps 3a).
    Personality,
    /// `IORING_REGISTER_PBUF_RING` (22) — buffers fournis ring-mapped (Temps 3b).
    ProvidedBuffers,
    /// `IORING_REGISTER_RING_FDS` (20) — enregistrement du ring fd (Temps 3a/3e).
    RingFd,
    /// `IORING_REGISTER_SYNC_CANCEL` (24) — annulation synchrone (Temps 2c/3d).
    SyncCancel,
    /// `IORING_REGISTER_PROBE` (8) — introspection des opcodes (Temps 1).
    Probe,
}

impl RegisterOp {
    /// Numéro kernel `IORING_REGISTER_*` (placé dans le champ `register_op` de
    /// `io_uring_restriction`). Style aligné sur `opcode_number` : littéraux `u8`
    /// (tous < 256), nom kernel en doc de variante.
    fn number(self) -> u8 {
        match self {
            RegisterOp::Buffers => 15,
            RegisterOp::Files => 13,
            RegisterOp::Eventfd => 4,
            RegisterOp::Personality => 9,
            RegisterOp::ProvidedBuffers => 22,
            RegisterOp::RingFd => 20,
            RegisterOp::SyncCancel => 24,
            RegisterOp::Probe => 8,
        }
    }
}

// ───────────────────────────────────────────────────────────────────────────
// SqeFlagSet — drapeaux IOSQE_* pour les restrictions de drapeaux (§4)
// ───────────────────────────────────────────────────────────────────────────

/// Ensemble de drapeaux `IOSQE_*` pour les restrictions de drapeaux SQE
/// ([`RestrictionSet::allow_sqe_flags`] / [`RestrictionSet::require_sqe_flags`]).
/// `Default` = aucun drapeau. Builder chaînable. Partage la représentation des
/// drapeaux avec [`SubmitOptions`](super::SubmitOptions).
#[derive(Debug, Clone, Copy, Default)]
pub struct SqeFlagSet {
    options: SubmitOptions,
}

impl SqeFlagSet {
    /// Ensemble vide (équivaut à [`Default`]).
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// `IOSQE_FIXED_FILE` : le `fd` du SQE est un **index de slot fixe**. En
    /// `require_sqe_flags`, **interdit les FD bruts** (force les FD enregistrés).
    #[must_use]
    pub fn fixed_file(mut self) -> Self {
        self.options = self.options.fixed_file();
        self
    }

    /// `IOSQE_IO_DRAIN` : draine les opérations précédentes avant celle-ci.
    #[must_use]
    pub fn drain(mut self) -> Self {
        self.options = self.options.drain();
        self
    }

    /// `IOSQE_ASYNC` : force l'exécution sur le pool io-wq.
    #[must_use]
    pub fn force_async(mut self) -> Self {
        self.options = self.options.force_async();
        self
    }

    /// `IOSQE_BUFFER_SELECT` : sélection automatique d'un buffer fourni (Temps 3b).
    #[must_use]
    pub fn buffer_select(mut self) -> Self {
        self.options = self.options.buffer_select();
        self
    }

    /// `IOSQE_CQE_SKIP_SUCCESS` : pas de CQE en cas de succès.
    #[must_use]
    pub fn skip_cqe_on_success(mut self) -> Self {
        self.options = self.options.skip_cqe_on_success();
        self
    }

    /// Conversion interne vers la représentation [`SubmitOptions`] portée par
    /// [`Restriction`].
    fn into_options(self) -> SubmitOptions {
        self.options
    }
}

// ───────────────────────────────────────────────────────────────────────────
// Tests
// ───────────────────────────────────────────────────────────────────────────
//
// Intégration kernel (io_uring non modélisé par Miri) → `#[cfg_attr(miri, ignore)]`.
// La preuve de sécurité (§8) est `openat2_refused_on_network_only_ring`.

#[cfg(test)]
mod tests {
    use super::{RegisterOp, RestrictionSet, SqeFlagSet};
    use crate::io_uring::{
        IoUringBuilder, IoUringOpcode, Restriction, SubmitOptions, encode_restriction,
        opcode_number, raw, syscall,
    };
    use air_sys_types::Errno;
    use air_sys_types::fs::{DirFd, OpenHow};
    use air_sys_types::net::{SocketDomain, SocketType};
    use core::num::NonZeroU32;
    use std::ffi::CString;

    fn nz(n: u32) -> NonZeroU32 {
        NonZeroU32::new(n).expect("n ≠ 0")
    }

    /// Liste candidate pour la propriété.
    const CANDIDATE_OPS: &[IoUringOpcode] = &[
        IoUringOpcode::Nop,
        IoUringOpcode::Socket,
        IoUringOpcode::Connect,
        IoUringOpcode::Send,
        IoUringOpcode::Recv,
        IoUringOpcode::Close,
        IoUringOpcode::Openat2,
        IoUringOpcode::Read,
    ];

    const ALL_REGISTER_OPS: &[RegisterOp] = &[
        RegisterOp::Buffers,
        RegisterOp::Files,
        RegisterOp::Eventfd,
        RegisterOp::Personality,
        RegisterOp::ProvidedBuffers,
        RegisterOp::RingFd,
        RegisterOp::SyncCancel,
        RegisterOp::Probe,
    ];

    fn cpath(p: &std::path::Path) -> CString {
        CString::new(p.as_os_str().as_encoded_bytes()).expect("chemin sans NUL")
    }

    // ── Unitaires (sans kernel) ───────────────────────────────────────────

    #[test]
    fn restriction_set_is_default_deny_and_accumulates() {
        // Vide par défaut : ring non confiné.
        let empty = RestrictionSet::new();
        assert!(empty.is_empty());
        assert_eq!(empty.len(), 0);
        assert!(empty.as_slice().is_empty());

        // Chaque combinateur ajoute exactement une restriction, dans l'ordre.
        let set = RestrictionSet::new()
            .allow_op(IoUringOpcode::Socket)
            .allow_register(RegisterOp::ProvidedBuffers)
            .allow_sqe_flags(SqeFlagSet::new().force_async())
            .require_sqe_flags(SqeFlagSet::new().fixed_file());
        assert!(!set.is_empty());
        assert_eq!(set.len(), 4);

        // `from_entitlements` = `allow_op` répété (point d'intégration couche 5).
        let from_ent =
            RestrictionSet::from_entitlements([IoUringOpcode::Send, IoUringOpcode::Recv]);
        assert_eq!(from_ent.len(), 2);
    }

    #[test]
    fn register_op_numbers_match_kernel_uapi() {
        // Exhaustif : chaque variante → son numéro `IORING_REGISTER_*` (6.12).
        let expected: &[(RegisterOp, u8)] = &[
            (RegisterOp::Buffers, 15),
            (RegisterOp::Files, 13),
            (RegisterOp::Eventfd, 4),
            (RegisterOp::Personality, 9),
            (RegisterOp::ProvidedBuffers, 22),
            (RegisterOp::RingFd, 20),
            (RegisterOp::SyncCancel, 24),
            (RegisterOp::Probe, 8),
        ];
        for &(op, number) in expected {
            assert_eq!(op.number(), number, "{op:?}");
        }
        assert_eq!(ALL_REGISTER_OPS.len(), expected.len(), "liste exhaustive");
    }

    #[test]
    fn sqe_flag_set_maps_to_submit_options() {
        // SqeFlagSet partage la représentation des drapeaux avec SubmitOptions.
        let from_set = SqeFlagSet::new()
            .fixed_file()
            .drain()
            .force_async()
            .buffer_select()
            .skip_cqe_on_success()
            .into_options();
        let direct = SubmitOptions::default()
            .fixed_file()
            .drain()
            .force_async()
            .buffer_select()
            .skip_cqe_on_success();
        assert_eq!(from_set, direct);
    }

    proptest::proptest! {
        /// **Propriété (§8)** : pour tout sous-ensemble d'opcodes autorisés, la
        /// liste blanche encode **exactement** ces opcodes (un `RESTRICTION_SQE_OP`
        /// par opcode, dans l'ordre, sans extra) — ni plus, ni moins. Le comportement
        /// kernel default-deny est, lui, prouvé par les tests d'intégration et de
        /// sécurité ci-dessous (un opcode hors liste **échoue** réellement).
        #[test]
        fn whitelisted_ops_encode_exactly_those(
            mask in proptest::collection::vec(proptest::bool::ANY, CANDIDATE_OPS.len())
        ) {
            let subset: Vec<IoUringOpcode> = CANDIDATE_OPS
                .iter()
                .zip(&mask)
                .filter(|(_, keep)| **keep)
                .map(|(op, _)| *op)
                .collect();
            let set = RestrictionSet::from_entitlements(subset.iter().copied());
            proptest::prop_assert_eq!(set.len(), subset.len());
            for (restriction, expected) in set.as_slice().iter().zip(&subset) {
                let encoded = encode_restriction(*restriction);
                proptest::prop_assert_eq!(encoded.opcode, raw::IORING_RESTRICTION_SQE_OP);
                proptest::prop_assert_eq!(encoded.op_or_flags, opcode_number(*expected));
            }
        }
    }

    // ── Intégration kernel ────────────────────────────────────────────────

    /// Tous les types de restriction à la fois : `build()` applique réellement
    /// `REGISTER_RESTRICTIONS` (4 variantes encodées) ; après `enable`, l'opcode
    /// autorisé (Nop) passe.
    #[test]
    #[cfg_attr(miri, ignore = "io_uring non supporté par Miri")]
    fn confined_ring_with_all_restriction_kinds_runs_whitelisted_op() {
        let policy = RestrictionSet::new()
            .allow_op(IoUringOpcode::Nop)
            .allow_register(RegisterOp::Probe)
            .allow_sqe_flags(SqeFlagSet::new().force_async())
            .require_sqe_flags(SqeFlagSet::new()); // aucun drapeau imposé
        let mut ring = IoUringBuilder::new(nz(8))
            .restrict(policy.as_slice())
            .build()
            .expect("ring R_DISABLED + REGISTER_RESTRICTIONS");
        ring.enable().expect("enable du ring confiné");
        // Nop est en liste blanche → passe.
        let tok = ring.submit_nop().expect("submit_nop autorisé");
        ring.submit_and_wait(1).expect("submit_and_wait");
        let completion = ring.wait_completion().expect("completion");
        assert_eq!(completion.token(), tok);
        completion.completed().expect("nop autorisé réussit");
        assert_eq!(ring.in_flight(), 0);
    }

    /// **Preuve de sécurité (§8)** : un `openat2` soumis via un ring « réseau
    /// seul » est **refusé** par le kernel, **alors même que le process a le droit
    /// d'ouvrir le fichier**. Ferme la voie de contournement de seccomp (§1).
    #[test]
    #[cfg_attr(miri, ignore = "io_uring non supporté par Miri")]
    fn openat2_refused_on_network_only_ring() {
        // Fichier que le process PEUT ouvrir hors ring (preuve que le refus vient
        // bien de la restriction du ring, pas d'un défaut de permission FS).
        let path = std::env::temp_dir().join(format!("air-iou3f-{}", std::process::id()));
        std::fs::write(&path, b"secret").expect("création fixture");
        assert!(
            std::fs::File::open(&path).is_ok(),
            "le process a bien le droit d'ouvrir le fichier hors ring"
        );

        // Ring « réseau seul » : openat2 n'est PAS en liste blanche.
        let policy = RestrictionSet::new()
            .allow_op(IoUringOpcode::Socket)
            .allow_op(IoUringOpcode::Connect)
            .allow_op(IoUringOpcode::Send)
            .allow_op(IoUringOpcode::Recv)
            .allow_op(IoUringOpcode::Close);
        let mut ring = IoUringBuilder::new(nz(8))
            .restrict(policy.as_slice())
            .build()
            .expect("ring réseau seul");
        ring.enable().expect("enable");

        // Un opcode autorisé (socket) passe — le ring est fonctionnel.
        let sock_tok = ring
            .submit_socket(SocketDomain::Ipv4, SocketType::Stream, 0)
            .expect("submit_socket autorisé");
        ring.submit_and_wait(1).expect("submit_and_wait socket");
        let sock = ring.wait_completion().expect("completion socket");
        assert_eq!(sock.token(), sock_tok);
        sock.completed().expect("socket autorisé réussit");

        // openat2 (hors liste) → REFUSÉ par le kernel, malgré le droit FS.
        let open_tok = ring
            .submit_openat2(DirFd::Cwd, cpath(&path), OpenHow::default())
            .expect("submit_openat2 (la soumission elle-même est acceptée)");
        ring.submit_and_wait(1).expect("submit_and_wait openat2");
        let opened = ring.wait_completion().expect("completion openat2");
        assert_eq!(opened.token(), open_tok);
        let err = opened
            .completed()
            .expect_err("openat2 doit être REFUSÉ sur un ring réseau seul");
        assert!(
            matches!(err, Errno::EACCES | Errno::EINVAL),
            "refus default-deny attendu (EACCES/EINVAL), obtenu {err:?}"
        );

        let _ = std::fs::remove_file(&path);
    }

    /// `require_sqe_flags` imposé : une soumission **sans** le drapeau requis est
    /// refusée par le kernel.
    #[test]
    #[cfg_attr(miri, ignore = "io_uring non supporté par Miri")]
    fn required_sqe_flag_missing_is_refused() {
        let policy = RestrictionSet::new()
            .allow_op(IoUringOpcode::Nop)
            .require_sqe_flags(SqeFlagSet::new().fixed_file());
        let mut ring = IoUringBuilder::new(nz(8))
            .restrict(policy.as_slice())
            .build()
            .expect("ring");
        ring.enable().expect("enable");
        // Nop SANS IOSQE_FIXED_FILE alors qu'il est requis → refusé.
        let tok = ring.submit_nop().expect("submit_nop (soumission acceptée)");
        ring.submit_and_wait(1).expect("submit_and_wait");
        let completion = ring.wait_completion().expect("completion");
        assert_eq!(completion.token(), tok);
        let err = completion
            .completed()
            .expect_err("drapeau requis manquant → refus");
        assert!(
            matches!(err, Errno::EACCES | Errno::EINVAL),
            "refus drapeau requis attendu, obtenu {err:?}"
        );
    }

    /// Soumission **avant** `enable` : refusée (le ring `R_DISABLED` ne soumet rien).
    #[test]
    #[cfg_attr(miri, ignore = "io_uring non supporté par Miri")]
    fn submission_before_enable_is_refused() {
        let policy = RestrictionSet::new().allow_op(IoUringOpcode::Nop);
        let mut ring = IoUringBuilder::new(nz(8))
            .restrict(policy.as_slice())
            .build()
            .expect("ring R_DISABLED");
        // PAS de enable(). La préparation du SQE réussit ; la soumission échoue.
        ring.submit_nop().expect("préparation du SQE");
        let err = ring
            .submit()
            .expect_err("soumission sur un ring désactivé doit échouer");
        // EBADFD (77) sur ring désactivé : pas un Errno nommé → on vérifie le code.
        assert_eq!(
            err.as_raw(),
            77,
            "ring désactivé : EBADFD attendu, obtenu {err:?}"
        );
    }

    /// **Immuabilité** après `enable` : l'API ne propose aucune re-restriction
    /// (garantie par construction — `restrict` n'est que sur le builder) ; on
    /// prouve ici que le **kernel** la refuse aussi (défense en profondeur) en
    /// retentant `REGISTER_RESTRICTIONS` sur un ring déjà activé.
    #[test]
    #[cfg_attr(miri, ignore = "io_uring non supporté par Miri")]
    fn restrictions_are_immutable_after_enable() {
        let policy = RestrictionSet::new().allow_op(IoUringOpcode::Nop);
        let mut ring = IoUringBuilder::new(nz(8))
            .restrict(policy.as_slice())
            .build()
            .expect("ring");
        ring.enable().expect("enable");

        // Re-restriction d'un ring ACTIF, au niveau register brut.
        let entry = encode_restriction(Restriction::AllowOp(IoUringOpcode::Read));
        let arr = [entry];
        // SAFETY: `arr` est un tableau d'une `io_uring_restriction` valide et
        // vivante pour la durée de l'appel ; `fd_raw()` est le ring fd possédé.
        // On ATTEND un échec (ring déjà activé) — aucune mutation d'état effective.
        let ret = unsafe {
            syscall::register(
                ring.fd_raw(),
                raw::IORING_REGISTER_RESTRICTIONS,
                arr.as_ptr() as u64,
                1,
            )
        };
        assert!(
            ret < 0,
            "re-restriction d'un ring déjà activé doit être refusée par le kernel"
        );
    }

    /// Couverture du bras d'erreur de `apply_restrictions` : si
    /// `REGISTER_RESTRICTIONS` échoue (ici injecté), `build()` remonte l'`Errno`
    /// et le ring `R_DISABLED` se ferme proprement (pas de fuite de FD).
    #[test]
    #[cfg_attr(miri, ignore = "io_uring_setup réel requis (register injecté)")]
    fn build_propagates_register_restrictions_error() {
        syscall::sim::clear();
        // `setup` réussit (vrai syscall) ; `register` échoue (injecté -EINVAL).
        syscall::sim::inject(syscall::sim::Syscall::Register, -22);
        let policy = RestrictionSet::new().allow_op(IoUringOpcode::Nop);
        let result = IoUringBuilder::new(nz(8))
            .restrict(policy.as_slice())
            .build();
        assert_eq!(result.err(), Some(Errno::EINVAL));
        syscall::sim::clear();
    }
}