Webserver mit Nikto scannen

Einführung

In diesem Lab lernen Sie, wie Sie Nikto, einen Open-Source-Webserver-Scanner (Webserver-Scanner im Original), verwenden können, um potenzielle Sicherheitslücken in Webanwendungen zu erkennen. Sie üben Scantechniken an der absichtlich anfälligen bWAPP-Anwendung und lernen gleichzeitig, die Scanergebnisse effektiv zu interpretieren.

Das Lab behandelt die Installation von Nikto, die Konfiguration des Ziels, die Ausführung des Scans und die Analyse der Ergebnisse. Durch praktische Übungen erwerben Sie die wesentlichen Fähigkeiten, um grundlegende Sicherheitsbewertungen von Webservern mit diesem weit verbreiteten Sicherheitstool durchzuführen.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/save_output("Save Output to File") nmap/NmapGroup -.-> nmap/target_specification("Target Specification") subgraph Lab Skills nmap/save_output -.-> lab-549948{{"Webserver mit Nikto scannen"}} nmap/target_specification -.-> lab-549948{{"Webserver mit Nikto scannen"}} end

Installieren von Nikto

In diesem Schritt installieren Sie Nikto, einen Open-Source-Webserver-Scanner (Webserver-Scanner im Original), der hilft, Sicherheitslücken in Webservern zu identifizieren. Nikto prüft auf veraltete Serversoftware, gefährliche Dateien/CGIs und andere häufige Sicherheitsrisiken. Das Verständnis dieser Sicherheitslücken ist entscheidend für die Absicherung von Webanwendungen.

Bevor wir beginnen, stellen wir sicher, dass wir uns im richtigen Verzeichnis befinden. Das Verzeichnis ~/project ist der Ort, an dem wir alle unsere Labarbeiten durchführen, um die Dateien organisiert zu halten:

cd ~/project

Als Nächstes müssen wir die Paketliste aktualisieren. Dadurch wird sichergestellt, dass wir die neueste verfügbare Version von Nikto mit allen aktuellen Sicherheitsupdates installieren:

sudo apt update

Jetzt sind wir bereit, Nikto zu installieren. Das -y-Flag bestätigt die Installation automatisch und erspart uns die manuelle Bestätigung:

sudo apt install -y nikto

Nach Abschluss der Installation überprüfen wir, ob alles korrekt funktioniert hat, indem wir die installierte Version prüfen. Dies bestätigt, dass Nikto richtig installiert ist und zeigt, welche Version wir verwenden werden:

nikto -Version

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Nikto v2.1.6

Nikto ist jetzt erfolgreich auf Ihrem System installiert. Obwohl Nikto eine Konfigurationsdatei unter /etc/nikto.conf hat, verwenden wir für dieses Einführungslab die Standardeinstellungen. Diese Standards bieten ein gutes Gleichgewicht zwischen gründlichem Scannen und angemessener Geschwindigkeit für Lernzwecke.

Auswahl eines Zielservers

In diesem Schritt lernen Sie, wie Sie einen Ziel-Webserver für die Sicherheitslückenprüfung auswählen und überprüfen. Wir verwenden Nikto, um eine absichtlich anfällige Webanwendung namens "bWAPP" (Buggy Web Application) zu scannen, die sicher in unserer LabEx-Umgebung eingerichtet ist. Diese Übungsanwendung ist für Sicherheitstests konzipiert, ohne reale Systeme zu beeinträchtigen.

Zunächst navigieren wir in das richtige Arbeitsverzeichnis, in dem wir unsere Scans durchführen. Dies hilft, unsere Projektdateien organisiert zu halten:
```
cd ~/project
```
Bevor wir den Scan durchführen, müssen wir bestätigen, dass unser Ziel-Webserver ordnungsgemäß läuft. Wir verwenden curl mit dem -I-Flag, um nur die HTTP-Header abzurufen:
```
curl -I http://localhost:8000
```
Eine erfolgreiche Antwort zeigt den HTTP-Statuscode 200 OK an, was bedeutet, dass der Server aktiv ist:
```
HTTP/1.1 200 OK
```
Jetzt legen wir unsere Ziel-URL als Umgebungsvariable fest. Dies erleichtert die Referenzierung in späteren Scans:
```
TARGET="http://localhost:8000"
```
Lassen Sie uns einen schnellen Test durchführen, um die Antwort des Webservers zu sehen. Wir verwenden curl, um den Seiteninhalt abzurufen und nur die ersten 5 Zeilen anzuzeigen:
```
curl $TARGET | head -n 5
```
Dies gibt uns eine Stichprobe des HTML-Inhalts und bestätigt, dass wir erfolgreich eine Verbindung zum Server herstellen können.
Merken Sie sich diese Ziel-URL, da wir sie während des gesamten Scansvorgangs verwenden werden. Das Verfolgen Ihres Ziels ist bei der Durchführung von Sicherheitsbewertungen von entscheidender Bedeutung.

Durchführen eines Sicherheitslücken-Scans

In diesem Schritt verwenden Sie Nikto, um einen Sicherheitslücken-Scan auf dem Zielserver durchzuführen, den wir im vorherigen Schritt ausgewählt haben. Nikto ist ein Open-Source-Webserver-Scanner (Webserver-Scanner im Original), der über 6700 potenziell gefährliche Dateien/Programme testet, auf veraltete Serverversionen prüft und häufige Fehleinstellungen von Webservern erkennt.

Bevor Sie den Scan starten, ist es wichtig, sich im richtigen Verzeichnis zu befinden, in dem Sie die Berechtigung haben, das Tool auszuführen und die Ergebnisse zu speichern. Der Befehl cd ändert Ihr aktuelles Arbeitsverzeichnis:

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden:
```
cd ~/project
```

Jetzt führen wir einen grundlegenden Scan durch. Das -h-Flag gibt den Zielhost an (in diesem Fall unseren lokalen Testserver). Nikto prüft automatisch auf häufige Sicherheitslücken wie:

Standarddateien und -programme
Unsichere Serverkonfigurationen
Veraltete Serversoftware
Potenzielle XSS- und SQL-Injection-Sicherheitslücken

Führen Sie einen grundlegenden Nikto-Scan auf unserem Zielserver (http://localhost:8000) durch:
```
nikto -h http://localhost:8000
```

Der Scan wird ausgeführt und die Ergebnisse werden in Echtzeit angezeigt. Sie sehen eine Ausgabe ähnlich der folgenden:

- Nikto v2.1.6
- Target IP:          127.0.0.1
- Target Hostname:    localhost
- Target Port:        8000
- Start Time:         [timestamp]

Für eine gründlichere Prüfung können wir Tuning-Optionen verwenden. Der Parameter -Tuning ermöglicht es Ihnen, anzugeben, welche Tests ausgeführt werden sollen. Hier aktiviert x erweiterte Tests, während 6 auf häufige Dateien prüft, die sensible Informationen preisgeben könnten.

Für einen umfassenderen Scan können Sie diese Optionen hinzufügen:
```
nikto -h http://localhost:8000 -Tuning x 6
```
Dies führt erweiterte Tests (x) durch und prüft auf häufige Dateien (6).
Der Scan kann 1 - 2 Minuten dauern, bis er abgeschlossen ist. Wenn er fertig ist, sehen Sie eine Zusammenfassung der gefundenen Probleme, einschließlich:
```
+ Server may be vulnerable to XSS
+ Retrieved x-powered-by header: PHP/7.4.3
+ OSVDB-3092: Possible sensitive directory
```

Jedes gefundene Problem enthält:

Eine Beschreibung der Sicherheitslücke
Den Typ der Sicherheitslücke
Relevante Referenzen (z. B. OSVDB-IDs)
Die betroffene Komponente

Beachten Sie, dass einige gefundene Probleme möglicherweise Falschalarme sind - wir werden diese im nächsten Schritt analysieren. Nicht alle gemeldeten Probleme sind tatsächliche Sicherheitslücken, weshalb die manuelle Überprüfung in der Sicherheitstests von entscheidender Bedeutung ist.

Überprüfung der Scan-Ausgabe

In diesem Schritt werden wir die Scan-Ergebnisse von Nikto sorgfältig untersuchen, um zu verstehen, welche Sicherheitslücken im Ziel-Webserver gefunden wurden. Als Anfänger ist es wichtig zu wissen, dass Nikto seine Ergebnisse strukturiert präsentiert, um Ihnen die effiziente Identifizierung von Sicherheitsproblemen zu erleichtern.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden, in dem Ihre Scan-Ergebnisse gespeichert sind:
```
cd ~/project
```
Dieser Befehl wechselt Ihr aktuelles Verzeichnis in das Verzeichnis, in dem Nikto seine Ausgabedatei gespeichert hat.
Lassen Sie uns die Hauptabschnitte analysieren, die Sie in der Nikto-Ausgabedatei sehen werden:
- Serverinformationen: Zeigen, welche Webserver-Software (z. B. Apache oder Nginx) läuft und welche Version davon verwendet wird.
- Gefundene Sicherheitslücken: Zeigen spezifische Sicherheitsprobleme, die Nikto entdeckt hat, und geben an, wie schwerwiegend jedes Problem ist.
- Scan-Zusammenfassung: Gibt die Gesamtzahl der während des Scans gefundenen Probleme an.
Um schnell die wichtigsten Sicherheitslücken zu finden, führen Sie diesen Befehl aus:
```
grep -E '\+|OSVDB' ~/project/nikto_scan.txt
```
Dieser Befehl durchsucht Ihre Scan-Ergebnisse und zeigt nur die Zeilen an, die Sicherheitslückenmarker (+) oder OSVDB-Referenzen (die IDs aus der Sicherheitslückendatenbank sind) enthalten.
Beachten Sie bei der Überprüfung der Ergebnisse besonders:
- Alle gefundenen Probleme, die als "HIGH" (hoch) riskant eingestuft sind - diese sind die gefährlichsten Probleme.
- Alte Versionen der Server-Software - veraltete Programme haben oft bekannte Sicherheitslücken.
- Offen gelegte Verzeichnisse oder sensible Dateien - diese sollten nicht öffentlich zugänglich sein.
- Häufige Web-Angriffe wie Cross-Site Scripting (XSS) oder SQL-Injection (SQLi).
So könnten typische gefundene Probleme aussehen:
```
+ /config.php: PHP config file found
+ OSVDB-3092: /admin/: This might be interesting
```
Die erste Zeile zeigt, dass Nikto eine Konfigurationsdatei gefunden hat, die nicht öffentlich zugänglich sein sollte. Die zweite Zeile verweist auf eine spezifische Sicherheitslücken-ID aus der Open Source Vulnerability Database.
Um weitere Details zu einem bestimmten OSVDB-Eintrag zu erhalten, können Sie die Sicherheitslückendatenbank abfragen:
```
curl -s "https://vulners.com/api/v3/search/id/?id=OSVDB-3092" | jq '.data.attributes'
```
Dieser Befehl ruft detaillierte Informationen zur Sicherheitslücke OSVDB-3092 aus einer Online-Datenbank ab und formatiert sie für die bessere Lesbarkeit.
Notieren Sie sich beim Durchgehen der Ergebnisse die schwerwiegendsten Probleme, die Sie finden. Wir werden diese Notizen im nächsten Schritt verwenden, wenn wir unsere Ergebnisse dokumentieren. Konzentrieren Sie sich darauf, zu verstehen, was jede Sicherheitslücke bedeutet, anstatt versuchen, alles auf einmal zu beheben.

Speichern des Berichts

In diesem letzten Schritt speichern Sie die Nikto-Scan-Ergebnisse in einer Datei für die Dokumentation und zur späteren Referenz. Das Speichern von Berichten ist in der Sicherheitsprüfung von entscheidender Bedeutung, da es Beweise für gefundene Sicherheitslücken liefert und den Fortschritt bei der Behebung von Problemen verfolgen hilft.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Arbeitsverzeichnis befinden, in dem Sie Ihre Scan-Berichte speichern möchten. Der Befehl cd wechselt das Verzeichnis:
```
cd ~/project
```
Um die Scan-Ergebnisse aus dem vorherigen Schritt im Klartextformat zu speichern, führen Sie diesen Befehl aus. Das -output-Flag gibt den Dateinamen an, in den Nikto seine Ergebnisse schreiben wird:
```
nikto -h http://localhost:8000 -output vuln_scan_report.txt
```
Überprüfen Sie, ob der Bericht erfolgreich erstellt wurde. Der Befehl ls -l listet die Dateien mit Details auf, und Sie sollten Ihre Berichtsdatei mit Inhalt (nicht Nullgröße) sehen:
```
ls -l vuln_scan_report.txt
```
Für eine bessere Lesbarkeit und zum Teilen mit Teammitgliedern können Sie einen HTML-formatierten Bericht generieren. Die Option -Format html erstellt einen visuell organisierten Bericht:
```
nikto -h http://localhost:8000 -Format html -output vuln_scan_report.html
```
Um schnell den Inhalt Ihres Textberichts zu überprüfen, verwenden Sie den head-Befehl, der die ersten 20 Zeilen anzeigt. Dies hilft, zu überprüfen, ob der Scan ordnungsgemäß abgeschlossen wurde:
```
head -n 20 vuln_scan_report.txt
```
Der Bericht enthält mehrere wichtige Abschnitte, die Sicherheitsfachleute analysieren:
- Scan-Metadaten (Datum, Ziel usw.) - zeigen, wann und was gescannt wurde
- Alle identifizierten Sicherheitslücken - die Kernfindungen, die Beachtung erfordern
- Empfehlungen zur Behebung - vorgeschlagene Lösungen für jedes Problem
- Scan-Statistiken und Abschlusszeit - helfen, die Leistung des Scans zu messen
Diese Berichtsdateien sind jetzt in Ihrem ~/project-Verzeichnis gespeichert. Sie können:
- Sie mit Entwicklern teilen, um Probleme zu beheben
- Sie mit zukünftigen Scans vergleichen, um den Fortschritt zu verfolgen
- Sie in Sicherheitsaudit-Dokumentationen aufnehmen
- Sie als Beweis in Konformitätsberichten verwenden

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Nikto, einen leistungsstarken Open-Source-Webserver-Scanner, installieren und konfigurieren, um Sicherheitslücken in Zielsystemen zu erkennen. Die Übung hat Sie durch die Überprüfung der Installation, die Prüfung der Serverzugänglichkeit und die Durchführung umfassender Scans gegen eine anfällige Webanwendung geführt.

Sie haben praktische Erfahrungen in der Interpretation von Scan-Ergebnissen und der Erstellung von Berichten gesammelt, was die entscheidende Rolle der Sicherheitslückenbewertung bei der Aufrechterhaltung der Web-Sicherheit zeigt. Diese praktischen Kenntnisse rüsten Sie mit den wesentlichen Fähigkeiten aus, um potenzielle Sicherheitsrisiken in Webservern zu identifizieren.