Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/xuyw-seu/packetpatch
Sniffing et Analyse de PaquetsOutils de Chiffrement/DéchiffrementSécurité RéseauProtection de la Vie PrivéeApprentissage AutomatiqueArticles et RechercheApprentissage et ÉducationSécurité de l'IAAttaque Adversariale
GitHubxuyw-seu/packetpatch

PacketPatch

Génération pratique de paquets adverses en black-box contre la classification du trafic chiffré, avec une surcharge minimale et une récupérabilité complète des paquets.

717il y a 2 moisPas encore vérifié
Voir le dépôt

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

PacketPatch : Génération et déploiement pratiques de paquets adverses pour la classification du trafic chiffré basée sur des caractéristiques d'octets

Article : PacketPatch: Practical Generation and Deployment of Adversarial Packets for Byte-Feature-Based Encrypted Traffic Classification Auteurs : Yuwei Xu, Yuanyuan Xu, Yunpeng Bai, Jiahui Chen, Kehui Song, Jie Cao, Qiao Xiang, Guang Cheng Affiliation : Southeast University, Purple Mountain Laboratories, Tiangong University, Queen's University, Xiamen University Statut : Accepté/En cours d'examen (Elsevier)

Aperçu

PacketPatch est un schéma pratique de génération de paquets réseau adverses contre les modèles de classification du trafic chiffré basée sur des caractéristiques d'octets (B-ETC), visant à protéger la vie privée des utilisateurs. Contrairement aux méthodes existantes qui reposent sur des hypothèses de boîte blanche irréalistes ou introduisent une surcharge excessive, PacketPatch fonctionne dans des conditions strictes de boîte noire tout en maintenant des performances en temps réel et l'utilisabilité des paquets.

Caractéristiques principales

  • Fonctionnement en boîte noire : aucun accès aux gradients, paramètres ou données d'entraînement du modèle cible n'est requis
  • Indépendant de l'utilisateur : la génération de perturbation repose uniquement sur les caractéristiques du paquet courant, sans historique de comportement de l'utilisateur
  • Efficacité en temps réel : génération en un seul passage avant, latence moyenne d'environ 10 ms par paquet
  • Surcharge de bande passante contrôlable : longueur de perturbation ≤ 10 % de la taille du paquet d'origine
  • Validité et récupérabilité des paquets : l'architecture de proxy symétrique garantit que les paquets passent les contrôles d'intégrité et peuvent être parfaitement restaurés chez le destinataire
  • Architecture

    Architecture

    Flux de travail de PatchGenerator

    1. Préparation de l'entrée : séparer l'en-tête du paquet de la charge utile ; préparer les jetons [MASK] (longueur = 10 % de la taille du paquet)
    2. Construction de la séquence : assembler [CLS] + en-tête + Pad1 + [SEP] + en-tête_aléatoire(hr) + Pad2 + charge utile
    3. Génération de la perturbation : un seul passage avant BERT → distributions de probabilité sur le vocabulaire
      • Pad1 → arg min (perturbe au maximum les caractéristiques d'origine)
      • Pad2 → arg max (génère des caractéristiques alignées avec l'en-tête aléatoire)
    4. Assemblage du vecteur : perturbation finale v = Pad1 + hr + Pad2

    Structure du dépôt

    root@kitploit:~
    PacketPatch/
    ├── README.md                          # Aperçu du projet (ce fichier)
    ├── LICENSE                            # Licence MIT
    ├── requirements.txt                   # Dépendances Python
    ├── bert_base_config.json              # Configuration du modèle BERT (12 couches, 768 dims, 12 têtes)
    │
    ├── packet_adv/                        # ★ Code expérimental principal
    │   ├── README.md                      # Guide d'utilisation des modules principaux
    │   ├── adv_fine_tuning_cls.py         # Étape 1 : Entraîner PatchGenerator (SpanBERT)
    │   ├── generate.py                    # Étape 2 : Générer des paquets adverses
    │   └── gen_onnx.py                    # Étape 3 (optionnelle) : Accélération ONNX/TensorRT
    │
    ├── uer/                               # Framework UER (Universal Encoder Representations)
    │   ├── README.md                      # Documentation du framework
    │   ├── encoders/                      # Implémentations des encodeurs (Transformer, RNN, CNN)
    │   ├── layers/                        # Couches réseau (Embedding, Attention, FFN)
    │   ├── targets/                       # Objectifs d'entraînement (MLM, NSP, Span-MBM, etc.)
    │   ├── models/                        # Définition du modèle
    │   ├── utils/                         # Utilitaires (tokeniseurs, optimiseurs, chargement de données)
    │   ├── model_builder.py               # Construction du modèle
    │   ├── model_loader.py                # Chargement des poids pré-entraînés
    │   ├── model_saver.py                 # Sauvegarde des points de contrôle du modèle
    │   ├── trainer.py                     # Implémentation de la boucle d'entraînement
    │   └── opts.py                        # Définitions des arguments CLI
    │
    ├── dataset/                           # Documentation des jeux de données
    │   └── README.md                      # Descriptions des jeux de données, liens de téléchargement, prétraitement
    │
    ├── image/                             # Figures d'architecture et de résultats
    │   └── README.md                      # Descriptions des figures
    │
    └── tools/                             # Outils utilitaires
        └── README.md                      # Descriptions et utilisations des outils
    

    Démarrage rapide

    1. Configuration de l'environnement

    root@kitploit:~
    # Cloner ce dépôt
    git clone https://github.com/your-org/PacketPatch.git
    cd PacketPatch
    
    # Installer les dépendances
    pip install -r requirements.txt
    

    Prérequis :

    • Python 3.7+
    • GPU NVIDIA avec ≥ 6 Go de VRAM (recommandé : RTX 3080 ou supérieur)
    • 32 Go+ de mémoire système

    2. Préparer le modèle pré-entraîné et les jeux de données

    PacketPatch est construit sur ET-BERT. Téléchargez les éléments suivants depuis le dépôt ET-BERT :

    • pretrained_model.bin — Poids pré-entraînés d'ET-BERT
    • encryptd_vocab.txt — Fichier de vocabulaire pour l'encodage par paires d'octets

    Jeux de données : Nous évaluons sur trois jeux de données publics. Voir dataset/README.md pour les liens de téléchargement et les instructions de prétraitement.

    Jeu de donnéesClassesScénario
    ISCX-TOR16Trafic anonyme Tor
    ISCX-VPN11Tunnels VPN chiffrés
    USTC20Trafic malveillant + bénin

    3. Entraîner PatchGenerator

    root@kitploit:~
    cd packet_adv
    
    # Modifier adv_fine_tuning_cls.py d'abord :
    #   - Mettre à jour les chemins des jeux de données (lignes 47-50)
    #   - Mettre à jour le chemin du modèle pré-entraîné (lignes 73-75)
    #   - Définir le bon num_classes (ligne 56)
    #   - Définir la bonne taille de l'ensemble d'entraînement (ligne 878)
    
    python adv_fine_tuning_cls.py
    

    Le point de contrôle entraîné sera sauvegardé dans le répertoire de journalisation spécifié (par exemple, span_2seg_cls_log/).

    4. Générer des paquets adverses

    root@kitploit:~
    cd packet_adv
    
    # Modifier generate.py d'abord :
    #   - Mettre à jour les chemins des données de test (lignes 42-44)
    #   - Mettre à jour --load_model_path vers votre point de contrôle entraîné (lignes 68-69)
    #   - Définir BWO (ratio de surcharge de bande passante, ligne 60, défaut 0.1)
    #   - Choisir la stratégie de génération via le paramètre 'fun' (ligne 50)
    
    python generate.py
    

    5. (Optionnel) Accélération du modèle avec TensorRT

    root@kitploit:~
    cd packet_adv
    
    # Modifier gen_onnx.py d'abord :
    #   - Mettre à jour le chemin du point de contrôle du modèle (ligne 132)
    #   - Mettre à jour les chemins de sortie (lignes 145, 207)
    #   - Sélectionner le mode de précision : 'fp16' ou 'int8' (ligne 21)
    
    python gen_onnx.py
    

    Paramètres de configuration clés

    ParamètreFichierLigneDescriptionDéfaut
    BWOgenerate.py60Ratio de surcharge de bande passante0.1 (10 %)
    fungenerate.py50Stratégie de génération'fun5'
    n_epochsadv_fine_tuning_cls.py53Époques d'entraînement50
    batch_sizeadv_fine_tuning_cls.py54Taille de lot32
    num_classesadv_fine_tuning_cls.py56Nombre de classes de traficDépend du jeu de données
    learning_rateadv_fine_tuning_cls.py94-95Taux d'apprentissage2e-5
    seq_lengthadv_fine_tuning_cls.py92-93Longueur de séquence d'entrée256

    Stratégies de génération (paramètre fun)

    StratégieDescription
    fun1Segment unique, sélection argmin
    fun2Double segment, les deux en argmax
    fun3Double segment, répartition fixe 50/50, Pad1 argmin + Pad2 argmax
    fun4Double segment, répartition aléatoire, Pad1 argmin + Pad2 argmax
    fun5 (défaut)Double segment avec en-tête factice aléatoire, Pad1 argmin + Pad2 argmax
    fun6Double segment avec en-tête factice, stratégie guidée par NSP
    randomBaseline aléatoire
    random_dummy_headBaseline de remplacement d'en-tête aléatoire
    random_padBaseline de bourrage aléatoire

    Tâches d'entraînement

    Le PatchGenerator de PacketPatch est entraîné avec deux tâches auto-supervisées :

    SCP (Same Category Prediction — Prédiction de même catégorie)

    Détermine si deux paquets d'entrée appartiennent à la même catégorie de trafic. Cela dote le modèle de capacités d'extraction de caractéristiques discriminantes.

    Perte : Entropie croisée binaire

    Span-MBM (Span Masked Byte Modeling — Modélisation d'octets masqués par segments)

    Reconstruit des segments d'octets masqués consécutifs en utilisant le contexte bidirectionnel. Cela dote le modèle de capacités de génération de séquences d'octets conscientes du contexte.

    Perte : Log-vraisemblance négative Perte totale : Loss = Loss_SCP + Loss_Span-MBM

    Résumé des résultats

    Efficacité défensive (DSR : taux de succès défensif)

    Efficacité défensive

    Surcharge temporelle

    ÉtapeTemps (ms/paquet)
    Prétraitement du paquet0.054
    Génération de perturbation9.626
    Reconstruction du paquet0.398
    Total10.078

    PacketPatch surpasse les méthodes de référence en boîte blanche suivantes dans des conditions strictes de boîte noire :

    Comparaison avec les méthodes de référence

    Citation

    Si vous utilisez PacketPatch dans vos recherches, veuillez citer notre article :

    root@kitploit:~
    @article{xu2025packetpatch,
        title = {PacketPatch: Practical Generation and Deployment of Adversarial Packets for Byte-Feature-Based Encrypted Traffic Classification},
        author = {Yuwei Xu and Yuanyuan Xu and Yunpeng Bai and Jiahui Chen and Kehui Song and Jie Cao and Qiao Xiang and Guang Cheng},
        journal = {Elsevier},
        year = {2025},
    }
    

    Licence

    Ce projet est sous licence MIT — voir le fichier LICENSE pour plus de détails.

    Contact

    Pour toute question ou demande, veuillez contacter l'auteur correspondant ou ouvrir une issue sur GitHub.

    • Yuwei Xu — [email protected]
    • Yuanyuan Xu — [email protected]

    Remerciements

    Ce projet est construit sur le framework ET-BERT, qui fournit le modèle pré-entraîné et le framework d'entraînement UER (Universal Encoder Representations). Nous remercions les auteurs d'ET-BERT pour leurs précieuses contributions.

    Télécharger l’outil