Calculateur de cartes et plugin Proxmark3 pour écrire et/ou simuler tous les types de cartes pris en charge par Doppelgänger Community, Pro, Stealth et MFAS.
Une application GUI professionnelle pour calculer les données de cartes et automatiser les opérations Proxmark3 pour chaque type de carte pris en charge par Doppelgänger Core et Stealth. Cet outil rationalise le processus d'écriture de cartes pour les tests de pénétration physiques en offrant une interface intuitive avec des affichages de sortie doubles, des séparateurs visuels et une copie dans le presse-papiers en un clic, éliminant ainsi le besoin de mémoriser la syntaxe complexe de Proxmark3 ou de fouiller dans des notes.
Les installateurs automatisés installeront Doppelganger Assistant, les dépendances requises, et la dernière version du fork Iceman de Proxmark3. Pendant l'installation, il vous sera demandé de sélectionner votre type de périphérique Proxmark3 pour une configuration optimale.
/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
Ouvrez PowerShell en tant qu'administrateur et exécutez :```powershell irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/installers/doppelganger_install_windows.ps1 | iex
**Remarque :** L'installateur vous demandera de choisir entre **Ubuntu 24.04 LTS (Noble)** (recommandé) ou **Kali Linux**. Il détectera automatiquement les installations existantes et vous demandera de mettre à jour. Si un redémarrage est nécessaire pour activer les fonctionnalités WSL, vous serez invité à le faire. Exécutez simplement la même commande après le redémarrage.
⚠️ IMPORTANT : WSL2 ne prend pas en charge l'exécution dans des machines virtuelles imbriquées. L'installateur détecte et empêche automatiquement l'installation dans de tels environnements. Pour continuer, installez sur du matériel physique.
## Ce que le Doppelgänger Assistant peut faire
Le Doppelgänger Assistant fournit un flux de travail complet d'analyse et de clonage de cartes, de la détection initiale aux opérations d'écriture réussies. L'application identifie automatiquement les technologies de cartes, extrait les données d'identification, récupère les clés de chiffrement et écrit des cartes clonées avec vérification.
### Détection intelligente de carte
La fonction Card Discovery analyse automatiquement les puces basse fréquence et haute fréquence, identifiant les cartes à double puce et déterminant les technologies de carte spécifiques, notamment HID Prox, iCLASS, PicoPass, MIFARE, etc. Les résultats incluent des données Wiegand décodées avec les codes d'établissement et les numéros de carte lorsqu'ils sont disponibles.
### Analyse de clé de carte hôtelière
La section Contrôle d'accès hôtelier fournit des outils spécialisés pour les systèmes de clés de cartes hôtelières basés sur MIFARE. La récupération des informations de carte identifie automatiquement les cartes clés hôtelières Saflok et affiche des informations détaillées sur la carte, notamment l'UID, le type de carte, les capacités magiques et la détection PRNG. La sortie brute du Proxmark3 inclut des métadonnées Saflok complètes lorsqu'elles sont disponibles.
### Récupération automatisée de clés
Les outils d'attaque MIFARE incluent plusieurs méthodes de récupération : Autopwn (multi-méthode automatique), Darkside, Nested, Hardnested, Static Nested, Bruteforce et test de vulnérabilité NACK. Autopwn sélectionne automatiquement la meilleure méthode d'attaque en fonction des caractéristiques de la carte. Les résultats affichent des résumés de récupération complets montrant les secteurs récupérés, le nombre total de clés trouvées, les méthodes de récupération utilisées et la génération automatique de fichiers dump pour un clonage immédiat de la carte.
### Opérations sur les cartes d'accès d'entreprise
La section Contrôle d'accès d'entreprise prend en charge la lecture et l'écriture de cartes iCLASS, PicoPass, AWID, HID Prox, Indala, Avigilon et d'autres technologies de cartes d'entreprise. Les données de la carte sont automatiquement extraites de la sortie du Proxmark3 pour obtenir les codes d'établissement, les numéros de carte, les longueurs de bits, les types de format (H10301, C1k35s, etc.), les valeurs CSN et les données hexadécimales brutes. Le flux de travail intégré permet une écriture immédiate sur des cartes vierges avec vérification optionnelle.
### Flux de travail de clonage complet
Le Doppelgänger Assistant s'intègre parfaitement au matériel RFID Doppelgänger et aux appareils Proxmark3. Les informations d'identification capturées avec les lecteurs Doppelgänger peuvent être directement importées dans l'interface graphique pour analyse et écriture. L'application prend en charge la lecture de cartes de plusieurs fabricants, l'analyse des données à partir de l'interface web et l'exécution d'opérations d'écriture avec des mises à jour de statut en temps réel et une vérification.
## Journal des modifications
### Version 1.1.2 (18 décembre 2025)
**Nouvelles fonctionnalités :**
* Ajout du bouton LAUNCH PM3 pour ouvrir Proxmark3 dans une fenêtre de terminal séparée
* Ajout de la section Card Discovery avec détection automatique du type de carte
* Ajout de la fonctionnalité READ CARD DATA pour tous les types de cartes pris en charge
* Ajout de la section Contrôle d'accès hôtel/résidence avec outils MIFARE
* Ajout de la détection de cartes à double puce pour les cartes possédant des capacités LF et HF
* Ajout de la récupération automatique des informations de carte lorsque des cartes MIFARE sont détectées
**Améliorations :**
* Amélioration de la détection de carte pour afficher les types MIFARE spécifiques et les capacités magiques
* Amélioration de la vérification de carte avec des messages de succès plus clairs
* Meilleure gestion des erreurs et retour utilisateur dans toute l'application
* Amélioration de la lecture de carte iCLASS avec prise en charge du déchiffrement automatique
### Version 1.1.1
* Version initiale avec les fonctionnalités principales d'écriture, de vérification et de simulation de cartes
* Prise en charge des cartes PROX, iCLASS, AWID, Indala, Avigilon, EM4100, PIV et MIFARE
## Appareils Doppelgänger
Vous pouvez acheter un lecteur Stealth, une carte de développement Doppelgänger ou des lecteurs longue portée entièrement assemblés sur le [Physical Exploitation Store](https://store.physicalexploit.com/). Pour le firmware open-source, consultez [Doppelgänger Core](https://github.com/mwgroup-io/Doppelganger_Core).
## Appareils Proxmark3 pris en charge
Le Doppelgänger Assistant fonctionne avec le [fork Iceman de Proxmark3](https://github.com/RfidResearchGroup/proxmark3) et prend en charge les types d'appareils suivants :
* **Proxmark3 RDV4** - Avec ou sans l'extension Bluetooth Blueshark
* **Proxmark3 Easy (512KB)** - Prise en charge de plateforme générique
Les installateurs automatisés vous demanderont de sélectionner votre type d'appareil lors de l'installation pour une configuration optimale.
## Types de cartes PACS d'entreprise
Voici les types de cartes PACS d'entreprise officiellement pris en charge basés sur le firmware Doppelgänger. La prise en charge des cartes clés d'hôtel/Mifare a été ajoutée dans la version 1.1.2 avec des capacités de récupération et de clonage de clés. Notez que l'analyse des cartes clés d'hôtel / l'analyse détaillée Mifare n'est pas alignée sur les données capturées à l'aide des produits Doppelgänger. Il s'agit simplement d'une fonctionnalité supplémentaire visant à soutenir les efforts de test de pénétration physique et est considérée comme un travail en cours.
| Types de carte | Core | Stealth | Plage FC | Plage CN |
| --------------------------- | ---- | ------- | ------------ | ----------------- |
| Codes PIN du clavier | | 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 (Various Types) | X | X | N/A | N/A |
Les technologies prises en charge incluent :
* iCLASS (Legacy/SE/Seos) *Remarque : Les cartes SE et Seos capturées ne peuvent être écrites que sur des cartes iCLASS 2k*
* PROX
* Indala
* AWID
* Avigilon
* EM4102
* PIV (UID uniquement - Car c'est ce qui est fourni via la sortie Wiegand des lecteurs)
* MIFARE (UID uniquement - Car c'est ce qui est fourni via la sortie Wiegand des lecteurs)
## Instructions d'installation détaillées
### Installation manuelle sur macOS
1. Téléchargez le fichier DMG approprié pour votre architecture depuis la [page des versions](https://github.com/tweathers-sec/doppelganger_assistant/releases) :
- Apple Silicon (M1/M2/M3) : `doppelganger_assistant_darwin_arm64.dmg`
- Intel : `doppelganger_assistant_darwin_amd64.dmg`
2. Ouvrez le fichier DMG et glissez `doppelganger_assistant.app` dans votre dossier `/Applications`
3. Supprimez les attributs de quarantaine : ```sh
xattr -cr /Applications/doppelganger_assistant.app
~/.zshrc ou ~/.zprofile): ```sh
alias doppelganger_assistant='/Applications/doppelganger_assistant.app/Contents/MacOS/doppelganger_assistant'
Option 1 : Utilisation du paquet .deb (Debian/Ubuntu/Kali - Recommandé)
Installer les dépendances : ```sh sudo apt update && sudo apt upgrade -y sudo apt install libgl1 xterm wget -y
Téléchargez et installez le paquet .deb pour votre architecture : ```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
Corrigez toutes les dépendances manquantes (si nécessaire) : ```sh sudo apt-get install -f -y
Option 2 : Utilisation de l'archive tar.xz (Autres distributions)
Installer les dépendances : ```sh sudo apt update && sudo apt upgrade -y sudo apt install libgl1 xterm make git wget -y
Téléchargez et installez pour votre architecture: ```sh
tar xvf doppelganger_assistant_linux_*.tar.xz cd doppelganger_assistant sudo make install cd .. rm -rf doppelganger_assistant
Pour lancer le Doppelganger Assistant GUI :```sh doppelganger_assistant
### Installation manuelle Windows (WSL)
1. **Activez WSL et installez une distribution Linux**. Ouvrez PowerShell en tant qu'Administrateur : ```powershell
# For Ubuntu 24.04 LTS (recommended):
wsl --install -d Ubuntu-24.04
# OR for Kali Linux:
wsl --install -d kali-linux
Redémarrez Windows. Après le redémarrage, WSL terminera l'installation. Lorsque vous y serez invité, créez un nom d'utilisateur et un mot de passe pour votre environnement Linux.
Installez Doppelganger Assistant (dans 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
Installer les dépendances Proxmark3: ```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
Cloner et construire Proxmark3 : ```sh mkdir -p ~/src && cd ~/src git clone https://github.com/RfidResearchGroup/proxmark3.git cd proxmark3
cp Makefile.platform.sample Makefile.platform
Pour lancer Doppelganger Assistant :```sh doppelganger_assistant
## Mise à jour
### Mise à jour de l'installation Windows (WSL)
#### Mise à jour automatisée (recommandée)
Exécutez le script de mise à jour depuis le répertoire d'installation :```powershell
powershell -ExecutionPolicy Bypass -File C:\doppelganger_assistant\wsl_update.ps1
Ou téléchargez et exécutez directement depuis GitHub:```powershell powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/scripts/wsl_update.ps1 | iex"
The update script will:
- Download the latest Doppelganger Assistant binary
- Mettre à jour tous les scripts et installateurs depuis le dépôt
- Mettre à jour et reconstruire Proxmark3 depuis les sources
- Préserver votre configuration et paramètres WSL
### Mise à jour de l'installation macOS ou Linux
Réexécutez le script d'installation. Il détectera l'installation existante et vous demandera de mettre à jour :
**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)
## Uninstallation
### Désinstallation depuis Windows (WSL)
#### Désinstallation automatisée (Recommandée)
Téléchargez et exécutez le désinstalleur directement depuis GitHub:```powershell
powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/scripts/uninstall.ps1 | iex"
Si vous avez Doppelganger Assistant installé, exécutez le script de désinstallation :```powershell powershell -ExecutionPolicy Bypass -File C:\doppelganger_assistant\uninstall.ps1
Le désinstalleur va:
- Arrêter et désenregistrer les distributions WSL (Kali-doppelganger_assistant ou Ubuntu-doppelganger_assistant)
- Supprimer tous les fichiers de `C:\doppelganger_assistant`
- Supprimer le raccourci du bureau
- Désinstaller usbipd (il sera réinstallé si vous exécutez à nouveau l'installateur)
**Remarque:** Le script se déplace automatiquement vers un répertoire temporaire pour garantir une suppression propre du répertoire d'installation.
### Désinstallation sous macOS
Pour désinstaller sous macOS :```bash
sudo rm -rf /Applications/doppelganger_assistant.app
sudo rm /usr/local/bin/doppelganger_assistant
Si installé via le paquet .deb :```bash sudo apt remove doppelganger-assistant
**Si installé via l'archive tar.xz :**```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
Pour construire Doppelganger Assistant à partir des sources :```bash
git clone https://github.com/tweathers-sec/doppelganger_assistant.git cd doppelganger_assistant
./build.sh
./build_all.sh
### Structure du projet
- **`src/`** - Contient tous les fichiers sources Go et les fichiers de module
- **`installers/`** - Scripts d'installation spécifiques à la plateforme
- **`scripts/`** - Scripts utilitaires pour la configuration WSL et Windows
- **`build.sh`** - Script de construction pour une seule plateforme
- **`build_all.sh`** - Script de construction multi-plateforme utilisant fyne-cross
### Contribution
1. Forker le dépôt
2. Créer une branche de fonctionnalité
3. Effectuer vos modifications dans le répertoire `src/`
4. Tester vos modifications avec `./build.sh`
5. Soumettre une pull request
## Utilisation
### Lancement de l'interface graphique
L'interface graphique de l'Assistant Doppelgänger se lance par défaut lorsque vous exécutez l'application :```sh
doppelganger_assistant
Ou lancez explicitement en mode GUI:```sh doppelganger_assistant -g
### Flux de travail de l'interface graphique
1. **Sélectionner le type de carte** : Choisir parmi PROX, iCLASS, AWID, Indala, Avigilon, EM4100, PIV ou MIFARE
2. **Choisir la longueur de bits** : Sélectionner la longueur de bits appropriée pour votre type de carte (filtrée automatiquement en fonction du type de carte)
3. **Saisir les données de la carte** : Saisir le code d'installation, le numéro de carte, les données hexadécimales ou l'UID selon le type de carte sélectionné
4. **Choisir une action** :
- **Générer uniquement** : Affiche les commandes Proxmark3 pour une exécution manuelle sans écriture
- **Écrire et vérifier** : Écrit les données de la carte sur une carte vierge et vérifie le résultat
- **Simuler la carte** : Simule la carte à l'aide de votre appareil Proxmark3
5. **Exécuter** : Cliquer sur le bouton EXÉCUTER pour lancer l'opération
6. **Surveiller la sortie** :
- **Sortie d'état** (panneau supérieur) : Messages d'état codés par couleur avec progression de l'opération
- **Sortie de commande** (panneau inférieur) : Résultats détaillés des commandes Proxmark3 avec séparateurs visuels
7. **Copier les résultats** : Cliquer sur COPIER LA SORTIE pour copier tous les résultats de commande dans le presse-papiers
8. **Réinitialiser** : Cliquer sur RÉINITIALISER pour effacer tous les champs et recommencer
Les deux panneaux de sortie offrent une séparation claire entre les mises à jour d'état et les résultats de commande, avec des séparateurs visuels (par exemple, `|----------- WRITE #1 -----------|`) facilitant la distinction entre plusieurs tentatives d'écriture ou étapes de vérification.
### Démo vidéo
Voici une courte démonstration vidéo de l'utilisation :
[](https://youtu.be/RfWKgS-U8ws)
### Exemples d'utilisation en ligne de commande
#### Génération de commandes pour l'écriture de cartes iCLASS
Cette commande génère la commande nécessaire pour encoder les données d'une carte iCLASS (Legacy/SE/Seos) sur une carte iCLASS 2k :```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
En ajoutant les drapeaux -w (write) et -v (verify), l'application utilisera votre Proxmark3 pour écrire et vérifier les données de la carte :```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
#### Simulation de cartes PIV/MF
En utilisant l'UID fourni par Doppelgänger (Core et Stealth), vous pouvez simuler le signal wiegand exact avec un Proxmark3.```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
Les cartes LF (Prox, AWID, Indala, Avigilon, EM) effectuent automatiquement 5 tentatives d'écriture avec séparateurs visuels :```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
#### Writing Avigilon 56-bit cards
Avigilon cards are written with 5 attempts like other LF cards:```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)
En utilisant les données de carte Avigilon, vous pouvez simuler le signal exact avec un Proxmark3 :```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.
## Avis juridique
Cette application est destinée exclusivement aux tests de pénétration professionnels et aux évaluations de sécurité autorisées. Toute utilisation ou possession non autorisée ou illégale de ce logiciel relève de la seule responsabilité de l'utilisateur. Mayweather Group LLC, Practical Physical Exploitation et le créateur déclinent toute responsabilité en cas d'application illégale de ce logiciel.
## Licence
[](https://creativecommons.org/licenses/by-nc-nd/4.0/)
Ce travail est sous licence [Creative Commons Attribution - Pas d'Utilisation Commerciale - Pas de Modification 4.0 International](https://creativecommons.org/licenses/by-nc-nd/4.0/).
**Vous êtes autorisé à :**
* **Partager** — copier et redistribuer le matériel sur tout support ou format
**Selon les conditions suivantes :**
* **Attribution** — Vous devez créditer l'œuvre, fournir un lien vers la licence et indiquer si des modifications ont été effectuées.
* **Pas d'Utilisation Commerciale** — Vous n'êtes pas autorisé à utiliser ce matériel à des fins commerciales.
* **Pas de Modification** — Si vous remixez, transformez ou construisez à partir du matériel, vous ne pouvez pas distribuer le matériel modifié.
Consultez le fichier [LICENSE](https://github.com/tweathers-sec/doppelganger_assistant/blob/HEAD/LICENSE) pour le texte complet de la licence.
## Support
Pour un support professionnel et de la documentation, visitez :
* [Documentation Practical Physical Exploitation](https://docs.physicalexploit.com/)
* [Problèmes GitHub](https://github.com/tweathers-sec/doppelganger_assistant/issues)
* [Boutique professionnelle](https://store.physicalexploit.com/)
## Crédits
Développé par Travis Weathers ([@tweathers-sec](https://github.com/tweathers-sec))
Copyright © 2025 Mayweather Group, LLC
---
*Ce logiciel fonctionne conjointement avec [Doppelgänger Core](https://github.com/mwgroup-io/Doppelganger_Core) et les dispositifs matériels Doppelgänger.*
nano Makefile.platform
make clean && make -j$(nproc) sudo make install PREFIX=/usr/local
Installer USBipd (depuis Windows PowerShell en tant qu'administrateur) : ```powershell winget install --interactive --exact dorssel.usbipd-win
Connecter Proxmark3 à WSL (depuis cmd.exe ou PowerShell de Windows en tant qu'Administrateur) : ```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