feat(brahman-net+handshake): swarm-level deny via libp2p block_list

Optimizacion de seguridad: la denylist ya no espera al handshake
brahman para rechazar — ahora se proyecta al block_list behaviour
del swarm libp2p. Conexiones desde peers baneados son rechazadas
ANTES del Noise handshake, ahorrando el round-trip TCP+Noise por
cada intento denegado.

brahman-net:
- Nuevo behaviour block_list: allow_block_list::Behaviour<BlockedPeers>
  añadido al BrahmanBehaviour derivado. Default vacio.
- Nuevos comandos BlockPeer / UnblockPeer en el enum interno.
- API publica: BrahmanNet::block_peer / unblock_peer. Idempotentes.
- Dep nueva: libp2p-allow-block-list 0.6 (sub-crate, no es feature
  de libp2p en 0.56).

brahman_handshake::peer_policy:
- PeerPolicy gana net: Arc<RwLock<Option<Arc<BrahmanNet>>>>. Default
  None preserva callers existentes.
- Nuevo attach_to_net(net): sync inicial (block_peer por cada en
  deny) + guarda net para diff-sync en cada reload.
- reload extendido: snapshot prev_deny ANTES de mutar inner. Tras
  mutar, sync_deny_to_swarm aplica block/unblock por cada
  added/removed.
- Atomicidad preservada: si parse falla, sync no ocurre y la
  version anterior persiste tanto en policy como en block_list.

ente-zero: tras setup_brahman_net + setup_brahman_policy, si AMBOS
estan presentes -> policy.attach_to_net(net.clone()) con log
informativo.

Tests: 1 nuevo E2E swarm_level_deny_blocks_before_noise. A configura
policy con deny + attach_to_net. Cliente baneado intenta connect_libp2p;
en lugar del Unauthorized del handshake, ahora falla con error de
transporte/stream o timeout — el dial nunca completa porque el swarm
rechaza la conexion.

5 tests verdes en network_libp2p.rs. 31 tests totales en brahman-
handshake + brahman-net.

Trade-offs documentados:
- Mas eficiente contra DoS (no consume CPU del Noise por peer baneado).
- Misma fuente de verdad: PeerPolicy. Swarm es cache derivado, sync
  via diff en cada reload, sin drift posible.
- El handshake-level gate sigue activo como segunda linea (defensa
  en profundidad si por bug/race un peer baneado pasa el block_list).

crates/core/brahman-handshake/src/peer_policy.rs

@@ -38,7 +38,7 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, RwLock};
 use std::time::{Duration, Instant};
 
-use brahman_net::PeerId;
+use brahman_net::{BrahmanNet, PeerId};
 use tracing::{debug, info, warn};
 
 /// Política de admisión combinada (allow + deny). Clone barato (todos
@@ -47,6 +47,14 @@ use tracing::{debug, info, warn};
 pub struct PeerPolicy {
     inner: Arc<RwLock<PolicyInner>>,
     paths: Arc<PolicyPaths>,
+    /// `BrahmanNet` opcional asociado vía [`Self::attach_to_net`].
+    /// Si está set, cada cambio en la denylist se sincroniza con el
+    /// `block_list` behaviour del swarm — los peers baneados son
+    /// rechazados ANTES del Noise handshake. `RwLock<Option<...>>`
+    /// para que `attach_to_net` se pueda llamar después del
+    /// constructor (típico en ente-zero: primero arma la policy,
+    /// después el net, después attach).
+    net: Arc<RwLock<Option<Arc<BrahmanNet>>>>,
 }
 
 #[derive(Default)]
@@ -111,6 +119,7 @@ impl PeerPolicy {
         Self {
             inner: Arc::new(RwLock::new(PolicyInner::default())),
             paths: Arc::new(PolicyPaths::default()),
+            net: Arc::new(RwLock::new(None)),
         }
     }
 
@@ -120,6 +129,7 @@ impl PeerPolicy {
         Self {
             inner: Arc::new(RwLock::new(PolicyInner { allow, deny })),
             paths: Arc::new(PolicyPaths::default()),
+            net: Arc::new(RwLock::new(None)),
         }
     }
 
@@ -145,6 +155,7 @@ impl PeerPolicy {
                 allow_path: allow_path.map(Path::to_path_buf),
                 deny_path: deny_path.map(Path::to_path_buf),
             }),
+            net: Arc::new(RwLock::new(None)),
         })
     }
 
@@ -184,6 +195,11 @@ impl PeerPolicy {
     /// falla, la versión anterior persiste y el error se devuelve.
     /// Esto evita que un typo en el archivo deje al Init en modo
     /// inseguro.
+    ///
+    /// Si hay un `BrahmanNet` attached vía [`Self::attach_to_net`],
+    /// el cambio de denylist se sincroniza con el `block_list` del
+    /// swarm: se calcula el diff (added/removed) y se aplican
+    /// `block_peer`/`unblock_peer` por cada cambio.
     pub fn reload(&self) -> Result<(), PolicyError> {
         let new_allow = match &self.paths.allow_path {
             Some(p) => Some(parse_peer_set(p)?),
@@ -193,13 +209,58 @@ impl PeerPolicy {
             Some(p) => parse_peer_set(p)?,
             None => BTreeSet::new(),
         };
+        // Snapshot de la deny actual ANTES de mutar, para diff.
+        let prev_deny = self
+            .inner
+            .read()
+            .map(|g| g.deny.clone())
+            .unwrap_or_default();
         if let Ok(mut inner) = self.inner.write() {
             inner.allow = new_allow;
-            inner.deny = new_deny;
+            inner.deny = new_deny.clone();
         }
+        self.sync_deny_to_swarm(&prev_deny, &new_deny);
         Ok(())
     }
 
+    /// Asocia esta política a un `BrahmanNet`. Sincroniza el snapshot
+    /// actual de la denylist con el `block_list` behaviour del swarm
+    /// (cada peer baneado se rechaza ANTES del Noise handshake), y
+    /// registra el net para re-sincronizarse en cada [`Self::reload`].
+    ///
+    /// Si ya había un net attached, se reemplaza (caso esperado:
+    /// un Init no debería tener dos `BrahmanNet`s).
+    pub fn attach_to_net(&self, net: Arc<BrahmanNet>) {
+        // Sync inicial: bloquear todos los peers actualmente en deny.
+        if let Ok(inner) = self.inner.read() {
+            for peer in &inner.deny {
+                net.block_peer(*peer);
+            }
+        }
+        if let Ok(mut slot) = self.net.write() {
+            *slot = Some(net);
+        }
+    }
+
+    /// Calcula el diff entre `prev` y `new` y aplica
+    /// `block_peer`/`unblock_peer` al net asociado (si hay).
+    /// No-op si no hay net attached.
+    fn sync_deny_to_swarm(&self, prev: &BTreeSet<PeerId>, new: &BTreeSet<PeerId>) {
+        let net = match self.net.read() {
+            Ok(g) => match g.as_ref() {
+                Some(n) => n.clone(),
+                None => return,
+            },
+            Err(_) => return,
+        };
+        for added in new.difference(prev) {
+            net.block_peer(*added);
+        }
+        for removed in prev.difference(new) {
+            net.unblock_peer(*removed);
+        }
+    }
+
     /// Arranca un thread que vigila los archivos asociados con
     /// `notify` y llama [`Self::reload`] cuando cambian. Debounce
     /// 250ms para coalescer múltiples eventos por save (los editores

crates/core/brahman-handshake/tests/network_libp2p.rs

@@ -321,3 +321,78 @@ async fn libp2p_handshake_denylist_blocks_listed_peer() {
     }
     other_client.farewell().await.ok();
 }
+
+/// Swarm-level deny via `PeerPolicy::attach_to_net`: cuando la deny
+/// se aplica al swarm vía `block_list`, el peer baneado es rechazado
+/// en el dial — la conexión TCP/Noise nunca completa, así que el
+/// cliente nunca llega siquiera a mandar el Hello. Más eficiente que
+/// el handshake-level deny.
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn swarm_level_deny_blocks_before_noise() {
+    let banned_kp = Keypair::generate_ed25519();
+    let banned_peer = banned_kp.public().to_peer_id();
+
+    let tmp = TempDir::new().unwrap();
+    let unix_socket = tmp.path().join("brahman-init.sock");
+    let policy = brahman_handshake::peer_policy::PeerPolicy::from_sets(
+        None,
+        [banned_peer].into_iter().collect(),
+    );
+    let server = Arc::new(
+        Server::bind(
+            &unix_socket,
+            ServerConfig {
+                init_attached: true,
+                broker: None,
+                net: None,
+                policy: Some(policy.clone()),
+            },
+        )
+        .unwrap(),
+    );
+    let server_net = Arc::new(BrahmanNet::new().unwrap());
+    let server_peer = server_net.peer_id;
+
+    // ATTACH: la deny se proyecta al swarm. Es lo nuevo de este
+    // commit — sin esta llamada, el deny seguiría aplicando sólo
+    // al nivel de handshake brahman (lo que también funciona pero
+    // gasta un round-trip Noise).
+    policy.attach_to_net(server_net.clone());
+
+    let actual = server_net
+        .listen("/ip4/127.0.0.1/tcp/0".parse().unwrap())
+        .await;
+    let mut full = actual.clone();
+    full.push(Protocol::P2p(server_peer));
+
+    tokio::spawn(run_libp2p_accept_loop(server.clone(), server_net.clone()));
+
+    // Cliente baneado intenta dial + handshake. Con swarm-level
+    // deny, la conexión libp2p ni siquiera completa: `connect_libp2p`
+    // falla con error de open_stream (peer inalcanzable / connection
+    // refused) en lugar del Unauthorized del handshake-level path.
+    let banned_net = BrahmanNet::with_keypair(banned_kp.clone()).unwrap();
+    banned_net.dial(full.clone());
+
+    let card = sample_card("test.swarm_banned");
+    // Timeout corto: si el block falla, el handshake completaría
+    // rápido en localhost. Si funciona, debería fallar el dial casi
+    // instantáneo o colgarse hasta el timeout.
+    let result = tokio::time::timeout(
+        Duration::from_secs(3),
+        connect_libp2p(&banned_net, server_peer, card, None, &banned_kp),
+    )
+    .await;
+
+    match result {
+        Ok(Ok(_)) => panic!("peer baneado a nivel swarm NO debería completar handshake"),
+        Ok(Err(e)) => {
+            // Esperado: error de transporte/stream, no de handshake.
+            tracing::info!(error = %e, "swarm-level deny rechazó como esperado");
+        }
+        Err(_) => {
+            // También aceptable: timeout porque el dial nunca completa.
+            tracing::info!("swarm-level deny → connect timeout (también OK)");
+        }
+    }
+}