sergio/takana

1#!/usr/bin/env python3
2"""censar.py — CENSO de una máquina: qué corre, qué sirve, qué datos tiene. Sin IA, sin adivinar.
3
4⚠ «Sólo lee» hay que decirlo con cuidado: NO ESCRIBE nada, pero las sondas de RED dejan huella. Ver
5`sondear_dominio` — censar gioser contra sí mismo hizo que su propio fail2ban lo baneara.
6
7Primer paso de la mudanza (SDD 29). Produce un inventario TOML que un humano revisa y que las etapas
8siguientes consumen. NO toca nada: todo lo que hace son lecturas.
9
10── LA REGLA QUE LO ORDENA TODO ─────────────────────────────────────────────────────────────────
11Cruzar SIEMPRE lo DECLARADO contra lo VIVO, y reportar las tres clases por separado:
12
13    vivo            declarado Y corriendo        ⇒ candidato a mudarse
14    declarado-muerto  declarado y sin proceso    ⇒ candidato a morir
15    no-declarado    corriendo y sin declaración  ⇒ EL TRABAJO REAL: nadie sabe cómo levantarlo
16
17No es teoría. Medido sobre gioser (2026-09-11):
18  · `rc-status` decía `stopped` de caddy, gitea, sshd, cronie y act-runner, y los CINCO estaban
19    vivos colgando de PID 1. Un censo que lea sólo el init habría producido un plan que no arranca.
20  · De los 19 dominios del Caddyfile, 8 no tenían DNS, 2 daban 502 y 3 ya vivían en OTRA máquina.
21    Sólo 6 eran reales. Un censo que lea sólo la config habría mudado 13 fósiles.
22  · Y el propio caddy de la caja NUEVA murió en un reinicio sin que nadie lo notara, porque estaba
23    arrancado a mano y no declarado. Esa es la clase `no-declarado`, y es la que duele.
24
25── POR QUÉ CADA SONDA ──────────────────────────────────────────────────────────────────────────
26`ppid==1` es la verdad de qué corre, no el init. Los sockets en LISTEN dicen qué SIRVE. El DNS y un
27GET dicen si alguien lo usa. `du` dice qué pesa. Nada de esto necesita juicio: son hechos, y el
28juicio (qué se muda, qué muere) lo pone el usuario en la etapa siguiente, sobre este fichero.
29
30Uso:
31    scripts/mudanza/censar.py --host root@1.2.3.4 [--key ~/.ssh/id] [--out censo.toml]
32    scripts/mudanza/censar.py --local                       # censa esta máquina
33
34La superficie va en inglés (CLAUDE.md regla 4); los mensajes, en castellano.
35"""
36import argparse, json, os, re, shlex, subprocess, sys, time
37
38# ── ejecución de sondas ─────────────────────────────────────────────────────────────────────────
39
40class Objetivo:
41    """Una máquina a censar. `run` devuelve (salida, ok) y NUNCA levanta: una sonda que falla es un
42    dato («esa máquina no tiene ss»), no un motivo para abortar el censo entero."""
43
44    def __init__(self, host=None, key=None, timeout=25):
45        self.host, self.key, self.timeout = host, key, timeout
46
47    def run(self, cmd):
48        if self.host:
49            base = ["ssh", "-o", "StrictHostKeyChecking=accept-new",
50                    "-o", f"ConnectTimeout={self.timeout}", "-o", "BatchMode=yes"]
51            if self.key:
52                base += ["-i", os.path.expanduser(self.key)]
53            argv = base + [self.host, cmd]
54        else:
55            argv = ["sh", "-c", cmd]
56        try:
57            p = subprocess.run(argv, capture_output=True, text=True, timeout=self.timeout * 4)
58            return p.stdout.strip(), p.returncode == 0
59        except Exception as e:
60            return f"(sonda falló: {e})", False
61
62
63# ── sondas ──────────────────────────────────────────────────────────────────────────────────────
64
65def identidad(t):
66    """Quién es esta máquina. El hostname MIENTE (gioser dice `momento`): la IP es el discriminador."""
67    out, _ = t.run("hostname; ip -4 addr show scope global 2>/dev/null | grep -o 'inet [0-9.]*' | "
68                   "cut -d' ' -f2 | head -3; uname -r; cat /proc/1/comm")
69    ls = [l for l in out.splitlines() if l.strip()]
70    return {
71        "hostname": ls[0] if ls else "?",
72        "ips": [l for l in ls[1:-2]] if len(ls) > 3 else [],
73        "kernel": ls[-2] if len(ls) >= 2 else "?",
74        "pid1": ls[-1] if ls else "?",
75    }
76
77
78def invocaciones(t, pids):
79    """La LÍNEA DE COMANDO y el `cwd` de cada servicio vivo, leídos de `/proc`.
80
81    Es el dato que convierte `no-declarado` de «acá hay un problema» en «acá está la solución»: si
82    nadie sabe cómo levantar un servicio, lo que hace falta para declararlo es exactamente cómo se
83    está ejecutando ahora. Sin esto el plan sólo puede decir «declaralo», que es lo que uno ya sabía.
84
85    ⚠ Se lee `cmdline` y `cwd`, NO el entorno: `/proc/<pid>/environ` suele traer tokens y
86    contraseñas, y un censo que se guarda en un fichero y se manda por ahí no puede llevarlos."""
87    out = {}
88    for nombre, ps in pids.items():
89        pid = ps[0]
90        # ⚠ SONDAS SEPARADAS, y es un bug pagado: iban en un solo comando, y como `readlink
91        # /proc/<pid>/cwd` necesita permiso de ptrace (dueño o root), en cualquier proceso de root
92        # el comando entero salía ≠0 y se descartaba TAMBIÉN el `cmdline`, que sí se podía leer.
93        # Resultado: 26 de 37 servicios sin invocación, justo el dato que da sentido al censo.
94        # Una sonda que falla es un dato; no puede arrastrarse a las que funcionaron.
95        cmd, _ = t.run(f"tr '\\0' ' ' < /proc/{pid}/cmdline 2>/dev/null")
96        cwd, _ = t.run(f"readlink /proc/{pid}/cwd 2>/dev/null")
97        # ⚠ Tercera sonda, y también separada. Muchos demonios REESCRIBEN su `argv[0]` para decir en
98        # qué andan (`sshd: /usr/bin/sshd [listener]`, `php-fpm: master process (…)`), así que la
99        # línea de comando NO dice cuál es el binario. `/proc/<pid>/exe` sí — pero necesita permiso
100        # de ptrace, o sea ser el dueño o root. Medido en gioser con uid 1001: 7 de 38 servicios
101        # quedaban en «no se pudo leer su binario» por esto, y no por ser realmente desconocidos.
102        exe, _ = t.run(f"readlink /proc/{pid}/exe 2>/dev/null")
103        cmd, cwd, exe = cmd.strip(), cwd.strip(), exe.strip()
104        # ⚠⚠ `/proc/<pid>/exe` termina en « (deleted)» cuando el fichero YA NO ESTÁ en disco: el
105        # proceso sostiene el inodo y nadie más lo puede abrir por su ruta. Medido en gioser: CUATRO
106        # servicios están así, y en dos de ellos hay AHORA otro fichero en la misma ruta, de distinto
107        # tamaño — `tejido` corre 12 750 368 bytes y en su ruta hay 13 815 864. Copiar la ruta muda
108        # OTRA COSA, en silencio, y el servicio nuevo no es el que estaba andando.
109        #
110        # Se recupera leyendo `/proc/<pid>/exe`, y SÓLO mientras el proceso viva: al reiniciar gioser
111        # —o al morirse ese pid— ese binario desaparece para siempre. En una mudanza que termina
112        # BORRANDO el origen, esto es lo más urgente del censo.
113        borrado = exe.endswith(" (deleted)")
114        if borrado:
115            exe = exe[:-len(" (deleted)")]
116        vivo_b = disco_b = ""
117        if borrado:
118            v, _ = t.run(f"stat -L -c %s /proc/{pid}/exe 2>/dev/null")
119            d, _ = t.run(f"stat -c %s {shlex.quote(exe)} 2>/dev/null")
120            vivo_b = v.strip() if v.strip().isdigit() else ""
121            disco_b = d.strip() if d.strip().isdigit() else ""
122        for v in ("cmd", "cwd", "exe"):
123            if locals()[v].startswith("(sonda falló"):
124                cmd, cwd, exe = (("" if v == "cmd" else cmd), ("" if v == "cwd" else cwd),
125                                 ("" if v == "exe" else exe))
126        sup = SUPERVISADOS.get(pid)
127        if sup:
128            cmd, exe = sup["cmdline"], sup["exec"]
129        if cmd or cwd or exe:
130            out[nombre] = {"cmdline": cmd, "cwd": cwd,
131                           "exe": exe if exe.startswith("/") else "",
132                           "usuario": (sup or {}).get("usuario", ""),
133                           "exe_borrado": borrado, "pid": pid,
134                           "bytes_vivo": vivo_b, "bytes_disco": disco_b}
135    return out
136
137
138def duenos(t, ejecutables):
139    """¿Quién PROVEE el binario de cada servicio? Determinista, preguntándole al gestor de paquetes
140    del origen.
141
142    Es lo que convierte «instalá el paquete» —que es lo que uno ya sabía— en una instrucción: o el
143    binario lo trae un paquete con nombre, o NO lo trae nadie y entonces es un compilado suelto que
144    hay que llevar o reconstruir. La diferencia decide el trabajo, y no se adivina.
145
146    Una consulta por lote, no una por servicio: son decenas de servicios y cada `ssh` cuesta."""
147    if not ejecutables:
148        return {}
149    lista = " ".join(shlex.quote(e) for e in sorted(set(ejecutables)))
150    # Se prueba el gestor que exista. `2>/dev/null || echo -` ⇒ un fichero sin dueño no aborta el lote.
151    guion = (
152        'for f in %s; do '
153        '  if command -v pacman >/dev/null 2>&1; then o=$(pacman -Qoq "$f" 2>/dev/null); '
154        '  elif command -v dpkg >/dev/null 2>&1; then o=$(dpkg -S "$f" 2>/dev/null | cut -d: -f1); '
155        '  elif command -v apk >/dev/null 2>&1; then o=$(apk info -W "$f" 2>/dev/null | tail -1 '
156        '       | sed "s/.* is owned by //;s/-[0-9].*//"); '
157        '  elif command -v rpm >/dev/null 2>&1; then o=$(rpm -qf "$f" 2>/dev/null); '
158        '  else o=""; fi; '
159        '  echo "$f|${o:-}"; done'
160    ) % lista
161    out, _ = t.run(guion)
162    res = {}
163    for l in out.splitlines():
164        if "|" in l:
165            f, o = l.split("|", 1)
166            res[f.strip()] = o.strip()
167    return res
168
169
170# Envoltorios que NO son el servicio: el nombre de verdad está en sus argumentos. Sin desenvolverlos,
171# los CINCO `supervise-daemon` de gioser se juntaban en UNA entrada llamada `supervise-daemo` — cinco
172# servicios distintos (shuma-daemon, dbus, metalog…) colapsados en una tarjeta con el nombre del
173# envoltorio. Un servicio de más es ruido; cinco servicios fundidos en uno es un plan que no arranca.
174SUPERVISORES = {"supervise-daemon", "start-stop-daemon", "s6-supervise", "runsv", "daemonize"}
175_COMM_SUP = {s[:15] for s in SUPERVISORES}
176
177# pid → lo que el supervisor manda de verdad. Se llena al listar los procesos y se consulta al leer
178# `/proc`: el pid con ppid==1 es el SUPERVISOR, así que su `cmdline` y su `exe` describen al
179# envoltorio, no al servicio.
180SUPERVISADOS = {}
181
182
183def _mandado_por_supervisor(args):
184    """El comando REAL que hay detrás de `supervise-daemon`, y con qué usuario corre.
185
186    El formato es `supervise-daemon <servicio> --start [opciones] <ejecutable> -- [argumentos]`, así
187    que el ejecutable es el ÚLTIMO token antes del `--` suelto. Comprobado contra los cinco de gioser
188    (dbus, dhcpcd, metalog, squid, shuma-daemon).
189
190    ⚠ Sin esto, el censo guardaba como `cmdline` la línea del SUPERVISOR — y una tarjeta de arje
191    hecha con eso arrancaría `supervise-daemon` DENTRO de arje, que ya supervisa. Y el `exec` salía
192    `/usr/bin/supervise-daemon`, o sea que `squid` figuraba como provisto por el paquete `openrc`.
193
194    ⚠⚠ Y se rescata el `--user`: `shuma-daemon` corre como `sergio`. Perder ese dato al desenvolver
195    sería la misma elisión que el escritor de arje reporta como SIN-TRADUCIR — un servicio que en el
196    origen corría sin privilegios terminaría de root en el destino, y nadie se enteraría."""
197    p = args.split()
198    if "--start" not in p:
199        return "", "", ""
200    resto = p[p.index("--start") + 1:]
201    usuario = ""
202    for i, x in enumerate(resto):
203        if x in ("--user", "-u") and i + 1 < len(resto):
204            usuario = resto[i + 1]
205            break
206    corte = resto.index("--") if "--" in resto else len(resto)
207    izq, der = resto[:corte], resto[corte + 1:]
208    if not izq or not izq[-1].startswith("/"):
209        return "", "", usuario
210    return izq[-1], " ".join([izq[-1]] + der), usuario
211
212
213def _desenvolver(comm, args):
214    """(nombre_real, args_reales) para un proceso que puede ser un envoltorio."""
215    p = args.split()
216    if not p:
217        return comm, args
218    base = os.path.basename(p[0])
219    if base not in SUPERVISORES and comm not in {s[:15] for s in SUPERVISORES}:
220        return comm, args
221    if base in ("supervise-daemon", "s6-supervise", "runsv") and len(p) > 1:
222        # `supervise-daemon <servicio> --start …` · `runsv /etc/service/<servicio>`
223        return os.path.basename(p[1].rstrip("/")), args
224    for i, x in enumerate(p):                      # start-stop-daemon
225        if x in ("--name", "-n") and i + 1 < len(p):
226            return p[i + 1], args
227        if x in ("--exec", "-x", "--startas", "-a") and i + 1 < len(p):
228            return os.path.basename(p[i + 1]), args
229    return comm, args
230
231
232def _destruncar(comm, args):
233    """`comm` viene del kernel y está capado a 15 caracteres: `willay-crosscheck` llega como
234    `willay-crossche`. Ese nombre truncado no es cosmético — es el que el plan mete en
235    `--in /etc/init.d/<nombre>` (ruta que no existe) y el que va de `label` en la tarjeta de arje.
236    La línea de comando sí trae el nombre entero, así que se usa ESA cuando confirma al truncado."""
237    if len(comm) < 15:
238        return comm
239    p = args.split()
240    if p:
241        base = os.path.basename(p[0])
242        if base.startswith(comm):
243            return base
244    return comm
245
246
247def procesos_vivos(t):
248    """Lo que REALMENTE corre, colgado de PID 1. La verdad, no la declaración."""
249    out, _ = t.run("ps -eo pid=,ppid=,comm=,args= 2>/dev/null | awk '$2==1 && $1!=1'")
250    vivos = {}
251    for l in out.splitlines():
252        parts = l.split(None, 3)
253        if len(parts) < 3 or not parts[0].isdigit():
254            continue
255        pid, comm, args = int(parts[0]), parts[2], (parts[3] if len(parts) > 3 else "")
256        nombre, args = _desenvolver(comm, args)
257        nombre = _destruncar(nombre, args)
258        exe, linea, usuario = _mandado_por_supervisor(args) if comm[:15] in _COMM_SUP else ("", "", "")
259        if exe:
260            SUPERVISADOS[pid] = {"exec": exe, "cmdline": linea, "usuario": usuario}
261        vivos.setdefault(nombre, []).append(pid)
262    # los kernel threads no son servicios
263    return {k: v for k, v in vivos.items() if not k.startswith(("kworker", "kthread", "ksoftirq",
264                                                                "migration", "rcu_", "irq/", "idle_"))}
265
266
267def puertos(t):
268    """Qué SIRVE esta máquina, y quién. Un servicio sin puerto no se muda igual que uno con puerto."""
269    out, ok = t.run("ss -lntpH 2>/dev/null || netstat -lntp 2>/dev/null | tail -n +3")
270    res = []
271    for l in out.splitlines():
272        m = re.search(r'(\S+):(\d+)\s', l)
273        proc = re.search(r'\("([^"]+)"|/(\S+)\s*$', l)
274        # El PID es lo que ata el puerto a un servicio sin ambigüedad. Ver comentario en la
275        # asignación: por NOMBRE, un `shuma` declarado-muerto se quedaba con el puerto del
276        # `shuma-gateway` que lo escucha de verdad.
277        pidm = re.search(r'pid=(\d+)', l)
278        res.append({"addr": m.group(1), "port": int(m.group(2)),
279                    "proc": (proc.group(1) or proc.group(2)) if proc else "?",
280                    "pid": int(pidm.group(1)) if pidm else 0}) if m else None
281    # dedup por (puerto, proc)
282    vistos, uniq = set(), []
283    for r in sorted(res, key=lambda x: x["port"]):
284        k = (r["port"], r["proc"], r.get("pid", 0))
285        if k not in vistos:
286            vistos.add(k); uniq.append(r)
287    return uniq
288
289
290def declarados(t):
291    """Lo que el init DICE que hay. Se compara contra lo vivo — no se cree."""
292    fuentes = {}
293    # `rc-status -a` lista TODO lo disponible en el sistema, no lo que esta máquina usa: en gioser
294    # daba 100 «declarado-muerto» que no significan nada. `rc-update show` da lo ENCENDIDO por
295    # runlevel, que es lo que de verdad se declara.
296    out, ok = t.run("rc-update show 2>/dev/null | awk '{print $1}' | grep -E '^[a-z]'")
297    if ok and out:
298        fuentes["openrc"] = out.split()
299    out, ok = t.run("systemctl list-units --type=service --no-legend --no-pager 2>/dev/null | awk '{print $1}'")
300    if ok and out:
301        fuentes["systemd"] = [s.replace(".service", "") for s in out.split()]
302    out, ok = t.run("ls /etc/arje/cards.d/ 2>/dev/null")
303    if ok and out:
304        fuentes["arje-cards"] = [s.replace(".json", "") for s in out.split()]
305    out, ok = t.run("python3 -c \"import json;print(' '.join(n['label'] for n in "
306                    "json.load(open('/ente/seed.card.json'))['genesis']))\" 2>/dev/null")
307    if ok and out:
308        fuentes["arje-seed"] = out.split()
309    out, ok = t.run("ls /etc/service /run/runit/service 2>/dev/null")
310    if ok and out:
311        fuentes["runit"] = out.split()
312    return fuentes
313
314
315# Config del servidor web → qué sitio apunta a qué directorio. Se lee con los LECTORES del centro de
316# traducción (`formatos/`), no con un parser propio: ya existen para caddy, nginx y apache, y tener
317# dos parsers del mismo formato es cómo se separan sin que nadie lo note.
318_CONFS = [("/etc/caddy/Caddyfile", "caddy"),
319          ("/etc/nginx/nginx.conf", "nginx"),
320          ("/etc/nginx/sites-enabled/*", "nginx"),
321          ("/etc/apache2/sites-enabled/*", "apache"),
322          ("/etc/httpd/conf.d/*", "apache")]
323
324
325def sitios_web(t):
326    """Los sitios declarados en la config, con su raíz y si esa raíz EXISTE.
327
328    ── POR QUÉ ESTO NO LO PODÍA DECIR EL DNS ───────────────────────────────────────────────────
329    La sonda DNS dice si un dominio resuelve; no si el servidor tiene algo que servirle. Un bloque
330    cuyo `root` apunta a un directorio que NO existe es un fósil que devuelve 502 — y eso se lee del
331    fichero: **sin red, sin pedirle una página al servidor, sin arriesgar su fail2ban**. Medido en
332    gioser: 3 sitios (`aura`, `sigma`, `kosmofono`) apuntan a raíces borradas, lo que explica los
333    502 que en su día hicieron que el censo se baneara a sí mismo al sondearlos por HTTP.
334
335    Y sirve para lo contrario: un directorio que la config SÍ referencia no es un huérfano. Sin esto
336    el censo marcó `/var/www/git-tawasuyu` como «nadie lo recuerda» cuando es un sitio vivo."""
337    import formatos
338    lectores, _ = formatos.cargar()
339    res = []
340    for patron, fmt in _CONFS:
341        if fmt not in lectores:
342            continue
343        ficheros = [patron]
344        if "*" in patron:
345            out, ok = t.run(f"ls -1 {patron} 2>/dev/null")
346            ficheros = out.split() if ok and out.strip() else []
347        for f in ficheros:
348            texto, ok = t.run(f"cat {f} 2>/dev/null")
349            if not ok or not texto.strip() or texto.startswith("(sonda falló"):
350                continue
351            try:
352                cfg = lectores[fmt][0](texto, f)
353            except Exception as e:
354                # Un parser que revienta NO puede tumbar el censo entero, pero tampoco callarse:
355                # sin esto uno cree que el servidor no declara sitios, que es lo contrario del dato.
356                res.append({"config": f, "formato": fmt, "nombres": "", "raiz": "",
357                            "raiz_existe": "error", "detalle": f"no se pudo leer: {e}"[:120]})
358                continue
359            for s in cfg.sitios:
360                # El `root` del sitio Y los de sus rutas anidadas: un `handle` con su propio `root`
361                # referencia disco igual, y no verlo es lo que hacía pasar por huérfano a un sitio vivo.
362                raices = [(s.raiz or "").rstrip("/")] + [
363                    a.valor.rstrip("/") for r in s.rutas for a in r.acciones if a.tipo == "archivos"]
364                # A DÓNDE PROXEA este sitio: la config declara de qué servicios depende, y eso es
365                # lo único que puede cazar «este dominio se muda y el servicio que lo sirve se mata».
366                prox = [a.valor for a in s.acciones if a.tipo == "proxy"] + [
367                    a.valor for r in s.rutas for a in r.acciones if a.tipo == "proxy"]
368                for raiz in dict.fromkeys(x for x in raices if x) or [""]:
369                    res.append({"config": f, "formato": fmt,
370                                "nombres": " ".join(s.nombres), "raiz": raiz,
371                                "proxies": " ".join(dict.fromkeys(prox)),
372                                "raiz_existe": "", "detalle": ""})
373    # Un solo comando para todas las raíces: una sonda por directorio sobre SSH es lentísima.
374    raices = sorted({r["raiz"] for r in res if r["raiz"]})
375    if raices:
376        guion = "; ".join(f'[ -d {shlex.quote(d)} ] && echo "SI {d}" || echo "NO {d}"' for d in raices)
377        out, _ = t.run(guion)
378        estado = {}
379        for l in out.splitlines():
380            p = l.split(None, 1)
381            if len(p) == 2:
382                estado[p[1]] = "si" if p[0] == "SI" else "no"
383        for r in res:
384            if r["raiz"]:
385                r["raiz_existe"] = estado.get(r["raiz"], "?")
386    return res
387
388
389def dominios(t):
390    """Los dominios que la máquina DICE servir, contrastados con DNS y con un GET real.
391
392    Las tres respuestas posibles importan y son distintas: sin DNS (nadie lo resuelve), con DNS pero
393    5xx (backend caído), y con DNS y 200 (vivo). Y hay una cuarta que sólo se ve mirando a DÓNDE
394    resuelve: un dominio que responde 200 desde OTRA IP ya está mudado, y su bloque de config acá
395    es un fósil."""
396    confs = ["/etc/caddy/Caddyfile", "/etc/nginx/nginx.conf", "/etc/nginx/sites-enabled/*",
397             "/etc/apache2/sites-enabled/*", "/etc/httpd/conf.d/*"]
398    out, _ = t.run("cat " + " ".join(confs) + " 2>/dev/null")
399    nombres = set()
400    for l in out.splitlines():
401        s = l.strip()
402        if s.startswith("#"):
403            continue
404        # caddy: «a.com, b.com {» · nginx/apache: «server_name a.com b.com;» / «ServerName a.com»
405        if s.endswith("{") and not s.startswith(("@", "}")):
406            cand = s[:-1]
407        elif s.lower().startswith(("server_name", "servername", "serveralias")):
408            cand = s.split(None, 1)[1].rstrip(";") if len(s.split(None, 1)) > 1 else ""
409        else:
410            continue
411        for d in re.split(r'[,\s]+', cand):
412            d = d.strip().rstrip(";")
413            if re.fullmatch(r'[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9-]+)+', d, re.I):
414                nombres.add(d.lower())
415    return sorted(nombres)
416
417
418def sondear_dominio(d, ips_maquina, http=True):
419    """DNS (+ HTTP opcional) desde donde corre el censo. Determinista, sin juicio.
420
421    ⚠⚠ **NO se hace contra la máquina que uno está censando desde ella misma.** «Sólo lee» era falso:
422    leer POR RED tiene efectos. Medido el 2026-09-11 — censar gioser en modo `--local` disparó 29
423    peticiones HTTPS a sus propios dominios, varios devuelven 502, y su `fail2ban` (jaula
424    `caddy-backend-down`) **baneó la propia IP de la máquina**. Resultado: gioser dejó de poder hablar
425    con su propio gitea y los `git push` empezaron a fallar con «Could not read from remote
426    repository». Un censo que deja la máquina incomunicada no es de sólo lectura.
427
428    Y además es metodológicamente mejor: lo que interesa es **qué ve el mundo**, no qué ve la máquina
429    de sí misma. Por eso la sonda se hace desde donde corre el censo —el operador o la caja nueva— y
430    se SALTA cuando se censa en local, salvo `--probe` explícito.
431
432    ── PERO EL DNS NO TOCA AL ORIGEN ───────────────────────────────────────────────────────────
433    Lo que dispara el fail2ban es el HTTP, no la resolución: `getent` le pregunta al DNS, no al
434    servidor. Con `--probe-dns` se sondea SÓLO el nombre, y eso ya contesta la pregunta que más
435    pesa en una mudanza — **cuáles de estos dominios siguen apuntando acá y cuáles son fósiles**.
436    Lo que el DNS solo NO puede decir es si el backend contesta, así que esos dominios quedan en
437    `apunta-aca`, que es una clase propia y no `vivo`: decir «vivo» sin haber pedido una página
438    sería exactamente la respuesta falsa con forma de respuesta que este censo existe para evitar."""
439    ip = ""
440    try:
441        r = subprocess.run(["getent", "ahostsv4", d], capture_output=True, text=True, timeout=10)
442        if r.returncode == 0 and r.stdout.strip():
443            ip = r.stdout.split()[0]
444    except Exception:
445        pass
446    code = ""
447    if ip and http:
448        try:
449            r = subprocess.run(["curl", "-sk", "-o", "/dev/null", "-w", "%{http_code}",
450                                "--max-time", "8", f"https://{d}/"], capture_output=True, text=True, timeout=20)
451            code = r.stdout.strip() or "000"
452        except Exception:
453            pass
454    if not ip:
455        clase = "fosil-sin-dns"
456    elif ip not in ips_maquina:
457        clase = "ya-mudado"          # resuelve a otra máquina: el bloque de acá es fósil
458    elif not http:
459        clase = "apunta-aca"         # resuelve acá; si SIRVE no se preguntó, y no se inventa
460    elif code.startswith(("2", "3")):
461        clase = "vivo"
462    else:
463        clase = "backend-caido"
464    return {"domain": d, "dns": ip, "http": code, "class": clase}
465
466
467def datos(t, raices):
468    """Qué pesa y dónde. Sin esto no se puede dimensionar la mudanza — y `du` sobre hardlinks MIENTE
469    para dimensionar una COPIA (medido: 60 G por `du`, 85 G al copiar sin `-H`), así que se reportan
470    los dos números."""
471    res = []
472    for r in raices:
473        out, ok = t.run(f"du -sh {shlex.quote(r)} 2>/dev/null | cut -f1; "
474                        f"du -sh --count-links {shlex.quote(r)} 2>/dev/null | cut -f1")
475        ls = out.splitlines()
476        if ok and ls:
477            res.append({"path": r, "size": ls[0],
478                        "size_copy": ls[1] if len(ls) > 1 else ls[0]})
479    return res
480
481
482def montajes(t):
483    out, _ = t.run("df -h 2>/dev/null | grep -vE 'tmpfs|devtmpfs|^Filesystem|^Sist' ")
484    res = []
485    for l in out.splitlines():
486        f = l.split()
487        if len(f) >= 6:
488            res.append({"dev": f[0], "size": f[1], "used": f[2], "avail": f[3], "mount": f[-1]})
489    return res
490
491
492def fuera_de_git(t):
493    """Lo que NO viaja con el repo y sin lo cual el servidor nuevo no funciona. Se reporta la
494    EXISTENCIA, nunca el contenido: un censo no copia secretos."""
495    cands = ["~/.ssh", "/root/.ssh", "~/.config/hammer", "/root/.config/hammer",
496             "/etc/caddy", "/etc/nginx", "/etc/letsencrypt", "/var/lib/gitea",
497             "/etc/arje/cards.d", "/ente"]
498    res = []
499    for c in cands:
500        out, ok = t.run(f"ls -d {c} >/dev/null 2>&1 && ls -1 {c} 2>/dev/null | head -20")
501        if ok:
502            res.append({"path": c, "entries": out.split() if out else []})
503    out, _ = t.run("crontab -l 2>/dev/null | grep -vE '^#|^$' | wc -l")
504    if out.isdigit() and int(out) > 0:
505        res.append({"path": "crontab", "entries": [f"{out} líneas"]})
506    return res
507
508
509def contenido_web(t, raices=("/var/www", "/srv")):
510    """Qué hay en las raíces de contenido web, con su tamaño. Un nivel, sin juicio.
511
512    ── POR QUÉ EXISTE ──────────────────────────────────────────────────────────────────────────
513    La regla 2 del plan dice que lo que muere se nombra «por su nombre Y CON SU TAMAÑO». Los
514    servicios y los datos ya lo cumplían; los DOMINIOS no — se listaban pelados, y un dominio fósil
515    no pesa nada por sí mismo: pesa lo que dejó en disco. `terapeuta.ec` no resuelve en ningún DNS y
516    tiene 279 M en `/var/www/terapeuta`. Que eso se supiera dependía de que alguien se acordara.
517
518    ⚠ **No se afirma la correspondencia, se OFRECE.** El directorio se llama `terapeuta` y el
519    dominio `terapeuta.ec`: no coinciden. Una regla difusa que empareje «casi» acierta la mayoría de
520    las veces y el resto de las veces manda a borrar lo que no era. Se listan los candidatos con su
521    tamaño y decide el humano — y se listan TAMBIÉN los directorios que no se parecen a ningún
522    dominio, que son los que nadie recuerda (`gioser.bak.20260501`, `ogisoer`)."""
523    res = []
524    for raiz in raices:
525        out, ok = t.run(f"du -sh {raiz}/* 2>/dev/null | sort -rh | head -40")
526        if not ok or not out.strip():
527            continue
528        for l in out.splitlines():
529            p = l.split(None, 1)
530            if len(p) == 2 and p[1].startswith("/"):
531                res.append({"path": p[1], "size": p[0], "raiz": raiz})
532    return res
533
534
535def candidatos_de(dominio, contenido):
536    """Directorios que PODRÍAN ser de este dominio. Por etiqueta principal, no por nombre completo."""
537    d = dominio.lower()
538    etiquetas = [x for x in d.split(".") if x not in ("www", "com", "net", "org", "ec", "io", "dev")]
539    principal = etiquetas[-1] if etiquetas else d
540    out = []
541    for c in contenido:
542        base = os.path.basename(c["path"]).lower()
543        if principal and (principal in base or base.split(".")[0] in etiquetas):
544            out.append(c)
545    return out
546
547
548# ── clasificación ───────────────────────────────────────────────────────────────────────────────
549
550# Nombres que NO son servicios: son el andamiaje del sistema o hijos de un servicio. Contarlos como
551# `no-declarado` es ruido, y un censo con hallazgos falsos se ignora entero.
552NO_SERVICIOS = {
553    "agetty", "getty", "login", "bash", "sh", "dash", "zsh", "ssh", "sshd-session", "su", "sudo",
554    "bwrap", "ps", "awk", "sed", "tail", "sleep", "rsync", "scp", "cat", "python3", "perl",
555    # Restos de tubería reparentados a PID 1 cuando su padre muere. Medido: `head -15` figuraba como
556    # servicio `no-declarado` con ppid==1. No se esconden —salen en `descartados`, porque un huérfano
557    # ES un hallazgo— pero no son servicios y contarlos como tales es el ruido que mata un censo.
558    "head", "tr", "cut", "grep", "wc", "find", "xargs", "tee", "sort", "uniq", "env", "nohup",
559    "timeout", "flock", "tar", "gzip", "zstd", "dd", "md5sum", "sha256sum", "less", "more",
560}
561
562
563def normalizar(n):
564    """Un mismo servicio se llama distinto en cada sitio: OpenRC dice `act-runner`, `ps` dice
565    `act_runner`, systemd dice `act-runner.service`, y los getty por tty son `agetty.tty1`,
566    `agetty-tty2`… Sin normalizar, el MISMO proceso sale a la vez como `no-declarado` y como
567    `declarado-muerto`, que son las dos clases que más importan. Medido en gioser: pasaba con
568    `act_runner`."""
569    n = n.strip().lower()
570    for suf in (".service", ".socket", ".timer", ".target"):
571        if n.endswith(suf):
572            n = n[: -len(suf)]
573    n = n.replace("_", "-")
574    n = re.sub(r'[.\-]tty\d+$', '', n)       # agetty.tty1 / agetty-tty2 → agetty
575    n = re.sub(r'\d+$', '', n) if re.fullmatch(r'[a-z-]+\d+', n) else n
576    return n
577
578
579def emparenta(vivo, declarado):
580    """¿Son el mismo servicio con distinto nombre? Los desajustes son sistemáticos, no caprichosos:
581    el DEMONIO y la UNIDAD se llaman distinto. Medidos en gioser: `crond`↔`cronie`,
582    `dbus-daemon`↔`dbus`, `fail2ban-server`↔`fail2ban`, `elogind-daemon`↔`elogind`.
583
584    Sin esto, cada uno de ésos aparece a la vez como `no-declarado` (falso: sí está declarado) y como
585    `declarado-muerto` (falso: sí está corriendo) — las dos clases que más importan, las dos mal."""
586    if vivo == declarado:
587        return True
588    for suf in ("-daemon", "-server", "-bin"):
589        if vivo.endswith(suf) and vivo[: -len(suf)] == declarado:
590            return True
591    # `crond` → `cron`, prefijo de `cronie`. `sshd` → `ssh`. Sólo quitando UNA `d` final y exigiendo
592    # prefijo: quitar letras a ciegas emparenta cosas que no tienen nada que ver.
593    if len(vivo) > 4 and vivo.endswith("d") and declarado.startswith(vivo[:-1]):
594        return True
595    return False
596
597
598def es_nombre_de_servicio(n):
599    """Descarta lo que claramente no es un servicio: versiones (`2.1.240`), rutas, vacíos. Salieron
600    de parsear `rc-status -a`, cuya salida incluye líneas que no son unidades."""
601    return bool(re.fullmatch(r'[a-z][a-z0-9@._+-]{1,40}', n)) and not re.fullmatch(r'[\d.]+', n)
602
603
604def clasificar(vivos, decl):
605    """Las tres clases. `no-declarado` es la importante: corre y nadie sabe cómo levantarlo."""
606    # índice normalizado: nombre-canónico → fuentes que lo declaran
607    idx = {}
608    for fuente, nombres in decl.items():
609        for n in nombres:
610            if es_nombre_de_servicio(n.lower()):
611                idx.setdefault(normalizar(n), set()).add(fuente)
612
613    out, vistos, descartados = [], set(), []
614    for nombre, pids in sorted(vivos.items()):
615        canon = normalizar(nombre)
616        if canon in NO_SERVICIOS or not es_nombre_de_servicio(canon):
617            # No se esconde: un proceso con ppid==1 que no es un servicio suele ser un HUÉRFANO, y
618            # eso es un hallazgo (procesos fugados que retienen locks, por ejemplo).
619            descartados.append(nombre)
620            continue
621        fuentes = sorted(idx.get(canon, set()))
622        if not fuentes:  # segunda pasada: demonio vs unidad
623            emparentados = [f for d, fs in idx.items() if emparenta(canon, d) for f in fs]
624            fuentes = sorted(set(emparentados))
625            if fuentes:
626                vistos.update(d for d in idx if emparenta(canon, d))
627        vistos.add(canon)
628        out.append({"name": nombre, "pids": pids,
629                    "class": "vivo" if fuentes else "no-declarado",
630                    "declared_in": fuentes})
631    for canon in sorted(set(idx) - vistos):
632        if canon in NO_SERVICIOS:
633            continue
634        out.append({"name": canon, "pids": [],
635                    "class": "declarado-muerto",
636                    "declared_in": sorted(idx[canon])})
637    return out, descartados
638
639
640# ── salida ──────────────────────────────────────────────────────────────────────────────────────
641
642def toml_escape(s):
643    return '"' + str(s).replace("\\", "\\\\").replace('"', '\\"') + '"'
644
645
646def emitir_toml(c):
647    L = []
648    L.append("# censo de mudanza — generado por scripts/mudanza/censar.py. NO editar a mano salvo")
649    L.append("# para DECIDIR: la etapa siguiente lee `decision` de cada entrada.")
650    L.append(f"schema = \"takana-censo/1\"")
651    L.append(f"fecha = {toml_escape(c['fecha'])}")
652    L.append("")
653    L.append("[maquina]")
654    for k, v in c["identidad"].items():
655        L.append(f"{k} = {toml_escape(v) if isinstance(v, str) else json.dumps(v)}")
656    L.append("")
657    for m in c["montajes"]:
658        L.append("[[montaje]]")
659        for k, v in m.items():
660            L.append(f"{k} = {toml_escape(v)}")
661        L.append("")
662    for s in c["servicios"]:
663        L.append("[[servicio]]")
664        L.append(f"name = {toml_escape(s['name'])}")
665        L.append(f"class = {toml_escape(s['class'])}")
666        L.append(f"declared_in = {json.dumps(s['declared_in'])}")
667        L.append(f"pids = {json.dumps(s['pids'])}")
668        # ⚠ Por PID, no por nombre. Emparejar `proc.startswith(name[:15])` le daba el puerto 7378
669        # —que escucha `shuma-gateway`, comprobado con `ss -lntp`— al `shuma` DECLARADO-MUERTO, que
670        # por definición no puede estar escuchando nada. El puerto es la señal más fuerte de que algo
671        # sirve, así que colgárselo al servicio equivocado envenena todo lo que se derive de él.
672        _pids = set(s.get("pids") or [])
673        _mios = [p["port"] for p in c["puertos"] if p.get("pid") and p["pid"] in _pids]
674        if not _mios and _pids:
675            # Sin pid en la salida de `ss` (sin permisos, o `netstat` viejo) se cae al nombre, pero
676            # sólo para servicios VIVOS: un declarado-muerto nunca escucha.
677            _mios = [p["port"] for p in c["puertos"]
678                     if not p.get("pid") and p["proc"].startswith(s["name"][:15])]
679        elif not _pids:
680            _mios = []
681        L.append(f"ports = {json.dumps(sorted(set(_mios)))}")
682        L.append(f"cmdline = {toml_escape(s.get('cmdline',''))}")
683        L.append(f"cwd = {toml_escape(s.get('cwd',''))}")
684        L.append(f"exec = {toml_escape(s.get('exec',''))}")
685        if s.get('usuario'):
686            L.append(f"usuario = {toml_escape(s['usuario'])}")
687        if s.get('exec_borrado'):
688            L.append("exec_borrado = true")
689            L.append(f"pid_vivo = {int(s.get('pid_vivo') or 0)}")
690            L.append(f"bytes_vivo = {toml_escape(s.get('bytes_vivo',''))}")
691            L.append(f"bytes_disco = {toml_escape(s.get('bytes_disco',''))}")
692        if s.get('exec_motivo'):
693            L.append(f"exec_motivo = {toml_escape(s['exec_motivo'])}")
694        L.append(f"paquete = {toml_escape(s.get('paquete',''))}")
695        L.append('decision = ""   # muda | muere | (vacío = sin decidir)')
696        L.append("")
697    for x in c.get("sitios", []):
698        L.append("[[sitio]]")
699        for k, v in x.items():
700            L.append(f"{k} = {toml_escape(v)}")
701        L.append("")
702    for x in c.get("contenido", []):
703        L.append("[[contenido]]")
704        for k, v in x.items():
705            L.append(f"{k} = {toml_escape(v)}")
706        L.append("")
707    for d in c["dominios"]:
708        L.append("[[dominio]]")
709        for k, v in d.items():
710            L.append(f"{k} = {toml_escape(v)}")
711        L.append('decision = ""   # muda | muere | (vacío = sin decidir)')
712        L.append("")
713    for d in c["datos"]:
714        L.append("[[datos]]")
715        for k, v in d.items():
716            L.append(f"{k} = {toml_escape(v)}")
717        # ⚠ `destino` existe porque la ruta de origen NO tiene por qué caber en la misma ruta del
718        # destino. Medido contra la caja takana: `/` tiene 3,5 G libres y los datos de gioser son
719        # 33,6 G — el sitio está en `/work` (66 G) y en `/store` (19 G). Sin este campo el plan
720        # copiaba ruta→misma ruta y la mudanza no entraba, con el detalle de que el fallo aparece a
721        # mitad de un rsync de 22 G.
722        L.append('destino = ""   # vacío = la MISMA ruta en el destino. Ej: "/work/home"')
723        L.append('decision = ""   # muda | muere | (vacío = sin decidir)')
724        L.append("")
725    for f in c["fuera_de_git"]:
726        L.append("[[fuera_de_git]]")
727        L.append(f"path = {toml_escape(f['path'])}")
728        L.append(f"entries = {json.dumps(f['entries'])}")
729        L.append("")
730    return "\n".join(L) + "\n"
731
732
733def resumen(c):
734    i = c["identidad"]
735    print(f"\n══ CENSO de {i['hostname']} ({', '.join(i['ips']) or '?'}) ══")
736    print(f"   kernel {i['kernel']} · PID 1: {i['pid1']}")
737    por_clase = {}
738    for s in c["servicios"]:
739        por_clase.setdefault(s["class"], []).append(s["name"])
740    print("\n── servicios ──")
741    for cl in ("vivo", "no-declarado", "declarado-muerto"):
742        n = por_clase.get(cl, [])
743        marca = "⚠ " if cl == "no-declarado" else "  "
744        print(f"{marca}{cl:18} {len(n):3}  {' '.join(sorted(n)[:8])}{' …' if len(n) > 8 else ''}")
745    if c.get("huerfanos"):
746        print(f"   descartados (no son servicios: herramientas sueltas o HUÉRFANOS con ppid==1): "
747              f"{len(c['huerfanos'])}  {' '.join(sorted(c['huerfanos'])[:8])}")
748    if por_clase.get("no-declarado"):
749        print("   ⚠ `no-declarado` = corre y NADIE sabe cómo levantarlo. Es el trabajo de la mudanza.")
750    if c["dominios"]:
751        print("\n── dominios ──")
752        pd = {}
753        for d in c["dominios"]:
754            pd.setdefault(d["class"], []).append(d["domain"])
755        for cl in ("vivo", "apunta-aca", "ya-mudado", "backend-caido", "fosil-sin-dns", "sin-sondear"):
756            n = pd.get(cl, [])
757            if n:
758                print(f"  {cl:16} {len(n):3}  {' '.join(sorted(n)[:6])}{' …' if len(n) > 6 else ''}")
759    if c["datos"]:
760        print("\n── datos ──")
761        for d in c["datos"]:
762            extra = f"  (copiar sin -H: {d['size_copy']})" if d["size_copy"] != d["size"] else ""
763            print(f"  {d['path']:28} {d['size']:>7}{extra}")
764    print()
765
766
767def main():
768    ap = argparse.ArgumentParser(description="Censo de una máquina para mudarla. Sólo lee.")
769    ap.add_argument("--host", help="usuario@host a censar por SSH")
770    ap.add_argument("--key", help="clave SSH")
771    ap.add_argument("--local", action="store_true", help="censar esta máquina")
772    ap.add_argument("--out", help="fichero TOML de salida (default: stdout sólo el resumen)")
773    ap.add_argument("--probe", action="store_true",
774                    help="sondear los dominios por DNS+HTTP. Por defecto SÓLO con --host: hacerlo "
775                         "contra uno mismo puede disparar el fail2ban de la propia máquina")
776    ap.add_argument("--probe-dns", action="store_true",
777                    help="sondear SÓLO el DNS (sin HTTP): no toca al origen, así que es seguro "
778                         "contra uno mismo. Dice qué dominios son fósiles y cuáles apuntan acá")
779    ap.add_argument("--no-probe", action="store_true", help="no sondear dominios")
780    ap.add_argument("--data-root", action="append", default=[],
781                    help="raíz de datos a medir (repetible). Default: las habituales")
782    a = ap.parse_args()
783    if not a.host and not a.local:
784        ap.error("hace falta --host o --local")
785
786    t = Objetivo(a.host, a.key)
787    print("   censando… (no se ESCRIBE nada; las sondas de red sí dejan huella: ver --probe)",
788          file=sys.stderr)
789
790    ident = identidad(t)
791    vivos = procesos_vivos(t)
792    decl = declarados(t)
793    svc, huerfanos = clasificar(vivos, decl)
794    inv = invocaciones(t, vivos)
795    for e in svc:
796        i = inv.get(e['name'], {})
797        e['cmdline'] = i.get('cmdline', '')
798        e['cwd'] = i.get('cwd', '')
799        e['exe_real'] = i.get('exe', '')
800        if i.get('exe_borrado'):
801            e['exec_borrado'] = True
802            e['pid_vivo'] = i.get('pid', 0)
803            e['bytes_vivo'] = i.get('bytes_vivo', '')
804            e['bytes_disco'] = i.get('bytes_disco', '')
805        if i.get('usuario'):
806            e['usuario'] = i['usuario']
807    # `/proc/<pid>/exe` MANDA sobre `argv[0]`: es el binario de verdad y no lo puede reescribir el
808    # proceso. `argv[0]` queda de respaldo para cuando la sonda no tuvo permiso.
809    def _exe_de(e):
810        return e.get('exe_real') or (
811            (e.get('cmdline') or '').split(' ')[0] if (e.get('cmdline') or '').startswith('/') else '')
812    ejes = [x for x in (_exe_de(e) for e in svc) if x]
813    dn = duenos(t, ejes)
814    raiz = os.geteuid() == 0 if a.local else None
815    for e in svc:
816        exe = _exe_de(e)
817        e['exec'] = exe
818        e['paquete'] = dn.get(exe, '')
819        if not exe and e.get('pids'):
820            # Decir POR QUÉ no se sabe. «Averigualo a mano» y «volvé a correr el censo con sudo» son
821            # dos trabajos muy distintos, y confundirlos manda a alguien a investigar un permiso.
822            e['exec_motivo'] = ("el censo no corrió como root: `/proc/<pid>/exe` de un proceso de "
823                                "otro usuario no se puede leer. Repetilo con sudo"
824                                if raiz is False else
825                                "el proceso reescribió su argv[0] y no se pudo leer /proc/<pid>/exe")
826    pts = puertos(t)
827    nombres = dominios(t)
828    cont = contenido_web(t)
829    sitios = sitios_web(t)
830    sondear = (a.probe or a.probe_dns or bool(a.host)) and not a.no_probe
831    http_ok = not a.probe_dns
832    if nombres and not sondear:
833        print(f"   ⚠ {len(nombres)} dominio(s) declarados, SIN sondear: censando en local, y pedirle",
834              file=sys.stderr)
835        print("     a la máquina sus propios dominios puede disparar su fail2ban y dejarla",
836              file=sys.stderr)
837        print("     incomunicada (pasó). Sondealos desde otra máquina, o forzá con --probe.",
838              file=sys.stderr)
839        doms = [{"domain": d, "dns": "", "http": "", "class": "sin-sondear"} for d in nombres]
840    else:
841        doms = []
842        for i, d in enumerate(nombres):
843            if i and http_ok:
844                time.sleep(0.5)   # no parecer un escaneo ante el propio fail2ban del objetivo
845            doms.append(sondear_dominio(d, set(ident["ips"]), http_ok))
846    raices = a.data_root or ["/var/www", "/var/lib", "/srv", "/opt", "/home", "/store"]
847    dat = datos(t, raices)
848    censo = {
849        "fecha": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
850        "identidad": ident, "servicios": svc, "huerfanos": huerfanos, "puertos": pts,
851        "dominios": doms, "datos": dat, "contenido": cont, "sitios": sitios, "montajes": montajes(t),
852        "fuera_de_git": fuera_de_git(t),
853    }
854    resumen(censo)
855    if a.out:
856        with open(a.out, "w") as f:
857            f.write(emitir_toml(censo))
858        print(f"   censo → {a.out}   (decidí `decision` en cada entrada y pasalo a la etapa 2)")
859
860
861if __name__ == "__main__":
862    main()