Wie installiert und konfiguriert man Snort auf Ubuntu Linux?

Veröffentlicht am: 25 November 2024

.

20 Minuten Lesezeit

.

Für die englische version

SNORT® Intrusion Prevention System, das weltweit führende Open-Source-IPS, hat im Januar 2021 offiziell Snort 3 veröffentlicht. Snort 3 ist ein umfassendes Upgrade, das Verbesserungen und neue Funktionen umfasst, die zu einer verbesserten Leistung, schnelleren Verarbeitung, besserer Skalierbarkeit für Ihr Netzwerk und mehr als 200 Plugins führen, mit denen Benutzer eine benutzerdefinierte Netzwerk-Konfiguration erstellen können.

Um Ihren mission-kritischen Ubuntu-Server oder das Netzwerk dahinter vor verschiedenen Arten von Cyberangriffen zu schützen, können Sie Ihren Linux-Server ganz einfach in eine leistungsstarke Next-Generation-Firewall umwandeln. Um dies zu erreichen, müssen Sie die folgenden Schritte ausführen:

1. Installieren und konfigurieren Sie die UFW-Firewall auf Ihrem Ubuntu-Server zum Paketfiltering

2. Zenarmor installieren und konfigurieren Next-Generation-Firewall-Engine für Webfilterung und Anwendungskontrolle

3. Installieren und konfigurieren Sie Snort zur Erkennung und Verhinderung von Netzwerkangriffen

In diesem Tutorial werden wir erklären, wie man Snort 3 auf einem Ubuntu 22.04 Linux-Server installiert und konfiguriert. Sie können Snort auf einem Ubuntu-Server installieren, indem Sie die nächsten 3 Hauptschritte befolgen:

1. Aktualisieren Sie den Ubuntu-Server
2. Abhängigkeiten installieren
3. Snort aus dem Quellcode herunterladen und installieren

Um Snort IPS auf Ihrem Ubuntu-Server zu konfigurieren, um Ihr Netzwerk zu schützen, folgen Sie den nächsten Hauptschritten:

1. Konfigurieren der Netzwerkschnittstellen
2. Konfiguration der Snort-Community- und lokalen Regelsets
3. Installation von Snort OpenAppID
4. Konfiguration des Snort-Loggings
5. Snort als Dienst ausführen

Was ist der Unterschied zwischen Snort 2 und Snort 3?

Snort 3 bringt mehrere Verbesserungen mit sich, um das Schreiben von Regeln zu vereinfachen und die Einheitlichkeit der Regel-Syntax zu erhöhen, während gleichzeitig die Robustheit und Granularität der Erkennung verbessert wird.

Es gibt mehrere Vorteile, von Snort 2 auf Snort 3 umzusteigen. Zu den wichtigsten neuen Funktionen und Verbesserungen in Snort 3 gehören:

• Unterstützung für mehrere Threads zur Paketverarbeitung, was mehr RAM für die Paketverarbeitung freigibt.

• Neue Regel-Syntax und Regel-Parser.

• Zugriff auf fast zweihundert Plugins

• Nutzung einer gemeinsam genutzten Konfigurations- und Attributtabelle.

• Verbesserte Regeln für gemeinsam genutzte Objekte, einschließlich der Möglichkeit, Regeln für Zero-Day-Schwachstellen hinzuzufügen

• Überarbeitete TCP-Verarbeitung.

• Neue Regelkommentare und Anmerkungen, die in der Regelung selbst enthalten sind.

• Neue Leistungsanzeige

Die wichtigsten Unterschiede zwischen Snort 2 und Snort 3 sind in der folgenden Tabelle aufgeführt.

Funktion	Snort 2	Snort 3
Paket-Threads	Einer pro Prozess	Beliebige Anzahl pro Prozess
Konfigurationsspeicher	N Prozesse * M GB verwenden	M GB insgesamt, mehr für Pakete
Konfigurationsneuladen	N Prozesse, langsamer	Ein Thread, der auf separate Kerne festgelegt werden kann
Plugins	Begrenzt auf Preprocs und Ausgaben	Vollständiges Pluginsystem mit mehr als 200 Plugins
DAQ	2.X, bis zum Abschluss ausführen	3.X, Vektoreingabe, mehrere ausstehende Pakete
DAQ-Module	Nur Legacy-Module	Gestapelte Module, IOCTLs, Datei-, Socket- und Textmodule
PCAP-Lesevorgangsgeschwindigkeit	X Mbit/s für Max-Detect	2X mit AC, 4X mit Hyperscan
IP-Schichten	Maximal zwei	Beliebige und konfigurierbare Grenzen
IP-Reputation	Komplex mit gemeinsamem Speicher	Vereinfachter Prozessspeicher
Stream TCP	Komplexe Implementierung	Neue und verbesserte Implementierung
Dienst-Erkennung	Nur AppID, Portkonfigurationen erforderlich	Automatische Erkennung, die meisten Portkonfigurationen optional
HTTP-Inspektor	Teilweise zustandsbehaftet	Vollständig zustandsbehaftet
Port-Scan-Erkennung	Nur hohe, mittlere und niedrige Schwellenwerte	Vollständig konfigurierbare Erkennungsschwellenwerte
Konfigurationsanalyse	Einen Fehler melden und beenden	Alle Fehler melden
Befehlszeile	Teilweise Überschneidung mit Konfigurationsdatei	Setzen, um jede Konfigurationsdatei von der Befehlszeile zu überschreiben
Standardkonfiguration	Komplex, benötigt Anpassungen	Vereinfachte, effektive
Beispiele für Richtlinien	Keine	Anpassungen, um alle Standard-Talos-Richtlinien zu erfüllen
Richtlinienbindungen	Eine Ebene	Verschachtelt
Regelsyntax	Inkonsistent und erfordert Zeilenumbrüche	Einheitliches System mit beliebigem Leerraum
Regel-Parsing	Fehlerhaft mit begrenzten Warnungen	Robust mit zahlreichen optionalen Warnungen
Regelkommentare	Nur Kommentare	#, #begin/#end-Marken, C-Stil und rem-Optionen
Alarmdateiregeln	Nein	Ja
Alarmdienstregeln	Nein	Ja
Schnellmuster-Puffer	Sechs verfügbar	14 verfügbar
SO-Regelfunktionen	Eingeschränkte Funktionalität	Wahre Obermenge der Textregeln
Einfache SO-Regeln	Nein	Ja
Dump eingebaute Stubs	Nein (nur SO-Stubs)	Ja
Laufzeit-Tracking	Nein (nur Debug-Tracking und verschiedene Logs)	Ja
Dokumentation	LaTeX-basierte PDF, READMEs	ASCII-Dokumente, Text, HTML und PDFs
Quellcode	470.000 Zeilen C, mit einem Durchschnitt von 400 Zeilen pro Datei	389.000 Zeilen C++, mit einem Durchschnitt von 200 Zeilen pro Datei
Verteilung	Snort.org-Tarballs, mit Updates alle sechs Monate	GitHub-Repo, mit Updates alle zwei Wochen

Tabelle 1. Snort 2 vs Snort 3

info

Snort 3 unterscheidet sich erheblich von der Snort 2.9.9.x-Serie. Die Konfigurations- und Regeldateien zwischen den beiden Versionen sind unterschiedlich und inkompatibel. Mit dem mitgelieferten Befehl snort2lua können Snort 2-Konfigurations- und Regeldateien in das Snort 3-Format konvertiert werden.

Wie installiert man Snort 3 auf Ubuntu 22.04?

Die Installation von Snort ist ziemlich einfach und unkompliziert, da das Snort-Paket in den Repositories der meisten Linux-Distributionen verfügbar ist. Das Paket kann sowohl aus den Quell- als auch aus den Software-Repositories installiert werden.

Zum Zeitpunkt dieses Schreibens enthält das Standard-Universum-Repository von Ubuntu 22.04 Snort 2.9. Um das verfügbare Snort-Paket in den Ubuntu-Repositories anzuzeigen, führen Sie den folgenden Befehl aus:

apt-cache policy snort

Siehe ähnliche Ausgabe unten:

snort:
Installed: (none)

Candidate: 2.9.15.1-6build1

Version table:

2.9.15.1-6build1 500

500 http://tr.archive.ubuntu.com/ubuntu jammy/universe amd64 Packages

Die Installation und Konfiguration von Snort 3 auf Ubuntu 22.04 erfordert den Bau aus dem Quellcode. Sie können die folgenden Schritte befolgen, um Snort 3 auf Ihrem Ubuntu 22.04-Server als Systemdienst zu installieren und zu konfigurieren.

1. Aktualisieren Sie den Ubuntu-Server

2. Abhängigkeiten installieren

3. Snort aus dem Quellcode herunterladen und installieren

1. Aktualisieren Sie den Ubuntu-Server

Um sicherzustellen, dass Ihr Ubuntu 22.04-Server auf dem neuesten Stand ist und die aktuellste Paketliste hat, führen Sie den folgenden Befehl aus:

sudo apt-get update && sudo apt-get dist-upgrade -y

2. Abhängigkeiten installieren

Vor dem Build müssen eine Reihe von Build-Tools und Abhängigkeiten auf Ubuntu 22.04 installiert werden, um einen erfolgreichen Build und die Installation von Snort 3 zu gewährleisten.

1. Führen Sie den folgenden Befehl aus, um die Paketabhängigkeiten für die Installation von Snort 3 auf einem Ubuntu 22.04-Server zu installieren:

   sudo apt install build-essential libpcap-dev libpcre3-dev libnet1-dev zlib1g-dev luajit hwloc libdnet-dev libdumbnet-dev bison flex liblzma-dev openssl libssl-dev pkg-config libhwloc-dev cmake cpputest libsqlite3-dev uuid-dev libcmocka-dev libnetfilter-queue-dev libmnl-dev autotools-dev libluajit-5.1-dev libunwind-dev libfl-dev -y

2. Wir werden viele Quell-Tarballs und andere Dateien herunterladen, und wir möchten sie in einem einzigen Ordner aufbewahren. Erstellen Sie ein Verzeichnis und ändern Sie Ihren Standort, indem Sie die folgenden Befehle ausführen:

   mkdir ~/snort_src && cd ~/snort_src

3. Snort DAQ (Data Acquisition-Bibliothek) ist nicht in den üblichen Ubuntu-Repositories enthalten. Daher muss es aus dem Quellcode kompiliert und installiert werden. Laden Sie die neueste Snort DAQ herunter und installieren Sie sie, indem Sie die folgenden Befehle ausführen:

   git clone https://github.com/snort3/libdaq.git
   cd libdaq
   ./bootstrap
   	./configure
   make
   	sudo make install

4. Um Googles thread-caching malloc, Tcmalloc, einen für hochgradige Parallelität optimierten Speicher-Allocator, der eine schnellere Leistung auf Kosten eines erhöhten Speicherverbrauchs bietet (dies ist eine empfohlene, aber optionale Abhängigkeit), auszuführen, geben Sie die folgenden Befehle ein:

   cd ../
   wget https://github.com/gperftools/gperftools/releases/download/gperftools-2.9.1/gperftools-2.9.1.tar.gz
   tar xzf gperftools-2.9.1.tar.gz
   cd gperftools-2.9.1/
   ./configure
   make
   sudo make install

3. Snort aus dem Quellcode herunterladen und installieren

Jetzt, da alle Voraussetzungen erfüllt sind, können wir Snort 3 auf Ubuntu 22.04 herunterladen und installieren. Sie können die unten angegebenen Schritte befolgen, um Snort 3.1.39.0, die neueste Version zum Zeitpunkt des Schreibens, herunterzuladen und einzurichten.

1. Um die neueste Version des Snort-Tarballs von der Releases-Seite herunterzuladen, führen Sie die folgenden Befehle aus:

   	cd..
   	wget https://github.com/snort3/snort3/archive/refs/heads/master.zip
   	unzip master.zip
   	cd snort3-master
   	./configure_cmake.sh --prefix=/usr/local --enable-tcmalloc
   tipp

   Wenn Sie daran interessiert sind, zusätzliche Kompilierungsfunktionen zu aktivieren, wie die Fähigkeit, große (über 2 GB) PCAP-Dateien zu verarbeiten oder die neue Befehlszeilen-Shell, führen Sie ./configure cmake.sh --help aus, um alle optionalen Funktionen aufzulisten, und fügen Sie diese dann dem oben gezeigten Befehl ./configure cmake.sh hinzu.

   Sie werden ähnliche Ausgaben unten sehen:

   ------------------------------------------------------
   snort version 3.1.39.0
   Install options:
   prefix: /usr/local
   includes: /usr/local/include/snort
   plugins: /usr/local/lib/snort
   Compiler options:
   CC: /usr/bin/cc
   CXX: /usr/bin/c++
   CFLAGS: -fvisibility=hidden -DNDEBUG -g -ggdb -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free -O2 -g -DNDEBUG
   CXXFLAGS: -fvisibility=hidden -DNDEBUG -g -ggdb -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-free -O2 -g -DNDEBUG
   EXE_LDFLAGS:
   MODULE_LDFLAGS:
   Feature options:
   DAQ Modules: Static (afpacket;bpf;dump;fst;gwlb;nfq;pcap;savefile;trace)
   libatomic: System-provided
   Hyperscan: OFF
   ICONV: ON
   Libunwind: ON
   LZMA: ON
   RPC DB: Built-in
   SafeC: OFF
   TCMalloc: ON
   JEMalloc: OFF
   UUID: ON
   -------------------------------------------------------
   -- Configuring done
   -- Generating done
   -- Build files have been written to: /home/alp/snort_src/snort3-master/build

2. Um zum Build-Verzeichnis zu navigieren und Snort 3 auf Ubuntu 22.04 vor dem Kompilieren zu installieren, führen Sie die folgenden Befehle aus:

   cd build
   make
   sudo make install

   Dies dauert je nach Hardware etwa eine halbe Stunde. Snort ist jetzt unter /usr/local/ installiert.

3. Nach Abschluss der Installation aktualisieren Sie die gemeinsam genutzten Bibliotheken, indem Sie den nächsten Befehl ausführen. Andernfalls erhalten Sie einen Fehler, wenn Sie versuchen, Snort auszuführen:

   sudo ldconfig

4. Um zu überprüfen, dass Snort korrekt läuft, übergeben wir der Snort-Executable das -V-Flag:

   snort -V

   Sie sollten eine Ausgabe sehen, die der folgenden ähnlich ist:

   ,,_ -*> Snort++ <*-
   o" )~ Version 3.1.39.0
   '''' By Martin Roesch & The Snort Team
   http://snort.org/contact#team
   Copyright (C) 2014-2022 Cisco and/or its affiliates. All rights reserved.
   Copyright (C) 1998-2013 Sourcefire, Inc., et al.
   Using DAQ version 3.0.9
   Using LuaJIT version 2.1.0-beta3
   Using OpenSSL 3.0.2 15 Mar 2022
   Using libpcap version 1.10.1 (with TPACKET_V3)
   Using PCRE version 8.39 2016-06-14
   Using ZLIB version 1.2.11
   Using LZMA version 5.2.5

5. Um Ihre Snort-Installation mit der Standardkonfigurationsdatei zu testen, führen Sie den folgenden Befehl aus:

   snort -c /usr/local/etc/snort/snort.lua

   Sie sollten eine Ausgabe sehen, die der folgenden ähnlich ist:

   --------------------------------------------------
   o")~ Snort++ 3.1.39.0
   --------------------------------------------------
   Loading /usr/local/etc/snort/snort.lua:
   Loading snort_defaults.lua:
   Finished snort_defaults.lua:
   ssh
   hosts
   host_cache
   pop
   so_proxy
   stream_tcp
   mms
   smtp
   gtp_inspect
   packets
   dce_http_proxy
   stream_icmp
   normalizer
   ips
   network
   binder
   wizard
   appid
   file_id
   stream_udp
   http2_inspect
   http_inspect
   ftp_data
   search_engine
   ftp_server
   port_scan
   dce_http_server
   dce_smb
   dce_tcp
   netflow
   iec104
   cip
   telnet
   ssl
   sip
   rpc_decode
   modbus
   host_tracker
   stream_user
   stream_ip
   process
   back_orifice
   classifications
   dnp3
   active
   trace
   ftp_client
   decode
   alerts
   stream
   daq
   references
   arp_spoof
   output
   dns
   dce_udp
   imap
   file_policy
   s7commplus
   stream_file
   Finished /usr/local/etc/snort/snort.lua:
   Loading file_id.rules_file:
   Loading file_magic.rules:
   Finished file_magic.rules:
   Finished file_id.rules_file:
     --------------------------------------------------
   ips policies rule stats
   id loaded shared enabled file
   0 203 0 203 /usr/local/etc/snort/snort.lua
     --------------------------------------------------
   rule counts
   total rules loaded: 203
   text rules: 203
   option chains: 203
   chain headers: 1
     --------------------------------------------------
   service rule counts to-srv to-cli
   file_id: 203 203
   total: 203 203
     --------------------------------------------------
   fast pattern groups
   to_server: 1
   to_client: 1
     --------------------------------------------------
   search engine
   instances: 2
   patterns: 406
   pattern chars: 2436
   num states: 1724
   num match states: 364
   memory scale: KB
   total memory: 66.7676
   pattern memory: 18.2363
   match list memory: 26.5938
   transition memory: 21.6875
     --------------------------------------------------
   pcap DAQ configured to passive.
   Snort successfully validated the configuration (with 0 warnings).
     o")~ Snort exiting

6. Snort bietet mehrere Optionen, um weitere Hilfe zu erhalten. Um die Snort-Hilfsoptionen anzuzeigen, führen Sie den nächsten Befehl aus:

   snort --help

   Um die Schnellhilfe für die Snort-Befehlszeilenoptionen anzuzeigen, führen Sie den folgenden Befehl aus:

   snort -?
   info

   Debian-basierte Linux-Distributionen, wie zum Beispiel Ubuntu 22.04, werden mit dem vorinstallierten "apt"-Paketmanager geliefert. Im Wesentlichen ist es ein auf der Befehlszeile basierendes Dienstprogramm, das verwendet wird, um aufgabenbezogene Aufgaben wie Installation, Aktualisierung und Deinstallation durchzuführen. Führen Sie die folgenden Befehle aus, um Snort auf Ubuntu 22.04 mit dem apt-Manager zu installieren:

   sudo apt update
   sudo apt install snort -y

So konfigurieren Sie Snort 3 auf Ubuntu 22.04

Es gibt drei Konfigurationsoptionen für Snort: Sniffer-Modus, Paket-Logger-Modus und Netzwerk-IDS-Modus. Wir werden Snort in diesem Abschnitt für den Network IDS-Modus einrichten.

Sie können die Snort 3 IPS-Software auf Ihrem Ubuntu 22.04-Server ganz einfach konfigurieren, indem Sie die 5 Schritte in diesem Abschnitt befolgen:

1. Konfigurieren der Netzwerkschnittstellen
2. Konfiguration der Snort-Community- und lokalen Regelsets
3. Installation von Snort OpenAppID
4. Konfigurieren des Snort-Loggings
5. Snort als Dienst ausführen

1. Konfiguration von Netzwerkschnittstellen

Moderne Netzwerkkarten verwenden Offloading (zum Beispiel LRO), um die Neuassemblierung von Netzwerkpaketen in der Hardware anstelle von Software durchzuführen. In den meisten Fällen ist dies wünschenswert, da es die Systembelastung verringert. Für ein NIDS müssen wir LRO und GRO deaktivieren, da sie die Trunkierung längerer Pakete verursachen. Wir müssen einen systemD-Dienst einrichten, um diese Werte zu ändern.

1. Bestimmen Sie den/die Namen der Schnittstelle(n), auf der/die Snort lauschen wird, indem Sie den folgenden Befehl ausführen:

   ip address show

   Dies wird Ihre Netzwerkschnittstellen auf dem Ubuntu-Server ähnlich wie unten auflisten, und wir werden die WAN-Schnittstelle ens18 auswählen, um Snort darauf auszuführen, in unserem Beispiel:

   1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
   link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
   inet 127.0.0.1/8 scope host lo
   valid_lft forever preferred_lft forever
   inet6 ::1/128 scope host
   valid_lft forever preferred_lft forever
   2: ens18: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
   link/ether 9e:d6:2e:8e:2c:2c brd ff:ff:ff:ff:ff:ff
   altname enp0s18
   inet 192.168.0.29/24 metric 100 brd 192.168.0.255 scope global dynamic ens18
   valid_lft 595176sec preferred_lft 595176sec
   inet6 fe80::9cd6:2eff:fe8e:2c2c/64 scope link
   valid_lft forever preferred_lft forever
     	3: ens19: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
   link/ether 3a:49:6f:b5:60:20 brd ff:ff:ff:ff:ff:ff
   altname enp0s19
   inet 10.10.10.21/24 metric 100 brd 10.10.10.255 scope global dynamic ens19
   valid_lft 4776sec preferred_lft 4776sec
   inet6 fe80::3849:6fff:feb5:6020/64 scope link
   valid_lft forever preferred_lft forever

2. Setzen Sie die Schnittstelle, auf der Snort den Netzwerkverkehr abhört, in den Promiskuitivmodus, damit es den gesamten ankommenden Netzwerkverkehr sehen kann und nicht nur den Verkehr, der vom Ubuntu-Server kommt, indem Sie den nächsten Befehl ausführen:

   sudo ip link set dev ens18 promisc on

3. Um zu überprüfen, ob die Netzwerkschnittstelle im Promiscuous-Modus läuft, führen Sie den folgenden Befehl aus:

   ip address show ens18

   Sie sollten das PROMISC-Muster in der ersten Zeile sehen.

   2: ens18: <BROADCAST,MULTICAST,PROMISC,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000

4. Überprüfen Sie den Status von Large-Receive-Offload (LRO) und Generic-Receive-Offload (GRO) für diese Schnittstellen, sobald Sie den Namen der Netzwerkschnittstelle kennen, auf der Snort den Datenverkehr abhören wird, indem Sie den folgenden Befehl ausführen (ersetzen Sie ens18 durch den Namen Ihrer Schnittstelle):

   ethtool -k ens18 | grep receive-offload

   Sie sehen möglicherweise die folgende Ausgabe:

   generic-receive-offload: on
   large-receive-offload: off [fixed]

5. Wir müssen sicherstellen, dass beide auf off (oder off [fixed]) gesetzt sind, wenn wir eine ähnliche Ausgabe wie oben sehen. Um das Interface-Offloading zu deaktivieren und zu verhindern, dass Snort große Pakete größer als 1518 Bytes abschneidet, führen Sie den folgenden Befehl aus (ersetzen Sie ens18 durch den Namen Ihres Interfaces):

   sudo ethtool -K ens18 gro off lro off

6. Erstellen und aktivieren Sie eine systemd-Diensteinheit, um die Änderungen anzuwenden, damit sie nach einem Systemneustart bestehen bleiben, indem Sie die folgenden Befehle ausführen:

   sudo su
   cat > /etc/systemd/system/snort3-nic.service << 'EOL'
   > [Unit]
   Description=Set Snort 3 NIC in promiscuous mode and Disable GRO, LRO on boot
   After=network.target
   [Service]
   Type=oneshot
   ExecStart=/usr/sbin/ip link set dev ens18 promisc on
   ExecStart=/usr/sbin/ethtool -K ens18 gro off lro off
   TimeoutStartSec=0
   RemainAfterExit=yes
   [Install]
   WantedBy=default.target
   EOL

7. Um die systemd-Konfigurationseinstellungen neu zu laden, führen Sie den folgenden Befehl aus:

   systemctl daemon-reload

8. Starten und aktivieren Sie den Dienst beim Booten, führen Sie den folgenden Befehl aus:

   systemctl enable --now snort3-nic.service

9. Um den Status unseres neu erstellten Dienstes anzuzeigen, führen Sie den folgenden Befehl aus:

   service snort3-nic status
   ? snort3-nic.service - Set Snort 3 NIC in promiscuous mode and Disable GRO, LRO on boot
   Loaded: loaded (/etc/systemd/system/snort3-nic.service; enabled; vendor preset: enabled)
   Active: active (exited) since Mon 2022-08-22 12:19:02 UTC; 1min 39s ago
   Process: 41076 ExecStart=/usr/sbin/ip link set dev ens18 promisc on (code=exited, status=0/SUCCESS)
   Process: 41077 ExecStart=/usr/sbin/ethtool -K ens18 gro off lro off (code=exited, status=0/SUCCESS)
   Main PID: 41077 (code=exited, status=0/SUCCESS)
   CPU: 4ms
   Aug 22 12:19:02 snort systemd[1]: Starting Set Snort 3 NIC in promiscuous mode and Disable GRO, LRO on boot...
   Aug 22 12:19:02 snort systemd[1]: Finished Set Snort 3 NIC in promiscuous mode and Disable GRO, LRO on boot.

2. Konfiguration der Snort Community- und lokalen Regelsets

Regelsätze sind der primäre Kanal für die Snort-Engine zur Erkennung und Verhinderung von Eindringlingen. Es gibt drei Arten von Snort-Regeln:

• Community-Regeln

• Registrierte Regeln

• Abonnentenregeln

In diesem Tutorial werden die Community Snort-Regeln und lokale Regeln installiert.

1. Erstellen Sie einige Ordner und Dateien, die Snort für Regeln benötigt, indem Sie die folgenden Befehle ausführen:

   sudo mkdir /usr/local/etc/rules
   sudo mkdir /usr/local/etc/so_rules/
   sudo mkdir /usr/local/etc/lists/
   sudo touch /usr/local/etc/rules/local.rules
   sudo touch /usr/local/etc/lists/default.blocklist
   sudo mkdir /var/log/snort

2. Um eine Regel hinzuzufügen, die ICMP-Verkehr erkennt und hervorragend geeignet ist, um zu überprüfen, ob Snort ordnungsgemäß funktioniert und Alarme ausgibt, fügen Sie die folgende Zeile in die Datei local.rules ein:

   alert icmp any any -> any any ( msg:"ICMP Traffic Detected"; sid:10000001; metadata:policy security-ips alert; )

3. Starten Sie Snort und lassen Sie die Datei local.rules laden (unter Verwendung des Parameters -R), um sicherzustellen, dass diese Regeln erfolgreich geladen werden, indem Sie den folgenden Befehl ausführen:

   snort -c /usr/local/etc/snort/snort.lua -R /usr/local/etc/rules/local.rules

   Der Output sollte mit der folgenden Zeile enden:

   Snort successfully validated the configuration (with 0 warnings).

   Das Durchscrollen der Ergebnisse sollte zeigen, dass diese Regel korrekt geladen wurde. (under the rule counts section).

4. Führen Sie Snort im Erkennungsmodus auf einer Schnittstelle aus (ersetzen Sie eth0 durch den Namen Ihrer Schnittstelle) und protokollieren Sie alle Alarme auf der Konsole, indem Sie den folgenden Befehl eingeben:

   sudo snort -c /usr/local/etc/snort/snort.lua -R /usr/local/etc/rules/local.rules -i ens18 -A alert_fast -s 65535 -k none

   Eine Erklärung der Flags im vorherigen Befehl finden Sie unten:

   • -c: /usr/local/etc/snort/snort.lua Die snort.lua-Konfigurationsdatei.
   • -R: /usr/local/etc/rules/local.rules Der Pfad zur Regeldatei, die unsere eine ICMP-Regel enthält.
   • -i ens18: Die Schnittstelle, auf der gehört werden soll.
   • -A alert_fast: Verwenden Sie das alert_fast-Ausgabe-Plugin, um Warnungen auf der Konsole auszugeben.
   • -s 65535: Setzen Sie die Snaplen, damit Snort übergroße Pakete nicht abschneidet und verwirft.
   • -k none: Ignoriere fehlerhafte Prüfziffern, andernfalls wird Snort Pakete mit fehlerhaften Prüfziffern verwerfen

   Snort wird die Konfiguration laden und dann die folgenden Zeilen anzeigen:

   Commencing packet processing
   ++ [0] ens18

   Dies zeigt an, dass Snort derzeit den gesamten Verkehr auf dieser Schnittstelle, ens18, gemäß der geladenen Regel überprüft. Wenn der Datenverkehr mit einer Regel übereinstimmt, generiert Snort eine Konsolenwarnung. Jetzt, von einem anderen Computer aus, pingen Sie die IP-Adresse dieser Schnittstelle Ihres Ubuntu-Servers an. Warnungen sollten ähnlich wie unten auf dem Bildschirm erscheinen:

   08/22-12:45:11.714259 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] {ICMP} 192.168.0.29 -> 192.168.0.34
   08/22-12:45:13.455554 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] {ICMP} 192.168.0.34 -> 192.168.0.29
   08/22-12:45:13.455606 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] {ICMP} 192.168.0.29 -> 192.168.0.34
   08/22-12:45:14.470965 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] {ICMP} 192.168.0.34 -> 192.168.0.29
   08/22-12:45:14.471009 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] {ICMP} 192.168.0.29 -> 192.168.0.34

5. Um Snort zu stoppen, drücken Sie Strg-C. Dies ist eine nützliche Regel zum Testen von Snort, aber sie könnte für den produktiven Einsatz zu laut sein, daher können Sie sie mit dem Raute-Symbol auskommentieren, wenn Sie möchten.

6. Um Decoder- und Inspektor-Warnungen zu aktivieren (bösartiger Verkehr, der von Snort identifiziert wurde, nicht durch die Regeln aufgrund der komplizierteren Struktur der Regeln), und um das ips-Modul darüber zu informieren, wo sich unsere Regeldatei befinden wird (aufgrund des komplexeren Formats der Regeln), bearbeiten Sie die Datei snort.lua:

   sudo vi /usr/local/etc/snort/snort.lua

7. Suchen Sie den Abschnitt ips in Zeile 182, der mit ips beschriftet ist, und kommentieren Sie enable_builtin_rules=true aus (entfernen Sie die beiden vorangestellten Striche) und aktivieren Sie unsere lokalen Regeln:

   ips =
   {
   -- use this to enable decoder and inspector alerts
   enable_builtin_rules = true,
   include = RULE_PATH .. "/local.rules",
   -- use include for rules files; be sure to set your path
   -- note that rules files can include other rules files
   -- (see also related path vars at the top of snort_defaults.lua)
   variables = default_variables
   }

8. Um die Konfiguration der Snort-Datei zu überprüfen, führen Sie den nächsten Befehl aus.

   snort -c /usr/local/etc/snort/snort.lua

9. Führen Sie Snort mit dem folgenden Befehl aus:

   sudo snort -c /usr/local/etc/snort/snort.lua -i ens18 -A alert_fast -s 65535 -k none

   Wenn Sie die Ubuntu Snort-Schnittstelle von einem anderen Computer aus anpingen, sollten die Alarme in die Konsole umgeschrieben werden.

10. Um die Snort Community-Regeln herunterzuladen und zu installieren, führen Sie den folgenden Befehl aus

    sudo su
    cd /usr/local/etc/rules && wget https://www.snort.org/downloads/community/snort3-community-rules.tar.gz
    tar xzf snort3-community-rules.tar.gz

11. Um die Dateien anzuzeigen, führen Sie den folgenden Befehl aus:

    ls -l snort3-community-rules

    Sie sollten etwas Ähnliches wie das untenstehende sehen:

    -rw-r--r-- 1 1210 root 7834 Aug 17 20:32 AUTHORS
    -rw-r--r-- 1 1210 root 15127 Aug 17 20:32 LICENSE
    -rw-r--r-- 1 1210 root 492722 Aug 17 20:32 sid-msg.map
    -rw-r--r-- 1 1210 root 1797899 Aug 17 20:32 snort3-community.rules
    -rw-r--r-- 1 1210 root 21084 Aug 17 20:32 VRT-License.txt

12. Bearbeiten Sie die Snort-Konfigurationsdatei /usr/local/etc/snort/snort.lua mit Ihrem bevorzugten Editor, wie vi oder nano.

    vi /usr/local/etc/snort/snort.lua

13. Setzen Sie die Umgebungsvariablen HOME_NET und EXTERNAL_NET. HOME_NET muss auf die Netzwerke gesetzt werden, die von Snort geschützt werden sollen, wie die WAN IP-Adresse Ihres Ubuntu-Servers oder das LAN Netzwerk (Subnets) hinter dem Ubuntu-Server. Wir setzen dies auf die IP-Adresse der Snort 3 ens18 Schnittstelle, 192.168.0.29/32 in unserem Beispiel. Das EXTERNAL_NET ist jedes Netzwerk außer unserem HOME_NET.

14. Gehen Sie zum ips-Block in Zeile 182 und aktualisieren Sie die Datei wie unten angegeben:

    ips =
    {
    -- use this to enable decoder and inspector alerts
    enable_builtin_rules = true,
    include = RULE_PATH .. "/local.rules",
    include= RULE_PATH .. "/snort3-community-rules/snort3-community.rules"
    -- use include for rules files; be sure to set your path
    -- note that rules files can include other rules files
    -- (see also related path vars at the top of snort_defaults.lua)
    variables = default_variables
    }

15. Speichern Sie die Konfigurationsdatei und beenden Sie sie.

16. Validieren Sie die Konfigurationsänderungen, indem Sie den folgenden Befehl ausführen:

    snort -c /usr/local/etc/snort/snort.lua
    tipp

    Zusätzlich können Sie sich auf der Snort-Website registrieren. Die Registrierung ermöglicht es Ihnen, die Regeln für registrierte Benutzer mit ihrem Oink-Code zu erhalten. Um die registrierten Snort-Regeln zu erhalten und zu installieren, können Sie die folgenden Schritte befolgen:

    1. Abonnieren Sie die Snort-Website über https://snort.org/users/sign_up.

    2. Melden Sie sich bei Ihrem Sort-Konto an und erhalten Sie den Oink-Code, indem Sie zum Oink-Code-Menü navigieren.

       Abbildung 1. Erhalt des Snort Oinkcodes

    3. Klicken Sie auf den Link Downloads in der oberen Navigationsleiste.

       Abbildung 2. Herunterladen der registrierten Snort V3.0-Regeln

    4. Scrollen Sie nach unten zu den Regeln und kopieren Sie die Linkadresse des neuesten Registered Snort V3.0-Regelsatzes, wie z.B. snortrules-snapshot-31350.tar.gz.

    5. Um das neueste Regelset herunterzuladen, können Sie entweder den nächsten Befehl ausführen (vergessen Sie nicht, das Oinkcode-Muster durch Ihren eigenen Code zu ersetzen) oder auf das neueste registrierte Snort V3.0-Regelset auf der Download-Seite klicken und die Datei dann auf Ihren Server kopieren:

       wget https://www.snort.org/downloads/registered/snortrules-snapshot-31350.tar.gz?oinkcode=oinkcode -O snortrules-snapshot-31350.tar.gz

    6. Um die registrierten Regeln zu extrahieren, führen Sie den folgenden Befehl aus:

       sudo tar -xvf ~/snortrules-snapshot-31350.tar.gz -C /usr/local/etc/rules/

    7. Sehen Sie sich die registrierten Regeln an, indem Sie den folgenden Befehl ausführen:

       ls /usr/local/etc/rules/so_rules/

       Sie sollten die ähnliche Ausgabe unten sehen:

       browser-chrome.rules file-executable.rules file-office.rules malware-cnc.rules os-windows.rules protocol-other.rules rulestates-balanced-ips.states server-iis.rules server-webapp.rules
       browser-ie.rules file-flash.rules file-other.rules malware-other.rules policy-other.rules protocol-scada.rules rulestates-connectivity-ips.states server-mail.rules src
       browser-other.rules file-image.rules file-pdf.rules netbios.rules policy-social.rules protocol-snmp.rules rulestates-max-detect-ips.states server-mysql.rules
       browser-webkit.rules file-java.rules includes.rules os-linux.rules precompiled protocol-tftp.rules rulestates-no-rules-active.states server-oracle.rules
       exploit-kit.rules file-multimedia.rules indicator-shellcode.rules os-other.rules protocol-dns.rules protocol-voip.rules rulestates-security-ips.states server-other.rules

    8. Die Regelsets für registrierte Benutzer bieten eine beträchtliche Menge an vordefinierten Erkennungsregeln, die hilfreich sind. Wenn Sie Snort bereits mit den Community-Regeln getestet haben, können Sie zusätzliche registrierte Regeln aktivieren und dann die Konfigurationsänderungen validieren.

3. Installation von Snort OpenAppID

OpenAppId ist eine anwendungszentrierte Erkennungssprache und ein Verarbeitungsmodul für Snort, das es Benutzern ermöglicht, Anwendungs- und Dienstenerkennung zu erstellen, zu verteilen und auszuführen. OpenAppID identifiziert den Anwendungsschichtverkehr (Layer 7) und ermöglicht es Ihnen, Regeln zu erstellen, die auf den Anwendungsschichtverkehr wirken (zum Beispiel, um Facebook oder einen bestimmten Typ von Virtual Private Network (VPN) zu verbieten) und Verkehrsstatistiken für jede identifizierte Art von Verkehr zu melden. OpenAppID ist eine optionale Funktion, die von Snort angeboten wird; Sie sollten sie aktivieren, wenn Sie bestimmte Arten von Datenverkehr (FTP, Twitter usw.) erkennen oder blockieren oder Statistiken über die Datenmenge pro erkannter Verkehrsart auf Ihrem Snort-Server sammeln möchten.

Das Application Detector Package ist eine Sammlung von Detektoren, die vom Snort-Team in Zusammenarbeit mit der Community erstellt wurden und zum Download und zur Installation verfügbar sind. Sie können die OpenAppID-Detektoren (Identifizierung des Datenverkehrs) aktivieren und dann die Aufzeichnung der OpenAppID-Metriken aktivieren, indem Sie die folgenden Schritte ausführen:

1. Laden Sie das OpenAppID-Detektor-Paket herunter und entpacken Sie es, indem Sie den folgenden Befehl ausführen:

   cd ~/snort_src/
   wget https://snort.org/downloads/openappid/26425 -O OpenAppID-26425.tgz
   tar -xzvf OpenAppID-26425.tgz
   sudo cp -R odp /usr/local/lib/
   warnung

   Wenn Sie die OpenAppID-Datei nicht von der oben angegebenen URL herunterladen können, gehen Sie zur Seite https://snort.org/downloads und kopieren Sie die Linkadresse der snort-openappid.tar.gz unter der Überschrift OpenAppID.

2. Bearbeiten Sie unsere Snort-Konfigurationsdatei, um auf dieses odp-Verzeichnis zu verweisen.

     	sudo nano /usr/local/etc/snort/snort.lua

3. Suchen Sie den Abschnitt appid und konfigurieren Sie ihn wie folgt:

   appid =
   {
   -- appid requires this to use appids in rules
   app_detector_dir = '/usr/local/lib',
   log_stats = true,
   }

4. Validieren Sie die Konfigurationsänderungen, indem Sie den folgenden Befehl ausführen:

   snort -c /usr/local/etc/snort/snort.lua

5. Ändern Sie die Snort local.rules-Datei mit einer neuen Regel, die Facebook-Verkehr erkennt, indem Sie die folgende Zeile hinzufügen:

   alert tcp any any -> any any ( msg:"Facebook Detected"; appids:"Facebook"; sid:10000002; metadata:policy security-ips alert; )

6. Überprüfen Sie die Syntax der Datei local.rules, indem Sie den folgenden Befehl ausführen:

   snort -c /usr/local/etc/snort/snort.lua -R /usr/local/etc/rules/local.rules

7. Run Snort by executing the command below(by replacing ens18 with your interface name):

   snort -c /usr/local/etc/snort/snort.lua -R /usr/local/etc/rules/local.rules -i ens18 -A alert_fast -s 65535 -k none

8. Versuchen Sie, die Facebook-Seite von Ihrem Ubuntu-Server aus zu verbinden. Sie sollten die folgenden Warnungen auf der Konsole sehen:

   08/23-10:56:06.262915 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 192.168.0.29:48824 -> 157.240.234.35:443
   08/23-10:56:06.263574 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 192.168.0.29:48824 -> 157.240.234.35:443
   08/23-10:56:06.265113 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 192.168.0.29:48824 -> 157.240.234.35:443
   08/23-10:56:06.261005 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 157.240.234.35:443 -> 192.168.0.29:48824
   08/23-10:56:06.265411 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 157.240.234.35:443 -> 192.168.0.29:48824
   08/23-10:56:06.266529 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 192.168.0.29:48824 -> 157.240.234.35:443

9. Drücken Sie Ctrl+C, um Snort zu stoppen. Sie werden Paketstatistiken sehen, die den unten angegebenen ähnlich sind:

   Packet Statistics
     --------------------------------------------------
   daq
   received: 1034
   analyzed: 966
   dropped: 36
   outstanding: 68
   allow: 881
   whitelist: 85
   rx_bytes: 293090
     --------------------------------------------------
   codec
   total: 966 (100.000%)
   arp: 8 ( 0.828%)
   eth: 966 (100.000%)
   icmp4: 398 ( 41.201%)
   icmp6: 4 ( 0.414%)
   igmp: 4 ( 0.414%)
   ipv4: 954 ( 98.758%)
   ipv6: 4 ( 0.414%)
   ipv6_hop_opts: 2 ( 0.207%)
   tcp: 540 ( 55.901%)
   udp: 12 ( 1.242%)
     --------------------------------------------------
   Module Statistics
     -------------------------------------------------
   appid
   packets: 958
   processed_packets: 958
   total_sessions: 15
   service_cache_adds: 6
   bytes_in_use: 912
   items_in_use: 6
     --------------------------------------------------
   Appid Statistics
     --------------------------------------------------
   detected apps and services
   Application: Services Clients Users Payloads Misc Referred
   dns: 4 4 0 0 0 0
   facebook: 0 0 0 2 0 0
   http: 1 0 0 0 0 0
   putty: 0 1 0 0 0 0
   ssh: 1 0 0 0 0 0
   wget: 0 1 0 0 0 0
   https: 2 0 0 0 0 0
   ssl_client: 0 2 0 0 0 0
   ubuntu: 0 0 0 1 0 0
   icmp: 1 0 0 0 0 0
   icmp_for_ipv6: 2 0 0 0 1 0
   igmp: 2 0 0 0 0 0
   unknown: 1 0 0 0 0 0
     --------------------------------------------------
   Summary Statistics
     --------------------------------------------------
   process
   signals: 1
     --------------------------------------------------
   timing
   runtime: 00:03:23
   seconds: 203.166562
   pkts/sec: 5
   o")~ Snort exiting

4. Konfiguration des Snort-Loggings

Alle Ausgaben von Ereignissen und Paketen werden von Loggern durchgeführt. Um Snort 3-Ereignisse in Protokolldateien zu schreiben, müssen die Alarmeinstellungen konfiguriert werden. Es gibt mehrere Möglichkeiten, mit Snort zu protokollieren.

• alert_csv: Ausgabe von Ereignissen im CSV-Format
• alert_ex: Ausgabe von gid:sid:rev für Alarme
• alert_fast: Ausgabe des Ereignisses im kurzen Textformat
• alert_full: Ausgabeereignis mit vollständigem Paketdump
• alert_json: Ausgabeereignis im JSON-Format
• alert_sfsocket: Ereignis über Socket ausgeben
• alert_syslog: Ereignis an Syslog ausgeben
• alert_unixsock: Ereignis über Unix-Socket ausgeben
• log_codecs: Protokolle in Paketen schichtweise protokollieren
• log_hext: Ausgabe des Payloads geeignet für daq hext
• log_pcap: Protokollpaket im pcap-Format
• Unified2: Ausgabe von Ereignissen und Paketen in einer Unified2-Formatdatei

1. Um Ereignisdaten im Kurzformat in eine Datei zu exportieren (wie in der obigen Befehlszeile durch die Option -A alert_type angegeben), gehen Sie zum Abschnitt Ausgaben der snort.lua-Konfigurationsdatei.

   ---------------------------------------------------------------------------
   -- 7. configure outputs
     	---------------------------------------------------------------------------
     	-- event logging
     	-- you can enable with defaults from the command line with -A <alert_type>
     	-- uncomment below to set non-default configs
     	--alert_csv = { }
     	alert_fast = {file = true,
     	packet = false,
     	limit = 10,
     	}
     	--alert_full = { }
     	--alert_sfsocket = { }
     	--alert_syslog = { }
     	--unified2 = { }
     	-- packet logging
     	-- you can enable with defaults from the command line with -L <log_type>
     	--log_codecs = { }
     	--log_hext = { }
     	--log_pcap = { }
     	-- additional logs
     	--packet_capture = { }
     	--file_log = { }

2. Speichern Sie die Konfigurationsdatei und beenden Sie sie. Die Einstellung bewirkt, dass Snort Protokolle in die Datei alert_fast.txt schreibt. Überprüfen Sie die Syntax, indem Sie den nächsten Befehl ausführen.

   snort -c /usr/local/etc/snort/snort.lua

3. Führen Sie Snort erneut aus, ohne die Option -A alert_fast. Aber geben Sie das Protokollverzeichnis mit der Option -l /var/log/snort an.

4. Versuchen Sie, sich von Ihrem Ubuntu-Server aus mit der Facebook-Seite zu verbinden. Sie sollten die folgenden Warnungen in der Datei /var/log/snort/alert_fast.txt sehen:

   tail -f /var/log/snort/alert_fast.txt
   08/23-11:59:04.444640 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] [AppID: ICMP] {ICMP} 192.168.0.34 -> 192.168.0.29
   08/23-11:59:04.444640 [**] [1:384:8] "PROTOCOL-ICMP PING" [**] [Classification: Misc activity] [Priority: 3] [AppID: ICMP] {ICMP} 192.168.0.34 -> 192.168.0.29
   08/23-11:59:04.444686 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] [AppID: ICMP] {ICMP} 192.168.0.29 -> 192.168.0.34
   08/23-11:59:05.473735 [**] [1:382:11] "PROTOCOL-ICMP PING Windows" [**] [Classification: Misc activity] [Priority: 3] [AppID: ICMP] {ICMP} 192.168.0.34 -> 192.168.0.29
   08/23-11:59:05.473735 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] [AppID: ICMP] {ICMP} 192.168.0.34 -> 192.168.0.29
   08/23-11:59:05.473735 [**] [1:384:8] "PROTOCOL-ICMP PING" [**] [Classification: Misc activity] [Priority: 3] [AppID: ICMP] {ICMP} 192.168.0.34 -> 192.168.0.29
   08/23-11:59:05.473782 [**] [1:10000001:0] "ICMP Traffic Detected" [**] [Priority: 0] [AppID: ICMP] {ICMP} 192.168.0.29 -> 192.168.0.34
   08/23-11:59:05.618221 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 157.240.234.35:443 -> 192.168.0.29:48826
   08/23-11:59:05.618238 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 192.168.0.29:48826 -> 157.240.234.35:443
   08/23-11:59:05.618221 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 157.240.234.35:443 -> 192.168.0.29:48826
   08/23-11:59:05.618646 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 192.168.0.29:48826 -> 157.240.234.35:443
   08/23-11:59:05.618612 [**] [1:10000002:0] "Facebook Detected" [**] [Priority: 0] [AppID: Facebook] {TCP} 157.240.234.35:443 -> 192.168.0.29:48826

5. Snort als Dienst ausführen

Es ist möglich, Snort im Hintergrund als Daemon mit der -D-Befehlszeilenoption auszuführen, aber es ist auch möglich, eine systemd-Diensteinheit für Snort einzurichten. Um Snort als systemd-Dienst auf Ihrem Ubuntu 22.04-Server auszuführen, können Sie die folgenden Schritte befolgen:

1. Es wird empfohlen, Snort als nicht privilegierten Systembenutzer auszuführen, wenn es als Dienst ausgeführt werden soll. Erstellen Sie ein Systembenutzerkonto ohne Login für Snort:

   useradd -r -s /usr/sbin/nologin -M -c SNORT_IDS snort

2. Gewähren Sie dem Benutzer 'snort' die Berechtigung für das Protokollverzeichnis, indem Sie die folgenden Befehle ausführen:

   sudo chmod -R 5775 /var/log/snort
   sudo chown -R snort:snort /var/log/snort

3. Um die Snort systemD-Dienstdatei zu erstellen, führen Sie den folgenden Befehl aus:

   [Unit]
   Description=Snort3 NIDS Daemon
   After=syslog.target network.target
   [Service]
   Type=simple
   ExecStart=/usr/local/bin/snort -c /usr/local/etc/snort/snort.lua -s 65535 -k none -l /var/log/snort -D -u snort -g snort -i ens18 -m 0x1b --create-pidfile
   ExecStop=/bin/kill -9 $MAINPID
   [Install]
   WantedBy=multi-user.target

   Hier ist eine Zusammenfassung aller Flags, die wir mit Snort verwenden:

   • /usr/local/bin/snort: Dies ist der Pfad zur Snort-Binärdatei. Wir verwenden hier kein sudo, da das Skript mit erhöhten (Root-)Rechten gestartet wird.
   • -c /usr/local/etc/snort/snort.lua: Die snort.lua Konfigurationsdatei.
   • -s 65535: Setzen Sie den Snaplen, damit Snort übergroße Pakete nicht abschneidet und verwirft.
   • -k none: Ignoriere fehlerhafte Prüfziffern, andernfalls wird Snort Pakete mit fehlerhaften Prüfziffern verwerfen, und sie werden nicht ausgewertet.
   • -l /var/log/snort: Der Pfad zum Ordner, in dem Snort alle ausgegebenen Protokolldateien speichert.
   • -D: Als Daemon ausführen.
   • -u snort: Nach dem Start (und nach dem Ausführen von Aufgaben, die erhöhte Berechtigungen erfordern), wechsle zum Benutzer "snort".
   • -g snort: Nach dem Start als die "snort"-Gruppe ausführen.
   • -i eth0: Die Schnittstelle, auf der zugehört werden soll.
   • -m 0x1b: Umask von 033 für Dateiberechtigungen.
   • --create-pidfile: Erstelle eine PID-Datei im Log-Verzeichnis

4. Aktivieren Sie den Snort systemD-Dienst und starten Sie ihn, indem Sie die nächsten Befehle ausführen:

   sudo systemctl enable snort3
   sudo service snort3 start

5. Um den Status des Snort-Dienstes anzuzeigen, führen Sie den nächsten Befehl aus:

   sudo service snort3 status

   Ihr Ergebnis sollte dem folgenden ähnlich sein,

   ? snort3.service - Snort3 NIDS Daemon
   Loaded: loaded (/lib/systemd/system/snort3.service; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2022-08-23 12:19:52 UTC; 4s ago
   Main PID: 1793 (snort)
   Tasks: 2 (limit: 9286)
   Memory: 232.7M
   CPU: 1.432s
   CGroup: /system.slice/snort3.service
   ??1793 /usr/local/bin/snort -c /usr/local/etc/snort/snort.lua -s 65535 -k none -l /var/log/snort -D -u snort -g snort -i ens18 -m 0x1b --create-pidfile
   Aug 23 12:19:53 snort snort[1793]: total memory: 2.64854
   Aug 23 12:19:53 snort snort[1793]: pattern memory: 0.420437
   Aug 23 12:19:53 snort snort[1793]: match list memory: 0.940338
   Aug 23 12:19:53 snort snort[1793]: transition memory: 1.25066
   Aug 23 12:19:53 snort snort[1793]: fast pattern only: 4963
   Aug 23 12:19:53 snort snort[1793]: --------------------------------------------------
   Aug 23 12:19:53 snort snort[1793]: pcap DAQ configured to passive.
   Aug 23 12:19:53 snort snort[1793]: Commencing packet processing
   Aug 23 12:19:53 snort snort[1793]: ++ [0] ens18
   Aug 23 12:19:53 snort snort[1793]: Writing PID "1793" to file "/var/log/snort/snort.pid"

6. Überprüfen Sie die gesamte Ausgabe des Dienstes mit dem folgenden Befehl, falls es Probleme gibt:

   sudo journalctl -u snort3.service

Wie überprüfe ich meine Snort-Version?

Um die installierte Snort-Version zu überprüfen, führen Sie den folgenden Befehl in der CLI Ihres Snort IPS-Systems aus:

snort -V

Sie sollten die Ausgabe ähnlich der unten angegebenen sehen:

,,_ -*> Snort++ <*-
o" )~ Version 3.1.39.0
'''' By Martin Roesch & The Snort Team

http://snort.org/contact#team
Copyright (C) 2014-2022 Cisco and/or its affiliates. All rights reserved.
Copyright (C) 1998-2013 Sourcefire, Inc., et al.
Using DAQ version 3.0.9
Using LuaJIT version 2.1.0-beta3
Using OpenSSL 3.0.2 15 Mar 2022
Using libpcap version 1.10.1 (with TPACKET_V3)
Using PCRE version 8.39 2016-06-14
Using ZLIB version 1.2.11
Using LZMA version 5.2.5

Wie ändere ich meine IP-Adresse auf Snort?

Um Ihre IP-Adresse auf Snort zu ändern, folgen Sie den folgenden Schritten:

1. Bearbeiten Sie die Konfigurationsdatei /usr/local/etc/snort/snort.lua.

2. Setzen Sie die Deklaration für die HOME_NET-Variable auf das Netzwerk, das Sie vor Cyberangriffen schützen möchten.

   info

   Anstatt den Standardwert any für die HOME NET-Deklaration zu belassen, ersetzen Sie ihn durch den IP-Adressbereich Ihres lokalen Netzwerks.

   Die Verwendung einer CIDR-Format-Ausdrucks, um den gesamten Bereich der relevanten Adressen abzudecken (insbesondere bei der Verwendung von Network Address Translation in von Gateways oder Routern gesteuerten Einstellungen), ist die einfachste Methode.

   Für ein typisches Heimnetzwerk lautet der Ausdruck 192.168.0.1/24 oder 192.168.1.1/24.

   In einem typischen großen Büronetzwerk, das Netzwerkadressübersetzung verwendet, lautet der Ausdruck 10.0.0.0/8.

   In einigen Kontexten (insbesondere in Haushaltsumgebungen, die über ein Kabelmodem ohne Gateway oder Router mit dem Internet verbunden sind) kann der Internetdienstanbieter (ISP) den richtigen IP-Adressbereich vorschlagen, den man verwenden sollte.

3. Speichern und beenden.

4. Überprüfen Sie die Konfigurationsänderungen, indem Sie den nächsten Befehl ausführen.

   snort -c /usr/local/etc/snort/snort.lua

Ist Snort mehrkernfähig?

Ja. Seit Snort 3, das am 19. Januar 2021 veröffentlicht wurde, ist Snort mehrthreadig. Mehrere Paketverarbeitungsthreads können in Snort 3 gleichzeitig betrieben werden.

Snort 3 bietet die Option --max-packet-threads oder -z zur Verwendung mehrerer Paketverarbeitungsthreads. Dieser Parameter gibt die Anzahl der Threads an, die von Snort zur Verarbeitung des Netzwerkverkehrs verwendet werden, mit maximal 8 Threads.

Snort startet N Paketverarbeitungs-Threads, wobei N die Anzahl der Threads ist, die nach der --max-packet-threads oder -z Option angegeben wird.

Zum Beispiel, um 4 Threads zur Verarbeitung von pcap-Dateien mit der Endung *.pcap aus einem bestimmten Verzeichnis 'pcaps' zu verwenden, führen Sie die folgenden Befehle in Ihrer Snort-CLI aus:

snort -c snort.lua --pcap-dir ./pcaps --pcap-filter '*.pcap' -l /var/log/snort plugin-path /extra -k none -z --4

Beachten Sie, dass bei der Verwendung mehrerer Threads zum Protokollieren in Dateien jeder Thread seine eigenen Protokolldateien basierend auf der im snort.lua-Datei angegebenen Protokollkonfiguration erstellt.

Wenn die Option --id-subdir angegeben ist, erstellt jeder Thread ein Verzeichnis unter dem angegebenen Log-Verzeichnis oder dem Standard-Log-Verzeichnis /var/log/snort, das nach der ID des Threads benannt ist.

Ist Snort aktiv oder passiv?

Snort ist standardmäßig ein passives IDS. Snort überwacht oder "schnüffelt" den Netzwerkverkehr, zeichnet ihn auf und kann den Administrator alarmieren, wenn ein Paket einer bestimmten Regel entspricht oder eine bestimmte Zeichenfolge enthält. Die aktive Reaktionsfunktion macht Snort jedoch zu einem aktiven IDS.

Snort spielt eine aktivere Rolle in der Netzwerksicherheit, indem es aktive Reaktionen bereitstellt, um bösartige Verbindungen zu beenden. Wenn aktive Antworten aktiviert sind, sendet Snort TCP RST oder ICMP unerreichbar, wenn eine Sitzung beendet wird.

Die aktive Reaktion wird aktiviert, indem eines der unten aufgeführten IPS Aktions-Plugins eingestellt wird:

• react = : Die IPS-Aktion reagiert, indem sie das Übertragen einer HTML-Seite und anschließend das Zurücksetzen einer Sitzung ermöglicht.

• reject = : Durch das Einspeisen von TCP-Resets (TCP-Verbindungen) oder ICMP-Unreachable-Paketen kann eine feindliche Netzwerksitzung beendet werden.

• rewrite = : Die IPS-Aktion "rewrite" erlaubt den Austausch des Paketinhalts, abhängig von der Regeloption "replace".

Ist Snort hostbasiert?

Nein. Snort ist ein netzwerkbasiertes Intrusion Detection- und Prevention-System, allgemein bekannt als Netzwerk-Intrusion Detection- und Prevention-System. (NIDS). Snort enthält einen Paket-Sniffer, um den Netzwerkverkehr zur Analyse zu sammeln. Als NIDS fängt Snort Cyberangriffe ab, sobald sie auftreten. Die Snort-Engine basiert typischerweise auf Regeln und kann durch Hinzufügen eigener Regeln modifiziert werden.

Wie viele Protokolle unterstützt Snort?

Drei (3). Derzeit überwacht Snort drei IP-Protokolle auf verdächtiges Verhalten:

1. TCP

2. UDP

3. ICMP

Es könnte in Zukunft andere Protokolle geben, wie ARP, IGRP, GRE, OSPF, RIP und IPX.

Was passiert, wenn Snort ein Paket ablehnt?

Snort beendet feindliche Netzwerksitzungen, indem es TCP-Resets (TCP-Verbindungen) oder

ICMP unerreichbare Pakete und das Protokollieren des Ereignisses, wenn es ein Paket durch eine aktive Reaktion ablehnt.