Sujet: Installer Pi-hole avec DNS-over-HTTPS (DoH) et dnscrypt-proxy sous Docker : bloquer les publicités et interroger des résolveurs souverains

This topic is empty.

Affichage de 1 message (sur 1 au total)

Auteur
Articles
avril 12, 2025 à 4:05 pm #12833
nam1962
Keymaster
Introduction
Mise à jour : la liste des résolveurs DNS-over-HTTPS a été actualisée avec des serveurs testés, non filtrants et compatibles avec dnscrypt-proxy.
Je vous propose ici une stack DNS chiffrée avec Pi-hole et dnscrypt-proxy : une alternative propre aux résolveurs DNS des FAI, avec blocage publicitaire local, chiffrement des requêtes DNS et sélection explicite de résolveurs de confiance.
Grâce à Pi-hole et dnscrypt-proxy, je peux résoudre mes requêtes DNS via des serveurs DoH ou DNSCrypt choisis, sans passer par Google, Cloudflare ou les DNS de mon fournisseur d’accès. Pi-hole reste chargé du filtrage local : publicités, traqueurs, domaines indésirables et listes personnalisées.
DNS-over-HTTPS chiffre les requêtes DNS dans du trafic HTTPS. Le fournisseur d’accès ne reçoit plus les requêtes via son propre résolveur. Il devient donc beaucoup plus difficile pour lui d’appliquer un filtrage DNS local, de renvoyer une réponse mensongère ou de journaliser directement les noms demandés au niveau DNS.
Cette configuration apporte trois fonctions :
- blocage local des publicités, traqueurs et domaines indésirables ;
- résolution DNS chiffrée via dnscrypt-proxy ;
- sélection explicite de résolveurs non filtrants, hors FAI et compatibles avec dnscrypt-proxy.
Astuce : si vous hésitez entre DoH et DoT avec Unbound, vous pouvez aussi utiliser un petit switcher pour passer de l’un à l’autre.
Pourquoi cette méthode ?
- pour ne plus confier ses requêtes DNS au fournisseur d’accès ;
- pour contourner les DNS menteurs et les blocages DNS grossiers ;
- pour chiffrer les requêtes DNS vers des résolveurs externes choisis ;
- pour garder le filtrage publicitaire en local avec Pi-hole ;
- pour conserver une stack simple, portable et isolée dans Docker.
Prérequis
Avant de commencer, assurez-vous d’avoir :
- un système Linux à jour ;
- Docker et Docker Compose installés ;
- un terminal et un accès sudo ;
- le port local 53 disponible sur la machine.
Installation de Docker si nécessaire
Arch Linux et dérivés
```
sudo pacman -S docker docker-compose
sudo systemctl enable --now docker
sudo usermod -aG docker "$USER"
```
Debian
```
sudo apt update
sudo apt install -y ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/debian/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(. /etc/os-release && echo "$VERSION_CODENAME") stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

sudo systemctl enable --now docker
sudo usermod -aG docker "$USER"
```
Après avoir ajouté votre utilisateur au groupe Docker, déconnectez-vous puis reconnectez-vous pour que les changements prennent effet.
Pour Linux Mint basé sur Ubuntu, utilisez le dépôt Docker correspondant à la version Ubuntu sous-jacente plutôt que de réutiliser automatiquement le dépôt Debian.
Mise en place de la stack DNS-DoH
Je travaille ici dans un répertoire dédié :
```
mkdir -p ~/docker/dns-doh/dnscrypt-proxy
mkdir -p ~/docker/dns-doh/etc-dnsmasq.d
cd ~/docker/dns-doh
```
1. Télécharger les images Docker
Avant de couper l’ancien DNS, je récupère les images nécessaires :
```
docker pull klutchell/dnscrypt-proxy
docker pull pihole/pihole
```
2. docker-compose.yml
Je crée le fichier suivant :
```
nano docker-compose.yml
```
Voici le contenu du fichier :
```
services:
  dnscrypt-proxy:
    container_name: dnscrypt-proxy
    image: klutchell/dnscrypt-proxy
    restart: unless-stopped
    volumes:
      - ./dnscrypt-proxy:/config
    networks:
      dnsnet:
        ipv4_address: 172.22.0.2
    mem_limit: 512m
    mem_reservation: 256m
    cpus: "1.0"

  pihole:
    container_name: pihole
    image: pihole/pihole:latest
    restart: unless-stopped
    depends_on:
      - dnscrypt-proxy
    hostname: pihole
    env_file:
      - .env
    environment:
      TZ: ${TZ}
      FTLCONF_webserver_api_password: ${PIHOLE_WEBPASSWORD}
      FTLCONF_dns_upstreams: 172.22.0.2#53
      FTLCONF_dns_listeningMode: all
      FTLCONF_misc_etc_dnsmasq_d: "true"
    volumes:
      - ./etc-pihole:/etc/pihole
      - ./etc-dnsmasq.d:/etc/dnsmasq.d
    ports:
      - "127.0.0.1:53:53/tcp"
      - "127.0.0.1:53:53/udp"
      - "127.0.0.1:8080:80/tcp"
    networks:
      dnsnet:
        ipv4_address: 172.22.0.3
    mem_limit: 512m
    mem_reservation: 256m
    cpus: "1.0"

networks:
  dnsnet:
    ipam:
      config:
        - subnet: 172.22.0.0/24
```
Pi-hole est publié uniquement sur la boucle locale de la machine : 127.0.0.1. Il n’est donc pas exposé sur tout le réseau local par défaut.
3. Fichier .env
Je crée un fichier .env avec les variables nécessaires :
```
nano .env
```
Contenu :
```
TZ=Europe/Paris
PIHOLE_WEBPASSWORD=mot_de_passe_a_remplacer
```
Remplacez mot_de_passe_a_remplacer par un vrai mot de passe pour l’interface web de Pi-hole.
4. Configuration de dnscrypt-proxy
Je crée le fichier de configuration :
```
nano ~/docker/dns-doh/dnscrypt-proxy/dnscrypt-proxy.toml
```
Et je configure dnscrypt-proxy pour utiliser des résolveurs chiffrés, non filtrants, hors FAI et compatibles avec cette stack :
```
server_names = [
  'libredns',
  'doh.ffmuc.net',
  'doh.appliedprivacy.net',
  'dns.digitale-gesellschaft.ch',
  'uncensoreddns-dk-ipv4',
  'uncensoreddns-ipv4',
  'fdn'
]

listen_addresses = ['0.0.0.0:53']

max_clients = 300

ipv4_servers = true
ipv6_servers = false

dnscrypt_servers = true
doh_servers = true
odoh_servers = false

require_dnssec = false
require_nolog = true
require_nofilter = true

disabled_server_names = []

force_tcp = false
http3 = false

timeout = 5000
keepalive = 30

cache = true
cache_size = 8192
cache_min_ttl = 2400
cache_max_ttl = 86400
cache_neg_min_ttl = 60
cache_neg_max_ttl = 600

lb_strategy = 'p2'
lb_estimator = true

ignore_system_dns = true

[static]
```
Cette configuration autorise les résolveurs DoH et DNSCrypt. La liste proposée privilégie des résolveurs non filtrants, hors FAI, et compatibles avec dnscrypt-proxy.
Dans Docker, dnscrypt-proxy doit écouter sur 0.0.0.0:53 dans son conteneur pour que Pi-hole puisse le joindre via le réseau Docker. Le conteneur dnscrypt-proxy n’expose aucun port directement sur l’hôte.
5. Permissions du dossier dnscrypt-proxy
L’image klutchell/dnscrypt-proxy écrit ses fichiers de cache dans /config. Le dossier monté doit donc être accessible à l’utilisateur non privilégié du conteneur.
```
cd ~/docker/dns-doh
sudo chown -R 65532:65532 dnscrypt-proxy
```
Après cette commande, les fichiers du dossier dnscrypt-proxy appartiennent à l’utilisateur non privilégié du conteneur. Pour modifier ensuite dnscrypt-proxy.toml, utilisez par exemple :
```
sudo nano ~/docker/dns-doh/dnscrypt-proxy/dnscrypt-proxy.toml
```
6. Configuration dnsmasq pour Pi-hole
Je crée un petit fichier de réglage pour Pi-hole :
```
cat > ~/docker/dns-doh/etc-dnsmasq.d/99-custom.conf <<'EOF'
dns-forward-max=300
EOF
```
7. Validation de la configuration Docker Compose
Avant de démarrer, je vérifie la syntaxe :
```
cd ~/docker/dns-doh
docker compose config
```
La commande doit afficher la configuration complète sans erreur.
8. Démarrage
Une fois tout en place, je lance la stack :
```
cd ~/docker/dns-doh
docker compose up -d
```
Sur les systèmes plus anciens, la commande peut être :
```
docker-compose up -d
```
9. Vérifier les conteneurs
```
docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}' | grep -E 'NAMES|pihole|dnscrypt'
```
Résultat attendu :
```
pihole            Up ... (healthy)   127.0.0.1:53->53/tcp, 127.0.0.1:53->53/udp, 127.0.0.1:8080->80/tcp
dnscrypt-proxy    Up ...
```
10. Vérifier les résolveurs détectés
```
docker logs --tail=120 dnscrypt-proxy
```
Les logs doivent indiquer des résolveurs actifs, par exemple :
```
[libredns] OK (DoH)
[doh.ffmuc.net] OK (DoH)
[dns.digitale-gesellschaft.ch] OK (DoH)
[uncensoreddns-dk-ipv4] OK (DoH)
```
Pour afficher la liste effective retenue par dnscrypt-proxy :
```
docker exec dnscrypt-proxy dnscrypt-proxy \
  -config /config/dnscrypt-proxy.toml \
  -list
```
11. Vérifier que Pi-hole interroge dnscrypt-proxy
```
docker exec pihole dig @172.22.0.2 kernel.org A +time=3 +tries=1 +short
```
Résultat attendu :
```
kernel.org renvoie une adresse IP
```
12. Tester Pi-hole depuis l’hôte
```
dig @127.0.0.1 kernel.org A +short
dig @127.0.0.1 pi.hole A +short
```
Résultat attendu :
```
kernel.org renvoie une adresse IP
pi.hole renvoie 172.22.0.3
```
13. Vérifier le chemin complet avec une requête fraîche
Pour éviter de tester uniquement une réponse déjà en cache, je lance une requête fraîche :
```
rand="test-$(date +%s).example.com"

dig @127.0.0.1 "$rand" A +time=5 +tries=1

docker logs --since=2m dnscrypt-proxy
```
La commande dig doit répondre via 127.0.0.1#53. Les logs dnscrypt-proxy permettent de vérifier l’activité de la couche chiffrée.
14. Utiliser Pi-hole comme DNS local
Il faut maintenant configurer le système pour utiliser Pi-hole comme résolveur DNS local :
```
127.0.0.1
```
Avec NetworkManager, identifiez la connexion active :
```
nmcli connection show --active
```
Appliquez le DNS local à la connexion choisie :
```
sudo nmcli connection modify "NOM_DE_LA_CONNEXION" ipv4.ignore-auto-dns yes ipv4.dns "127.0.0.1" ipv6.ignore-auto-dns yes
sudo nmcli connection down "NOM_DE_LA_CONNEXION"
sudo nmcli connection up "NOM_DE_LA_CONNEXION"
```
Vérifiez ensuite le serveur DNS réellement utilisé :
```
dig kernel.org A | grep SERVER
```
La sortie doit indiquer :
```
SERVER: 127.0.0.1#53
```
Si un gestionnaire réseau externe réécrit automatiquement /etc/resolv.conf, configurez le DNS local via l’outil réseau de votre distribution plutôt qu’en modifiant ce fichier à la main.
15. Accéder à l’interface web de Pi-hole
Ouvrez dans votre navigateur :
```
http://localhost:8080/admin
```
Connectez-vous avec le mot de passe défini dans le fichier .env.
16. Ajouter des listes de blocage recommandées
Pour améliorer le blocage des publicités et des traqueurs, ajoutez des listes de blocage à Pi-hole.
Dans l’interface Pi-hole :
1. ouvrez http://localhost:8080/admin ;
2. allez dans Group Management, puis Adlists ;
3. ajoutez vos listes ;
4. allez dans Tools, puis Update Gravity.
Listes utiles :
```
https://raw.githubusercontent.com/StevenBlack/hosts/master/hosts
https://adaway.org/hosts.txt
https://raw.githubusercontent.com/hagezi/dns-blocklists/main/domains/light.txt
https://small.oisd.nl/
```
Résolveurs DoH complémentaires
Ces résolveurs peuvent être ajoutés à server_names si vous voulez élargir la liste des résolveurs utilisables par dnscrypt-proxy. Ce ne sont pas les modes fallback du DNS Switcher.
```
dnsforge.de-nofilter
mullvad-doh
nic.cz
doh.ibksturm
```
Pour les activer, ajoutez-les à la liste server_names dans dnscrypt-proxy.toml, puis recréez le conteneur :
```
cd ~/docker/dns-doh
docker compose up -d --force-recreate dnscrypt-proxy
```
Résolveurs à éviter dans cette configuration
Les résolveurs filtrants, familiaux, publicitaires, commerciaux ou trop centralisés ne sont pas retenus dans cette configuration.
```
google
cloudflare
adguard
nextdns
cleanbrowsing
quad9 filtré
mullvad-adblock*
family
safe
protective
```
Modes fallback
Si vous utilisez un DNS Switcher pour basculer entre DoT, DoH et des modes de secours, distinguez deux fallbacks.
Fallback neutre
Ce mode sert à retrouver une résolution DNS hors FAI quand les stacks locales sont arrêtées ou cassées. Il ne remplace pas Pi-hole et ne fournit pas de filtrage publicitaire.
```
91.239.100.100  # UncensoredDNS anycast
80.67.169.12    # FDN ns0
```
Fallback filtrant externe
Ce mode conserve un filtrage DNS minimal quand Pi-hole est indisponible, en déléguant temporairement le filtrage à des résolveurs externes.
```
94.140.14.14  # AdGuard DNS filtrant
45.90.28.0    # NextDNS filtrant configurable
```
Ce mode est un choix explicite. Il n’est pas le chemin normal de résolution.
Tester une liste de résolveurs dnscrypt-proxy
```
docker exec dnscrypt-proxy dnscrypt-proxy \
  -config /config/dnscrypt-proxy.toml \
  -list
```
Pour voir les latences et les serveurs actifs :
```
docker logs --tail=160 dnscrypt-proxy | grep -E '\] \[NOTICE\] \[|Sorted latencies|lowest initial latency|WARNING|ERROR|listening'
```
Arrêter la stack
```
cd ~/docker/dns-doh
docker compose down
```
Redémarrer la stack
```
cd ~/docker/dns-doh
docker compose up -d
```
Mettre à jour les images
```
cd ~/docker/dns-doh
docker compose pull
docker compose up -d
```
Dépannage rapide
Pi-hole ne répond pas sur 127.0.0.1
```
docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}' | grep -E 'NAMES|pihole|dnscrypt'
docker logs --tail=80 pihole
docker logs --tail=80 dnscrypt-proxy
```
Pi-hole répond, mais dnscrypt-proxy ne répond pas
```
docker exec pihole dig @172.22.0.2 kernel.org A +time=3 +tries=1 +short
docker logs --tail=120 dnscrypt-proxy
```
Dans Docker, dnscrypt-proxy doit écouter sur 0.0.0.0:53 dans son conteneur. S’il écoute seulement sur 127.0.0.1:53, Pi-hole ne pourra pas le joindre depuis son propre conteneur.
dnscrypt-proxy affiche des erreurs de permission
Si les logs indiquent que dnscrypt-proxy ne peut pas écrire ses fichiers de cache dans /config, appliquez :
```
cd ~/docker/dns-doh
sudo chown -R 65532:65532 dnscrypt-proxy
docker compose up -d --force-recreate dnscrypt-proxy
```
Documentation utile
Conclusion
Cette solution me permet d’utiliser une résolution DNS chiffrée, sans passer par les serveurs DNS de mon FAI, tout en bénéficiant du filtrage local de Pi-hole.
Le chemin de résolution est :
```
applications -> 127.0.0.1 -> Pi-hole -> dnscrypt-proxy -> résolveurs DNS chiffrés
```
Les listes de blocage restent locales. Les résolveurs amont reçoivent les requêtes transmises après traitement par Pi-hole.
Vous pouvez utiliser cette stack seule, ou l’alterner avec une stack Pi-hole + Unbound DoT selon le degré de contrôle, de discrétion et de résilience recherché.
Un jeune site que j'aime bien, la ferrari du T-shirt ...bio en plus : GoudronBlanc
Auteur
Articles

Affichage de 1 message (sur 1 au total)

Vous devez être connecté pour répondre à ce sujet.

Login

Introduction

Pourquoi cette méthode ?

Prérequis

Installation de Docker si nécessaire

Arch Linux et dérivés

Debian

Mise en place de la stack DNS-DoH

1. Télécharger les images Docker

2. docker-compose.yml

3. Fichier .env

4. Configuration de dnscrypt-proxy

5. Permissions du dossier dnscrypt-proxy

6. Configuration dnsmasq pour Pi-hole

7. Validation de la configuration Docker Compose

8. Démarrage

9. Vérifier les conteneurs

10. Vérifier les résolveurs détectés

11. Vérifier que Pi-hole interroge dnscrypt-proxy

12. Tester Pi-hole depuis l’hôte

13. Vérifier le chemin complet avec une requête fraîche

14. Utiliser Pi-hole comme DNS local

15. Accéder à l’interface web de Pi-hole

16. Ajouter des listes de blocage recommandées

Résolveurs DoH complémentaires

Résolveurs à éviter dans cette configuration

Modes fallback

Fallback neutre

Fallback filtrant externe

Tester une liste de résolveurs dnscrypt-proxy

Arrêter la stack

Redémarrer la stack

Mettre à jour les images

Dépannage rapide

Pi-hole ne répond pas sur 127.0.0.1

Pi-hole répond, mais dnscrypt-proxy ne répond pas

dnscrypt-proxy affiche des erreurs de permission

Documentation utile

Conclusion