harkaq: Q1 CERRADA — la evidencia llega; + D9 (canario deliberado) y el banco de pruebas
Q1 era el gate del proyecto (¿llegan los registros AUDIT_LANDLOCK_* a un lector?). Medido en el laptop (ABI 10) con scripts/harkaq/q1-audit.c: ✅ VIABLE. El multicast AUDIT_NLGRP_READLOG entrega blockers=fs.read_file path="/etc/passwd" dev="nvme1n1p6" ino=4458369 + exe=/comm= del que lo intentó. Es el diagnóstico de de-Alpinización que el SDD promete, saliendo del kernel sin instrumentar nada. Dos precondiciones que el Draft 2 no tenía, ambas medidas: - audit_enabled=1 NO viene de fábrica (sin audit=1 en cmdline, sin auditd) ⇒ cero registros de cualquier escenario. AUDIT_SET o audit=1 horneado. - LOG_NEW_EXEC_ON es OBLIGATORIO: same-exec=2 registros, new-exec=0, new-exec-logon=4. harkaq restringe y DESPUÉS execea el builder ⇒ sin el flag certificaría herméticos TODOS los builds, denials=[], sin un error. D9 (nueva, no negociable): el canario lo fabrica harkaq. Se investigó si el registro `deallocated denials=N` servía de verificación cruzada gratis: NO. Medido con ventana de 6s, un dominio con flags default y denegación post-exec no emite NADA (ni allocated, ni access, ni el contador); y el `allocated` es perezoso (llega pegado al primer denial logueado) ⇒ su ausencia tampoco prueba nada. Un build hermético y un lector ciego son bit-idénticos: denials=[]. El Verdict pasa a 3 estados (Hermetico / Impuro / SinEvidencia). El contador SÍ sirve para lo otro: nº ACCESS == denials caza registros perdidos por backlog (riesgo real con la granja en paralelo). Nota de método (§3.4): la 1ª corrida dio 0 en los 3 escenarios y "confirmaba" la hipótesis. Era el instrumento roto (AUDIT_GET con NLM_F_ACK: el ACK llegaba antes que la respuesta → enabled=-1 → nunca se encendía el audit). Se cazó sólo porque el CONTROL (same-exec) también dio 0, y eso era imposible. Es el modo de falla de harkaq en vivo sobre su propio banco. El test ahora aborta (exit 4) si no confirma audit_enabled=1. Nuevas Q1b (¿el lector ve a través del userns de bwrap? ¿cómo se atribuye un registro a SU build con la granja en paralelo?) y Q1c (privilegio de harkaq-audit). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 4.8
+117
-10
@@ -169,6 +169,68 @@ resultó ser la correcta por razones de seguridad que nadie había escrito todav
|
||||
|
||||
**Fase 3 se elimina del plan.** El riesgo de cronograma desaparece.
|
||||
|
||||
### 3.4 Q1 resuelta: la evidencia llega, con dos precondiciones y un canario obligatorio
|
||||
|
||||
Experimento `scripts/harkaq/q1-audit.c` (2026-07-15), corrido en el laptop (ABI 10). Tres
|
||||
escenarios: denegación sin `execve`, con `execve` y flags por defecto, y con `execve` +
|
||||
`LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON`.
|
||||
|
||||
**La evidencia llega, y es exactamente la que el diseño necesita.** Un lector no privilegiado
|
||||
del grupo multicast `AUDIT_NLGRP_READLOG` recibe:
|
||||
|
||||
```
|
||||
domain=146973ef2 blockers=fs.read_file path="/etc/passwd" dev="nvme1n1p6" ino=4458369
|
||||
domain=146973ef2 status=allocated mode=enforcing pid=3359 uid=0 exe="…/q1-audit" comm="q1-audit"
|
||||
```
|
||||
|
||||
`blockers` + `path` + `dev` + `ino` + el `exe` que lo intentó. Ese registro **es** el diagnóstico
|
||||
de de-Alpinización de §0, y sale del kernel sin instrumentar nada.
|
||||
|
||||
**Precondición 1 — `audit_enabled=1`.** Medido: el laptop arranca con `audit_enabled=0` (sin
|
||||
`audit=1` en el cmdline, sin `auditd`). Con audit apagado **no se emite ningún registro, de
|
||||
ningún escenario**. Se enciende con `AUDIT_SET` por netlink (`CAP_AUDIT_CONTROL`) o con `audit=1`
|
||||
en el cmdline — que para el kernel de hammer es horneable, igual que el resto del cmdline metal.
|
||||
|
||||
**Precondición 2 — `LOG_NEW_EXEC_ON` es obligatorio, y su ausencia es indetectable.** Medido:
|
||||
|
||||
| Escenario | Registros `ACCESS` |
|
||||
|---|---|
|
||||
| `same-exec` (sin `execve`) | **2** — logueado por defecto |
|
||||
| `new-exec` (flags por defecto) | **0** |
|
||||
| `new-exec-logon` (`LOG_NEW_EXEC_ON`) | **4** |
|
||||
|
||||
Misma jaula, misma denegación, `cat` rebotó con `EACCES` en los tres. harkaq **restringe y después
|
||||
hace `execve`** del builder (bwrap → `/bin/sh -c` → make → `zig cc`): es el caso `new-exec`. Sin el
|
||||
flag, harkaq certificaría como herméticos **todos** los builds, `denials=[]`, para siempre, sin un
|
||||
solo error visible. El flag no es configuración: es la diferencia entre el sistema y un sello de goma.
|
||||
|
||||
**No hay canario gratis en el kernel.** Se investigó si el registro `status=deallocated denials=N`
|
||||
podía servir de verificación cruzada. Medido, con una ventana de escucha de 6s: **un dominio con
|
||||
flags por defecto cuya única denegación es post-`exec` no emite absolutamente nada** — ni
|
||||
`allocated`, ni `access`, ni el `deallocated` con su contador. El contador existe **sólo para
|
||||
dominios que ya loguean**. Y el `allocated` se emite **perezosamente**, pegado al primer denial
|
||||
logueado (mismo evento de audit), así que un build genuinamente limpio tampoco lo produce: su
|
||||
presencia no puede usarse como prueba de que los flags tomaron.
|
||||
|
||||
⇒ **D9 (nueva decisión cerrada, abajo): el canario lo fabrica harkaq.**
|
||||
|
||||
Lo que el contador sí resuelve, cuando el logging está bien puesto: exigir
|
||||
`nº de registros ACCESS recibidos == denials` del `deallocated` detecta **registros perdidos** por
|
||||
desborde del backlog de audit — un riesgo real con la granja construyendo en paralelo. Son dos
|
||||
chequeos para dos fallas distintas (mala configuración vs. pérdida), y hacen falta los dos.
|
||||
|
||||
> **Nota de método, que vale más que el resultado.** La primera corrida del experimento dio 0
|
||||
> registros en los tres escenarios y parecía confirmar la hipótesis. Era un bug del instrumento:
|
||||
> el `AUDIT_GET` pedía `NLM_F_ACK`, el ACK llegaba antes que la respuesta (el kernel la manda
|
||||
> asíncrona), el lector lo tomaba por fallo, `enabled` quedaba en `-1`, la rama que encendía el
|
||||
> audit nunca corría y el kernel no emitía nada. Sólo se detectó porque el **control**
|
||||
> (`same-exec`, que debía loguear) también dio 0, y eso era imposible.
|
||||
>
|
||||
> Es el modo de falla de harkaq, en vivo, sobre su propio banco de pruebas: un sistema cuyo
|
||||
> producto es la *ausencia* de algo no se rompe ruidosamente — dice que todo está bien. El
|
||||
> experimento ahora aborta con código 4 si no puede **confirmar** `audit_enabled=1`, en vez de
|
||||
> reportar cero. La misma disciplina es la que D9 le impone a harkaq.
|
||||
|
||||
---
|
||||
|
||||
## 4. Arquitectura
|
||||
@@ -316,6 +378,38 @@ Ojo con la semántica documentada — un socket datagram ya conectado antes del
|
||||
enviando; y el scoping no admite reglas: si un dominio está scoped, no hay forma de permitir un
|
||||
recurso puntual fuera. Es todo-o-nada, lo cual para nosotros está bien.
|
||||
|
||||
### D9 — El canario deliberado: `denials=[]` no se cree, se gana
|
||||
|
||||
(Nace de la medición de §3.4. Es la decisión que Q1 obligó a tomar.)
|
||||
|
||||
**El problema.** Un build hermético y un lector ciego producen exactamente los mismos bytes:
|
||||
`denials=[]`. Y §3.4 midió que el kernel **no ofrece ninguna forma de distinguirlos** — un dominio
|
||||
sin logging es invisible, y el registro `allocated` es perezoso, así que su ausencia tampoco
|
||||
prueba nada. Sin resolver esto, D2 (la evidencia negativa) no vale nada: la afirmación más fuerte
|
||||
del sistema sería indistinguible de su falla más común.
|
||||
|
||||
**La decisión.** Cada build provoca una denegación conocida, **después del `execve`**, y harkaq
|
||||
**exige verla**. El canario es un path que existe en el sandbox y que la política deja
|
||||
deliberadamente fuera de la clausura (p.ej. un `--ro-bind` a una ruta fija que el ruleset no
|
||||
concede). El probe se antepone al comando del builder — misma vía que `Sandbox::run` ya usa
|
||||
(`/bin/sh -c`), así que corre en el dominio y del lado correcto del `exec`.
|
||||
|
||||
**El veredicto pasa a ser de tres estados, no de dos:**
|
||||
|
||||
| Canario | Otras denegaciones | Veredicto |
|
||||
|---|---|---|
|
||||
| visto | ∅ | `Hermetico` — y *ahora sí* significa algo |
|
||||
| visto | ≥1 | `Impuro { denials }` — el diagnóstico útil |
|
||||
| **no visto** | cualquiera | **`SinEvidencia`** — el lector no es confiable; no se afirma nada |
|
||||
|
||||
El canario cubre la mala configuración (flag ausente, audit apagado, lector caído). El contador
|
||||
`deallocated denials=N` de §3.4 cubre la otra falla, la pérdida de registros por backlog: se exige
|
||||
`nº de ACCESS == N`. Dos chequeos, dos fallas, ninguno redundante.
|
||||
|
||||
**Por qué es un no-negociable.** Es la misma disciplina de D7 (fallo cerrado) y de D3 (cero
|
||||
quieting), aplicada al único punto donde el sistema podría mentirse a sí mismo en silencio. Y no
|
||||
es hipotético: el banco de pruebas de Q1 ya cayó en esa trampa una vez (§3.4, nota de método).
|
||||
|
||||
---
|
||||
|
||||
## 6. Fases
|
||||
@@ -324,9 +418,15 @@ recurso puntual fuera. Es todo-o-nada, lo cual para nosotros está bien.
|
||||
Landlock ausente-pero-a-un-flag en el kernel de hammer, cero FODs y fetcher ya construido.
|
||||
|
||||
**Fase 1 — El hito demostrable (una tarde).**
|
||||
Encender `SECURITY_LANDLOCK` en `recipes/linux.toml`. Tomar **una** receta real de hammer.
|
||||
Derivar su política de la clausura. Correrla bajo Landlock+seccomp dentro del bwrap actual. Emitir
|
||||
el `Verdict` con `denials = []`.
|
||||
Precondiciones, todas ya medidas en §3 y ninguna especulativa:
|
||||
1. `scripts/config -e SECURITY_LANDLOCK` en `recipes/linux.toml` (+ rebuild, ~35min, cambia el hash).
|
||||
2. `audit=1` horneado en el cmdline del kernel metal — o `AUDIT_SET` desde hammerd (§3.4, Q1c).
|
||||
3. `LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON` en el `restrict_self` (§3.4). **Sin esto no hay nada.**
|
||||
4. El canario de D9 antepuesto al comando del builder.
|
||||
|
||||
Después: tomar **una** receta real de hammer. Derivar su política de la clausura. Correrla bajo
|
||||
Landlock+seccomp dentro del bwrap actual. Emitir el `Verdict` con `denials = []` **y el canario
|
||||
visto**.
|
||||
Luego correr **una receta que sepamos no de-Alpinizada** y mostrar que la jaula nombra exactamente
|
||||
qué usó sin declarar, con path/dev/ino.
|
||||
**Ese par de corridas es el argumento entero del proyecto**, y se enseña en dos minutos.
|
||||
@@ -379,13 +479,20 @@ vibra.
|
||||
|
||||
## 8. Preguntas abiertas
|
||||
|
||||
- **Q1 (Fase 1, la que importa):** ¿cómo llegan los registros `AUDIT_LANDLOCK_*` a `harkaq-audit`?
|
||||
El subsistema de audit del kernel pide `CAP_AUDIT_READ` para leer por netlink, y suele tener un
|
||||
único consumidor (`auditd`) con el que habría que competir o coordinar. Además el build corre
|
||||
bajo `--unshare-all` (userns) y `exec`ea varias veces, lo cual interactúa con los flags de
|
||||
logging de `restrict_self` (`LOG_NEW_EXEC_ON` y compañía). **Esto se prueba antes que nada**: si
|
||||
la evidencia no sale del kernel de forma confiable, no hay proyecto. Es el primer experimento,
|
||||
no el último.
|
||||
- **Q1 — ✅ CERRADA (2026-07-15).** La evidencia llega, con `blockers`/`path`/`dev`/`ino`/`exe`, por
|
||||
el multicast `AUDIT_NLGRP_READLOG`. Precondiciones medidas: `audit_enabled=1` (no viene de
|
||||
fábrica) y `LOG_NEW_EXEC_ON` (sin él, cero registros tras el `exec`). No hay canario gratis ⇒
|
||||
D9. Detalle y mediciones en §3.4. **El gate del proyecto está pasado: harkaq es viable.**
|
||||
- **Q1b (Fase 1, lo que Q1 destapó):** ¿el lector funciona igual con el build **dentro del userns
|
||||
de bwrap**? El audit no está namespaceado, así que `harkaq-audit` lee desde el host (junto a
|
||||
hammerd) y debería ver los denials de adentro — pero hay que medirlo, no suponerlo. Y de paso:
|
||||
¿cómo se atribuye un registro a *su* build cuando la granja corre varios en paralelo? El campo
|
||||
`domain=` es la clave candidata; el `pid=` del `allocated` es el puente, pero §3.4 midió que ese
|
||||
registro es perezoso. **Riesgo concreto:** sin atribución fiable, los builds paralelos se
|
||||
contaminan la evidencia entre sí.
|
||||
- **Q1c:** ¿quién corre `harkaq-audit` y con qué privilegio? Necesita `CAP_AUDIT_READ` (leer) y
|
||||
`CAP_AUDIT_CONTROL` (encender el audit, si no se hornea `audit=1` en el cmdline). En el laptop
|
||||
hizo falta root. ¿hammerd ya lo tiene, o hace falta un helper con capabilities acotadas?
|
||||
- **Q2 (Fase 2):** ¿qué es exactamente el "runtime base" que toda receta necesita y ninguna
|
||||
declara (`/bin/sh`, la libc del rootfs, `/opt/zig`)? ¿Va en la clausura implícitamente, o se
|
||||
declara y se vuelve parte del hash de la receta? *Esta es la decisión de diseño de verdad*, y
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
# harkaq — banco de pruebas
|
||||
|
||||
Ver `docs/16-harkaq-jaula.md`. Acá viven los experimentos que sostienen las afirmaciones del SDD:
|
||||
si el doc dice "medido", el que lo midió está en este directorio.
|
||||
|
||||
## `q1-audit.c` — el gate del proyecto (Q1, ✅ cerrado 2026-07-15)
|
||||
|
||||
Responde: *¿llegan los registros `AUDIT_LANDLOCK_*` a un lector?* Todo harkaq cuelga de eso — su
|
||||
producto es la evidencia, no la jaula.
|
||||
|
||||
```sh
|
||||
gcc -O1 -Wall -o q1-audit q1-audit.c
|
||||
for s in same-exec new-exec new-exec-logon; do sudo ./q1-audit $s; done
|
||||
```
|
||||
|
||||
Necesita root (`CAP_AUDIT_READ` para leer el multicast, `CAP_AUDIT_CONTROL` para encender el
|
||||
audit). **Enciende `audit_enabled=1` globalmente y no lo restaura** — reversible, no persiste al
|
||||
reboot (no toca el cmdline), pero deja `dmesg` más ruidoso mientras tanto.
|
||||
|
||||
### Resultados en el laptop (ABI 10, kernel 7.2.0-rc3)
|
||||
|
||||
| Escenario | Registros `ACCESS` | Qué prueba |
|
||||
|---|---|---|
|
||||
| `same-exec` | 2 | el kernel loguea por defecto sin `execve` |
|
||||
| `new-exec` | **0** | **flags por defecto ⇒ ciego tras `execve`** — el caso real de harkaq |
|
||||
| `new-exec-logon` | 4 | `LOG_NEW_EXEC_ON` lo arregla |
|
||||
|
||||
Los registros traen `blockers=fs.read_file path="/etc/passwd" dev="nvme1n1p6" ino=4458369` y el
|
||||
`exe=` que lo intentó. Análisis completo en `docs/16-harkaq-jaula.md` §3.4.
|
||||
|
||||
### Por qué aborta con código 4
|
||||
|
||||
Si no puede **confirmar** `audit_enabled=1`, aborta en vez de reportar 0 registros. No es
|
||||
paranoia: la primera corrida dio 0 en los tres escenarios y parecía confirmar la hipótesis. Era un
|
||||
bug del instrumento (`AUDIT_GET` con `NLM_F_ACK` → el ACK llegaba antes que la respuesta → nunca
|
||||
se encendía el audit). Se detectó sólo porque el **control** (`same-exec`) también dio 0, y eso era
|
||||
imposible.
|
||||
|
||||
Es el modo de falla de harkaq sobre su propio banco de pruebas: un sistema cuyo producto es la
|
||||
*ausencia* de algo no falla ruidosamente — dice que todo está bien. De ahí sale D9 (el canario
|
||||
deliberado), y de ahí sale la regla de este directorio: **todo experimento lleva un control que
|
||||
debe dar positivo.** Un experimento sin control no mide, tranquiliza.
|
||||
@@ -0,0 +1,248 @@
|
||||
// Q1 de harkaq (SDD 16 §8): ¿llegan los registros AUDIT_LANDLOCK_ACCESS a un lector?
|
||||
//
|
||||
// Prueba las tres cosas de las que cuelga el proyecto:
|
||||
// 1. ¿El audit del kernel emite el registro? (audit_enabled, kauditd)
|
||||
// 2. ¿Un lector multicast (AUDIT_NLGRP_READLOG) los recibe? (CAP_AUDIT_READ)
|
||||
// 3. ¿SOBREVIVEN AL execve? — harkaq restringe y DESPUÉS ejecuta el builder.
|
||||
// El default del kernel NO loguea tras exec (linux/landlock.h:80-83).
|
||||
// Sin LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON, harkaq vería denials=[] SIEMPRE.
|
||||
//
|
||||
// Uso (como root): ./q1-audit same-exec | new-exec | new-exec-logon
|
||||
//
|
||||
// El "víctima" se autoencierra con una política que sólo permite leer /tmp, y
|
||||
// después intenta leer /etc/passwd (fuera de la clausura) → EACCES → debe generar
|
||||
// un AUDIT_LANDLOCK_ACCESS. El padre escucha el netlink y lo imprime.
|
||||
|
||||
#define _GNU_SOURCE
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <linux/audit.h>
|
||||
#include <linux/landlock.h>
|
||||
#include <linux/netlink.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/prctl.h>
|
||||
#include <sys/socket.h>
|
||||
#include <sys/syscall.h>
|
||||
#include <sys/wait.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
static int ll_create(const struct landlock_ruleset_attr *a, size_t n, __u32 f) {
|
||||
return syscall(SYS_landlock_create_ruleset, a, n, f);
|
||||
}
|
||||
static int ll_add(int fd, enum landlock_rule_type t, const void *a, __u32 f) {
|
||||
return syscall(SYS_landlock_add_rule, fd, t, a, f);
|
||||
}
|
||||
static int ll_restrict(int fd, __u32 f) {
|
||||
return syscall(SYS_landlock_restrict_self, fd, f);
|
||||
}
|
||||
|
||||
#define ACCESS_FS_ROUGHLY_READ \
|
||||
(LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_READ_DIR | \
|
||||
LANDLOCK_ACCESS_FS_EXECUTE)
|
||||
|
||||
// ---------------------------------------------------------------- netlink audit
|
||||
|
||||
static int nl_open(void) {
|
||||
int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_AUDIT);
|
||||
if (fd < 0) { perror("socket(NETLINK_AUDIT)"); return -1; }
|
||||
struct sockaddr_nl sa = {0};
|
||||
sa.nl_family = AF_NETLINK;
|
||||
sa.nl_pid = 0;
|
||||
// Grupo multicast de sólo-lectura: exactamente para lectores como harkaq-audit.
|
||||
sa.nl_groups = 1 << (AUDIT_NLGRP_READLOG - 1);
|
||||
if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
|
||||
perror("bind(AUDIT_NLGRP_READLOG) <-- ¿falta CAP_AUDIT_READ?");
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
// Manda un AUDIT_GET/AUDIT_SET. `payload` NULL ⇒ GET.
|
||||
static int nl_send(int fd, int type, const void *payload, size_t len) {
|
||||
struct {
|
||||
struct nlmsghdr h;
|
||||
char data[256];
|
||||
} req = {0};
|
||||
req.h.nlmsg_len = NLMSG_LENGTH(len);
|
||||
req.h.nlmsg_type = type;
|
||||
// SIN NLM_F_ACK: la respuesta de AUDIT_GET la manda el kernel de forma ASÍNCRONA
|
||||
// (audit_send_reply usa un kthread), así que el ACK llegaba ANTES que el AUDIT_GET
|
||||
// y el lector lo tomaba por "fallo". Pedir sólo REQUEST y filtrar por tipo al leer.
|
||||
req.h.nlmsg_flags = NLM_F_REQUEST;
|
||||
req.h.nlmsg_seq = 1;
|
||||
req.h.nlmsg_pid = getpid();
|
||||
if (payload) memcpy(req.data, payload, len);
|
||||
struct sockaddr_nl sa = {0};
|
||||
sa.nl_family = AF_NETLINK;
|
||||
return sendto(fd, &req, req.h.nlmsg_len, 0, (struct sockaddr *)&sa, sizeof(sa));
|
||||
}
|
||||
|
||||
// Lee el estado del audit por un socket dedicado (unicast). Devuelve enabled o -1.
|
||||
static int audit_status(int *enabled, int *pid) {
|
||||
int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_AUDIT);
|
||||
if (fd < 0) return -1;
|
||||
if (nl_send(fd, AUDIT_GET, NULL, 0) < 0) { close(fd); return -1; }
|
||||
struct timeval tv = {.tv_sec = 1};
|
||||
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
|
||||
// Drenamos hasta encontrar el AUDIT_GET: puede venir detrás de otros mensajes.
|
||||
char buf[8192];
|
||||
for (int i = 0; i < 8; i++) {
|
||||
ssize_t n = recv(fd, buf, sizeof(buf), 0);
|
||||
if (n <= 0) break;
|
||||
for (struct nlmsghdr *h = (struct nlmsghdr *)buf; NLMSG_OK(h, n);
|
||||
h = NLMSG_NEXT(h, n)) {
|
||||
if (h->nlmsg_type == AUDIT_GET) {
|
||||
struct audit_status *st = (struct audit_status *)NLMSG_DATA(h);
|
||||
*enabled = st->enabled;
|
||||
*pid = st->pid;
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
if (h->nlmsg_type == NLMSG_ERROR) {
|
||||
struct nlmsgerr *e = (struct nlmsgerr *)NLMSG_DATA(h);
|
||||
if (e->error)
|
||||
fprintf(stderr, "[q1] AUDIT_GET rechazado: %s\n", strerror(-e->error));
|
||||
}
|
||||
}
|
||||
}
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int audit_enable(void) {
|
||||
int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_AUDIT);
|
||||
if (fd < 0) return -1;
|
||||
struct audit_status st = {0};
|
||||
st.mask = AUDIT_STATUS_ENABLED;
|
||||
st.enabled = 1;
|
||||
int r = nl_send(fd, AUDIT_SET, &st, sizeof(st));
|
||||
close(fd);
|
||||
return r < 0 ? -1 : 0;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------- la víctima
|
||||
|
||||
// Se autoencierra: sólo /tmp legible. Todo lo demás → EACCES + registro de audit.
|
||||
static void jail(__u32 restrict_flags) {
|
||||
struct landlock_ruleset_attr attr = {.handled_access_fs = ACCESS_FS_ROUGHLY_READ};
|
||||
int rs = ll_create(&attr, sizeof(attr), 0);
|
||||
if (rs < 0) { perror("landlock_create_ruleset"); exit(2); }
|
||||
|
||||
// La "clausura declarada": /tmp y el intérprete. Nada más.
|
||||
const char *allowed[] = {"/tmp", "/usr/lib", "/lib", "/bin", "/usr/bin", NULL};
|
||||
for (int i = 0; allowed[i]; i++) {
|
||||
int dfd = open(allowed[i], O_PATH | O_CLOEXEC);
|
||||
if (dfd < 0) continue;
|
||||
struct landlock_path_beneath_attr pb = {.allowed_access = ACCESS_FS_ROUGHLY_READ,
|
||||
.parent_fd = dfd};
|
||||
if (ll_add(rs, LANDLOCK_RULE_PATH_BENEATH, &pb, 0) < 0) perror("add_rule");
|
||||
close(dfd);
|
||||
}
|
||||
if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) { perror("no_new_privs"); exit(2); }
|
||||
if (ll_restrict(rs, restrict_flags) < 0) { perror("landlock_restrict_self"); exit(2); }
|
||||
close(rs);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
const char *scenario = argc > 1 ? argv[1] : "new-exec";
|
||||
|
||||
int enabled = -1, apid = -1;
|
||||
if (audit_status(&enabled, &apid) == 0)
|
||||
fprintf(stderr, "[q1] audit: enabled=%d auditd_pid=%d\n", enabled, apid);
|
||||
else
|
||||
fprintf(stderr, "[q1] audit: no pude leer el estado (¿sin CAP_AUDIT_CONTROL?)\n");
|
||||
|
||||
// `!= 1` y no `== 0`: si el GET falló (enabled=-1) igual hay que intentar encenderlo.
|
||||
// El bug de la primera corrida fue justo este: GET falló → enabled=-1 → no entró acá →
|
||||
// audit_enabled siguió en 0 → CERO registros en los 3 escenarios → un "hallazgo" que
|
||||
// era el instrumento roto.
|
||||
if (enabled != 1) {
|
||||
fprintf(stderr, "[q1] audit no habilitado (enabled=%d) → AUDIT_SET\n", enabled);
|
||||
if (audit_enable() < 0) perror("[q1] AUDIT_SET");
|
||||
usleep(100000);
|
||||
if (audit_status(&enabled, &apid) == 0)
|
||||
fprintf(stderr, "[q1] audit: enabled=%d (tras AUDIT_SET)\n", enabled);
|
||||
}
|
||||
// GATE: sin audit_enabled=1 el kernel no emite NADA y el test no mide lo que cree medir.
|
||||
// Abortar es obligatorio: un 0 acá significaría "instrumento roto", no "sin denegaciones".
|
||||
if (enabled != 1) {
|
||||
fprintf(stderr,
|
||||
"[q1] ABORTO: no pude confirmar audit_enabled=1. Cualquier resultado sería\n"
|
||||
" un falso negativo del test, no una medición. (¿root? ¿audit=1?)\n");
|
||||
return 4;
|
||||
}
|
||||
|
||||
// Sin CAP_AUDIT_READ no hay lector, pero la víctima corre igual: así una corrida
|
||||
// sin privilegio valida al menos que la JAULA deniega (la mitad barata del test).
|
||||
int nl = nl_open();
|
||||
if (nl < 0)
|
||||
fprintf(stderr, "[q1] sin lector (correr como root para la prueba completa)\n");
|
||||
else
|
||||
fprintf(stderr, "[q1] lector multicast OK. escenario=%s\n", scenario);
|
||||
|
||||
__u32 flags = 0;
|
||||
if (!strcmp(scenario, "new-exec-logon")) flags = LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON;
|
||||
|
||||
pid_t pid = fork();
|
||||
if (pid == 0) {
|
||||
usleep(200000); // dejamos que el padre esté escuchando
|
||||
jail(flags);
|
||||
if (!strcmp(scenario, "same-exec")) {
|
||||
// Denegación SIN execve: el default del kernel SÍ la loguea.
|
||||
int fd = open("/etc/passwd", O_RDONLY);
|
||||
fprintf(stderr, "[victima] open(/etc/passwd) = %d (%s)\n", fd, strerror(errno));
|
||||
} else {
|
||||
// Denegación TRAS execve: el caso REAL de harkaq (bwrap → sh -c → make).
|
||||
fprintf(stderr, "[victima] execve(/bin/cat /etc/passwd)\n");
|
||||
execl("/bin/cat", "cat", "/etc/passwd", (char *)NULL);
|
||||
perror("execl");
|
||||
}
|
||||
_exit(0);
|
||||
}
|
||||
|
||||
// El pid del hijo permite atribuir los registros DOMAIN (traen pid=) a NUESTRO dominio y
|
||||
// no al de una corrida anterior que se libera tarde — el error que casi me como.
|
||||
fprintf(stderr, "[q1] hijo pid=%d (atribuir los DOMAIN por este pid)\n", pid);
|
||||
char buf[16384];
|
||||
int landlock_records = 0, total = 0;
|
||||
if (nl < 0) {
|
||||
waitpid(pid, NULL, 0);
|
||||
fprintf(stderr, "\n[q1] jaula validada; evidencia NO probada (hace falta root).\n");
|
||||
return 3;
|
||||
}
|
||||
// Deadline de pared, NO "cortar al primer timeout": el registro `status=deallocated
|
||||
// denials=N` se emite cuando el dominio se libera, DESPUÉS de que el hijo muere, y con
|
||||
// retraso (RCU/workqueue). Con la ventana de 2s se perdía y aparecía en la corrida
|
||||
// siguiente, haciéndolo pasar por el dominio equivocado. Escuchamos 6s pasado el exit.
|
||||
struct timeval tv = {.tv_sec = 1};
|
||||
setsockopt(nl, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
|
||||
time_t deadline = time(NULL) + 6;
|
||||
while (time(NULL) < deadline) {
|
||||
ssize_t n = recv(nl, buf, sizeof(buf), 0);
|
||||
if (n <= 0) continue; // timeout de 1s: seguimos hasta el deadline
|
||||
for (struct nlmsghdr *h = (struct nlmsghdr *)buf; NLMSG_OK(h, n);
|
||||
h = NLMSG_NEXT(h, n)) {
|
||||
total++;
|
||||
if (h->nlmsg_type == AUDIT_LANDLOCK_ACCESS ||
|
||||
h->nlmsg_type == AUDIT_LANDLOCK_DOMAIN) {
|
||||
landlock_records++;
|
||||
printf("[REGISTRO %s] %.*s\n",
|
||||
h->nlmsg_type == AUDIT_LANDLOCK_ACCESS ? "ACCESS" : "DOMAIN",
|
||||
(int)(NLMSG_PAYLOAD(h, 0)), (char *)NLMSG_DATA(h));
|
||||
}
|
||||
}
|
||||
}
|
||||
waitpid(pid, NULL, 0);
|
||||
|
||||
fprintf(stderr, "\n[q1] VEREDICTO escenario=%s: %d registros landlock (%d msgs audit total)\n",
|
||||
scenario, landlock_records, total);
|
||||
if (landlock_records == 0)
|
||||
fprintf(stderr, "[q1] ⇒ SIN EVIDENCIA. harkaq reportaría denials=[] (falso 'hermético').\n");
|
||||
else
|
||||
fprintf(stderr, "[q1] ⇒ EVIDENCIA ENTREGADA. Q1 viable por esta vía.\n");
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user