wiki/HowtoFail2Ban.md

**Cette page a été importée automatiquement de notre ancien wiki mais n'a pas encore été révisée.**

# Howto Fail2Ban

Fail2Ban est un service (en Python), qui scanne les logs applicatifs à la recherche d'échec de connexions pour bannir (via iptables) les adresses IP qui font trop de tentatives.
Il est disponible en version 0.8.4-3 pour Squeeze et 0.8.6-3 pour Wheezy. Un backport pour Squeeze est [disponible](https://packages.debian.org/squeeze-backports/fail2ban)

## Installation

~~~
# aptitude install fail2ban
~~~

## Configuration

Cela se passe dans le répertoire /etc/fail2ban

Le principe repose sur un système de règles basées sur des regex correspondant à applicatif.

Par défaut les règles pour SSH sont activées , voici comment ça se composer

*filter.d/sshd.conf* contient les regex correspondant à SSH

jail.conf est le fichier principal activant (ou pas) les règles avec différents paramètres

~~~
[ssh]                        

enabled = true               
port    = ssh                
filter  = sshd               
logpath  = /var/log/auth.log
maxretry = 6                 
~~~

On peut régler plusieurs paramètres, comme le maxretry (nombres d'échecs) dans la section [DEFAULT] ou pour chaque applicatif.

## Règles

On peut évidemment écrire ses propres règles. On pourra les tester ainsi :

~~~
# fail2ban-regex /tmp/mail.log filter.d/sasl-test.conf
~~~

## Administration

On peut lister les "jails" :

~~~
# fail2ban-client status
|- Number of jail:      NN
`- Jail list:           ...
~~~

On va les retrouver aussi avec `iptables -L -n`

Pour débannir une IP :

~~~
# fail2ban-client set <JAIL> unbanip <IP>
~~~


## Exemples

### Dovecot

Il faut ajouter des règles personnalisées :

~~~
[dovecot-pop3imap]             
enabled = true
filter = dovecot-pop3imap
port = pop3,pop3s,imap,imaps
logpath = /var/log/mail.log
~~~

Filtre dovecot, filter.d/dovecot-pop3imap.conf

~~~
[Definition]                                                                                                           
failregex = (?: pop3-login|imap-login): .*(?:Authentication failure|Aborted login \(auth failed|Aborted login \(tried to use disabled|Disconnected \(auth failed|Aborted login \(\d+ authentication attempts).*rip=(?P<host>\S*),.*
ignoreregex =
~~~

## Courier

Il suffit d'activer la règle courierlogin prédéfinie :

~~~{.ini}
[courierauth]

enabled  = true
port     = smtp,ssmtp,imap2,imap3,imaps,pop3,pop3s
filter   = courierlogin
logpath  = /var/log/mail.log
~~~

## Postfix SASL

Il faut modifier la règle SASL prédéfinie :

~~~{.ini}
[sasl]

enabled  = true
port     = smtp,ssmtp,imap2,imap3,imaps,pop3,pop3s
filter   = sasl-evolix
logpath  = /var/log/mail.log
~~~

avec filter.d/sasl-evolix.conf :

~~~
[Definition]
failregex = (?i): warning: [-._\w]+\[<HOST>\]: SASL (?:LOGIN|PLAIN|(?:CRAM|DIGEST)-MD5) authentication failed:
ignoreregex =
~~~

## Services HTTP

Il est possible d'utiliser `fail2ban` sur des sites web pour ajouter une couche de protection contre les attaques, ou alors pour répondre à une attaque en cours.

Les deux attaques les plus courantes sur les services HTTP sont les DDOS et les attaques en "brute force".

Pour les attaques de type DDOS, la chose la plus efficace à faire est d'écrire des règles pour le serveur web (Apache, Nginx, etc.)

Comme `fail2ban` a besoin d'être configuré au cas par cas, il faut utiliser des configurations différentes pour chaque plateforme web.

En général, on tente d'être le plus précis possible en configurant `fail2ban` pour regarder les logs d'authentification. Cela permet d'éviter les faux positifs et d'être efficace en cas d'attaque.

### Apache & Nginx DDOS

On peut protéger Apache des attaques DDOS simples avec les configurations suivantes. Il faut tout d'abord s'assurer qu'Apache enregistre des logs d'accès. On ajoute ensuite un filtre à `fail2ban` dans `/etc/fail2ban/filter.d/ddos-<http.conf`:>

~~~
failregex = ^ -.*GET
~~~

Finalement, on modifie `/etc/fail2ban/jail.local` pour ajouter une des deux règles suivantes. Avec cette règle, une personne qui accède plus de 300 fois à une page web sur notre serveur web en 5 minutes va être bannie pendant la période de temps par défaut:

~~~{.ini}
[ddos-<http-apache>]
enabled = true
port = <http,https>
filter = ddos-http
logpath = /var/log/apache2/access.log
maxretry = 300
findtime = 300
~~~

~~~{.ini}
[ddos-<http-nginx>]
enabled = true
port = <http,https>
filter = ddos-http
logpath = /var/log/nginx/access.log
maxretry = 300
findtime = 300
~~~

### Wordpress

Il existe plusieurs options pour configurer `fail2ban` pour Wordpress. Cela découle du fait qu'il n'y a pas de moyen par défaut de logger les authentifications erronées sous Wordpress, et que la page d'authentification ne renvoie pas d'erreur HTTP particulière non plus. ["Une proposition à cet effet"](https://core.trac.wordpress.org/ticket/25446) a cependant été faite et risque éventuellement d'être implémentée.

#### Option 1: HTPP 200

Cette option est la plus simple des trois car elle ne nécessite pas de modifier l'installation Wordpress. Elle a cependant le désavantage d'être très générale et peu créer des faux positifs. C'est celle qui est actuellement utilisée par Évolix.

Il faut tout d'abord s'assurer que notre serveur web enregistre des logs d'accès. On ajoute ensuite un filtre à `fail2ban` dans `/etc/fail2ban/filter.d/apache-wp.conf`:

~~~
[Definition]
failregex = <HOST> -.*"POST.*/wp-login.php HTTP.* 200
            <HOST> -.*"POST.*/xmlrpc.php.*
~~~

Finalement, on modifie `/etc/fail2ban/jail.local` pour ajouter une règle. Avec cette règle, une personne qui accède plus de 5 fois à la page `/wp-login.php` ou à `/xmlrpc.php` dans une période d'une minute va être bannie pendant la période de temps par défaut:

~~~{.ini}
[apache-wp]
enabled  = true
port     = <http,https>
filter   = apache-wp
logpath  = /var/log/apache2/access.log
maxretry = 5
findtime = 60
~~~

#### Option 2: Plugin simple & HTTP 401

Une seconde option est d'utiliser un plugin Wordpress très simple pour envoyer une erreur HTTP 401 en cas d'erreur d'authentification. Cette méthode est plus fine et créé moins de faux positifs, mais nécessite de toucher à l'installation Wordpress.

Elle est cependant peu invasive car elle fait installe le plugin dans [wp-content/mu-plugins](https://codex.wordpress.org/Must_Use_Plugins), un dossier spécial pour les plugins de ce genre. Typiquement, les mu-plugins ne sont pas vu à travers l'interface d'administration web.

Il faut tout d'abord s'assurer que notre serveur web enregistre des logs d'accès. Par la suite, on installe le plugin dans `wp-content/mu-plugins/401-on-login-fail.php`:

~~~{.php}
<?php
function my_login_failed_401() {
    status_header( 401 );
}
add_action( 'wp_login_failed', 'my_login_failed_401' );
~~~

On ajoute ensuite un filtre à `fail2ban` dans `/etc/fail2ban/filter.d/apache-wp.conf`:

~~~
[Definition]
  failregex = <HOST>.*POST.*(wp-login\.php|xmlrpc\.php).* 401
~~~

Finalement, on modifie `/etc/fail2ban/jail.local` pour ajouter une règle. Avec cette règle, une personne qui accède plus de 5 fois à la page `/wp-login.php` ou à `/xmlrpc.php` dans une période d'une minute va être bannie pendant la période de temps par défaut:

~~~{.ini}
[apache-wp]
enabled  = true
port     = <http,https>
filter   = apache-wp
logpath  = /var/log/apache2/access.log
           /home/user/log/access.log
maxretry = 5
findtime = 60
~~~

#### Option 3: Plugin régulier & LOG_AUTH

La dernière solution utilise le [le plugin Wordpress fail2ban](https://wordpress.org/plugins/wp-fail2ban/) pour enregistrer les authentification dans un fichier de log. `fail2ban` vérifie par la suite ce fichier pour bannir les gens effectuant des attaques.

Parce qu'elle nécessite l'installation et la mise à jour régulière d'un plugin, elle ne devrait être utilisée que par les personnes administrant le site web en question.

On commence tout d'abord par [installer le plugin](https://wordpress.org/plugins/wp-fail2ban/). Une fois que cela est fait, on ajoute les deux filtres suivants, respectivement dans `etc/fail2ban/filter.d/wordpress-hard` et `etc/fail2ban/filter.d/wordpress-soft`:

~~~{.ini}
# Fail2Ban configuration file hard
#
# Author: Charles Lecklider
#

[INCLUDES]

# Read common prefixes. If any customizations available -- read them from
# common.local
before = common.conf


[Definition]

_daemon = (?:wordpress|wp)

# Option:  failregex
# Notes.:  regex to match the password failures messages in the logfile. The
#          host must be matched by a group named "host". The tag "<HOST>" can
#          be used for standard IP/hostname matching and is only an alias for
#          (?:::f{4,6}:)?(?P<host>[\w\-.^_]+)
# Values:  TEXT
#
failregex = ^%(__prefix_line)sAuthentication attempt for unknown user .* from <HOST>( via XML-RPC)?$
            ^%(__prefix_line)sBlocked authentication attempt for .* from <HOST>( via XML-RPC)?$
            ^%(__prefix_line)sBlocked user enumeration attempt from <HOST>$
            ^%(__prefix_line)sPingback error .* generated from <HOST>$

# Option:  ignoreregex
# Notes.:  regex to ignore. If this regex matches, the line is ignored.
# Values:  TEXT
#
ignoreregex =
~~~

~~~{.ini}
# Fail2Ban configuration file soft
#
# Author: Charles Lecklider
#

[INCLUDES]

# Read common prefixes. If any customizations available -- read them from
# common.local
before = common.conf


[Definition]

_daemon = (?:wordpress|wp)

# Option:  failregex
# Notes.:  regex to match the password failures messages in the logfile. The
#          host must be matched by a group named "host". The tag "<HOST>" can
#          be used for standard IP/hostname matching and is only an alias for
#          (?:::f{4,6}:)?(?P<host>[\w\-.^_]+)
# Values:  TEXT
#
failregex = ^%(__prefix_line)sAuthentication failure for .* from <HOST>$
            ^%(__prefix_line)sXML-RPC authentication failure from <HOST>$

# Option:  ignoreregex
# Notes.:  regex to ignore. If this regex matches, the line is ignored.
# Values:  TEXT
#
ignoreregex =
~~~

Finalement, on modifie `/etc/fail2ban/jail.local` pour ajouter les règles suivantes. Avec cette règle, une personne qui tente de se connecter avec un compte inexistant ou qui n'arrive pas à se connecter 5 fois sera bannie pendant la période de temps par défaut:

~~~{.ini}
[wordpress-hard]
  enabled = true
  filter = wordpress-hard
  logpath = /var/log/auth.log
  maxretry = 1
  port = <http,https>

[wordpress-soft]
  enabled = true
  filter = wordpress-soft
  logpath = /var/log/auth.log
  maxretry = 5
  port = <http,https>
~~~

### ownCloud

Pour faire fonctionne ownCloud avec fail2ban, il faut tout d'abord modifier le `config.php` pour enregistrer les informations d'authentification:

~~~
'loglevel' => '2',
'log_authfailip' => true,
'logfile' => '/var/log/owncloud.log',
~~~

On ajoute ensuite un filtre à `fail2ban` dans `/etc/fail2ban/filter.d/owncloud.conf`:

~~~
[Definition]
  failregex={"app":"core","message":"Login failed: user '.*' , wrong password, IP:<HOST>","level":2,"time":".*"}
~~~

Finalement, on modifie `/etc/fail2ban/jail.local` pour ajouter une règle. Avec cette règle, une personne qui n'arrive pas à se connecter 5 fois dans une période de 10 minutes sera bannie pendant la période de temps par défaut:

~~~{.ini}
[owncloud]
  enabled = true
  filter  = owncloud  
  port    = <http,https>
  logpath = /var/log/owncloud.log
  maxrety = 5
  findtime = 600
~~~

### Joomla

Il faut tout d'abord s'assurer que notre serveur web enregistre des logs d'accès. On ajoute ensuite un filtre à `fail2ban` dans `/etc/fail2ban/filter.d/apache-joomla.conf`:

~~~{.ini}
[Definition]
  failregex = <HOST> -.*"POST.*/administrator/index.php.*
~~~

Finalement, on modifie `/etc/fail2ban/jail.local` pour ajouter une règle. Avec cette règle, une personne qui accède plus de 5 fois à la page `/administrator/index.php` dans une période d'une minute va être bannie pendant la période de temps par défaut:

~~~{.ini}
[apache-joomla]
  enabled  = true
  port     = <http,https>
  filter   = apache-joomla
  logpath  = /var/log/apache2/access.log
  maxretry = 5
  findtime = 60
~~~

### Prestashop

Il faut tout d'abord s'assurer que notre serveur web enregistre des logs d'accès. On ajoute ensuite un filtre à `fail2ban` dans `/etc/fail2ban/filter.d/apache-prestashop.conf`:

~~~{.ini}
[Definition]
  failregex = <HOST> -.*"POST.*/login.*
~~~

Finalement, on modifie `/etc/fail2ban/jail.local` pour ajouter une règle. Avec cette règle, une personne qui accède plus de 10 fois à la page de connexion pour un compte utilisateur dans une période d'une minute va être bannie pendant la période de temps par défaut:

~~~{.ini}
[apache-prestashop]
  enabled  = true
  port     = <http,https>
  filter   = apache-prestashop
  logpath  = /var/log/apache2/access.log
  maxretry = 10
  findtime = 60
~~~