👩🏿‍🤝‍👩🏽 🦏 👃🏻 Schichtschutz. Fortinet & Flowmon-Netzwerke 🧛🏼 🅿️ 🆑

In letzter Zeit reifen immer mehr Unternehmen zu einem abgestuften Schutz, wenn eine Lösung den Netzwerkumfang schützt, die anderen Endstationen, die dritte das Netzwerk ständig überwacht, Anomalien erkennt, die vierte das Netzwerk nach offenen Schwachstellen durchsucht und so weiter. Gleichzeitig wächst der Bedarf an verschiedenen Integrationen und es ist gut, wenn sie sofort einsatzbereit sind, dh Sie müssen keine komplexen Skripte schreiben.

Wir haben kürzlich über einen neuen TS Solution-Service geschrieben - CheckFlow . Dies ist eine kostenlose Prüfung des Netzwerkverkehrs (sowohl intern als auch extern). Flowmon- Eine Telemetrieanalyse- und Netzwerküberwachungslösung, die sowohl Netzwerkadministratoren als auch Sicherheitspersonal wertvolle Informationen liefert: Anomalien, Scans, unzulässige Server, Schleifen, unzulässige Interaktionen, Netzwerkeinbrüche, Zero-Day-Angriffe und vieles mehr.

Ich empfehle außerdem, auf Artikel 9 der allgemeinen Netzwerkprobleme zu verweisen, die mithilfe der Analyse mit Flowmon erkannt werden können .

Integration Flowmon & FortiGate

Die Integration wurde in unserem Blog erwähnt . Im Allgemeinen besteht es darin, dass die Firewall der nächsten Generation (wie FortiGate) den Perimeter schützt und Flowmon die Netzwerkinfrastruktur überwacht, wodurch der Kunde die vollständige Sichtbarkeit des Netzwerks erhält. Flowmon kann jedoch Angriffe und Anomalien nur erkennen, aber nicht verhindern, da es mit Telemetrie arbeitet, die mit Netflow / IPFIX ermittelt wird. Eine NGFW- oder NAC-Lösung (Network Access Control) kann verwendet werden, um einen verdächtigen oder infizierten Host unter Quarantäne zu stellen.

Daher hat der Anbieter Flowmon ein Shell-Skript veröffentlicht, das als Reaktion auf Sicherheitsvorfälle die folgenden Aktionen für FortiGate ausführen kann:

Blockieren Sie den infizierten Host anhand der IP-Adresse (IP Ban).
Quarantäne des Hosts mit FortiClient unter MAC-Adresse (Quarantäne mit FortiClient);
Dynamische Quarantäne für alle infizierten Hosts nach MAC-Adressen (Access Layer Quarantine);

Anpassung

1. Ich werde nicht auf die Details des Skripts selbst eingehen, sondern nur sagen, dass es zwei Versionen gibt: eine für FortiGate über Version 6.4.0, die andere für frühere Versionen. Der Code wird unten angezeigt.

Skriptcode für FortiGate unter Version 6.4.0

#!/bin/bash
# Author: Jiri Knapek
# Description: This script is to quarantine IP on Fortigate Firewalls for FortiOS before 6.4.
# Version: 1.3
# Date: 8/3/2020
# Debug 1 = yes, 0 = no
DEBUG=0

[ $DEBUG -ne 0 ] && echo `date` "Starting mitigation script" >> /tmp/fg-mitigation.log

# Management IP/hostname of Firewall/ Core device
IP='10.10.30.210'
API_KEY='fp8114zdNpjp8Qf8zN4Hdp57dhgjjf'
# Default timeout for action is
# value in seconds or never
TIMEOUT='300'

# FortiGate API URL
BAN="https://$IP/api/v2/monitor/user/banned/add_users?access_token=$API_KEY"

function usage {
    cat << EOF >&2
usage: mitigation_script.sh <options>

Optional:
    --fw        IP / hostname of Fortigate firewall
	--timeout	Timeout in seconds
	--key		FortiGate API key
    
EOF
    exit
}      

params="$(getopt -o f:t:k:h -l fw:,timeout:,key:,help --name "mitigation_script.sh" -- "$@")"

[ $DEBUG -ne 0 ] && echo `date` "Params $params" >> /tmp/fg-mitigation.log

if [ $? -ne 0 ]
then
    usage
    [ $DEBUG -ne 0 ] && echo `date` "Got to usage." >> /tmp/fg-mitigation.log
fi

eval set -- "$params"
unset params

while true
do
    case $1 in
        -f|--fw)
            IP=("${2-}")
            shift 2
            ;;
        -k|--key)
            API_KEY=("${2-}")
            shift 2
            ;;
        -t|--timeout)
            TIMEOUT=("${2-}")
            shift 2
            ;;
        -h|--help)
            usage
            ;;
        --)
            shift
            break
            ;;
        *)
            usage
            ;;
    esac
done

# we dont support any other args
[ $# -gt 0 ] && {
    usage
    [ $DEBUG -ne 0 ] &&  echo `date`  "INFO: Too many arguments. Got to usage." >> /tmp/fg-mitigation.log 2>&1
}

cat << EOF >&2
-----  My params are ------------------
FW = $IP
API KEY = $API_KEY
TIMEOUT = $TIMEOUT
TOKEN = $TOKEN
---------------------------------------
EOF

[ $DEBUG -ne 0 ] && cat >> /tmp/fg-mitigation.log << EOF >&2
-----  My params are ------------------
FW = $IP
API KEY = $API_KEY
TIMEOUT = $TIMEOUT
TOKEN = $TOKEN
---------------------------------------
EOF

echo "Stdin read started..." >&2

LINE_NUM=1
array=()
while read line
do
    IFS=$'\t'
    array=($line)
    echo "$LINE_NUM - ID ${array[0]} - type ${array[4]} - source ${array[10]}"
    [ $DEBUG -ne 0 ] &&  echo "$LINE_NUM - ID ${array[0]} - type ${array[4]} - source ${array[10]}" >> /tmp/fg-mitigation.log 2>&1
    
    LINE_NUM=$((LINE_NUM+1))

    # BAN the source IP of the event
    if [ $DEBUG -ne 0 ]; then
        /usr/bin/curl -k -X POST -H "Content-Type": "application/json" --data "{ \"ip_addresses\": [\"${array[10]}\"], \"expiry\": $TIMEOUT}" $BAN >> /tmp/fg-mitigation.log 2>&1
    else
        /usr/bin/curl -k -X POST -H "Content-Type": "application/json" --data "{ \"ip_addresses\": [\"${array[10]}\"], \"expiry\": $TIMEOUT}" $BAN
    fi

done < /dev/stdin

echo "---- Everything completed ----"
[ $DEBUG -ne 0 ] &&  echo `date` "---- Everything completed ----" >> /tmp/fg-mitigation.log

Skriptcode für FortiGate Version 6.4.0 und höher

#!/bin/bash

# Author: Jiri Knapek
# Description: This script is to quarantine IP or MAC on Fortigate Firewalls and Security Fabric
# Version: 2.0
# Date: 7/8/2020
# Debug 1 = yes, 0 = no
DEBUG=0

[ $DEBUG -ne 0 ] && echo `date` "Starting mitigation script" >> /tmp/fg-mitigation.log

# Flowmon API access
USER='admin'
PASS='admin'
# Management IP/hostname of Firewall/ Core device
IP='10.10.30.210'
WEBHOOK='FlowmonADS'
API_KEY='s4mQH9j88kt1hkd4dsyjtsg8thghc4'
MAC=0

URL="https://$IP/api/v2/monitor/system/automation-stitch/webhook/$WEBHOOK"

function usage {
    cat << EOF >&2
usage: mitigation_script.sh <options>

Optional:
	--fw        IP / hostname of Fortigate firewall
	--user      Username to be used for Flowmon API authentication
	--pass      Password for the user
	--key	    FortiGate API key
	--mac	    Add this parameter to enable MAC mitigation

EOF
    exit
}



params="$(getopt -o f:u:p:k:h:m: -l fw:,key:,pass:,user:,help,mac: --name "mitigation_script.sh" -- "$@")"

if [ $? -ne 0 ]
then
    usage
    [ $DEBUG -ne 0 ] && echo `date` "Got to usage." >> /tmp/fg-mitigation.log
fi

[ $DEBUG -ne 0 ] && echo `date` "Params $params" >> /tmp/fg-mitigation.log

eval set -- "$params"
unset params

while true
do
    case $1 in
        -f|--fw)
            IP=("${2-}")
            shift 2
            ;;
        -k|--key)
            API_KEY=("${2-}")
            shift 2
            ;;
        -p|--pass)
            PASS=("${2-}")
            shift 2
            ;;
        -u|--user)
            USER=("${2-}")
            shift 2
            ;;
        -m|--mac)
            MAC=1
            shift 2
            ;;
        -h|--help)
            usage
            ;;
        --)
            shift
            break
            ;;
        *)
            usage
            ;;
    esac
done

# we dont support any other args
[ $# -gt 0 ] && {
    usage
    [ $DEBUG -ne 0 ] &&  echo `date`  "INFO: Got to usage." >> /tmp/fg-mitigation.log 2>&1
}

if [ $MAC -ne 0 ];
then
    # authenticate to localhost
    OUTPUT="$(/usr/bin/curl "https://localhost/resources/oauth/token" -k -d 'grant_type=password' -d 'client_id=invea-tech' -d "username=$USER" -d "password=$PASS")"
    TOKEN=""

    echo "${OUTPUT}" > /tmp/access_token.json

    if [[ $OUTPUT == *"access_token"* ]]; then
        [ $DEBUG -ne 0 ] && echo `date` "Successfully authenticated to Flowmon Collector!" >> /tmp/fg-mitigation.log
        TOKEN="$(cat /tmp/access_token.json | jq '.access_token')"
        TOKEN="${TOKEN//\"}"
        TOKEN="Authorization: bearer "$TOKEN
    fi
fi

cat << EOF >&2
-----  My params are ------------------
FW = $IP
API KEE = $API_KEY
URL = $URL
MAC = $MAC
TOKEN = $TOKEN
---------------------------------------
EOF

[ $DEBUG -ne 0 ] && cat >> /tmp/fg-mitigation.log << EOF >&2
-----  My params are ------------------
FW = $IP
API KEE = $API_KEY
URL = $URL
MAC = $MAC
TOKEN = $TOKEN
---------------------------------------
EOF

echo "Stdin read started..." >&2

LINE_NUM=1
array=()
while read line
do
    IFS=$'\t'
    array=($line)
    echo "$LINE_NUM - ID ${array[0]} - type ${array[4]} - source ${array[10]}"
    [ $DEBUG -ne 0 ] &&  echo "$LINE_NUM - ID ${array[0]} - type ${array[4]} - source ${array[10]}" >> /tmp/fg-mitigation.log 2>&1

    # Call a webhook
    if [ $MAC -ne 0 ];
    then
        MAC_ADDR="$(/usr/bin/curl "https://localhost/rest/ads/event/${array[0]}" -G -k -H "$TOKEN"  | jq '.macAddress')"
        if [ $DEBUG -ne 0 ]; then
            /usr/bin/curl -k -X POST -H "Authorization: Bearer $API_KEY" --data "{ \"srcip\": \"${array[10]}\", \"mac\": $MAC_ADDR, \"fctuid\": \"A8BA0B12DA694E47BA4ADF24F8358E2F\"}" $URL >> /tmp/fg-mitigation.log 2>&1
        else
            /usr/bin/curl -k -X POST -H "Authorization: Bearer $API_KEY" --data "{ \"srcip\": \"${array[10]}\", \"mac\": $MAC_ADDR, \"fctuid\": \"A8BA0B12DA694E47BA4ADF24F8358E2F\"}" $URL
        fi
    else
        if [ $DEBUG -ne 0 ]; then
            /usr/bin/curl -k -X POST -H "Authorization: Bearer $API_KEY" --data "{ \"srcip\": \"${array[10]}\",  \"fctuid\": \"A8BA0B12DA694E47BA4ADF24F8358E2F\"}" $URL >> /tmp/fg-mitigation.log 2>&1
        else
            /usr/bin/curl -k -X POST -H "Authorization: Bearer $API_KEY" --data "{ \"srcip\": \"${array[10]}\",  \"fctuid\": \"A8BA0B12DA694E47BA4ADF24F8358E2F\"}" $URL
        fi
    fi

    LINE_NUM=$((LINE_NUM+1))

done < /dev/stdin

echo "---- Everything completed ----"
[ $DEBUG -ne 0 ] &&  echo `date` "---- Everything completed ----" >> /tmp/fg-mitigation.log

2. Ich verwende FortiGate Version 6.4.2. Im Skript selbst sollten Sie in den Zeilen 13 und 14 Ihren Benutzernamen und Ihr Kennwort zu Flowmon hinzufügen sowie den API-Schlüssel aus Abschnitt 5 , die FortiGate-IP-Adresse und den Webhook- Namen (den Namen des Automatisierungsmechanismus) hinzufügen .

3. In der Weboberfläche sollte FortiGate unter Security Fabric> Automation> New Automation Stitch hinzugefügt werden . Name - FlowmonADS , Status - Aktiviert , Auslöser - Eingehender Webhook , Aktion - IP-BAN, Quarantäne der Zugriffsebene, Quarantäne mit FortiCLient (falls verwendet).

4. Dann sehen Sie ein Fenster wie im folgenden Screenshot mit der FortiGate-URL für diesen Webhook, einem Feld für die Admin-Token-API (wir werden es später erstellen) und einer Beispielanforderung.

5. Als Nächstes müssen Sie ein Administratorprofil erstellen, das über Rechte verfügt. Registerkarte System> Admin-Profile> Neu erstellen .

6. Weisen Sie Security Fabric - Lesen, Firewall - Lesen / Schreiben, System - Lesen / Schreiben, Sicherheitsprofil - Lesen / Schreiben die Rechte zu .

7. Erstellen Sie anschließend auf der Registerkarte System> Administratoren einen neuen Administrator mit dem Profil api_admin . Darüber hinaus können Sie im Feld Vertrauenswürdige Hosts vertrauenswürdige Netzwerke oder die IP-Adresse des Flowmon angeben.

Hinweis : Parameter für vertrauenswürdige HostsMit dieser Option können Sie IP-Segmente fest codieren , von denen api_admin API-Anforderungen an FortiGate senden kann. Dies ist daher die empfohlene Einstellung.

8. Nach diesem Schritt wird ein API-Schlüssel generiert , der zusammen mit anderen in Absatz 1 und im Webhook in Absatz 4 angegebenen Daten zum ursprünglichen Skript hinzugefügt werden muss.

9. Wechseln Sie anschließend auf der Registerkarte System> System im Modul ADS (Anomaly Detection System) zu Flowmon Einstellungen> Benutzerdefinierte Skripte> Neues benutzerdefiniertes Skript> Datei mit der Erweiterung .sh auswählen . Als Nächstes müssen Sie die Parameter --fw (FortiGate-IP-Adresse), --key (API-Token), --mac (nichts), --pass (Kennwort von REST API Flowmon), --user (REST API-Benutzer Flowmon) festlegen. Klicken Sie dann auf die Schaltfläche Speichern .

Hinweis : --pass und --user sind standardmäßig admin / admin .

10. Der letzte Schritt besteht darin, die Ereignisse festzulegen, für die der angegebene Programmcode ausgelöst wird. Ändern Sie auf derRegisterkarte Einstellungen> Verarbeitung> Benutzerdefinierte Skripte> Neue Aktion für benutzerdefinierte Skripte den Parameter Perspektive in Sicherheitsprobleme , legen Sie die zu meldende Mindestpriorität fest und überprüfen Sie die Parameter aus dem vorherigen Schritt.

Prüfen

Wenn auf Flowmon ein Ereignis aus der Kategorie Sicherheitsprobleme ausgelöst wird, blockiert FortiGate diesen Host. Darüber hinaus können Sie im praktischen Quarantäne-Widget potenziell infizierte Hosts anzeigen, indem Sie hineinfallen. Oder über den Befehl in der CLI- Diagnose-Benutzerquarantäneliste .

Nach der Informationssicherheit kann der Administrator den Vorfall mithilfe von Flowmon ADS untersuchen und den ursprünglich infizierten Host identifizieren, über den sich die Malware verbreitet, sowie deren Verhalten. Mithilfe von Lösungen zum Schutz von Arbeitsstationen, z. B. FortiEDR, können Sie die Maschine heilen und eine Untersuchung eines Sicherheitsvorfalls durchführen.

Um einen Host aus der Quarantäne zu entfernen, wählen Sie ihn aus und klicken Sie auf die Schaltfläche Löschen oder Alle entfernenum alle Hosts aus der Quarantäne zu entfernen.

Fazit

Der allgegenwärtige Ansatz zur Tiefenverteidigung zwingt viele Anbieter dazu, sich sofort in andere Lösungen zu integrieren. In diesem Artikel wurde beschrieben, wie Flowmon und FortiGate integriert, konfiguriert und demonstriert werden.

In naher Zukunft planen wir ein Webinar, in dem wir detaillierter erläutern, wie sich Flowmon und Fortinet ergänzen, wie sie sich integrieren und auch Ihre Fragen beantworten. Die Registrierung ist hier verfügbar .

Wenn Sie an diesem Thema interessiert sind, bleiben Sie auf unseren Kanälen (Telegramm, Facebook, VK, TS Solution Blog) auf dem Laufenden!

Schichtschutz. Fortinet & Flowmon-Netzwerke

Integration Flowmon & FortiGate

Anpassung

Prüfen

Fazit

More articles: