Installer et comprendre Impervious.
Impervious est un bouclier qui se place devant votre site ou votre API. Il analyse chaque visite, reconnaît les robots et les attaques coordonnées, et les arrête avant qu'ils atteignent votre application. Cette page explique comment l'installer, comment il décide, et comment le régler.
Démarrage rapide
Impervious est distribué sous la forme d'une image Docker. Il n'a besoin que d'une information : l'adresse de l'application à protéger.
docker run -d --name impervious --restart unless-stopped \ -p 8080:8080 -p 127.0.0.1:9090:9090 \ -e IMPERVIOUS_UPSTREAM=http://mon-app:3000 \ -v impervious:/var/lib/impervious \ ghcr.io/impervious-sec/shield docker logs impervious # affiche le lien du tableau de bord
Ensuite, faites pointer votre domaine (ou votre proxy) vers le port 8080 au lieu de votre application. C'est tout : les secrets sont générés au premier démarrage, et Impervious commence en mode observation, sans rien bloquer.
Ce qui se passe en arrière-planAu premier démarrage, Impervious crée ses secrets dans le volume, rejoint le réseau Impervious et imprime dans ses journaux le lien de son tableau de bord. Vos visiteurs ne voient aucune différence.
Prérequis
- Docker 20 ou plus récent, sur Linux (amd64 ou arm64), macOS ou Windows.
- Une application web joignable depuis le conteneur : un autre conteneur, un service sur la machine, ou une adresse interne.
- Environ 10 à 50 Mo de mémoire pour un site moyen. Impervious analyse des dizaines de milliers de requêtes par seconde sur une seule machine.
- Un accès sortant en HTTPS vers le réseau Impervious. Sans lui, la protection locale fonctionne quand même.
Le langage de votre application n'a aucune importance : Node.js, PHP, Python, Go, Java, Ruby, .NET, WordPress… Impervious ne parle que HTTP.
Installer avec Docker
Le cas le plus courant : votre application tourne déjà, avec un proxy ou non devant. Impervious s'insère entre les deux.
Internet ──▶ votre application
Internet ──▶ Impervious :8080 ──▶ votre application
Si votre application tourne dans un conteneur, mettez les deux sur le même réseau Docker et utilisez le nom du conteneur comme adresse :
docker network create web docker network connect web mon-app docker run -d --name impervious --restart unless-stopped --network web \ -p 8080:8080 -p 127.0.0.1:9090:9090 \ -e IMPERVIOUS_UPSTREAM=http://mon-app:3000 \ -v impervious:/var/lib/impervious \ ghcr.io/impervious-sec/shield
Si votre application tourne directement sur la machine, utilisez l'adresse de l'hôte : http://host.docker.internal:3000 (ajoutez --add-host=host.docker.internal:host-gateway sous Linux).
Fermez l'accès direct à l'applicationSi votre application reste joignable directement depuis Internet, un attaquant peut contourner Impervious. Elle ne doit écouter que sur le réseau Docker ou sur 127.0.0.1.
HTTPS automatique
Si rien n'est devant votre application, Impervious peut gérer HTTPS lui-même. Il obtient ses certificats auprès de Let's Encrypt et les renouvelle seul.
docker run -d --name impervious --restart unless-stopped \ -p 80:80 -p 443:443 -p 127.0.0.1:9090:9090 \ -e IMPERVIOUS_UPSTREAM=http://mon-app:3000 \ -e IMPERVIOUS_DOMAINS=api.exemple.com,www.exemple.com \ -e IMPERVIOUS_ACME_EMAIL=admin@exemple.com \ -v impervious:/var/lib/impervious \ ghcr.io/impervious-sec/shield
- Les domaines doivent déjà pointer vers le serveur (enregistrement DNS
A), et les ports 80 et 443 doivent être ouverts. - Le port 80 ne sert qu'à valider les certificats et à rediriger vers HTTPS.
- C'est aussi le seul mode où Impervious voit l'empreinte TLS des clients, ce qui démasque les robots qui se font passer pour un navigateur.
Derrière un proxy existant
Vous avez déjà nginx, Caddy, Traefik ou un répartiteur de charge ? Gardez-le. Lancez Impervious sur le port 8080, puis changez seulement la cible du proxy :
| Proxy | Avant | Après |
|---|---|---|
| nginx | proxy_pass http://127.0.0.1:3000; | proxy_pass http://127.0.0.1:8080; |
| Caddy | reverse_proxy 127.0.0.1:3000 | reverse_proxy 127.0.0.1:8080 |
| Traefik | service → mon-app:3000 | service → impervious:8080 |
Pour nginx, transmettez l'adresse réelle du visiteur :
location / {
proxy_pass http://127.0.0.1:8080;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
}
Les proxys situés sur un réseau privé (Docker, réseau local, 127.0.0.1) sont reconnus d'office : Impervious lit l'adresse réelle du visiteur dans X-Forwarded-For. Rien à configurer.
Derrière Cloudflare
-e IMPERVIOUS_CLIENT_IP_HEADER=CF-Connecting-IP \ -e IMPERVIOUS_TRUSTED_PROXIES=173.245.48.0/20,103.21.244.0/22,…
Listez les plages publiées par Cloudflare. Sans cela, tous les visiteurs ressembleraient à Cloudflare, et un attaquant pourrait inventer sa propre adresse.
Dokploy, Coolify, CapRover, Portainer
Toutes ces plateformes demandent les mêmes quatre informations :
| Champ | Valeur |
|---|---|
| Image | ghcr.io/impervious-sec/shield:latest |
| Variable | IMPERVIOUS_UPSTREAM=http://<nom du service>:<port> |
| Domaine | votre domaine → port 8080 du conteneur (et retirez-le de l'application) |
| Volume | /var/lib/impervious |
Protéger un site existant avec Traefik, sans toucher à sa configuration
Sur Dokploy ou Coolify, votre site est déjà routé par Traefik. Plutôt que de modifier son domaine, Impervious déclare une route plus prioritaire pour le même domaine. Si Impervious s'arrête, Traefik revient tout seul à la route d'origine : votre site ne tombe jamais.
services:
impervious:
image: ghcr.io/impervious-sec/shield:latest
restart: unless-stopped
environment:
IMPERVIOUS_UPSTREAM: http://mon-site:80
IMPERVIOUS_MODE: monitor
volumes:
- impervious-data:/var/lib/impervious
networks: [traefik]
labels:
- traefik.enable=true
- traefik.docker.network=dokploy-network
- traefik.http.routers.imp.rule=Host(`exemple.com`) || Host(`www.exemple.com`)
- traefik.http.routers.imp.priority=1000
- traefik.http.routers.imp.entrypoints=websecure
- traefik.http.routers.imp.tls.certresolver=letsencrypt
- traefik.http.services.imp.loadbalancer.server.port=8080
volumes:
impervious-data:
networks:
traefik:
name: dokploy-network # coolify : "coolify"
external: true
Le nom du service de votre site (mon-site) se trouve dans la plateforme, ou avec docker ps.
Docker Compose
Pour une installation complète, avec HTTPS automatique et votre application dans le même fichier :
services:
impervious:
image: ghcr.io/impervious-sec/shield:latest
restart: unless-stopped
ports:
- "80:80"
- "443:443"
- "127.0.0.1:9090:9090"
environment:
IMPERVIOUS_UPSTREAM: http://app:3000
IMPERVIOUS_DOMAINS: api.exemple.com
IMPERVIOUS_MODE: monitor
volumes:
- impervious-data:/var/lib/impervious
app:
image: mon-application:latest
restart: unless-stopped
# aucun port publié : seule Impervious peut la joindre
volumes:
impervious-data:
Premier démarrage
1. Ouvrir le tableau de bord
Le lien s'affiche dans les journaux au premier démarrage. Pour le retrouver :
docker exec impervious impervious token
Le tableau de bord écoute sur le port 9090 du serveur, limité à 127.0.0.1 par sécurité. Depuis votre ordinateur, ouvrez un tunnel SSH puis le lien :
ssh -N -L 9090:127.0.0.1:9090 mon-serveur # puis http://127.0.0.1:9090/?token=…
Pour l'exposer sur un sous-domaine, placez le port 9090 derrière votre proxy HTTPS. Il est protégé par son jeton.
2. Observer quelques jours
En mode monitor, rien n'est bloqué. Le tableau de bord montre ce qu'Impervious aurait fait : qui aurait été ralenti, mis au défi ou bloqué, et pourquoi. Vérifiez qu'aucun de vos vrais utilisateurs, partenaires ou outils de surveillance n'y apparaît. Sinon, ajoutez-les à IMPERVIOUS_ALLOW.
3. Passer en protection
-e IMPERVIOUS_MODE=enforce
Redémarrez le conteneur. Les bannissements décidés pendant l'observation ne sont pas appliqués rétroactivement : vous repartez propre.
Parcours d'une requête
Chaque requête traverse les étapes suivantes, dans cet ordre. Un point rouge signifie que la requête peut s'arrêter là.
- IdentificationAdresse réelle du visiteur, empreinte du navigateur, clé d'API utilisée.
- ListesLes adresses interdites sont refusées. Les adresses autorisées passent sans analyse.
- Zones réservéesUn chemin interne (
/admin…) appelé depuis l'extérieur de vos réseaux est refusé. - PiègesUne fausse page ou un faux secret touché : bannissement immédiat.
- Garde des paiementsFaux callback d'opérateur, retrait au-delà des plafonds.
- AnalyseSignatures d'attaque, listes de menaces, réseau Impervious, vitesse. Chaque indice ajoute des points.
- DécisionLaisser passer, ralentir, défi ou blocage, selon le score.
- TransmissionLa requête arrive à votre application, avec le verdict en en-tête.
- ComportementLa réponse de votre application (erreur, succès, introuvable) alimente l'analyse du comportement : rafales d'erreurs, force brute, énumération.
Score et décisions
Chaque identité a un score. Les indices ajoutent des points. Les points s'effacent avec le temps (ils diminuent de moitié toutes les 10 minutes par défaut) : un faux positif se répare seul, alors qu'un attaquant obstiné continue de monter.
Rien à signaler.
Un léger délai, invisible pour un humain.
Preuve de travail à résoudre.
Bannissement temporaire.
Les bannissements sont progressifs : 15 minutes la première fois, puis 30 minutes, 1 heure… jusqu'à 24 heures. Ils survivent aux redémarrages.
La sensibilité générale se règle avec IMPERVIOUS_SENSITIVITY : low, normal (défaut), high ou paranoid.
Identités suivies
Changer d'adresse IP ne remet pas le compteur à zéro. Impervious note le même comportement sur plusieurs identités à la fois :
| Identité | Exemple | Sanction maximale |
|---|---|---|
| Adresse IP | 203.0.113.7 | blocage |
| Sous-réseau | 203.0.113.0/24 | défi seulement |
| Empreinte du client | signature TLS et en-têtes stables | défi seulement |
| Clé d'API | empreinte du jeton Authorization | blocage |
Les identités partagées (un sous-réseau d'opérateur mobile, une empreinte de navigateur très répandue) ne sont jamais bloquées : elles reçoivent au pire un défi. Elles demandent aussi beaucoup plus d'indices avant de réagir. Un essaim qui tourne sur des centaines d'adresses avec le même outil est ainsi repéré, sans pénaliser les milliers de vrais utilisateurs qui partagent un réseau.
Ce qui est détecté
Signatures d'attaque
Injections SQL et NoSQL, XSS, XXE, SSTI, SSRF vers les métadonnées cloud, injection de commandes, remontée de répertoires, Log4Shell, jetons JWT sans signature, webshells, pollution de paramètres, assignation de masse, scanners connus (sqlmap, nuclei, ffuf…), navigateurs automatisés.
Comportements
| Comportement | Ce que ça repère |
|---|---|
| Fuzzing | Des dizaines de chemins inexistants essayés en peu de temps |
| Rafale d'erreurs | Un visiteur qui provoque surtout des erreurs |
| Force brute | Mots de passe ou codes OTP essayés en série, et le succès qui suit |
| Énumération | Des identifiants qui se suivent : /users/1001, /1002, /1003… |
| Requêtes en double | La même opération rejouée en boucle (paiement, retrait) |
| Mutation de paramètres | Le même appel avec des valeurs qui changent à chaque essai |
| Attaque multi-vecteurs | Plusieurs familles d'injection essayées par la même source |
| Chaîne d'attaque | Une reconnaissance suivie d'une tentative de prise de contrôle |
| Essaim | Une même attaque répartie sur de nombreuses adresses |
| Clé dispersée | Une clé d'API utilisée depuis trop d'adresses : elle a sans doute fuité |
| Client trompeur | Un robot qui se présente comme un navigateur sans en avoir la signature |
Listes de menaces
Adresses connues pour attaquer, livrées avec Impervious et enrichies en continu par le réseau. Vous pouvez ajouter vos propres listes avec IMPERVIOUS_IOC_FILES.
Preuve de travail
Quand un visiteur est douteux sans être clairement hostile, Impervious ne le bloque pas : il lui demande de résoudre un petit calcul (trouver un nombre dont l'empreinte SHA-256 commence par un certain nombre de zéros).
- Pour un navigateur, une page s'affiche brièvement, le calcul se fait seul en environ 100 ms, puis la page d'origine s'affiche. L'utilisateur reçoit un laissez-passer et n'est plus dérangé.
- Pour un robot, le coût grimpe avec son score. À l'échelle de milliers de requêtes, l'attaque devient trop chère.
- Le laissez-passer est lié à l'empreinte du client. S'il est copié et réutilisé depuis de nombreuses adresses, il est révoqué.
Les clients d'API reçoivent le défi en JSON. Voir Clients d'API.
Réseau et données
Chaque installation rejoint automatiquement le réseau Impervious. Elle envoie les attaquants qu'elle confirme toutes les 30 secondes, et reçoit la liste partagée toutes les 5 minutes.
| Envoyé | Jamais envoyé |
|---|---|
| L'IP d'un visiteur classé suspect (gravité moyenne ou plus) ou banni | Le contenu des requêtes, les chemins, les paramètres |
Les règles déclenchées (SQLI, TRAP…) | Les cookies, l'en-tête Authorization, les clés d'API |
| Son user-agent, limité à 200 caractères | Les IP de vos visiteurs non suspects |
| Les heures et le nombre de tentatives | Le nom ou l'adresse de votre site |
Les adresses privées et réservées ne sont jamais transmises. Le partage ne peut pas être désactivé : c'est la contrepartie de la gratuité. Si le réseau est injoignable, la protection locale continue et les signalements sont renvoyés plus tard.
Protection contre les abus
- Approbation. Une nouvelle installation n'alimente la liste partagée qu'une fois approuvée. Personne ne peut injecter de fausses adresses en installant simplement l'image.
- Défi, jamais blocage. Une adresse signalée par le réseau reçoit seulement une preuve de travail, invisible pour un vrai navigateur. Seul son propre comportement sur votre site peut la faire bannir.
- Correction. Une adresse signalée par erreur peut être retirée du réseau. Ses nouveaux signalements sont alors ignorés pendant 30 jours.
Variables
Tout se règle par variables d'environnement. docker exec impervious impervious env les liste toutes.
| Variable | Rôle |
|---|---|
IMPERVIOUS_UPSTREAM | Obligatoire. Adresse de l'application à protéger |
IMPERVIOUS_MODE | monitor (défaut, ne bloque rien) ou enforce |
IMPERVIOUS_LISTEN | Adresse d'écoute du proxy (défaut :8080) |
IMPERVIOUS_DOMAINS | Domaines servis en HTTPS automatique sur le port 443 |
IMPERVIOUS_ACME_EMAIL | E-mail de contact pour Let's Encrypt |
IMPERVIOUS_SENSITIVITY | low, normal, high, paranoid |
IMPERVIOUS_BLOCK_STATUS | Code renvoyé en cas de blocage : 403 ou 429 |
IMPERVIOUS_BAN_DURATION | Durée du premier bannissement (défaut 15m) |
IMPERVIOUS_ALLOW | Réseaux jamais analysés : votre surveillance, vos partenaires |
IMPERVIOUS_DENY | Réseaux toujours refusés |
IMPERVIOUS_BYPASS | Chemins transmis sans analyse : /health,/static/* |
IMPERVIOUS_RESTRICT | Chemins internes : /admin/* |
IMPERVIOUS_RESTRICT_ALLOW | Réseaux autorisés sur ces chemins internes |
IMPERVIOUS_TRAP_PATHS | Fausses pages qui bannissent au premier contact |
IMPERVIOUS_TRAP_TOKENS | Faux secrets qui bannissent dès leur utilisation |
IMPERVIOUS_IOC_FILES | Listes d'adresses supplémentaires à mettre au défi |
IMPERVIOUS_TRUSTED_PROXIES | Proxys autorisés à donner l'adresse du visiteur (défaut : réseaux privés) |
IMPERVIOUS_CLIENT_IP_HEADER | X-Forwarded-For (défaut), CF-Connecting-IP, X-Real-IP |
IMPERVIOUS_DASHBOARD | Adresse du tableau de bord, ou off |
IMPERVIOUS_DASHBOARD_TOKEN | Jeton du tableau de bord (généré si vide) |
IMPERVIOUS_SECRET | Secret des défis (généré si vide). Identique sur toutes les copies si vous en lancez plusieurs |
IMPERVIOUS_SLACK_WEBHOOK | Alertes Slack |
IMPERVIOUS_TEAMS_WEBHOOK | Alertes Microsoft Teams |
IMPERVIOUS_ALERT_WEBHOOK | Alertes vers n'importe quelle adresse, en JSON |
IMPERVIOUS_ALERT_SEVERITY | Gravité minimale des alertes (défaut high) |
IMPERVIOUS_ACCESS_LOG | Journaliser chaque requête (true/false) |
IMPERVIOUS_LOG_FORMAT | json (défaut) ou text |
IMPERVIOUS_LOG_LEVEL | debug, info, warn, error |
IMPERVIOUS_DATA_DIR | Dossier des secrets, bannissements et certificats |
Les listes s'écrivent séparées par des virgules : 10.8.0.0/16,192.0.2.10/32.
Pièges et zones réservées
Zones réservées
Votre back-office ne doit être joignable que depuis vos réseaux. Pour tout le reste du monde, il est refusé, et la tentative compte comme un indice d'attaque.
-e IMPERVIOUS_RESTRICT=/admin/*,/internal/* \ -e IMPERVIOUS_RESTRICT_ALLOW=10.8.0.0/16,41.202.10.25/32
Pièges
Un piège est une page ou un secret qu'aucun vrai utilisateur ne demandera jamais, mais qu'un attaquant cherche systématiquement. Un seul contact bannit l'adresse et la clé d'API utilisées.
-e IMPERVIOUS_TRAP_PATHS=/backup.sql,/.env.production,/api/v0/* \ -e IMPERVIOUS_TRAP_TOKENS=sk_live_leurre_9f2c1a
Choisissez des pièges vraiment inutilisésNe placez jamais un piège sur un chemin que votre application utilise, ni à l'intérieur d'une zone réservée. Un faux secret peut être glissé dans un ancien fichier de configuration ou un dépôt de test : quiconque l'utilise s'est servi d'une fuite.
Garde des paiements
Conçue après une fraude réelle : un attaquant a envoyé lui-même le faux message « paiement réussi » de l'opérateur, puis a retiré l'argent. La garde sépare les appels de vos clients de ceux des opérateurs, et plafonne les retraits.
Elle se règle dans un fichier, car elle dépend de vos routes. Générez un modèle, adaptez-le, puis indiquez-le à Impervious :
docker exec impervious impervious init --fintech -o /var/lib/impervious/impervious.yaml docker cp impervious:/var/lib/impervious/impervious.yaml . # modifiez le fichier, puis renvoyez-le : docker cp impervious.yaml impervious:/var/lib/impervious/impervious.yaml # relancez le conteneur avec : -e IMPERVIOUS_CONFIG=/var/lib/impervious/impervious.yaml
money: client_paths: ["/api/partner/*"] webhooks: - name: mtn paths: ["/webhooks/mtn*"] allow_cidrs: ["<plage d'adresses de l'opérateur>"] - name: wave paths: ["/webhooks/wave*"] signature: header: Wave-Signature secret: "${WAVE_WEBHOOK_SECRET}" algo: sha256 encoding: hex prefix: "v1=" withdrawals: - name: retraits paths: ["/api/partner/transfers*"] methods: [POST] amount_field: amount beneficiary_field: recipient.phone max_amount: 500000 # par opération daily_amount: 5000000 # par jour per_minute: 5 # retraits par minute daily_beneficiaries: 20 # bénéficiaires différents par jour
| Règle | Ce qu'elle bloque |
|---|---|
PAY-WEBHOOK-FROM-CLIENT | Un callback envoyé par une adresse ou une clé qui utilise aussi votre API client. Un opérateur ne fait jamais les deux. |
PAY-WEBHOOK-UNTRUSTED | Un callback hors des adresses de l'opérateur, ou sans signature valide |
PAY-WEBHOOK-PROBE | Une même source qui teste les callbacks de plusieurs opérateurs |
PAY-MAX-AMOUNT, PAY-DAILY-CAP, PAY-VELOCITY, PAY-FANOUT | Montant par opération, plafond journalier, retraits par minute, bénéficiaires par jour |
PAY-UNREADABLE | Une demande d'argent dont le montant est illisible : refusée par prudence |
La garde fait gagner du temps, elle ne remplace pas votre codeUn callback est un signal, jamais une preuve. Avant de créditer, interrogez l'opérateur pour confirmer la transaction, n'acceptez qu'une demande en attente de cet opérateur, et refusez tout identifiant de transaction déjà vu.
Les variables restent prioritaires sur le fichier.
Tableau de bord et alertes
- En direct : événements au fil de l'eau, graphiques du trafic et des attaques (15 min à 24 h), temps de réponse de votre application.
- Acteurs : les identités les plus suspectes du moment, avec leur score et leur raison.
- Bannissements : liste, bannissement manuel, levée d'un bannissement en un clic.
- Réseau : état de la connexion au réseau Impervious et taille de la liste partagée.
- Prometheus : métriques sur
/metrics, sur le port du tableau de bord.
-e IMPERVIOUS_SLACK_WEBHOOK=https://hooks.slack.com/services/… \ -e IMPERVIOUS_ALERT_SEVERITY=high
Les alertes identiques sont regroupées : une attaque soutenue ne noie pas votre canal.
Côté application
Votre application n'a rien à changer. Elle reçoit en plus ces en-têtes, que vous pouvez journaliser ou utiliser :
| En-tête | Contenu |
|---|---|
X-Real-IP | Adresse réelle du visiteur |
X-Forwarded-For, -Proto, -Host | En-têtes de transfert standard |
X-Impervious-Request-Id | Identifiant de la requête, affiché aussi sur les pages de blocage |
X-Impervious-Action | allow, throttle, challenge ou block (les deux derniers seulement en observation) |
X-Impervious-Score | Score actuel de l'identité la plus suspecte |
X-Impervious-Actor | Cette identité, quand l'action n'est pas allow |
Les en-têtes X-Impervious-* envoyés par un visiteur sont supprimés : ils ne peuvent pas être falsifiés.
Réponses possibles d'Impervious
| Code | Quand |
|---|---|
403 + page | Défi pour un navigateur |
428 + JSON | Défi pour un client d'API |
403 ou 429 | Bloqué, selon IMPERVIOUS_BLOCK_STATUS |
429 | Limite de vitesse ou de retraits atteinte |
400 / 413 | Demande d'argent illisible ou trop volumineuse |
502 | Votre application ne répond pas |
Clients d'API
Un client d'API légitime (application mobile, partenaire, script) peut lui aussi recevoir un défi. Il reçoit 428 avec {"challenge": "<jeton>", "difficulty": N}. Il doit trouver un nombre nonce tel que sha256(jeton + ":" + nonce) commence par N bits à zéro, puis rejouer la requête avec l'en-tête Impervious-Solution: <jeton>:<nonce>. La réponse contient Impervious-Pass, à renvoyer sur les requêtes suivantes.
import { createHash } from "node:crypto";
function zeroBits(buf) {
let n = 0;
for (const b of buf) {
if (b === 0) { n += 8; continue; }
return n + Math.clz32(b) - 24;
}
return n;
}
export async function shieldedFetch(url, init = {}, state = {}) {
const headers = new Headers(init.headers);
if (state.pass) headers.set("Impervious-Pass", state.pass);
let res = await fetch(url, { ...init, headers });
if (res.status === 428) {
const { challenge, difficulty } = await res.json();
let nonce = 0;
while (zeroBits(createHash("sha256").update(`${challenge}:${nonce}`).digest()) < difficulty) nonce++;
headers.set("Impervious-Solution", `${challenge}:${nonce}`);
res = await fetch(url, { ...init, headers });
}
const pass = res.headers.get("Impervious-Pass");
if (pass) state.pass = pass;
return res;
}
Pour un partenaire de confiance à adresse fixe, le plus simple reste de l'ajouter à IMPERVIOUS_ALLOW. En ligne de commande, impervious solve <jeton> <difficulté> résout un défi.
Commandes
Toutes s'utilisent avec docker exec impervious impervious <commande>.
| Commande | Rôle |
|---|---|
token | Affiche le lien et le jeton du tableau de bord |
health | Vérifie que le bouclier répond |
env | Liste toutes les variables |
check | Valide un fichier de configuration |
init | Génère un fichier de configuration (--fintech pour les paiements) |
rules | Liste les règles chargées |
solve | Résout un défi de preuve de travail |
version | Affiche la version |
Mise à jour
docker pull ghcr.io/impervious-sec/shield:latest docker rm -f impervious # relancez la même commande docker run qu'à l'installation
Avec Compose : docker compose pull && docker compose up -d. Les bannissements, les secrets et les certificats sont conservés dans le volume.
Dépannage
Tous les visiteurs ont la même adresse
Votre proxy n'est pas reconnu comme fiable, ou il ne transmet pas X-Forwarded-For. Ajoutez son adresse à IMPERVIOUS_TRUSTED_PROXIES et vérifiez sa configuration (voir Derrière un proxy).
Erreur 502
Impervious n'arrive pas à joindre votre application. Vérifiez IMPERVIOUS_UPSTREAM et que les deux conteneurs sont sur le même réseau : docker exec impervious impervious health.
Un vrai utilisateur est bloqué
Levez son bannissement depuis le tableau de bord, puis regardez la raison affichée. Si c'est un outil à vous (surveillance, partenaire), ajoutez son adresse à IMPERVIOUS_ALLOW. Si un chemin légitime déclenche une règle, ajoutez-le à IMPERVIOUS_BYPASS.
« Impervious network unreachable » dans les journaux
Le serveur n'arrive pas à joindre le réseau. La protection locale continue, et les signalements seront renvoyés dès que la connexion revient. Vérifiez l'accès sortant en HTTPS.
Le certificat HTTPS n'est pas émis
Le domaine doit pointer vers le serveur, et les ports 80 et 443 doivent être joignables depuis Internet. Les journaux indiquent la raison du refus de Let's Encrypt.
J'ai perdu le lien du tableau de bord
docker exec impervious impervious token.
FAQ
Impervious remplace-t-il un pare-feu ou un WAF ?
Il fait le travail d'un WAF orienté robots et comportements, devant une application web. Il ne remplace pas le pare-feu de votre serveur (ports, SSH) ni les bonnes pratiques dans votre code.
Puis-je lancer plusieurs copies ?
Oui. Utilisez le même IMPERVIOUS_SECRET partout pour que les laissez-passer soient valables sur toutes les copies, et un répartiteur de charge qui garde un même visiteur sur la même copie.
Le code source est-il disponible ?
Non. Impervious est gratuit, mais seule l'image compilée est distribuée.
Est-ce que ça ralentit mon site ?
L'analyse ajoute environ 20 microsecondes par requête, soit des centaines de fois moins qu'un aller-retour réseau.
Puis-je désactiver le partage avec le réseau ?
Non, c'est la contrepartie de la gratuité. Aucune donnée de vos visiteurs ni le contenu des requêtes ne sont transmis : seulement les attaquants confirmés. Voir Réseau et données.