Cet article vous permettra d’accroître la sécurité de votre application de messagerie « poste.io », en ajoutant un reverse proxy (HAProxy) en amont de votre serveur pour la partie administration et webmail.

Préambule

HAProxy est un répartiteur de charge et un proxy open source pour les applications TCP et HTTP. HAProxy est disponible gratuitement dans sa version communautaire, ou également de manière commerciale sous le nom de Hapee (version packagée) et Aloha (version appliance).

Poste.io² est un serveur de mail (smtp, imap, pop, antispam, antivirus, webmail, web administration) packagé avec des outils open source (dovecot, haraka, nginx, rspamd, clamav, redis, sqlite) . Il existe différentes versions (une version free et des versions PRO).

A travers cet article, vous trouverez les éléments de base pour configurer l’application HAProxy afin de sécuriser la partie webmail et la partie administration de poste.io.

HAProxy

Dans le but de sécuriser davantage l’application poste.io nous allons réaliser la configuration suivante :

• Limiter l’accès à la page d’administration
• Ralentir les clients réalisant trop de requêtes
• Limiter le nombre de requêtes d’authentification pour un même utilisateur

Limiter l’accès à la page d’administration

Le path de l’url d’administration de l’application poste.io est « /admin/login » ({ path -m beg /admin/login }). Nous allons donc limiter l’accès (http-request deny if) seulement aux réseaux RFC 1918 (!{ src 10.0.0.0/8 172.16.0.0/12 192.168.0.0./16 }).
Vous pouvez remplacer les réseaux par vos adresses IP publiques ou locales.

http-request deny if { path -m beg /admin/login } !{ src 10.0.0.0/8 172.16.0.0/12 192.168.0.0./16 }

---

Ralentir les utilisateurs réalisant trop de requêtes

Création d’une stick-table portant le nom st_limit à l’aide d’un nouveau backend. Une stick-table permet de collecter et stocker des données sur le flux traversant HAProxy.
Dans cette stick-table, nous stockerons des adresses IP (type ip). Nous pourrons stocker au maximum un million d’entrées pendant 10 minutes (size 1m expire 1h). Les données stockées seront le nombre de requêtes HTTP (http_req_rate((20s)) pendant 20 secondes ainsi que le nombre de requêtes HTTP en erreur (http_err_rate(1h)) pendant une heure.

backend st_limit
     stick-table type ip size 1m expire 1h store http_req_rate(20s),http_err_rate(1h)

Ajoutez dans votre backend la règle permettant de capturer toutes les adresses IP dans la stick-table « st_limit ».

http-request track-sc0 src table st_limit

Ajoutez une directive dans le backend pour ralentir (les requêtes sont en attente au niveau de HAProxy) un utilisateur pendant deux minutes (timeout tarpit 120s) s’il dépasse 200 requêtes en 20 secondes (http-request tarpit if { sc0_http_req_rate(st_limit) gt 200 }). Il pourra de nouveau accéder correctement au site une fois qu’il sera en dessous du seuil de deux cent requêtes en vingt secondes.

timeout tarpit 120s
http-request tarpit if { sc0_http_req_rate(st_limit) gt 200 }

---

Limiter les scanners de faille

Les scanners de failles testent des URLs correspondant à différentes applications connues. Cela engendre beaucoup d’erreurs car les URL testées n’existent pas. Nous allons donc limiter les clients générant beaucoup d’erreurs HTTP.

A l’aide de la stick-table créée précédemment, nous stockons le nombre de requêtes en erreur. Ce compteur va nous permettre de rejeter les adresses IP réalisant trop de requêtes de ce type. Au dessus de 20 requêtes en erreur sur une période d’une heure, l’adresse IP sera bloqué. Elle restera bloquée tant qu’elle ne descendra pas en dessous du seuil ci-dessus.

http-request deny if { sc0_http_err_rate(st_limit) gt 20 }

Limiter le nombre de requêtes d’authentification

limiter le nombre de requête d’authentificationLors d’une authentification erronée, aussi bien sur la partie administration que sur la partie webmail, l’application poste.io retourne un code retour HTTP 401 (non autorisé). Nous allons donc encore utiliser le système de « stick-table » afin de rejeter les connexions qui auraient un trop grand nombre d’erreurs d’authentification.

Création d’un nouveau backend dédié à une nouvelle stick-table. Cette stick-table peut garder un million d’adresses IP pendant 10 minutes. Elle stockera le nombre de requêtes HTTP réalisé en 20 secondes.

backend st_limit_auth
     stick-table type ip size 1m expire 10m store http_req_rate(20s)

Ajoutez dans votre backend la règle permettant de capturer les adresses IPs réalisant des erreurs d’authentification dans la stick-table « st_limit_auth ».

http-response track-sc1 src table st_limit_status if { status 401 }

Afin de bloquer les utilisateurs (http-request deny), il faudra rajouter la directive ci-dessous dans votre backend. Cela bloquera les utilisateurs qui réalisent plus de 5 erreurs d’authentification ({sc1_http_req_rate gt 5 }) en 20 secondes. L’utilisateur sera de nouveau autoriser à s’authentifier lorsqu’il sera en dessous de ce seuil.

http-request deny if { sc1_http_req_rate(st_limit_auth) gt 5 }

---

Fichier de configuration HAProxy

Si vous voulez utiliser le fichier de configuration, il faudra modifier au minimum les adresses IP ainsi que le chemin vers votre certificat SSL.

Télécharger le fichier de configuration : haproxy.cfg

Références :

• http://www.haproxy.org
• https://www.haproxy.com/blog
• https://poste.io/
• https://www.zenetys.com/haproxy-reference-cards/