Injection d'en-tête Host : quand Drupal envoie lui-même le lien de l'attaquant

· 9 min de lecture

Cette semaine, sur un site Drupal 11 en production que nous maintenons, un administrateur a reçu un mail « mot de passe oublié » qu’il n’avait pas demandé. Le message avait le bon expéditeur et le gabarit habituel du site, et il passait SPF et DKIM. Une seule chose clochait : le lien de réinitialisation ne pointait pas vers le site, mais vers un domaine inconnu.

La première hypothèse était la plus rassurante : un mail de phishing envoyé de l’extérieur, qui imite le site. C’était faux. C’est bien le site qui avait envoyé ce mail, avec un vrai jeton de réinitialisation valide. L’attaquant n’avait piraté ni le serveur ni la messagerie. Il avait seulement choisi le nom de domaine que Drupal allait utiliser pour construire le lien.

Cet article explique comment c’est possible, comment le reproduire sans risque et quels réglages le bloquent vraiment. Un de ces réglages est souvent présenté comme la solution, alors qu’il ne suffit pas seul.

Ce que l’attaquant n’a pas fait

Le formulaire /user/password ne demande qu’un nom d’utilisateur ou un email. Il n’existe aucun champ pour y glisser un lien, et l’attaquant n’a exploité aucune faille de ce formulaire. Il a tapé l’adresse de la victime, comme n’importe qui.

Le domaine du lien ne vient pas de ce qui est saisi dans le formulaire. Il vient de la requête HTTP elle-même.

Comment Drupal construit le lien du mail

Le gabarit du mail (user.mail.yml, clé password_reset) contient le jeton [user:one-time-login-url]. Ce jeton est remplacé par une URL absolue, générée ainsi dans le cœur :

// core/modules/user/user.module, Drupal 11.3 (user_pass_reset_url()).
// Déplacé dans OneTimeAuthentication::generateOneTimeLoginUrl() en 11.4.
return Url::fromRoute('user.reset', [
  'uid' => $account->id(),
  'timestamp' => $timestamp,
  'hash' => user_pass_rehash($account, $timestamp),
], [
  'absolute' => TRUE,
  // ...
]);

Pour produire une URL absolue, Drupal a besoin d’un domaine. Ce domaine ne vient d’aucune configuration : Drupal le déduit de la requête en cours, via Request::getHost() de Symfony. Simplifié, getHost() fait ceci :

// vendor/symfony/http-foundation/Request.php
if ($this->isFromTrustedProxy() && $host = $this->getTrustedValues(self::HEADER_X_FORWARDED_HOST)) {
  $host = $host[0];           // 1. Requête venue d'un proxy de confiance : X-Forwarded-Host.
}
else {
  $host = $this->headers->get('HOST');  // 2. Sinon : l'en-tête Host.
}
// 3. Si des trusted hosts sont définis, $host doit correspondre à l'un
//    d'eux, sinon une exception est levée.

L’en-tête Host et l’en-tête X-Forwarded-Host sont tous les deux envoyés par le client. Si rien ne les vérifie, c’est le client qui choisit le domaine des liens que Drupal génère, y compris celui du mail de réinitialisation.

Les deux réglages qui ouvraient la porte

Le settings.php du site réunissait deux conditions.

1. trusted_host_patterns n’était pas défini en production. Il n’apparaissait qu’en commentaire, et dans le settings.ddev.php local avec la valeur ['.*']. Drupal acceptait donc n’importe quel domaine.

Drupal le signale pourtant dans le rapport d’état (/admin/reports/status), avec une erreur, pas un simple avertissement :

Trusted Host Settings : Not enabled. The trusted_host_patterns setting is not configured in settings.php. This can lead to security vulnerabilities.

C’est l’un des contrôles de notre liste des signes d’un site mal maintenu : cette ligne rouge était là depuis des années.

2. La liste des proxys de confiance contenait… l’appelant lui-même.

$settings['reverse_proxy'] = TRUE;
$settings['reverse_proxy_addresses'] = [$_SERVER['REMOTE_ADDR']];

Cette ligne se retrouve dans beaucoup de projets hébergés derrière un load balancer dont l’IP change. Elle dit à Drupal : « l’IP qui me parle est un proxy de confiance ». Autrement dit, tout le monde est un proxy de confiance. Symfony propose d’ailleurs la même chose avec la valeur littérale 'REMOTE_ADDR'.

Et quand reverse_proxy_trusted_headers n’est pas défini, Drupal fait confiance par défaut à tous les en-têtes de proxy, X-Forwarded-Host compris. Le commentaire du cœur le dit lui-même :

// core/lib/Drupal/Core/StackMiddleware/ReverseProxyMiddleware.php
// Set the default value. This is the most relaxed setting possible and
// not recommended for production.
$trusted_header_set = Request::HEADER_X_FORWARDED_FOR | Request::HEADER_X_FORWARDED_HOST
  | Request::HEADER_X_FORWARDED_PORT | Request::HEADER_X_FORWARDED_PROTO | Request::HEADER_FORWARDED;

Le déroulé de l’attaque

Une seule requête suffit :

POST /user/password HTTP/1.1
Host: www.example.com
X-Forwarded-Host: attaquant.example
Content-Type: application/x-www-form-urlencoded

name=admin@example.com&form_id=user_pass&...
  1. Drupal croit que la requête vient d’un proxy, prend attaquant.example comme domaine et envoie un vrai mail, depuis le vrai serveur, à la victime.
  2. Le mail contient https://attaquant.example/user/reset/<uid>/<timestamp>/<hash>.
  3. Si la victime clique, son navigateur envoie l’URL complète, donc le jeton, au serveur de l’attaquant. Certaines passerelles de messagerie ouvrent aussi les liens pour les analyser : le jeton peut alors fuiter sans aucun clic.
  4. L’attaquant ouvre /user/reset/<uid>/<timestamp>/<hash> sur le vrai site et se connecte avec le compte de la victime. Sur un compte administrateur, il obtient tout le back-office.

Le jeton est valable 24 heures par défaut (password_reset_timeout: 86400 dans user.settings) et il ne sert qu’une fois : son hash inclut la date de dernière connexion du compte, donc il devient invalide dès que la victime se connecte.

Le mail passe tous les filtres anti-phishing, puisqu’il vient vraiment du domaine du site. C’est ce qui rend l’attaque efficace.

Pourquoi les protections en place n’ont rien vu

  • Antibot et Honeypot protégeaient le formulaire. Ils bloquent bien un curl naïf. Mais ils n’inspectent pas les en-têtes Host ou X-Forwarded-Host, et un attaquant qui pilote un vrai navigateur (Chrome headless, par exemple) les contourne. Ils freinent les bots basiques, ils ne protègent pas de cette faille.
  • Le flood control de Drupal limite le nombre de demandes de réinitialisation. Ici, une seule demande suffit.
  • Les logs Drupal sont trompeurs : avec un proxy de confiance pour tout le monde, l’en-tête X-Forwarded-For est cru lui aussi. L’IP enregistrée dans le journal Drupal peut donc être falsifiée. Seuls les logs du load balancer donnent la vraie IP source.

Reproduire sans risque

Ne rejouez pas l’attaque sur la production, surtout si une équipe sécurité enquête dessus : vous brouilleriez ses traces et déclencheriez une nouvelle alerte.

En local avec DDEV, les mails arrivent dans Mailpit et ne partent jamais. Pour reproduire les conditions de la prod, commentez temporairement le trusted_host_patterns = ['.*'] de settings.ddev.php. Ensuite, deux tests suffisent.

Un test qui n’envoie aucun mail : demandez une page avec un domaine falsifié et cherchez ce domaine dans les liens absolus du HTML (canonical, og:url, hreflang).

curl -s -H 'X-Forwarded-Host: attaquant.example' https://monsite.ddev.site/user/login \
  | grep -c 'attaquant.example'
# Vulnérable : > 0. Corrigé : 0, ou une réponse 400.

Le test du mail : soumettez « mot de passe oublié » depuis un navigateur, avec une extension qui ajoute l’en-tête X-Forwarded-Host, puis ouvrez le mail dans Mailpit. Sur notre projet, le lien reçu pointait bien vers https://attaquant.example/user/reset/…, exactement comme dans le mail de la production.

Le correctif

// settings.php, production uniquement (voir « Les pièges du déploiement »).

// 1. La liste blanche des domaines servis par cet environnement.
$settings['trusted_host_patterns'] = [
  '^www\.example\.com$',
  '^example\.com$',
];

// 2. Seul le load balancer est un proxy de confiance : ses sous-réseaux,
//    pas l'IP de l'appelant.
$settings['reverse_proxy'] = TRUE;
$settings['reverse_proxy_addresses'] = ['10.0.1.0/24', '10.0.2.0/24'];

// 3. On ne croit que les en-têtes que le load balancer écrit lui-même.
$settings['reverse_proxy_trusted_headers'] =
  \Symfony\Component\HttpFoundation\Request::HEADER_X_FORWARDED_FOR |
  \Symfony\Component\HttpFoundation\Request::HEADER_X_FORWARDED_PROTO |
  \Symfony\Component\HttpFoundation\Request::HEADER_X_FORWARDED_PORT;

Quel réglage bloque vraiment l’attaque ?

On présente souvent le point 2 comme le correctif : « ne faire confiance qu’au load balancer ». Seul, il ne suffit pas. L’attaquant ne contacte pas le serveur Drupal directement, il passe par le load balancer, comme tout le monde. Or un Application Load Balancer AWS gère X-Forwarded-For, X-Forwarded-Proto et X-Forwarded-Port, mais pas X-Forwarded-Host : l’en-tête envoyé par l’attaquant arrive tel quel. La requête vient bien d’un proxy de confiance, et Drupal croit donc l’en-tête.

Réglage Bloque l’attaque à lui seul ?
trusted_host_patterns Oui. getHost() valide le domaine, qu’il vienne de Host ou de X-Forwarded-Host. Un domaine inconnu donne une réponse 400.
reverse_proxy_trusted_headers sans X_FORWARDED_HOST En partie. X-Forwarded-Host est ignoré, mais un Host falsifié reste accepté si le load balancer le laisse passer jusqu’à Drupal.
reverse_proxy_addresses limité au load balancer Non, quand l’attaque passe par le load balancer. Cela protège seulement si le serveur est aussi joignable directement.

Le vrai correctif, c’est trusted_host_patterns. Les deux autres réglages réduisent la surface d’attaque, et ils rendent fiable l’IP enregistrée dans les logs.

Avec le correctif, la même requête reçoit une réponse 400 avec le message The provided host name is not valid for this server., et aucun mail ne part.

Les pièges du déploiement

Activer trusted_host_patterns peut faire tomber un site si on oublie un domaine. Avant de déployer, vérifiez les points suivants :

  • Le health check du load balancer. S’il interroge le conteneur avec un Host qui n’est pas dans la liste (l’IP de la cible, par exemple), il reçoit une réponse 400, les tâches passent unhealthy et l’orchestrateur les remplace en boucle. Regardez dans les logs d’accès quel Host envoie votre health check, et autorisez-le, ou faites-lui envoyer un domaine autorisé.
  • Tous les domaines réels : avec et sans www, les alias, les domaines de recette et de préprod, et ceux d’un éventuel multisite. Ancrez toujours les motifs avec ^ et $, et échappez les points : un motif example.com accepte aussi example.com.attaquant.example.
  • L’ordre des fichiers de settings. settings.ddev.php, inclus en fin de settings.php, impose ['.*']. C’est voulu en local, mais si vos valeurs de production sont définies après cet include, elles s’appliqueront aussi en local. Placez-les dans un fichier par environnement, ou derrière une condition sur une variable d’environnement.
  • Drush n’est pas concerné. Le cœur ignore trusted_host_patterns en ligne de commande (PHP_SAPI === 'cli'). Pour les liens générés par Drush (drush uli, mails envoyés par cron), passez le domaine avec --uri ou définissez-le dans drush.yml.

Après l’incident

  • Le journal Drupal : cherchez « Password reset instructions mailed to » (la demande) puis « used one-time login link » (l’utilisation du lien) pour le compte visé. Un lien utilisé alors que la victime n’a rien demandé, c’est une prise de compte.
  • Les logs du load balancer : c’est la seule source fiable pour la vraie IP et l’en-tête Host du POST /user/password.
  • Si le lien a été utilisé : supprimez les sessions du compte, changez son mot de passe, et vérifiez ce qui a été modifié depuis (contenus, utilisateurs, rôles, configuration).
  • Les autres risques du même réglage. Le cache de page interne de Drupal inclut le domaine dans sa clé, donc une page générée pour un domaine falsifié n’est pas servie aux autres visiteurs. En revanche, un CDN ou un Varnish qui ne tiendrait compte que du chemin pourrait mettre en cache et servir à tout le monde une page aux liens absolus empoisonnés.

Checklist

  • trusted_host_patterns est défini en production, avec des motifs ancrés ^…$.
  • Le rapport d’état affiche « Trusted Host Settings : Enabled ».
  • reverse_proxy_addresses liste les sous-réseaux du load balancer, jamais $_SERVER['REMOTE_ADDR'].
  • reverse_proxy_trusted_headers est défini, sans HEADER_X_FORWARDED_HOST ni HEADER_FORWARDED, sauf si le proxy les écrit lui-même.
  • Le health check passe avec le correctif, testé en recette avant la production.
  • curl -H 'X-Forwarded-Host: attaquant.example' renvoie 400, ou du HTML sans ce domaine.
  • Les liens générés par Drush utilisent le bon domaine (--uri).

Ce réglage tient en quelques lignes, et Drupal le signale en rouge depuis Drupal 8. Ici, son absence a suffi pour que le site envoie lui-même un mail de phishing parfaitement authentique.