#!/usr/bin/env bash
# Prueba local del sshd en contenedor + nginx (sin tocar ningún servidor).
# Una CA de prueba hace el papel de Vault: firma certificados SSH con principal al_<id>.
# Requiere Docker y OpenSSH en la máquina. Uso:  bash relay/relay-sshd/test-local.sh
set -uo pipefail
cd "$(dirname "$0")"

P=relaytest; VOL=relay-sockets-test; PORT=22223; NGX=19443; TLS=18543   # no 18443: lo usa el Traefik del borde en esta máquina
T=$(mktemp -d); PIDS=(); TUN_PID=
pass=0; fail=0
ok(){ printf '  \033[32m✔\033[0m %s\n' "$1"; pass=$((pass+1)); }
ko(){ printf '  \033[31m✘\033[0m %s\n' "$1"; fail=$((fail+1)); }
chk(){ local d=$1; shift; if "$@" >/dev/null 2>&1; then ok "$d"; else ko "$d"; fi; }
hdr(){ printf '\n\033[1m%s\033[0m\n' "$1"; }
wait_for(){ local n=$1; shift; for _ in $(seq 1 "$n"); do "$@" >/dev/null 2>&1 && return 0; sleep 1; done; return 1; }
dx(){ docker exec relay-sshd "$@"; }
ngx(){ docker exec nginx-test "$@"; }
# tmo <segundos> cmd...: como timeout, pero admite funciones de shell (devuelve 124 si agota el tiempo)
tmo(){ local n=$1 p i=0; shift; "$@" & p=$!
  while kill -0 "$p" 2>/dev/null && [ $i -lt $((n*10)) ]; do sleep 0.1; i=$((i+1)); done
  if kill -0 "$p" 2>/dev/null; then kill "$p" 2>/dev/null; wait "$p" 2>/dev/null; return 124; fi
  wait "$p"; }

cleanup(){
  for p in "${PIDS[@]:-}"; do [ -n "$p" ] && kill "$p" 2>/dev/null; done
  docker rm -f nginx-test >/dev/null 2>&1
  RELAY_CONF_DIR="$T/conf" RELAY_SOCKETS_VOLUME=$VOL docker compose -p $P down -v >/dev/null 2>&1
  docker volume rm $VOL >/dev/null 2>&1
  rm -rf "$T"
}
trap cleanup EXIT

SSHO=(-F /dev/null -p $PORT -o BatchMode=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile="$T/kh"
      -o IdentitiesOnly=yes -o ConnectTimeout=8 -o LogLevel=ERROR)
# sshc <usuario> <clave> [args ssh...]  -> entra como al_<usuario> con el certificado <clave>-cert.pub
sshc(){ local u=$1 k=$2; shift 2; ssh "${SSHO[@]}" -i "$k" -o CertificateFile="$k-cert.pub" "al_$u@127.0.0.1" "$@"; }
# sign <usuario> <clave> <ca> [validez]
sign(){ ssh-keygen -q -s "$3" -I "test-$1" -n "al_$1" -V "${4:-+30m}" -O clear -O permit-port-forwarding "$2.pub"; }
# tun <usuario> <clave> <socket remoto>  -> abre -R en segundo plano; pid en TUN_PID
tun(){ local u=$1 k=$2 r=$3
  sshc "$u" "$k" -N -o ExitOnForwardFailure=yes -R "$r:127.0.0.1:$TLS" >"$T/tun_$u.log" 2>&1 &
  TUN_PID=$!; PIDS+=("$TUN_PID"); }
denied(){ local d=$1 o; shift; o=$(tmo 15 "$@" 2>&1)
  if echo "$o" | grep -q "Permission denied"; then ok "$d"; else ko "$d (salida: ${o:0:70} | sshd: $(docker logs relay-sshd 2>&1 | grep -i -E 'penal|refus|drop|too many' | tail -1 | cut -c1-110))"; fi; }
fwdfail(){ local d=$1 rc; shift; tmo 12 "$@" >"$T/o" 2>&1; rc=$?
  if [ $rc -ne 124 ] && grep -qi "forwarding failed" "$T/o"; then ok "$d"; else ko "$d (rc=$rc: $(head -c 90 "$T/o"))"; fi; }

hdr "Preparación"
mkdir -p "$T/conf"
ssh-keygen -q -t ed25519 -N '' -f "$T/ca"; ssh-keygen -q -t ed25519 -N '' -f "$T/ca2"
cp "$T/ca.pub" "$T/conf/ca.pub"; printf 'ana\nluis\n' > "$T/conf/alumnos.txt"
for u in ana luis eva mal exp plain; do ssh-keygen -q -t ed25519 -N '' -f "$T/k_$u"; done
sign ana  "$T/k_ana" "$T/ca"; sign luis "$T/k_luis" "$T/ca"; sign eva "$T/k_eva" "$T/ca"
sign ana  "$T/k_mal" "$T/ca2"                       # certificado de ana firmado por OTRA CA
sign ana  "$T/k_exp" "$T/ca" "-2h:-1h"              # certificado ya caducado
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes -days 1 -subj "/CN=alumno-local" \
  -keyout "$T/s.key" -out "$T/s.crt" 2>/dev/null

docker volume create $VOL >/dev/null
docker build -q -t relay-alumnos-nginx:1 ../nginx >/dev/null
RELAY_CONF_DIR="$T/conf" SYNC_INTERVAL=3 RELAY_SSH_PORT=$PORT RELAY_SOCKETS_VOLUME=$VOL \
  docker compose -p $P up -d --build 2>&1 | tail -1
docker run -d --name nginx-test -p 127.0.0.1:$NGX:9443 \
  -v "$PWD/../nginx/nginx.conf:/etc/nginx/nginx.conf:ro" -v $VOL:/var/lib/alumnos:ro relay-alumnos-nginx:1 >/dev/null
openssl s_server -accept 127.0.0.1:$TLS -cert "$T/s.crt" -key "$T/s.key" -www >/dev/null 2>&1 & PIDS+=($!)
chk "sshd en contenedor escuchando" wait_for 40 nc -z 127.0.0.1 $PORT
chk "cuentas creadas desde alumnos.txt (al_ana, al_luis)" wait_for 20 bash -c 'docker exec relay-sshd id al_ana && docker exec relay-sshd id al_luis'
chk "política sshd: MaxStartups 200:30:600 y AuthorizedKeysFile none" bash -c \
  'o=$(docker exec relay-sshd sshd -T); echo "$o" | grep -q "^maxstartups 200:30:600" && echo "$o" | grep -q "^authorizedkeysfile none"'

l=$(ngx stat -c '%A %g' /var/lib/alumnos/ana 2>&1)
if [ "$l" = "drwxr-s--- 2000" ]; then ok "directorio del alumno con setgid y grupo nginxsock (gid 2000)"; else ko "directorio del alumno SIN setgid/grupo correcto (visto: $l) -> falta CAP_FSETID"; fi

hdr "A. Autenticación con certificados"
tun ana "$T/k_ana" /var/lib/alumnos/ana/web.sock; ANA=$TUN_PID
chk "túnel de ana abre el socket y nginx lo ve (volumen compartido)" wait_for 12 ngx test -S /var/lib/alumnos/ana/web.sock
l=$(ngx ls -ln /var/lib/alumnos/ana/ 2>&1; ngx ls -l /var/lib/alumnos/ana/web.sock 2>&1)
if echo "$l" | grep -q 'srw-rw----.*nginxsock'; then ok "socket srw-rw---- con grupo nginxsock (setgid)"; else ko "socket srw-rw---- con grupo nginxsock (visto: $(echo "$l" | tr '\n' '|' | cut -c1-200))"; fi
r=$(curl -sk -m 8 --resolve x.ana.alumnos.codecrypto.dev:$NGX:127.0.0.1 https://x.ana.alumnos.codecrypto.dev:$NGX/ 2>&1)
if echo "$r" | grep -q s_server; then ok "extremo a extremo: x.ana.alumnos… -> nginx -> socket -> ssh -R -> servidor TLS del alumno"
else ko "extremo a extremo (curl: ${r:0:60} | nginx: $(docker logs nginx-test 2>&1 | tail -2 | tr '\n' ' ' | cut -c1-260))"; fi
chk "varios niveles: a.b.c.ana.alumnos… llega al mismo socket" bash -c \
  "curl -sk -m 8 --resolve a.b.c.ana.alumnos.codecrypto.dev:$NGX:127.0.0.1 https://a.b.c.ana.alumnos.codecrypto.dev:$NGX/ | grep -q s_server"
denied "el certificado de ana NO sirve para entrar como luis (principal distinto)" sshc luis "$T/k_ana" true
denied "una clave sin certificado se rechaza" ssh "${SSHO[@]}" -i "$T/k_plain" al_ana@127.0.0.1 true
denied "certificado firmado por otra CA se rechaza" sshc ana "$T/k_mal" true
denied "certificado caducado se rechaza" sshc ana "$T/k_exp" true
denied "certificado válido pero sin cuenta (eva aún no está en la lista)" sshc eva "$T/k_eva" true
PUB=$(cat "$T/k_plain.pub")
dx sh -c "for d in /var/empty/.ssh /var/lib/alumnos/ana/.ssh; do mkdir -p \$d; echo '$PUB' > \$d/authorized_keys; chmod 644 \$d/authorized_keys; done"
denied "un authorized_keys propio del alumno no abre ninguna puerta" ssh "${SSHO[@]}" -i "$T/k_plain" al_ana@127.0.0.1 true
o=$(tmo 15 sshc ana "$T/k_ana" id 2>&1)
if ! echo "$o" | grep -q 'uid=' && ! echo "$o" | grep -q 'Permission denied'; then ok "autentica pero no hay shell ni comandos (ForceCommand /bin/false)"; else ko "ejecutó un comando o no autenticó: ${o:0:80}"; fi

hdr "B. Lo que un alumno NO puede hacer"
fwdfail "ana no puede crear un socket en el directorio de luis" \
  sshc ana "$T/k_ana" -N -o ExitOnForwardFailure=yes -R "/var/lib/alumnos/luis/web.sock:127.0.0.1:$TLS"
fwdfail "no puede abrir un puerto TCP en el servidor (PermitListen)" \
  sshc ana "$T/k_ana" -N -o ExitOnForwardFailure=yes -R "127.0.0.1:29999:127.0.0.1:$TLS"
fwdfail "no puede abrir un puerto TCP ni en 0.0.0.0" \
  sshc ana "$T/k_ana" -N -o ExitOnForwardFailure=yes -R "0.0.0.0:29998:127.0.0.1:$TLS"

# 25 fallos de autenticación seguidos desde la misma IP (como una clase tras una NAT con certificados caducados)
for _ in $(seq 1 25); do ssh "${SSHO[@]}" -i "$T/k_plain" al_ana@127.0.0.1 true >/dev/null 2>&1; done
o=$(tmo 15 sshc ana "$T/k_ana" true 2>&1)
if ! echo "$o" | grep -qiE 'Permission denied|closed|reset|kex_exchange|timed out'; then ok "tras 25 fallos desde la misma IP, un alumno válido sigue entrando (sin bloqueo por IP)"; else ko "bloqueo por IP de origen: ${o:0:90}"; fi

hdr "C. Cuentas en caliente (sin reiniciar nada)"
echo eva >> "$T/conf/alumnos.txt"
chk "alta: eva aparece sola en <10 s" wait_for 15 dx id al_eva
tun eva "$T/k_eva" /var/lib/alumnos/eva/web.sock; EVA=$TUN_PID
chk "eva abre su túnel con el certificado que antes se rechazaba" wait_for 12 ngx test -S /var/lib/alumnos/eva/web.sock
chk "el túnel de ana siguió vivo durante el alta" kill -0 "$ANA"
printf 'ana\neva\n' > "$T/conf/alumnos.txt"
chk "baja: luis desaparece (cuenta y directorio)" wait_for 15 bash -c '! docker exec relay-sshd id al_luis && ! docker exec relay-sshd test -d /var/lib/alumnos/luis'
: > "$T/conf/alumnos.txt"; sleep 8
chk "lista VACÍA no borra a nadie (protección ante un fallo de Keycloak)" bash -c 'docker exec relay-sshd id al_ana && docker exec relay-sshd id al_eva'
chk "…y los túneles siguen" bash -c "kill -0 $ANA && kill -0 $EVA"
printf 'eva\n' > "$T/conf/alumnos.txt"
chk "baja de ana: su cuenta desaparece" wait_for 15 bash -c '! docker exec relay-sshd id al_ana'
chk "baja de ana: su sesión SSH se corta" wait_for 10 bash -c "! kill -0 $ANA"
chk "baja de ana: nginx ya no ve su socket" bash -c '! docker exec nginx-test test -e /var/lib/alumnos/ana/web.sock'
chk "eva sigue conectada tras la baja de otro alumno" kill -0 "$EVA"

hdr "D. Escala: 1000 alumnos"
{ echo eva; for i in $(seq -w 1 1000); do echo "u$i"; done; } > "$T/conf/alumnos.txt"
t0=$(date +%s)
wait_for 240 bash -c '[ "$(docker exec relay-sshd sh -c "getent passwd | grep -c ^al_")" -ge 1001 ]'; rc=$?
t1=$(date +%s)
n=$(dx sh -c 'getent passwd | grep -c ^al_'); d=$(dx sh -c 'ls /var/lib/alumnos | wc -l')
[ $rc -eq 0 ] && ok "alta de 1000 cuentas en $((t1-t0)) s ($n cuentas, $d directorios)" || ko "no se llegaron a crear 1000 cuentas ($n)"
chk "el túnel de eva sobrevivió al alta masiva" kill -0 "$EVA"
chk "un alumno recién creado (u0777) ya puede autenticar con su certificado" bash -c "
  ssh-keygen -q -t ed25519 -N '' -f $T/k_u777 && ssh-keygen -q -s $T/ca -I t -n al_u0777 -V +30m -O clear -O permit-port-forwarding $T/k_u777.pub &&
  o=\$(ssh -F /dev/null -p $PORT -o BatchMode=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=$T/kh -o IdentitiesOnly=yes -o LogLevel=ERROR -i $T/k_u777 -o CertificateFile=$T/k_u777-cert.pub al_u0777@127.0.0.1 true 2>&1); ! echo \"\$o\" | grep -q 'Permission denied'"
mem=$(docker stats --no-stream --format '{{.MemUsage}}' relay-sshd | cut -d/ -f1)
echo "  · memoria del contenedor con 1001 cuentas y 1 túnel: $mem"
printf 'eva\n' > "$T/conf/alumnos.txt"; t0=$(date +%s)
wait_for 240 bash -c '[ "$(docker exec relay-sshd sh -c "getent passwd | grep -c ^al_")" -le 1 ]'; rc=$?; t1=$(date +%s)
[ $rc -eq 0 ] && ok "baja de 1000 cuentas en $((t1-t0)) s" || ko "la baja masiva no terminó"
chk "eva sigue conectada tras la baja masiva" kill -0 "$EVA"

hdr "E. Persistencia"
fp1=$(ssh-keyscan -p $PORT 127.0.0.1 2>/dev/null | ssh-keygen -lf - 2>/dev/null)
docker restart relay-sshd >/dev/null
wait_for 40 nc -z 127.0.0.1 $PORT; sleep 2
fp2=$(ssh-keyscan -p $PORT 127.0.0.1 2>/dev/null | ssh-keygen -lf - 2>/dev/null)
[ -n "$fp1" ] && [ "$fp1" = "$fp2" ] && ok "la huella de host se conserva al reiniciar el contenedor" || ko "la huella cambió ($fp1 / $fp2)"
chk "las cuentas se conservan tras reiniciar (al_eva)" dx id al_eva
chk "eva puede volver a autenticar tras el reinicio" bash -c "
  o=\$(ssh -F /dev/null -p $PORT -o BatchMode=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=$T/kh -o IdentitiesOnly=yes -o LogLevel=ERROR -i $T/k_eva -o CertificateFile=$T/k_eva-cert.pub al_eva@127.0.0.1 true 2>&1); ! echo \"\$o\" | grep -q 'Permission denied'"

printf '\n\033[1mResultado: %d correctas, %d fallos\033[0m\n' "$pass" "$fail"
[ "$fail" -eq 0 ]
