Calculadora de cartões e Plugin Proxmark3 para gravar e/ou simular todos os tipos de cartão suportados pelo Doppelgänger Community, Pro, Stealth e MFAS.
Aplicativo GUI profissional para calcular dados de cartão e automatizar operações do Proxmark3 para todos os tipos de cartão suportados pelo Doppelgänger Core e Stealth. Esta ferramenta simplifica o processo de gravação de cartões para testes de penetração física, oferecendo uma interface intuitiva com exibições duplas de saída, separadores visuais e cópia para a área de transferência com um clique, eliminando a necessidade de memorizar sintaxes complexas do Proxmark3 ou consultar anotações.
Os instaladores automatizados instalarão o Doppelganger Assistant, as dependências necessárias e o fork Iceman do Proxmark3. Durante a instalação, você será solicitado a selecionar o tipo do seu dispositivo Proxmark3 para uma configuração ideal.
/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
Abra o PowerShell como Administrador e execute:```powershell irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/installers/doppelganger_install_windows.ps1 | iex
**Nota:** O instalador solicitará que você selecione entre **Ubuntu 24.04 LTS (Noble)** (recomendado) ou **Kali Linux**. Ele detectará automaticamente instalações existentes e solicitará a atualização. Se uma reinicialização for necessária para habilitar os recursos do WSL, você será notificado. Basta executar o mesmo comando novamente após reiniciar.
⚠️ IMPORTANTE: o WSL2 não oferece suporte à execução dentro de máquinas virtuais aninhadas. O instalador detecta automaticamente e impede a instalação nesses ambientes. Para prosseguir, instale em hardware físico.
## O que o Assistente Doppelgänger Pode Fazer
O Assistente Doppelgänger fornece um fluxo de trabalho completo de análise e clonagem de cartões, desde a detecção inicial até as operações de gravação bem-sucedidas. O aplicativo identifica automaticamente as tecnologias de cartão, extrai dados de credenciais, recupera chaves de criptografia e grava cartões clonados com verificação.
### Detecção Inteligente de Cartões
O recurso Card Discovery verifica automaticamente chips de Baixa Frequência (LF) e Alta Frequência (HF), identificando cartões de chip duplo e determinando tecnologias específicas de cartão, incluindo HID Prox, iCLASS, PicoPass, MIFARE e outras. Os resultados incluem dados Wiegand decodificados com facility codes e números de cartão quando disponíveis.
### Análise de Cartões-Chave de Hotel
A seção Hotel Access Control fornece ferramentas especializadas para sistemas de chave de hotel baseados em MIFARE. A recuperação de Card Info identifica automaticamente cartões-chave de hotel Saflok e exibe informações detalhadas do cartão, incluindo UID, tipo de cartão, capacidades magic e detecção de PRNG. A saída bruta do Proxmark3 inclui metadados abrangentes do Saflok quando disponíveis.
### Recuperação Automatizada de Chaves
As ferramentas de ataque MIFARE incluem vários métodos de recuperação: Autopwn (multimétodo automático), Darkside, Nested, Hardnested, Static Nested, Bruteforce e teste de vulnerabilidade NACK. O Autopwn seleciona automaticamente o melhor método de ataque com base nas características do cartão. Os resultados exibem resumos abrangentes de recuperação mostrando setores recuperados, total de chaves encontradas, métodos de recuperação utilizados e geração automática de arquivo dump para clonagem imediata do cartão.
### Operações com Cartões de Acesso Corporativo
A seção Corporate Access Control oferece suporte à leitura e gravação de iCLASS, PicoPass, AWID, HID Prox, Indala, Avigilon e outras tecnologias de cartão corporativo. Os dados do cartão são analisados automaticamente a partir da saída do Proxmark3 para extrair facility codes, números de cartão, comprimentos de bits, format types (H10301, C1k35s, etc.), valores CSN e dados hex brutos. O fluxo de trabalho integrado permite a gravação imediata em cartões em branco com verificação opcional.
### Fluxo de Trabalho Completo de Clonagem
O Assistente Doppelgänger integra-se perfeitamente ao hardware RFID Doppelgänger e aos dispositivos Proxmark3. Credenciais capturadas com leitores Doppelgänger podem ser importadas diretamente para a GUI para análise e gravação. O aplicativo suporta a leitura de cartões de vários fabricantes, o parsing dos dados da interface web e a execução de operações de gravação com atualizações de status em tempo real e verificação.
## Histórico de Alterações
### Versão 1.1.2 (18 de dezembro de 2025)
**Novos Recursos:**
* Adicionado botão LAUNCH PM3 para abrir o Proxmark3 em uma janela de terminal separada
* Adicionada seção Card Discovery com detecção automática do tipo de cartão
* Adicionada funcionalidade READ CARD DATA para todos os tipos de cartão suportados
* Adicionada seção Hotel / Residence Access Control com ferramentas MIFARE
* Adicionada detecção de cartões de chip duplo para cartões com capacidades LF e HF
* Adicionada recuperação automática de Card Info quando cartões MIFARE são detectados
**Melhorias:**
* Detecção de cartões aprimorada para exibir tipos MIFARE específicos e capacidades magic
* Verificação de cartões aprimorada com mensagens de sucesso mais claras
* Melhor tratamento de erros e feedback ao usuário em todo o aplicativo
* Leitura de cartões iCLASS aprimorada com suporte à descriptografia automática
### Versão 1.1.1
* Lançamento inicial com recursos principais de gravação, verificação e simulação de cartões
* Suporte para cartões PROX, iCLASS, AWID, Indala, Avigilon, EM4100, PIV e MIFARE
## Dispositivos Doppelgänger
Você pode comprar um leitor Stealth, um Doppelgänger Dev Board ou leitores de longo alcance totalmente montados na [Physical Exploitation Store](https://store.physicalexploit.com/). Para o firmware de código aberto, confira o [Doppelgänger Core](https://github.com/mwgroup-io/Doppelganger_Core).
## Dispositivos Proxmark3 Suportados
O Assistente Doppelgänger funciona com o [fork Iceman do Proxmark3](https://github.com/RfidResearchGroup/proxmark3) e suporta os seguintes tipos de dispositivos:
* **Proxmark3 RDV4** - Com ou sem o addon Bluetooth Blueshark
* **Proxmark3 Easy (512KB)** - Suporte genérico de plataforma
Os instaladores automatizados solicitarão que você selecione o tipo do seu dispositivo durante a instalação para uma configuração ideal.
## Tipos de Cartão Corporativo PACS
Abaixo estão os tipos de cartão corporativo PACS oficialmente suportados com base no firmware Doppelgänger. O suporte a cartões-chave de hotel/Mifare foi adicionado na versão 1.1.2 com recursos de recuperação de chaves e clonagem. Nota: a análise de cartões-chave de hotel / análise detalhada de Mifare não está alinhada com os dados capturados usando produtos Doppelgänger. Este é apenas um recurso adicional para apoiar esforços de testes de penetração física e é considerado um trabalho em andamento.
| Tipos de Cartão | Core | Stealth | Faixa FC | Faixa CN |
| --------------------------- | ---- | ------- | ----------- | --------------- |
| Códigos PIN de Teclado | | 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 (Vários Tipos) | X | X | N/A | N/A |
As tecnologias suportadas incluem:
* iCLASS(Legacy/SE/Seos) *Nota: cartões SE e Seos capturados só podem ser gravados em cartões iCLASS 2k*
* PROX
* Indala
* AWID
* Avigilon
* EM4102
* PIV (Apenas UID - pois é isso que é fornecido pela saída wiegand dos leitores)
* MIFARE (Apenas UID - pois é isso que é fornecido pela saída wiegand dos leitores)
## Instruções Detalhadas de Instalação
### Instalação Manual no MacOS
1. Baixe o arquivo DMG apropriado para sua arquitetura na [página de releases](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. Abra o arquivo DMG e arraste `doppelganger_assistant.app` para a pasta `/Applications`
3. Remova os atributos de quarentena: ```sh
xattr -cr /Applications/doppelganger_assistant.app
~/.zshrc ou ~/.zprofile): ```sh
alias doppelganger_assistant='/Applications/doppelganger_assistant.app/Contents/MacOS/doppelganger_assistant'
Opção 1: Usando pacote .deb (Debian/Ubuntu/Kali - Recomendado)
Instale as dependências: ```sh sudo apt update && sudo apt upgrade -y sudo apt install libgl1 xterm wget -y
Baixe e instale o pacote .deb para sua arquitetura: ```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
Corrija as dependências ausentes (se necessário): ```sh sudo apt-get install -f -y
Opção 2: Usando arquivo tar.xz (Outras distribuições)
Instale as dependências: ```sh sudo apt update && sudo apt upgrade -y sudo apt install libgl1 xterm make git wget -y
Baixe e instale para sua arquitetura: ```sh
tar xvf doppelganger_assistant_linux_*.tar.xz cd doppelganger_assistant sudo make install cd .. rm -rf doppelganger_assistant
Para iniciar a GUI do Doppelganger Assistant:```sh doppelganger_assistant
### Instalação Manual no Windows (WSL)
1. **Habilite o WSL e instale uma distribuição Linux**. Abra o PowerShell como Administrador: ```powershell
# For Ubuntu 24.04 LTS (recommended):
wsl --install -d Ubuntu-24.04
# OR for Kali Linux:
wsl --install -d kali-linux
Reinicie o Windows. Após reiniciar, o WSL concluirá a configuração. Quando for solicitado, crie um nome de usuário e uma senha para o seu ambiente Linux.
Instale o Doppelganger Assistant (dentro do 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
Instalar dependências do 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
Clonar e compilar o Proxmark3: ```sh mkdir -p ~/src && cd ~/src git clone https://github.com/RfidResearchGroup/proxmark3.git cd proxmark3
cp Makefile.platform.sample Makefile.platform
Para iniciar o Doppelganger Assistant:```sh doppelganger_assistant
## Atualização
### Atualizando a Instalação do Windows (WSL)
#### Atualização Automatizada (Recomendada)
Execute o script de atualização a partir do diretório de instalação:```powershell
powershell -ExecutionPolicy Bypass -File C:\doppelganger_assistant\wsl_update.ps1
Ou baixe e execute diretamente do GitHub:```powershell powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/scripts/wsl_update.ps1 | iex"
O script de atualização irá:
- Baixar o binário mais recente do Doppelganger Assistant
- Atualizar todos os scripts e instaladores do repositório
- Atualizar e recompilar o Proxmark3 a partir do código-fonte
- Preservar sua configuração e ajustes do WSL
### Atualizando a instalação no macOS ou Linux
Execute novamente o script de instalação. Ele detectará a instalação existente e solicitará que você atualize:
**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)
## Desinstalação
### Desinstalação no Windows (WSL)
#### Desinstalação Automatizada (Recomendada)
Baixe e execute o desinstalador diretamente do GitHub:```powershell
powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.com/tweathers-sec/doppelganger_assistant/main/scripts/uninstall.ps1 | iex"
Se você tem o Doppelganger Assistant instalado, execute o script de desinstalação:```powershell powershell -ExecutionPolicy Bypass -File C:\doppelganger_assistant\uninstall.ps1
O desinstalador irá:
- Parar e cancelar o registro das distribuições WSL (Kali-doppelganger_assistant ou Ubuntu-doppelganger_assistant)
- Remover todos os arquivos de `C:\doppelganger_assistant`
- Excluir o atalho da área de trabalho
- Desinstalar o usbipd (ele será reinstalado se você executar o instalador novamente)
**Nota:** O script se realoca automaticamente para um diretório temporário para garantir a remoção limpa do diretório de instalação.
### Desinstalando no macOS
Para desinstalar no macOS:```bash
sudo rm -rf /Applications/doppelganger_assistant.app
sudo rm /usr/local/bin/doppelganger_assistant
Se instalado via pacote .deb:```bash sudo apt remove doppelganger-assistant
**Se instalado via arquivo 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
Para compilar o Doppelganger Assistant a partir do código-fonte:```bash
git clone https://github.com/tweathers-sec/doppelganger_assistant.git cd doppelganger_assistant
./build.sh
./build_all.sh
### Estrutura do Projeto
- **`src/`** - Contém todo o código-fonte Go e arquivos de módulo
- **`installers/`** - Scripts de instalação específicos da plataforma
- **`scripts/`** - Scripts utilitários para configuração do WSL e do Windows
- **`build.sh`** - Script de build para plataforma única
- **`build_all.sh`** - Script de build multiplataforma usando fyne-cross
### Contribuindo
1. Faça um fork do repositório
2. Crie um branch de feature
3. Faça suas alterações no diretório `src/`
4. Teste suas alterações com `./build.sh`
5. Envie um pull request
## Uso
### Iniciando a GUI
A GUI do Assistente Doppelgänger é iniciada por padrão quando você executa o aplicativo:```sh
doppelganger_assistant
Ou lance explicitamente no modo GUI:```sh doppelganger_assistant -g
### Fluxo de trabalho da GUI
1. **Selecione o tipo de cartão**: Escolha entre PROX, iCLASS, AWID, Indala, Avigilon, EM4100, PIV ou MIFARE
2. **Escolha o comprimento de bits**: Selecione o comprimento de bits apropriado para o seu tipo de cartão (filtrado automaticamente com base no tipo de cartão)
3. **Insira os dados do cartão**: Insira o código da instalação, número do cartão, dados hex ou UID conforme exigido para o tipo de cartão selecionado
4. **Escolha a ação**:
- **Somente Gerar**: Exibe os comandos Proxmark3 para execução manual sem gravação
- **Gravar e Verificar**: Grava os dados do cartão em um cartão em branco e verifica o resultado
- **Simular Cartão**: Simula o cartão usando seu dispositivo Proxmark3
5. **Executar**: Clique no botão EXECUTAR para executar a operação
6. **Monitore a saída**:
- **Saída de status** (painel superior): Mensagens de status codificadas por cores com o progresso da operação
- **Saída de comandos** (painel inferior): Resultados detalhados dos comandos Proxmark3 com separadores visuais
7. **Copiar resultados**: Clique em COPIAR SAÍDA para copiar todos os resultados dos comandos para a área de transferência
8. **Redefinir**: Clique em REDEFINIR para limpar todos os campos e começar de novo
Os dois painéis de saída fornecem uma separação clara entre atualizações de status e resultados de comandos, com espaçadores visuais (por exemplo, `|----------- WRITE #1 -----------|`) facilitando a distinção entre várias tentativas de gravação ou etapas de verificação.
### Demonstração em Vídeo
Abaixo está uma demonstração em vídeo rápida do uso:
[](https://youtu.be/RfWKgS-U8ws)
### Exemplos de Uso via Linha de Comando
#### Gerando comandos para gravar cartões iCLASS
Este comando gerará o comando necessário para codificar dados de cartão iCLASS (Legacy/SE/Seos) em um cartão 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
Ao adicionar as flags -w (gravar) e -v (verificar), o aplicativo usará seu Proxmark3 para gravar e verificar os dados do cartão:```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
#### Simulando Cartões PIV/MF
Usando o UID fornecido pelo Doppelgänger (Core e Stealth), você pode simular o sinal wiegand exato com um 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
Cartões LF (Prox, AWID, Indala, Avigilon, EM) executam automaticamente 5 tentativas de gravação com separadores visuais:```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)
Usando os dados do cartão Avigilon, você pode simular o sinal exato com um 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.
## Aviso Legal
Este aplicativo destina-se exclusivamente a testes de penetração profissionais e avaliações de segurança autorizadas. O uso/posse não autorizado ou ilegal deste software é de responsabilidade exclusiva do usuário. A Mayweather Group LLC, a Practical Physical Exploitation e o criador não são responsáveis pelo uso ilegal deste software.
## Licença
[](https://creativecommons.org/licenses/by-nc-nd/4.0/)
Este trabalho está licenciado sob uma [Licença Creative Commons Atribuição-NãoComercial-SemDerivações 4.0 Internacional](https://creativecommons.org/licenses/by-nc-nd/4.0/).
**Você é livre para:**
* **Compartilhar** — copiar e redistribuir o material em qualquer meio ou formato
**Sob os seguintes termos:**
* **Atribuição** — Você deve dar o crédito apropriado, fornecer um link para a licença e indicar se foram feitas alterações.
* **NãoComercial** — Você não pode usar o material para fins comerciais.
* **SemDerivações** — Se você remixar, transformar ou criar a partir do material, não pode distribuir o material modificado.
Consulte o arquivo [LICENSE](https://github.com/tweathers-sec/doppelganger_assistant/blob/HEAD/LICENSE) para o texto completo da licença.
## Suporte
Para suporte profissional e documentação, visite:
* [Documentação da Practical Physical Exploitation](https://docs.physicalexploit.com/)
* [Issues do GitHub](https://github.com/tweathers-sec/doppelganger_assistant/issues)
* [Loja Profissional](https://store.physicalexploit.com/)
## Créditos
Desenvolvido por Travis Weathers ([@tweathers-sec](https://github.com/tweathers-sec))
Copyright © 2025 Mayweather Group, LLC
---
*Este software funciona em conjunto com o [Doppelgänger Core](https://github.com/mwgroup-io/Doppelganger_Core) e os dispositivos de hardware Doppelgänger.*
nano Makefile.platform
make clean && make -j$(nproc) sudo make install PREFIX=/usr/local
Instalar o USBipd (no Windows PowerShell como Administrador): ```powershell winget install --interactive --exact dorssel.usbipd-win
Conecte o Proxmark3 ao WSL (a partir do cmd.exe do Windows ou do PowerShell como Administrador): ```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