anubis-fetch

$ nix run github:fzakaria/anubis-fetch -- --text https://lore.kernel.org/

Una CLI de Go para obtener URLs detrás de los desafíos de prueba de trabajo de Anubis. Resuelve desafíos heredados de SHA-256 y WASM en proceso, con Chromium sin interfaz como respaldo.

Sitios como lore.kernel.org y kernel.org usan Anubis para requerir prueba de trabajo antes de servir una página. Un cliente HTTP simple puede recibir la página de desafío en lugar del contenido solicitado. anubis-fetch resuelve el desafío, envía la respuesta y escribe la página resultante en stdout.

Cómo funciona

1. Reutiliza una cookie guardada. Anubis emite una cookie de autenticación tras un desafío exitoso. La herramienta guarda cookies por host y las envía en solicitudes posteriores.
2. Resuelve la prueba de trabajo en proceso. El cliente HTTP usa req para suplantar la huella TLS y HTTP/2 de Chrome. Esto puede ayudar con verificaciones pasivas de bots, incluidas las de Cloudflare. Para los métodos fast y slow de Anubis, la herramienta calcula un nonce y envía la respuesta directamente. Para los métodos WASM sha256, argon2id y hashx, descarga el módulo del sitio y lo ejecuta en Go con wazero.
3. Recurre a un navegador. Chromium sin interfaz, controlado por chromedp, ejecuta el código del desafío servido por el sitio.

El respaldo del navegador maneja los métodos preact y metarefresh de Anubis, y las páginas de desafío de Cloudflare (respuestas con cf-mitigated: challenge). La herramienta también recurre al navegador cuando la dificultad del SHA-256 heredado excede su límite, la ejecución de WASM falla o expira, o Anubis rechaza una solución. Usa --browser para comenzar con Chromium, o --no-browser para requerir la ruta HTTP. Los tres métodos WASM funcionan con --no-browser.

¿Por qué no usar un navegador para todo?

El solucionador nativo evita iniciar un proceso de navegador para cada obtención. Chromium sigue incluido en el paquete Nix para los desafíos que necesitan el respaldo.

Tiempos aproximados de obtención para la ruta SHA-256 original:

Ruta	Tiempo real	Necesita Chromium
Solucionador SHA-256 en proceso	~0.6s	No
Respaldo con navegador	~2.0s	Sí

Tiempos de obtención WASM contra un servidor Anubis local con dificultad 2:

Método WASM	Tiempo real mediano	Necesita Chromium
SHA-256	~0.025s	No
Argon2id	~0.55s-2.33s	No
HashX	~0.041s	No

La prueba de trabajo de Anubis, brevemente

Para los métodos fast y slow, Anubis incrusta el desafío en la página:

{"rules":{"algorithm":"fast","difficulty":4},
 "challenge":{"id":"...","method":"fast","randomData":"6214bd88...","difficulty":4}}

El solucionador busca un nonce tal que hex(sha256(randomData || nonce)) comience con difficulty caracteres cero. El nonce se codifica como una cadena decimal. La respuesta se envía a Anubis:

GET /.within.website/x/cmd/anubis/api/pass-challenge?id=...&response=<hash>&nonce=<n>&redir=<url>&elapsedTime=<ms>

Una respuesta exitosa establece una cookie de autenticación y redirige a la página solicitada. La dificultad 4 requiere aproximadamente 65,536 hashes en promedio.

Desafíos WASM

Para sha256, argon2id y hashx, Anubis sirve un módulo WebAssembly que implementa la prueba de trabajo. anubis-fetch descarga el módulo, decodifica los datos hexadecimales del desafío a bytes, y pasa los datos y la dificultad al módulo. El módulo busca un nonce y devuelve el nonce y el hash para enviarlos al mismo endpoint anterior.

El módulo se ejecuta dentro del proceso de Go usando wazero, por lo que estos métodos funcionan con --no-browser. La ejecución tiene límites de memoria y tiempo. El módulo define las reglas de dificultad; los números de dificultad de WASM no son directamente comparables con el método SHA-256 heredado.

Instalación

Ejecutar directamente:

$ nix run github:fzakaria/anubis-fetch -- <url>

O añade la entrada a tu flake:

{
  inputs.anubis-fetch.url = "github:fzakaria/anubis-fetch";
}

Añade inputs.anubis-fetch.packages.${system}.default a home.packages o environment.systemPackages.

Uso

anubis-fetch [flags] URL

Flag	Efecto
--text	Convierte HTML a texto plano
--timeout MS	Establece el tiempo de espera por paso en milisegundos; por defecto 30000
--ua STRING	Establece el User-Agent
--browser	Usa Chromium directamente
--no-browser	Sale con 3 si el solucionador HTTP necesita el respaldo del navegador
--no-cache	Desactiva la lectura y escritura de cookies guardadas
--help, -h	Muestra el uso y sale

# HTML a stdout
anubis-fetch https://lore.kernel.org/

# Texto plano
anubis-fetch --text https://lore.kernel.org/

# Requiere la ruta HTTP; comprueba el estado de salida 3
anubis-fetch --no-browser https://lore.kernel.org/

Persistencia de cookies

Las cookies se guardan por host en $XDG_CACHE_HOME/anubis-fetch/cookies/<host>.json, o ~/.cache/anubis-fetch/cookies/<host>.json cuando XDG_CACHE_HOME no está establecido. Una cookie de autenticación válida puede permitir que las solicitudes posteriores omitan el desafío. Las cookies obtenidas a través de Chromium también se guardan, junto con el User-Agent de Chromium. Cloudflare solo respeta cf_clearance bajo el User-Agent que lo obtuvo, por lo que las solicitudes HTTP posteriores a ese host envían el User-Agent guardado a menos que --ua lo sobrescriba.

Usa --no-cache para obtener sin cookies guardadas, o elimina el archivo del host para descartarlas. Una cookie expirada o rechazada requiere un nuevo desafío.

Desarrollo

$ nix develop          # Go, gopls, Chromium, treefmt
$ go test ./...        # Pruebas unitarias de Go
$ nix build            # CLI empaquetada
$ nix flake check      # Compilaciones, pruebas y formato
$ nix fmt              # Formatea Go y Nix

Dependencias

• TecharoHQ/anubis: el servidor de desafíos.
• imroc/req: el cliente HTTP con suplantación de Chrome.
• chromedp/chromedp: el controlador de Chromium.
• tetratelabs/wazero: el runtime de WebAssembly para Go.