sergio/takana

1// harkaq-exec — aplica la política y ejecuta el builder (SDD 16 §4). Corre DENTRO de bwrap,
2// como último eslabón antes del `sh -c` del build: bwrap ya puso los namespaces, el overlay y
3// la ausencia de red; esto pone el grano fino y —lo que importa— abre el canal de evidencia.
4//
5//   harkaq-exec --policy <fichero> [--abi-min 3] [--allow-nesting] [--no-landlock] -- <cmd> [...]
6//
7// Fichero de política (lo genera harkaq-policy a partir de la clausura; D1: la política se
8// DERIVA, no se escribe):
9//   ro   /usr/include/zlib.h     un fichero de la clausura: leer/ejecutar SÓLO él
10//   ro   /opt/zig                un directorio: todo el subárbol
11//   list /usr/include            listar el directorio, SIN poder leer su contenido
12//   rw   /out
13//
14// El grano POR FICHERO no es capricho: el sandbox de hammer funde las deps y el rootfs Alpine
15// en el mismo `/usr` (`--overlay-src` × N + `--tmp-overlay /`), así que /usr/include/zlib.h
16// (dep declarada) y /usr/include/stdio.h (Alpine, no declarado) son el MISMO directorio. Una
17// regla sobre /usr concede los dos y la evidencia no vale nada. En el host sí sabemos qué
18// ficheros aporta cada dep ⇒ la clausura se enumera fichero a fichero.
19//
20// `list` existe por la misma razón: pkgconf/configure NECESITAN listar /usr/lib/pkgconfig, pero
21// listar no es leer. Landlock separa READ_DIR de READ_FILE, así que se concede el listado del
22// directorio y se deniega la lectura de los .pc que la receta no declaró.
23//
24// Estático a propósito: corre dentro del rootfs Alpine (musl) del sandbox.
25//
26// D7 (fallo cerrado, honesto sobre el ABI):
27//   ABI < min      → RECHAZA el build (sin REFER/TRUNCATE no compila software real)
28//   min <= ABI < 7 → corre, pero avisa SIN EVIDENCIA (no hay audit de denegaciones)
29//   ABI >= 7       → corre con LOG_NEW_EXEC_ON: la evidencia existe
30// Nunca se afirma evidencia que el kernel no respaldó.
31
32#define _GNU_SOURCE
33#include "harkaq-uapi.h"
34#include <errno.h>
35#include <fcntl.h>
36#include <linux/filter.h>
37#include <linux/seccomp.h>
38#include <stddef.h>
39#include <stdio.h>
40#include <stdlib.h>
41#include <string.h>
42#include <sys/prctl.h>
43#include <sys/stat.h>
44#include <sys/syscall.h>
45#include <unistd.h>
46
47static int ll_create(const struct landlock_ruleset_attr *a, size_t n, __u32 f) {
48    return syscall(SYS_landlock_create_ruleset, a, n, f);
49}
50static int ll_add(int fd, enum landlock_rule_type t, const void *a, __u32 f) {
51    return syscall(SYS_landlock_add_rule, fd, t, a, f);
52}
53static int ll_restrict(int fd, __u32 f) {
54    return syscall(SYS_landlock_restrict_self, fd, f);
55}
56
57// Conjuntos de derechos por ABI. Cada uno AÑADE a los anteriores; recortamos al ABI real del
58// kernel (D7 / §3.1: se consulta el ABI por syscall, JAMÁS por versión de kernel — hay
59// backports y el número miente).
60#define FS_ABI1                                                              \
61    (LANDLOCK_ACCESS_FS_EXECUTE | LANDLOCK_ACCESS_FS_WRITE_FILE |            \
62     LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_READ_DIR |            \
63     LANDLOCK_ACCESS_FS_REMOVE_DIR | LANDLOCK_ACCESS_FS_REMOVE_FILE |        \
64     LANDLOCK_ACCESS_FS_MAKE_CHAR | LANDLOCK_ACCESS_FS_MAKE_DIR |            \
65     LANDLOCK_ACCESS_FS_MAKE_REG | LANDLOCK_ACCESS_FS_MAKE_SOCK |            \
66     LANDLOCK_ACCESS_FS_MAKE_FIFO | LANDLOCK_ACCESS_FS_MAKE_BLOCK |          \
67     LANDLOCK_ACCESS_FS_MAKE_SYM)
68#define FS_ABI2 (FS_ABI1 | LANDLOCK_ACCESS_FS_REFER)
69#define FS_ABI3 (FS_ABI2 | LANDLOCK_ACCESS_FS_TRUNCATE)
70#define FS_ABI5 (FS_ABI3 | LANDLOCK_ACCESS_FS_IOCTL_DEV)
71
72#define RO_RIGHTS \
73    (LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_READ_DIR | LANDLOCK_ACCESS_FS_EXECUTE)
74
75// Derechos que Landlock SÓLO admite sobre directorios. Añadir una regla con cualquiera de
76// éstos sobre un fichero regular hace que el kernel rechace la regla entera con EINVAL — y
77// como la clausura es mayormente ficheros sueltos (§4), sin esta máscara no arranca nada.
78#define DIR_ONLY_RIGHTS                                                           \
79    (LANDLOCK_ACCESS_FS_READ_DIR | LANDLOCK_ACCESS_FS_REMOVE_DIR |                \
80     LANDLOCK_ACCESS_FS_REMOVE_FILE | LANDLOCK_ACCESS_FS_MAKE_CHAR |              \
81     LANDLOCK_ACCESS_FS_MAKE_DIR | LANDLOCK_ACCESS_FS_MAKE_REG |                  \
82     LANDLOCK_ACCESS_FS_MAKE_SOCK | LANDLOCK_ACCESS_FS_MAKE_FIFO |                \
83     LANDLOCK_ACCESS_FS_MAKE_BLOCK | LANDLOCK_ACCESS_FS_MAKE_SYM |                \
84     LANDLOCK_ACCESS_FS_REFER)
85
86// ------------------------------------------------------------------ seccomp (D4)
87//
88// D4: "Landlock no basta". Landlock cubre fs, puertos TCP e IPC scoping — no cubre ptrace, bpf,
89// userfaultfd, keyctl, io_uring, montajes, ni la mitad de la superficie interesante.
90//
91// DENYLIST, no allowlist (corrige a D4, que pedía allowlist). Un allowlist por syscall para
92// builds ARBITRARIOS —compiladores, make, shells, linkers, perl— es un blanco móvil: cada
93// herramienta nueva lo rompe. Es el riesgo del §7 ("los falsos positivos matan proyectos de
94// sandboxing") aplicado a las syscalls, y con peor final: un build que muere por una syscall
95// legítima no da un diagnóstico útil, da un misterio. Lo *peligroso*, en cambio, es enumerable
96// y estable: no hay build honesto que cargue módulos, haga kexec o attachee un ptrace.
97//
98// EPERM y no KILL: matar el proceso deja un cadáver sin explicación; EPERM deja al build fallar
99// donde corresponde y al log decir por qué. Y lo que importa —la evidencia— la sigue dando
100// Landlock; esto sólo recorta superficie de escape.
101static const int SYSCALLS_DENEGADAS[] = {
102    // io_uring: superficie de kernel enorme y bypassea buena parte del análisis por-syscall.
103    // Denegado explícitamente en v1 (D4). Si un builder lo necesita, que lo justifique.
104#ifdef __NR_io_uring_setup
105    __NR_io_uring_setup, __NR_io_uring_enter, __NR_io_uring_register,
106#endif
107    // Inspección/inyección entre procesos: un build no necesita mirar dentro de otro.
108    __NR_ptrace, __NR_process_vm_readv, __NR_process_vm_writev,
109#ifdef __NR_bpf
110    __NR_bpf,
111#endif
112#ifdef __NR_userfaultfd
113    __NR_userfaultfd,  // usado para ganar carreras TOCTOU en el kernel
114#endif
115    // Llavero del kernel: ni se lee ni se siembra desde un build.
116    __NR_keyctl, __NR_add_key, __NR_request_key,
117    // Módulos y kexec: un build que toca esto no es un build.
118    __NR_init_module, __NR_finit_module, __NR_delete_module, __NR_kexec_load,
119#ifdef __NR_kexec_file_load
120    __NR_kexec_file_load,
121#endif
122    // perf: superficie histórica de escalada.
123    __NR_perf_event_open,
124};
125
126// La FAMILIA DEL ANIDAMIENTO, separada del resto a propósito.
127//
128// Para un BUILD estas syscalls no tienen uso legítimo: bwrap ya armó el árbol y re-montar sólo
129// sirve para escapar de él. Pero harkaq también enjaula instancias ajenas (qorpa, ADR 0015), y ahí
130// hay un caso legítimo y central: **Steam ya es un contenedor**. Su pressure-vessel monta y crea
131// namespaces DENTRO del nuestro, que es la configuración exacta que Valve prueba (ADR 0015 D6).
132// Denegarle `mount` no lo hace más seguro: lo hace no arrancar.
133//
134// Por eso se deniegan POR DEFECTO —el build no cambia ni un byte— y sólo se levantan con
135// `--allow-nesting`, que en qorpa cuelga de una concesión DECLARADA en el manifiesto. Abrir sólo
136// lo declarado, otra vez.
137//
138// `pivot_root` no está en ninguna de las dos listas: bwrap lo usa ANTES de llegar acá.
139static const int SYSCALLS_ANIDAMIENTO[] = {
140    __NR_mount, __NR_umount2,
141#ifdef __NR_open_tree
142    __NR_open_tree, __NR_move_mount, __NR_fsopen, __NR_fsconfig, __NR_fsmount,
143#endif
144    // Salirse de los namespaces que bwrap puso.
145    __NR_setns,
146};
147
148// TECHO DE LA LISTA, y por qué no es un detalle: `jt`/`jf` de la BPF clásica son `__u8`. En la
149// forma de abajo el salto más largo mide n+3, así que a partir de ~252 entradas el desplazamiento
150// DA LA VUELTA y el filtro deja de decir lo que dice este fichero — sin error y sin aviso. Hoy son
151// 25 y sobra sitio; el riesgo es que agregar syscalls a una denylist es exactamente lo que uno
152// hace sin pensarlo. Esto no genera código: es un portón de compilación.
153// (SDD 25 T17 midió además que la longitud de esta lista NO cuesta nada en ejecución — el bitmap
154//  de acción constante del kernel la hace plana —, así que no hay ningún motivo de rendimiento
155//  para recortarla ni para reordenarla.)
156_Static_assert((sizeof(SYSCALLS_DENEGADAS) + sizeof(SYSCALLS_ANIDAMIENTO)) * 2 /
157                       sizeof(SYSCALLS_DENEGADAS[0]) <= 240,
158               "la denylist pasa el techo de salto de la BPF clasica (__u8): partir el filtro");
159
160// ── i386: por qué hay una SEGUNDA tabla de números ──────────────────────────────────────────────
161//
162// El filtro de abajo comprueba la arquitectura y MATA lo que no sea x86_64. Para un build es
163// correcto y es la defensa clásica: los números de syscall son POR ARCH, y sin el check un binario
164// i386 pediría otra syscall con el mismo número. Para una instancia ajena es FATAL, y se midió:
165// el cliente de Steam es un ELF i386, y moría con **SIGSYS** (`exit code 159`) antes de imprimir
166// una línea. Un `ldd` que devuelve 159 no se parece en nada a «tu jaula mata los 32 bits».
167//
168// La salida NO es aflojar el check —eso reabre el agujero— sino darle a i386 su propia tabla y
169// aplicarle la MISMA política. Los números van literales porque compilando para x86_64 no hay
170// `__NR_*` de i386; son ABI estable, Linux no los renumera nunca.
171#define I386_ARCH_TABLA_BASE                                                  \
172    26,   /* ptrace */                                                        \
173    347, 348, /* process_vm_readv, process_vm_writev */                       \
174    357,  /* bpf */                                                           \
175    374,  /* userfaultfd */                                                   \
176    288, 286, 287, /* keyctl, add_key, request_key */                         \
177    128, 350, 129, /* init_module, finit_module, delete_module */             \
178    283,  /* kexec_load — `kexec_file_load` NO EXISTE en i386: poner su número de x86_64 (320)
179             habría denegado `utimensat`, que en i386 tiene ESE número y la usa cualquier cosa
180             que toque una marca de tiempo. Verificado contra
181             /usr/include/asm/unistd_32.h, los 25 números uno por uno; éste era el único mal. */                               \
182    336,  /* perf_event_open */                                               \
183    425, 426, 427 /* io_uring_{setup,enter,register} */
184#define I386_ARCH_TABLA_ANIDAMIENTO                                           \
185    21, 52, /* mount, umount2 */                                              \
186    428, 429, 430, 431, 432, /* open_tree, move_mount, fsopen, fsconfig, fsmount */ \
187    346  /* setns */
188static const int SYSCALLS_DENEGADAS_I386[] = {I386_ARCH_TABLA_BASE};
189static const int SYSCALLS_ANIDAMIENTO_I386[] = {I386_ARCH_TABLA_ANIDAMIENTO};
190
191// Arma e instala el filtro. Devuelve 0 si quedó puesto, -1 si el kernel no lo aceptó.
192static int poner_seccomp(int permitir_anidamiento) {
193    const int n64b = (int)(sizeof(SYSCALLS_DENEGADAS) / sizeof(SYSCALLS_DENEGADAS[0]));
194    const int n64a = permitir_anidamiento
195                         ? 0
196                         : (int)(sizeof(SYSCALLS_ANIDAMIENTO) / sizeof(SYSCALLS_ANIDAMIENTO[0]));
197    const int n32b = (int)(sizeof(SYSCALLS_DENEGADAS_I386) / sizeof(SYSCALLS_DENEGADAS_I386[0]));
198    const int n32a =
199        permitir_anidamiento
200            ? 0
201            : (int)(sizeof(SYSCALLS_ANIDAMIENTO_I386) / sizeof(SYSCALLS_ANIDAMIENTO_I386[0]));
202    const int n64 = n64b + n64a, n32 = n32b + n32a;
203
204    int *a64 = calloc(n64 ? n64 : 1, sizeof(int));
205    int *a32 = calloc(n32 ? n32 : 1, sizeof(int));
206    if (!a64 || !a32) { free(a64); free(a32); return -1; }
207    for (int i = 0; i < n64b; i++) a64[i] = SYSCALLS_DENEGADAS[i];
208    for (int i = 0; i < n64a; i++) a64[n64b + i] = SYSCALLS_ANIDAMIENTO[i];
209    for (int i = 0; i < n32b; i++) a32[i] = SYSCALLS_DENEGADAS_I386[i];
210    for (int i = 0; i < n32a; i++) a32[n32b + i] = SYSCALLS_ANIDAMIENTO_I386[i];
211
212    // Disposición: [arch?x86_64] → tabla 64 → ALLOW ; si no, [arch?i386] → tabla 32 → ALLOW ;
213    // si no, KILL. El desplazamiento de un salto BPF clásico es __u8, así que todo esto tiene que
214    // caber en 255 instrucciones — de ahí el _Static_assert de arriba, que ahora suma las cuatro
215    // tablas.
216    const int len = 2 + 1 + n64 + 1 + 2 + 1 + n32 + 1 + 2;
217    struct sock_filter *f = calloc(len, sizeof(*f));
218    if (!f) { free(a64); free(a32); return -1; }
219
220    const int I_I386 = 2 + 1 + n64 + 1;      // donde arranca la rama de 32 bits
221    const int I_ERRNO = len - 2;
222    const int I_KILL = len - 1;
223    int k = 0;
224
225    f[k++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
226                                          offsetof(struct seccomp_data, arch));
227    const int I_ARCH64 = k++;
228    f[I_ARCH64] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, AUDIT_ARCH_X86_64, 0,
229                                               I_I386 - I_ARCH64 - 1);
230    f[k++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
231                                          offsetof(struct seccomp_data, nr));
232    for (int i = 0; i < n64; i++, k++)
233        f[k] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, (unsigned)a64[i],
234                                            I_ERRNO - k - 1, 0);
235    f[k++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
236
237    // Rama i386. Hay que RECARGAR `arch`: el acumulador quedó con el número de syscall.
238    f[k++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
239                                          offsetof(struct seccomp_data, arch));
240    const int I_ARCH32 = k++;
241    f[I_ARCH32] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, AUDIT_ARCH_I386, 0,
242                                               I_KILL - I_ARCH32 - 1);
243    f[k++] = (struct sock_filter)BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
244                                          offsetof(struct seccomp_data, nr));
245    for (int i = 0; i < n32; i++, k++)
246        f[k] = (struct sock_filter)BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, (unsigned)a32[i],
247                                            I_ERRNO - k - 1, 0);
248    f[k++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ALLOW);
249    f[k++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K,
250                                          SECCOMP_RET_ERRNO | (EPERM & SECCOMP_RET_DATA));
251    f[k++] = (struct sock_filter)BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_KILL_PROCESS);
252
253    struct sock_fprog prog = {.len = (unsigned short)k, .filter = f};
254    // Requiere no_new_privs, que ya está puesto antes de llamar acá.
255    int r = syscall(SYS_seccomp, SECCOMP_SET_MODE_FILTER, 0, &prog);
256    free(f);
257    free(a64);
258    free(a32);
259    return r;
260}
261
262int main(int argc, char **argv) {
263    const char *policy = NULL;
264    int abi_min = 3, permitir_anidamiento = 0, sin_landlock = 0, i;
265    for (i = 1; i < argc; i++) {
266        if (!strcmp(argv[i], "--policy") && i + 1 < argc) policy = argv[++i];
267        else if (!strcmp(argv[i], "--abi-min") && i + 1 < argc) abi_min = atoi(argv[++i]);
268        else if (!strcmp(argv[i], "--allow-nesting")) permitir_anidamiento = 1;
269        // MEDIDO 2026-09-03: un dominio Landlock activo hace fallar `mount` con EACCES aunque
270        // seccomp lo permita — el kernel no deja crear montajes nuevos bajo un dominio, porque un
271        // montaje nuevo escaparía de sus reglas por-ruta. Es decir: **Landlock y un runtime de
272        // contenedores anidado son incompatibles hoy**, y eso incluye a pressure-vessel de Valve
273        // (ADR 0015 D6). Para ese caso se cambia política-de-fs por poder anidar; seccomp y
274        // no_new_privs SIGUEN puestos, que es lo que más importa con un binario ajeno. Nunca por
275        // defecto, y siempre dicho en la línea de arranque: la regla de harkaq es no afirmar una
276        // jaula que no se puso.
277        else if (!strcmp(argv[i], "--no-landlock")) sin_landlock = 1;
278        else if (!strcmp(argv[i], "--")) { i++; break; }
279    }
280    if (!policy || i >= argc) {
281        fprintf(stderr, "uso: harkaq-exec --policy <f> [--abi-min N] -- <cmd> [args...]\n");
282        return 2;
283    }
284    char **cmd = &argv[i];
285
286    int abi = ll_create(NULL, 0, LANDLOCK_CREATE_RULESET_VERSION);
287    if (abi < abi_min) {
288        // Fallo CERRADO: no correr un build que creemos enjaulado y no lo está.
289        fprintf(stderr,
290                "[harkaq] RECHAZO: ABI de Landlock = %d, se exige >= %d.\n"
291                "         Sin REFER/TRUNCATE no compila software real y la jaula sería ficción.\n",
292                abi, abi_min);
293        return 4;
294    }
295
296    int n_file = 0, n_dir = 0;
297    if (sin_landlock) goto tras_landlock;
298
299    __u64 handled = abi >= 5 ? FS_ABI5 : abi >= 3 ? FS_ABI3 : abi >= 2 ? FS_ABI2 : FS_ABI1;
300    struct landlock_ruleset_attr attr = {.handled_access_fs = handled};
301    int rs = ll_create(&attr, sizeof(attr), 0);
302    if (rs < 0) { perror("[harkaq] create_ruleset"); return 4; }
303
304    FILE *f = fopen(policy, "r");
305    if (!f) { perror("[harkaq] abrir política"); return 4; }
306    char line[4200];
307    while (fgets(line, sizeof(line), f)) {
308        char *nl = strchr(line, '\n');
309        if (nl) *nl = 0;
310        if (!line[0] || line[0] == '#') continue;
311        __u64 grant;
312        char *p;
313        if (!strncmp(line, "ro ", 3)) { grant = RO_RIGHTS; p = line + 3; }
314        else if (!strncmp(line, "rw ", 3)) { grant = handled; p = line + 3; }
315        else if (!strncmp(line, "list ", 5)) { grant = LANDLOCK_ACCESS_FS_READ_DIR; p = line + 5; }
316        else {
317            fprintf(stderr, "[harkaq] política inválida: %s\n", line);
318            return 4;
319        }
320        int dfd = open(p, O_PATH | O_CLOEXEC);
321        if (dfd < 0) {
322            // Una entrada de la clausura que no existe es un bug de harkaq-policy, no del
323            // build. Fallar ruidoso: si la ignoráramos, la política sería MÁS chica que la
324            // clausura y el build denegaría cosas legítimas — falsos positivos que matan
325            // el proyecto (§7).
326            fprintf(stderr, "[harkaq] la política nombra un path inexistente: %s (%m)\n", p);
327            return 4;
328        }
329        // Recortar los derechos de-sólo-directorio cuando el destino NO lo es: el kernel
330        // rechazaría la regla entera con EINVAL. Es el caso MAYORITARIO — la clausura es una
331        // lista de ficheros.
332        struct stat st;
333        int is_dir = (fstat(dfd, &st) == 0) && S_ISDIR(st.st_mode);
334        if (!is_dir) grant &= ~(__u64)DIR_ONLY_RIGHTS;
335        grant &= handled;  // nunca conceder más de lo que el ruleset declara manejar
336        if (!grant) {
337            fprintf(stderr, "[harkaq] regla vacía tras recortar por tipo: %s\n", p);
338            close(dfd);
339            return 4;
340        }
341        struct landlock_path_beneath_attr pb = {.allowed_access = grant, .parent_fd = dfd};
342        if (ll_add(rs, LANDLOCK_RULE_PATH_BENEATH, &pb, 0) < 0) {
343            fprintf(stderr, "[harkaq] add_rule(%s): %m\n", p);
344            close(dfd);
345            return 4;
346        }
347        close(dfd);
348        is_dir ? n_dir++ : n_file++;
349    }
350    fclose(f);
351
352    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) { perror("[harkaq] no_new_privs"); return 4; }
353
354    // LOG_NEW_EXEC_ON: el flag del que cuelga TODO. harkaq restringe y DESPUÉS ejecuta el
355    // builder; sin este flag el kernel no loguea ninguna denegación posterior al execve y
356    // harkaq certificaría como herméticos todos los builds, para siempre, sin un solo error
357    // visible (medido: §3.4). No es configuración, es la diferencia entre el sistema y un
358    // sello de goma.
359    __u32 flags = 0;
360    if (abi >= 7) flags |= LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON;
361    if (abi >= 8) flags |= LANDLOCK_RESTRICT_SELF_TSYNC;  // D5: cubre todos los hilos
362    if (ll_restrict(rs, flags) < 0) { perror("[harkaq] restrict_self"); return 4; }
363    close(rs);
364
365tras_landlock:;
366
367    // seccomp DESPUÉS de landlock y de no_new_privs, y justo antes del exec: el filtro se hereda
368    // por fork/exec igual que el dominio de Landlock (D5), así que cubre todo el árbol del build.
369    // Si el kernel lo rechaza NO se sigue: D7 es fallo cerrado — correr un build creyéndolo
370    // enjaulado cuando le falta media jaula es peor que no correrlo.
371    if (poner_seccomp(permitir_anidamiento) < 0) {
372        fprintf(stderr, "[harkaq] RECHAZO: no pude instalar el filtro seccomp (%m).\n"
373                        "         ¿CONFIG_SECCOMP_FILTER=y? D4: seccomp no es opcional.\n");
374        return 4;
375    }
376
377    if (sin_landlock)
378        fprintf(stderr,
379                "[harkaq] SIN LANDLOCK por pedido explícito: seccomp y no_new_privs SÍ están, pero "
380                "NO hay política de ficheros ni evidencia. El confinamiento de fs queda en manos "
381                "del namespace de montaje de quien invoca.\n");
382    else if (abi < 7)
383        fprintf(stderr,
384                "[harkaq] AVISO: ABI %d < 7 ⇒ el kernel no audita denegaciones. El build corre "
385                "ENJAULADO pero SIN EVIDENCIA; el veredicto no podrá afirmar hermeticidad.\n",
386                abi);
387    else
388        fprintf(stderr,
389                "[harkaq] jaula puesta: ABI %d, clausura = %d ficheros + %d dirs, "
390                "logging post-exec ON%s\n",
391                abi, n_file, n_dir,
392                permitir_anidamiento ? ", ANIDAMIENTO PERMITIDO (mount/setns)" : "");
393
394    execvp(cmd[0], cmd);
395    fprintf(stderr, "[harkaq] execvp %s: %m\n", cmd[0]);
396    return 127;
397}