sergio/takana

1// Q1b de harkaq (SDD 16 §8): ¿el lector del host ve las denegaciones de ADENTRO de bwrap,
2// y se puede atribuir cada registro a SU build con la granja corriendo en paralelo?
3//
4// Q1 probó que la evidencia llega, pero con la víctima corriendo en el host. El caso real es
5// otro: `Sandbox::run` lanza bwrap con --unshare-all (user/pid/mount/net/ipc/uts ns) y el
6// lector (harkaq-audit) vive AFUERA, junto a hammerd. Dos preguntas:
7//
8//   (a) ¿Cruzan los registros el userns/pidns? El audit no está namespaceado, así que
9//       DEBERÍA — pero medirlo es el punto.
10//   (b) ATRIBUCIÓN: con N builds en paralelo hay N dominios. ¿Cuál es de quién?
11//       Hipótesis: el canario de D9 lo resuelve gratis. Si cada build usa un canario con
12//       nonce ÚNICO, el primer registro logueado trae path="/harkaq-canary-<nonce>" ⇒
13//       identifica el build sin depender del pid (que el pidns reescribe) ⇒ y de paso
14//       revela su domain=, que ata todos los registros siguientes de ese build.
15//
16// Uso (como root):  ./q1b-attrib            → lanza 2 víctimas concurrentes y atribuye
17//                   ./q1b-attrib victim <canario>   (uso interno, dentro de bwrap)
18
19#define _GNU_SOURCE
20#include <errno.h>
21#include <fcntl.h>
22#include <linux/audit.h>
23#include <linux/landlock.h>
24#include <linux/netlink.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28#include <grp.h>
29#include <sys/prctl.h>
30#include <sys/socket.h>
31#include <sys/syscall.h>
32#include <sys/wait.h>
33#include <time.h>
34#include <unistd.h>
35
36static int ll_create(const struct landlock_ruleset_attr *a, size_t n, __u32 f) {
37    return syscall(SYS_landlock_create_ruleset, a, n, f);
38}
39static int ll_add(int fd, enum landlock_rule_type t, const void *a, __u32 f) {
40    return syscall(SYS_landlock_add_rule, fd, t, a, f);
41}
42static int ll_restrict(int fd, __u32 f) {
43    return syscall(SYS_landlock_restrict_self, fd, f);
44}
45
46#define ACCESS_READ                                               \
47    (LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_READ_DIR | \
48     LANDLOCK_ACCESS_FS_EXECUTE)
49
50// ------------------------------------------------------------------ víctima (dentro de bwrap)
51
52// Política: todo lo que sh/cat necesitan, y NADA más. El canario queda deliberadamente fuera
53// ⇒ exactamente UNA denegación esperada, con un path que identifica a este build.
54static int victim(const char *canary) {
55    struct landlock_ruleset_attr attr = {.handled_access_fs = ACCESS_READ};
56    int rs = ll_create(&attr, sizeof(attr), 0);
57    if (rs < 0) { perror("[victima] create_ruleset"); return 2; }
58    // /tmp NO va en la clausura: es donde vive el canario (único punto de montaje escribible
59    // bajo `--ro-bind / /`, ver README). Todo lo demás es lo que sh/cat necesitan para correr.
60    const char *allowed[] = {"/usr", "/lib", "/lib64", "/bin", "/etc", "/proc", NULL};
61    for (int i = 0; allowed[i]; i++) {
62        int dfd = open(allowed[i], O_PATH | O_CLOEXEC);
63        if (dfd < 0) continue;
64        struct landlock_path_beneath_attr pb = {.allowed_access = ACCESS_READ, .parent_fd = dfd};
65        ll_add(rs, LANDLOCK_RULE_PATH_BENEATH, &pb, 0);
66        close(dfd);
67    }
68    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)) { perror("[victima] nnp"); return 2; }
69    // LOG_NEW_EXEC_ON: sin esto no se loguea nada tras el execve (Q1/§3.4). Obligatorio.
70    if (ll_restrict(rs, LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON) < 0) {
71        perror("[victima] restrict_self");
72        return 2;
73    }
74    close(rs);
75    // Post-exec, como el builder real (bwrap → sh -c → make).
76    // Sin redirects: `>/dev/null` necesita /dev, que NO está en la clausura ⇒ sh fallaba en la
77    // redirección y `cat` no llegaba a correr nunca. El rc=1 venía del redirect, no del canario:
78    // el test habría medido la denegación equivocada y "pasado" igual. Mantener el comando
79    // mínimo, y que el único acceso fuera de la clausura sea EL CANARIO.
80    char cmd[512];
81    snprintf(cmd, sizeof(cmd), "cat %s; echo \"[victima] canario=%s cat rc=$?\" >&2", canary,
82             canary);
83    execl("/bin/sh", "sh", "-c", cmd, (char *)NULL);
84    perror("[victima] execl");
85    return 2;
86}
87
88// ------------------------------------------------------------------ netlink
89
90static int nl_send(int fd, int type, const void *payload, size_t len) {
91    struct { struct nlmsghdr h; char data[256]; } req = {0};
92    req.h.nlmsg_len = NLMSG_LENGTH(len);
93    req.h.nlmsg_type = type;
94    req.h.nlmsg_flags = NLM_F_REQUEST;
95    req.h.nlmsg_seq = 1;
96    req.h.nlmsg_pid = getpid();
97    if (payload) memcpy(req.data, payload, len);
98    struct sockaddr_nl sa = {.nl_family = AF_NETLINK};
99    return sendto(fd, &req, req.h.nlmsg_len, 0, (struct sockaddr *)&sa, sizeof(sa));
100}
101
102static int audit_status(int *enabled) {
103    int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_AUDIT);
104    if (fd < 0) return -1;
105    if (nl_send(fd, AUDIT_GET, NULL, 0) < 0) { close(fd); return -1; }
106    struct timeval tv = {.tv_sec = 1};
107    setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
108    char buf[8192];
109    for (int i = 0; i < 8; i++) {
110        ssize_t n = recv(fd, buf, sizeof(buf), 0);
111        if (n <= 0) break;
112        for (struct nlmsghdr *h = (struct nlmsghdr *)buf; NLMSG_OK(h, n); h = NLMSG_NEXT(h, n))
113            if (h->nlmsg_type == AUDIT_GET) {
114                *enabled = ((struct audit_status *)NLMSG_DATA(h))->enabled;
115                close(fd);
116                return 0;
117            }
118    }
119    close(fd);
120    return -1;
121}
122
123static int audit_enable(void) {
124    int fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_AUDIT);
125    if (fd < 0) return -1;
126    struct audit_status st = {.mask = AUDIT_STATUS_ENABLED, .enabled = 1};
127    int r = nl_send(fd, AUDIT_SET, &st, sizeof(st));
128    close(fd);
129    return r < 0 ? -1 : 0;
130}
131
132// ------------------------------------------------------------------ driver
133
134// Baja a un uid sin privilegio antes de lanzar bwrap. Dos razones:
135//  1. Corrección: bwrap con --unshare-all mapea SÓLO uid 0→0. Los ficheros de otro uid quedan
136//     sin mapear (aparecen como `nobody`) y CAP_DAC_OVERRIDE dentro de un userns sólo vale
137//     sobre uids MAPEADOS ⇒ root-en-userns no puede atravesar un home drwx------ y el exec
138//     del binario falla con EACCES. Costó una corrida entera diagnosticarlo.
139//  2. Fidelidad: modela el despliegue real — harkaq-audit privilegiado (CAP_AUDIT_READ),
140//     los builds sin privilegio. Si la evidencia cruzara sólo con builds root, no serviría.
141static void drop_privs(void) {
142    const char *su = getenv("SUDO_UID"), *sg = getenv("SUDO_GID");
143    if (!su) return;  // no venimos de sudo: nada que bajar
144    uid_t uid = (uid_t)atoi(su);
145    gid_t gid = sg ? (gid_t)atoi(sg) : uid;
146    if (setgroups(0, NULL) < 0) perror("[q1b] setgroups");
147    if (setgid(gid) < 0) { perror("[q1b] setgid"); _exit(2); }
148    if (setuid(uid) < 0) { perror("[q1b] setuid"); _exit(2); }
149}
150
151static void spawn_victim(const char *self, const char *canary_src, const char *canary_path) {
152    // bwrap con los mismos ns que Sandbox::bwrap_args (--unshare-all). El canario se bindea
153    // en una ruta fija que la política de landlock NO concede.
154    execlp("bwrap", "bwrap", "--unshare-all", "--ro-bind", "/", "/", "--tmpfs", "/tmp",
155           "--ro-bind", canary_src, canary_path, "--die-with-parent", self, "victim",
156           canary_path, (char *)NULL);
157    perror("execlp bwrap");
158    _exit(2);
159}
160
161int main(int argc, char **argv) {
162    if (argc >= 3 && !strcmp(argv[1], "victim")) return victim(argv[2]);
163
164    char self[4096];
165    ssize_t sl = readlink("/proc/self/exe", self, sizeof(self) - 1);
166    if (sl < 0) { perror("readlink"); return 1; }
167    self[sl] = 0;
168
169    int enabled = -1;
170    audit_status(&enabled);
171    if (enabled != 1) {
172        fprintf(stderr, "[q1b] audit enabled=%d → AUDIT_SET\n", enabled);
173        audit_enable();
174        usleep(100000);
175        audit_status(&enabled);
176    }
177    // Mismo gate que q1-audit: sin audit_enabled=1 un 0 no significa "sin denegaciones",
178    // significa "el instrumento no mide". Abortar, nunca reportar.
179    if (enabled != 1) {
180        fprintf(stderr, "[q1b] ABORTO: no pude confirmar audit_enabled=1 (¿root?)\n");
181        return 4;
182    }
183
184    int nl = socket(AF_NETLINK, SOCK_RAW, NETLINK_AUDIT);
185    struct sockaddr_nl sa = {.nl_family = AF_NETLINK,
186                             .nl_groups = 1 << (AUDIT_NLGRP_READLOG - 1)};
187    if (nl < 0 || bind(nl, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
188        perror("[q1b] bind multicast (¿CAP_AUDIT_READ?)");
189        return 1;
190    }
191    fprintf(stderr, "[q1b] lector del HOST escuchando; audit enabled=%d\n", enabled);
192
193    // DOS builds concurrentes, canarios con nonce distinto. Si la atribución por canario
194    // funciona, cada registro cae inequívocamente en su build sin mirar el pid.
195    const char *canaries[] = {"/tmp/harkaq-canary-AAAA", "/tmp/harkaq-canary-BBBB"};
196    pid_t kids[2];
197    for (int i = 0; i < 2; i++) {
198        if ((kids[i] = fork()) == 0) {
199            usleep(300000);
200            drop_privs();
201            spawn_victim(self, "/etc/hostname", canaries[i]);
202        }
203        fprintf(stderr, "[q1b] build %d: bwrap pid=%d canario=%s\n", i, kids[i], canaries[i]);
204    }
205
206    struct timeval tv = {.tv_sec = 1};
207    setsockopt(nl, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
208    char buf[16384];
209    int seen[2] = {0, 0}, other = 0, total = 0;
210    time_t deadline = time(NULL) + 8;
211    while (time(NULL) < deadline) {
212        ssize_t n = recv(nl, buf, sizeof(buf), 0);
213        if (n <= 0) continue;
214        for (struct nlmsghdr *h = (struct nlmsghdr *)buf; NLMSG_OK(h, n); h = NLMSG_NEXT(h, n)) {
215            if (h->nlmsg_type != AUDIT_LANDLOCK_ACCESS && h->nlmsg_type != AUDIT_LANDLOCK_DOMAIN)
216                continue;
217            total++;
218            const char *rec = (const char *)NLMSG_DATA(h);
219            printf("[%s] %.*s\n",
220                   h->nlmsg_type == AUDIT_LANDLOCK_ACCESS ? "ACCESS" : "DOMAIN",
221                   (int)NLMSG_PAYLOAD(h, 0), rec);
222            int matched = 0;
223            for (int i = 0; i < 2; i++)
224                if (strstr(rec, canaries[i])) { seen[i]++; matched = 1; }
225            if (!matched && h->nlmsg_type == AUDIT_LANDLOCK_ACCESS) other++;
226        }
227    }
228    // GATE DEL INSTRUMENTO: si la víctima no corrió, "0 registros" no significa "nada cruzó",
229    // significa "no medí nada". La corrida anterior imprimió "NADA cruzó ⇒ replantear la
230    // arquitectura" cuando bwrap ni siquiera había podido ejecutar el binario (EACCES). Un
231    // veredicto que no verifica su propio estímulo es exactamente el falso 'hermético' de D9,
232    // pero del lado del banco de pruebas. Tercera vez en esta sesión: por eso es un gate.
233    int bad = 0;
234    for (int i = 0; i < 2; i++) {
235        int st = 0;
236        waitpid(kids[i], &st, 0);
237        if (!WIFEXITED(st) || WEXITSTATUS(st) != 0) {
238            fprintf(stderr, "[q1b] build %d NO corrió limpio (status=%d)\n", i, st);
239            bad = 1;
240        }
241    }
242    if (bad) {
243        fprintf(stderr,
244                "\n[q1b] ABORTO: alguna víctima no llegó a ejecutarse ⇒ el estímulo no existió.\n"
245                "      Cualquier conteo de registros sería del instrumento, no del kernel.\n");
246        return 4;
247    }
248
249    fprintf(stderr, "\n[q1b] ── VEREDICTO ──\n");
250    fprintf(stderr, "[q1b] (a) ¿cruzan el userns de bwrap?  %s (%d registros landlock)\n",
251            total > 0 ? "SÍ" : "NO", total);
252    fprintf(stderr, "[q1b] (b) atribución por canario: AAAA=%d  BBBB=%d  (otros ACCESS=%d)\n",
253            seen[0], seen[1], other);
254    if (seen[0] >= 1 && seen[1] >= 1)
255        fprintf(stderr, "[q1b] ⇒ el canario con nonce ATRIBUYE: 2 builds paralelos, sin ambigüedad.\n");
256    else if (total == 0)
257        fprintf(stderr, "[q1b] ⇒ NADA cruzó. harkaq-audit no puede vivir en el host: replantear.\n");
258    else
259        fprintf(stderr, "[q1b] ⇒ registros SÍ, atribución NO. Hace falta otra clave (¿domain=?).\n");
260    return 0;
261}