sergio/takana
> Una distribución Linux construida con un laboratorio funcional y hermético en el > sótano, y una terminal mutable, clásica y anárquica en el piso de arriba — diseñada > desde el suelo para que una IA programadora entienda, modifique y co…
fix(qorpa): el EBUSY del overlay preguntaba por otra `run` y el culpable era un nieto fugado
1//! `takana qorpa` — imágenes ajenas ([ADR 0015](../../../docs/adr/0015-imagenes-ajenas.md)).
2//!
3//! Superficie en inglés, mensajes en castellano (`CLAUDE.md` regla 4).
4//!
5//! ── LA INVARIANTE QUE ESTE MÓDULO PROTEGE ───────────────────────────────────────────────────────
6//! Una imagen ajena **no es un artefacto y no vive en el store** (ADR 0015 D1). El store promete que
7//! cada entrada se reconstruye desde fuente bit a bit, y un rootfs de Ubuntu no. Por eso todo lo de
8//! acá cuelga de un espacio de nombres paralelo (`/var/lib/hammer/qorpa/`), fuera de `hash_inputs`
9//! de todo, y nada de este fichero toca `Store`.
10//!
11//! ── EL ORDEN DE LAS OPERACIONES NO ES CASUAL ────────────────────────────────────────────────────
12//! Se verifica el sha256 **antes** de desempacar, nunca después. Un tar ajeno que no verificaste es
13//! código ajeno que ya escribió en tu disco: desempacar primero y comprobar luego deja el árbol
14//! sucio justo en el caso que importa. Y el veredicto sigue a ADR 0014: *ausencia ⇒ seguir;
15//! contenido distinto ⇒ ABORTAR*.
16
17use std::io::Read;
18use std::os::unix::fs::PermissionsExt;
19use std::path::{Path, PathBuf};
20use std::process::Command;
21
22use anyhow::{bail, Context, Result};
23use clap::Subcommand;
24use serde::{Deserialize, Serialize};
25
26/// Raíz del espacio de nombres de qorpa. Deliberadamente **fuera** del store.
27pub const DEFAULT_ROOT: &str = "/var/lib/hammer/qorpa";
28/// Para correr sin root (tests, laptop). Mismo patrón que `TAKANA_KCONFIG_ROOT`.
29pub const ROOT_ENV: &str = "TAKANA_QORPA_ROOT";
30/// El manifiesto de la imagen. No confundir con `instancia.toml`, que describe una INSTANCIA.
31const IMAGE_MANIFEST: &str = "image.toml";
32/// El árbol desempacado dentro del directorio de la imagen.
33const TREE: &str = "rootfs";
34/// El manifiesto de una INSTANCIA: la verdad de la que se recrea (D3).
35const INSTANCE_MANIFEST: &str = "instance.toml";
36
37#[derive(Subcommand)]
38pub enum QorpaCmd {
39 /// [ADR 0015 §Orden 2] Trae una imagen ajena y la verifica por sha256 ANTES de desempacarla.
40 ///
41 /// La identidad de la imagen es el sha256 del ARCHIVO original, no del árbol: así dos máquinas
42 /// que la traigan de orígenes distintos coinciden, que es lo que hace gratis el espejo
43 /// (ADR 0013: la URL no entra en la identidad) y posible el multi-origen (ADR 0014).
44 Pull {
45 /// De dónde bajarla. Cualquier esquema que entienda curl, `file://` incluido.
46 url: String,
47 /// sha256 esperado del archivo, en hex. Obligatorio: sin esto no hay identidad.
48 #[arg(long)]
49 sha256: String,
50 /// Etiqueta legible (`arch-bootstrap-2026.09.01`). Informativa; no entra en la identidad.
51 #[arg(long)]
52 label: Option<String>,
53 /// Baja y verifica, pero NO desempaca. Para poblar un espejo sin gastar el disco del árbol.
54 #[arg(long)]
55 verify_only: bool,
56 /// Dónde está el rootfs DENTRO del archivo, si la detección automática no acierta.
57 #[arg(long)]
58 subdir: Option<String>,
59 /// Raíz de qorpa (default: `$TAKANA_QORPA_ROOT` o `/var/lib/hammer/qorpa`).
60 #[arg(long)]
61 root: Option<PathBuf>,
62 },
63 /// Lista las imágenes presentes. Marca a gritos las que están VACÍAS (`CLAUDE.md` regla 3):
64 /// un directorio vacío no es una imagen, es un nombre.
65 List {
66 #[arg(long)]
67 root: Option<PathBuf>,
68 /// Salida JSON, para que un script no tenga que parsear la tabla.
69 #[arg(long)]
70 json: bool,
71 },
72 /// [ADR 0015 §Orden 3] Crea una instancia: capa mutable sobre una imagen + su manifiesto.
73 ///
74 /// Nace SIN NINGUNA concesión (D7): ni red, ni sockets, ni dispositivos, ni directorios del
75 /// host. Se abre lo que se declare en `instance.toml`, y sólo eso.
76 Create {
77 /// Identificador de la instancia (`games`).
78 id: String,
79 /// sha256 de la imagen base, ya traída con `pull`. Acepta prefijos.
80 #[arg(long)]
81 base: String,
82 /// Nombre informativo de la distro (`arch`, `ubuntu-24.04`).
83 #[arg(long)]
84 distro: Option<String>,
85 #[arg(long)]
86 root: Option<PathBuf>,
87 },
88 /// [ADR 0015 §Orden 3] Tira la capa mutable y la rehace desde el manifiesto.
89 ///
90 /// Es la prueba de D3: si esto duele, es que el `upper` se volvió el activo — y un blob
91 /// irreemplazable es justo lo que takana existe para no tener.
92 Recreate {
93 id: String,
94 /// No reinstalar `packages` después de tirar la capa. Deja la instancia como recién creada.
95 #[arg(long)]
96 no_provision: bool,
97 #[arg(long)]
98 root: Option<PathBuf>,
99 },
100 /// [ADR 0015 §Orden 3] Entra a la instancia con las concesiones declaradas y nada más.
101 Run {
102 id: String,
103 #[arg(long)]
104 root: Option<PathBuf>,
105 /// Imprime el `bwrap` que se ejecutaría y sale. La jaula tiene que ser inspeccionable.
106 #[arg(long)]
107 dry_run: bool,
108 /// Corre SIN harkaq (sin Landlock, sin seccomp, sin no_new_privs). Para diagnosticar
109 /// cuando algo muere y hay que saber si fue la jaula. Avisa a gritos.
110 #[arg(long)]
111 no_jail: bool,
112 /// Fuerza el userns de un solo id que crea bwrap, en vez del rango de `/etc/subuid`.
113 /// Para comparar: casi todo lo que "no anda adentro" es este mapeo.
114 #[arg(long)]
115 single_id: bool,
116 /// Abre el canal de evidencia: apunta qué intentó tocar la instancia y no pudo.
117 ///
118 /// **Es la única forma de auditar el montón B.** De un binario ajeno no hay fuente que
119 /// leer: lo único que queda es lo que el kernel deniega y anota. Exige una política que
120 /// pueda denegar algo (`seal_image`) y Landlock vivo (o sea, sin `nesting`); si falta
121 /// alguna, FALLA diciendo cuál — un `denials=[]` sin evidencia posible sería el
122 /// instrumento mintiendo.
123 #[arg(long)]
124 evidence: bool,
125 /// Comando dentro (default: el shell de la imagen). Va después de `--`.
126 #[arg(last = true)]
127 cmd: Vec<String>,
128 },
129 /// [ADR 0015 D3] Instala en la instancia lo declarado en `packages`.
130 ///
131 /// **Es lo que vuelve cierta la frase «el manifiesto es la verdad».** Sin esto `packages` era
132 /// una lista que nadie leía: `recreate` tiraba la capa y lo instalado a mano no volvía, así que
133 /// el `upper` era el activo de verdad — exactamente el blob irreemplazable que takana existe
134 /// para no tener.
135 Provision {
136 id: String,
137 /// Reinstala aunque el registro diga que esos mismos paquetes ya se instalaron.
138 #[arg(long)]
139 force: bool,
140 /// Imprime el guión que correría dentro de la instancia y sale.
141 #[arg(long)]
142 dry_run: bool,
143 #[arg(long)]
144 root: Option<PathBuf>,
145 },
146 /// [ADR 0015 D8] Registra como imagen un artefacto del store que trae una imagen ajena SELLADA.
147 ///
148 /// Es el consumidor de `recipes/steam-runtime-sniper.toml`: la imagen deja de venir de la CDN
149 /// de Valve y viene de nuestro store, replicable con `takana mirror push` y cubrible por el
150 /// índice firmado (ADR 0014). **La identidad no cambia**: la imagen se registra bajo el sha256
151 /// del ARCHIVO de upstream que el artefacto declara, no bajo su ArtifactHash, así que la que
152 /// importa una máquina y la que otra trae con `pull` son la MISMA imagen.
153 Import {
154 /// Hash del artefacto en el store; acepta prefijo.
155 #[arg(long)]
156 from_store: String,
157 /// Copia en vez de enlazar. Por defecto enlaza (`cp -al`), que es gratis y correcto: una
158 /// imagen NUNCA se escribe —las escrituras van al `upper` de la instancia—, así que
159 /// compartir inodos con el artefacto sellado no puede corromper nada.
160 #[arg(long)]
161 copy: bool,
162 #[arg(long)]
163 root: Option<PathBuf>,
164 },
165 /// [ADR 0015 §Orden 5] Genera los shims y `.desktop` de lo declarado en `[export]`.
166 ///
167 /// **Se GENERAN, no se copian.** El `Exec=` de un `.desktop` ajeno es texto ajeno: copiarlo
168 /// pondría una línea de comando que no escribimos en el menú del usuario (D5).
169 Export {
170 id: String,
171 /// Prefijo donde escribir (`<into>/bin`, `<into>/share/applications`). Default: `~/.local`.
172 #[arg(long)]
173 into: Option<PathBuf>,
174 /// Borra exactamente lo que se generó. Revocable: sin shims, la instancia desaparece del
175 /// sistema sin desmontar nada.
176 #[arg(long)]
177 remove: bool,
178 #[arg(long)]
179 root: Option<PathBuf>,
180 },
181 /// [ADR 0015 §Orden 7] Poda: restos de descargas a medias, imágenes que ninguna instancia usa
182 /// y —si se pide— las capas mutables, que por D3 siempre se pueden tirar.
183 ///
184 /// **Sin `--yes` no borra nada**: dice qué haría y cuánto liberaría. Este repo ya tuvo tres
185 /// emergencias de disco y un `store-gc` que REPORTABA borrados que no ocurrían.
186 Prune {
187 /// Además, tira la capa mutable de cada instancia. El manifiesto es la verdad y el `upper`
188 /// es caché (D3) — pero lo que instalaste a mano y no declaraste en `packages` se va.
189 #[arg(long)]
190 upper: bool,
191 /// Ejecuta de verdad. Sin esto es un simulacro.
192 #[arg(long)]
193 yes: bool,
194 #[arg(long)]
195 root: Option<PathBuf>,
196 },
197}
198
199pub fn run(cmd: QorpaCmd, store: &Path) -> Result<()> {
200 match cmd {
201 QorpaCmd::Pull { url, sha256, label, verify_only, subdir, root } => {
202 pull(&resolve_root(root), &url, &sha256, label.as_deref(), verify_only, subdir.as_deref())
203 }
204 QorpaCmd::List { root, json } => list(&resolve_root(root), json),
205 QorpaCmd::Create { id, base, distro, root } => {
206 create(&resolve_root(root), &id, &base, distro.as_deref())
207 }
208 QorpaCmd::Recreate { id, no_provision, root } => {
209 recreate(&resolve_root(root), &id, no_provision)
210 }
211 QorpaCmd::Run { id, root, dry_run, no_jail, single_id, evidence, cmd } => run_instance(
212 &resolve_root(root), &id, &cmd,
213 Ajustes { dry_run, no_jail, single_id, evidencia: evidence, ..Default::default() },
214 ),
215 QorpaCmd::Provision { id, force, dry_run, root } => {
216 provision(&resolve_root(root), &id, force, dry_run)
217 }
218 QorpaCmd::Export { id, into, remove, root } => {
219 export(&resolve_root(root), &id, into.as_deref(), remove)
220 }
221 QorpaCmd::Prune { upper, yes, root } => prune(&resolve_root(root), upper, yes),
222 QorpaCmd::Import { from_store, copy, root } => {
223 import(&resolve_root(root), store, &from_store, copy)
224 }
225 }
226}
227
228fn resolve_root(flag: Option<PathBuf>) -> PathBuf {
229 flag.or_else(|| takana_core::env::var_os(ROOT_ENV).map(PathBuf::from))
230 .unwrap_or_else(|| PathBuf::from(DEFAULT_ROOT))
231}
232
233/// Lo que queda escrito junto al árbol. Es el registro de PROCEDENCIA: sin él, un directorio con
234/// un rootfs adentro no sabe decir de dónde salió ni contra qué se verificó.
235#[derive(Serialize, Deserialize)]
236struct ImageManifest {
237 sha256: String,
238 url: String,
239 #[serde(skip_serializing_if = "Option::is_none")]
240 label: Option<String>,
241 archive_bytes: u64,
242 tree_files: u64,
243 tree_bytes: u64,
244 /// El rootfs venía dentro de este subdirectorio del archivo (`root.x86_64` de Arch) y se elevó
245 /// a raíz. Ausente = el archivo YA era un rootfs plano (Ubuntu base).
246 #[serde(skip_serializing_if = "Option::is_none")]
247 rootfs_subdir: Option<String>,
248 /// Lo que había al lado del rootfs y NO entró (`version`, `pkglist.x86_64.txt` de Arch). Se
249 /// registra en vez de descartarse en silencio: si mañana falta algo, acá está qué se tiró.
250 #[serde(default, skip_serializing_if = "Vec::is_empty")]
251 dropped_siblings: Vec<String>,
252}
253
254// ── pull ────────────────────────────────────────────────────────────────────────────────────────
255
256fn pull(
257 root: &Path, url: &str, sha_in: &str, label: Option<&str>, verify_only: bool,
258 subdir: Option<&str>,
259) -> Result<()> {
260 let sha = normalize_sha256(sha_in)?;
261 let images = root.join("images");
262 let dest = images.join(&sha);
263
264 // Idempotencia con la regla 3 puesta delante: "ya está" sólo si TIENE CONTENIDO. Un directorio
265 // vacío de un pull interrumpido se leería como presencia y el error viajaría hasta el final.
266 if dest.exists() {
267 match tree_state(&dest.join(TREE)) {
268 TreeState::Populated => {
269 println!("ya presente y verificada: {}", dest.display());
270 return Ok(());
271 }
272 TreeState::Missing if verify_only => {
273 println!("archivo ya verificado antes (sin desempacar): {}", dest.display());
274 return Ok(());
275 }
276 TreeState::Missing | TreeState::Empty => {
277 eprintln!(
278 "aviso: {} existe pero su árbol está vacío o ausente — pull anterior a medias, \
279 se rehace",
280 dest.display()
281 );
282 force_remove_dir_all(&dest)
283 .with_context(|| format!("no pude limpiar {}", dest.display()))?;
284 }
285 }
286 }
287
288 std::fs::create_dir_all(&images)
289 .with_context(|| format!("no puedo crear {}", images.display()))?;
290
291 let archive = images.join(format!(".{sha}.part"));
292 println!("bajando {url}");
293 download_to_file(url, &archive)?;
294
295 // El corte. Si el contenido no es el que dice ser, se ABORTA — no se avisa y se sigue.
296 takana_build::download::verify_sha256(&archive, &sha).inspect_err(|_| {
297 std::fs::remove_file(&archive).ok();
298 })?;
299 let archive_bytes = std::fs::metadata(&archive)?.len();
300 println!("sha256 verificado ({} bytes)", archive_bytes);
301
302 if verify_only {
303 std::fs::create_dir_all(&dest)?;
304 write_manifest(&dest, &ImageManifest {
305 sha256: sha.clone(), url: url.into(), label: label.map(Into::into),
306 archive_bytes, tree_files: 0, tree_bytes: 0, rootfs_subdir: None,
307 dropped_siblings: Vec::new(),
308 })?;
309 std::fs::rename(&archive, dest.join("archive"))?;
310 println!("guardada sin desempacar en {}", dest.display());
311 return Ok(());
312 }
313
314 // Desempacado atómico-ish: a un `.tmp` al lado y luego rotar. Extraer directo sobre el destino
315 // dejaría medio rootfs si algo falla, y medio rootfs es justo lo que la regla 3 castiga.
316 let staging = images.join(format!(".{sha}.tmp"));
317 force_remove_dir_all(&staging)
318 .with_context(|| format!("no pude limpiar el staging {}", staging.display()))?;
319 let tree_tmp = staging.join(TREE);
320 std::fs::create_dir_all(&tree_tmp)?;
321 println!("desempacando…");
322 // Cualquier fallo de acá en adelante barre el staging Y el archivo: "no dejar nada a medias" no
323 // vale sólo para el sha que no coincide — un desempacado a medias es la misma trampa.
324 let unpack = || -> Result<(Option<String>, Vec<String>, u64, u64)> {
325 untar(&archive, &tree_tmp)?;
326 let (sub, dropped) = locate_rootfs(&tree_tmp, subdir)?;
327 let (files, bytes) = walk_tree(&tree_tmp)?;
328 Ok((sub, dropped, files, bytes))
329 };
330 let (rootfs_subdir, dropped_siblings, tree_files, tree_bytes) = match unpack() {
331 Ok(v) => v,
332 Err(e) => {
333 force_remove_dir_all(&staging).ok();
334 std::fs::remove_file(&archive).ok();
335 return Err(e);
336 }
337 };
338 std::fs::remove_file(&archive).ok();
339
340 if let Some(d) = &rootfs_subdir {
341 println!("el rootfs venía en {d}/ — elevado a raíz");
342 }
343 if !dropped_siblings.is_empty() {
344 println!("fuera del rootfs, NO entran: {}", dropped_siblings.join(", "));
345 }
346 if tree_files == 0 {
347 force_remove_dir_all(&staging).ok();
348 bail!("el archivo desempacó VACÍO — eso no es una imagen, es un nombre (CLAUDE.md regla 3)");
349 }
350
351 write_manifest(&staging, &ImageManifest {
352 sha256: sha.clone(), url: url.into(), label: label.map(Into::into),
353 archive_bytes, tree_files, tree_bytes, rootfs_subdir, dropped_siblings,
354 })?;
355 std::fs::rename(&staging, &dest)
356 .with_context(|| format!("no puedo rotar {} a {}", staging.display(), dest.display()))?;
357
358 println!(
359 "imagen lista: {} · {tree_files} ficheros · {}",
360 dest.display(),
361 human(tree_bytes)
362 );
363 Ok(())
364}
365
366/// Descarga a fichero. NO se reusa `download::fetch_url_to_file` a propósito: ése trae el cuerpo
367/// entero a memoria (le sirve para un patch de KB) y acá hablamos de cientos de MB, con `--max-time`
368/// de 300 s que un rootfs no respeta.
369///
370/// **`--retry` a secas no cubre el fallo que de verdad pasa.** Medido trayendo el runtime *sniper*
371/// (302 MB): la CDN de Valve cortó el stream al 73% con `HTTP/2 INTERNAL_ERROR` (exit 92) y curl
372/// **no reintentó**, porque sin `--retry-all-errors` sólo considera transitorios los timeouts y los
373/// 5xx — un stream roto a media transferencia no entra en esa lista. Y aun reintentando, sin
374/// `-C -` cada intento vuelve a empezar de cero: en un fichero de cientos de MB sobre una conexión
375/// que se corta, eso no converge nunca.
376///
377/// Por eso el parcial **NO se borra al fallar**: es lo que hace que el siguiente intento reanude en
378/// vez de rebajar todo. Es seguro porque quien decide no es el fichero sino el `sha256` que se
379/// verifica después —un parcial corrupto no puede pasar por bueno— y porque el nombre lleva punto
380/// delante, así que `list` no lo ve como imagen y `prune` ya lo barre como «resto de un pull a
381/// medias».
382fn download_to_file(url: &str, dst: &Path) -> Result<()> {
383 if let Some(p) = dst.parent() {
384 std::fs::create_dir_all(p)?;
385 }
386 let st = Command::new("curl")
387 .args(["-fL", "--retry", "5", "--retry-delay", "2", "--retry-all-errors",
388 "--connect-timeout", "30", "-C", "-", "--progress-bar", "-o"])
389 .arg(dst)
390 .arg(url)
391 .status()
392 .context("no pude ejecutar curl")?;
393 if !st.success() {
394 let reanudable = std::fs::metadata(dst).map(|m| m.len()).unwrap_or(0);
395 if reanudable > 0 {
396 eprintln!(
397 " (quedaron {} bajados en {}: el siguiente intento reanuda desde ahí; \
398 `qorpa prune` los barre)",
399 human(reanudable),
400 dst.display()
401 );
402 }
403 bail!("curl falló bajando {url} (exit {:?})", st.code());
404 }
405 Ok(())
406}
407
408fn normalize_sha256(s: &str) -> Result<String> {
409 let s = s.strip_prefix("sha256:").unwrap_or(s).trim().to_ascii_lowercase();
410 if s.len() != 64 || !s.bytes().all(|b| b.is_ascii_hexdigit()) {
411 bail!("--sha256 debe ser 64 dígitos hex (llegó {:?}, {} chars)", s, s.len());
412 }
413 Ok(s)
414}
415
416/// Elige el descompresor por MAGIC, no por extensión: el nombre de un fichero es una sugerencia y
417/// las tres imágenes curadas usan tres compresores distintos (zstd en Arch, gzip en Ubuntu, xz en
418/// Fedora). `tar` extrae con `--no-same-owner` para que el resultado sea el MISMO lo corra root o
419/// no — la propiedad real la pone el mapeo del userns, no el tar.
420fn untar(archive: &Path, into: &Path) -> Result<()> {
421 let mut magic = [0u8; 6];
422 let n = std::fs::File::open(archive)?.read(&mut magic)?;
423 let flag = match &magic[..n.min(6)] {
424 [0x28, 0xb5, 0x2f, 0xfd, ..] => Some("--zstd"),
425 [0x1f, 0x8b, ..] => Some("-z"),
426 [0xfd, b'7', b'z', b'X', b'Z', 0x00] => Some("-J"),
427 [b'B', b'Z', b'h', ..] => Some("-j"),
428 _ => None, // tar plano
429 };
430 // ⚠ EL `tar` DE BUSYBOX NO SIRVE ACÁ, Y SU FALLO NO LO DICE. Medido en la caja de producción:
431 // `qorpa pull` de un rootfs `.tar.zst` moría imprimiendo **la ayuda de busybox** y un
432 // `exit 1` — ningún mensaje sobre `--zstd`, que es la opción que no entiende. Comprobarlo acá
433 // convierte diez minutos de diagnóstico en una línea, y nombra el arreglo: `tar` (GNU) está
434 // sellado en el corpus desde hace meses; lo que faltaba era declararlo en el perfil.
435 let es_gnu = Command::new("tar")
436 .arg("--version")
437 .output()
438 .map(|o| String::from_utf8_lossy(&o.stdout).contains("GNU tar"))
439 .unwrap_or(false);
440 if !es_gnu {
441 bail!(
442 "el `tar` de este sistema no es GNU tar (parece busybox): no entiende `--zstd`, \n\
443 `-p` ni `--delay-directory-restore`, que hacen falta para desempacar un rootfs ajeno.\n\
444 Instalá el paquete `tar` — está sellado en el corpus; si esta es una imagen de takana, \n\
445 declaralo en el perfil."
446 );
447 }
448 let mut c = Command::new("tar");
449 if let Some(f) = flag {
450 c.arg(f);
451 }
452 // `-p` conserva los modos exactos (el setuid de `sudo` adentro importa), y
453 // `--delay-directory-restore` es OBLIGATORIO junto con él: un rootfs real trae directorios de
454 // sólo-lectura (`/etc/ca-certificates/extracted/cadir` en Arch), y sin esto tar los crea con su
455 // modo final ANTES de meterles los ficheros ⇒ "Permission denied" al extraer sin ser root. Con
456 // esto, tar los deja escribibles y aplica los modos al final.
457 // tar ya rechaza rutas absolutas y `..` al extraer: ésa es la defensa contra un tarball ajeno
458 // malicioso. Los xattr `security.capability` se pierden sin privilegios (tar avisa): dentro de
459 // la jaula da igual salvo para binarios que dependan de capabilities de fichero — anotado.
460 c.args(["-x", "-p", "--delay-directory-restore", "--no-same-owner", "-f"])
461 .arg(archive).arg("-C").arg(into);
462 let st = c.status().context("no pude ejecutar tar")?;
463 if !st.success() {
464 bail!("tar falló desempacando {} (exit {:?})", archive.display(), st.code());
465 }
466 Ok(())
467}
468
469/// Dónde está el rootfs dentro de lo que se desempacó.
470///
471/// La primera versión de esto usaba «si hay UN solo directorio arriba, ése es el rootfs». Sonaba
472/// razonable y es FALSA: el bootstrap de Arch trae tres entradas arriba (`root.x86_64/`, `version`,
473/// `pkglist.x86_64.txt`) y la regla no disparaba, así que el rootfs quedaba un nivel abajo — con
474/// todo verde y sin un solo error. Se mide por ESTRUCTURA, que es lo que define a un rootfs:
475/// tiene `etc/` y tiene `usr/` o `bin/`.
476///
477/// Si no acierta, **falla y pide `--subdir`** en vez de adivinar: un rootfs mal anclado no rompe
478/// acá, rompe mucho después, cuando la instancia no encuentra su loader.
479fn looks_like_rootfs(d: &Path) -> bool {
480 d.join("etc").is_dir() && (d.join("usr").is_dir() || d.join("bin").exists())
481}
482
483/// Deja `tree` conteniendo el rootfs. Devuelve (subdir elevado, hermanos descartados).
484fn locate_rootfs(tree: &Path, forced: Option<&str>) -> Result<(Option<String>, Vec<String>)> {
485 if forced.is_none() && looks_like_rootfs(tree) {
486 return Ok((None, Vec::new())); // Ubuntu base: el archivo YA es el rootfs.
487 }
488 let entries: Vec<_> = std::fs::read_dir(tree)
489 .with_context(|| format!("leyendo la raíz desempacada {}", tree.display()))?
490 .collect::<std::io::Result<Vec<_>>>()?;
491 let name = match forced {
492 Some(f) => {
493 if !tree.join(f).is_dir() {
494 bail!("--subdir {f:?} no existe dentro del archivo");
495 }
496 f.to_string()
497 }
498 None => {
499 let mut cands: Vec<String> = entries
500 .iter()
501 .filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
502 .filter(|e| looks_like_rootfs(&e.path()))
503 .map(|e| e.file_name().to_string_lossy().into_owned())
504 .collect();
505 cands.sort();
506 match cands.len() {
507 1 => cands.remove(0),
508 0 => bail!(
509 "no encuentro un rootfs en el archivo (ni la raíz ni ningún subdirectorio tiene \
510 `etc/` + `usr|bin`). Pasá `--subdir <dir>` si sabés dónde está."
511 ),
512 _ => bail!(
513 "hay {} subdirectorios que parecen rootfs ({}) — elegí con `--subdir`",
514 cands.len(), cands.join(", ")
515 ),
516 }
517 }
518 };
519 let dropped: Vec<String> = entries
520 .iter()
521 .map(|e| e.file_name().to_string_lossy().into_owned())
522 .filter(|n| *n != name)
523 .collect();
524
525 let top = tree.join(&name);
526 let parked = tree.with_file_name(format!(
527 "{}.lift",
528 tree.file_name().unwrap_or_default().to_string_lossy()
529 ));
530 // Renombrar un DIRECTORIO exige permiso de escritura sobre el directorio mismo (el kernel tiene
531 // que reescribir su `..`), y el `root.x86_64` de Arch viene `dr-xr-xr-x`. Se abre, se mueve y se
532 // le devuelve su modo exacto: la imagen tiene que quedar como venía, no como nos vino cómodo.
533 let mode = std::fs::metadata(&top)?.permissions().mode();
534 std::fs::set_permissions(&top, std::fs::Permissions::from_mode(mode | 0o700))?;
535 std::fs::rename(&top, &parked)
536 .with_context(|| format!("elevando {} a {}", top.display(), parked.display()))?;
537 force_remove_dir_all(tree)
538 .with_context(|| format!("descartando los hermanos en {}", tree.display()))?;
539 std::fs::rename(&parked, tree)
540 .with_context(|| format!("rotando {} a {}", parked.display(), tree.display()))?;
541 std::fs::set_permissions(tree, std::fs::Permissions::from_mode(mode))?;
542 Ok((Some(name), dropped))
543}
544
545/// `remove_dir_all` NO puede con un árbol que trae directorios sin permiso de escritura — y un
546/// rootfs real los trae (`/etc/ca-certificates/extracted/cadir` de Arch es 0555). Tragarse ese
547/// fallo con `.ok()` deja vivo el staging de un pull roto y el siguiente pull extrae ENCIMA: nos
548/// pasó, y el síntoma («Permission denied» en un directorio que acabás de crear) no se parece en
549/// nada a la causa. Abre los directorios a escritura de arriba abajo y después borra.
550fn force_remove_dir_all(p: &Path) -> std::io::Result<()> {
551 if !p.exists() {
552 return Ok(());
553 }
554 let mut stack = vec![p.to_path_buf()];
555 while let Some(d) = stack.pop() {
556 let _ = std::fs::set_permissions(&d, std::fs::Permissions::from_mode(0o700));
557 if let Ok(rd) = std::fs::read_dir(&d) {
558 for e in rd.flatten() {
559 // `file_type` de read_dir es lstat: un symlink a directorio NO se sigue.
560 if e.file_type().map(|t| t.is_dir()).unwrap_or(false) {
561 stack.push(e.path());
562 }
563 }
564 }
565 }
566 match std::fs::remove_dir_all(p) {
567 Ok(()) => Ok(()),
568 Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
569 // SEGUNDA causa, y aparece recién con el mapeo por rango: el `upper` de una instancia
570 // contiene ficheros de los SUBUID mapeados (apt deja los suyos con uid 165577), y
571 // nuestro uid normal no puede borrarlos ni chownearlos. La cura es la misma que los
572 // creó: entrar a un userns donde esos ids son nuestros. `--map-auto` usa newuidmap,
573 // así que esto sólo anda si subuid está provisionado — y si no, el error vuelve a
574 // salir tal cual, que es lo correcto.
575 let st = Command::new("unshare")
576 .args(["-U", "--map-auto", "-r", "rm", "-rf"])
577 .arg(p)
578 .status()?;
579 if st.success() && !p.exists() {
580 Ok(())
581 } else {
582 Err(e)
583 }
584 }
585 Err(e) => Err(e),
586 }
587}
588
589enum TreeState { Missing, Empty, Populated }
590
591fn tree_state(tree: &Path) -> TreeState {
592 match std::fs::read_dir(tree) {
593 Err(_) => TreeState::Missing,
594 Ok(mut it) => {
595 if it.next().is_some() { TreeState::Populated } else { TreeState::Empty }
596 }
597 }
598}
599
600fn walk_tree(root: &Path) -> Result<(u64, u64)> {
601 let (f, b, _) = walk_tree_ciegos(root)?;
602 Ok((f, b))
603}
604
605/// Igual, pero además cuenta los directorios que NO se pudieron leer. Sin ese tercer número, el
606/// tamaño de un `upper` con ficheros de los subuid sale MENOR de lo que es y nadie lo nota: un
607/// número silenciosamente bajo es peor que ninguno cuando lo que se decide con él es borrar.
608fn walk_tree_ciegos(root: &Path) -> Result<(u64, u64, u64)> {
609 let (mut files, mut bytes, mut ciegos) = (0u64, 0u64, 0u64);
610 let mut stack = vec![root.to_path_buf()];
611 while let Some(d) = stack.pop() {
612 // Un rootfs ajeno trae directorios que NI SU DUEÑO puede leer (`/etc/sudoers.d` es 0750,
613 // `/var/log/private` 0700, y alguno 0000). No es corrupción: es el rootfs siendo lo que es.
614 // Se cuentan como 0 y se sigue — abortar el pull por no poder contar sería absurdo.
615 let rd = match std::fs::read_dir(&d) {
616 Ok(rd) => rd,
617 Err(_) => { ciegos += 1; continue }
618 };
619 for e in rd {
620 let Ok(e) = e else { continue };
621 let Ok(ft) = e.file_type() else { continue };
622 if ft.is_dir() {
623 stack.push(e.path());
624 } else {
625 files += 1;
626 bytes += e.metadata().map(|m| m.len()).unwrap_or(0);
627 }
628 }
629 }
630 Ok((files, bytes, ciegos))
631}
632
633fn write_manifest(dir: &Path, m: &ImageManifest) -> Result<()> {
634 let body = format!(
635 "# Lo escribe `hammer qorpa pull`; no editar a mano.\n\
636 # La identidad de la imagen es el sha256 del ARCHIVO original, no de este árbol: por eso\n\
637 # la URL es informativa y espejar es gratis (ADR 0013).\n{}",
638 toml::to_string_pretty(m).context("serializando el manifiesto")?
639 );
640 std::fs::write(dir.join(IMAGE_MANIFEST), body)?;
641 Ok(())
642}
643
644// ── import: consumir una imagen SELLADA al store (D8) ───────────────────────────────────────────
645//
646// D1 dice que las imágenes ajenas no entran al store, y el motivo es que un rootfs MUTABLE no
647// reproduce. Sniper no muta —nadie le instala nada adentro— así que sellarlo es una afirmación
648// verdadera, y con eso se gana cadena de custodia nuestra: se replica con `takana mirror push`, su
649// digest puede ir al índice firmado (ADR 0014) y una instancia se arma sin depender de la CDN de
650// Valve. Esto es lo que convierte ese artefacto en una imagen usable.
651//
652// LO QUE NO CAMBIA: la identidad. La imagen se registra bajo el **sha256 del archivo de upstream**
653// que el artefacto declara, no bajo su ArtifactHash. Si se registrara por ArtifactHash, la imagen
654// importada del store y la traída con `pull` serían dos imágenes distintas con los mismos bytes, y
655// las instancias de dos máquinas dejarían de coincidir — justo lo que el pin existe para evitar.
656fn import(root: &Path, store: &Path, hash: &str, copiar: bool) -> Result<()> {
657 let store = takana_core::store::Store::open(store)
658 .map_err(|e| anyhow::anyhow!("abriendo el store: {e}"))?;
659 let art = store.find_by_hash(hash)
660 .map_err(|e| anyhow::anyhow!("{e}"))?;
661
662 // La imagen vive bajo un prefijo namespaceado: un rootfs glibc entero en la raíz del artefacto
663 // pisaría el sistema si alguien lo compusiera por error.
664 let base = art.join("usr/share/qorpa/images");
665 let mut candidatos: Vec<PathBuf> = std::fs::read_dir(&base)
666 .with_context(|| format!(
667 "el artefacto {} no trae `usr/share/qorpa/images/` — ¿es una receta de imagen ajena? \
668 (hoy sólo `steam-runtime-sniper`)", art.display()))?
669 .flatten()
670 .map(|e| e.path())
671 .filter(|p| p.join(IMAGE_MANIFEST).is_file())
672 .collect();
673 candidatos.sort();
674 let src = match candidatos.len() {
675 1 => candidatos.remove(0),
676 0 => bail!("no hay ninguna imagen con `{IMAGE_MANIFEST}` en {}", base.display()),
677 n => bail!("{n} imágenes en un mismo artefacto: no adivino cuál ({:?})", candidatos),
678 };
679
680 let m: ImageManifest = toml::from_str(&std::fs::read_to_string(src.join(IMAGE_MANIFEST))?)
681 .with_context(|| format!("leyendo {}", src.join(IMAGE_MANIFEST).display()))?;
682 let sha = normalize_sha256(&m.sha256)?;
683 let arbol_src = src.join(TREE);
684 if !matches!(tree_state(&arbol_src), TreeState::Populated) {
685 bail!("el artefacto declara la imagen pero su `{TREE}/` está vacío o no existe — un nombre \
686 no es una imagen (CLAUDE.md regla 3)");
687 }
688
689 let dest = root.join("images").join(&sha);
690 if let TreeState::Populated = tree_state(&dest.join(TREE)) {
691 println!("ya presente: {} (sha256:{}…)", dest.display(), &sha[..12]);
692 return Ok(());
693 }
694 force_remove_dir_all(&dest).ok();
695 std::fs::create_dir_all(&dest)?;
696
697 // ENLAZAR, no copiar, y no es un ahorro cualquiera: una imagen NUNCA se escribe —lo que escribe
698 // la instancia va a su `upper`—, así que compartir inodos con un artefacto sellado (y de sólo
699 // lectura) es correcto por construcción y hace que la imagen cueste ~0 bytes.
700 // ⚠ La contracara, que ya nos mordió con `.dmerge`: mientras el artefacto siga en el store,
701 // borrar la imagen NO libera disco. Es una propiedad, no un fallo; `--copy` la evita.
702 let mut modo = "enlazada";
703 let arbol_dst = dest.join(TREE);
704 let cp = |args: &[&str]| -> Result<bool> {
705 Ok(Command::new("cp").args(args)
706 .arg(&arbol_src).arg(&arbol_dst).status()?.success())
707 };
708 if copiar || !cp(&["-a", "--link", "-T"])? {
709 if !copiar {
710 // EXDEV: el store puede estar en OTRO mount (bind-mount del volumen), y `link()` no
711 // cruza mounts aunque sea el mismo filesystem. Se dice y se copia, en vez de fallar.
712 eprintln!(" (no pude enlazar —¿store en otro mount?—, copio)");
713 force_remove_dir_all(&arbol_dst).ok();
714 }
715 modo = "copiada";
716 if !cp(&["-a", "-T"])? {
717 bail!("no pude copiar el árbol de la imagen desde {}", arbol_src.display());
718 }
719 }
720
721 // Se MIDE lo que quedó, no se cree lo que el manifiesto del artefacto decía: los contadores del
722 // artefacto podrían venir de otra máquina y este árbol es el que la instancia va a montar.
723 let (tree_files, tree_bytes) = walk_tree(&arbol_dst)?;
724 if tree_files == 0 {
725 bail!("el árbol importado quedó vacío — se aborta antes de escribir el manifiesto");
726 }
727 write_manifest(&dest, &ImageManifest {
728 sha256: sha.clone(), url: m.url, label: m.label,
729 archive_bytes: m.archive_bytes, tree_files, tree_bytes,
730 rootfs_subdir: m.rootfs_subdir, dropped_siblings: m.dropped_siblings,
731 })?;
732 println!(
733 "imagen {modo} desde el store: {} · {tree_files} ficheros · {}",
734 dest.display(), human(tree_bytes)
735 );
736 println!(" identidad = sha256 del archivo de upstream, no el ArtifactHash: coincide con la \
737 que otra máquina traiga con `pull`");
738 Ok(())
739}
740
741// ── instancias ──────────────────────────────────────────────────────────────────────────────────
742
743/// El manifiesto de una instancia. **Es la verdad**: el `upper/` es caché y se puede tirar entero
744/// (D3). Los nombres de campo van en inglés como el resto de la superficie (`CLAUDE.md` regla 4);
745/// el ADR los escribió en castellano y se corrigieron aquí.
746#[derive(Serialize, Deserialize, Default)]
747struct Instance {
748 /// sha256 de la imagen base. Cambiarlo + `recreate` ES la actualización de versión (D8).
749 base: String,
750 #[serde(skip_serializing_if = "Option::is_none")]
751 distro: Option<String>,
752 /// Lo que debe estar instalado adentro. **Se instala solo**: `takana qorpa provision` lo pone
753 /// con el gestor de la imagen, y `recreate` lo llama después de tirar la capa. Sin esto el
754 /// `upper` sería el activo y el manifiesto un adorno.
755 #[serde(default, skip_serializing_if = "Vec::is_empty")]
756 packages: Vec<String>,
757 /// La política, autorada (D7). **Por defecto vacía**: una instancia nace sin ver nada.
758 #[serde(default)]
759 grants: Grants,
760 /// Correr el comando como este usuario de la imagen, en vez de como root.
761 ///
762 /// ── POR QUÉ ESTO Y NO `root = false` ───────────────────────────────────────────────────────
763 /// MEDIDO con Steam: el cliente **se niega a correr como root** (`bin_steam.sh: Error: Cannot
764 /// run as root user`), así que la instancia de juegos necesita un usuario normal. La vía
765 /// tentadora —cambiar el mapa para caer en el uid 1000— **corrompe la instancia**: un fichero
766 /// creado bajo un mapa aparece con OTRO uid bajo el otro, y el `useradd` de la preparación deja
767 /// un `/home` que después su propio dueño no puede escribir.
768 ///
769 /// La vía correcta es la de cualquier runtime de contenedores: **un solo mapa, y se BAJA de
770 /// privilegio adentro**. Tenemos `CAP_SETUID` en el namespace, así que es un `setpriv` y ya.
771 #[serde(default, skip_serializing_if = "Option::is_none")]
772 run_as: Option<String>,
773 /// La capa de transparencia (D5). Vacía por defecto: **se exporta lo DECLARADO**, nunca todo.
774 /// Exportar todo es la falla de Bedrock — su `ls` compitiendo con el nuestro, arbitrado por
775 /// heurística en tiempo de `exec`. Acá la ambigüedad se resuelve al declarar.
776 #[serde(default)]
777 export: Export,
778}
779
780#[derive(Serialize, Deserialize, Default)]
781struct Export {
782 /// Binarios que aparecen en el `PATH` del host como shims.
783 #[serde(default, skip_serializing_if = "Vec::is_empty")]
784 binaries: Vec<String>,
785 /// Ficheros `.desktop` de la imagen cuyo equivalente se GENERA para el menú del host.
786 #[serde(default, skip_serializing_if = "Vec::is_empty")]
787 apps: Vec<String>,
788}
789
790#[derive(Serialize, Deserialize)]
791#[serde(default)]
792struct Grants {
793 /// Nombres cortos: `wayland`, `pipewire`, `dbus`. ⚠ `wayland` es un borde de PRIVILEGIO, no un
794 /// caño: quien lo tiene puede capturar pantalla y sintetizar teclas (ADR §NO-resuelve 1).
795 #[serde(default, skip_serializing_if = "Vec::is_empty")]
796 sockets: Vec<String>,
797 /// Nodos de dispositivo (`/dev/dri`). ABI de kernel, que es lo único que cruza el borde (D2).
798 #[serde(default, skip_serializing_if = "Vec::is_empty")]
799 devices: Vec<String>,
800 #[serde(default, skip_serializing_if = "Vec::is_empty")]
801 dirs: Vec<DirGrant>,
802 /// La concesión más peligrosa, y por eso va sola en su línea. `dnf`/`pacman` la necesitan.
803 #[serde(default)]
804 network: bool,
805 /// Pasar el socket de Wayland **crudo**, sin el proxy filtrante. Apagado por defecto.
806 ///
807 /// Con esto la instancia recupera TODOS los globals del compositor, incluidos los que capturan
808 /// pantalla, sintetizan teclas y leen el portapapeles. Existe para diagnosticar, no para usar.
809 #[serde(default)]
810 wayland_raw: bool,
811 /// Globals de Wayland que el proxy deja ver. Vacío = la lista curada de `qorpa_wl`.
812 #[serde(default, skip_serializing_if = "Vec::is_empty")]
813 wayland_globals: Vec<String>,
814 /// Deja que la instancia monte y cree namespaces adentro. **Steam ya es un contenedor**: su
815 /// pressure-vessel necesita esto para arrancar (D6). Es una concesión real — con ella la
816 /// instancia recupera la familia `mount`/`setns` que la jaula deniega por defecto.
817 #[serde(default)]
818 nesting: bool,
819 /// Compartir el **árbol de procesos del host** en vez de armar uno propio (`--unshare-pid`).
820 ///
821 /// Apagado por defecto: un `ps` de adentro no tiene por qué ver la máquina entera. Se
822 /// enciende cuando algo de ADENTRO tiene que ser identificable desde AFUERA por su pid.
823 ///
824 /// El caso que lo trajo (2026-09-25): Claude Code deja un registro vivo en
825 /// `~/.claude/sessions/<pid>.json` para poder reanudar una conversación, y shuma lo usa para
826 /// que restaurar una pestaña devuelva **la charla** y no un shell pelado. Con el namespace
827 /// propio ese pid es el de adentro —**2**, en todas las jaulas a la vez— así que (a) el
828 /// daemon, que vive afuera, no puede cruzarlo contra `/proc`, y (b) como el `$HOME` está
829 /// compartido, **todas las jaulas escriben el mismo `2.json` y se pisan**. Medido: los tres
830 /// registros que había eran de la misma jaula y ninguno de la sesión viva.
831 ///
832 /// ⚠ Es una concesión real: con esto la instancia ve y puede señalizar los procesos del host
833 /// que su uid alcance. No abre nada más (fs, red y capacidades siguen igual).
834 #[serde(default)]
835 host_pids: bool,
836 /// Mapear tu uid a **root adentro**. Encendido por defecto: es lo que quieren `dnf`/`pacman`.
837 ///
838 /// ⚠ MEDIDO 2026-09-03, y es un conflicto real con `nesting`: con `--uid 0`, un userns anidado
839 /// NO puede escribir su `uid_map` («Operation not permitted»), así que **pressure-vessel de
840 /// Valve no arranca**. Sin remapear a root, el anidamiento funciona pero el gestor de paquetes
841 /// se queja. Las dos mitades se arreglan con lo mismo: mapear un RANGO real de subuid con
842 /// `newuidmap` y pasarle el namespace a bwrap con `--userns FD` — el mismo impuesto que paga
843 /// hoy `apt` con su `setgroups`.
844 #[serde(default = "si")]
845 root: bool,
846 /// Sella el árbol de la IMAGEN (`/usr`, `/bin`, `/lib`, `/opt`…) contra escritura, aunque
847 /// adentro seas root. Apagado por defecto porque un gestor de paquetes necesita escribir en
848 /// `/usr`; encendido para una instancia que sólo CORRE algo, un exploit no puede persistir en
849 /// el `upper`. Es lo único que Landlock aporta acá que el namespace de montaje no da ya.
850 #[serde(default)]
851 seal_image: bool,
852}
853
854/// Dónde vive `harkaq-exec`. Misma convención que el harkaq del build (`HARKAQ_BIN`), **más el
855/// binario instalado**, que es el caso de cualquier máquina que no sea el hub de desarrollo.
856///
857/// ⚠ MEDIDO el 2026-09-15 en la caja de producción: sólo se buscaba en `~/.cache/harkaq`, o sea en
858/// la caché de quien lo hubiera compilado a mano. En una caja instalada no hay `gcc`, ni `scripts/`,
859/// ni caché — así que `qorpa` abortaba con una instrucción imposible de seguir y la jaula del ADR
860/// 0015 funcionaba únicamente en la máquina donde alguien la había construido. Ahora
861/// `recipes/harkaq-exec.toml` lo publica en `/usr/bin` y va declarado en `perfil.base`.
862///
863/// El orden es deliberado: lo que el operador declara (`HARKAQ_BIN`) gana, después el árbol de
864/// desarrollo —para que un cambio en la jaula se pruebe sin instalar nada—, y el paquete al final.
865/// Si no está ninguno se devuelve el primer candidato, que es el que nombra el error.
866fn harkaq_exec() -> PathBuf {
867 if let Ok(dir) = std::env::var("HARKAQ_BIN") {
868 return PathBuf::from(dir).join("harkaq-exec");
869 }
870 let cache = PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| "/root".into()))
871 .join(".cache/harkaq")
872 .join("harkaq-exec");
873 if cache.exists() {
874 return cache;
875 }
876 let instalado = PathBuf::from("/usr/bin/harkaq-exec");
877 if instalado.exists() {
878 return instalado;
879 }
880 cache
881}
882
883/// Las capabilities que hacen que el uid 0 de adentro sea root DE VERDAD.
884///
885/// MEDIDO: bwrap tira TODAS las capabilities, y en Linux ser root es tener `CAP_SETUID`, no tener
886/// uid 0. Sin ellas `apt` no puede `seteuid(42)` para bajar a `_apt` y `dpkg` no puede chownear —
887/// que es exactamente el síntoma que parecía de subuid y no lo era.
888///
889/// Son SEGURAS por construcción: una capability dentro de un user namespace sólo alcanza a lo que
890/// ese namespace posee, o sea los ids que le mapeamos (nuestros propios subuid). No dan nada en el
891/// host. Por eso se conceden con `root = true` sin pedir permiso aparte.
892///
893/// `CAP_SYS_ADMIN` NO está en la lista: es la que permite montar, y montar cuelga de la concesión
894/// `nesting` declarada. Abrir sólo lo declarado, también acá.
895const CAPS_ROOT: &[&str] = &[
896 "CAP_CHOWN", "CAP_DAC_OVERRIDE", "CAP_FOWNER", "CAP_FSETID", "CAP_MKNOD",
897 "CAP_SETGID", "CAP_SETUID", "CAP_SETFCAP", "CAP_SETPCAP", "CAP_SYS_CHROOT",
898 "CAP_KILL", "CAP_AUDIT_WRITE",
899];
900
901/// Los directorios que pertenecen a la IMAGEN y que `seal_image` congela.
902const IMAGEN_INMUTABLE: &[&str] = &["usr", "bin", "sbin", "lib", "lib64", "lib32", "opt", "boot"];
903/// Lo que bwrap monta encima del overlay y siempre es de la instancia, no de la imagen.
904const DEL_SANDBOX: &[&str] = &["/proc", "/dev", "/tmp", "/run"];
905
906/// Compila las concesiones a la política que consume `harkaq-exec`.
907///
908/// ── QUÉ APORTA HARKAQ ACÁ, Y QUÉ NO ─────────────────────────────────────────────────────────────
909/// Honestidad primero: en el eje del SISTEMA DE FICHEROS, harkaq casi no agrega nada a una
910/// instancia, porque el namespace de montaje de bwrap ya es una lista blanca — lo que no se bindea
911/// no existe adentro, y un `--ro-bind` es de sólo lectura por el kernel, más fuerte que una regla.
912/// Escribir reglas `ro` que no cambian nada sería un sello de goma, así que no se escriben.
913///
914/// Lo que harkaq SÍ aporta, y es grande para un binario ajeno y opaco:
915/// 1. **seccomp.** bwrap no instala filtro alguno: hoy una instancia puede `io_uring`, `bpf`,
916/// `ptrace`, `userfaultfd`, `keyctl`, `perf_event_open`, cargar módulos. Esa superficie
917/// importa MÁS con un prebuilt de terceros que con nuestros propios builds.
918/// 2. **`no_new_privs`**: ningún setuid de la imagen escala adentro.
919/// 3. **el canal de evidencia**: con ABI≥7 el kernel audita las denegaciones ⇒ se puede saber
920/// qué intentó tocar un binario cerrado. Es la única forma de auditar el montón B.
921/// 4. **`seal_image`**: lo único del eje fs que el namespace no da — congelar el árbol de la
922/// imagen aunque adentro seas root.
923fn compile_policy(g: &Grants, image_tree: &Path, dst: &Path) -> Result<()> {
924 use std::fmt::Write as _;
925 let mut out = String::new();
926 out.push_str("# Política de una INSTANCIA qorpa (ADR 0015 D7).\n");
927 out.push_str("# A diferencia de la del build, ésta NO se deriva de una clausura: se AUTORA,\n");
928 out.push_str("# que es el único sitio del sistema donde eso pasa. Se compila del manifiesto.\n");
929
930 if !g.seal_image {
931 // El árbol entero es de la instancia y sus escrituras van al `upper`, que es caché.
932 out.push_str("rw /\n");
933 } else {
934 // Sin regla sobre `/` no se puede ni listar la raíz; listar no es leer ni escribir.
935 out.push_str("list /\n# la imagen, congelada:\n");
936 for d in IMAGEN_INMUTABLE {
937 if image_tree.join(d).exists() {
938 let _ = writeln!(out, "ro /{d}");
939 }
940 }
941 out.push_str("# lo mutable de la instancia:\n");
942 let mut mutables: Vec<String> = std::fs::read_dir(image_tree)
943 .with_context(|| format!("leyendo el árbol de la imagen {}", image_tree.display()))?
944 .flatten()
945 .filter(|e| e.file_type().map(|t| t.is_dir()).unwrap_or(false))
946 .map(|e| e.file_name().to_string_lossy().into_owned())
947 .filter(|n| !IMAGEN_INMUTABLE.contains(&n.as_str()))
948 .map(|n| format!("/{n}"))
949 .collect();
950 for d in DEL_SANDBOX {
951 if !mutables.iter().any(|m| m == d) {
952 mutables.push((*d).to_string());
953 }
954 }
955 mutables.sort();
956 mutables.dedup();
957 for m in &mutables {
958 let _ = writeln!(out, "rw {m}");
959 }
960 }
961 std::fs::write(dst, out)
962 .with_context(|| format!("escribiendo la política {}", dst.display()))?;
963 Ok(())
964}
965
966
967impl Default for Grants {
968 fn default() -> Self {
969 // Toda concesión arranca CERRADA menos `root`, que no abre nada del host: sólo decide
970 // quién sos adentro de tu propio rootfs.
971 Grants {
972 sockets: Vec::new(), devices: Vec::new(), dirs: Vec::new(),
973 network: false, nesting: false, root: true, seal_image: false,
974 host_pids: false,
975 wayland_raw: false, wayland_globals: Vec::new(),
976 }
977 }
978}
979
980#[derive(Serialize, Deserialize)]
981struct DirGrant {
982 host: String,
983 inside: String,
984 /// `ro` o `rw`.
985 #[serde(default = "ro")]
986 mode: String,
987}
988fn ro() -> String { "ro".into() }
989fn si() -> bool { true }
990
991fn instances_dir(root: &Path) -> PathBuf { root.join("instances") }
992fn instance_dir(root: &Path, id: &str) -> PathBuf { instances_dir(root).join(id) }
993
994/// Resuelve un prefijo de sha contra las imágenes presentes. Que exista y que TENGA CONTENIDO: una
995/// instancia sobre una imagen vacía es un directorio con nombre de rootfs (regla 3).
996fn resolve_image(root: &Path, prefix: &str) -> Result<(String, PathBuf)> {
997 let prefix = prefix.strip_prefix("sha256:").unwrap_or(prefix).to_ascii_lowercase();
998 let images = root.join("images");
999 let mut hits: Vec<String> = std::fs::read_dir(&images)
1000 .with_context(|| format!("no hay imágenes en {}", images.display()))?
1001 .flatten()
1002 .map(|e| e.file_name().to_string_lossy().into_owned())
1003 .filter(|n| !n.starts_with('.') && n.starts_with(&prefix))
1004 .collect();
1005 hits.sort();
1006 match hits.len() {
1007 1 => {
1008 let sha = hits.remove(0);
1009 let tree = images.join(&sha).join(TREE);
1010 if !matches!(tree_state(&tree), TreeState::Populated) {
1011 bail!("la imagen {sha} está VACÍA — no es una imagen, es un nombre");
1012 }
1013 Ok((sha, tree))
1014 }
1015 0 => bail!("ninguna imagen empieza por {prefix:?} — traela con `hammer qorpa pull`"),
1016 n => bail!("{n} imágenes empiezan por {prefix:?}: dame más dígitos"),
1017 }
1018}
1019
1020fn create(root: &Path, id: &str, base: &str, distro: Option<&str>) -> Result<()> {
1021 if id.is_empty() || id.contains('/') || id.starts_with('.') {
1022 bail!("id de instancia inválido: {id:?}");
1023 }
1024 let dir = instance_dir(root, id);
1025 if dir.exists() {
1026 bail!("la instancia {id} ya existe en {} — `recreate` tira su capa mutable", dir.display());
1027 }
1028 let (sha, _tree) = resolve_image(root, base)?;
1029
1030 let inst = Instance {
1031 base: format!("sha256:{sha}"),
1032 distro: distro.map(Into::into),
1033 ..Default::default()
1034 };
1035 std::fs::create_dir_all(dir.join("upper"))?;
1036 std::fs::create_dir_all(dir.join("work"))?;
1037 write_instance(&dir, &inst)?;
1038 println!("instancia {id} creada en {}", dir.display());
1039 println!(" base: sha256:{}", &sha[..12]);
1040 println!(" concesiones: NINGUNA — se abren declarándolas en {}", INSTANCE_MANIFEST);
1041 Ok(())
1042}
1043
1044fn read_instance(root: &Path, id: &str) -> Result<(PathBuf, Instance)> {
1045 let dir = instance_dir(root, id);
1046 let f = dir.join(INSTANCE_MANIFEST);
1047 let body = std::fs::read_to_string(&f)
1048 .with_context(|| format!("no existe la instancia {id} ({})", f.display()))?;
1049 let inst: Instance = toml::from_str(&body)
1050 .with_context(|| format!("manifiesto ilegible: {}", f.display()))?;
1051 Ok((dir, inst))
1052}
1053
1054fn write_instance(dir: &Path, inst: &Instance) -> Result<()> {
1055 let body = format!(
1056 "# Manifiesto de la instancia — ESTO es la verdad, `upper/` es caché descartable (ADR 0015 D3).\n\
1057 # `[grants]` es la política, y se AUTORA: es el único sitio del sistema donde no se deriva\n\
1058 # de una clausura declarada (D7). Por defecto no hay ninguna.\n{}",
1059 toml::to_string_pretty(inst).context("serializando la instancia")?
1060 );
1061 std::fs::write(dir.join(INSTANCE_MANIFEST), body)?;
1062 Ok(())
1063}
1064
1065fn recreate(root: &Path, id: &str, no_provision: bool) -> Result<()> {
1066 let (dir, inst) = read_instance(root, id)?;
1067 let (sha, _) = resolve_image(root, &inst.base)?;
1068 for capa in ["upper", "work"] {
1069 force_remove_dir_all(&dir.join(capa))
1070 .with_context(|| format!("no pude tirar {capa}/ de {id}"))?;
1071 std::fs::create_dir_all(dir.join(capa))?;
1072 }
1073 // El registro vive FUERA del `upper` (si viviera dentro se iría con él y nunca sabríamos qué
1074 // había), así que hay que borrarlo a mano: la capa se fue, así que no hay nada instalado.
1075 // Dejarlo sería la forma más pura del error de la regla 3 — un registro que afirma presencia
1076 // sobre un árbol vacío.
1077 let _ = std::fs::remove_file(dir.join(PROVISION_LEDGER));
1078 println!("instancia {id} recreada sobre sha256:{} — capa mutable tirada", &sha[..12]);
1079 if inst.packages.is_empty() {
1080 return Ok(());
1081 }
1082 if no_provision {
1083 println!(
1084 " declara {} paquete(s) y NO se reinstalaron (--no-provision): `hammer qorpa \
1085 provision {id}`",
1086 inst.packages.len()
1087 );
1088 return Ok(());
1089 }
1090 // Acá es donde D3 deja de ser una aspiración: si `recreate` no reinstala, el `upper` es el
1091 // activo y el manifiesto un adorno.
1092 println!(" reinstalando lo declarado ({} paquete(s))…", inst.packages.len());
1093 provision(root, id, false, false)
1094}
1095
1096// ── provision: `packages` deja de ser una lista que nadie lee (D3) ──────────────────────────────
1097
1098const PROVISION_LEDGER: &str = "provisioned.toml";
1099
1100/// Lo que quedó instalado, para no reinstalar por gusto y para que `recreate` sepa qué rehacer.
1101/// Vive junto al manifiesto y NO dentro del `upper`: si viviera dentro se iría con la capa.
1102#[derive(Serialize, Deserialize, Default)]
1103struct Provisionado {
1104 manager: String,
1105 packages: Vec<String>,
1106 /// Segundos desde epoch. Sin dep de fechas: se lee con `date -u -d @<n>`.
1107 at_unix: u64,
1108}
1109
1110/// El guión que instala, y de qué gestor sale.
1111///
1112/// **Un gestor por imagen, entrando explícitamente** — el ADR rechaza multiplexar `dnf`/`pacman`
1113/// detrás de un comando único (el `pmm` de Bedrock): eso es menos mágico y no miente. Acá no se
1114/// multiplexa nada: se DETECTA cuál trae la imagen y se corre ése, con sus manías.
1115#[derive(Debug)]
1116struct Gestor {
1117 nombre: &'static str,
1118 guion: String,
1119}
1120
1121/// Comillas simples de shell a prueba de todo: el contenido sale del manifiesto, que lo escribe una
1122/// persona, y un nombre de paquete no tiene por qué ser un token seguro.
1123fn comillar(s: &str) -> String {
1124 format!("'{}'", s.replace('\'', r"'\''"))
1125}
1126
1127fn gestor_de(dir: &Path, tree: &Path, paquetes: &[String]) -> Result<Gestor> {
1128 // Nombres de paquete: se validan ANTES de armar el guión. Quotear alcanza para que no se
1129 // ejecute nada, pero un nombre raro casi siempre es un error de tipeo, y fallar temprano dice
1130 // dónde está mejor que un gestor quejándose de un paquete inexistente.
1131 for p in paquetes {
1132 if p.is_empty()
1133 || !p.chars().all(|c| c.is_ascii_alphanumeric() || "._+-:@/".contains(c))
1134 {
1135 bail!("nombre de paquete raro en `packages`: {p:?} — se aborta antes de armar el guión");
1136 }
1137 }
1138 let lista = paquetes.iter().map(|p| comillar(p)).collect::<Vec<_>>().join(" ");
1139 let hay = |rel: &str| resolver_en_instancia(dir, tree, rel).is_some();
1140
1141 if hay("usr/bin/apt-get") {
1142 return Ok(Gestor { nombre: "apt", guion: format!(
1143 "set -e\n\
1144 export DEBIAN_FRONTEND=noninteractive\n\
1145 apt-get update\n\
1146 apt-get install -y --no-install-recommends {lista}\n")});
1147 }
1148 if hay("usr/bin/pacman") {
1149 // Dos manías del bootstrap de Arch, y ninguna se ve hasta que pacman falla:
1150 // · la mirrorlist viene ENTERA comentada ⇒ «no servers configured for repository»;
1151 // · el llavero no está inicializado ⇒ toda firma es inválida.
1152 // El mirror se elige acá y se dice cuál: es el geo oficial de Arch. Que lo elija la
1153 // herramienta es peor que que lo elija el usuario, pero **no elegir** deja una instancia
1154 // que no instala nada, y el fichero queda a la vista en el `upper` para cambiarlo.
1155 return Ok(Gestor { nombre: "pacman", guion: format!(
1156 "set -e\n\
1157 grep -q '^Server' /etc/pacman.d/mirrorlist 2>/dev/null || {{\n\
1158 \x20 echo 'aviso: mirrorlist vacía — pongo el mirror geo oficial de Arch' >&2\n\
1159 \x20 echo 'Server = https://geo.mirror.pkgbuild.com/$repo/os/$arch' >> /etc/pacman.d/mirrorlist\n\
1160 }}\n\
1161 [ -d /etc/pacman.d/gnupg ] || {{ pacman-key --init; pacman-key --populate archlinux; }}\n\
1162 pacman -Sy --noconfirm --needed {lista}\n")});
1163 }
1164 if hay("usr/bin/dnf") {
1165 return Ok(Gestor { nombre: "dnf", guion: format!(
1166 "set -e\ndnf install -y --setopt=install_weak_deps=False {lista}\n")});
1167 }
1168 if hay("sbin/apk") || hay("usr/bin/apk") {
1169 return Ok(Gestor { nombre: "apk", guion: format!(
1170 "set -e\napk add --no-cache {lista}\n")});
1171 }
1172 bail!(
1173 "no encuentro gestor de paquetes en la instancia (busqué apt-get, pacman, dnf y apk).\n \
1174 Si la imagen usa otro, instalá a mano con `run` — pero entonces `recreate` no lo va a \n \
1175 poder rehacer, y eso es justo lo que D3 dice que no puede pasar."
1176 );
1177}
1178
1179fn provision(root: &Path, id: &str, force: bool, dry_run: bool) -> Result<()> {
1180 let (dir, inst) = read_instance(root, id)?;
1181 let (_, tree) = resolve_image(root, &inst.base)?;
1182 if inst.packages.is_empty() {
1183 println!(
1184 "la instancia {id} no declara `packages`. Se instala lo DECLARADO: es lo que hace que \
1185 la capa mutable sea caché y no el activo."
1186 );
1187 return Ok(());
1188 }
1189
1190 let previo: Option<Provisionado> = std::fs::read_to_string(dir.join(PROVISION_LEDGER))
1191 .ok()
1192 .and_then(|s| toml::from_str(&s).ok());
1193 if let Some(p) = &previo {
1194 if !force && p.packages == inst.packages {
1195 println!(
1196 "ya provisionada con {} ({} paquete(s)) — `--force` para reinstalar",
1197 p.manager, p.packages.len()
1198 );
1199 return Ok(());
1200 }
1201 }
1202
1203 let g = gestor_de(&dir, &tree, &inst.packages)?;
1204 if dry_run {
1205 println!("# gestor detectado: {}", g.nombre);
1206 print!("{}", g.guion);
1207 return Ok(());
1208 }
1209 println!("provisionando {id} con {} — {} paquete(s)", g.nombre, inst.packages.len());
1210 run_instance(root, id, &["/bin/sh".into(), "-c".into(), g.guion.clone()],
1211 Ajustes { provisionando: true, ..Default::default() })?;
1212
1213 let reg = Provisionado {
1214 manager: g.nombre.into(),
1215 packages: inst.packages.clone(),
1216 at_unix: std::time::SystemTime::now()
1217 .duration_since(std::time::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0),
1218 };
1219 std::fs::write(
1220 dir.join(PROVISION_LEDGER),
1221 format!(
1222 "# Lo escribe `hammer qorpa provision`. Es un REGISTRO, no la verdad: la verdad es\n\
1223 # `packages` en instance.toml. Si los dos difieren, gana el manifiesto y se reinstala.\n\
1224 # `at_unix` se lee con `date -u -d @<n>`.\n{}",
1225 toml::to_string_pretty(®).context("serializando el registro")?
1226 ),
1227 )?;
1228 println!("listo: {} paquete(s) instalados con {}", reg.packages.len(), reg.manager);
1229 Ok(())
1230}
1231
1232/// Los directorios INTERMEDIOS de un punto de montaje que la imagen no trae, de arriba hacia abajo.
1233///
1234/// No incluye el punto de montaje en sí: ése lo tapa el `--bind` y hereda los modos del anfitrión.
1235/// Sólo devuelve los que faltan en la imagen, porque `--dir` sobre uno existente le cambiaría los
1236/// permisos a la imagen. Ver el comentario largo en `grants_to_args`.
1237fn ancestros_a_crear(dentro: &str, tree: &Path) -> Vec<String> {
1238 let mut out = Vec::new();
1239 let mut acc = String::new();
1240 let partes: Vec<&str> = dentro.trim_matches('/').split('/').collect();
1241 // `partes.len() - 1`: el último es el punto de montaje, no un ancestro.
1242 for p in partes.iter().take(partes.len().saturating_sub(1)) {
1243 if p.is_empty() { continue; }
1244 acc.push('/');
1245 acc.push_str(p);
1246 if !tree.join(acc.trim_start_matches('/')).is_dir() {
1247 out.push(acc.clone());
1248 }
1249 }
1250 out
1251}
1252
1253/// Traduce las concesiones a argumentos de bwrap. Devuelve también las advertencias que el usuario
1254/// tiene que LEER, no descubrir: el ADR pide que el socket de Wayland se diga en la cara.
1255fn grants_to_args(g: &Grants, destino_xdg: &str, wl: Option<&Path>, tree: &Path) -> (Vec<String>, Vec<String>) {
1256 let mut a: Vec<String> = Vec::new();
1257 let mut warn: Vec<String> = Vec::new();
1258 // Sin dep de libc: el dueño de /proc/self ES el uid efectivo.
1259 let uid = std::fs::metadata("/proc/self")
1260 .map(|m| std::os::unix::fs::MetadataExt::uid(&m))
1261 .unwrap_or(1000);
1262 let xdg = std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| format!("/run/user/{uid}"));
1263
1264 for s in &g.sockets {
1265 let (host, dentro) = match s.as_str() {
1266 "wayland" => {
1267 let d = std::env::var("WAYLAND_DISPLAY").unwrap_or_else(|_| "wayland-0".into());
1268 match wl {
1269 Some(proxy) => (proxy.display().to_string(), format!("{destino_xdg}/wayland-0")),
1270 None => {
1271 warn.push(
1272 "wayland CRUDO (`wayland_raw`): la instancia ve TODOS los globals del \
1273 compositor y podrá CAPTURAR LA PANTALLA, SINTETIZAR TECLAS y LEER EL \
1274 PORTAPAPELES. El proxy filtrante existe; esto lo saltea a propósito."
1275 .into(),
1276 );
1277 (format!("{xdg}/{d}"), format!("{destino_xdg}/wayland-0"))
1278 }
1279 }
1280 }
1281 "pipewire" => (format!("{xdg}/pipewire-0"), format!("{destino_xdg}/pipewire-0")),
1282 "dbus" => (format!("{xdg}/bus"), format!("{destino_xdg}/bus")),
1283 otro => {
1284 warn.push(format!("socket desconocido {otro:?} — ignorado"));
1285 continue;
1286 }
1287 };
1288 a.push("--bind-try".into()); a.push(host); a.push(dentro);
1289 }
1290 for d in &g.devices {
1291 a.push("--dev-bind-try".into()); a.push(d.clone()); a.push(d.clone());
1292 }
1293 for d in &g.dirs {
1294 let host = if let Some(rest) = d.host.strip_prefix('~') {
1295 format!("{}{}", std::env::var("HOME").unwrap_or_default(), rest)
1296 } else { d.host.clone() };
1297 // ── LOS PADRES QUE INVENTA bwrap SON 0700, Y ESO DEJA LA CONCESIÓN FUERA DE ALCANCE ─────
1298 // MEDIDO el 2026-09-15 con `php-fpm` en la instancia `gioser-php`: la concesión estaba
1299 // montada, visible y con sus modos correctos, y el servicio contestaba «File not found».
1300 // La causa no está en el bind sino en el CAMINO: para montar en `/work/www/gioser-web`,
1301 // bwrap crea `/work` y `/work/www` —que no existen en la imagen— y los crea **0700 root**.
1302 // Adentro somos root, así que a mano todo se lee; pero un servicio que BAJA de privilegio
1303 // (php-fpm a `http`, o cualquier instancia con `run_as`) no puede ni atravesarlos. El
1304 // síntoma no se parece a la causa: dice que falta el fichero, y el fichero está.
1305 //
1306 // Se crean explícitamente a 0755 **sólo los que la imagen no trae**: hacerlo sobre un
1307 // directorio que ya existe (`/etc`, `/usr`, `/home`) le cambiaría los modos a la imagen,
1308 // que es justo lo que no se quiere. Misma familia que el `--perms 1777` del `--tmpfs /tmp`.
1309 for ancestro in ancestros_a_crear(&d.inside, tree) {
1310 a.push("--perms".into()); a.push("0755".into());
1311 a.push("--dir".into()); a.push(ancestro);
1312 }
1313 a.push(if d.mode == "rw" { "--bind".into() } else { "--ro-bind".into() });
1314 a.push(host); a.push(d.inside.clone());
1315 }
1316 if g.network {
1317 // El segundo fallo clásico de la primera corrida, según el propio ADR.
1318 a.push("--ro-bind-try".into());
1319 a.push("/etc/resolv.conf".into());
1320 a.push("/etc/resolv.conf".into());
1321 } else {
1322 a.push("--unshare-net".into());
1323 }
1324 (a, warn)
1325}
1326
1327// ── el mapeo por rango (subuid) ──────────────────────────────────────────────────────────────────
1328//
1329// EL PROBLEMA, medido en los pasos anteriores: bwrap crea el user namespace con UN SOLO id mapeado
1330// (`uid_map: 0 1001 1`, `setgroups: deny`). Con eso `apt` no puede bajar a `_apt`, `pacman` no
1331// puede chownear su descarga a `alpm`, y un userns anidado —pressure-vessel— no puede escribir su
1332// propio mapa. Tres síntomas distintos, una sola causa.
1333//
1334// LA CURA: crear el namespace NOSOTROS, mapearle un rango real de `/etc/subuid` con `newuidmap`, y
1335// pasárselo a bwrap con `--userns FD`. bwrap no llama a `newuidmap` a propósito —es un binario con
1336// capability y bwrap no quiere depender de él—, así que el trabajo es de quien lo invoca.
1337//
1338// El namespace lo sostiene un proceso «tenedor» que espera en un fifo: mientras viva, el fd
1339// `/proc/<pid>/ns/user` es válido. La coreografía (hijo avisa por un fifo, padre mapea desde fuera,
1340// hijo sigue) es la misma que ya verifica `scripts/qorpa/qorpa-preflight.sh`.
1341
1342struct Rango { inicio: u32, cantidad: u32 }
1343
1344fn leer_subid(fichero: &str, usuario: &str) -> Option<Rango> {
1345 let txt = std::fs::read_to_string(fichero).ok()?;
1346 txt.lines().find_map(|l| {
1347 let mut c = l.split(':');
1348 let (u, i, n) = (c.next()?, c.next()?, c.next()?);
1349 if u != usuario {
1350 return None;
1351 }
1352 Some(Rango { inicio: i.parse().ok()?, cantidad: n.parse().ok()? })
1353 })
1354}
1355
1356/// La mitad PURA de `nombre_de_usuario`: el primer nombre de `/etc/passwd` con ese uid.
1357fn nombre_en_passwd(passwd: &str, uid: u32) -> Option<String> {
1358 passwd.lines().find_map(|linea| {
1359 let mut c = linea.split(':');
1360 let (nombre, _, u) = (c.next()?, c.next()?, c.next()?);
1361 (u.parse::<u32>().ok()? == uid).then(|| nombre.to_string())
1362 })
1363}
1364
1365/// El nombre del usuario que corre esto, para buscar su rango en `/etc/subuid`.
1366///
1367/// ⚠ MEDIDO el 2026-09-15: esto leía `$USER`/`$LOGNAME` y nada más. Una shell interactiva los trae;
1368/// **un init NO**. Al poner `squid` bajo arje-zero, la tarjeta arrancó con `PATH`, `HOME` y poco
1369/// más, el nombre salió vacío, no hubo rango, y la jaula cayó al **userns de un solo id** — con lo
1370/// que squid murió en `setgid(15): (22) Invalid argument`. El aviso estaba y era correcto («no hay
1371/// rango para "" en /etc/subuid»), pero el servicio se caía en bucle y el error que se veía era el
1372/// de squid, no el nuestro: **la degradación silenciosa la paga el de más abajo**.
1373///
1374/// Ahora el nombre se deriva del **uid real** leyendo `/etc/passwd`, y el entorno es sólo un atajo.
1375/// El uid es el hecho; `$USER` es una etiqueta que cualquiera puede no poner (ver la nota de
1376/// `la-etiqueta-no-es-el-hecho`).
1377fn nombre_de_usuario(uid: u32) -> String {
1378 if let Ok(passwd) = std::fs::read_to_string("/etc/passwd") {
1379 if let Some(n) = nombre_en_passwd(&passwd, uid) {
1380 return n;
1381 }
1382 }
1383 // Último recurso: el entorno. Sirve cuando `/etc/passwd` no describe a este uid (un rootfs
1384 // pelado, un uid prestado), y no estorba cuando sí.
1385 std::env::var("USER")
1386 .or_else(|_| std::env::var("LOGNAME"))
1387 .unwrap_or_default()
1388}
1389
1390/// El namespace vivo, con su tenedor. Al soltarlo, se mata al tenedor y el namespace desaparece.
1391struct UsernsMapeado {
1392 tenedor: std::process::Child,
1393 ns_path: String,
1394 ids: u32,
1395}
1396
1397impl Drop for UsernsMapeado {
1398 fn drop(&mut self) {
1399 // El tenedor sólo existe para sostener el namespace. Si sobreviviera al `run`, dejaríamos
1400 // un proceso colgado por cada instancia arrancada.
1401 let _ = self.tenedor.kill();
1402 let _ = self.tenedor.wait();
1403 }
1404}
1405
1406/// Crea el namespace y le mapea el rango. Devuelve `Err` con la CAUSA exacta: hay tres formas de
1407/// que esto no se pueda, y las tres se arreglan distinto, así que no se colapsan en un "no pude".
1408///
1409/// `uid_dentro` decide quién sos adentro, y **eso lo hace el MAPA, no un flag de bwrap** — que es
1410/// justo lo que permite ser un usuario normal sin renunciar al rango. Hizo falta por Steam: el
1411/// cliente se niega a correr como root (`bin_steam.sh: Error: Cannot run as root user`), así que la
1412/// instancia de juegos NECESITA no ser root, y antes eso costaba el rango entero.
1413fn userns_con_rango(uid_dentro: u32) -> Result<UsernsMapeado> {
1414 let uid = std::fs::metadata("/proc/self")
1415 .map(|m| std::os::unix::fs::MetadataExt::uid(&m))
1416 .unwrap_or(1000);
1417 let gid = std::fs::metadata("/proc/self")
1418 .map(|m| std::os::unix::fs::MetadataExt::gid(&m))
1419 .unwrap_or(1000);
1420 let usuario = nombre_de_usuario(uid);
1421 let ru = leer_subid("/etc/subuid", &usuario)
1422 .with_context(|| format!("no hay rango para {usuario:?} en /etc/subuid"))?;
1423 let rg = leer_subid("/etc/subgid", &usuario)
1424 .with_context(|| format!("no hay rango para {usuario:?} en /etc/subgid"))?;
1425
1426 let tmp = std::env::temp_dir().join(format!("qorpa-userns-{}", std::process::id()));
1427 std::fs::create_dir_all(&tmp)?;
1428 let listo = tmp.join("listo");
1429 let adelante = tmp.join("adelante");
1430 for f in [&listo, &adelante] {
1431 let _ = std::fs::remove_file(f);
1432 let st = Command::new("mkfifo").arg(f).status().context("mkfifo")?;
1433 if !st.success() {
1434 bail!("no pude crear el fifo {}", f.display());
1435 }
1436 }
1437
1438 let tenedor = Command::new("unshare")
1439 .arg("-U")
1440 .arg("sh")
1441 .arg("-c")
1442 .arg(format!(
1443 "echo r > {l}; read _ < {a}",
1444 l = listo.display(), a = adelante.display()
1445 ))
1446 .spawn()
1447 .context("no pude ejecutar `unshare -U` — ¿está util-linux?")?;
1448 let pid = tenedor.id();
1449 let mut guard = UsernsMapeado {
1450 tenedor,
1451 ns_path: format!("/proc/{pid}/ns/user"),
1452 ids: 1 + ru.cantidad,
1453 };
1454
1455 // Bloquea hasta que el hijo esté DENTRO del namespace. Sin este apretón de manos mapearíamos
1456 // el namespace del padre, que es el del host.
1457 std::fs::read_to_string(&listo).context("el tenedor no llegó al fifo")?;
1458
1459 // Los tramos del mapa. Con `uid_dentro = 0` es el caso simple (somos root adentro y el resto
1460 // del rango va detrás). Con cualquier otro, hay que partir el rango en tres para dejar hueco:
1461 // los ids de abajo (incluido el 0, que tiene que EXISTIR para que la imagen tenga dueño de
1462 // ficheros) salen del subuid, nosotros caemos en `uid_dentro`, y el resto sigue arriba.
1463 let tramos = move |id_afuera: u32, r: &Rango| -> Vec<String> {
1464 if uid_dentro == 0 {
1465 vec!["0".into(), id_afuera.to_string(), "1".into(),
1466 "1".into(), r.inicio.to_string(), r.cantidad.to_string()]
1467 } else {
1468 let bajos = uid_dentro.min(r.cantidad);
1469 let altos = r.cantidad.saturating_sub(bajos + 1);
1470 let mut v = vec![
1471 "0".into(), r.inicio.to_string(), bajos.to_string(),
1472 uid_dentro.to_string(), id_afuera.to_string(), "1".into(),
1473 ];
1474 if altos > 0 {
1475 v.extend([(uid_dentro + 1).to_string(), (r.inicio + bajos).to_string(),
1476 altos.to_string()]);
1477 }
1478 v
1479 }
1480 };
1481
1482 let mapear = |bin: &str, id: u32, r: &Rango| -> Result<()> {
1483 let mut argv = vec![pid.to_string()];
1484 argv.extend(tramos(id, r));
1485 let out = Command::new(bin)
1486 .args(&argv)
1487 .output()
1488 .with_context(|| format!("no pude ejecutar {bin}"))?;
1489 if !out.status.success() {
1490 bail!("{bin}: {}", String::from_utf8_lossy(&out.stderr).trim());
1491 }
1492 Ok(())
1493 };
1494 mapear("newuidmap", uid, &ru)?;
1495 mapear("newgidmap", gid, &rg)?;
1496
1497 // Soltar al tenedor: ya mapeado, se queda esperando el fifo (que nadie escribirá) hasta que lo
1498 // matemos. Lo que importa es que el proceso VIVA, no lo que haga.
1499 let _ = std::fs::remove_file(&listo);
1500 let _ = std::fs::remove_file(&adelante);
1501 guard.ids = 1 + ru.cantidad;
1502 Ok(guard)
1503}
1504
1505/// Lo que NO viene del manifiesto: banderas de la invocación. Van juntas para que agregar una no
1506/// mueva la firma de media docena de llamadas.
1507#[derive(Default, Clone, Copy)]
1508struct Ajustes {
1509 dry_run: bool,
1510 no_jail: bool,
1511 single_id: bool,
1512 /// Modo `provision`: la política declarada se ENSANCHA para poder instalar, y sólo mientras
1513 /// dura la instalación. Ver `provision()` — lo que se ensancha y por qué se dice en voz alta.
1514 provisionando: bool,
1515 /// Levanta el lector de audit y recoge el veredicto. Ver `preparar_evidencia`.
1516 evidencia: bool,
1517}
1518
1519/// Quién tiene el overlay de esta instancia montado **en su propio namespace**.
1520///
1521/// ══ POR QUÉ HACE FALTA, Y QUÉ COSTÓ NO TENERLO ════════════════════════════════════════════════
1522/// El mensaje de abajo preguntaba «¿Hay otra `qorpa run <id>` viva?», y el 2026-10-13 la respuesta
1523/// fue **NO** y el overlay estaba tomado igual. Lo tenía un **nieto fugado**: un `minga host`
1524/// —demonio del espejo de tawasuyu— que alguien arrancó DENTRO de la jaula, que sobrevivió a su
1525/// sesión reparentado a pid 1, y que al seguir vivo mantiene vivo el **namespace de montaje** de la
1526/// jaula… y con él el overlay. El `qorpa run` que lo creó ya no existe, así que la pregunta del
1527/// mensaje llevaba a buscar donde no estaba.
1528///
1529/// Es el mismo patrón que el `flock` de `CLAUDE.md`: *el recurso lo retiene algo que nadie asocia
1530/// con el recurso*. Ahí la respuesta fue `fuser -v <lock>`; acá no hay `fuser` que valga —el mount
1531/// vive en otro namespace y `/proc/mounts` del anfitrión no lo ve— así que se recorre
1532/// `/proc/*/mountinfo`, que sí.
1533///
1534/// Devuelve `(pid, comm, cmdline recortada)`. Vacío significa que de verdad no hay nadie: entonces
1535/// el EBUSY es otra cosa y el mensaje lo dice así en vez de culpar a un proceso inexistente.
1536fn quien_retiene_overlay(id: &str) -> Vec<(String, String, String)> {
1537 let yo = std::process::id().to_string();
1538 let mut fuera = Vec::new();
1539 let Ok(entradas) = std::fs::read_dir("/proc") else {
1540 return fuera;
1541 };
1542 for e in entradas.flatten() {
1543 let pid = e.file_name().to_string_lossy().to_string();
1544 if pid == yo || !pid.chars().all(|c| c.is_ascii_digit()) {
1545 continue;
1546 }
1547 // `mountinfo` y no `mounts`: el primero es por-proceso y muestra SU namespace, que es
1548 // justo donde se esconde el montaje que el anfitrión no ve.
1549 let Ok(mi) = std::fs::read_to_string(format!("/proc/{pid}/mountinfo")) else {
1550 continue;
1551 };
1552 if !mi.contains(id) {
1553 continue;
1554 }
1555 let comm = std::fs::read_to_string(format!("/proc/{pid}/comm"))
1556 .unwrap_or_default()
1557 .trim()
1558 .to_string();
1559 let cmd = std::fs::read("/proc/".to_string() + &pid + "/cmdline")
1560 .map(|b| {
1561 b.split(|&c| c == 0)
1562 .filter(|s| !s.is_empty())
1563 .map(|s| String::from_utf8_lossy(s).to_string())
1564 .collect::<Vec<_>>()
1565 .join(" ")
1566 })
1567 .unwrap_or_default();
1568 let cmd: String = cmd.chars().take(100).collect();
1569 fuera.push((pid, comm, cmd));
1570 if fuera.len() >= 6 {
1571 break;
1572 }
1573 }
1574 fuera
1575}
1576
1577fn run_instance(
1578 root: &Path, id: &str, cmd: &[String], aj: Ajustes,
1579) -> Result<()> {
1580 let Ajustes { dry_run, no_jail, single_id, provisionando, evidencia: _ } = aj;
1581 let (dir, mut inst) = read_instance(root, id)?;
1582 let (sha, tree) = resolve_image(root, &inst.base)?;
1583
1584 // ── LA POLÍTICA SE ENSANCHA PARA PROVISIONAR, Y SE DICE ────────────────────────────────────
1585 // Instalar paquetes pide exactamente las tres cosas que una instancia bien declarada NO tiene:
1586 // red (los paquetes se bajan), root (el gestor chownea y escribe en /usr) y la imagen sin
1587 // sellar (lo que instala va a /usr por definición). Ensancharlas en silencio sería la falla
1588 // que el ADR llama por su nombre en D7: la política se AUTORA. Así que se ensancha sólo aquí,
1589 // sólo mientras dura el `provision`, y se imprime en la cara — el manifiesto NO se toca, y el
1590 // siguiente `run` vuelve a la política escrita.
1591 if provisionando {
1592 let mut abierto: Vec<&str> = Vec::new();
1593 if !inst.grants.network { abierto.push("red"); inst.grants.network = true; }
1594 if !inst.grants.root { abierto.push("root"); inst.grants.root = true; }
1595 if inst.grants.seal_image { abierto.push("imagen sin sellar"); inst.grants.seal_image = false; }
1596 if inst.run_as.is_some() { abierto.push("como root, no `run_as`"); inst.run_as = None; }
1597 if !abierto.is_empty() {
1598 eprintln!(
1599 "⚠ provision ENSANCHA la política sólo para esta operación: {}. El manifiesto no \n\
1600 \x20 cambia y el próximo `run` vuelve a lo declarado.",
1601 abierto.join(", ")
1602 );
1603 }
1604 }
1605
1606 // Quién sos adentro. Con el mapeo por rango esto NO cuesta el rango: lo decide el propio mapa.
1607 // ⚠ Cambiarlo en una instancia YA USADA la corrompe: los ficheros del `upper` quedaron con los
1608 // uids del mapa anterior. Para correr como usuario normal está `run_as`, que no toca el mapa.
1609 let uid_dentro: u32 = if inst.grants.root { 0 } else { 1000 };
1610 // El XDG_RUNTIME_DIR es del usuario que CORRE, no del uid del mapa: con `run_as`, apuntarlo al
1611 // de root deja a las herramientas del Steam Runtime sin poder crear su temporal
1612 // (`srt-logger: g_mkdtemp: Permission denied`), y eso se lee como un aviso menor hasta que algo
1613 // deja de andar sin explicar por qué.
1614 let uid_corre = match &inst.run_as {
1615 Some(u) => usuario_de(&dir, &tree, u).map(|(x, _, _)| x).unwrap_or(uid_dentro),
1616 None => uid_dentro,
1617 };
1618 let runtime_dir = format!("/run/user/{uid_corre}");
1619
1620 // El proxy vive mientras viva este proceso, que es exactamente lo que dura la instancia.
1621 // `_proxy` se mantiene en scope a propósito.
1622 let mut proxy_sock: Option<PathBuf> = None;
1623 let _proxy = if inst.grants.sockets.iter().any(|s| s == "wayland") && !inst.grants.wayland_raw {
1624 let xdg = std::env::var("XDG_RUNTIME_DIR")
1625 .unwrap_or_else(|_| format!("/run/user/{}", uid_corre));
1626 let d = std::env::var("WAYLAND_DISPLAY").unwrap_or_else(|_| "wayland-0".into());
1627 let real = PathBuf::from(format!("{xdg}/{d}"));
1628 if !real.exists() {
1629 bail!("la instancia pide `wayland` pero no hay compositor en {}", real.display());
1630 }
1631 let permitidos: std::collections::HashSet<String> = if inst.grants.wayland_globals.is_empty() {
1632 crate::qorpa_wl::GLOBALS_PERMITIDOS.iter().map(|s| s.to_string()).collect()
1633 } else {
1634 inst.grants.wayland_globals.iter().cloned().collect()
1635 };
1636 let n = permitidos.len();
1637 let p = crate::qorpa_wl::arrancar(&dir.join("wl"), &real, permitidos)
1638 .context("no pude arrancar el proxy de Wayland")?;
1639 eprintln!(" wayland: proxy filtrante puesto — {n} global(s) visibles, el resto no existe \
1640 para la instancia");
1641 proxy_sock = Some(p.socket.clone());
1642 Some(p)
1643 } else {
1644 None
1645 };
1646 let (grant_args, warns) = grants_to_args(&inst.grants, &runtime_dir, proxy_sock.as_deref(), &tree);
1647
1648 // El orden importa: `--overlay-src` describe la capa BAJA del `--overlay` que viene justo
1649 // después. Y `--clearenv` va primero porque el entorno del host también es una concesión: lo
1650 // que no se declara, no entra (D2, "por defecto NADA").
1651 // El mapeo por rango se intenta SIEMPRE que se pueda: es lo que quita el impuesto de
1652 // `apt`/`pacman` y lo que permite anidar. `root = false` lo descarta porque ser otro-que-root
1653 // adentro pide el `--uid` de bwrap, que exige `--unshare-user` y ése es incompatible con
1654 // `--userns`. Cuando no se puede, se dice POR QUÉ y se sigue con un id: degradar en silencio
1655 // haría que "no anda adentro" fuese un misterio en vez de una línea.
1656 let mut mapeado: Option<UsernsMapeado> = None;
1657 if !single_id {
1658 match userns_con_rango(uid_dentro) {
1659 Ok(m) => mapeado = Some(m),
1660 Err(e) => eprintln!(
1661 "⚠ sin mapeo por rango ({e:#}) ⇒ un solo id adentro. Consecuencias MEDIDAS: `apt` \
1662 no baja a `_apt`, `pacman` no chownea su descarga, y un userns anidado no puede \
1663 escribir su mapa. Diagnóstico: scripts/qorpa/qorpa-preflight.sh"
1664 ),
1665 }
1666 }
1667
1668 let mut args: Vec<String> = vec![
1669 "--unshare-ipc", "--unshare-uts", "--unshare-cgroup-try",
1670 "--hostname", "qorpa",
1671 "--clearenv",
1672 "--die-with-parent",
1673 ].into_iter().map(String::from).collect();
1674 // El árbol de procesos propio se arma salvo que la instancia pida compartir el del host
1675 // (`host_pids`). Va al FRENTE para no cambiar el orden que tenían las banderas.
1676 if !inst.grants.host_pids {
1677 args.insert(0, "--unshare-pid".into());
1678 }
1679 if mapeado.is_none() {
1680 // bwrap crea el suyo, con un solo id.
1681 args.insert(0, "--unshare-user".into());
1682 if inst.grants.root {
1683 args.extend(["--uid", "0", "--gid", "0"].map(String::from));
1684 }
1685 }
1686 if inst.grants.root {
1687 for c in CAPS_ROOT {
1688 args.push("--cap-add".into());
1689 args.push((*c).to_string());
1690 }
1691 if inst.grants.nesting {
1692 // La que permite montar. Sólo con la concesión declarada.
1693 args.push("--cap-add".into());
1694 args.push("CAP_SYS_ADMIN".into());
1695 }
1696 }
1697
1698 args.push("--overlay-src".into()); args.push(tree.display().to_string());
1699 args.push("--overlay".into());
1700 args.push(dir.join("upper").display().to_string());
1701 args.push(dir.join("work").display().to_string());
1702 args.push("/".into());
1703
1704 // /proc y /dev van DESPUÉS del overlay: son del kernel, no de la imagen.
1705 // `--perms 1777` antes del `--tmpfs /tmp` no es cosmético: bwrap lo crearía 0755 y entonces el
1706 // `_apt` (uid 42) al que apt baja para bajar paquetes no puede escribir su fichero temporal.
1707 // Un /tmp que no es 1777 no es /tmp.
1708 args.extend(["--proc", "/proc", "--dev", "/dev",
1709 "--perms", "1777", "--tmpfs", "/tmp"].map(String::from));
1710 args.extend(["--dir".to_string(), runtime_dir.clone(), "--chdir".into(), "/".into()]);
1711 // El HOME sale del /etc/passwd de la IMAGEN, no de una constante: si la instancia creó un
1712 // usuario, su home es el que ese fichero dice. Un HOME que no existe hace que media app se
1713 // comporte raro sin decir por qué.
1714 let home = home_de(&dir, &tree, uid_dentro);
1715 args.extend([
1716 "--setenv", "PATH", "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1717 "--setenv", "HOME", &home,
1718 "--setenv", "TERM", &std::env::var("TERM").unwrap_or_else(|_| "xterm".into()),
1719 ].map(String::from));
1720 args.extend(["--setenv".to_string(), "XDG_RUNTIME_DIR".into(), runtime_dir.clone()]);
1721 args.extend(grant_args);
1722
1723 let mut cmd: Vec<String> = if cmd.is_empty() {
1724 vec!["/bin/sh".into()] // toda imagen trae uno; bash puede no estar.
1725 } else { cmd.to_vec() };
1726
1727 // Bajar de privilegio ADENTRO, con el mapa intacto. `setpriv` viene en util-linux, que trae
1728 // toda imagen de distro; si faltara, se dice en vez de correr como root en silencio — que sería
1729 // exactamente lo que el manifiesto pidió no hacer.
1730 if let Some(usuario) = &inst.run_as {
1731 let (uid_u, gid_u, home_u) = usuario_de(&dir, &tree, usuario).with_context(|| {
1732 format!("`run_as = {usuario:?}` pero no existe en el /etc/passwd de la instancia")
1733 })?;
1734 // Un prelude MÍNIMO como root para darle su runtime dir al usuario, y después `exec`: el
1735 // `"$@"` evita entrecomillar el comando del usuario, que es donde estos wrappers se rompen.
1736 let mut env = vec![
1737 "/bin/sh".to_string(), "-c".into(),
1738 "chown \"$1\":\"$2\" \"$3\" 2>/dev/null; shift 3; exec \"$@\"".into(),
1739 "qorpa".into(), uid_u.to_string(), gid_u.to_string(), runtime_dir.clone(),
1740 "setpriv".into(), "--reuid".into(), uid_u.to_string(),
1741 "--regid".into(), gid_u.to_string(), "--init-groups".into(), "--".into(),
1742 ];
1743 env.extend(cmd);
1744 cmd = env;
1745 // El HOME tiene que ser el SUYO, no el de root: media app se comporta raro sin decir por qué.
1746 if let Some(i) = args.iter().position(|a| a == "HOME") {
1747 args[i + 1] = home_u;
1748 }
1749 }
1750
1751 // ── EL CANAL DE EVIDENCIA ──────────────────────────────────────────────────────────────────
1752 // De un binario ajeno no hay fuente que leer. Lo único que queda para saber qué intentó hacer
1753 // es lo que el kernel le NEGÓ y anotó — por eso el ADR lo llama «la única forma de auditar el
1754 // montón B». El lector (`harkaq-audit`) vive en el HOST, fuera de bwrap, porque el audit no
1755 // está namespaceado; se levanta ANTES para no perderse las primeras denegaciones.
1756 let mut ev: Option<Evidencia> = None;
1757 if aj.evidencia && !dry_run {
1758 let e = preparar_evidencia(&dir, id, no_jail, &inst.grants)?;
1759 args.push("--ro-bind".into());
1760 args.push(e.canario_src.display().to_string());
1761 args.push(e.canario.clone());
1762 // El canario se lee ADENTRO y su denegación es lo que revela el `domain=` del dominio
1763 // Landlock, que es un número que nadie puede adivinar desde fuera. Sin esto el lector no
1764 // sabe cuáles de todas las denegaciones del sistema son de ESTA instancia.
1765 let mut w = vec![
1766 "/bin/sh".to_string(), "-c".into(),
1767 // El `{ …; } 2>/dev/null` NO es lo mismo que `read _ < "$1" 2>/dev/null`: las
1768 // redirecciones se aplican de izquierda a derecha, así que en la segunda forma el
1769 // fallo de la entrada se reporta ANTES de silenciar stderr y el usuario ve un
1770 // «Permission denied» que parece un error suyo y es el canario funcionando.
1771 "{ read _ < \"$1\"; } 2>/dev/null || true; shift; exec \"$@\"".into(),
1772 "qorpa".into(), e.canario.clone(),
1773 ];
1774 w.extend(cmd);
1775 cmd = w;
1776 ev = Some(e);
1777 }
1778
1779 // harkaq va como ÚLTIMO eslabón antes del comando, igual que en el sandbox del build: bwrap ya
1780 // puso los namespaces y el overlay, y esto pone el grano fino. Cruza el borde un binario
1781 // ESTÁTICO — no una librería —, así que sigue valiendo D2: lo único que comparte con el host
1782 // es la ABI del kernel.
1783 if !no_jail {
1784 let exec = harkaq_exec();
1785 if !exec.exists() {
1786 bail!(
1787 "no encuentro harkaq-exec en {} ni en /usr/bin — la instancia NO va a correr \
1788 enjaulada y eso no se hace en silencio.\n instalalo: está en `perfil.base` como \
1789 receta `harkaq-exec`; en una caja instalada, `takana upgrade`.\n o construilo: \
1790 gcc -O1 -Wall -static -o {} scripts/harkaq/harkaq-exec.c (sólo en el árbol de \
1791 desarrollo)\n o corré con --no-jail si sabés lo que estás haciendo.",
1792 exec.display(), exec.display()
1793 );
1794 }
1795 let policy = dir.join("policy");
1796 compile_policy(&inst.grants, &tree, &policy)?;
1797
1798 args.push("--ro-bind".into()); args.push(exec.display().to_string());
1799 args.push("/run/qorpa/harkaq-exec".into());
1800 args.push("--ro-bind".into()); args.push(policy.display().to_string());
1801 args.push("/run/qorpa/policy".into());
1802
1803 let mut envoltura: Vec<String> = vec![
1804 "/run/qorpa/harkaq-exec".into(), "--policy".into(), "/run/qorpa/policy".into(),
1805 ];
1806 if inst.grants.nesting {
1807 // MEDIDO: seccomp no alcanza. Un dominio Landlock activo hace fallar `mount` con
1808 // EACCES aunque el filtro lo permita — el kernel no admite montajes nuevos bajo un
1809 // dominio, porque escaparían de sus reglas por-ruta. ⇒ anidar cuesta la política de
1810 // ficheros. Seccomp y no_new_privs siguen puestos, que es lo que más pesa con un
1811 // binario ajeno, y el confinamiento de fs queda en el namespace de montaje de bwrap,
1812 // que ya es una lista blanca.
1813 envoltura.push("--allow-nesting".into());
1814 envoltura.push("--no-landlock".into());
1815 }
1816 envoltura.push("--".into());
1817 envoltura.extend(cmd);
1818 cmd = envoltura;
1819 } else {
1820 eprintln!("⚠ --no-jail: SIN Landlock, SIN seccomp, SIN no_new_privs. Sólo los namespaces \
1821 de bwrap. No es el modo normal.");
1822 }
1823 args.extend(cmd.iter().cloned());
1824
1825 for w in &warns {
1826 eprintln!("⚠ {w}");
1827 }
1828 if dry_run {
1829 if let Some(m) = &mapeado {
1830 println!("# el userns lo creamos nosotros y le mapeamos {} ids:", m.ids);
1831 println!("# exec 3<{} ⇒ bwrap --userns 3 …", m.ns_path);
1832 }
1833 // Una línea por concesión, no una por token: el punto de `--dry-run` es que se LEA.
1834 let mut linea = String::from("bwrap");
1835 for a in &args {
1836 if a.starts_with("--") { println!("{linea} \\"); linea = format!(" {a}"); }
1837 else { linea.push(' '); linea.push_str(a); }
1838 }
1839 println!("{linea}");
1840 return Ok(());
1841 }
1842 eprintln!("qorpa {id} · sha256:{} · red={} · {} socket(s), {} device(s), {} dir(s) · \
1843 jaula={} · imagen={}",
1844 &sha[..12], inst.grants.network, inst.grants.sockets.len(),
1845 inst.grants.devices.len(), inst.grants.dirs.len(),
1846 if no_jail { "NO" } else if inst.grants.nesting { "sí (anidamiento permitido)" } else { "sí" },
1847 if inst.grants.seal_image { "sellada" } else { "escribible" });
1848 eprintln!(" ids mapeados: {}",
1849 match &mapeado { Some(m) => m.ids.to_string(), None => "1 (sin rango)".into() });
1850
1851 // Cuando el namespace es nuestro hay que pasarle a bwrap un fd ABIERTO, y un fd sólo cruza el
1852 // `exec` si no es CLOEXEC. En vez de arrastrar una dep de C para un `fcntl`, lo abre la shell:
1853 // sus redirecciones no son CLOEXEC por definición, y de paso el `--dry-run` puede mostrar
1854 // exactamente lo que pasa.
1855 // ── EL OVERLAY PUEDE SEGUIR TOMADO POR LA CORRIDA ANTERIOR ─────────────────────────────────
1856 // MEDIDO: dos `run` seguidos sobre la MISMA instancia y el segundo muere con
1857 // `bwrap: Can't make overlay mount … Device or resource busy`; el tercero anda.
1858 //
1859 // No es un capricho de overlayfs: el kernel se NIEGA a montar dos overlays vivos que compartan
1860 // `upperdir`/`workdir` porque eso corrompe la capa. O sea que el EBUSY es un GUARDIÁN, no una
1861 // molestia — lo que está mal es el momento: la corrida anterior ya devolvió el prompt y su
1862 // namespace todavía no terminó de reaparse, así que el usuario ve una denegación correcta por
1863 // una razón que ya no existe. Se reintenta acotado; si de verdad hay otra `run` viva, los
1864 // reintentos se agotan y se dice cuál es la causa en vez de dejar el mensaje crudo de bwrap.
1865 const INTENTOS: u32 = 6;
1866 let mut st = None;
1867 for intento in 1..=INTENTOS {
1868 let (status, overlay_tomado) = lanzar_bwrap(&mapeado, &args)?;
1869 if status.success() || !overlay_tomado {
1870 st = Some(status);
1871 break;
1872 }
1873 if intento == INTENTOS {
1874 // NO se adivina quién lo tiene: se mira. El mensaje viejo preguntaba por otra
1875 // `qorpa run` y el culpable medido fue un demonio nieto en el namespace de la jaula
1876 // muerta, así que la pregunta mandaba a buscar donde no estaba.
1877 let culpables = quien_retiene_overlay(&id);
1878 let detalle = if culpables.is_empty() {
1879 // Cada línea suelta, sin `\` de continuación: el `\` arrastra la sangría del
1880 // FUENTE al mensaje y el aviso salía escalonado en la terminal.
1881 [
1882 " y NADIE lo tiene montado: ningún proceso tiene este overlay en su",
1883 " `mountinfo`. Entonces el EBUSY no es otra corrida — mirá si el `upper`",
1884 " o el `work` quedaron en un estado raro, o si el namespace que lo montó",
1885 " acaba de morir y el kernel todavía no lo soltó.",
1886 ]
1887 .join("\n")
1888 } else {
1889 let mut t = String::from(" lo retiene(n), con el overlay en SU namespace de montaje:\n");
1890 for (pid, comm, cmd) in &culpables {
1891 t.push_str(&format!(" pid {pid:<8} {comm:<16} {cmd}\n"));
1892 }
1893 t.push_str(" Suele ser un NIETO FUGADO: un demonio arrancado dentro de la jaula\n");
1894 t.push_str(" que sobrevivió a su sesión y mantiene vivo su namespace de montaje.\n");
1895 t.push_str(" Si no lo necesitás, `kill <pid>` libera el overlay. Matalo POR PID,\n");
1896 t.push_str(" nunca con `pkill -f`, que se lleva tu propia shell por delante.");
1897 t
1898 };
1899 bail!(
1900 "el overlay de `{id}` sigue tomado tras {INTENTOS} intentos.\n\
1901 Dos overlays con el mismo `upper` corromperían la capa mutable, y por eso el\n\
1902 kernel lo niega.\n{detalle}"
1903 );
1904 }
1905 eprintln!(" el overlay lo tiene todavía la corrida anterior — reintento {intento}/{INTENTOS}");
1906 std::thread::sleep(std::time::Duration::from_millis(200 * u64::from(intento)));
1907 }
1908 let st = st.expect("el bucle sale con estado o con bail");
1909 if let Some(e) = ev {
1910 recoger_evidencia(&dir, e)?;
1911 }
1912 match st.code() {
1913 Some(0) => Ok(()),
1914 Some(c) => std::process::exit(c),
1915 None => bail!("la instancia murió por señal"),
1916 }
1917}
1918
1919// ── el canal de evidencia (D9 punto 3) ──────────────────────────────────────────────────────────
1920//
1921// LO QUE HACE ÚNICO A ESTE CANAL: con nuestros propios builds, si algo toca lo que no debe, está
1922// la receta y la fuente para mirar. Con un binario ajeno no hay nada que leer. Lo que el kernel
1923// deniega y anota es LA ÚNICA superficie observable — el ADR lo dice así en D9.
1924//
1925// Tres piezas, y ninguna sobra:
1926// · el LECTOR vive en el host, fuera de bwrap: el audit no está namespaceado y los registros
1927// cruzan igual. Se levanta ANTES de la instancia o se pierde el principio.
1928// · el CANARIO es un fichero en un sitio que la política NO alcanza. Al leerlo, el kernel emite
1929// una denegación con el `domain=` de este dominio Landlock — un número que desde fuera no se
1930// puede adivinar. Sin canario, el lector no sabe cuáles de todas las denegaciones del sistema
1931// son de esta instancia.
1932// · el VEREDICTO se gana: `denials=[]` sólo vale si el canario se vio Y el contador del kernel
1933// cuadra. Si no, el estado es `SinEvidencia`, que es distinto de «limpio».
1934
1935const EVIDENCE_FILE: &str = "evidence.json";
1936
1937struct Evidencia {
1938 canario: String,
1939 canario_src: PathBuf,
1940 veredicto: PathBuf,
1941 lector: std::process::Child,
1942}
1943
1944fn preparar_evidencia(dir: &Path, id: &str, no_jail: bool, g: &Grants) -> Result<Evidencia> {
1945 // ── LAS TRES CONDICIONES, Y POR QUÉ SE FALLA EN VEZ DE SEGUIR ──────────────────────────────
1946 // Si alguna falta, el lector devolvería `denials=[]` y eso se leería como «la instancia no
1947 // intentó nada raro», cuando la verdad sería «no había forma de enterarse». Un instrumento que
1948 // no puede medir tiene que decirlo, no marcar cero.
1949 if no_jail {
1950 bail!("`--evidence` con `--no-jail` no tiene sentido: sin jaula no hay dominio Landlock y \
1951 no hay nada que el kernel pueda anotar");
1952 }
1953 if g.nesting {
1954 bail!(
1955 "`nesting` apaga Landlock (D9, conflicto 1: el kernel no admite montajes nuevos bajo \n \
1956 un dominio) ⇒ o la instancia anida o se audita, no las dos. Para auditar Steam hay \n \
1957 que mirar la instancia SIN pressure-vessel."
1958 );
1959 }
1960 if !g.seal_image {
1961 bail!(
1962 "sin `seal_image` la política de una instancia es UNA línea, `rw /` ⇒ no hay NADA que \n \
1963 el kernel pueda denegar, y el veredicto diría `denials=[]` por construcción y no por \n \
1964 mérito. Encendé `seal_image = true` en el manifiesto y volvé a correr."
1965 );
1966 }
1967
1968 let bin = harkaq_exec().parent().unwrap_or(Path::new(".")).join("harkaq-audit");
1969 if !bin.exists() {
1970 bail!(
1971 "no encuentro harkaq-audit en {}\n \
1972 construilo: gcc -O1 -Wall -o {} scripts/harkaq/harkaq-audit.c\n \
1973 y dale las capabilities: sudo setcap cap_audit_read,cap_audit_control+ep {}",
1974 bin.display(), bin.display(), bin.display()
1975 );
1976 }
1977
1978 // El canario va en la RAÍZ. Con `seal_image` la política concede `list /` y nada más sobre la
1979 // raíz misma, así que un fichero ahí se puede LISTAR pero no LEER: la denegación es exacta.
1980 // En cualquier directorio con `rw` —/etc, /var, /tmp— se leería sin ruido y el canario sería
1981 // mudo, que es la misma trampa que ya documenta el canario del build.
1982 let canario = format!("/harkaq-canary-{id}-{}", std::process::id());
1983 let canario_src = dir.join("canary");
1984 std::fs::write(&canario_src, b"harkaq\n")
1985 .with_context(|| format!("escribiendo el canario {}", canario_src.display()))?;
1986
1987 let veredicto = dir.join(EVIDENCE_FILE);
1988 let vf = std::fs::File::create(&veredicto)
1989 .with_context(|| format!("creando {}", veredicto.display()))?;
1990 let lector = Command::new(&bin)
1991 .arg("--canary").arg(&canario)
1992 .arg("--timeout").arg(std::env::var("HARKAQ_TIMEOUT").unwrap_or_else(|_| "1800".into()))
1993 .stdout(std::process::Stdio::from(vf))
1994 .stderr(std::process::Stdio::inherit())
1995 .spawn()
1996 .with_context(|| format!("no pude lanzar {}", bin.display()))?;
1997 // El lector tiene que estar en el multicast antes de que arranque la instancia: si no, sus
1998 // primeras denegaciones —el canario entre ellas— se emiten sin nadie del otro lado y el
1999 // veredicto sale `SinEvidencia` por una carrera y no por un problema real.
2000 std::thread::sleep(std::time::Duration::from_millis(300));
2001 eprintln!(" evidencia: lector puesto, canario {canario}");
2002 Ok(Evidencia { canario, canario_src, veredicto, lector })
2003}
2004
2005fn recoger_evidencia(dir: &Path, mut e: Evidencia) -> Result<()> {
2006 // Gracia para que llegue el `deallocated` del dominio: el kernel lo emite con retraso (RCU),
2007 // y es lo que le permite al lector comparar su conteo contra el del kernel.
2008 std::thread::sleep(std::time::Duration::from_millis(1500));
2009 let _ = nix::sys::signal::kill(
2010 nix::unistd::Pid::from_raw(e.lector.id() as i32),
2011 nix::sys::signal::Signal::SIGTERM,
2012 );
2013 let salida = e.lector.wait().ok().and_then(|s| s.code());
2014 let _ = std::fs::remove_file(&e.canario_src);
2015
2016 let txt = std::fs::read_to_string(&e.veredicto).unwrap_or_default();
2017 // Un veredicto VACÍO no es un veredicto: es el lector que no llegó a emitir. Se dice con su
2018 // código de salida, que es el único dato que queda — un `SinEvidencia` mudo manda a buscar el
2019 // problema en el sitio equivocado.
2020 if txt.trim().is_empty() {
2021 println!(
2022 "evidencia: SIN EVIDENCIA — el lector no emitió veredicto (salió con {}). NO quiere \
2023 decir «limpio».\n Comprobá: getcap {}",
2024 salida.map(|c| c.to_string()).unwrap_or_else(|| "señal".into()),
2025 harkaq_exec().parent().unwrap_or(Path::new(".")).join("harkaq-audit").display(),
2026 );
2027 return Ok(());
2028 }
2029 let v: serde_json::Value = serde_json::from_str(txt.trim()).unwrap_or(serde_json::Value::Null);
2030 let estado = v.get("estado").and_then(|x| x.as_str()).unwrap_or("SinEvidencia");
2031 let denials = v.get("denials").and_then(|x| x.as_array()).map(|a| a.len()).unwrap_or(0);
2032 match estado {
2033 "Hermetico" => println!("evidencia: HERMÉTICO — 0 denegaciones, y el canario las respalda"),
2034 "Impuro" => {
2035 println!("evidencia: IMPURO — {denials} denegación(es); esto es el diagnóstico, no el fallo");
2036 for d in v["denials"].as_array().into_iter().flatten().take(12) {
2037 println!(" {} · {}",
2038 d.get("blockers").and_then(|x| x.as_str()).unwrap_or("?"),
2039 d.get("path").and_then(|x| x.as_str()).unwrap_or("?"));
2040 }
2041 if denials > 12 { println!(" … y {} más en {}", denials - 12, e.veredicto.display()); }
2042 }
2043 _ => println!(
2044 "evidencia: SIN EVIDENCIA — {}. NO quiere decir «limpio»: quiere decir que no se pudo \
2045 saber.",
2046 v.get("motivo").and_then(|x| x.as_str()).unwrap_or("el lector no dejó motivo")
2047 ),
2048 }
2049 println!(" veredicto completo: {}", e.veredicto.display());
2050 let _ = dir;
2051 Ok(())
2052}
2053
2054/// Lanza bwrap y devuelve su estado junto con **si el fallo fue el overlay tomado**.
2055///
2056/// El stderr se PASA A TRAVÉS mientras se mira, byte a byte y sin esperar renglones: hay que leerlo
2057/// para distinguir ese fallo de cualquier otro, pero tragárselo sería peor que el bug —adentro
2058/// corre un shell interactivo y su prompt sale por stderr sin salto de línea—. Sólo se guardan los
2059/// primeros KB para buscar la firma; el resto se reenvía y se olvida.
2060fn lanzar_bwrap(
2061 mapeado: &Option<UsernsMapeado>, args: &[String],
2062) -> Result<(std::process::ExitStatus, bool)> {
2063 let mut c = match mapeado {
2064 Some(m) => {
2065 let mut c = Command::new("sh");
2066 c.arg("-c")
2067 .arg(r#"exec 3<"$1"; shift; exec bwrap --userns 3 "$@""#)
2068 .arg("qorpa")
2069 .arg(&m.ns_path)
2070 .args(args);
2071 c
2072 }
2073 None => {
2074 let mut c = Command::new("bwrap");
2075 c.args(args);
2076 c
2077 }
2078 };
2079 c.stderr(std::process::Stdio::piped());
2080 let mut hijo = c
2081 .spawn()
2082 .context("no pude ejecutar bwrap — ¿está en el PATH? (recipes/bwrap.toml)")?;
2083 let mut err = hijo.stderr.take().expect("stderr pedido arriba");
2084 let hilo = std::thread::spawn(move || {
2085 use std::io::Write;
2086 let mut principio = Vec::new();
2087 let mut buf = [0u8; 4096];
2088 loop {
2089 match err.read(&mut buf) {
2090 Ok(0) | Err(_) => break,
2091 Ok(n) => {
2092 if principio.len() < 8192 {
2093 principio.extend_from_slice(&buf[..n]);
2094 }
2095 let _ = std::io::stderr().write_all(&buf[..n]);
2096 let _ = std::io::stderr().flush();
2097 }
2098 }
2099 }
2100 let t = String::from_utf8_lossy(&principio).into_owned();
2101 t.contains("Can't make overlay mount") && t.contains("busy")
2102 });
2103 let st = hijo.wait().context("esperando a bwrap")?;
2104 let overlay_tomado = hilo.join().unwrap_or(false);
2105 Ok((st, overlay_tomado))
2106}
2107
2108// ── prune: la poda (§Orden 7) ───────────────────────────────────────────────────────────────────
2109//
2110// Nace CON el subsistema y no después, a propósito: un rootfs son cientos de MB o varios GB, y no
2111// lo alcanzan ni `store-gc` ni la caché `.dmerge` — es un tercer montón sin dueño, como ya lo fue
2112// `work/sources`. La regla que la hace trivial es D3: **un `upper` siempre se puede borrar**.
2113//
2114// Dos cicatrices del repo, cableadas acá:
2115// · `store-gc` REPORTABA borrados que no ocurrían (corriendo en segundo plano). Por eso esto
2116// comprueba DESPUÉS de borrar que el directorio se fue, y si sigue ahí lo dice.
2117// · Un tamaño calculado sobre un árbol que no se puede leer entero sale MENOR de lo que es. Por
2118// eso se cuentan los directorios ciegos y la cifra se marca como cota inferior.
2119
2120struct Candidato { que: String, ruta: PathBuf, bytes: u64, cota: bool }
2121
2122fn prune(root: &Path, con_upper: bool, de_verdad: bool) -> Result<()> {
2123 let images = root.join("images");
2124 let mut cands: Vec<Candidato> = Vec::new();
2125
2126 // 1. Restos de descargas y desempacados a medias. Basura por definición: llevan el prefijo con
2127 // punto justo para que `list` no los confunda con una imagen.
2128 if let Ok(rd) = std::fs::read_dir(&images) {
2129 for e in rd.flatten() {
2130 let n = e.file_name().to_string_lossy().into_owned();
2131 if !n.starts_with('.') {
2132 continue;
2133 }
2134 let (bytes, cota) = medir(&e.path());
2135 cands.push(Candidato { que: format!("resto de un pull a medias ({n})"),
2136 ruta: e.path(), bytes, cota });
2137 }
2138 }
2139
2140 // 2. Imágenes que ninguna instancia usa. Se pueden volver a traer por digest, así que borrarlas
2141 // no pierde nada que no se pueda recuperar: es exactamente la propiedad que da el pin.
2142 let usadas: std::collections::BTreeSet<String> = std::fs::read_dir(instances_dir(root))
2143 .into_iter().flatten().flatten()
2144 .filter_map(|e| {
2145 let body = std::fs::read_to_string(e.path().join(INSTANCE_MANIFEST)).ok()?;
2146 let i: Instance = toml::from_str(&body).ok()?;
2147 Some(i.base.strip_prefix("sha256:").unwrap_or(&i.base).to_string())
2148 })
2149 .collect();
2150 if let Ok(rd) = std::fs::read_dir(&images) {
2151 for e in rd.flatten() {
2152 let n = e.file_name().to_string_lossy().into_owned();
2153 if n.starts_with('.') || usadas.contains(&n) {
2154 continue;
2155 }
2156 let m: Option<ImageManifest> = std::fs::read_to_string(e.path().join(IMAGE_MANIFEST))
2157 .ok().and_then(|s| toml::from_str(&s).ok());
2158 // El tamaño ya está en el manifiesto (lo midió `pull` sobre el árbol recién
2159 // desempacado, cuando todavía era legible entero): mejor dato y gratis.
2160 let (bytes, cota) = match &m {
2161 Some(m) if m.tree_bytes > 0 => (m.tree_bytes, false),
2162 _ => medir(&e.path()),
2163 };
2164 let etiqueta = m.and_then(|m| m.label).unwrap_or_else(|| n[..12].to_string());
2165 cands.push(Candidato { que: format!("imagen sin instancia ({etiqueta})"),
2166 ruta: e.path(), bytes, cota });
2167 }
2168 }
2169
2170 // 3. Capas mutables. Sólo si se piden: son caché (D3), pero lo que instalaste a mano y no
2171 // declaraste en `packages` no vuelve solo.
2172 if con_upper {
2173 for e in std::fs::read_dir(instances_dir(root)).into_iter().flatten().flatten() {
2174 let id = e.file_name().to_string_lossy().into_owned();
2175 let up = e.path().join("upper");
2176 if !up.exists() {
2177 continue;
2178 }
2179 let (bytes, cota) = medir(&up);
2180 cands.push(Candidato { que: format!("capa mutable de {id}"), ruta: up, bytes, cota });
2181 }
2182 }
2183
2184 if cands.is_empty() {
2185 println!("nada que podar en {}", root.display());
2186 return Ok(());
2187 }
2188 let total: u64 = cands.iter().map(|c| c.bytes).sum();
2189 let alguna_cota = cands.iter().any(|c| c.cota);
2190 for c in &cands {
2191 println!(" {}{:<9} {}", if c.cota { "≥" } else { " " }, human(c.bytes), c.que);
2192 }
2193 println!("{}{} en {} elemento(s)", if alguna_cota { "≥ " } else { "" }, human(total), cands.len());
2194
2195 if !de_verdad {
2196 println!("\nsimulacro: no se borró nada. Repetí con --yes.");
2197 if !con_upper {
2198 println!("(`--upper` añade las capas mutables, que por D3 siempre se pueden tirar)");
2199 }
2200 return Ok(());
2201 }
2202
2203 let (mut ok, mut fallos) = (0u64, 0u64);
2204 for c in &cands {
2205 // `force_remove_dir_all` sabe abrir los directorios de sólo-lectura de un rootfs y, si el
2206 // árbol tiene ficheros de los subuid, entrar al userns mapeado para borrarlos.
2207 let r = if c.ruta.is_dir() { force_remove_dir_all(&c.ruta) } else { std::fs::remove_file(&c.ruta) };
2208 // La cicatriz de store-gc: no basta con que la llamada devuelva Ok — se COMPRUEBA que se fue.
2209 match (r, c.ruta.exists()) {
2210 (Ok(()), false) => { ok += 1; }
2211 (Ok(()), true) => { fallos += 1; eprintln!(" !! {} dijo que sí y SIGUE AHÍ", c.ruta.display()); }
2212 (Err(e), _) => { fallos += 1; eprintln!(" !! {}: {e}", c.ruta.display()); }
2213 }
2214 }
2215 // La capa mutable es parte de la instancia: si se tiró, hay que dejarla utilizable.
2216 if con_upper {
2217 for e in std::fs::read_dir(instances_dir(root)).into_iter().flatten().flatten() {
2218 let _ = std::fs::create_dir_all(e.path().join("upper"));
2219 let _ = force_remove_dir_all(&e.path().join("work"));
2220 let _ = std::fs::create_dir_all(e.path().join("work"));
2221 }
2222 }
2223 println!("podado: {ok} de {} elemento(s)", cands.len());
2224 if fallos > 0 {
2225 bail!("{fallos} no se pudieron borrar — el número de arriba NO es lo que se liberó");
2226 }
2227 Ok(())
2228}
2229
2230/// Tamaño de un árbol y si la cifra es cota inferior (hubo directorios ilegibles).
2231fn medir(p: &Path) -> (u64, bool) {
2232 if p.is_file() {
2233 return (std::fs::metadata(p).map(|m| m.len()).unwrap_or(0), false);
2234 }
2235 match walk_tree_ciegos(p) {
2236 Ok((_, bytes, ciegos)) => (bytes, ciegos > 0),
2237 Err(_) => (0, true),
2238 }
2239}
2240
2241// ── export: la capa de transparencia (D5) ───────────────────────────────────────────────────────
2242//
2243// El objetivo es el poder de Bedrock Linux —apps de cualquier «stratum» disponibles en todos
2244// lados— SIN sus formas: nada de un FUSE global en el camino de cada `exec`, nada de arbitrar por
2245// heurística qué binario gana. Acá no hace falta, porque **el FHS de esta distro ya es una
2246// proyección**: `takana hydrate` proyecta artefactos a un árbol, y extender la proyección a
2247// instancias es idiomático.
2248//
2249// Tres propiedades que un FUSE no da: **cero costo en runtime** (no hay proceso en el camino
2250// crítico), **inspeccionable** (`cat` al shim y ves qué hace) y **revocable** (se borran los shims
2251// y la instancia desaparece del sistema sin desmontar nada).
2252
2253/// Registro de lo escrito. Sin esto, `--remove` tendría que ADIVINAR qué ficheros son nuestros, y
2254/// borrar por patrón en el `~/.local/bin` de alguien es exactamente lo que no se hace.
2255const EXPORT_LEDGER: &str = "exported.json";
2256/// Marca dentro de cada fichero generado. Redundante con el registro a propósito: si alguien mueve
2257/// el shim, sigue diciendo de dónde salió.
2258const MARCA: &str = "hammer-qorpa";
2259
2260/// Claves del `.desktop` ajeno que se copian: TEXTO DE PRESENTACIÓN y nada más.
2261///
2262/// Lista blanca, no negra. `Exec`, `TryExec`, `Path`, `DBusActivatable` y `Actions` quedan fuera
2263/// **por definición**: son ejecución, y la ejecución la escribimos nosotros. Una lista negra
2264/// dejaría entrar la próxima clave ejecutable que invente el estándar.
2265const DESKTOP_OK: &[&str] = &[
2266 "Name", "GenericName", "Comment", "Keywords", "Icon", "Categories",
2267 "Terminal", "StartupWMClass", "StartupNotify", "MimeType", "NoDisplay", "Type",
2268];
2269
2270/// Busca un fichero en la vista MERGED de la instancia: primero la capa mutable, después la imagen.
2271/// Es el mismo orden que ve el proceso adentro; mirar sólo la imagen se perdería lo que instaló el
2272/// gestor de paquetes, que es justo lo que se quiere exportar.
2273fn resolver_en_instancia(dir: &Path, tree: &Path, rel: &str) -> Option<PathBuf> {
2274 let rel = rel.trim_start_matches('/');
2275 for base in [dir.join("upper"), tree.to_path_buf()] {
2276 let p = base.join(rel);
2277 if p.exists() {
2278 return Some(p);
2279 }
2280 }
2281 None
2282}
2283
2284fn buscar_desktop(dir: &Path, tree: &Path, nombre: &str) -> Option<PathBuf> {
2285 let nombre = if nombre.ends_with(".desktop") { nombre.to_string() } else { format!("{nombre}.desktop") };
2286 for d in ["usr/share/applications", "usr/local/share/applications", "share/applications"] {
2287 if let Some(p) = resolver_en_instancia(dir, tree, &format!("{d}/{nombre}")) {
2288 return Some(p);
2289 }
2290 }
2291 None
2292}
2293
2294/// El icono referenciado por un `.desktop` puede ser una ruta o un NOMBRE de tema. Si es nombre, se
2295/// busca en los sitios estándar de la imagen y se copia al host: un `.desktop` con un icono que el
2296/// host no puede resolver se ve como un cuadrito gris, que es peor que no exportarlo.
2297fn copiar_icono(dir: &Path, tree: &Path, icono: &str, destino_base: &Path) -> Option<(String, PathBuf)> {
2298 if icono.starts_with('/') {
2299 let src = resolver_en_instancia(dir, tree, icono)?;
2300 let ext = src.extension().and_then(|e| e.to_str()).unwrap_or("png").to_string();
2301 let nombre = format!("{MARCA}-{}", src.file_name()?.to_string_lossy());
2302 let dst = destino_base.join(&nombre);
2303 std::fs::create_dir_all(destino_base).ok()?;
2304 std::fs::copy(&src, &dst).ok()?;
2305 let _ = ext;
2306 return Some((dst.display().to_string(), dst));
2307 }
2308 for tamano in ["scalable", "256x256", "128x128", "64x64", "48x48"] {
2309 for ext in ["svg", "png"] {
2310 let rel = format!("usr/share/icons/hicolor/{tamano}/apps/{icono}.{ext}");
2311 if let Some(src) = resolver_en_instancia(dir, tree, &rel) {
2312 let dst = destino_base.join(format!("{MARCA}-{icono}.{ext}"));
2313 std::fs::create_dir_all(destino_base).ok()?;
2314 if std::fs::copy(&src, &dst).is_ok() {
2315 return Some((dst.display().to_string(), dst));
2316 }
2317 }
2318 }
2319 }
2320 for rel in [format!("usr/share/pixmaps/{icono}.png"), format!("usr/share/pixmaps/{icono}.svg")] {
2321 if let Some(src) = resolver_en_instancia(dir, tree, &rel) {
2322 let ext = if rel.ends_with("svg") { "svg" } else { "png" };
2323 let dst = destino_base.join(format!("{MARCA}-{icono}.{ext}"));
2324 std::fs::create_dir_all(destino_base).ok()?;
2325 if std::fs::copy(&src, &dst).is_ok() {
2326 return Some((dst.display().to_string(), dst));
2327 }
2328 }
2329 }
2330 None
2331}
2332
2333fn export(root: &Path, id: &str, into: Option<&Path>, remove: bool) -> Result<()> {
2334 let (dir, inst) = read_instance(root, id)?;
2335 let ledger_path = dir.join(EXPORT_LEDGER);
2336
2337 if remove {
2338 let previos: Vec<String> = std::fs::read_to_string(&ledger_path)
2339 .ok()
2340 .and_then(|s| serde_json::from_str(&s).ok())
2341 .unwrap_or_default();
2342 if previos.is_empty() {
2343 println!("la instancia {id} no tiene nada exportado");
2344 return Ok(());
2345 }
2346 for f in &previos {
2347 match std::fs::remove_file(f) {
2348 Ok(()) => println!(" borrado {f}"),
2349 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
2350 Err(e) => eprintln!(" no pude borrar {f}: {e}"),
2351 }
2352 }
2353 let _ = std::fs::remove_file(&ledger_path);
2354 println!("{} fichero(s) revocados — la instancia sigue existiendo, ya no se ve", previos.len());
2355 return Ok(());
2356 }
2357
2358 if inst.export.binaries.is_empty() && inst.export.apps.is_empty() {
2359 bail!(
2360 "la instancia {id} no declara nada en `[export]`. Se exporta lo DECLARADO: exportar \
2361 todo haría que el `ls` de la imagen compita con el nuestro, que es la falla de Bedrock."
2362 );
2363 }
2364 let (_sha, tree) = resolve_image(root, &inst.base)?;
2365
2366 let prefijo = into.map(PathBuf::from).unwrap_or_else(|| {
2367 PathBuf::from(std::env::var("HOME").unwrap_or_else(|_| "/root".into())).join(".local")
2368 });
2369 let bin_dir = prefijo.join("bin");
2370 let app_dir = prefijo.join("share/applications");
2371 let icon_dir = prefijo.join("share/icons/qorpa");
2372 std::fs::create_dir_all(&bin_dir)?;
2373
2374 // La ruta ABSOLUTA de este mismo binario: un shim que dependiera del `PATH` del usuario haría
2375 // que la app arranque o no según quién la lance.
2376 let hammer = std::env::current_exe().context("no sé cuál es mi propia ruta")?;
2377 let raiz_flag = if root == Path::new(DEFAULT_ROOT) {
2378 String::new()
2379 } else {
2380 format!(" --root {}", shell_quote(&root.display().to_string()))
2381 };
2382
2383 let mut escritos: Vec<String> = Vec::new();
2384
2385 for b in &inst.export.binaries {
2386 let dst = bin_dir.join(b);
2387 let cuerpo = format!(
2388 "#!/bin/sh\n\
2389 # GENERADO por `takana qorpa export {id}` — {MARCA}. No editar: se reescribe.\n\
2390 # Borralo (o corré `takana qorpa export {id} --remove`) y la instancia deja de verse.\n\
2391 exec {hammer} qorpa run{raiz_flag} {id} -- {b} \"$@\"\n",
2392 hammer = shell_quote(&hammer.display().to_string()),
2393 b = shell_quote(b),
2394 );
2395 std::fs::write(&dst, cuerpo)?;
2396 std::fs::set_permissions(&dst, std::fs::Permissions::from_mode(0o755))?;
2397 escritos.push(dst.display().to_string());
2398 println!(" bin {}", dst.display());
2399 }
2400
2401 for a in &inst.export.apps {
2402 let src = buscar_desktop(&dir, &tree, a)
2403 .with_context(|| format!("no encuentro {a} dentro de la instancia {id}"))?;
2404 let texto = std::fs::read_to_string(&src)?;
2405 let (campos, exec_original) = leer_desktop(&texto);
2406
2407 let nombre_bin = exec_original
2408 .split_whitespace()
2409 .next()
2410 .map(|c| c.rsplit('/').next().unwrap_or(c).to_string())
2411 .unwrap_or_else(|| a.trim_end_matches(".desktop").to_string());
2412
2413 let mut salida = String::from("[Desktop Entry]\n");
2414 salida.push_str(&format!(
2415 "# GENERADO por `hammer qorpa export {id}` — {MARCA}. El Exec de abajo es NUESTRO:\n\
2416 # el original decía `{exec_original}` y no se copia (D5).\n"
2417 ));
2418 let mut icono_final = None;
2419 for (k, v) in &campos {
2420 if k.starts_with("Icon") {
2421 if let Some((ruta, dst)) = copiar_icono(&dir, &tree, v, &icon_dir) {
2422 escritos.push(dst.display().to_string());
2423 icono_final = Some(ruta);
2424 continue; // se escribe abajo, ya resuelto a ruta del host
2425 }
2426 }
2427 salida.push_str(&format!("{k}={v}\n"));
2428 }
2429 if let Some(i) = icono_final {
2430 salida.push_str(&format!("Icon={i}\n"));
2431 }
2432 if !campos.iter().any(|(k, _)| k == "Type") {
2433 salida.push_str("Type=Application\n");
2434 }
2435 salida.push_str(&format!(
2436 "Exec={} qorpa run{raiz_flag} {id} -- {} %U\n",
2437 shell_quote(&hammer.display().to_string()),
2438 shell_quote(&nombre_bin),
2439 ));
2440 salida.push_str(&format!("X-Qorpa-Instance={id}\n"));
2441
2442 std::fs::create_dir_all(&app_dir)?;
2443 let dst = app_dir.join(src.file_name().unwrap());
2444 std::fs::write(&dst, salida)?;
2445 escritos.push(dst.display().to_string());
2446 println!(" desktop {}", dst.display());
2447 }
2448
2449 std::fs::write(&ledger_path, serde_json::to_string_pretty(&escritos)?)?;
2450 println!(
2451 "{} fichero(s) generados desde {} — inspeccionables con `cat`, revocables con --remove",
2452 escritos.len(), src_label(&dir)
2453 );
2454 if !bin_dir.display().to_string().is_empty() {
2455 println!(" ⚠ que `{}` esté en tu PATH es cosa tuya", bin_dir.display());
2456 }
2457 Ok(())
2458}
2459
2460/// Busca el home del uid en el `/etc/passwd` de la instancia (vista merged). Cae a `/root` para el
2461/// 0 y a `/home/qorpa` si no hay entrada — nunca a nada, porque un HOME vacío rompe más que uno
2462/// inventado.
2463fn home_de(dir: &Path, tree: &Path, uid: u32) -> String {
2464 if let Some(p) = resolver_en_instancia(dir, tree, "etc/passwd") {
2465 if let Ok(txt) = std::fs::read_to_string(p) {
2466 for l in txt.lines() {
2467 let c: Vec<&str> = l.split(':').collect();
2468 if c.len() >= 6 && c[2].parse::<u32>() == Ok(uid) && !c[5].is_empty() {
2469 return c[5].to_string();
2470 }
2471 }
2472 }
2473 }
2474 if uid == 0 { "/root".into() } else { "/home/qorpa".into() }
2475}
2476
2477/// (uid, gid, home) de un usuario del `/etc/passwd` de la instancia. Acepta nombre o uid.
2478fn usuario_de(dir: &Path, tree: &Path, quien: &str) -> Result<(u32, u32, String)> {
2479 let p = resolver_en_instancia(dir, tree, "etc/passwd")
2480 .context("la instancia no tiene /etc/passwd")?;
2481 for l in std::fs::read_to_string(p)?.lines() {
2482 let c: Vec<&str> = l.split(':').collect();
2483 if c.len() < 6 {
2484 continue;
2485 }
2486 if c[0] == quien || c[2] == quien {
2487 return Ok((c[2].parse()?, c[3].parse()?,
2488 if c[5].is_empty() { "/".into() } else { c[5].to_string() }));
2489 }
2490 }
2491 bail!("no encuentro al usuario {quien:?}")
2492}
2493
2494fn src_label(dir: &Path) -> String {
2495 dir.file_name().map(|s| s.to_string_lossy().into_owned()).unwrap_or_else(|| dir.display().to_string())
2496}
2497
2498/// Parsea el `[Desktop Entry]` de un `.desktop` y devuelve (campos permitidos, el `Exec` original).
2499/// El `Exec` se devuelve SÓLO para nombrar el binario y para dejar dicho en el fichero generado qué
2500/// decía el ajeno — nunca se emite.
2501fn leer_desktop(texto: &str) -> (Vec<(String, String)>, String) {
2502 let mut campos = Vec::new();
2503 let mut exec = String::new();
2504 let mut dentro = false;
2505 for l in texto.lines() {
2506 let l = l.trim();
2507 if l.starts_with('[') {
2508 dentro = l == "[Desktop Entry]";
2509 continue;
2510 }
2511 if !dentro || l.is_empty() || l.starts_with('#') {
2512 continue;
2513 }
2514 let Some((k, v)) = l.split_once('=') else { continue };
2515 let (k, v) = (k.trim(), v.trim());
2516 if k == "Exec" && exec.is_empty() {
2517 exec = v.to_string();
2518 continue;
2519 }
2520 // La clave puede venir localizada (`Name[es]`): se compara la parte antes del corchete.
2521 let base = k.split('[').next().unwrap_or(k);
2522 if DESKTOP_OK.contains(&base) {
2523 campos.push((k.to_string(), v.to_string()));
2524 }
2525 }
2526 (campos, exec)
2527}
2528
2529/// Comillas para `sh`. Un shim se lee y se ejecuta: una ruta con espacios no puede romperlo.
2530fn shell_quote(s: &str) -> String {
2531 if !s.is_empty() && s.bytes().all(|b| b.is_ascii_alphanumeric() || b"@%+=:,./-_".contains(&b)) {
2532 s.to_string()
2533 } else {
2534 format!("'{}'", s.replace('\'', r"'\''"))
2535 }
2536}
2537
2538// ── list ────────────────────────────────────────────────────────────────────────────────────────
2539
2540fn list(root: &Path, json: bool) -> Result<()> {
2541 let images = root.join("images");
2542 let mut rows: Vec<(String, Option<ImageManifest>, TreeState)> = Vec::new();
2543 if let Ok(rd) = std::fs::read_dir(&images) {
2544 for e in rd.flatten() {
2545 let name = e.file_name().to_string_lossy().into_owned();
2546 if name.starts_with('.') {
2547 continue; // restos de un pull a medias
2548 }
2549 let m = std::fs::read_to_string(e.path().join(IMAGE_MANIFEST))
2550 .ok()
2551 .and_then(|s| toml::from_str::<ImageManifest>(&s).ok());
2552 rows.push((name, m, tree_state(&e.path().join(TREE))));
2553 }
2554 }
2555 rows.sort_by(|a, b| a.0.cmp(&b.0));
2556
2557 let insts: Vec<(String, Instance)> = std::fs::read_dir(instances_dir(root))
2558 .into_iter()
2559 .flatten()
2560 .flatten()
2561 .filter_map(|e| {
2562 let id = e.file_name().to_string_lossy().into_owned();
2563 let body = std::fs::read_to_string(e.path().join(INSTANCE_MANIFEST)).ok()?;
2564 Some((id, toml::from_str::<Instance>(&body).ok()?))
2565 })
2566 .collect();
2567
2568 if json {
2569 let out: Vec<_> = rows.iter().map(|(sha, m, st)| {
2570 serde_json::json!({
2571 "sha256": sha,
2572 "label": m.as_ref().and_then(|m| m.label.clone()),
2573 "url": m.as_ref().map(|m| m.url.clone()),
2574 "tree_files": m.as_ref().map(|m| m.tree_files).unwrap_or(0),
2575 "tree_bytes": m.as_ref().map(|m| m.tree_bytes).unwrap_or(0),
2576 "empty": !matches!(st, TreeState::Populated),
2577 })
2578 }).collect();
2579 let insts_json: Vec<_> = insts.iter().map(|(id, i)| serde_json::json!({
2580 "id": id, "base": i.base, "distro": i.distro,
2581 "packages": i.packages, "network": i.grants.network,
2582 "sockets": i.grants.sockets, "devices": i.grants.devices,
2583 })).collect();
2584 println!("{}", serde_json::to_string_pretty(
2585 &serde_json::json!({"images": out, "instances": insts_json}))?);
2586 return Ok(());
2587 }
2588
2589 if rows.is_empty() && insts.is_empty() {
2590 println!("no hay imágenes en {} — `hammer qorpa pull <url> --sha256 <sha>`", images.display());
2591 return Ok(());
2592 }
2593 let mut vacias = 0;
2594 for (sha, m, st) in &rows {
2595 let etiqueta = m.as_ref().and_then(|m| m.label.clone()).unwrap_or_else(|| "—".into());
2596 match st {
2597 TreeState::Populated => println!(
2598 " {} {:<32} {:>7} ficheros {}",
2599 &sha[..12],
2600 etiqueta,
2601 m.as_ref().map(|m| m.tree_files).unwrap_or(0),
2602 human(m.as_ref().map(|m| m.tree_bytes).unwrap_or(0)),
2603 ),
2604 _ => {
2605 vacias += 1;
2606 println!(" {} {:<32} !! VACÍA — no es una imagen, es un nombre", &sha[..12], etiqueta);
2607 }
2608 }
2609 }
2610 if !insts.is_empty() {
2611 println!("\ninstancias:");
2612 for (id, i) in &insts {
2613 let sha = i.base.strip_prefix("sha256:").unwrap_or(&i.base);
2614 // Se enumeran las concesiones porque una instancia sin política declarada y una con la
2615 // pantalla abierta se ven IGUAL desde fuera, y no son lo mismo (ADR §NO-resuelve 1).
2616 let mut abre: Vec<String> = Vec::new();
2617 if i.grants.network { abre.push("red".into()); }
2618 abre.extend(i.grants.sockets.iter().cloned());
2619 abre.extend(i.grants.devices.iter().cloned());
2620 if !i.grants.dirs.is_empty() { abre.push(format!("{} dir(s)", i.grants.dirs.len())); }
2621 println!(" {:<16} sobre {} abre: {}", id, &sha[..sha.len().min(12)],
2622 if abre.is_empty() { "nada".into() } else { abre.join(", ") });
2623 }
2624 }
2625 println!("\n{} imagen(es) en {}", rows.len(), images.display());
2626 if vacias > 0 {
2627 bail!("{vacias} imagen(es) VACÍA(s): un ausente falla ruidosamente, un vacío llega hasta el final diciendo que todo fue bien");
2628 }
2629 Ok(())
2630}
2631
2632fn human(b: u64) -> String {
2633 const U: [&str; 5] = ["B", "K", "M", "G", "T"];
2634 let (mut v, mut i) = (b as f64, 0);
2635 while v >= 1024.0 && i < 4 { v /= 1024.0; i += 1; }
2636 if i == 0 { format!("{b} B") } else { format!("{v:.1} {}", U[i]) }
2637}
2638
2639#[cfg(test)]
2640mod tests {
2641 use super::*;
2642
2643 fn tar_gz(dir: &Path, dst: &Path, contenido: &[(&str, &str)]) {
2644 for (p, c) in contenido {
2645 let f = dir.join(p);
2646 std::fs::create_dir_all(f.parent().unwrap()).unwrap();
2647 std::fs::write(f, c).unwrap();
2648 }
2649 let st = Command::new("tar").args(["-czf"]).arg(dst).arg("-C").arg(dir)
2650 .args(contenido.iter().map(|(p, _)| p.split('/').next().unwrap()).collect::<std::collections::BTreeSet<_>>())
2651 .status().unwrap();
2652 assert!(st.success());
2653 }
2654
2655 fn sha_of(p: &Path) -> String {
2656 use sha2::{Digest, Sha256};
2657 let mut h = Sha256::new();
2658 std::io::copy(&mut std::fs::File::open(p).unwrap(), &mut h).unwrap();
2659 hex::encode(h.finalize())
2660 }
2661
2662 #[test]
2663 fn pull_verifica_desempaca_y_es_idempotente() {
2664 let d = tempfile::tempdir().unwrap();
2665 let src = d.path().join("src");
2666 std::fs::create_dir_all(&src).unwrap();
2667 let arch = d.path().join("img.tar.gz");
2668 tar_gz(&src, &arch, &[("etc/os-release", "ID=ajena\n"), ("bin/sh", "#!/bin/sh\n")]);
2669 let sha = sha_of(&arch);
2670 let root = d.path().join("qorpa");
2671 let url = format!("file://{}", arch.display());
2672
2673 pull(&root, &url, &sha, Some("prueba"), false, None).unwrap();
2674 let tree = root.join("images").join(&sha).join(TREE);
2675 assert_eq!(std::fs::read_to_string(tree.join("etc/os-release")).unwrap(), "ID=ajena\n");
2676 // Segundo pull: no vuelve a bajar ni rompe.
2677 pull(&root, &url, &sha, Some("prueba"), false, None).unwrap();
2678 assert!(root.join("images").join(&sha).join(IMAGE_MANIFEST).exists());
2679 }
2680
2681 #[test]
2682 fn pull_aborta_si_el_contenido_no_es_el_que_dice_ser() {
2683 let d = tempfile::tempdir().unwrap();
2684 let src = d.path().join("src");
2685 std::fs::create_dir_all(&src).unwrap();
2686 let arch = d.path().join("img.tar.gz");
2687 tar_gz(&src, &arch, &[("etc/hostname", "ajena\n")]);
2688 let root = d.path().join("qorpa");
2689 let mentira = "0".repeat(64);
2690 let err = pull(&root, &format!("file://{}", arch.display()), &mentira, None, false, None)
2691 .unwrap_err().to_string();
2692 assert!(err.contains("sha256 mismatch"), "mensaje inesperado: {err}");
2693 // Y no dejó nada a medias: contenido distinto ⇒ ABORTAR, no "avisar y seguir".
2694 assert!(!root.join("images").join(&mentira).exists());
2695 }
2696
2697 /// La cicatriz de Arch: el rootfs viene en `root.x86_64/` CON HERMANOS al lado (`version`,
2698 /// `pkglist`). La regla vieja ("un solo directorio arriba") no disparaba y dejaba el rootfs un
2699 /// nivel abajo, en verde. Se ancla por estructura.
2700 #[test]
2701 fn el_rootfs_anidado_se_eleva_aunque_tenga_hermanos() {
2702 let d = tempfile::tempdir().unwrap();
2703 let src = d.path().join("src");
2704 std::fs::create_dir_all(&src).unwrap();
2705 let arch = d.path().join("boot.tar.gz");
2706 tar_gz(&src, &arch, &[
2707 ("root.x86_64/etc/os-release", "ID=arch\n"),
2708 ("root.x86_64/usr/lib/keep", ""),
2709 ("version", "2026.09.01\n"),
2710 ]);
2711 let sha = sha_of(&arch);
2712 let root = d.path().join("qorpa");
2713 pull(&root, &format!("file://{}", arch.display()), &sha, None, false, None).unwrap();
2714 let tree = root.join("images").join(&sha).join(TREE);
2715 assert!(tree.join("etc/os-release").exists(), "no ancló el rootfs anidado");
2716 assert!(!tree.join("root.x86_64").exists());
2717 assert!(!tree.join("version").exists(), "el hermano no debía entrar al rootfs");
2718 let m: ImageManifest = toml::from_str(
2719 &std::fs::read_to_string(root.join("images").join(&sha).join(IMAGE_MANIFEST)).unwrap(),
2720 ).unwrap();
2721 assert_eq!(m.rootfs_subdir.as_deref(), Some("root.x86_64"));
2722 assert_eq!(m.dropped_siblings, vec!["version".to_string()]);
2723 }
2724
2725 #[test]
2726 fn un_arbol_vacio_no_pasa_por_imagen() {
2727 let d = tempfile::tempdir().unwrap();
2728 let vacio = d.path().join("vacio");
2729 std::fs::create_dir_all(&vacio).unwrap();
2730 let arch = d.path().join("nada.tar.gz");
2731 assert!(Command::new("tar").args(["-czf"]).arg(&arch).arg("-C").arg(&vacio)
2732 .args(["--files-from", "/dev/null"]).status().unwrap().success());
2733 let sha = sha_of(&arch);
2734 let root = d.path().join("qorpa");
2735 let err = pull(&root, &format!("file://{}", arch.display()), &sha, None, false, None)
2736 .unwrap_err().to_string();
2737 assert!(err.contains("VACÍO") || err.contains("no encuentro un rootfs"),
2738 "mensaje inesperado: {err}");
2739 assert!(!root.join("images").join(&sha).exists());
2740 }
2741
2742 /// Una imagen mínima que pasa por rootfs: `etc/` + `bin/`.
2743 fn imagen_falsa(root: &Path, sha: &str) {
2744 let t = root.join("images").join(sha).join(TREE);
2745 std::fs::create_dir_all(t.join("etc")).unwrap();
2746 std::fs::create_dir_all(t.join("bin")).unwrap();
2747 std::fs::write(t.join("etc/os-release"), "ID=falsa\n").unwrap();
2748 }
2749
2750 /// Un artefacto del store con una imagen ajena sellada dentro. Réplica de lo que produce
2751 /// `recipes/steam-runtime-sniper.toml`.
2752 fn artefacto_con_imagen(store: &Path, hex: &str, sha_upstream: &str, con_arbol: bool) -> PathBuf {
2753 let img = store.join(format!("{hex}-imagen-ajena")).join("usr/share/qorpa/images/ajena");
2754 std::fs::create_dir_all(&img).unwrap();
2755 if con_arbol {
2756 std::fs::create_dir_all(img.join(TREE).join("etc")).unwrap();
2757 std::fs::write(img.join(TREE).join("etc/os-release"), "ID=ajena\n").unwrap();
2758 } else {
2759 std::fs::create_dir_all(img.join(TREE)).unwrap();
2760 }
2761 std::fs::write(img.join(IMAGE_MANIFEST), format!(
2762 "sha256 = \"{sha_upstream}\"\nurl = \"https://ejemplo/x.tar.gz\"\n\
2763 label = \"ajena-1\"\narchive_bytes = 42\ntree_files = 0\ntree_bytes = 0\n"
2764 )).unwrap();
2765 img
2766 }
2767
2768 /// LA propiedad que hace que sellar valga la pena: la imagen importada del store queda bajo el
2769 /// **sha256 de upstream**, no bajo el hash del artefacto. Si fuera al revés, la imagen del store
2770 /// y la traída con `pull` serían dos imágenes distintas con los mismos bytes y las instancias de
2771 /// dos máquinas dejarían de coincidir — justo lo que el pin existe para evitar.
2772 #[test]
2773 fn import_registra_la_imagen_por_el_sha_de_upstream_no_por_el_del_artefacto() {
2774 let d = tempfile::tempdir().unwrap();
2775 let store = d.path().join("store");
2776 let root = d.path().join("qorpa");
2777 let hex = "f".repeat(64);
2778 let up = "1".repeat(64);
2779 artefacto_con_imagen(&store, &hex, &up, true);
2780
2781 import(&root, &store, "ffffffff", true).unwrap();
2782 let dest = root.join("images").join(&up);
2783 assert_eq!(std::fs::read_to_string(dest.join(TREE).join("etc/os-release")).unwrap(),
2784 "ID=ajena\n");
2785 assert!(!root.join("images").join(&hex).exists(), "se registró por el hash del artefacto");
2786
2787 let m: ImageManifest = toml::from_str(
2788 &std::fs::read_to_string(dest.join(IMAGE_MANIFEST)).unwrap()).unwrap();
2789 assert_eq!(m.sha256, up);
2790 // Los contadores se MIDEN sobre lo importado, no se copian del artefacto (que traía 0).
2791 assert_eq!(m.tree_files, 1);
2792 assert!(m.tree_bytes > 0);
2793
2794 // Idempotente: importar dos veces no rompe ni duplica.
2795 import(&root, &store, "ffffffff", true).unwrap();
2796 }
2797
2798 /// Regla 3 en el eslabón nuevo: un árbol vacío dentro del artefacto no puede pasar por imagen.
2799 /// Es donde más barato sale equivocarse — el manifiesto está, el directorio está, y lo único
2800 /// que falta es el contenido.
2801 #[test]
2802 fn import_rechaza_un_artefacto_con_el_arbol_vacio() {
2803 let d = tempfile::tempdir().unwrap();
2804 let store = d.path().join("store");
2805 let root = d.path().join("qorpa");
2806 artefacto_con_imagen(&store, &"e".repeat(64), &"2".repeat(64), false);
2807 let err = import(&root, &store, "eeeeeeee", true).unwrap_err().to_string();
2808 assert!(err.contains("vacío"), "mensaje inesperado: {err}");
2809 assert!(!root.join("images").join("2".repeat(64)).exists());
2810 }
2811
2812 #[test]
2813 fn create_nace_sin_ninguna_concesion() {
2814 let d = tempfile::tempdir().unwrap();
2815 let root = d.path();
2816 let sha = "a".repeat(64);
2817 imagen_falsa(root, &sha);
2818 create(root, "prueba", "aaaa", Some("falsa")).unwrap();
2819 let (_, inst) = read_instance(root, "prueba").unwrap();
2820 assert_eq!(inst.base, format!("sha256:{sha}"));
2821 // D7: la política se autora, y arranca VACÍA.
2822 assert!(!inst.grants.network);
2823 assert!(inst.grants.sockets.is_empty() && inst.grants.devices.is_empty());
2824 // Y no se pisa a sí misma.
2825 assert!(create(root, "prueba", "aaaa", None).is_err());
2826 }
2827
2828 #[test]
2829 fn create_rechaza_una_imagen_vacia() {
2830 let d = tempfile::tempdir().unwrap();
2831 let root = d.path();
2832 let sha = "b".repeat(64);
2833 std::fs::create_dir_all(root.join("images").join(&sha).join(TREE)).unwrap();
2834 let err = create(root, "x", &sha, None).unwrap_err().to_string();
2835 assert!(err.contains("VACÍA"), "mensaje inesperado: {err}");
2836 }
2837
2838 #[test]
2839 fn recreate_tira_la_capa_mutable_y_conserva_el_manifiesto() {
2840 let d = tempfile::tempdir().unwrap();
2841 let root = d.path();
2842 let sha = "c".repeat(64);
2843 imagen_falsa(root, &sha);
2844 create(root, "i", &sha, None).unwrap();
2845 let upper = instance_dir(root, "i").join("upper");
2846 std::fs::write(upper.join("basura"), "x").unwrap();
2847 recreate(root, "i", true).unwrap();
2848 assert!(!upper.join("basura").exists(), "el upper no es caché si sobrevive");
2849 assert!(instance_dir(root, "i").join(INSTANCE_MANIFEST).exists(), "el manifiesto ES la verdad");
2850 }
2851
2852 /// El registro de lo provisionado vive FUERA del `upper`, así que `recreate` tiene que borrarlo
2853 /// a mano. Si sobreviviera, afirmaría que hay paquetes instalados sobre una capa recién
2854 /// vaciada: la forma más pura del error de la regla 3 —presencia declarada sin contenido—, y
2855 /// además haría que el siguiente `provision` no instalara nada.
2856 #[test]
2857 fn recreate_no_deja_vivo_el_registro_de_lo_provisionado() {
2858 let d = tempfile::tempdir().unwrap();
2859 let root = d.path();
2860 let sha = "e".repeat(64);
2861 imagen_falsa(root, &sha);
2862 create(root, "i", &sha, None).unwrap();
2863 let dir = instance_dir(root, "i");
2864 let (_, mut inst) = read_instance(root, "i").unwrap();
2865 inst.packages = vec!["strace".into()];
2866 write_instance(&dir, &inst).unwrap();
2867 std::fs::write(
2868 dir.join(PROVISION_LEDGER),
2869 toml::to_string(&Provisionado {
2870 manager: "apt".into(), packages: vec!["strace".into()], at_unix: 1,
2871 }).unwrap(),
2872 ).unwrap();
2873
2874 recreate(root, "i", true).unwrap();
2875 assert!(!dir.join(PROVISION_LEDGER).exists(), "el registro sobrevivió a la capa que describía");
2876 }
2877
2878 /// El gestor se DETECTA de la vista merged, no se configura: una imagen trae el suyo. Y el
2879 /// `upper` gana, porque el gestor puede haberse instalado después.
2880 #[test]
2881 fn el_gestor_sale_de_la_imagen_y_el_upper_manda() {
2882 let d = tempfile::tempdir().unwrap();
2883 let dir = d.path().join("inst");
2884 let tree = d.path().join("tree");
2885 std::fs::create_dir_all(dir.join("upper/usr/bin")).unwrap();
2886 std::fs::create_dir_all(tree.join("usr/bin")).unwrap();
2887
2888 std::fs::write(tree.join("usr/bin/apt-get"), "").unwrap();
2889 let g = gestor_de(&dir, &tree, &["strace".into()]).unwrap();
2890 assert_eq!(g.nombre, "apt");
2891 assert!(g.guion.contains("--no-install-recommends"));
2892
2893 std::fs::write(tree.join("usr/bin/dnf"), "").unwrap();
2894 assert_eq!(gestor_de(&dir, &tree, &["strace".into()]).unwrap().nombre, "apt",
2895 "con dos, manda el orden declarado, no el azar del directorio");
2896
2897 // Sin ninguno: falla diciendo qué buscó, en vez de correr un comando que no existe.
2898 let vacio = d.path().join("pelada");
2899 std::fs::create_dir_all(&vacio).unwrap();
2900 let err = gestor_de(&vacio, &vacio, &["x".into()]).unwrap_err().to_string();
2901 assert!(err.contains("pacman") && err.contains("apk"), "mensaje inesperado: {err}");
2902 }
2903
2904 /// El nombre de paquete sale del manifiesto, que lo escribe una persona. Se comilla SIEMPRE, y
2905 /// además se rechaza lo que no parece un nombre: quotear evita la ejecución, pero un `;` en un
2906 /// nombre es un error de tipeo que conviene ver acá y no en la salida del gestor.
2907 #[test]
2908 fn un_nombre_de_paquete_raro_no_llega_al_guion() {
2909 let d = tempfile::tempdir().unwrap();
2910 let tree = d.path().join("tree");
2911 std::fs::create_dir_all(tree.join("usr/bin")).unwrap();
2912 std::fs::write(tree.join("usr/bin/apt-get"), "").unwrap();
2913
2914 for malo in ["strace; rm -rf /", "$(whoami)", "a b", "'", ""] {
2915 assert!(gestor_de(d.path(), &tree, &[malo.into()]).is_err(), "pasó {malo:?}");
2916 }
2917 assert_eq!(comillar("a'b"), r"'a'\''b'");
2918 }
2919
2920 #[test]
2921 fn sin_concesiones_la_red_queda_fuera_y_con_red_entra_el_resolv_conf() {
2922 let (a, w) = grants_to_args(&Grants::default(), "/run/user/0", None, Path::new("/nonexistent"));
2923 assert!(a.contains(&"--unshare-net".to_string()));
2924 assert!(w.is_empty());
2925
2926 let g = Grants { network: true, ..Default::default() };
2927 let (a, _) = grants_to_args(&g, "/run/user/0", None, Path::new("/nonexistent"));
2928 assert!(!a.contains(&"--unshare-net".to_string()));
2929 // El segundo fallo clásico de la primera corrida, según el ADR.
2930 assert!(a.iter().any(|x| x == "/etc/resolv.conf"));
2931 }
2932
2933 #[test]
2934 fn el_usuario_sale_del_uid_y_no_del_entorno() {
2935 let passwd = "root:x:0:0::/root:/bin/sh\nhttp:x:33:33::/srv/http:/usr/bin/nologin\n";
2936 assert_eq!(nombre_en_passwd(passwd, 0).as_deref(), Some("root"));
2937 assert_eq!(nombre_en_passwd(passwd, 33).as_deref(), Some("http"));
2938 // El control que importa: un uid que no está NO inventa un nombre. Devolver algo aquí
2939 // haría buscar un rango de subuid ajeno, que es peor que no encontrar ninguno.
2940 assert_eq!(nombre_en_passwd(passwd, 1000), None);
2941 // Una línea rota no puede tumbar el arranque de una jaula.
2942 assert_eq!(nombre_en_passwd("basura\n\n:::\n", 0), None);
2943 }
2944
2945 #[test]
2946 fn los_padres_que_faltan_se_crean_y_los_de_la_imagen_no_se_tocan() {
2947 // El control que importa es el NEGATIVO: si esto devolviera los directorios que la imagen
2948 // ya trae, `--dir` les cambiaría los permisos a `/etc` y `/home` de la imagen.
2949 let d = tempfile::tempdir().unwrap();
2950 let tree = d.path();
2951 std::fs::create_dir_all(tree.join("etc")).unwrap();
2952 std::fs::create_dir_all(tree.join("home")).unwrap();
2953
2954 // `/work` y `/work/www` no existen en la imagen ⇒ hay que crearlos, de arriba hacia abajo.
2955 assert_eq!(
2956 ancestros_a_crear("/work/www/gioser-web", tree),
2957 vec!["/work".to_string(), "/work/www".to_string()]
2958 );
2959 // `/etc` SÍ existe ⇒ sólo el que falta.
2960 assert_eq!(ancestros_a_crear("/etc/php/php-fpm.d", tree), vec!["/etc/php".to_string()]);
2961 // Montar directamente bajo un directorio de la imagen no necesita crear NADA.
2962 assert!(ancestros_a_crear("/home/sergio", tree).is_empty());
2963 assert!(ancestros_a_crear("/srv", tree).is_empty());
2964 }
2965
2966 #[test]
2967 fn el_socket_de_wayland_avisa_que_es_un_borde_de_privilegio() {
2968 let g = Grants { sockets: vec!["wayland".into()], ..Default::default() };
2969 let (_, w) = grants_to_args(&g, "/run/user/0", None, Path::new("/nonexistent"));
2970 assert_eq!(w.len(), 1);
2971 assert!(w[0].contains("CAPTURAR LA PANTALLA"), "el aviso no puede ser tibio: {}", w[0]);
2972 }
2973
2974 #[test]
2975 fn sin_sellar_la_politica_no_finge_confinar_el_fs() {
2976 let d = tempfile::tempdir().unwrap();
2977 imagen_falsa(d.path(), "d".repeat(64).as_str());
2978 let tree = d.path().join("images").join("d".repeat(64)).join(TREE);
2979 let dst = d.path().join("policy");
2980 compile_policy(&Grants::default(), &tree, &dst).unwrap();
2981 let pol = std::fs::read_to_string(&dst).unwrap();
2982 // El namespace de montaje de bwrap YA es lista blanca. Escribir reglas `ro` que no cambian
2983 // nada sería un sello de goma, así que la política se queda en una línea honesta.
2984 assert!(pol.lines().any(|l| l == "rw /"), "{pol}");
2985 assert!(!pol.contains("\nro "), "no debería haber reglas decorativas:\n{pol}");
2986 }
2987
2988 #[test]
2989 fn sellar_congela_la_imagen_y_deja_mutable_lo_de_la_instancia() {
2990 let d = tempfile::tempdir().unwrap();
2991 let sha = "e".repeat(64);
2992 imagen_falsa(d.path(), &sha);
2993 let tree = d.path().join("images").join(&sha).join(TREE);
2994 std::fs::create_dir_all(tree.join("var")).unwrap();
2995 std::fs::create_dir_all(tree.join("usr")).unwrap();
2996 let dst = d.path().join("policy");
2997 compile_policy(&Grants { seal_image: true, ..Default::default() }, &tree, &dst).unwrap();
2998 let pol = std::fs::read_to_string(&dst).unwrap();
2999 assert!(pol.lines().any(|l| l == "ro /usr"), "{pol}");
3000 assert!(pol.lines().any(|l| l == "rw /etc"), "{pol}");
3001 assert!(pol.lines().any(|l| l == "rw /var"), "{pol}");
3002 assert!(pol.lines().any(|l| l == "list /"), "{pol}");
3003 // Si `rw /` sobreviviera, taparía todas las `ro`: Landlock une derechos por ancestro.
3004 assert!(!pol.lines().any(|l| l == "rw /"), "el `rw /` anula el sellado:\n{pol}");
3005 // Sólo se nombra lo que EXISTE: harkaq-exec falla duro ante un path inexistente.
3006 assert!(!pol.contains("/boot"), "{pol}");
3007 }
3008
3009 #[test]
3010 fn root_es_lo_unico_que_nace_encendido() {
3011 let g = Grants::default();
3012 assert!(g.root, "sin esto un gestor de paquetes no arranca");
3013 assert!(!g.network && !g.nesting && !g.seal_image);
3014 assert!(g.sockets.is_empty() && g.devices.is_empty() && g.dirs.is_empty());
3015 }
3016
3017 #[test]
3018 fn el_rango_de_subuid_se_lee_por_usuario() {
3019 let d = tempfile::tempdir().unwrap();
3020 let f = d.path().join("subuid");
3021 std::fs::write(&f, "otro:100000:65536\nsergio:165536:65536\n").unwrap();
3022 let r = leer_subid(f.to_str().unwrap(), "sergio").unwrap();
3023 assert_eq!((r.inicio, r.cantidad), (165536, 65536));
3024 assert!(leer_subid(f.to_str().unwrap(), "nadie").is_none());
3025 }
3026
3027 #[test]
3028 fn las_caps_de_root_no_incluyen_la_de_montar() {
3029 // CAP_SYS_ADMIN es la que permite `mount`, y montar cuelga de la concesión `nesting`
3030 // declarada. Si se colara acá, `nesting` dejaría de ser una decisión y pasaría a ser el
3031 // comportamiento por defecto — que es justo lo que D7 prohíbe.
3032 assert!(!CAPS_ROOT.contains(&"CAP_SYS_ADMIN"), "{CAPS_ROOT:?}");
3033 // Y las que sí están son las que `apt` y `dpkg` necesitaron de verdad.
3034 for c in ["CAP_SETUID", "CAP_SETGID", "CAP_CHOWN"] {
3035 assert!(CAPS_ROOT.contains(&c), "falta {c}");
3036 }
3037 }
3038
3039 #[test]
3040 fn del_desktop_ajeno_no_sobrevive_nada_ejecutable() {
3041 let (campos, exec) = leer_desktop(
3042 "[Desktop Entry]\nName=Pinentry\nName[es]=Pinentry\nExec=/usr/bin/pinentry-qt --raro\n\
3043 TryExec=/usr/bin/pinentry-qt\nDBusActivatable=true\nPath=/tmp\nIcon=pinentry\n\
3044 X-KDE-Wayland-Interfaces=org_kde_kwin_keystate\n[Desktop Action Otra]\nExec=/mal\n",
3045 );
3046 let claves: Vec<&str> = campos.iter().map(|(k, _)| k.as_str()).collect();
3047 assert!(claves.contains(&"Name") && claves.contains(&"Name[es]") && claves.contains(&"Icon"));
3048 // Lista BLANCA: todo lo que ejecuta queda fuera por definición, no por enumeración.
3049 for prohibida in ["Exec", "TryExec", "Path", "DBusActivatable", "X-KDE-Wayland-Interfaces"] {
3050 assert!(!claves.contains(&prohibida), "se coló {prohibida}: {claves:?}");
3051 }
3052 // El Exec se lee sólo para nombrar el binario y citarlo; nunca se emite.
3053 assert_eq!(exec, "/usr/bin/pinentry-qt --raro");
3054 }
3055
3056 #[test]
3057 fn el_shim_no_se_rompe_con_rutas_raras() {
3058 assert_eq!(shell_quote("/usr/bin/pacman"), "/usr/bin/pacman");
3059 assert_eq!(shell_quote("/con espacio/x"), "'/con espacio/x'");
3060 assert_eq!(shell_quote("a'b"), "'a'\\''b'"); // la comilla se cierra, se escapa y se reabre
3061 assert_eq!(shell_quote("; rm -rf /"), "'; rm -rf /'");
3062 }
3063
3064 #[test]
3065 fn run_as_resuelve_uid_gid_y_home_del_passwd_de_la_imagen() {
3066 let d = tempfile::tempdir().unwrap();
3067 let sha = "f".repeat(64);
3068 imagen_falsa(d.path(), &sha);
3069 let tree = d.path().join("images").join(&sha).join(TREE);
3070 std::fs::write(tree.join("etc/passwd"),
3071 "root:x:0:0::/root:/bin/bash\njugador:x:1000:1000::/home/jugador:/bin/bash\n").unwrap();
3072 let dir = d.path().join("instances/x");
3073 std::fs::create_dir_all(&dir).unwrap();
3074
3075 assert_eq!(usuario_de(&dir, &tree, "jugador").unwrap(), (1000, 1000, "/home/jugador".into()));
3076 assert_eq!(usuario_de(&dir, &tree, "1000").unwrap().0, 1000);
3077 assert!(usuario_de(&dir, &tree, "nadie").is_err(), "un run_as inexistente NO puede caer a root");
3078 // El HOME sale del passwd, no de una constante.
3079 assert_eq!(home_de(&dir, &tree, 1000), "/home/jugador");
3080 assert_eq!(home_de(&dir, &tree, 0), "/root");
3081 }
3082
3083 #[test]
3084 fn la_poda_no_toca_una_imagen_con_instancia_y_si_los_restos() {
3085 let d = tempfile::tempdir().unwrap();
3086 let root = d.path();
3087 let usada = "1".repeat(64);
3088 let huerfana = "2".repeat(64);
3089 imagen_falsa(root, &usada);
3090 imagen_falsa(root, &huerfana);
3091 create(root, "viva", &usada, None).unwrap();
3092 // Un resto de pull a medias: lleva punto justo para no confundirse con una imagen.
3093 std::fs::create_dir_all(root.join("images/.3333.tmp")).unwrap();
3094
3095 // Simulacro: NO borra nada. Es la diferencia entre una poda y un accidente.
3096 prune(root, false, false).unwrap();
3097 assert!(root.join("images").join(&huerfana).exists(), "el simulacro borró");
3098
3099 prune(root, false, true).unwrap();
3100 assert!(root.join("images").join(&usada).exists(), "borró una imagen EN USO");
3101 assert!(!root.join("images").join(&huerfana).exists(), "no borró la huérfana");
3102 assert!(!root.join("images/.3333.tmp").exists(), "no borró el resto");
3103 // La instancia sigue entera: la poda no la toca sin --upper.
3104 assert!(instance_dir(root, "viva").join(INSTANCE_MANIFEST).exists());
3105 assert!(instance_dir(root, "viva").join("upper").exists());
3106 }
3107
3108 #[test]
3109 fn con_upper_la_capa_se_va_pero_la_instancia_queda_usable() {
3110 let d = tempfile::tempdir().unwrap();
3111 let root = d.path();
3112 let sha = "4".repeat(64);
3113 imagen_falsa(root, &sha);
3114 create(root, "i", &sha, None).unwrap();
3115 std::fs::write(instance_dir(root, "i").join("upper/estado"), "x").unwrap();
3116 prune(root, true, true).unwrap();
3117 assert!(!instance_dir(root, "i").join("upper/estado").exists(), "el upper no es caché");
3118 // Y queda utilizable: sin upper/ y work/ la instancia no vuelve a arrancar.
3119 assert!(instance_dir(root, "i").join("upper").is_dir());
3120 assert!(instance_dir(root, "i").join("work").is_dir());
3121 }
3122
3123 #[test]
3124 fn sha_mal_formado_falla_antes_de_tocar_la_red() {
3125 assert!(normalize_sha256("abc").is_err());
3126 assert_eq!(normalize_sha256(&format!("sha256:{}", "A".repeat(64))).unwrap(), "a".repeat(64));
3127 }
3128}