atareao / podman-ips-reales-y-la-liga — demos

#!/usr/bin/env bash # ============================================================================= # demo-01 · Diagnóstico de tu motor # ============================================================================= # A qué punto del guion sirve: puntos 1, 2, 10 y 11 # · 1 «Dos mundos: Podman en mi portátil, Docker en el servidor» # → `podman --version` y `docker --version`: dos binarios, dos diseños. # · 2 «Y ahora quiero el servidor sin root» # → cómo se sabe si tu contenedor corre rootless: `podman info` / # `docker info`, y el mapa de identificadores del espacio de usuario. # · 10 «Qué cambia rootless de verdad» # → la línea `rootlessPortForwarder` de `podman info`: el reenviador # que hace de proxy y se come la IP de origen. # · 11 «No es cosa de Podman: es cosa de rootless» # → el mismo dato, buscado en `docker info`. # # Qué se ve en pantalla: cuatro bloques, uno por idea. Cada bloque lanza el # comando exacto y comenta en una línea lo que significa lo que ha salido. # # Estado: # · Podman (versiones, rootless, mapa de UID, reenviador) → VERIFICADO en # local con Podman 6.1.4 rootless. La salida real está en # `verificacion/demo-01-salida.txt`. # · Docker → NO VERIFICADO aquí: en esta máquina no hay binario `docker`. # El bloque está escrito para que funcione si lo hay, y si no, imprime la # salida ESPERADA y qué línea hay que buscar. # # Seguridad de la demo: solo LEE. No crea contenedores, no toca la red del # sistema y no modifica nada. `podman unshare` abre un espacio de nombres de # usuario, ejecuta `cat` y sale. # ============================================================================= set -u titulo() { printf '\n\033[1m── %s\033[0m\n' "$1"; } orden() { printf '\n\033[1m$ %s\033[0m\n' "$1"; } nota() { printf ' ↳ %s\n' "$1"; } esperado() { printf '\n\033[1m[ESPERADO, no ejecutado aquí]\033[0m\n'; } printf '\033[1mDiagnóstico de tu motor de contenedores\033[0m (puntos 1, 2, 10 y 11)\n' printf 'Máquina: %s · %s\n' "$(hostname)" "$(date -Is)" # ----------------------------------------------------------------------------- titulo "1 · ¿Qué motor tengo? · punto 1" # ----------------------------------------------------------------------------- # La versión dice mucho más de lo que parece: aquí no se elige "Podman o # Docker" por gusto, son dos arquitecturas. Podman no tiene demonio; Docker sí. if command -v podman >/dev/null 2>&1; then orden "podman --version" podman --version nota "Un binario más que contesta. No hay servicio con privilegios detrás:" nota "el contenedor es un hijo de esta sesión y muere con ella." else nota "no hay 'podman' en el PATH de esta máquina." fi if command -v docker >/dev/null 2>&1; then orden "docker --version" docker --version nota "Mismo software por debajo, distinto modelo: hay un 'dockerd'" nota "arrancado como root al que le pides el contenedor." else esperado printf '$ docker --version\n' printf 'Docker version 28.x.y, build xxxxxxx\n' nota "La versión en sí no te dice si es rootless: para eso, el bloque 2." fi # ----------------------------------------------------------------------------- titulo "2 · ¿Mi motor es rootless? · punto 2" # ----------------------------------------------------------------------------- # Pregunta útil, sobre todo en el servidor: si es rootless, el usuario cero # dentro del contenedor NO es el root de la máquina. if command -v podman >/dev/null 2>&1; then orden "podman info --format '{{.Host.Security.Rootless}}'" podman info --format '{{.Host.Security.Rootless}}' nota "'true' = rootless. 'false' = los contenedores corren como root de verdad." orden "podman info | grep -i rootless" podman info 2>/dev/null | grep -i rootless nota "Tres líneas, y ninguna sobra: 'rootlessNetworkCmd' (con qué se monta la" nota "red: aquí 'pasta'), 'rootlessPortForwarder' (quiénes publican los puertos:" nota "aquí 'rootlessport') y 'rootless: true', que es la tercera y la misma" nota "respuesta del comando anterior. El reenviador del bloque 10 es la segunda." else nota "no hay 'podman' en el PATH: se salta la comprobación rootless." fi # ----------------------------------------------------------------------------- titulo "3 · Qué significa rootless por dentro · punto 2" # ----------------------------------------------------------------------------- # El truco es del kernel: espacios de nombres de usuario. Dentro, el proceso se # cree root; fuera, es un usuario sin privilegios con un rango de identificadores # prestados. Se ve en el mapa de UID. # Se usa 'podman unshare' para NO tener que crear ningún contenedor: abre el # espacio de nombres, ejecuta 'cat' y sale. if command -v podman >/dev/null 2>&1; then orden "podman unshare cat /proc/self/uid_map" podman unshare cat /proc/self/uid_map 2>&1 nota "El 0 de la izquierda (dentro) es un 1000 cualquiera (fuera):" nota "quien escape del contenedor no encuentra el root del host, encuentra un don nadie." nota "En un contenedor ya en marcha, el mismo dato se ve con:" nota " cat /proc/self/uid_map (dentro del contenedor)" else nota "sin podman no hay espacio de nombres que enseñar." fi # ----------------------------------------------------------------------------- titulo "4 · El reenviador: donde se pierde la IP · punto 10" # ----------------------------------------------------------------------------- # En rootless nadie abre el puerto en el kernel por ti: lo abre un proceso tuyo # que escucha y reenvía hacia el contenedor. Ese proceso es un proxy, y por eso # dentro del contenedor la conexión no llega del visitante sino del mensajero. if command -v podman >/dev/null 2>&1; then orden "podman info --format '{{.Host.RootlessPortForwarder}}'" podman info --format '{{.Host.RootlessPortForwarder}}' 2>&1 orden "podman info --format '{{.Host.RootlessNetworkCmd}}'" podman info --format '{{.Host.RootlessNetworkCmd}}' 2>&1 nota "Esos dos nombres son la pieza de la que habla el guion: el reenvío" nota "de puertos ocurre en el espacio de usuario, no en el NAT del kernel." else nota "sin podman no hay reenviador que enseñar." fi # ----------------------------------------------------------------------------- titulo "5 · ¿Y en Docker? Exactamente lo mismo · punto 11" # ----------------------------------------------------------------------------- # La frase del episodio: no es cosa de Podman, es cosa de rootless. Docker # rootless arrastra el mismo comportamiento porque se apoya en RootlessKit. if command -v docker >/dev/null 2>&1; then orden "docker info --format '{{.SecurityOptions}}'" docker info --format '{{.SecurityOptions}}' 2>&1 nota "Si aparece 'rootless' en la lista, es rootless. Si no aparece, no lo es." orden "docker context inspect --format '{{.Endpoints.docker.Host}}'" docker context inspect --format '{{.Endpoints.docker.Host}}' 2>&1 nota "Segunda pista: un socket en /run/user/<uid>/docker.sock es rootless;" nota "unix:///var/run/docker.sock es el demonio de root de toda la vida." else esperado printf '$ docker info --format '"'"'{{.SecurityOptions}}'"'"'\n' printf '[name=seccomp,profile=builtin name=rootless name=cgroupns]\n\n' printf '$ docker context inspect --format '"'"'{{.Endpoints.docker.Host}}'"'"'\n' printf 'unix:///run/user/1000/docker.sock\n' nota "Docker rootless se instala aparte y se arranca como usuario;" nota "si no lo has hecho, tu Docker es rootful aunque no te lo diga la versión." fi # ----------------------------------------------------------------------------- titulo "Cierre del bloque" # ----------------------------------------------------------------------------- printf ' · Dos binarios, dos diseños: sin demonio (Podman) / con demonio (Docker).\n' printf ' · Rootless se comprueba con %s, no con la versión.\n' "'info'" printf ' · Y en rootless los puertos los publica un reenviador: ese es el que\n' printf ' hace que dentro del contenedor veas al mensajero y no al visitante.\n\n' exit 0

#!/usr/bin/env bash # ============================================================================= # demo-02 · Las correcciones de configuración # ============================================================================= # A qué punto del guion sirve: punto 13 # «Y se puede tratar en Traefik y en Umami» # # Qué se ve en pantalla: los dos fragmentos correctos, con la línea que importa # señalada, y una comprobación de que lo son de verdad. # 1. Traefik → `config/traefik-entrypoints.yml` # forwardedHeaders.trustedIPs y proxyProtocol.trustedIPs # apuntando SOLO al proxy correcto. # 2. Umami → `config/umami.env` # CLIENT_IP_HEADER=x-real-ip # # La frase que resume las dos: una cabecera que el proxy REESCRIBE frente a una # cabecera que CUALQUIERA PUEDE ESCRIBIR. # # Estado: VERIFICADO en local. El YAML se parsea y el fichero de entorno se # comprueba con comandos; la salida real está en # `verificacion/demo-02-salida.txt`. # # Seguridad: solo lee los ficheros de `config/`. No hay ningún secreto en ellos # (el token de Cloudflare, si algún día se usa, no vive aquí: va en un `podman # secret`). La única dirección de la confianza es la del borde de este montaje # (loopback); donde se usa un valor de mentira se marca como rango de # documentación (RFC 5737). # ============================================================================= set -u AQUI="$(cd "$(dirname "$0")" && pwd)" TRAEFIK="$AQUI/config/traefik-entrypoints.yml" UMAMI="$AQUI/config/umami.env" titulo() { printf '\n\033[1m── %s\033[0m\n' "$1"; } orden() { printf '\n\033[1m$ %s\033[0m\n' "$1"; } nota() { printf ' ↳ %s\n' "$1"; } ok() { printf ' \033[1m✔ %s\033[0m\n' "$1"; } fallo() { printf ' \033[1m✘ %s\033[0m\n' "$1"; } rc_final=0 printf '\033[1mLas dos correcciones del punto 13\033[0m\n' # ----------------------------------------------------------------------------- titulo "1 · Traefik: de quién se fía el proxy" # ----------------------------------------------------------------------------- # El error de partida (lo que se cuenta en voz alta, no hace falta fichero): # proxyProtocol: trustedIPs: [el rango de tu vecindario de contenedores] # ← confía en TODO el vecindario: cualquiera # que alcance el puerto puede contar que # viene de donde le apetezca # forwardedHeaders: insecure: true ← se cree cualquier cabecera # Con eso, cualquiera que alcance el puerto de Traefik entra diciendo que viene de # donde quiera. orden "cat config/traefik-entrypoints.yml" cat "$TRAEFIK" # ¿Se parsea? Un YAML roto en el arranque deja el proxy sin servicios. if command -v python3 >/dev/null 2>&1 && python3 -c 'import yaml' 2>/dev/null; then orden "python3 -c 'yaml.safe_load(...)' # ¿el YAML es válido y dice lo que creemos?" python3 - "$TRAEFIK" <<'PY' import sys, yaml with open(sys.argv[1]) as f: cfg = yaml.safe_load(f) ep = cfg["entryPoints"]["websecure"] print("address :", ep["address"]) print("proxyProtocol.trustedIPs :", ep["proxyProtocol"]["trustedIPs"]) print("forwardedHeaders.insecure :", ep.get("forwardedHeaders", {}).get("insecure", False)) print("forwardedHeaders.trustedIPs :", ep["forwardedHeaders"]["trustedIPs"]) PY ok "YAML válido y con las listas presentes." else nota "python3 + PyYAML no disponibles: se salta la comprobación de sintaxis." fi # Auditoría: lo que NO debe haber. Solo miran las líneas ACTIVAS (sin '#'). orden "grep -vE '^[[:space:]]*#' config/traefik-entrypoints.yml | grep -nE 'insecure: true|/[0-9]{1,2}\"' " if grep -vE '^[[:space:]]*#' "$TRAEFIK" | grep -E 'insecure: true|/(0|[0-9]|1[0-9]|2[0-3])"'; then fallo "hay un rango demasiado ancho o un 'insecure' activo." rc_final=1 else ok "ni 'insecure: true' ni rangos anchos activos: solo la IP del borde." fi # La misma auditoría, pero entendiendo el YAML (si hay python3). Es la que manda. if command -v python3 >/dev/null 2>&1 && python3 -c 'import yaml' 2>/dev/null; then orden "python3 -c 'auditar el YAML: insecure y prefijos de red'" if python3 - "$TRAEFIK" <<'PY' import sys, ipaddress, yaml ep = yaml.safe_load(open(sys.argv[1]))["entryPoints"]["websecure"] problemas = [] for nombre in ("forwardedHeaders", "proxyProtocol"): bloque = ep.get(nombre) or {} if bloque.get("insecure"): problemas.append(f"{nombre}.insecure: true ← se cree a cualquiera") for cidr in bloque.get("trustedIPs") or []: red = ipaddress.ip_network(cidr, strict=False) minimo = 24 if red.version == 4 else 64 if red.prefixlen < minimo: problemas.append(f"{nombre}.trustedIPs demasiado ancho: {cidr}") else: print(f" {nombre}.trustedIPs → {cidr} (red pequeña, correcto)") if problemas: for p in problemas: print(" ✘", p) sys.exit(1) print(" ✔ sin 'insecure' y sin rangos anchos.") PY then ok "el YAML auditado no tiene confianzas excesivas." else fallo "el YAML confía en más gente de la que debería." rc_final=1 fi fi # ----------------------------------------------------------------------------- titulo "2 · Umami: qué cabecera lee" # ----------------------------------------------------------------------------- # Mismo razonamiento, al revés: aquí no se restringe QUIÉN puede llegar, se elige # QUÉ cabecera creerse. Se elige la que el proxy reescribe. orden "cat config/umami.env" cat "$UMAMI" orden "grep -n '^CLIENT_IP_HEADER' config/umami.env" if grep -q '^CLIENT_IP_HEADER=x-real-ip' "$UMAMI"; then ok "CLIENT_IP_HEADER=x-real-ip → la cabecera que Traefik reconstruye." else fallo "CLIENT_IP_HEADER no apunta a x-real-ip." rc_final=1 fi orden "grep -nE 'cf-connecting-ip|true-client-ip' config/umami.env # no debe haber ninguna activa" if grep -E '^[[:space:]]*CLIENT_IP_HEADER=.*(cf-connecting-ip|true-client-ip)' "$UMAMI"; then fallo "queda una cabecera que cualquiera puede escribir." rc_final=1 else ok "ninguna cabecera de cliente (cf-connecting-ip / true-client-ip) activa." fi # ----------------------------------------------------------------------------- titulo "Por qué, en una frase (para decir en el aire)" # ----------------------------------------------------------------------------- cat <<'TEXTO' · En el proxy: no te fíes de todos. 'trustedIPs' con la IP exacta del borde; si te fías del rango entero, cualquiera que llegue te cuenta de dónde viene. · En la analítica: lee la cabecera que el proxy reescribe (x-real-ip), no una que pueda rellenar el primero que pase (cf-connecting-ip, x-forwarded-for). · Y recuerda el límite: esto ordena la casa, no tapa el agujero. Si el 8443 está abierto al mundo, la fiabilidad la da el firewall, no la cabecera. · Y ojo con el alcance: esto funcionaba… hasta que un sábado por la tarde el bloqueo judicial tumbó el rango entero del proxy que había delante. TEXTO printf '\n' if [ "$rc_final" -eq 0 ]; then printf '\033[1mResultado: las dos correcciones están en su sitio.\033[0m\n\n' else printf '\033[1mResultado: hay algo que corregir (ver arriba).\033[0m\n\n' fi exit "$rc_final"

#!/usr/bin/env bash # ============================================================================= # demo-03 · La prueba del ciudadano # ============================================================================= # A qué punto del guion sirve: punto 15 # «Qué puedes hacer tú: prueba, mide y denuncia» # # Qué hace: cuando un sitio legítimo te falla, guarda la prueba CON FECHA en un # fichero fechado. Dominio, operador, hora exacta y el error tal cual. # · curl → ¿responde? ¿con qué código? ¿cuánto tarda? y el error completo. # · dig → ¿resuelve? ¿a qué direcciones? ¿con qué servidor de nombres? # · whois → ¿de quién es esa dirección? (si es de un rango compartido, no se # ha caído «tu» servidor: se ha caído un vector que usan cientos de # miles de sitios). Si no hay `whois` instalado, se usa RDAP con # `curl`, que da la misma información sin instalar nada. # # Uso: # ./demo-03-prueba-del-ciudadano.sh <dominio> [operador] # ./demo-03-prueba-del-ciudadano.sh tudominio.example "Mi operador" # # El informe se guarda en: # $PRUEBAS_DIR/<AAAA-MM-DD_HHMMSS>-prueba-<dominio>.txt # (por defecto $PRUEBAS_DIR=/tmp/opencode/pruebas-ciudadano) # # Códigos de salida (para que sirva también en un cron o en un script): # 0 = el sitio responde # 1 = el sitio NO responde (conexión, TLS o tiempo agotado) # 2 = el nombre no resuelve # 3 = no se ha podido escribir el informe # # Estado: VERIFICADO en local (cuatro casos: responde, no resuelve, no responde # y bloqueo detectado). Salidas reales en `verificacion/demo-03-*.txt`. # # Seguridad de la demo: solo lectura. Nada de `ssh`, nada de tocar servidores # ajenos, nada que modifique el sistema. El único tráfico que sale es el de tus # propias consultas DNS/HTTP, que es justo lo que se está probando. # ============================================================================= set -u DOMINIO="${1:-example.com}" OPERADOR="${2:-${OPERADOR:-(anota aquí tu operador: Movistar, Vodafone, Digi…)}}" DESTINO="${PRUEBAS_DIR:-/tmp/opencode/pruebas-ciudadano}" if [ "$DOMINIO" = "-h" ] || [ "$DOMINIO" = "--help" ]; then sed -n '2,32p' "$0" | sed 's/^# \{0,1\}//' exit 0 fi mkdir -p "$DESTINO" || { printf 'no se puede crear %s\n' "$DESTINO" >&2; exit 3; } FECHA="$(date +%Y-%m-%d_%H%M%S)" INFORME="$DESTINO/${FECHA}-prueba-${DOMINIO}.txt" : > "$INFORME" || exit 3 ULTIMO_RC=0 salida() { printf '%s\n' "$*" | tee -a "$INFORME"; } orden() { printf '\n$ %s\n' "$*" | tee -a "$INFORME"; } run() { # run <comando…> → lanza, guarda la salida y el código, nunca aborta local cabecera salida_cmd rc=0 cabecera="$(printf '$'; for a in "$@"; do case "$a" in *" "*) printf " '%s'" "$a" ;; *) printf ' %s' "$a" ;; esac done)" printf '\n%s\n' "$cabecera" | tee -a "$INFORME" salida_cmd="$("$@" 2>&1)" || rc=$? printf '%s\n' "$salida_cmd" | tee -a "$INFORME" if [ "$rc" -ne 0 ]; then printf '[exit %s]\n' "$rc" | tee -a "$INFORME"; fi ULTIMO_RC=$rc return 0 } # ------------------------------------------------------------------ cabecera salida "================================================================" salida " PRUEBA DE ACCESO — prueba del ciudadano" salida "================================================================" salida " Dominio : $DOMINIO" salida " Operador : $OPERADOR" salida " Fecha : $(date -Is)" salida " Equipo : $(hostname) · $(uname -sr)" salida "================================================================" salida "" salida "Nota: esta prueba NO dice quién bloquea ni por qué. Solo deja constancia" salida "fechada de lo que ha pasado desde tu conexión. Una prueba, o varias, es" salida "lo que se adjunta a una reclamación." # --------------------------------------------------------------- 1 · curl salida "" salida "--- 1 · ¿El sitio responde? -------------------------------------" if command -v curl >/dev/null 2>&1; then run curl -sS -o /dev/null \ --connect-timeout 10 --max-time 20 \ -w 'HTTP %{http_code} · connect %{time_connect}s · TLS %{time_appconnect}s · total %{time_total}s · IP destino %{remote_ip}\n' \ "https://$DOMINIO/" RC_CURL=$ULTIMO_RC orden "curl -v https://$DOMINIO/ # el error tal cual, para adjuntar" curl -v -o /dev/null --connect-timeout 10 --max-time 20 "https://$DOMINIO/" 2>&1 \ | tee -a "$INFORME" else salida "curl no está instalado: sin esta parte no hay prueba de acceso." RC_CURL=127 fi # --------------------------------------------------------------- 2 · dig salida "" salida "--- 2 · ¿Resuelve el nombre? ------------------------------------" IP_A="" if command -v dig >/dev/null 2>&1; then run dig "$DOMINIO" A IP_A="$(dig +short A "$DOMINIO" | grep -E '^[0-9.]+$' | head -1)" run dig +short "$DOMINIO" AAAA run dig +short "$DOMINIO" NS if [ -n "$IP_A" ]; then salida "" salida "Primera dirección IPv4 anotada: $IP_A" fi else salida "dig no está instalado (paquete bind-utils / dnsutils)." fi # --------------------------------------------------------------- 3 · whois salida "" salida "--- 3 · ¿De quién es esa dirección? -----------------------------" salida "(si es de un rango compartido, no está caído «tu» servidor:" salida " está caído un vector que usan cientos de miles de sitios)" if [ -z "$IP_A" ]; then salida "Sin dirección IPv4 no hay nada que consultar." elif command -v whois >/dev/null 2>&1; then run whois "$IP_A" else salida "No hay 'whois' instalado en este equipo. Alternativa sin instalar nada:" salida "RDAP, el registro de direcciones que habla HTTP." if command -v curl >/dev/null 2>&1; then orden "curl -sSL https://rdap.org/ip/$IP_A" RDAP="$(curl -sSL --connect-timeout 10 --max-time 20 "https://rdap.org/ip/$IP_A" 2>&1)" \ || salida "(la consulta RDAP ha fallado)" if command -v jq >/dev/null 2>&1 && printf '%s' "$RDAP" | jq -e . >/dev/null 2>&1; then printf '%s' "$RDAP" | jq -r ' " titular : " + (.name // .handle // (.entities[0].handle // "?")), " registro : " + (.handle // "?"), " país : " + (.country // "?"), " rango : " + ( if .["cidr0_cidrs"] then (.["cidr0_cidrs"][0] | "\(.v4prefix // .v6prefix)/\(.length)") elif .startAddress then "\(.startAddress) - \(.endAddress)" else "?" end ) ' | tee -a "$INFORME" else printf '%s\n' "$RDAP" | head -40 | tee -a "$INFORME" fi fi fi # ------------------------------------------------------------- veredicto salida "" salida "--- Resultado ---------------------------------------------------" if [ -n "$IP_A" ] && [ "${RC_CURL:-1}" -eq 0 ]; then salida " ALCANZABLE: el sitio ha respondido desde esta conexión." salida " Si aún así a ti te falla a ratos, repite esta prueba cada vez que" salida " falle: lo que vale es la serie con fecha y hora, no una sola foto." VEREDICTO=0 elif [ -z "$IP_A" ]; then salida " NO RESUELVE EL NOMBRE: el dominio no se ha podido traducir a dirección." salida " Prueba desde otra red (datos móviles, otra casa) para saber si es" salida " cosa de tu operador o del dominio." VEREDICTO=2 else salida " NO ALCANZABLE: el nombre resuelve ($IP_A) pero la conexión no llega." salida " Guarda este fichero: es exactamente la prueba que hay que adjuntar." VEREDICTO=1 fi # ------------------------------------------------------- qué hacer ahora cat <<'TEXTO' | tee -a "$INFORME" --- Y ahora, los otros dos pasos --------------------------------- 2 · MEDIR. Instala OONI Probe (libre, sin registro) y lanza la prueba desde tu propia red: las mediciones se publican solas en OONI Explorer. Una anomalía sola no prueba nada, pero suma. App e instrucciones : https://ooni.org/install/ Mediciones públicas : https://explorer.ooni.org/ 3 · DENUNCIAR (esto deja constancia; no hay caso documentado de una reclamación individual que levante uno de estos bloqueos): · Tu operador, primero, y pide respuesta por escrito. · Oficina de Atención al Usuario de Telecomunicaciones (SETELECO): https://usuariosteleco.digital.gob.es/reclamaciones/telefonia-e-internet/tramitacion-electronica · AEPD, solo si hubo inspección de comunicaciones o tratamiento indebido de datos: https://www.aepd.es/ · CNMC, como coordinador de servicios digitales (DSA): https://www.cnmc.es/sectores-que-regulamos/servicios-digitales-dsa/reclamaciones Guarda también: capturas con la fecha visible, tu operador y, si puedes, la misma prueba desde otra conexión. TEXTO salida "" salida "Informe guardado en: $INFORME" # Sin códigos ANSI a propósito: la salida se guarda tal cual y se puede pegar en # un informe o un tique de incidencia sin que aparezcan escapes de color. printf '\nInforme guardado en: %s\n' "$INFORME" printf 'Código de salida: %s (0 responde · 1 no responde · 2 no resuelve)\n\n' "$VEREDICTO" exit "$VEREDICTO"

#!/usr/bin/env bash # ============================================================================= # demo-04 · El borde con HAProxy # ============================================================================= # A qué punto del guion sirve: puntos 16, 17, 18 y 19 # · 16 «HAProxy en bare metal» → el borde corre en el HOST, # fuera del contenedor. # · 17 «Directo al 443» → el puerto privilegiado lo abre # HAProxy, en el metal. # · 18 «Traefik se levanta en el 8443» → el contenedor solo publica un # puerto alto. # · 19 «Y no necesito reglas especiales» → sin ip_unprivileged_port_start, # sin setcap, sin iptables. # # Qué se ve en pantalla: # 1. `config/haproxy.cfg` entero, con las tres líneas clave señaladas. # 2. El recorrido: :443 → HAProxy → `send-proxy-v2` → Traefik :8443. # 3. La validación de sintaxis de verdad, con `haproxy -c` y un control # negativo (un fichero roto a propósito) para demostrar que el chequeo # no dice «OK» a todo. # # Estado: VERIFICADO en local. La validación se ejecuta con HAProxy 3.4.7 # dentro de un contenedor EFÍMERO (`--rm`, sin puertos publicados y sin tocar # el host). Salida real en `verificacion/demo-04-salida.txt`. # En esta máquina NO hay binario `haproxy` ni `docker` instalados: por eso la # validación va por contenedor y ese camino es el que está verificado. # # Si no hay ni `haproxy` ni `podman` ni `docker`, el script NO falla: avisa de # que la sintaxis queda sin validar y muestra el comando exacto para hacerlo. # ============================================================================= set -u AQUI="$(cd "$(dirname "$0")" && pwd)" CFG="$AQUI/config/haproxy.cfg" # Imagen del validador. Se mira primero la caché local y, si no hay ninguna, se # descarga. Son las mismas versiones que el binario oficial de HAProxy: # · docker.io/library/haproxy:lts-alpine → la canónica # · mirror.gcr.io/library/haproxy:lts-alpine → espejo público (el Hub devolvió # error de autenticación al preparar este material, así que el espejo es lo # que acabó funcionando) # · docker.io/library/haproxy:latest → por si ya la tienes por casa CANDIDATAS=( "docker.io/library/haproxy:lts-alpine" "mirror.gcr.io/library/haproxy:lts-alpine" "docker.io/library/haproxy:latest" ) IMAGEN="${HAPROXY_IMAGEN:-${CANDIDATAS[0]}}" TMP="${TMPDIR:-/tmp/opencode}" resolver_imagen() { # elige la primera imagen disponible (caché primero, luego descarga) local img for img in "${CANDIDATAS[@]}"; do if podman image exists "$img" >/dev/null 2>&1; then IMAGEN="$img"; return 0; fi done for img in "${CANDIDATAS[@]}"; do printf ' (descargando %s…)\n' "$img" if podman pull "$img" >/dev/null 2>&1; then IMAGEN="$img"; return 0; fi done return 1 } titulo() { printf '\n\033[1m── %s\033[0m\n' "$1"; } orden() { printf '\n\033[1m$ %s\033[0m\n' "$1"; } nota() { printf ' ↳ %s\n' "$1"; } ok() { printf ' \033[1m✔ %s\033[0m\n' "$1"; } fallo() { printf ' \033[1m✘ %s\033[0m\n' "$1"; } rc_final=0 printf '\033[1mEl borde en bare metal\033[0m (puntos 16, 17, 18 y 19)\n' # ----------------------------------------------------------------------------- titulo "1 · El fichero del borde" # ----------------------------------------------------------------------------- orden "cat config/haproxy.cfg" cat "$CFG" # ----------------------------------------------------------------------------- titulo "2 · Las cuatro líneas que sostienen el diseño" # ----------------------------------------------------------------------------- orden "grep -nE 'mode tcp|bind \\*:443|send-proxy-v2|127.0.0.1:8443' config/haproxy.cfg" grep -nE 'mode tcp|bind \*:443|send-proxy-v2|127.0.0.1:8443' "$CFG" nota "'bind *:443' → el puerto privilegiado lo abre el HOST (punto 17)." nota "'mode tcp' → no descifra: pasa la conexión tal cual." nota "'send-proxy-v2' → avisa al siguiente salto de quién llama." nota "'127.0.0.1:8443' → Traefik, en rootless, en un puerto alto (punto 18)." # Comprobación de que están de verdad (no solo de que el grep los encuentre). for patron in 'bind \*:443' 'send-proxy-v2' '127\.0\.0\.1:8443'; do if grep -qE "$patron" "$CFG"; then ok "presente: $patron" else fallo "falta: $patron" rc_final=1 fi done # ----------------------------------------------------------------------------- titulo "3 · Los tres apaños que NO hacen falta (punto 19)" # ----------------------------------------------------------------------------- orden "grep -nE 'ip_unprivileged_port_start|setcap|iptables|nftables' config/haproxy.cfg # solo aparecen en los comentarios" if grep -nE 'ip_unprivileged_port_start|setcap|iptables|nftables' "$CFG"; then nota "aparecen mencionados en los comentarios, para explicar por qué no se usan;" nota "ninguno está como directiva activa (en HAProxy no existen como directivas)." else nota "ni siquiera se mencionan." fi nota "El motivo, en una frase: el contenedor no abre ningún puerto < 1024," nota "así que no hay nada que habilitar dentro del espacio de nombres." # ----------------------------------------------------------------------------- titulo "4 · Validar la sintaxis con HAProxy de verdad" # ----------------------------------------------------------------------------- validar() { # validar <fichero> → 0 si HAProxy acepta la configuración if command -v haproxy >/dev/null 2>&1; then haproxy -c -f "$1" elif command -v podman >/dev/null 2>&1; then podman run --rm -v "$1:/usr/local/etc/haproxy/haproxy.cfg:ro" \ "$IMAGEN" haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg elif command -v docker >/dev/null 2>&1; then docker run --rm -v "$1:/usr/local/etc/haproxy/haproxy.cfg:ro" \ "$IMAGEN" haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg else return 127 fi } if command -v haproxy >/dev/null 2>&1; then orden "haproxy -v" haproxy -v | head -2 VALIDADOR="haproxy (binario del sistema)" elif command -v podman >/dev/null 2>&1; then [ -n "${HAPROXY_IMAGEN:-}" ] || resolver_imagen || true if podman run --rm "$IMAGEN" haproxy -v >/dev/null 2>&1; then orden "podman run --rm $IMAGEN haproxy -v" podman run --rm "$IMAGEN" haproxy -v 2>&1 | head -2 VALIDADOR="HAProxy en contenedor efímero (podman)" nota "El contenedor se borra solo (--rm): no deja nada en el host." nota "Imagen usada: $IMAGEN" else VALIDADOR="" fi elif command -v docker >/dev/null 2>&1; then if docker run --rm "$IMAGEN" haproxy -v >/dev/null 2>&1; then orden "docker run --rm $IMAGEN haproxy -v" docker run --rm "$IMAGEN" haproxy -v 2>&1 | head -2 VALIDADOR="HAProxy en contenedor efímero (docker)" else VALIDADOR="" fi else VALIDADOR="" fi if [ -n "$VALIDADOR" ]; then orden "haproxy -c -f config/haproxy.cfg" if validar "$CFG"; then ok "configuración válida (exit 0). Validador: $VALIDADOR" else fallo "HAProxy NO acepta la configuración." rc_final=1 fi # --- control negativo: si el chequeo dijera «OK» a todo, no valdría nada --- orden "control negativo: una copia con 'send-proxy-v9' (no existe)" ROTO="$(mktemp "$TMP/haproxy-roto-XXXXXX.cfg")" sed 's/send-proxy-v2/send-proxy-v9/' "$CFG" > "$ROTO" if validar "$ROTO" >/dev/null 2>&1; then fallo "ha aceptado una directiva inventada: la validación no vale." rc_final=1 else ok "la copia rota se rechaza → el chequeo es real (exit != 0)." fi rm -f "$ROTO" else nota "No hay 'haproxy', ni 'podman', ni 'docker' en esta máquina:" nota "la sintaxis queda SIN VALIDAR. Para validarla, en cualquier equipo:" nota " podman run --rm -v \"\$PWD/config/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro\" \\" nota " $IMAGEN haproxy -c -f /usr/local/etc/haproxy/haproxy.cfg" fi # ----------------------------------------------------------------------------- titulo "5 · El recorrido, para contarlo en voz alta" # ----------------------------------------------------------------------------- cat <<'TEXTO' visitante ──:443──► HAProxy (HOST, servicio del sistema) │ mode tcp: no descifra nada │ send-proxy-v2: antepone quién llama ▼ Traefik :8443 (rootless, en su contenedor) │ proxyProtocol.trustedIPs: solo ese borde │ forwardedHeaders: lee la IP de verdad ▼ tu web, tus logs y la analítica · El 443 no lo pelea el contenedor: lo abre el host. Por eso no hacen falta ip_unprivileged_port_start, ni setcap, ni reglas de iptables. · Sin certificados duplicados: HAProxy no termina TLS, solo lo atraviesa. · Cada cosa en la capa que le toca: el puerto en el metal, el enrutado en el contenedor rootless. TEXTO printf '\n' if [ "$rc_final" -eq 0 ]; then printf '\033[1mResultado: el diseño del borde está completo y validado.\033[0m\n\n' else printf '\033[1mResultado: hay algo que revisar (ver arriba).\033[0m\n\n' fi exit "$rc_final"