From e9f535a1bbf5c62d9db81f5d578210fd5f5c55df Mon Sep 17 00:00:00 2001 From: sergio Date: Sat, 13 Jun 2026 20:05:55 -0400 Subject: [PATCH] =?UTF-8?q?selfhost-verify:=20pieza=204=20(bwrap=20swap)?= =?UTF-8?q?=20+=20materializaci=C3=B3n=20de=20build-deps=20en=20el=20lab?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cuarta pieza del toolchain hammer-from-source (variante b, SDD 11 §7.2b): bubblewrap, el sandbox del propio lab. Binario estático ⇒ swap de archivo sobre /toolchain/usr/bin/bwrap. Como herramienta del toolchain (no input del 4/4) no necesita casar byte-a-byte con Alpine, sólo aislar igual. Tres piezas: - recipes/libcap.toml (2.78): dep obligatoria de bwrap; el toolchain Alpine no trae el -dev (libcap.a / sys/capability.h). Build estático musl con zig cc, sin patches (es tool, no input). - materialización de build-deps (hammer-build): deps.build ahora se CONSTRUYE recursivamente (build() llama build() por cada dep) y cada artefacto sellado se apila como capa --overlay-src bajo el rootfs del sandbox, dejando usr/{include,lib,lib/pkgconfig} en /usr. pkgconf y zig cc las hallan sin plumbing de flags. Recetas sin deps: sandbox byte-igual (baseline intacto). Tests nuevos: no_deps_emits_single_overlay_src, deps_stack_as_overlay_layers_under_rootfs. - recipes/bwrap.toml (0.11.0): el toolchain no trae meson/ninja/python, así que bypaseamos meson compilando los 4 .c de bubblewrap directo con zig cc (+config.h trivial). deps.build=["libcap"]. Validación host fuerte: hammer-bwrap es estático, corre --version y sandboxea, y musl rebuildeó BYTE-IDÉNTICO usándolo de sandbox (bisección). Expuesto con SWAP_BWRAP=1. Tests verdes. Pendiente: corrida in-VM acumulando swaps para el sello ✓ REPRODUCIBLE. Co-Authored-By: Claude Opus 4.8 --- crates/hammer-build/src/lib.rs | 43 ++++++++++++++++++++++ crates/hammer-build/src/sandbox.rs | 57 +++++++++++++++++++++++++++++- docs/10-roadmap.md | 19 ++++++++-- recipes/bwrap.toml | 47 ++++++++++++++++++++++++ recipes/libcap.toml | 35 ++++++++++++++++++ scripts/selfhost-verify.sh | 18 +++++++++- 6 files changed, 214 insertions(+), 5 deletions(-) create mode 100644 recipes/bwrap.toml create mode 100644 recipes/libcap.toml diff --git a/crates/hammer-build/src/lib.rs b/crates/hammer-build/src/lib.rs index 03b1de93..b7122dc8 100644 --- a/crates/hammer-build/src/lib.rs +++ b/crates/hammer-build/src/lib.rs @@ -82,6 +82,41 @@ fn resolve_build_dep_hashes( Ok(hashes) } +/// Construye (si falta) cada `deps.build` y devuelve sus directorios sellados en el store, para +/// apilarlos como capas overlay del sandbox (variante b: bwrap necesita libcap.a + sys/capability.h, +/// ausentes del toolchain Alpine). Recursivo vía `build`: una dep con sus propias deps se materializa +/// transitivamente. Los ciclos ya los corta `artifact_hash` (con su `stack`) antes de llegar acá. +fn materialize_build_deps( + recipe: &Recipe, + cfg: &BuildConfig, + store: &Store, +) -> hammer_core::Result> { + if recipe.deps.build.is_empty() { + return Ok(Vec::new()); + } + if recipe.base_dir.as_os_str().is_empty() { + return Err(hammer_core::Error::Recipe(format!( + "la receta '{}' declara deps de build {:?} pero no tiene base_dir; \ + cárgala con Recipe::load_from_path para resolver el catálogo", + recipe.name, recipe.deps.build + ))); + } + let mut dirs = Vec::with_capacity(recipe.deps.build.len()); + for dep in &recipe.deps.build { + let dep_path = recipe.base_dir.join(format!("{dep}.toml")); + let dep_recipe = Recipe::load_from_path(&dep_path).map_err(|e| { + hammer_core::Error::Recipe(format!( + "no pude cargar la dep de build '{dep}' de '{}' ({}): {e}", + recipe.name, + dep_path.display() + )) + })?; + let dep_hash = build(&dep_recipe, cfg, store)?; + dirs.push(store.path_of(&dep_hash, &dep_recipe.name)); + } + Ok(dirs) +} + /// Compila una receta y devuelve el hash del artefacto sellado en el store. /// Si el hash ya existe en el store, devuelve sin recompilar (caché). pub fn build( @@ -96,6 +131,13 @@ pub fn build( } sandbox::ensure_layout(&cfg.rootfs, &cfg.zig_dir)?; + // Materializa las deps de build (las construye si faltan) ANTES del fetch: sus árboles sellados + // se apilan como capas overlay del sandbox para que headers/libs/pkgconfig estén en /usr. + let dep_dirs = materialize_build_deps(recipe, cfg, store)?; + if !dep_dirs.is_empty() { + tracing::info!(n = dep_dirs.len(), "deps de build materializadas como capas overlay"); + } + tracing::info!(hash = %h, name = %recipe.name, "fetch"); let src_tree = fetch::fetch(recipe, &cfg.work_root)?; @@ -127,6 +169,7 @@ pub fn build( src_dir: src_tree.clone(), out_dir: out_dir.clone(), cache_dir: cfg.cache_root.clone(), + deps: dep_dirs, env, }; diff --git a/crates/hammer-build/src/sandbox.rs b/crates/hammer-build/src/sandbox.rs index 0c15fcc3..1c20e649 100644 --- a/crates/hammer-build/src/sandbox.rs +++ b/crates/hammer-build/src/sandbox.rs @@ -66,6 +66,11 @@ pub struct Sandbox { /// Si Some, se bindea RW como `/cache` y se setea `ZIG_GLOBAL_CACHE_DIR=/cache/zig`. /// Persistir esta caché entre builds evita que `zig cc` recompile musl cada vez (~30s). pub cache_dir: Option, + /// Directorios sellados de las `deps.build` (artefactos ya construidos en el store). Cada uno se + /// apila como capa overlay read-only BAJO el rootfs Alpine, así sus `usr/{include,lib,lib/pkgconfig}` + /// aparecen en las rutas estándar de `/usr` — el compilador y pkgconf los ven sin plumbing de flags. + /// Vacío ⇒ ninguna capa extra ⇒ el sandbox es idéntico al de una receta sin deps (baseline intacto). + pub deps: Vec, /// Vars de entorno extra inyectadas además del set por defecto. pub env: Vec<(String, String)>, } @@ -125,6 +130,15 @@ impl Sandbox { let mut args: Vec = vec![ "--overlay-src".into(), self.rootfs.display().to_string(), + ]; + // Capas overlay de las deps de build, apiladas bajo el rootfs (mismo `--tmp-overlay /`). bwrap + // admite múltiples `--overlay-src` para un overlay; los `usr/{include,lib}` de cada dep se + // funden con los del rootfs en `/usr`. Sólo se emiten si hay deps (compat hacia atrás). + for dep in &self.deps { + args.push("--overlay-src".into()); + args.push(dep.display().to_string()); + } + args.extend([ "--tmp-overlay".into(), "/".into(), "--proc".into(), @@ -146,7 +160,7 @@ impl Sandbox { "/src".into(), "--unshare-all".into(), "--die-with-parent".into(), - ]; + ]); if let Some(cache) = &self.cache_dir { args.push("--bind".into()); @@ -304,4 +318,45 @@ mod tests { let err = hammer_core::Error::Recipe("nope".into()); assert!(BuildFailure::from_error(&err).is_none()); } + + fn fixture(deps: Vec) -> Sandbox { + Sandbox { + rootfs: PathBuf::from("/rootfs"), + zig_dir: PathBuf::from("/zig"), + src_dir: PathBuf::from("/src-host"), + out_dir: PathBuf::from("/out-host"), + cache_dir: None, + deps, + env: vec![], + } + } + + #[test] + fn no_deps_emits_single_overlay_src() { + // Compat hacia atrás: sin deps, una sola capa overlay (el rootfs) — sandbox idéntico al previo. + let args = fixture(vec![]).bwrap_args("true"); + let n = args.iter().filter(|a| *a == "--overlay-src").count(); + assert_eq!(n, 1, "sin deps ⇒ un único --overlay-src"); + // El --tmp-overlay viene inmediatamente tras el rootfs. + let i = args.iter().position(|a| a == "--overlay-src").unwrap(); + assert_eq!(args[i + 1], "/rootfs"); + assert_eq!(args[i + 2], "--tmp-overlay"); + } + + #[test] + fn deps_stack_as_overlay_layers_under_rootfs() { + let args = fixture(vec![PathBuf::from("/dep/libcap"), PathBuf::from("/dep/zlib")]) + .bwrap_args("true"); + // rootfs + 2 deps = 3 capas overlay, todas antes del --tmp-overlay. + let srcs: Vec<&String> = args + .iter() + .enumerate() + .filter(|(_, a)| *a == "--overlay-src") + .map(|(i, _)| &args[i + 1]) + .collect(); + assert_eq!(srcs, vec!["/rootfs", "/dep/libcap", "/dep/zlib"]); + let to = args.iter().position(|a| a == "--tmp-overlay").unwrap(); + let last_src = args.iter().rposition(|a| a == "--overlay-src").unwrap(); + assert!(last_src < to, "todas las capas overlay van antes del --tmp-overlay"); + } } diff --git a/docs/10-roadmap.md b/docs/10-roadmap.md index 1cd0bf29..d1821303 100644 --- a/docs/10-roadmap.md +++ b/docs/10-roadmap.md @@ -269,9 +269,22 @@ Diseño completo en [SDD 11 — Bootstrap from-scratch](11-bootstrap.md). Resume se pisan sobre la salida. Criterio de éxito fuerte alcanzado: **`diff -r` del header-tree hammer contra el de Alpine = vacío** ⇒ el toolchain swapeado es byte-idéntico al baseline ⇒ todo lo que compile abajo reproduce de por sí (garantía por construcción, más fuerte que un rebuild). Expuesto con - `SWAP_LINUX_HEADERS=1`; ensamblado end-to-end en host OK. **Pendiente:** la corrida in-VM - (`KVM=1 MEM=24576 SWAP_LINUX_HEADERS=1 ./scripts/selfhost-verify.sh`) para el sello `✓ REPRODUCIBLE`, - y seguir con bwrap → rust/llvm (cada una swapeada y re-verificada igual). + `SWAP_LINUX_HEADERS=1`; ensamblado end-to-end en host OK. Falta sólo la corrida in-VM para el sello. + **Pieza 4 — bwrap (`recipes/bwrap.toml`, bubblewrap 0.11.0, validada en host):** EL sandbox del propio + lab (`hammer-build/src/sandbox.rs`). Binario estático ⇒ swap de archivo sobre `/toolchain/usr/bin/bwrap`. + Como tool del toolchain (no input del 4/4) NO necesita casar byte-a-byte con Alpine, sólo aislar igual. + Tres sub-hallazgos que la hicieron más jugosa que make/busybox: (1) el toolchain Alpine no trae meson/ + ninja/python — bypaseamos meson compilando los 4 `.c` de bubblewrap directo con `zig cc` (+`config.h` + trivial generado a mano); (2) depende de **libcap**, cuyo -dev (libcap.a + `sys/capability.h`) tampoco + está en el toolchain ⇒ nueva receta `recipes/libcap.toml`; (3) para que el build de bwrap viera libcap se + agregó **materialización de build-deps** al lab: `deps.build` ahora se construye recursivamente y cada + artefacto sellado se apila como capa `--overlay-src` BAJO el rootfs del sandbox, dejando sus + `usr/{include,lib,lib/pkgconfig}` en `/usr` — pkgconf y zig cc los hallan sin plumbing de flags (recetas + sin deps quedan byte-iguales, baseline intacto). Validación host fuerte: hammer-bwrap es estático, corre + `--version`/sandboxea, y **musl rebuildeó byte-idéntico** usándolo de sandbox (bisección). Expuesto con + `SWAP_BWRAP=1`. **Pendiente:** correr in-VM acumulando los swaps + (`KVM=1 MEM=24576 SWAP_MAKE=1 SWAP_BUSYBOX=1 SWAP_LINUX_HEADERS=1 SWAP_BWRAP=1 ./scripts/selfhost-verify.sh`) + para el `✓ REPRODUCIBLE`, y seguir con la última pieza: rust/llvm (la grande — ya hay infra de deps). - ⏭️ **También pendiente (Stage 1):** bus único (B.2: exponer el `CRASHED` a la capa de IA) y atestación arje (A1/A2). diff --git a/recipes/bwrap.toml b/recipes/bwrap.toml new file mode 100644 index 00000000..b748cd1e --- /dev/null +++ b/recipes/bwrap.toml @@ -0,0 +1,47 @@ +# bubblewrap (bwrap) 0.11.0 — pieza 4 del toolchain hammer-from-source (SDD 11 §7.2b). +# +# bwrap es EL sandbox del lab: cada build hermético corre dentro de `bwrap` (ver +# hammer-build/src/sandbox.rs). Reemplazar el bwrap de Alpine por uno construido por hammer cierra +# otra dependencia del toolchain. Como make/busybox/linux-headers, se monta sobre /toolchain con el +# swap del builder (variante b) — aquí un swap de BINARIO (`--swap bwrap=:usr/bin/bwrap`). +# +# bwrap NO necesita casar byte-a-byte con el de Alpine: es una herramienta del toolchain, no un input +# del 4/4. Cualquier bwrap funcional aísla igual (mismos namespaces/mounts ⇒ mismos outputs), así que +# la reproducibilidad de of_tree(stage1') se mantiene mientras bwrap sandboxee correctamente. +# +# Por qué NO meson: bubblewrap 0.11 usa meson+ninja+python, AUSENTES del toolchain Alpine. Pero el +# proyecto es 4 archivos .c + un `config.h` trivial; los compilamos directo con `zig cc` estático, +# evitando el meson por completo. Es el mismo binario, sólo otro driver de build. +# +# libcap es dependencia obligatoria (bubblewrap.c hace `#include ` y llama `cap_*`). +# El toolchain Alpine trae sólo el .so runtime, no el -dev; por eso `deps.build = ["libcap"]`: el lab +# construye libcap y apila su árbol como capa overlay del sandbox, dejando libcap.a + sys/capability.h +# + libcap.pc en /usr — pkgconf y zig cc los ven en las rutas estándar (ver materialize_build_deps). + +name = "bwrap" +version = "0.11.0" + +[source] +tarball = "https://github.com/containers/bubblewrap/releases/download/v0.11.0/bubblewrap-0.11.0.tar.xz" +sha256 = "988fd6b232dafa04b8b8198723efeaccdb3c6aa9c1c7936219d5791a8b7a8646" + +[build] +compiler = "zig-cc" +target = "x86_64-linux-musl" +link = "static" + +[deps] +build = ["libcap"] + +[build.phases] +# El árbol detecta como BuildSys::Meson ⇒ el default `meson setup` fallaría (no hay meson). Override +# de las 3 fases para compilar a mano con zig cc. +# configure: generar el `config.h` que meson produciría. Sólo PACKAGE_STRING es necesario; HAVE_SELINUX +# y ENABLE_REQUIRE_USERNS son #ifdef opcionales (los dejamos sin definir: sin SELinux, sin require_userns). +configure = "printf '#define PACKAGE_STRING \"bubblewrap 0.11.0\"\\n' > config.h" +# compile: los 4 .c estáticos contra musl + libcap. -D_GNU_SOURCE lo añade meson (bwrap usa clearenv, +# MS_*, etc.). -lcap -lpsx desde /usr/lib (la capa overlay de la dep libcap). -mcpu=baseline por +# reproducibilidad CPU-independiente (igual que el resto del lab). +compile = "zig cc -mcpu=baseline -static -O2 -D_GNU_SOURCE -I. bubblewrap.c bind-mount.c network.c utils.c -L/usr/lib -lcap -lpsx -o bwrap" +# install: el binario a /usr/bin/bwrap, donde lo espera el swap del builder. +install = "mkdir -p /out/usr/bin && cp bwrap /out/usr/bin/bwrap" diff --git a/recipes/libcap.toml b/recipes/libcap.toml new file mode 100644 index 00000000..16c1d020 --- /dev/null +++ b/recipes/libcap.toml @@ -0,0 +1,35 @@ +# libcap 2.78 — dependencia de build de bwrap (pieza 4 del toolchain hammer-from-source, SDD 11 §7.2b). +# +# bubblewrap usa libcap para soltar/levantar capabilities al armar el sandbox; su `bubblewrap.c` hace +# `#include ` y llama `cap_*`. El toolchain Alpine trae el .so runtime pero NO el +# -dev (ni `sys/capability.h` ni `libcap.a`), así que para compilar bwrap estático necesitamos libcap +# construido por hammer y materializado en el sandbox (ver deps.build de bwrap.toml + sandbox.rs). +# +# A diferencia de linux-headers, libcap NO necesita casar byte-a-byte con la de Alpine: es una pieza +# del TOOLCHAIN (se enlaza dentro de bwrap, una herramienta), no un input del 4/4. Cualquier libcap +# funcional sirve mientras bwrap aísle igual. Por eso sin patches de Alpine: build vainilla y listo. +# +# Build estático musl con zig cc. libcap usa un Makefile plano (no autotools): hay que pasar los +# overrides de toolchain por línea de comando y apagar lo que pide deps ausentes: +# GOLANG=no — sin bindings Go (no hay go en el sandbox). +# PAM_CAP=no — sin el módulo PAM (no hay libpam). +# SHARED=no — sólo estático; no generamos .so (bwrap linkea libcap.a). +# BUILD_CC — el compilador HOST para los toolitos generadores (_makenames/mkconst); zig cc igual. + +name = "libcap" +version = "2.78" + +[source] +tarball = "https://mirrors.edge.kernel.org/pub/linux/libs/security/linux-privs/libcap2/libcap-2.78.tar.gz" +sha256 = "2a2c705e382c413643a458b837575c0eb0989477ab6fb99c87adbe9a259612ad" + +[build] +compiler = "zig-cc" +target = "x86_64-linux-musl" +link = "static" + +[build.phases] +# El árbol de libcap detecta como BuildSys::Make ⇒ el compile/install por defecto no pasa los +# overrides de toolchain ni las flags GOLANG/PAM. Override explícito de ambas fases. +compile = "make CC='zig cc -mcpu=baseline' BUILD_CC='zig cc -mcpu=baseline' AR='zig ar' RANLIB='zig ranlib' OBJCOPY='zig objcopy' GOLANG=no PAM_CAP=no SHARED=no lib=lib" +install = "make CC='zig cc -mcpu=baseline' BUILD_CC='zig cc -mcpu=baseline' AR='zig ar' RANLIB='zig ranlib' OBJCOPY='zig objcopy' GOLANG=no PAM_CAP=no SHARED=no lib=lib prefix=/usr DESTDIR=/out install" diff --git a/scripts/selfhost-verify.sh b/scripts/selfhost-verify.sh index c2345abd..c6bbabd9 100755 --- a/scripts/selfhost-verify.sh +++ b/scripts/selfhost-verify.sh @@ -117,9 +117,14 @@ done # SWAP_BUSYBOX=1 → monta el busybox de hammer sobre /toolchain/bin/busybox (los symlinks de # applets de Alpine — sh/sed/grep/awk/tar/find — pasan a usarlo; cp/mkdir/ # install siguen siendo GNU coreutils, intactos). +# SWAP_LINUX_HEADERS=1 → construye recipes/linux-headers.toml y swap-directorio de los 13 subdirs +# kernel-owned de /toolchain/usr/include (linux/asm/…); musl bits/sys intactos. +# SWAP_BWRAP=1 → construye recipes/bwrap.toml (+libcap, su dep, vía deps.build) y lo monta +# sobre /toolchain/usr/bin/bwrap (el sandbox del propio lab). # SWAPS="name=hash[:rel] …" → swaps explícitos extra (formato del flag --swap). # Por defecto, off ⇒ corrida pura-Alpine (variante a), idéntica a la baseline conocida-buena. -# Ambas piezas validadas en host: con make+busybox de hammer los 4/4 reproducen of_tree=9adefb82. +# Piezas validadas en host: make+busybox reproducen of_tree=9adefb82 in-VM; linux-headers da un +# header-tree byte-idéntico a Alpine (diff -r vacío); bwrap rebuildea musl byte-idéntico de sandbox. SWAP_ARGS=() if [[ "${SWAP_MAKE:-0}" == 1 ]]; then say "variante b — construir make desde fuente (recipes/make.toml) y swapearlo en /toolchain" @@ -152,6 +157,17 @@ if [[ "${SWAP_LINUX_HEADERS:-0}" == 1 ]]; then SWAP_ARGS+=(--swap "linux-headers=${LH_HASH}:usr/include/$sub") done fi +if [[ "${SWAP_BWRAP:-0}" == 1 ]]; then + # Pieza 4: bwrap (bubblewrap), EL sandbox del lab. Binario estático ⇒ swap de archivo sobre + # /toolchain/usr/bin/bwrap. Su dep libcap la construye y materializa el lab solo (deps.build). + # bwrap es herramienta, no input del 4/4: no necesita casar byte-a-byte con Alpine, sólo aislar + # igual (validado en host — musl rebuildeó byte-idéntico bajo hammer-bwrap). + say "variante b — construir bwrap (+libcap) desde fuente y swapearlo en /toolchain/usr/bin/bwrap" + BW_HASH="$("$HAMMER" --store "$STORE" build recipes/bwrap.toml | grep -oE 'b3:[0-9a-f]{64}' | tail -1)" + [[ "$BW_HASH" == b3:* ]] || die "no obtuve el hash sellado de bwrap" + say "bwrap hammer: $BW_HASH" + SWAP_ARGS+=(--swap "bwrap=${BW_HASH}:usr/bin/bwrap") +fi for s in ${SWAPS:-}; do SWAP_ARGS+=(--swap "$s"); done # 4) Ensamblar el builder con la referencia embebida.