Scannerl

Scannerl est un moteur d'empreinte digitale modulaire distribué implémenté par Kudelski Security. Scannerl peut prendre les empreintes de milliers de cibles sur un seul hôte, mais peut tout aussi facilement être distribué sur plusieurs hôtes. Scannerl est à la prise d'empreinte ce que zmap est au scan de ports.

Scannerl fonctionne sur Debian/Ubuntu/Arch (mais fonctionnera probablement sur d'autres distributions également). Il utilise une architecture maître/esclave où le nœud maître distribue le travail (hôte(s) à prendre en empreinte) à ses esclaves (locaux ou distants). L'ensemble du déploiement est transparent pour l'utilisateur.

Pourquoi utiliser Scannerl

Lors de l'utilisation d'outils de prise d'empreinte conventionnels pour des analyses à grande échelle, les chercheurs en sécurité rencontrent souvent deux limitations : premièrement, ces outils sont généralement conçus pour analyser un nombre relativement restreint d'hôtes à la fois et sont inadaptés pour de grandes plages d'adresses IP. Deuxièmement, si une grande plage d'adresses IP protégées par des dispositifs IPS sont soumises à la prise d'empreinte, la probabilité d'être blacklisté est plus élevée, ce qui pourrait conduire à un ensemble d'informations incomplet. Scannerl est conçu pour contourner ces limitations, non seulement en offrant la capacité de prendre les empreintes de plusieurs hôtes simultanément, mais aussi en distribuant la charge sur un nombre arbitraire d'hôtes. Scannerl rend également la distribution de ces tâches complètement transparente, ce qui rend la configuration et la maintenance de projets de prise d'empreinte à grande échelle triviales ; cela permet de se concentrer sur les analyses plutôt que sur la tâche herculéenne de gérer et distribuer les processus de prise d'empreinte manuellement. En plus du facteur vitesse, scannerl a été conçu pour permettre de mettre en place facilement des analyses d'empreinte spécifiques en quelques lignes de code. Non seulement la création d'un cluster de prise d'empreinte est facile à configurer, mais elle peut être ajustée en ajoutant des scans finement réglés à vos campagnes de prise d'empreinte.

C'est l'outil le plus rapide pour réaliser des campagnes de prise d'empreinte à grande échelle.

Pour en savoir plus :

Table des matières

Installation
Utilisation
Étendre Scannerl
Contribuer
Licence et droits d'auteur

Voir le wiki pour plus d'informations.

Installation

Voir les différentes options d'installation sur la page d'installation du wiki

Pour installer à partir des sources, installez d'abord Erlang (au moins v.18) en choisissant le bon paquet pour votre plateforme : Téléchargements Erlang

Installez les paquets requis :

# sur debian
$ sudo apt install erlang erlang-src rebar

# sur arch
$ sudo pacman -S erlang-nox rebar

Ensuite, construisez scannerl :

$ git clone https://github.com/kudelskisecurity/scannerl.git
$ cd scannerl
$ ./build.sh

Obtenez l'utilisation en exécutant

$ ./scannerl -h

Scannerl est disponible sur AUR pour les utilisateurs d'arch linux

Les DEB (Ubuntu, Debian) sont disponibles dans les releases.

Les RPM (Opensuse, Centos, Redhat) sont disponibles sous https://build.opensuse.org/package/show/home:chapeaurouge/scannerl.

Configuration distribuée

Deux types de nœuds sont nécessaires pour effectuer un scan distribué :

Nœud maître : c'est là que le binaire de scannerl est exécuté
Nœud(s) esclave(s) : c'est là que scannerl se connectera pour distribuer tout son travail

Le nœud maître doit avoir scannerl installé et compilé tandis que le nœud(s) esclave(s) a seulement besoin d'Erlang installé. L'ensemble de la configuration est transparente et effectuée automatiquement par le nœud maître.

Exigences pour un scan distribué :

Tous les hôtes ont la même version d'Erlang installée
Tous les hôtes peuvent se connecter les uns aux autres en utilisant une clé publique SSH
Tous les noms d'hôtes résolvent (utilisez /etc/hosts si aucun DNS approprié n'est configuré)
Tous les hôtes ont le même cookie de sécurité Erlang
Tous les hôtes doivent autoriser la connexion au port EPMD Erlang (TCP/4369)
Tous les hôtes ont la plage de ports suivante ouverte : TCP/11100 à TCP/11100 + nombre-d-esclaves

Utilisation

$ ./scannerl -h
   ____   ____    _    _   _ _   _ _____ ____  _
  / ___| / ___|  / \  | \ | | \ | | ____|  _ \| |
  \___ \| |     / _ \ |  \| |  \| |  _| | |_) | |
   ___) | |___ / ___ \| |\  | |\  | |___|  _ <| |___
  |____/ \____/_/   \_\_| \_|_| \_|_____|_| \_\_____|

USAGE
  scannerl MODULE TARGETS [NODES] [OPTIONS]

  MODULE:
    -m <mod> --module <mod>
      mod: le module de prise d'empreinte à utiliser.
           les arguments sont séparés par deux-points.

  TARGETS:
    -f <target> --target <target>
      target: une liste de cibles séparées par une virgule.
    -F <path> --target-file <path>
      path: le chemin du fichier contenant une cible par ligne.
    -d <domain> --domain <domain>
      domain: une liste de domaines séparés par une virgule.
    -D <path> --domain-file <path>
      path: le chemin du fichier contenant un domaine par ligne.

  NODES:
    -s <node> --slave <node>
      node: une liste de nœuds (noms d'hôtes, pas d'IP) séparés par une virgule.
    -S <path> --slave-file <path>
      path: le chemin du fichier contenant un nœud par ligne.
            un nœud peut également être fourni avec un multiplicateur (<node>*<nb>).

  OPTIONS:
    -o <mod> --output <mod>     liste séparée par des virgules du/des module(s) de sortie à utiliser.
    -p <port> --port <port>     le port à prendre en empreinte.
    -t <sec> --timeout <sec>    le délai d'attente du processus de prise d'empreinte.
    -T <sec> --stimeout <sec>   délai d'attente de connexion esclave (par défaut : 10).
    -j <nb> --max-pkt <nb>      nombre max de paquets à recevoir (int ou "infinity").
    -r <nb> --retry <nb>        compteur de tentatives (par défaut : 0).
    -c <cidr> --prefix <cidr>   subdiviser la plage avec un préfixe > cidr (par défaut : 24).
    -M <port> --message <port>  port d'écoute pour les messages (par défaut : 57005).
    -P <nb> --process <nb>      nombre max de processus simultanés par nœud (par défaut : 28232).
    -Q <nb> --queue <nb>        nombre max de résultats non traités dans la file d'attente (par défaut : infinity).
    -C <path> --config <path>   lire les arguments depuis un fichier, un par ligne.
    -O <mode> --outmode <mode>  0 : sur le maître, 1 : sur l'esclave, >1 : sur un courtier (par défaut : 0).
    -v <val> --verbose <val>    être verbeux (0 <= int <= 255).
    -K <opt> --socket <opt>     option de socket séparée par des virgules (key[:value]).
    -l --list-modules           lister les modules fp/out disponibles.
    -V --list-debug             lister les options de débogage disponibles.
    -A --print-args             Afficher l'enregistrement des arguments.
    -X --priv-ports             utiliser uniquement les ports sources entre 1 et 1024.
    -N --nosafe                 continuer même si certains esclaves échouent à démarrer.
    -w --www                    DNS essaiera www.<domain>.
    -b --progress               afficher la progression.
    -x --dryrun                 exécution à blanc.

Voir le wiki pour plus d'informations.

Utilisation autonome

Scannerl peut être utilisé sur l'hôte local sans aucun autre hôte. Cependant, il créera quand même un nœud esclave sur le même hôte à partir duquel il est exécuté. Par conséquent, les exigences décrites dans Configuration distribuée doivent également être remplies.

Un moyen rapide de le faire est de s'assurer que votre hôte peut se résoudre lui-même avec

grep -q "127.0.1.1\s*`hostname`" /etc/hosts || echo "127.0.1.1 `hostname`" | sudo tee -a /etc/hosts

et de créer une clé SSH (si ce n'est pas déjà fait) et de l'ajouter au fichier authorized_keys (vous devez avoir un serveur SSH en cours d'exécution) :

cat $HOME/.ssh/id_rsa.pub >> $HOME/.ssh/authorized_keys

L'exemple suivant exécute une récupération de bannière HTTP sur google.com depuis localhost

./scannerl -m httpbg -d google.com

Utilisation distribuée

Afin d'effectuer un scan distribué, il faut préconfigurer les hôtes qui seront utilisés par scannerl pour distribuer le travail. Voir Configuration distribuée pour plus d'informations.

Scannerl attend une liste d'esclaves à utiliser (fournie par les options -s ou -S).

./scannerl -m httpbg -d google.com -s host1,host2,host3

Lister les modules disponibles

Scannerl liste les modules disponibles (modules de sortie ainsi que modules de prise d'empreinte) avec l'option -l :

$ ./scannerl -l

Modules de prise d'empreinte disponibles
================================

bacnet             UDP/47808 : Identification Bacnet
chargen            UDP/19 : Identification du facteur d'amplification Chargen
fox                TCP/1911 : Identification FOX
httpbg             TCP/80 : Identification de l'en-tête HTTP Server
                     - Arg1 : [true|false] suivre la redirection [Défaut : false]
httpsbg            SSL/443 : Identification de l'en-tête HTTPS Server
https_certif       SSL/443 : Récupérateur de certificat HTTPS
imap_certif        TCP/143 : Récupérateur de certificat IMAP STARTTLS
modbus             TCP/502 : Identification Modbus
mqtt               TCP/1883 : Identification MQTT
mqtts              TCP/8883 : Identification MQTT over SSL
mysql_greeting     TCP/3306 : Identification de la version MySQL
pop3_certif        TCP/110 : Récupérateur de certificat POP3 STARTTLS
smtp_certif        TCP/25 : Récupérateur de certificat SMTP STARTTLS
ssh_host_key       TCP/22 : Récupérateur de clé d'hôte SSH

Modules de sortie disponibles
========================

csv                sortie vers csv
                     - Arg1 : [true|false] tout sauvegarder [Défaut : true]
csvfile            sortie vers fichier csv
                     - Arg1 : [true|false] tout sauvegarder [Défaut : false]
                     - Arg2 : Chemin du fichier
file               sortie vers fichier
                     - Arg1 : Chemin du fichier
file_ip            sortie vers stdout (ip uniquement)
                     - Arg1 : Chemin du fichier
file_mini          sortie vers fichier (ip et résultat uniquement)
                     - Arg1 : Chemin du fichier
file_resultonly    sortie vers fichier (résultat uniquement)
                     - Arg1 : Chemin du fichier
stdout             sortie vers stdout
stdout_ip          sortie vers stdout (IP uniquement)
stdout_mini        sortie vers stdout (ip et résultat uniquement)

Arguments des modules

Des arguments peuvent être fournis aux modules avec deux-points. Par exemple pour le module de sortie file :

./scannerl -m httpbg -d google.com -o file:/tmp/result

Format des résultats

Le résultat renvoyé par scannerl aux modules de sortie a la forme suivante :

{module, target, port, result}

Où

module : le module utilisé (atome Erlang)
target : IP ou nom d'hôte (chaîne ou adresse IPv4)
port : le port (entier)
result : voir ci-dessous

La partie result est de la forme :

{{status, type},Value}

Où {status, type} est l'un des tuples suivants :

{ok, result} : la prise d'empreinte de la cible a réussi
{error, up} : la prise d'empreinte n'a pas réussi mais la cible a répondu
{error, unknown} : la prise d'empreinte a échoué

Value est la valeur retournée - c'est soit un atome, soit une liste d'éléments

Étendre Scannerl

Scannerl a été conçu et implémenté en gardant la modularité à l'esprit. Il est facile d'y ajouter de nouveaux modules :

Module de prise d'empreinte : pour interroger un protocole ou service spécifique. Par exemple, le module fp_httpbg.erl permet de récupérer l'entrée server dans la réponse HTTP.
Module de sortie : pour sortir vers une base de données/système de fichiers spécifique ou formater le résultat dans un format spécifique. Par exemple, les modules out_file.erl et out_stdout.erl permettent respectivement de sortir vers un fichier ou vers stdout (comportement par défaut si non spécifié).

Pour créer de nouveaux modules, suivez simplement le comportement (fp_module.erl pour les modules de prise d'empreinte et out_behavior.erl pour les modules de sortie) et implémentez vos modules.

Les nouveaux modules peuvent être ajoutés soit au moment de la compilation, soit dynamiquement en tant que fichier externe.

Voir la page wiki pour plus d'informations.

Contribuer

N'hésitez pas à ouvrir une issue ou une PR.

Licence et droits d'auteur

Ce programme est un logiciel libre ; vous pouvez le redistribuer et/ou le modifier selon les termes de la GNU General Public License version 3 telle que publiée par la Free Software Foundation.

Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE ; sans même la garantie implicite de QUALITÉ MARCHANDE ou d'ADÉQUATION À UN USAGE PARTICULIER. Voir la GNU General Public License pour plus de détails.

Vous devriez avoir reçu une copie de la GNU General Public License avec ce programme. Sinon, consultez http://www.gnu.org/licenses/.

scannerl

Populaires