Altcha : Vire ton CAPTCHA pourri et passe à l'open-source

Tu en as marre de ces CAPTCHA qui te demandent de sélectionner des feux de circulation pendant 10 minutes ? Ou pire, de cliquer sur des images floues en te demandant si un morceau de vélo compte vraiment comme "vélo" ? Bienvenue au club, on est tous passés par là. Et devine quoi ? Y'a une solution qui déchire pour se débarrasser de cette plaie tout en protégeant ton site des bots : Altcha.

Si t'es du genre à aimer le contrôle total sur ton infrastructure, la vie privée de tes utilisateurs et les solutions open-source, accroche-toi parce que je vais te présenter un projet qui va te faire vibrer. Altcha, c'est pas juste un énième CAPTCHA, c'est carrément une révolution dans la protection anti-spam.

Pourquoi les CAPTCHA classiques, c'est de la m*rde ?

Bon, soyons honnêtes deux secondes. Les CAPTCHA traditionnels (ouais, je parle de toi, reCAPTCHA), c'est :

Chiant pour l'utilisateur : Qui a envie de passer 5 minutes à identifier des panneaux de signalisation juste pour envoyer un formulaire de contact ? Personne.
Pas respectueux de la vie privée : Google, Cloudflare et compagnie adorent tracker tes utilisateurs avec leurs CAPTCHA. Cookies, fingerprinting, tout y passe.
Pas accessible : Les personnes malvoyantes ou utilisant un lecteur d'écran ? Bonne chance avec les puzzles visuels.
Gourmand en ressources : Ces trucs chargent des tonnes de scripts externes qui plombent les perfs de ton site.
Dépendance à des tiers : T'es à la merci de Google ou Cloudflare. Si leur service tombe, ton site aussi.

Bref, c'est pas génial. Et c'est là qu'Altcha débarque comme un super-héros de l'open-source.

Altcha, c'est quoi exactement ?

Altcha, c'est une alternative gratuite, open-source et auto-hébergeable aux CAPTCHA classiques. Contrairement aux solutions traditionnelles, Altcha utilise un mécanisme de preuve de travail (Proof-of-Work, ou PoW) léger. En gros, au lieu de te faire cliquer sur des images, ton navigateur résout un petit challenge cryptographique pour prouver que t'es humain.

Et le meilleur dans tout ça ? Pas de cookies, pas de tracking, pas de collecte de données perso. C'est conforme RGPD, WCAG 2.2 AA, et même à l'European Accessibility Act. En clair, c'est clean, éthique, et ça respecte vraiment tes utilisateurs.

Les points forts d'Altcha

✅ Respect de la vie privée : Zéro tracking, zéro cookie, zéro donnée perso collectée.
✅ Open-source : Code disponible sur GitHub, licence MIT. Tu peux l'auditer, le modifier, le forker.
✅ Auto-hébergé : Tu gardes le contrôle total. Pas de dépendance à un service tiers.
✅ Léger : Seulement 30 KB en gzippé (90% plus léger que reCAPTCHA).
✅ Accessible : Support de 50+ langues, conforme aux normes d'accessibilité.
✅ Facile à intégrer : Une simple balise HTML et quelques lignes de code backend.

Comment ça marche sous le capot ?

L'architecture d'Altcha est modulaire et simple :

Altcha Widget : C'est le composant web côté client (le truc que l'utilisateur voit). Il charge un challenge cryptographique que le navigateur doit résoudre.
Altcha Sentinel : C'est le serveur backend qui génère les challenges et vérifie les solutions. Tu peux l'auto-héberger avec Docker ou utiliser le service public d'Altcha.

Le processus est ultra fluide :

L'utilisateur arrive sur ton formulaire.
Le widget Altcha charge un challenge depuis ton serveur Sentinel.
Le navigateur résout le challenge (c'est rapide, genre quelques millisecondes).
La solution est envoyée à ton backend pour vérification.
Si c'est bon, le formulaire est validé. Sinon, c'est bloqué.

Et tout ça sans faire chier l'utilisateur avec des puzzles visuels ou des clics interminables. C'est invisible, rapide, et efficace.

Déployer Altcha Sentinel avec Docker

Bon, passons aux choses sérieuses. Altcha peut fonctionner de deux façons :

Mode self-hosted simple : Tu génères et vérifies les challenges directement dans ton backend avec altcha-lib. Pas besoin de Sentinel, tout tourne dans ton app.
Mode Sentinel (recommandé) : Tu déploies Sentinel qui gère les challenges, la détection de bots avancée, le machine learning, et plein d'autres trucs de ouf.

Dans cet article, on va se concentrer sur Sentinel parce que c'est lui qui apporte la vraie valeur ajoutée : détection adaptative, threat intelligence, rate limiting, etc.

Si tu veux auto-héberger Altcha (et crois-moi, tu veux), voici comment faire avec Docker. C'est simple, propre, et ça tourne nickel.

Prérequis

Un serveur (VPS, machine locale) avec Docker et Docker Compose installés.
Un nom de domaine (recommandé pour la prod) et un certificat SSL (Let's Encrypt, c'est gratuit).
Des connaissances basiques en Docker et en config YAML.

Étape 1 : Déploie Sentinel avec Docker

La façon la plus simple est d'utiliser l'image officielle Docker. Sentinel génère automatiquement un fichier .env sécurisé avec des secrets aléatoires.

# Créer un volume Docker pour les données persistantes
docker volume create altcha_sentinel_data

# Lancer Sentinel
docker run -d \
  -p 8080:8080 \
  -v altcha_sentinel_data:/data \
  ghcr.io/altcha-org/sentinel:latest

Important : Sentinel tourne sur le port 8080 par défaut (pas 3000).

Une fois lancé, tu peux accéder à :

Interface web : http://localhost:8080
API : http://localhost:8080/v1
Documentation API : http://localhost:8080/v1/docs

Credentials par défaut :

Username : root
Password : root

⚠️ Change le mot de passe immédiatement après la première connexion !

Étape 2 : Configuration avancée (optionnel)

Le serveur génère automatiquement un .env sécurisé dans /data. Tu peux le modifier ou passer des variables d'environnement :

docker run -d \
  -p 8080:8080 \
  -v altcha_sentinel_data:/data \
  -e CPU_LIMIT=2 \
  -e MEMORY_LIMIT=2048 \
  ghcr.io/altcha-org/sentinel:latest

Étape 3 : Configure un reverse proxy (Nginx, Traefik, Caddy)

Pour exposer Sentinel en HTTPS (obligatoire en prod), tu vas avoir besoin d'un reverse proxy. Voici un exemple avec Nginx :

server {
    listen 443 ssl http2;
    server_name sentinel.tondomaine.com;

    ssl_certificate /etc/letsencrypt/live/sentinel.tondomaine.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/sentinel.tondomaine.com/privkey.pem;

    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Redémarre Nginx :

sudo systemctl reload nginx

Et voilà, ton Sentinel est accessible en HTTPS sur https://sentinel.tondomaine.com ! 🎉

Intégrer le widget Altcha dans ta page web

Maintenant qu'on a le serveur qui tourne, on va intégrer le widget dans notre site. C'est ridiculement simple.

Étape 1 : Ajoute le script JS

Dans ta page HTML, ajoute le script du widget :

<script async defer src="https://cdn.jsdelivr.net/gh/altcha-org/altcha@main/dist/altcha.min.js" type="module"></script>

Étape 2 : Intègre le widget dans ton formulaire

Le widget se connecte à ton Sentinel via l'endpoint /v1/challenge :

<form action="/submit" method="POST">
  <input type="email" name="email" placeholder="Ton email" required />
  <textarea name="message" placeholder="Ton message" required></textarea>
  
  <!-- Le widget Altcha -->
  <altcha-widget challengeurl="https://sentinel.tondomaine.com/v1/challenge?apiKey=YOUR_API_KEY"></altcha-widget>
  
  <button type="submit">Envoyer</button>
</form>

⚠️ Note : Tu dois récupérer ton apiKey depuis l'interface Sentinel (http://localhost:8080 ou ton domaine).

Étape 3 : Vérifie la solution côté serveur

Maintenant, il faut vérifier que le token Altcha est valide avant de traiter le formulaire. Il y a deux façons de faire :

Option 1 : Avec la bibliothèque altcha-lib (recommandé)

npm install altcha-lib

import { Hono } from 'hono';
import { verifyServerSignature } from 'altcha-lib';

const apiKeySecret = 'sec_ton_api_key_secret'; // Depuis Sentinel
const app = new Hono();

app.post('/submit', async (c) => {
  const formData = await c.req.formData();
  const altchaToken = formData.get('altcha');
  
  if (!altchaToken) {
    return c.json({ error: 'Token Altcha manquant' }, 400);
  }

  // Vérifie le token avec Sentinel
  const { verified, verificationData } = await verifyServerSignature(
    String(altchaToken),
    apiKeySecret
  );
  
  if (!verified) {
    return c.json({ error: 'Token Altcha invalide - T\'es un bot ?' }, 400);
  }

  // Traitement du formulaire
  const email = formData.get('email');
  const message = formData.get('message');
  
  console.log(`Email: ${email}, Message: ${message}`);
  console.log('Verification Data:', verificationData);
  
  return c.json({ ok: true, message: 'Formulaire envoyé !' });
});

export default app;

Option 2 : Via l'API HTTP Sentinel

Si tu ne peux pas utiliser la bibliothèque JavaScript (par exemple en PHP ou Python), tu peux vérifier via l'API HTTP :

app.post('/submit', async (c) => {
  const formData = await c.req.formData();
  const altchaToken = formData.get('altcha');
  
  if (!altchaToken) {
    return c.json({ error: 'Token Altcha manquant' }, 400);
  }

  // Vérifie via l'API Sentinel
  const response = await fetch('https://sentinel.tondomaine.com/v1/verify/signature', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ payload: String(altchaToken) })
  });
  
  const { verified } = await response.json();
  
  if (!verified) {
    return c.json({ error: 'Token Altcha invalide' }, 400);
  }

  // Traitement du formulaire
  return c.json({ ok: true, message: 'Formulaire envoyé !' });
});

Et voilà ! Ton formulaire est protégé contre les spams et les bots, sans faire chier tes utilisateurs. 🎯

Exemple avec Python (FastAPI)

T'es plus Python que JavaScript ? Pas de souci, voici un exemple avec FastAPI :

from fastapi import FastAPI, Form, HTTPException
from altcha import verify_solution
import os

app = FastAPI()
HMAC_KEY = os.getenv("SECRET")

@app.post("/submit")
async def submit_form(
    email: str = Form(...),
    message: str = Form(...),
    altcha: str = Form(...)
):
    # Vérifie le token Altcha
    if not verify_solution(altcha, HMAC_KEY):
        raise HTTPException(status_code=400, detail="Token Altcha invalide")
    
    # Traitement du formulaire
    print(f"Email: {email}, Message: {message}")
    
    return {"ok": True, "message": "Formulaire envoyé !"}

Personnalisation du widget

Altcha est super customizable. Tu peux changer la langue, le design, et plein d'autres trucs.

Changer la langue

Par défaut, Altcha détecte automatiquement la langue du navigateur. Mais tu peux forcer une langue spécifique :

<altcha-widget 
  challengeurl="https://sentinel.tondomaine.com/challenge"
  lang="fr">
</altcha-widget>

Altcha supporte 50+ langues, dont le français, l'anglais, l'allemand, l'espagnol, etc.

Personnaliser le style

Tu peux ajouter ton propre CSS pour adapter le widget à ton design :

altcha-widget {
  --altcha-color-base: #1a1a1a;
  --altcha-color-text: #ffffff;
  --altcha-color-border: #333333;
  --altcha-max-width: 400px;
}

Désactiver l'autofocus

Par défaut, le widget prend le focus automatiquement. Si tu veux le désactiver :

<altcha-widget 
  challengeurl="https://sentinel.tondomaine.com/challenge"
  auto="off">
</altcha-widget>

Bonnes pratiques et optimisations

Sécurité

Change le mot de passe root : Dès la première connexion à Sentinel, change le mot de passe par défaut.
Protège ton API Key : Ne partage jamais ta clé API publiquement. Elle doit rester côté serveur uniquement.
HTTPS obligatoire : Ne fais jamais tourner Altcha en HTTP en prod. Le widget utilise l'API Web Crypto qui nécessite HTTPS.
Stocke les payloads utilisés : Pour éviter les attaques par rejeu (replay attacks), garde une trace des payloads déjà vérifiés.

Performance

Utilise le cache : Sentinel met automatiquement en cache les challenges pour éviter les calculs inutiles.
Ajuste le nombre de workers : Par défaut, le widget utilise navigator.hardwareConcurrency (max 16). Tu peux le limiter si besoin.
Volume persistant obligatoire : Monte toujours /data en volume persistant pour ne pas perdre ta config et tes données.

Scalabilité

Clustering avec PostgreSQL + Redis : Pour du haute disponibilité, Sentinel supporte le clustering avec PostgreSQL et Redis comme backends.
Requiert minimum 2 vCPUs et 2 GB RAM : Pour un fonctionnement optimal en production.
Multi-arch : L'image Docker officielle supporte AMD64 et ARM64.

Monitoring

Logs : Sentinel log tous les événements dans stdout. Utilise un système comme Loki ou Elasticsearch pour centraliser.
Métriques : Intègre avec Prometheus pour du monitoring avancé des performances et des taux de vérification.

Pourquoi Altcha, c'est le futur ?

Si t'en as marre de dépendre de Google ou Cloudflare pour protéger tes formulaires, Altcha est une bouffée d'air frais. C'est :

Éthique : Respect de la vie privée, conformité RGPD, pas de tracking.
Open-source : Code transparent, auditable, modifiable.
Performant : Léger, rapide, efficace.
Accessible : Conforme aux normes d'accessibilité, multilingue.
Auto-hébergé : Tu gardes le contrôle total sur ton infrastructure.

En plus, le projet est activement maintenu, avec une communauté grandissante et des intégrations pour WordPress, React, Vue, Angular, Flutter, etc.

Les alternatives à Altcha

Bon, soyons fair-play. Altcha, c'est pas la seule alternative open-source aux CAPTCHA classiques. Voici quelques autres solutions que tu peux checker :

Procaptcha : Basé sur la blockchain (oui, vraiment). C'est intéressant d'un point de vue sécurité, mais plus complexe à mettre en place.
FriendlyCaptcha : Utilise aussi un mécanisme de PoW, mais c'est un service SaaS (donc pas vraiment auto-hébergeable).
mCaptcha : Open-source, auto-hébergeable, mais moins mature qu'Altcha.

Perso, je préfère Altcha pour sa simplicité, sa légèreté, et sa maturité. Mais si t'as des besoins spécifiques, jette un œil aux alternatives.

Conclusion : Adopte Altcha

Voilà, tu as toutes les cartes en main pour déployer Altcha et te débarrasser des CAPTCHA qui plombent l'expérience de tes utilisateurs. C'est simple, efficace, open-source, et respectueux de la vie privée.

Alors, qu'est-ce que t'attends ? Lance-toi, teste Altcha, et dis adieu aux puzzles de reCAPTCHA. Tes utilisateurs te remercieront, et ton site sera protégé sans faire de compromis sur la performance ou la vie privée.

Happy coding, et que la force de l'open-source soit avec toi ! 🚀

Liens utiles

Site officiel : https://altcha.org
Documentation v2 : https://altcha.org/docs/v2
GitHub principal : https://github.com/altcha-org/altcha
GitHub organisation : https://github.com/altcha-org
Documentation Sentinel : https://altcha.org/docs/v2/sentinel
Installation Sentinel : https://altcha.org/docs/v2/sentinel/install