Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/xuyw-seu/packetpatch
Sniffing e Analisi dei PacchettiStrumenti di Crittografia/DecrittografiaSicurezza di RetePrivacyMachine LearningPaper e RicercaApprendimento e FormazioneSicurezza dell'IAAttacco Avversario
GitHubxuyw-seu/packetpatch

PacketPatch

Generazione pratica di pacchetti avversari black-box contro la classificazione del traffico crittografato con overhead minimo e piena recuperabilità dei pacchetti.

7172 mesi faNon ancora revisionato
Vedi Repository

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

PacketPatch: Generazione e Implementazione Pratica di Pacchetti Avversariali per la Classificazione del Traffico Criptato Basata su Caratteristiche Byte

Articolo: PacketPatch: Practical Generation and Deployment of Adversarial Packets for Byte-Feature-Based Encrypted Traffic Classification Autori: Yuwei Xu, Yuanyuan Xu, Yunpeng Bai, Jiahui Chen, Kehui Song, Jie Cao, Qiao Xiang, Guang Cheng Affiliazioni: Southeast University, Purple Mountain Laboratories, Tiangong University, Queen's University, Xiamen University Stato: Accettato/In Revisione (Elsevier)

Panoramica

PacketPatch è uno schema pratico per generare pacchetti di rete avversariali contro modelli di Classificazione del Traffico Criptato Basata su Caratteristiche Byte (B-ETC), con l'obiettivo di proteggere la privacy dell'utente. A differenza dei metodi esistenti che si basano su presupposti white-box irrealistici o introducono un overhead eccessivo, PacketPatch opera in rigorose condizioni black-box mantenendo prestazioni in tempo reale e usabilità dei pacchetti.

Caratteristiche Principali

  • Operatività Black-Box: Nessun accesso richiesto ai gradienti, parametri o dati di training del modello target
  • Agnostico rispetto all'Utente: La generazione delle perturbazioni si basa esclusivamente sulle caratteristiche del pacchetto corrente, senza cronologia del comportamento dell'utente
  • Efficienza in Tempo Reale: Generazione con un singolo forward pass, latenza media ~10 ms per pacchetto
  • Overhead di Banda Controllabile: Lunghezza della perturbazione ≤ 10% della dimensione originale del pacchetto
  • Validità e Recuperabilità del Pacchetto: L'architettura proxy simmetrica garantisce che i pacchetti superino i controlli di integrità e possano essere perfettamente ripristinati al ricevitore
  • Architettura

    Architettura

    Flusso di Lavoro di PatchGenerator

    1. Preparazione dell'Input: Separare l'intestazione del pacchetto dal payload; preparare token [MASK] (lunghezza = 10% della dimensione del pacchetto)
    2. Costruzione della Sequenza: Assemblaggio di [CLS] + header + Pad1 + [SEP] + random_header(hr) + Pad2 + payload
    3. Generazione della Perturbazione: Singolo forward pass BERT → distribuzioni di probabilità sul vocabolario
      • Pad1 → arg min (disturba al massimo le caratteristiche originali)
      • Pad2 → arg max (genera caratteristiche allineate con l'header casuale)
    4. Assemblaggio del Vettore: Perturbazione finale v = Pad1 + hr + Pad2

    Struttura del Repository

    root@kitploit:~
    PacketPatch/
    ├── README.md                          # Project overview (this file)
    ├── LICENSE                            # MIT License
    ├── requirements.txt                   # Python dependencies
    ├── bert_base_config.json              # BERT model configuration (12 layers, 768-dim, 12 heads)
    │
    ├── packet_adv/                        # ★ Core experimental code
    │   ├── README.md                      # Usage guide for core modules
    │   ├── adv_fine_tuning_cls.py         # Step 1: Train PatchGenerator (SpanBERT)
    │   ├── generate.py                    # Step 2: Generate adversarial packets
    │   └── gen_onnx.py                    # Step 3 (optional): ONNX/TensorRT acceleration
    │
    ├── uer/                               # UER (Universal Encoder Representations) framework
    │   ├── README.md                      # Framework documentation
    │   ├── encoders/                      # Encoder implementations (Transformer, RNN, CNN)
    │   ├── layers/                        # Network layers (Embedding, Attention, FFN)
    │   ├── targets/                       # Training targets (MLM, NSP, Span-MBM, etc.)
    │   ├── models/                        # Model definition
    │   ├── utils/                         # Utilities (tokenizers, optimizers, data loading)
    │   ├── model_builder.py               # Model construction
    │   ├── model_loader.py                # Pretrained weight loading
    │   ├── model_saver.py                 # Model checkpoint saving
    │   ├── trainer.py                     # Training loop implementation
    │   └── opts.py                        # CLI argument definitions
    │
    ├── dataset/                           # Dataset documentation
    │   └── README.md                      # Dataset descriptions, download links, preprocessing
    │
    ├── image/                             # Architecture and result figures
    │   └── README.md                      # Figure descriptions
    │
    └── tools/                             # Utility tools
        └── README.md                      # Tool descriptions and usage
    

    Avvio Rapido

    1. Configurazione dell'Ambiente

    root@kitploit:~
    # Clone this repository
    git clone https://github.com/your-org/PacketPatch.git
    cd PacketPatch
    
    # Install dependencies
    pip install -r requirements.txt
    

    Requisiti:

    • Python 3.7+
    • GPU NVIDIA con ≥6GB di VRAM (consigliata: RTX 3080 o superiore)
    • 32GB+ di memoria di sistema

    2. Preparare il Modello Pre-Addestrato e i Dataset

    PacketPatch è basato su ET-BERT. Scaricare quanto segue dal repository ET-BERT:

    • pretrained_model.bin — Pesi pre-addestrati di ET-BERT
    • encryptd_vocab.txt — File del vocabolario per la codifica byte-pair

    Dataset: Valutiamo su tre dataset pubblici. Consultare dataset/README.md per i link di download e le istruzioni di pre-elaborazione.

    DatasetClassiScenario
    ISCX-TOR16Traffico anonimo Tor
    ISCX-VPN11Tunnel VPN criptati
    USTC20Traffico malware + benigno

    3. Addestrare PatchGenerator

    root@kitploit:~
    cd packet_adv
    
    # Edit adv_fine_tuning_cls.py first:
    #   - Update dataset paths (lines 47-50)
    #   - Update pretrained model path (lines 73-75)
    #   - Set correct num_classes (line 56)
    #   - Set correct training set size (line 878)
    
    python adv_fine_tuning_cls.py
    

    Il checkpoint addestrato verrà salvato nella directory di log specificata (ad es., span_2seg_cls_log/).

    4. Generare Pacchetti Avversariali

    root@kitploit:~
    cd packet_adv
    
    # Edit generate.py first:
    #   - Update test data paths (lines 42-44)
    #   - Update --load_model_path to your trained checkpoint (line 68-69)
    #   - Set BWO (bandwidth overhead ratio, line 60, default 0.1)
    #   - Choose generation strategy via 'fun' parameter (line 50)
    
    python generate.py
    

    5. (Opzionale) Accelerazione del Modello con TensorRT

    root@kitploit:~
    cd packet_adv
    
    # Edit gen_onnx.py first:
    #   - Update model checkpoint path (line 132)
    #   - Update output paths (lines 145, 207)
    #   - Select precision mode: 'fp16' or 'int8' (line 21)
    
    python gen_onnx.py
    

    Parametri di Configurazione Chiave

    ParametroFileRigaDescrizionePredefinito
    BWOgenerate.py60Rapporto di overhead di banda0.1 (10%)
    fungenerate.py50Strategia di generazione'fun5'
    n_epochsadv_fine_tuning_cls.py53Epoche di training50
    batch_sizeadv_fine_tuning_cls.py54Dimensione del batch32
    num_classesadv_fine_tuning_cls.py56Numero di classi di trafficoDipende dal dataset
    learning_rateadv_fine_tuning_cls.py94-95Tasso di apprendimento2e-5
    seq_lengthadv_fine_tuning_cls.py92-93Lunghezza della sequenza in input256

    Strategie di Generazione (parametro fun)

    StrategiaDescrizione
    fun1Singolo segmento, selezione argmin
    fun2Doppio segmento, entrambi argmax
    fun3Doppio segmento, split fisso 50/50, Pad1 argmin + Pad2 argmax
    fun4Doppio segmento, split casuale, Pad1 argmin + Pad2 argmax
    fun5 (predefinita)Doppio segmento con header dummy casuale, Pad1 argmin + Pad2 argmax
    fun6Doppio segmento con header dummy, strategia guidata da NSP
    randomBaseline casuale
    random_dummy_headBaseline sostituzione header casuale
    random_padBaseline padding casuale

    Compiti di Addestramento

    Il PatchGenerator di PacketPatch viene addestrato con due compiti auto-supervisionati:

    SCP (Predizione della Stessa Categoria)

    Determina se due pacchetti in input appartengono alla stessa categoria di traffico. Ciò fornisce al modello capacità di estrazione di caratteristiche discriminanti.

    Loss: Binary Cross-Entropy

    Span-MBM (Span Masked Byte Modeling)

    Ricostruisce span di byte mascherati consecutivi utilizzando il contesto bidirezionale. Ciò fornisce al modello capacità di generazione di sequenze di byte sensibili al contesto.

    Loss: Negative Log-Likelihood Loss Totale: Loss = Loss_SCP + Loss_Span-MBM

    Riepilogo dei Risultati

    Efficacia della Difesa (DSR: Tasso di Successo della Difesa)

    Efficacia della Difesa

    Overhead Temporale

    FaseTempo (ms/pacchetto)
    Pre-elaborazione del pacchetto0.054
    Generazione della perturbazione9.626
    Ricostruzione del pacchetto0.398
    Totale10.078

    PacketPatch supera i seguenti metodi baseline white-box in rigorose ipotesi black-box:

    Confronto con Metodi di Base

    Citazione

    Se utilizzi PacketPatch nella tua ricerca, ti preghiamo di citare il nostro articolo:

    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},
    }
    

    Licenza

    Questo progetto è concesso in licenza secondo i termini della MIT License — consultare il file LICENSE per i dettagli.

    Contatti

    Per domande e richieste, contattare l'autore corrispondente o aprire un issue su GitHub.

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

    Riconoscimenti

    Questo progetto è basato sul framework ET-BERT, che fornisce il modello pre-addestrato e il framework di addestramento UER (Universal Encoder Representations). Ringraziamo gli autori di ET-BERT per i loro preziosi contributi.

    Scarica lo strumento