Reaction (comme dans “action → réaction”) est un logiciel permettant de faire comme Fail2ban mais sans les défauts de ce dernier :

• Consomme moins
• Plus facile à customiser
• Carrément plus simple de faire des regex

Et autres qualités que l'auteur explique bien.

Faudra que je participe au wiki officiel mais en attendant je met mes idées en place ici.

Commandes:

• start : Démarre le démon Reaction
  • reaction start [OPTIONS] –config <CONFIG>
  • Options possibles : -c (Requis), -l, -s, -h
  • Par exemple, pour un fichier reaction start -c /etc/reaction/server.jsonnet
  • Et un dossier : reaction start -c /etc/reaction/
  • Dans le cas des dossiers, les seuls fichiers du dossier qui seront lus automatiquement
    • Doivent se terminer par les extensions .json, .jsonnet, .yml ou .yaml.
    • Ne doivent pas démarrer par . ou _.
• show : Affiche les correspondances actuelles et les actions (= qui est banni)
  • reaction show [OPTIONS] [NAME=PATTERN]
  • [NAME=PATTERN] : n'affiche que les éléments correspondant à name=PATTERN regex
  • Options possibles : -s, -f, -l, -h
• flush : Retire une cible de Reaction (unban)
  • reaction flush [OPTIONS] [NAME=PATTERN]
  • Options possibles : -s, -f, -l, -h
  • Débannir quelqu'un : reaction flush IP
• test-regex : Tester une regex
  • reaction test-regex –config <CONFIG> <REGEX> [LINE]
  • Arguments:
    • <REGEX> Regex to test
    • [LINE] Line to be tested
  • Options possibles : -c (requis), -h
• test-config : Tester une configuration
  • reaction test-config [OPTIONS] –config <CONFIG>
  • Options possibles : -c (requis), -f, -v, -h
• help, -h : Affiche l'aide sur les commandes et sous-commandes
• -V, –version : Affiche la version de reaction

Pour les options possibles (suivant les commandes) :

• -c, –config <CONFIG> : Fichier de configuration en format json, jsonnet ou yaml ; ou dossier contenant ces fichers. Requis.
• -l, –loglevel <LOGLEVEL> : Niveau de log minimum à afficher [default: INFO].
• -s, –socket <SOCKET> : chemin d'accès au socket de communication client-daemon [default: /run/reaction/reaction.sock].
• -h, –help : Affiche l'aide.
• -f, –format <FORMAT> : comment formater la sortie [default: yaml] [valeurs possibles : json, yaml].
• -v, –verbose : affiche plus d'infos en sortie.

Par défaut les bases de données sont dans /var/lib/reaction/ (reaction-matches.db et reaction-flushes.db). Les effacer remet tout à zéro.

Pour l'installer, il y a un paquet debian mais pas dans les dépôts. Installer aussi Minisign pour vérifier l'intégrité. Ci-dessous en exemple mais la page des releases donne les bons numéros de release (et les instructions)… J'utilise wget plutôt que curl, ce dernier ayant quelques soucis de sécurité (et puis wget est déjà de base sur mon serveur).

sudo apt install minisign
wget https://static.ppom.me/reaction/releases/v1.4.1/reaction_1.4.1-1_amd64.deb \
     https://static.ppom.me/reaction/releases/v1.4.1/reaction_1.4.1-1_amd64.deb.minisig
minisign -VP RWSpLTPfbvllNqRrXUgZzM7mFjLUA7PQioAItz80ag8uU4A2wtoT2DzX -m reaction_1.4.1-1_amd64.deb &&
  rm reaction_1.4.1-1_amd64.deb.minisig &&
  sudo apt install ./reaction_1.4.1-1_amd64.deb

Ensuite on crée le ou les fichiers de config, et on les bidouillent. Voir plus bas la/les confs.

sudo mkdir /etc/reaction/
sudo nano /etc/reaction/reaction.jsonnet

sudo reaction start -c /etc/reaction/server.jsonnet

sudo reaction test-config -c /etc/reaction

On va créer un service :

sudo nano /etc/systemd/system/reaction.service

[Install]
WantedBy=multi-user.target
[Service]
ExecStart=/usr/bin/reaction start -c /etc/reaction/
StateDirectory=reaction
RuntimeDirectory=reaction
WorkingDirectory=/var/lib/reaction
Restart=on-failure
RestartSec=3

Vu que j'ai eu des plantages muets, je lui dis de se relancer si ça lui arrive¹⁾. Ce serait bien d'être averti quand ça plante, ceci dit

On démarre le service :

sudo systemctl enable reaction.service
sudo service reaction start

Pour la doc complète, se référer à https://reaction.ppom.me/. Concernant ma configuration, je pars avec ces spécificités :

• Utilisation de nftables
• Découpage de la configuration par services (pour faciliter certaines automatisations)
• Analyse des ip bannies pour en déduire des plages et bannir ces dernières ?
• Rapport (journalier ?) sur les ip bannies (histoire de pouvoir suivre ce qui se passe et la charge) ?

Il s'agit de me simplifier un peu la lecture et la maintenance. Sur l'exemple ici, j'ai 3 types de fichiers

• Définitions : ce qu'est l'action pour bannir/débannir, les périodes par défaut de bannissement… C'est le fichier _lib.jsonnet.
• server.jsonnet qui contient les trucs de base : comment les ip sont formatées et ce qui se passe quand on démarre/arrête le service.
• Les fichiers de stream (ssh.jsonnet, web.jsonnet, etc) qui vont lister, par service, quel fichier de log analyser et sur quelles regex on va bannir.

On paramètre évidement le lancement de Reaction (avec service ou direct en ligne de commande) pour lire tout le contenu du dossier (ici /etc/reaction).

Ici c'est assez classique, le seul point important étant que je tourne avec nftables. Il peut être utile de spécifier les ip à ne pas bannir avec Reaction, couplé avec un fichier nftables complet (entre autre sur la vérification des ip locales), ça évite de se bannir son propre routeur ou en tant que sysadmin.

server.jsonnet

{
  patterns: {
    ip: {
    // Both IPv4 and IPv6, do not accept malformed IPs
      regex: @'(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}|(?:(?:[0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})|:(?:(?::[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(?::[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(?:ffff(?::0{1,4}){0,1}:){0,1}(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])|(?:[0-9a-fA-F]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9]))',
      ignore: [
        // Ne pas oublier la virgule après chaque ip, pour l'énumération ;)
        '127.0.0.1',
        '::1',
        // Sous-réseau d'une box
        '192.168.1.0/24'
        // Sous-réseau proxmox ?
        //'10.0.0.0/8'
        // Ip fixes de sysadmins
        // ip de bastion
      ],
    },
  },
 
  start: [
    ['nft', |||
    table inet reaction {
      set ipv4bans {
        type ipv4_addr
        flags interval
        auto-merge
      }
      set ipv6bans {
        type ipv6_addr
        flags interval
        auto-merge
      }
      chain input {
        type filter hook input priority 0
        policy accept
        ip saddr @ipv4bans drop
        ip6 saddr @ipv6bans drop
      }
    }
||| ],
  ],
  stop: [
    ['nft', 'delete table inet reaction'],
  ],
}

Ce fichier sert à définir les actions telles que “banFor”, qu'on configure évidement avec notre commande pour nftables²⁾.

On peut ainsi définir des actions par défaut : combien de temps on bannit, combien de lignes dans les logs avant de bannir, etc. Cela permet par exemple de définir pour tout le monde la même durée de bannissement et de la changer à un seul endroit si besoin.

Le fait que le fichier commence par “_” fait qu'il ne sera pas lu automatiquement au lancement de Reaction, il faudra l'appeler là où il est utile (dans les streams). Si on ne fais pas ça (s'il est noté “lib.jsonnet” par exemple), on aura l'erreur “ERROR While reading ssh.jsonnet in /etc/reaction: variable is not defined: filter_default” lors de l'execution.

_lib.jsonnet

local banFor(time) = {
  ban: {
    cmd: ['nft46', 'add element inet reaction ipvXbans { <ip> }'],
  },
  unban: {
    cmd: ['nft46', 'delete element inet reaction ipvXbans { <ip> }'],
    after: time,
  },
};
 
local filter_default = {
  retry: 3,
  retryperiod: '3h',
  actions: banFor('24h'),
};
 
{
  banFor: banFor,
  filter_default: filter_default,
}

Je met ici une config très basique pour ssh (Faudra que je mette le tout sur une forge, une fois fini…), suffisante pour lister les “pièges” dans la syntaxe.

ssh.jsonnet

local lib = import '_lib.jsonnet';
{
  streams: {
    ssh: {
      cmd: ['journalctl', '-fn0', '-u', 'sshd.service'],
      filters: {
        failedlogin: lib.filter_default + {
          regex: [
            @'authentication failure;.*rhost=<ip>',
            @'Connection reset by authenticating user .* <ip>',
            @'Failed password for .* from <ip>',
          ],
          retry: 3,
          retryperiod: '6h',
          actions: lib.banFor('48h'),
        },
      },
    },
  },
}

• local lib = import '_lib.jsonnet'; ⇒ il est nécessaire d'appeler le fichier avec les définitions pour la suite, et on fait une variable pour les appels la concernant (lib).
• cmd: ['journalctl', '-fn0', '-u', 'sshd.service'] ⇒ indique quel fichier de log lire.
• lib.filter_default et lib.banFor : on utilise les actions banFor et filter_default mais comme elles sont dans le fichier _lib.jsonnet, on appelle la variable définie avant (lib). Sinon, ben… ça marche pas.

local sendmail(ip,rule) = {
  mail: {
    cmd: ['sh', '/root/scripts/sendmailreaction/mailreaction.sh', ip, rule],
  },
};

#!/bin/bash
# Envoyer un mail
dossiermail="/root/scripts/sendmailreaction/mail"
titremail="$1 banni"
# Création du fichier du corps du mail dans un fichier temporaire qui évite toute collision
corpmail="$(mktemp -p $dossiermail)"
listeip="/var/lib/reaction/reaction-matches.db"

# Vérifier si l'adresse a déjà été banni pour éviter de flooder lorsqu'on relance
if grep -q $1 $listeip; then
    exit
else
    # Message pour le corps du mail
    echo "Méchant $1 ! $2 \n \n" >> $corpmail
    # Ajouter les logs pour les détails
    journalctl --since yesterday | grep $1 >> $corpmail
    #Envoyer le mail
    cat $corpmail | mail -s "$titremail" root
    # Effacer le corps du crime pour éviter d'encombrer sans intérêt
    rm $corpmail
fi

  streams: {
    ssh: {
      cmd: ['journalctl', '-fn0', '-u', 'ssh.service'],
      filters: {
        failedlogin: {
          regex: [
            @'authentication failure;.*rhost=<ip>',
            @'Connection reset by authenticating user .* <ip>',
            @'Failed password for .* from <ip>',
          ],
          retry: 6,
          retryperiod: '6h',
          actions: banFor('48h') + sendmail('<ip>','"Banni 48h pour tentative de co à SSH"'),
        },
      },
    },