anubis-fetch

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

Un CLI Go pour récupérer des URLs derrière les défis de preuve de travail Anubis. Il résout les défis SHA-256 hérités et WASM en cours de processus, avec Chromium sans interface comme solution de repli.

Des sites tels que lore.kernel.org et kernel.org utilisent Anubis pour exiger une preuve de travail avant de servir une page. Un client HTTP simple peut recevoir la page de défi au lieu du contenu demandé. anubis-fetch résout le défi, soumet la réponse et écrit la page résultante sur stdout.

Fonctionnement

1. Réutiliser un cookie enregistré. Anubis émet un cookie d'authentification après un défi réussi. L'outil enregistre les cookies par hôte et les envoie lors des requêtes ultérieures.
2. Résoudre la preuve de travail en cours de processus. Le client HTTP utilise req pour usurper l'empreinte TLS et HTTP/2 de Chrome. Cela peut aider face aux vérifications passives de bots, y compris celles de Cloudflare. Pour les méthodes fast et slow d'Anubis, l'outil calcule un nonce et soumet la réponse directement. Pour les méthodes WASM sha256, argon2id et hashx, il télécharge le module du site et l'exécute en Go avec wazero.
3. Revenir à un navigateur. Chromium sans interface, piloté par chromedp, exécute le code de défi servi par le site.

Le repli sur navigateur gère les méthodes preact et metarefresh d'Anubis, ainsi que les pages de défi Cloudflare (réponses avec cf-mitigated: challenge). L'outil bascule également en repli lorsque la difficulté SHA-256 héritée dépasse sa limite, que l'exécution WASM échoue ou expire, ou qu'Anubis rejette une solution. Utilisez --browser pour démarrer avec Chromium, ou --no-browser pour exiger le chemin HTTP. Les trois méthodes WASM fonctionnent avec --no-browser.

Pourquoi ne pas tout faire avec un navigateur ?

Le solveur natif évite de démarrer un processus de navigateur à chaque récupération. Chromium est tout de même inclus dans le paquet Nix pour les défis qui nécessitent le repli.

Temps de récupération approximatifs pour le chemin SHA-256 d'origine :

Chemin	Temps réel	Nécessite Chromium
Solveur SHA-256 en cours de processus	~0,6s	Non
Repli sur navigateur	~2,0s	Oui

Temps de récupération WASM contre un serveur Anubis local à difficulté 2 :

Méthode WASM	Temps réel médian	Nécessite Chromium
SHA-256	~0,025s	Non
Argon2id	~0,55s-2,33s	Non
HashX	~0,041s	Non

La preuve de travail d'Anubis, brièvement

Pour les méthodes fast et slow, Anubis intègre le défi dans la page :

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

Le solveur cherche un nonce tel que hex(sha256(randomData || nonce)) commence par difficulty caractères zéro. Le nonce est encodé sous forme de chaîne décimale. La réponse est soumise à Anubis :

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

Une réponse réussie définit un cookie d'authentification et redirige vers la page demandée. La difficulté 4 nécessite environ 65 536 hachages en moyenne.

Défis WASM

Pour sha256, argon2id et hashx, Anubis sert un module WebAssembly qui implémente la preuve de travail. anubis-fetch télécharge le module, décode les données hexadécimales du défi en octets, et transmet les données et la difficulté au module. Le module recherche un nonce et renvoie le nonce et le hachage à soumettre au même endpoint ci-dessus.

Le module s'exécute à l'intérieur du processus Go via wazero, de sorte que ces méthodes fonctionnent avec --no-browser. L'exécution a des limites de mémoire et de temps. Le module définit les règles de difficulté ; les nombres de difficulté WASM ne sont pas directement comparables à la méthode SHA-256 héritée.

Installation

Exécuter directement :

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

Ou ajoutez l'entrée à votre flake :

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

Ajoutez inputs.anubis-fetch.packages.${system}.default à home.packages ou environment.systemPackages.

Utilisation

anubis-fetch [flags] URL

Option	Effet
--text	Convertir le HTML en texte brut
--timeout MS	Définir le délai d'expiration par étape en millisecondes ; par défaut 30000
--ua STRING	Définir le User-Agent
--browser	Utiliser Chromium directement
--no-browser	Quitter avec le code 3 si le solveur HTTP nécessite le repli sur navigateur
--no-cache	Désactiver la lecture et l'écriture des cookies enregistrés
--help, -h	Afficher l'utilisation et quitter

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

# Texte brut
anubis-fetch --text https://lore.kernel.org/

# Exiger le chemin HTTP ; vérifier le code de sortie 3
anubis-fetch --no-browser https://lore.kernel.org/

Persistance des cookies

Les cookies sont enregistrés par hôte dans $XDG_CACHE_HOME/anubis-fetch/cookies/<host>.json, ou ~/.cache/anubis-fetch/cookies/<host>.json lorsque XDG_CACHE_HOME n'est pas défini. Un cookie d'authentification valide peut permettre aux requêtes ultérieures de contourner le défi. Les cookies obtenus via Chromium sont également enregistrés, ainsi que le User-Agent de Chromium. Cloudflare n'honore cf_clearance que sous le User-Agent qui l'a obtenu, donc les requêtes HTTP ultérieures vers cet hôte envoient le User-Agent enregistré, sauf si --ua le remplace.

Utilisez --no-cache pour récupérer sans cookies enregistrés, ou supprimez le fichier de l'hôte pour les écarter. Un cookie expiré ou rejeté nécessite un nouveau défi.

Développement

$ nix develop          # Go, gopls, Chromium, treefmt
$ go test ./...        # Tests unitaires Go
$ nix build            # CLI empaqueté
$ nix flake check      # Compilations, tests et formatage
$ nix fmt              # Formater Go et Nix

Dépendances

• TecharoHQ/anubis : le serveur de défis.
• imroc/req : le client HTTP avec usurpation de Chrome.
• chromedp/chromedp : le pilote Chromium.
• tetratelabs/wazero : le runtime WebAssembly Go.