Kartenrechner und Proxmark3-Plugin zum Schreiben und/oder Simulieren aller Kartentypen, die Doppelgänger Community, Pro, Stealth und MFAS unterstützen.
Eine professionelle GUI-Anwendung zur Berechnung von Kartendaten und zur Automatisierung von Proxmark3-Operationen für jeden Kartentyp, den Doppelgänger Core und Stealth unterstützen. Dieses Tool optimiert den Kartenschreibprozess für physische Penetrationstests durch eine intuitive Oberfläche mit doppelten Ausgabeanzeigen, visuellen Trennzeichen und Ein-Klick-Zwischenablage – ganz ohne sich komplexe Proxmark3-Syntax merken oder Notizen durchwühlen zu müssen.
Die automatisierten Installationsprogramme installieren Doppelgänger Assistant, benötigte Abhängigkeiten und den neuesten Iceman-Fork von Proxmark3. Während der Installation werden Sie aufgefordert, Ihren Proxmark3-Gerätetyp für eine optimale Konfiguration auszuwählen.
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/installers/doppelganger_install_macos.sh)"
### Linux```bash
curl -sSL https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/installers/doppelganger_install_linux.sh | sudo bash
Öffnen Sie PowerShell als Administrator und führen Sie Folgendes aus:```powershell irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/installers/doppelganger_install_windows.ps1 | iex
**Hinweis:** Der Installer fordert Sie auf, zwischen **Ubuntu 24.04 LTS (Noble)** (empfohlen) oder **Kali Linux** zu wählen. Er erkennt automatisch vorhandene Installationen und fordert Sie zu einem Update auf. Falls ein Neustart erforderlich ist, um die WSL-Funktionen zu aktivieren, werden Sie dazu aufgefordert. Führen Sie nach dem Neustart einfach denselben Befehl erneut aus.
⚠️ WICHTIG: WSL2 unterstützt keinen Betrieb in verschachtelten virtuellen Maschinen. Der Installer erkennt solche Umgebungen automatisch und verhindert die Installation. Um fortzufahren, installieren Sie auf physischer Hardware.
## Was der Doppelgänger Assistant kann
Der Doppelgänger Assistant bietet einen vollständigen Arbeitsablauf für Kartenanalyse und -klonen, von der anfänglichen Erkennung bis zu erfolgreichen Schreibvorgängen. Die Anwendung identifiziert automatisch Kartentechnologien, extrahiert Anmeldedaten, stellt Verschlüsselungsschlüssel wieder her und schreibt geklonte Karten mit Verifizierung.
### Intelligente Kartenerkennung
Die Funktion Card Discovery scannt automatisch nach Chips mit niedriger und hoher Frequenz, identifiziert Dual-Chip-Karten und bestimmt bestimmte Kartentechnologien wie HID Prox, iCLASS, PicoPass, MIFARE und weitere. Die Ergebnisse enthalten dekodierte Wiegand-Daten mit Facility-Codes und Kartennummern, sofern verfügbar.
### Hotelzimmer-Kartenanalyse
Der Abschnitt Hotel Access Control bietet spezielle Werkzeuge für MIFARE-basierte Hotelkartensysteme. Der Card Info-Abruf identifiziert automatisch Saflok-Hotelkarten und zeigt detaillierte Karteninformationen einschließlich UID, Kartentyp, Magic-Fähigkeiten und PRNG-Erkennung. Die rohe Proxmark3-Ausgabe enthält umfassende Saflok-Metadaten, sofern verfügbar.
### Automatisierte Schlüsselwiederherstellung
Die MIFARE-Angriffswerkzeuge umfassen mehrere Wiederherstellungsmethoden: Autopwn (automatische Multimethode), Darkside, Nested, Hardnested, Static Nested, Bruteforce und NACK-Schwachstellentests. Autopwn wählt automatisch die beste Angriffsmethode basierend auf den Karteneigenschaften aus. Die Ergebnisse zeigen umfassende Wiederherstellungsübersichten mit wiederhergestellten Sektoren, gefundenen Schlüsseln, verwendeten Wiederherstellungsmethoden und automatischer Dump-Dateierzeugung für das sofortige Klonen von Karten.
### Operationen mit Firmenzugangskarten
Der Abschnitt Corporate Access Control unterstützt das Lesen und Schreiben von iCLASS-, PicoPass-, AWID-, HID Prox-, Indala-, Avigilon- und anderen Firmenkartentechnologien. Kartendaten werden automatisch aus der Proxmark3-Ausgabe analysiert, um Facility-Codes, Kartennummern, Bitlängen, Formattypen (H10301, C1k35s usw.), CSN-Werte und rohe Hex-Daten zu extrahieren. Der integrierte Arbeitsablauf ermöglicht das sofortige Schreiben auf leere Karten mit optionaler Verifizierung.
### Vollständiger Klon-Workflow
Der Doppelgänger Assistant integriert sich nahtlos in Doppelgänger-RFID-Hardware und Proxmark3-Geräte. Mit Doppelgänger-Lesegeräten erfasste Anmeldedaten können direkt in die GUI zur Analyse und zum Schreiben importiert werden. Die Anwendung unterstützt das Lesen von Karten mehrerer Hersteller, das Parsen der Daten aus der Webschnittstelle und das Ausführen von Schreibvorgängen mit Echtzeit-Statusaktualisierungen und Verifizierung.
## Änderungsprotokoll
### Version 1.1.2 (18. Dezember 2025)
**Neue Funktionen:**
* LAUNCH-PM3-Schaltfläche hinzugefügt, um Proxmark3 in einem separaten Terminalfenster zu öffnen
* Card Discovery-Abschnitt mit automatischer Kartentyperkennung hinzugefügt
* READ CARD DATA-Funktionalität für alle unterstützten Kartentypen hinzugefügt
* Abschnitt Hotel / Residence Access Control mit MIFARE-Werkzeugen hinzugefügt
* Dual-Chip-Kartenerkennung für Karten mit LF- und HF-Fähigkeiten hinzugefügt
* Automatischer Karteninfo-Abruf bei Erkennung von MIFARE-Karten hinzugefügt
**Verbesserungen:**
* Kartenerkennung verbessert, um spezifische MIFARE-Typen und Magic-Fähigkeiten anzuzeigen
* Kartenverifizierung mit klareren Erfolgsmeldungen verbessert
* Bessere Fehlerbehandlung und Benutzerfeedback in der gesamten Anwendung
* iCLASS-Kartenlesen mit automatischer Entschlüsselungsunterstützung verbessert
### Version 1.1.1
* Erste Veröffentlichung mit Kernfunktionen zum Kartenschreiben, Verifizieren und Simulieren
* Unterstützung für PROX-, iCLASS-, AWID-, Indala-, Avigilon-, EM4100-, PIV- und MIFARE-Karten
## Doppelgänger-Geräte
Sie können ein Stealth-Lesegerät, ein Doppelgänger Dev Board oder vollständig montierte Langstreckenlesegeräte im [Physical Exploitation Store](https://store.physicalexploit.com/) erwerben. Für die Open-Source-Firmware schauen Sie sich [Doppelgänger Core](https://github.com/mwgroup-io/Doppelganger_Core) an.
## Unterstützte Proxmark3-Geräte
Der Doppelgänger Assistant funktioniert mit dem [Iceman-Fork von Proxmark3](https://github.com/RfidResearchGroup/proxmark3) und unterstützt die folgenden Gerätetypen:
* **Proxmark3 RDV4** – Mit oder ohne Blueshark-Bluetooth-Addon
* **Proxmark3 Easy (512KB)** – Generische Plattformunterstützung
Die automatisierten Installationsprogramme fordern Sie während der Installation zur Auswahl Ihres Gerätetyps auf, um eine optimale Konfiguration zu gewährleisten.
## Unternehmens-PACS-Kartentypen
Nachfolgend sind die offiziell unterstützten PACS-Kartentypen für Unternehmen basierend auf der Doppelgänger-Firmware aufgeführt. Die Unterstützung für Hotel-/Mifare-Schlüsselkarten wurde in Version 1.1.2 mit Schlüsselwiederherstellung und Klonfunktionen hinzugefügt. Hinweis: Die Analyse von Hotel-Schlüsselkarten bzw. detaillierten Mifare-Analysen stimmt nicht mit den erfassten Daten von Doppelgänger-Produkten überein. Dies ist lediglich eine zusätzliche Funktion zur Unterstützung physischer Penetrationstests und wird als in Arbeit befindlich betrachtet.
| Kartentypen | Core | Stealth | FC-Bereich | CN-Bereich |
| --------------------------- | ---- | ------- | ----------- | --------------- |
| Keypad-PIN-Codes | | X | N/A | N/A |
| HID H10301 26-bit | X | X | 0–255 | 0–65.535 |
| Indala 26-bit | X | X | 0–255 | 0–65.535 |
| Indala 27-bit | X | X | 0–4.095 | 0–8.191 |
| 2804 WIEGAND 28-bit | X | X | 0–255 | 0–16.383 |
| Indala 29-bit | X | X | 0–4.095 | 0–32.767 |
| ATS Wiegand 30-bit | X | X | 0–2.047 | 0–32.767 |
| HID ADT 31-Bit | X | X | 0–15 | 0–8.388.607 |
| EM4102 / Wiegand 32-bit | X | X | 0–32.767 | 0–65.535 |
| HID D10202 33-bit | X | X | 0–127 | 0–16.777.215 |
| HID H10306 34-bit | X | X | 0–65.535 | 0–65.535 |
| HID Corporate 1000 35-bit | X | X | 0–4.095 | 0–1.048.575 |
| HID Simplex 36-bit (S12906) | X | X | 0–255 | 0–65.535 |
| HID H10304 37-bit | X | X | 0–65.535 | 0–524.287 |
| HID H800002 46-bit | X | X | 0–16.383 | 0–1.073.741.823 |
| HID Corporate 1000 48-bit | X | X | 0–4.194.303 | 0–8.388.607 |
| AWID 50-bit | X | X | 0–65.535 | 0–8.388.607 |
| Avigilon 56-bit | X | X | 0–1.048.575 | 0–4.194.303 |
| C910 PIVKey | X | X | N/A | N/A |
| MIFARE (Verschiedene Typen) | X | X | N/A | N/A |
Unterstützte Technologien umfassen:
* iCLASS (Legacy/SE/Seos) *Hinweis: Erfasste SE- und Seos-Karten können nur auf iCLASS-2k-Karten geschrieben werden*
* PROX
* Indala
* AWID
* Avigilon
* EM4102
* PIV (Nur UID – da dies über den Wiegand-Ausgang der Lesegeräte bereitgestellt wird)
* MIFARE (Nur UID – da dies über den Wiegand-Ausgang der Lesegeräte bereitgestellt wird)
## Detaillierte Installationsanweisungen
### Manuelle macOS-Installation
1. Laden Sie die passende DMG-Datei für Ihre Architektur von der [Release-Seite](https://github.com/tweathers-sec/doppelganger_assistant/releases) herunter:
- Apple Silicon (M1/M2/M3): `doppelganger_assistant_darwin_arm64.dmg`
- Intel: `doppelganger_assistant_darwin_amd64.dmg`
2. Öffnen Sie die DMG-Datei und ziehen Sie `doppelganger_assistant.app` in Ihren `/Applications`-Ordner
3. Entfernen Sie die Quarantäne-Attribute: ```sh
xattr -cr /Applications/doppelganger_assistant.app
~/.zshrc oder ~/.zprofile) hinzufügst: ```sh
alias doppelganger_assistant='/Applications/doppelganger_assistant.app/Contents/MacOS/doppelganger_assistant'
Option 1: Verwendung des .deb-Pakets (Debian/Ubuntu/Kali - Empfohlen)
Abhängigkeiten installieren: ```sh sudo apt update && sudo apt upgrade -y sudo apt install libgl1 xterm wget -y
Laden Sie das .deb-Paket für Ihre Architektur herunter und installieren Sie es: ```sh
wget https://github.com/tweathers-sec/doppelganger_assistant/releases/latest/download/doppelganger_assistant_linux_amd64.deb sudo dpkg -i doppelganger_assistant_linux_amd64.deb
wget https://github.com/tweathers-sec/doppelganger_assistant/releases/latest/download/doppelganger_assistant_linux_arm64.deb sudo dpkg -i doppelganger_assistant_linux_arm64.deb
Fehlende Abhängigkeiten beheben (falls erforderlich): ```sh sudo apt-get install -f -y
Option 2: Verwendung des tar.xz-Archivs (andere Distributionen)
Abhängigkeiten installieren: ```sh sudo apt update && sudo apt upgrade -y sudo apt install libgl1 xterm make git wget -y
Laden Sie herunter und installieren Sie für Ihre Architektur: ```sh
tar xvf doppelganger_assistant_linux_*.tar.xz cd doppelganger_assistant sudo make install cd .. rm -rf doppelganger_assistant
Um die Doppelganger-Assistant-GUI zu starten:```sh doppelganger_assistant
### Manuelle Windows-Installation (WSL)
1. **WSL aktivieren und eine Linux-Distribution installieren**. Öffnen Sie PowerShell als Administrator: ```powershell
# For Ubuntu 24.04 LTS (recommended):
wsl --install -d Ubuntu-24.04
# OR for Kali Linux:
wsl --install -d kali-linux
Windows neu starten. Nach dem Neustart schließt WSL die Einrichtung ab. Wenn Sie dazu aufgefordert werden, erstellen Sie einen Benutzernamen und ein Passwort für Ihre Linux-Umgebung.
Doppelganger Assistant installieren (innerhalb von WSL): ```sh sudo apt update && sudo apt upgrade -y sudo apt install libgl1 xterm wget -y
wget https://github.com/tweathers-sec/doppelganger_assistant/releases/latest/download/doppelganger_assistant_linux_amd64.deb sudo dpkg -i doppelganger_assistant_linux_amd64.deb
wget https://github.com/tweathers-sec/doppelganger_assistant/releases/latest/download/doppelganger_assistant_linux_arm64.deb sudo dpkg -i doppelganger_assistant_linux_arm64.deb
Installieren Sie Proxmark3-Abhängigkeiten: ```sh
sudo apt install --no-install-recommends -y git ca-certificates build-essential pkg-config
libreadline-dev gcc-arm-none-eabi libnewlib-dev qtbase5-dev
libbz2-dev liblz4-dev libbluetooth-dev libpython3-dev libssl-dev libgd-dev
Proxmark3 klonen und erstellen: ```sh mkdir -p ~/src && cd ~/src git clone https://github.com/RfidResearchGroup/proxmark3.git cd proxmark3
cp Makefile.platform.sample Makefile.platform
Um den Doppelganger-Assistenten zu starten:```sh doppelganger_assistant
## Aktualisierung
### Aktualisieren der Windows-Installation (WSL)
#### Automatische Aktualisierung (empfohlen)
Führen Sie das Aktualisierungsskript aus dem Installationsverzeichnis aus:```powershell
powershell -ExecutionPolicy Bypass -File C:\doppelganger_assistant\wsl_update.ps1
Oder direkt von GitHub herunterladen und ausführen:```powershell powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/scripts/wsl_update.ps1 | iex"
Das Update-Skript wird:
- Die neueste Doppelganger-Assistant-Binärdatei herunterladen
- Alle Skripte und Installationsprogramme aus dem Repository aktualisieren
- Proxmark3 aus dem Quellcode aktualisieren und neu erstellen
- Ihre WSL-Konfiguration und -Einstellungen beibehalten
### Aktualisieren einer macOS- oder Linux-Installation
Führen Sie das Installationsskript erneut aus. Es erkennt die vorhandene Installation und fordert Sie zur Aktualisierung auf:
**macOS:**```bash
bash <(curl -fsSL https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/installers/doppelganger_install_macos.sh)
Linux:```bash bash <(curl -fsSL https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/installers/doppelganger_install_linux.sh)
## Deinstallation
### Deinstallation unter Windows (WSL)
#### Automatische Deinstallation (Empfohlen)
Laden Sie den Deinstaller direkt von GitHub herunter und führen Sie ihn aus:```powershell
powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/scripts/uninstall.ps1 | iex"
Wenn Sie den Doppelganger Assistant installiert haben, führen Sie das Deinstallationsskript aus:```powershell powershell -ExecutionPolicy Bypass -File C:\doppelganger_assistant\uninstall.ps1
Der Deinstaller wird:
- WSL-Distributionen stoppen und abmelden (Kali-doppelganger_assistant oder Ubuntu-doppelganger_assistant)
- Alle Dateien aus `C:\doppelganger_assistant` entfernen
- Die Desktop-Verknüpfung löschen
- usbipd deinstallieren (es wird erneut installiert, wenn du den Installer erneut ausführst)
**Hinweis:** Das Skript verschiebt sich automatisch in ein temporäres Verzeichnis, um eine saubere Entfernung des Installationsverzeichnisses sicherzustellen.
### Deinstallation unter macOS
So deinstallierst du unter macOS:```bash
sudo rm -rf /Applications/doppelganger_assistant.app
sudo rm /usr/local/bin/doppelganger_assistant
Falls über das .deb-Paket installiert:```bash sudo apt remove doppelganger-assistant
**Falls über tar.xz-Archiv installiert:**```bash
sudo rm /usr/local/bin/doppelganger_assistant
rm -f ~/.local/share/applications/doppelganger_assistant.desktop
rm -f ~/Desktop/doppelganger_assistant.desktop
sudo rm /usr/share/pixmaps/doppelganger_assistant.png
Um Doppelganger Assistant aus dem Quellcode zu erstellen:```bash
git clone https://github.com/tweathers-sec/doppelganger_assistant.git cd doppelganger_assistant
./build.sh
./build_all.sh
### Projektstruktur
- **`src/`** - Enthält den gesamten Go-Quellcode und die Moduldateien
- **`installers/`** - Plattformspezifische Installationsskripte
- **`scripts/`** - Hilfsskripte für die WSL- und Windows-Einrichtung
- **`build.sh`** - Build-Skript für eine einzelne Plattform
- **`build_all.sh`** - Build-Skript für mehrere Plattformen mit fyne-cross
### Beitragen
1. Repository forken
2. Feature-Branch erstellen
3. Änderungen im Verzeichnis `src/` vornehmen
4. Änderungen mit `./build.sh` testen
5. Pull-Request einreichen
## Verwendung
### Starten der GUI
Die Doppelgänger-Assistant-GUI wird standardmäßig gestartet, wenn Sie die Anwendung ausführen:```sh
doppelganger_assistant
Oder starten Sie explizit im GUI-Modus:```sh doppelganger_assistant -g
### GUI-Workflow
1. **Kartentyp auswählen**: Wählen Sie aus PROX, iCLASS, AWID, Indala, Avilgon, EM4100, PIV oder MIFARE
2. **Bitlänge wählen**: Wählen Sie die passende Bitlänge für Ihren Kartentyp (wird automatisch basierend auf dem Kartentyp gefiltert)
3. **Kartendaten eingeben**: Geben Sie Facility-Code, Kartennummer, Hex-Daten oder UID ein, je nach Anforderung des ausgewählten Kartentyps
4. **Aktion wählen**:
- **Nur generieren**: Zeigt Proxmark3-Befehle zur manuellen Ausführung an, ohne zu schreiben
- **Schreiben und verifizieren**: Schreibt Kartendaten auf eine leere Karte und überprüft das Ergebnis
- **Karte simulieren**: Simuliert die Karte mit Ihrem Proxmark3-Gerät
5. **Ausführen**: Klicken Sie auf die Schaltfläche EXECUTE, um den Vorgang auszuführen
6. **Ausgabe überwachen**:
- **Statusausgabe** (oberes Feld): Farbcodierte Statusmeldungen mit Fortschritt des Vorgangs
- **Befehlsausgabe** (unteres Feld): Detaillierte Proxmark3-Befehlsergebnisse mit visuellen Trennzeichen
7. **Ergebnisse kopieren**: Klicken Sie auf COPY OUTPUT, um alle Befehlsergebnisse in die Zwischenablage zu kopieren
8. **Zurücksetzen**: Klicken Sie auf RESET, um alle Felder zu leeren und neu zu beginnen
Die dualen Ausgabefelder sorgen für eine klare Trennung zwischen Statusmeldungen und Befehlsergebnissen, wobei visuelle Trennzeichen (z. B. `|----------- WRITE #1 -----------|`) es einfach machen, mehrere Schreibversuche oder Verifizierungsschritte zu unterscheiden.
### Video-Demo
Im Folgenden finden Sie eine kurze Video-Demo zur Verwendung:
[](https://youtu.be/RfWKgS-U8ws)
### Beispiele für die Befehlszeilennutzung
#### Generieren von Befehlen zum Schreiben von iCLASS-Karten
Dieser Befehl generiert den Befehl, der benötigt wird, um iCLASS-Daten (Legacy/SE/Seos) auf eine iCLASS-2k-Karte zu kodieren:```sh
doppelganger_assistant -t iclass -bl 26 -fc 123 -cn 4567
[>>] Writing to iCLASS 2k card...
[>>] Command: hf iclass encode -w H10301 --fc 123 --cn 4567 --ki 0
Durch das Hinzufügen der Flags -w (schreiben) und -v (verifizieren) verwendet die Anwendung Ihren Proxmark3, um die Kartendaten zu schreiben und zu verifizieren:```sh
doppelganger_assistant -t iclass -bl 26 -fc 123 -cn 4567 -w -v
|----------- WRITE -----------| [..] Encoding iCLASS card data... [>>] Command: hf iclass encode -w H10301 --fc 123 --cn 4567 --ki 0
[=] Session log /Users/user/.proxmark3/logs/log_20250105120000.txt
[+] loaded /Users/user/.proxmark3/preferences.json
[+] execute command from commandline: hf iclass encode -w H10301 --fc 123 --cn 4567 --ki 0
[+] Using UART port /dev/tty.usbmodem101
[+] Communicating with PM3 over USB-CDC
[+] Encoding successful
[OK] Write complete - starting verification
|----------- VERIFICATION -----------| [..] Verifying card data - place card flat on reader...
[=] Session log /Users/user/.proxmark3/logs/log_20250105120005.txt [+] execute command from commandline: hf iclass rdbl --blk 7 --ki 0 [+] Using key[0] AE A6 84 A6 DA B2 32 78 [+] block 7/0x07 : 00 00 00 00 06 F6 23 AE
[OK] Verification successful - Block 7: 00 00 00 00 06 F6 23 AE [OK] Card contains: 26-bit, FC: 123, CN: 4567
#### Simulieren von PIV/MF-Karten
Mithilfe der von Doppelgänger (Core und Stealth) bereitgestellten UID können Sie das exakte wiegand-Signal mit einem Proxmark3 simulieren.```sh
doppelganger_assistant -uid 5AF70D9D -s -t piv
Handling PIV card...
Simulating the PIV card on your Proxmark3:
Executing command: hf 14a sim -t 3 --uid 5AF70D9D
[=] Session log /Users/tweathers/.proxmark3/logs/log_20240614152754.txt
[+] loaded `/Users/tweathers/.proxmark3/preferences.json`
[+] execute command from commandline: hf 14a sim -t 3 --uid 5AF70D9D
[+] Using UART port /dev/tty.usbmodem2134301
LF-Karten (Prox, AWID, Indala, Avigilon, EM) führen automatisch 5 Schreibversuche mit visuellen Trennzeichen durch:```sh doppelganger_assistant -t prox -bl 46 -fc 123 -cn 4567 -w
[..] Writing Prox card (5 attempts)...
|----------- WRITE #1 -----------| [+] Using UART port /dev/tty.usbmodem101 [+] Communicating with PM3 over USB-CDC [+] Wrote block successfully [..] Move card slowly... Write attempt #1 complete
|----------- WRITE #2 -----------| [+] Using UART port /dev/tty.usbmodem101 [+] Communicating with PM3 over USB-CDC [+] Wrote block successfully [..] Move card slowly... Write attempt #2 complete
|----------- WRITE #3 -----------| ... (continues for all 5 attempts)
[OK] All 5 write attempts complete
#### Avigilon-56-Bit-Karten schreiben
Avigilon-Karten werden wie andere LF-Karten mit 5 Versuchen geschrieben:```sh
doppelganger_assistant -t avigilon -bl 56 -fc 118 -cn 1603 -w
[..] Writing Avigilon card (5 attempts)...
|----------- WRITE #1 -----------|
[+] Using UART port /dev/tty.usbmodem101
[+] Communicating with PM3 over USB-CDC
lf hid clone -w Avig56 --fc 118 --cn 1603
[..] Move card slowly... Write attempt #1 complete
... (continues for all 5 attempts)
Mit den Avigilon-Kartendaten können Sie das exakte Signal mit einem Proxmark3 simulieren:```sh doppelganger_assistant -t avigilon -bl 56 -fc 118 -cn 1603 -s
Simulating the Avigilon card on your Proxmark3:
Executing command: lf hid sim -w Avig56 --fc 118 --cn 1603
Simulation is in progress... If your Proxmark3 has a battery, you can remove the device and the simulation will continue.
To end the simulation, press the pm3 button.
## Rechtlicher Hinweis
Diese Anwendung ist ausschließlich für professionelle Penetrationstests und autorisierte Sicherheitsbewertungen bestimmt. Die nicht autorisierte oder illegale Nutzung bzw. der Besitz dieser Software liegt in der alleinigen Verantwortung des Nutzers. Mayweather Group LLC, Practical Physical Exploitation und der Entwickler übernehmen keine Haftung für die illegale Anwendung dieser Software.
## Lizenz
[](https://creativecommons.org/licenses/by-nc-nd/4.0/)
Dieses Werk ist lizenziert unter einer [Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License](https://creativecommons.org/licenses/by-nc-nd/4.0/).
**Sie dürfen:**
* **Teilen** — das Material in jedwedem Medium oder Format kopieren und weiterverbreiten
**Unter den folgenden Bedingungen:**
* **Namensnennung** — Sie müssen angemessene Urheber- und Rechteangaben machen, einen Link zur Lizenz beifügen und angeben, ob Änderungen vorgenommen wurden.
* **Nicht kommerziell** — Sie dürfen das Material nicht für kommerzielle Zwecke nutzen.
* **Keine Bearbeitungen** — Wenn Sie das Material remixen, transformieren oder darauf aufbauen, dürfen Sie das bearbeitete Material nicht verbreiten.
Den vollständigen Lizenztext finden Sie in der Datei [LICENSE](https://github.com/tweathers-sec/doppelganger_assistant/blob/HEAD/LICENSE).
## Support
Für professionellen Support und Dokumentation besuchen Sie:
* [Practical Physical Exploitation Documentation](https://docs.physicalexploit.com/)
* [GitHub Issues](https://github.com/tweathers-sec/doppelganger_assistant/issues)
* [Professioneller Shop](https://store.physicalexploit.com/)
## Credits
Entwickelt von Travis Weathers ([@tweathers-sec](https://github.com/tweathers-sec))
Copyright © 2025 Mayweather Group, LLC
---
*Diese Software arbeitet in Verbindung mit [Doppelgänger Core](https://github.com/mwgroup-io/Doppelganger_Core) und Doppelgänger-Hardwaregeräten.*
nano Makefile.platform
make clean && make -j$(nproc) sudo make install PREFIX=/usr/local
Installieren Sie USBipd (von Windows PowerShell aus als Administrator): ```powershell winget install --interactive --exact dorssel.usbipd-win
Proxmark3 mit WSL verbinden (von Windows cmd.exe oder PowerShell als Administrator): ```powershell usbipd list # List USB devices - find your Proxmark3 (VID: 9ac4) usbipd bind --busid 9-1 # Replace 9-1 with your Proxmark3's busid usbipd attach --wsl --busid 9-1 # Attach to WSL