Honeypot mit Portspoof

Honeypot mit Portspoof, Einleitung

Portspoof ist ein ressourcenschonendes Programm, das einen interessanten Ansatz wählt, einen Server im Internet vor Angriffen zu schützen.
Der kleine Helfer öffnet einen einzigen Port und kann dabei für eine ganze Reihe von Diensten Signaturen emulieren.
In diesem Artikel wird Portspoof auf Port 4444 lauschen und mit Hilfe des Netfilters alle ansonsten geschlossenen Ports auf sich selbst umleiten. Auf jedem Port wird dann ein Dienst simuliert, um den Angreifer zu verwirren.
Portspoof verzögert den potentiellen Angriff enorm. Ein Port-Scan von mehreren Stunden wird hierbei zur echten Qual, reale Dienste tauchen in der Flut unter.

Worauf ich nicht weiter eingehe, aber auf keinen Fall unerwähnt lasse, ist die verführende Möglichkeit, sich bei einem Angriff nicht nur dumm zu stellen, sondern viel mehr sogar zurückzuschlagen; als erstaunlich erweist sich die Definition von Exploits als Antwort auf den vermeitlichen Angreifer. Aber Achtung: In Deutschland ist das Vorgehen nicht legal.
In der Standard-Konfiguration ist hierfür sogar ein Beispiel (für den Privatgebrauch…) zu sehen, der Callback allerdings auskommentiert. Nur so als Hinweis. :)

Portspoof enteignet sich beim Start seiner Privilegien und läuft fortan als Benutzer „daemon“.

Installation und Konfiguration

Zuerst die Installation der benötigten Werkzeuge und Bibliotheken zum Bauen:

sudo apt-get install libssl-dev build-essential

In dem Verzeichnis „~/build“ lege ich den Quell-Code als Git-Snapshot ab:

mkdir ~/build
cd ~/build
wget https://github.com/drk1wi/portspoof/archive/master.zip
unzip master.zip
rm master.zip

Die Installation erfolgt in „/usr/local“. Wer diesem Artikel nach arbeitet, sollte den Pfad nicht ändern:

cd portspoof-master
./configure && make && sudo make install

Die Konfiguration kann erst einmal deaktiviert werden. Die Beispiele bleiben erhalten, werden aber auskommentiert:

sed -i "s/^/#/" /usr/local/etc/portspoof.conf

Für die allgemeine Funktion von Portspoof wird die Konfiguration nicht gebraucht. Allerdings lässt sich hier beliebig einstellen, wie auf bestimmten Ports geantwortet wird (Stichwort: Exploits).
Die Beispiele sprechen für sich und sollten zumindest angeschaut werden. Hinweise zu „nützlichen“ Payloads etc. finden sich im Internet zur Genüge.

Init-Script mit Port-Umleitung

Portspoof kommt seit einigen Tagen mit einem nützlichen Init-Script, welches das Programm an das Interface mit dem meisten Traffic bindet.
Ich habe das Script etwas abgeändert, um das Interface manuell zu definieren (auf meinem Test-Server war das interne Interface leider das mit dem meisten Traffic) und habe zusätzlich die Ermittlung benutzter Ports verbessert:

Die neue Datei erstellen:

sudo nano /etc/init.d/portspoof

Und den Inhalt ergänzen („INTERFACE“ für das externe Interface anpassen!):

/etc/init.d/portspoof

#!/bin/bash
### BEGIN INIT INFO
# Provides: Portspoof
# Required-Start: $network $syslog
# Required-Stop: $network $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Description: Starts and stops Portspoof daemon and sets up iptables
### END INIT INFO

PATH=/sbin:/usr/sbin:/bin:/usr/bin:/usr/local/sbin:/usr/local/bin

##### CONFIG #####
INTERFACE="eth0"
PORTSPOOFCFG="/usr/local/etc/portspoof.conf"
PORTSPOOFSIG="/usr/local/etc/portspoof_signatures"
##################

function setUpIptables {
        runningPorts=(`netstat -an |grep -E "tcp\ ".*LISTEN|grep -v 127.0.0.1|awk '{print $4}'|sed s/"0.0.0.0:"//|sort -n`)
        if [ ${runningPorts[0]} -ne 1 ] && [ ${runningPorts[0]} -ne 2 ]; then
                underPort=$((${runningPorts[0]}-1))
                counter=0
                iptables -t nat -A PREROUTING -i $INTERFACE -p tcp -m tcp --dport 1:$underPort -j REDIRECT --to-ports 4444
                for i in "${runningPorts[@]}" ; do
                        counter=$(($counter+1))
                        upperPort=$(($i+1))
                        underPort=$((${runningPorts[$counter]}-1))
                        if [ $underPort -eq -1 ]; then
                                iptables -t nat -A PREROUTING -i $INTERFACE -p tcp -m tcp --dport $upperPort:65535 -j REDIRECT --to-ports 4444
                        else
                                iptables -t nat -A PREROUTING -i $INTERFACE -p tcp -m tcp --dport $upperPort:$underPort -j REDIRECT --to-ports 4444
                        fi
                done
        fi
}

function cleanUpIptables {
        IFS=$'\n'
        ipTableEntries=(`iptables -t nat -L PREROUTING  -n --line-numbers| grep "redir ports 4444"`)
        for i in "${ipTableEntries[@]}" ; do
                iptables -t nat -D PREROUTING 1
        done
}

case "$1" in
start)
        if pidof portspoof >/dev/null; then
                echo "Portspoof is already running! Exiting..."
                exit 1
        fi
        if [ $INTERFACE == "lo" ] ; then
                echo "WARNING: Setting the loopback interface up for PortSpoof."
        elif [ `grep $INTERFACE /proc/net/dev|awk '{print $2}'` -eq 0 ] ; then
                echo "WARNING: Specified interface is down or not flowing traffic."
        fi
        setUpIptables
        echo "Starting Portspoof..."
        portspoof -D -c $PORTSPOOFCFG -s $PORTSPOOFSIG
;;

stop)
        if pidof portspoof >/dev/null; then
                killall portspoof  >/dev/null
                echo "Portspoof stopped...s"
        else
                echo "Portspoof not running..."
		exit 0
        fi
        echo "Cleaning up iptables rules."
        cleanUpIptables
;;

*)
        echo "Usage: $0 {start|stop} interface"
        exit 1
esac

Die Datei als ausführbar markieren, den Dienst installieren und starten:

sudo chmod +x /etc/init.d/portspoof && sudo update-rc.d portspoof defaults && sudo service portspoof start

Funktion prüfen

Ob alle Ports umgeleitet werden, prüft folgender Befehl:

sudo iptables -L -v -n -t nat

Die Ausgabe sieht etwa so aus:

Chain PREROUTING (policy ACCEPT 294 packets, 20500 bytes)
pkts bytes target prot opt in out source destination
225 11512 REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:1:52 redir ports 4444
113 5728 REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:54:110 redir ports 4444
21 1068 REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:112:138 redir ports 4444
323 16620 REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:140:444 redir ports 4444
7361 378K REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:446:8080 redir ports 4444
219 11252 REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:8082:8199 redir ports 4444
1754 90064 REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:8201:32941 redir ports 4444
751 38476 REDIRECT tcp — eth0 * 0.0.0.0/0 0.0.0.0/0 tcp dpts:32943:65535 redir ports 4444

Ports, die auf meinem Test-Server tatsächlich in Benutzung sind, werden – wie zu sehen – übersprungen.
Wird Portspoof aktiv, loggt es in diesem Fall in das Syslog. In Zeile 59 des Init-Scripts, können die Start-Parameter angepasst werden. Zur Verfügung stehen folgende Optionen:

Usage: portspoof [OPTION]…

-i ip : Bind to a particular IP address
-p port : Bind to a particular PORT number
-s file_path : Portspoof service signature regex. file
-c file_path : Portspoof configuration file
-l file_path : Log port scanning alerts to a file
-f file_path : FUZZER_MODE – fuzzing payload file list
-n file_path : FUZZER_MODE – wrapping signatures file list
-1 FUZZER_MODE – generate fuzzing payloads internally
-2 switch to simple reply mode (doesn’t work for Nmap)!
-D run as daemon process
-d disable syslog
-v be verbose
-h display this help and exit

Ein Ausschnitt aus einem Scan mit Nmap:

Portspoof: Nmap Portscan
Portspoof: Nmap Portscan

5 Antworten auf “Honeypot mit Portspoof

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.