sergio/takana

1#!/usr/bin/env bash
2# attest-boot-test.sh — valida END-TO-END el gate de atestación (I4): hammer firma el seed (arje-packager)
3# y el arje-zero CON gate (arje-zero-attest) lo verifica al arranque. Demuestra ambos caminos:
4#   - íntegro: el gate atesta los binarios críticos ✓ y arranca los servicios (SSH responde);
5#   - TAMPER=1: se altera 1 byte de un binario crítico DESPUÉS de firmar ⇒ el gate (política Halt)
6#     aborta y cae a la shell de rescate (sin SSH) — la integridad comprometida NO levanta el entorno.
7#
8# DOS MODOS:
9#   (A) REAL (preferido) — bootea el `product-attested-rootfs` que produce `hammer bootstrap product
10#       --attest` (init con gate + seed firmada ya hidratados). Es el camino de PRODUCCIÓN, no un spike.
11#       Uso:  PRODUCT_ATTESTED=<hash> ./scripts/attest-boot-test.sh
12#   (B) SPIKE (fallback) — overlaya a mano el arje-zero con gate + firma el seed sobre una copia del
13#       `product-rootfs`. Útil cuando aún no se selló el atestado.
14#       Uso:  PRODUCT=<hash> ./scripts/attest-boot-test.sh
15#   Con TAMPER=1 (en cualquier modo) se altera 1 byte de un binario crítico DESPUÉS de firmar ⇒ HALT.
16set -euo pipefail
17ROOT="$(cd "$(dirname "$0")/.." && pwd)"; cd "$ROOT"
18KERNEL="${KERNEL:-$(ls store/*-linux/boot/bzImage 2>/dev/null | head -1)}"
19MEM="${MEM:-2048}"; KVM="${KVM:-1}"; PORT="${PORT:-2226}"; DEADLINE="${DEADLINE:-130}"
20WORK="$ROOT/work/attest-boot"; RFS="$WORK/rootfs"; LOG="$WORK/console.log"
21
22pick(){ ls -dt store/*-"$1" 2>/dev/null | head -1; }
23rm -rf "$WORK"; mkdir -p "$WORK"
24
25if [ -n "${PRODUCT_ATTESTED:-}" ] || { [ -z "${PRODUCT:-}" ] && PA=$(pick product-attested-rootfs) && [ -n "$PA" ]; }; then
26  # ── MODO A (REAL): el product-attested-rootfs ya trae el init con gate + el seed firmado ──────────
27  if [ -n "${PRODUCT_ATTESTED:-}" ]; then PA=$(ls -d store/"${PRODUCT_ATTESTED#b3:}"*-product-attested-rootfs 2>/dev/null | head -1); fi
28  [ -n "${PA:-}" ] && [ -d "$PA" ] || { echo "falta product-attested-rootfs (corré: hammer bootstrap product --rootfs <base> --attest)"; exit 1; }
29  echo "==> MODO REAL · product-attested $PA"
30  cp -a "$PA"/. "$RFS"/; chmod -R u+w "$RFS"; rm -rf "$RFS/.hammer"
31  echo "==> init con gate + seed firmada ya hidratados por hammer-bootstrap (sin overlay manual)"
32else
33  # ── MODO B (SPIKE): overlay manual del gate + firma sobre el product-rootfs ───────────────────────
34  if [ -n "${PRODUCT:-}" ]; then P=$(ls -d store/"${PRODUCT#b3:}"*-product-rootfs 2>/dev/null | head -1); else P=$(pick product-rootfs); fi
35  GATED=$(pick arje-zero-attest); PKGR=$(pick arje-packager)
36  [ -n "$P" ] && [ -d "$P" ] || { echo "falta product-rootfs"; exit 1; }
37  [ -n "$GATED" ] && [ -e "$GATED/usr/bin/arje-zero" ] || { echo "falta arje-zero-attest (construí recipes/arje-zero-attest.toml)"; exit 1; }
38  [ -n "$PKGR" ] && [ -e "$PKGR/usr/bin/arje-packager" ] || { echo "falta arje-packager"; exit 1; }
39  echo "==> MODO SPIKE · product $P · gated $GATED · packager $PKGR"
40  cp -a "$P"/. "$RFS"/; chmod -R u+w "$RFS"; rm -rf "$RFS/.hammer" "$RFS/ente/attest.json"
41  rm -f "$RFS/usr/bin/arje-zero"; cp "$GATED/usr/bin/arje-zero" "$RFS/usr/bin/arje-zero"; chmod 0755 "$RFS/usr/bin/arje-zero"
42  python3 - "$RFS/ente/seed.card.json" "$WORK/seed-in.json" <<'PY'
43import json,sys
44d=json.load(open(sys.argv[1])); d["attest_policy"]="halt"
45json.dump(d,open(sys.argv[2],"w"),indent=2)
46PY
47  printf 'hammer-attest-dev-rootkey-0001!!' > "$WORK/rootkey.bin"  # rootkey fija ⇒ firmas deterministas
48  "$PKGR/usr/bin/arje-packager" --seed "$WORK/seed-in.json" --rootkey "$WORK/rootkey.bin" \
49    --bin arje-zero="$RFS/usr/bin/arje-zero" --bin hammerd="$RFS/usr/bin/hammerd" \
50    --bin console-getty="$RFS/bin/busybox" --bin sshd="$RFS/bin/busybox" \
51    --seed-out "$RFS/ente/seed.card.json" 2>&1 | sed 's/^/   /'
52  echo "==> seed firmado inyectado en /ente/seed.card.json (attest_policy=halt)"
53fi
54
55# TAMPER: alterar 1 byte de un binario crítico DESPUÉS de firmar (su hash ya no casa la concesión)
56if [ "${TAMPER:-0}" = 1 ]; then
57  B="$RFS/usr/bin/hammerd"; sz=$(stat -c%s "$B"); head -c "$sz" "$B" > "$B.n"; printf '\xde' | dd of="$B.n" bs=1 seek=64 count=1 conv=notrunc status=none; mv "$B.n" "$B"; chmod 0755 "$B"
58  echo "==> TAMPER: /usr/bin/hammerd alterado tras la firma — el gate debe HALT"
59fi
60
61# SEED_REWRITE: el ataque que el ANCLA SOBERANA (#3) cierra. Un atacante reescribe el seed firmando los
62# binarios con SU rootkey y declara su pubkey en attest_rootkey (seed auto-consistente). Pero /etc/arje/
63# rootkey.pub (la pubkey LEGÍTIMA, fuera de la Card) queda intacta ⇒ el gate exige firmas del ancla ⇒ las
64# concesiones del atacante caen en AutorNoConfiable ⇒ Halt. Sin ancla, este seed arrancaría (hueco de A2).
65if [ "${SEED_REWRITE:-0}" = 1 ]; then
66  PKGR=$(pick arje-packager)
67  [ -n "$PKGR" ] && [ -e "$PKGR/usr/bin/arje-packager" ] || { echo "falta arje-packager para SEED_REWRITE"; exit 1; }
68  [ -e "$RFS/etc/arje/rootkey.pub" ] || { echo "el product-attested-rootfs no trae /etc/arje/rootkey.pub (¿v2?)"; exit 1; }
69  python3 - "$RFS/ente/seed.card.json" "$WORK/rewrite-in.json" <<'PY'
70import json,sys
71d=json.load(open(sys.argv[1])); d.pop("attest",None); d.pop("attest_rootkey",None); d["attest_policy"]="halt"
72json.dump(d,open(sys.argv[2],"w"),indent=2)
73PY
74  printf 'hammer-EVIL-rootkey-attacker-001' > "$WORK/evil.bin"  # 32 bytes, ≠ la rootkey legítima
75  "$PKGR/usr/bin/arje-packager" --seed "$WORK/rewrite-in.json" --rootkey "$WORK/evil.bin" \
76    --bin arje-zero="$RFS/usr/bin/arje-zero" --bin hammerd="$RFS/usr/bin/hammerd" \
77    --bin console-getty="$RFS/bin/busybox" --bin sshd="$RFS/bin/busybox" \
78    --seed-out "$RFS/ente/seed.card.json" >/dev/null 2>&1
79  echo "==> SEED_REWRITE: seed re-firmado con rootkey ATACANTE; /etc/arje/rootkey.pub legítima intacta — el gate debe HALT"
80fi
81
82# authorized_keys de prueba + empaquetar (root-owned)
83KG=$(ls store/*-openssh/usr/bin/ssh-keygen|head -1); "$KG" -t ed25519 -N '' -f "$WORK/clientkey" -q
84install -d -m 0700 "$RFS/root/.ssh"; cat "$WORK/clientkey.pub" > "$RFS/root/.ssh/authorized_keys"; chmod 0600 "$RFS/root/.ssh/authorized_keys"
85( cd "$RFS" && find . -print0 | cpio --null -o -H newc -R 0:0 2>/dev/null | gzip -1 ) > "$WORK/initramfs.cpio.gz"
86
87# boot
88accel=(-cpu Broadwell); { [ "$KVM" = 1 ] && [ -w /dev/kvm ]; } && accel=(-enable-kvm -cpu host)
89echo "==> boot QEMU (hostfwd :$PORT->:22)"
90qemu-system-x86_64 -m "$MEM" -no-reboot -nographic "${accel[@]}" -kernel "$KERNEL" -initrd "$WORK/initramfs.cpio.gz" \
91  -append "console=ttyS0 rdinit=/sbin/init" -netdev "user,id=n0,hostfwd=tcp::$PORT-:22" -device e1000,netdev=n0 > "$LOG" 2>&1 &
92QPID=$!; trap 'kill $QPID 2>/dev/null || true' EXIT
93SSHOPTS=(-p "$PORT" -i "$WORK/clientkey" -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o GlobalKnownHostsFile=/dev/null -o PasswordAuthentication=no -o ConnectTimeout=4 -o LogLevel=ERROR)
94echo "==> esperando (deadline ${DEADLINE}s)…"; start=$(date +%s); ssh_ok=0
95while [ $(( $(date +%s) - start )) -lt "$DEADLINE" ]; do
96  kill -0 $QPID 2>/dev/null || break
97  if out=$(ssh "${SSHOPTS[@]}" root@localhost 'echo ATTEST_SSH_OK; uname -sr' 2>/dev/null); then echo "$out"|grep -q ATTEST_SSH_OK && ssh_ok=1 && break; fi
98  sleep 3
99done
100sleep 2; echo "---- consola: líneas de atestación ----"; grep -iE "atestaci|attest|ATESTACIÓN|integridad|rescate|ARRANQUE FALLIDO|✓|✗" "$LOG" | head -20
101
102# veredicto
103echo "========================================"
104if [ "${TAMPER:-0}" = 1 ] || [ "${SEED_REWRITE:-0}" = 1 ]; then
105  caso=$([ "${SEED_REWRITE:-0}" = 1 ] && echo "SEED_REWRITE" || echo "TAMPER")
106  if [ "$ssh_ok" = 0 ] && grep -qiE "ATESTACIÓN FALLÓ|atestación al arranque falló|ARRANQUE FALLIDO|rescate" "$LOG"; then
107    echo "*** $caso OK — el gate detectó el ataque y HALTeó (sin SSH) ***"; exit 0
108  else
109    echo "*** $caso FALLÓ — el sistema arrancó pese al ataque (ssh_ok=$ssh_ok) ***"; exit 1
110  fi
111else
112  oks=$(grep -c "atestación ✓" "$LOG" 2>/dev/null || echo 0)
113  if [ "$ssh_ok" = 1 ] && [ "$oks" -ge 1 ] && ! grep -qiE "ATESTACIÓN FALLÓ|atestación al arranque falló" "$LOG"; then
114    echo "*** ATTEST OK — el gate atestó $oks binarios críticos ✓ y arrancó los servicios (SSH) ***"; exit 0
115  else
116    echo "*** ATTEST FALLÓ — íntegro pero no atestó/no SSH (ssh_ok=$ssh_ok, oks=$oks) ***"; exit 1
117  fi
118fi