sergio/takana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

parches: los 8 FUZZ del catálogo, mirados uno por uno — y un libro que se auto-invalida

Browse Source 
`vigia-parches.py --all` sobre las 99 aplicaciones de parche del catálogo: **0 FALLA**, y 14 líneas
FUZZ (8 pares parche/fuente distintos). FUZZ significa que `patch` metió el cambio ADIVINANDO dónde
porque el contexto no casaba, y si cayó en el sitio correcto sólo lo dice el diff. Nadie los había
mirado. Los miré todos:

  · **libxml2 / CVE-2026-6732** — el que más importaba, un parche de seguridad con fuzz 2 en sus dos
    hunks. Cayó bien: los dos dentro de `xmlParseReference()`, las 4 llamadas pasan `ctxt->userData`
    y no sobrevive ningún `sax->characters(ctxt,` en el fichero. El fuzz era por un offset de 226
    líneas, no por el sitio.
  · **doas / rowhammer** — el otro sensible, toca la decisión de privilegio. Cae dentro de
    `checkconfig()` y queda `rv=permit(...); if(rv==0)→permit`, coherente con el `if(rv!=0)→EPERM`
    de `main()`. Y el fuzz lo causa un parche ANTERIOR de la propia cadena (el `#ifdef DOAS_CONFDIR`
    que inserta `configuration-directory.patch`), no un cambio de upstream — que es una causa que no
    se me habría ocurrido sin abrirlo.
  · **wayland**, **mesa** (×3), **cairo** (×2), **firefox** (time64 y fix-rust-target): todos en su
    sitio, cada uno comprobado contra lo que el propio parche declara querer.
  · **gnupg / 0001-include-unistd** — hallazgo: el parche está OBSOLETO. Añade `#include <unistd.h>`
    y upstream YA lo trae dos líneas más abajo, así que sólo lo duplica. Inocuo (el header tiene
    guardas) y por eso el fuzz 2: cambió el contexto porque upstream lo incorporó. Quitarlo re-hashea
    gnupg, así que se paga cuando se re-selle por otro motivo.

Y para que esto no se repregunte en cada corrida —lo que vuelve ruido al vigía, y así es como se
pierde el FALLA del día que aparezca— los veredictos van a `docs/state/fuzz-verificado.tsv` con un
cuarto estado, FUZZ✓.

La clave del libro NO es (receta, parche) sino (receta, parche, HUELLA), donde la huella resume el
texto del parche MÁS el pin de la fuente. Tocá el parche o subí la versión y la huella cambia, la
entrada deja de casar y el vigía vuelve a preguntar. Es lo contrario de una lista de excepciones: no
hay forma de silenciar algo y que siga silenciado cuando cambió. Y el vigía imprime la línea lista
para pegar debajo de cada FUZZ sin verificar, porque calcular la huella a mano es justo la fricción
que hace que nadie lo anote.

Los dos FUZZ de waterfox quedan FUERA del libro a propósito: no los verifiqué en esta ronda y
waterfox está fuera de alcance. Van a seguir saliendo como FUZZ, que es lo honesto — el libro dice
lo que se miró, no lo que se supone.
This commit is contained in:
Sergio
2026-09-05 17:34:28 +00:00
parent 2a62c44b19
commit db7fd81236
2 changed files with 85 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/vigia-parches.py
+56 -5
View File
@@ -27,6 +27,12 @@
# que el fichero creció por arriba, no que el contexto haya cambiado.
# FUZZ entra, pero adivinando. NO es un fallo y no rompe el build — es la señal de que hay
# que abrir el diff y confirmar a mano que el cambio cayó donde debía.
# FUZZ✓ entra adivinando, PERO alguien ya abrió el diff y anotó dónde cayó, en
# `docs/state/fuzz-verificado.tsv`. La entrada está indexada por una huella del parche
# MÁS el pin de la fuente: si cualquiera de los dos cambia, deja de casar y vuelve a
# salir como FUZZ. Un fuzz mirado no debería preguntarse en cada corrida —eso vuelve
# ruido al vigía y así es como se pierde el FALLA del día que aparezca— pero tampoco
# debe poder silenciarse para siempre.
# FALLA no entra. Esto sí es el muro, y es el que queremos ver en dos minutos y no en cuatro
# horas. El arreglo es rebasar el parche que se queje, no bajar el listón del vigía.
#
@@ -55,6 +61,7 @@
import argparse
import os
import hashlib
import re
import shutil
import subprocess
@@ -70,6 +77,41 @@ ROOT = Path(__file__).resolve().parent.parent
# `patch` reporta el desplazamiento y el fuzz por hunk, en stdout, sólo con --verbose.
RE_HUNK = re.compile(r"^Hunk #(\d+) (succeeded|FAILED) at (\d+)(.*)$", re.M)
RE_FUZZ = re.compile(r"with fuzz (\d+)")
# ── EL LIBRO DE FUZZ YA MIRADOS ────────────────────────────────────────────────────────────────
# Un FUZZ no se puede resolver automáticamente: hay que abrir el diff y ver si el cambio cayó donde
# debía. Pero una vez mirado, el veredicto NO caduca solo — depende de dos cosas y las dos están
# pineadas: el TEXTO del parche y la FUENTE. Repreguntarlo en cada corrida convierte al vigía en
# ruido y se acaba ignorando (que es como se pierde el FALLA del día que aparezca).
#
# Por eso el libro se indexa por una HUELLA de las dos cosas. Si alguien toca el parche, o sube la
# versión de la receta, la huella cambia, la entrada deja de casar y el vigía vuelve a preguntar.
# Es lo contrario de una lista de excepciones: no hay forma de silenciar algo y que se quede
# silenciado cuando cambió.
LIBRO = Path(__file__).resolve().parent.parent / "docs/state/fuzz-verificado.tsv"
def huella(texto_parche: str, src: dict) -> str:
"""Identidad de un (parche, fuente) pineados. Cambiá cualquiera de los dos y cambia."""
pin = src.get("sha256") or src.get("commit") or ""
h = hashlib.sha256()
h.update(texto_parche.encode())
h.update(b"\n")
h.update(pin.encode())
return h.hexdigest()[:16]
def cargar_libro() -> dict:
if not LIBRO.exists():
return {}
out = {}
for linea in LIBRO.read_text(encoding="utf8").splitlines():
if linea.startswith("#") or not linea.strip():
continue
campos = linea.split("\t")
if len(campos) >= 4:
out[(campos[0], campos[1], campos[2])] = campos[3]
return out
RE_OFFSET = re.compile(r"offset (-?\d+) lines?")
@@ -136,7 +178,7 @@ def traer_tarball(url: str, ficheros: list[str], dest: Path) -> None:
destino.write_bytes(src.read())
def probar(receta: Path, keep: bool, git_only: bool) -> tuple[str, list[str]]:
def probar(receta: Path, keep: bool, git_only: bool, libro: dict) -> tuple[str, list[str]]:
"""Devuelve (estado, líneas del informe) para una receta. Estado ∈ ok|fuzz|falla|saltada."""
datos = tomllib.loads(receta.read_text(encoding="utf8"))
src = datos.get("source", {})
@@ -192,10 +234,18 @@ def probar(receta: Path, keep: bool, git_only: bool) -> tuple[str, list[str]]:
if "FAILED" in l or "can't find file" in l or "Reversed" in l:
lineas.append(f" {l.strip()}")
elif fuzz:
if peor != "falla":
peor = "fuzz"
det = ", ".join(f"hunk #{h} fuzz {f}" for h, f in fuzz)
lineas.append(f" FUZZ {base} ({det}) — entra ADIVINANDO, mirá el diff")
hu = huella(textos[p], src)
visto = libro.get((nombre, base, hu))
if visto:
lineas.append(f" FUZZ✓ {base} ({det}) — ya mirado: {visto}")
else:
if peor != "falla":
peor = "fuzz"
lineas.append(f" FUZZ {base} ({det}) — entra ADIVINANDO, mirá el diff")
# La línea lista para pegar en el libro DESPUÉS de mirarlo. Se da acá porque
# calcular la huella a mano es justo la fricción que hace que nadie lo anote.
lineas.append(f" libro: {nombre}\t{base}\t{hu}\t<tu veredicto>")
else:
extra = f" ({len(offs)} hunks desplazados)" if offs else ""
lineas.append(f" ok {base}{extra}")
@@ -225,10 +275,11 @@ def main() -> int:
ap.error("dame una receta o --all")
peor = "ok"
libro = cargar_libro()
orden = {"saltada": 0, "ok": 1, "fuzz": 2, "falla": 3}
for r in objetivos:
try:
estado, lineas = probar(r, a.keep, a.git_only)
estado, lineas = probar(r, a.keep, a.git_only, libro)
except subprocess.CalledProcessError as e:
estado, lineas = "falla", [f"{r}: ✗ no pude traer la fuente ({e})"]
except Exception as e: # una receta rota no debe tumbar el barrido entero