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
BaconSampler — Sniffa il traffico in uscita per callback sospette simili a beacon, perché se continua a tornare con regolarità, probabilmente non è colazione. | Kitploit
Strumenti/GitHubGitHub/logisek/baconsampler
Sniffing e Analisi dei PacchettiRicognizioneInformatica ForenseRaccolta InformazioniSicurezza di ReteThreat IntelligenceRilevamento IntrusioniAnalisi DNSAnalisi dei Log
GitHublogisek/baconsampler

BaconSampler

Sniffa il traffico in uscita per callback sospette simili a beacon, perché se continua a tornare con regolarità, probabilmente non è colazione.

2037 mesi faRevisionato da Kitploit
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

Bacon Sampler

Annusa il traffico in uscita alla ricerca di callback sospetti simili a beacon, perché se continua a tornare periodicamente, probabilmente non è colazione.

Connessioni in uscita (Windows + libpcap)

Bacon Sampler è un leggero catturatore di connessioni in uscita che annusa il traffico di rete e segnala comportamenti sospetti "simili a beacon" – quei callback periodici, lenti e costanti che il malware ama per comunicare con il server di comando.

Monitora passivamente le connessioni in uscita e le ricerche DNS, poi evidenzia pattern come intervalli costanti, destinazioni ripetute, jitter anomalo e dimensioni dei byte consistenti, insomma tutto ciò che assomiglia più a un bot che riceve istruzioni che a una normale navigazione.

Pensalo come uno Scanner di Beacon, ma più gustoso: se qualcosa continua a ripresentarsi sempre alla stessa ora... stiamo assaggiando il bacon.

Caratteristiche

  • Cattura Pcap con correlazione PID netstat opzionale
  • DNS inverso e GeoIP (database offline o ricerca online gratuita)
  • Filtri per protocollo, intervallo di porte remote e CIDR IP
  • Riepiloghi per gruppo (per IP remoto, processo o paese) con opzione primi N
  • Rilevamento di attività simili a beacon (callback lenti e costanti)
  • Rilevamento di pattern per comportamenti sospetti di connessione + query DNS
  • Esportazioni CSV/JSON con file di riepilogo derivati
  • Report HTML opzionale con tutte le tabelle

Prerequisiti

  • Windows 11
  • Python 3.10+
  • Npcap (consigliato) con "Install Npcap in WinPcap API-compatible Mode"
  • Database GeoIP per la ricerca offline del paese tramite IP:
    • MaxMind GeoLite2 Country (.mmdb) o DB-IP Lite (.mmdb)
    • IP2Location LITE (.BIN)
  • Esegui PowerShell come Amministratore per visibilità completa
  • Installazione

    root@kitploit:~
    pip install -r requirements.txt
    

    Scarica un database GeoIP e annota il percorso:

    • GeoLite2 o DB-IP Lite (.mmdb)
    • IP2Location LITE (.BIN)

    Se preferisci una ricerca online gratuita, puoi saltare questo passaggio e usare --geoip-online.

    Utilizzo

    Esempi di utilizzo (combinazioni comuni)

    Elenca interfacce:

    root@kitploit:~
    python capture_outbound.py --list-interfaces
    

    Scegli un'interfaccia per indice:

    root@kitploit:~
    python capture_outbound.py --interface 0
    

    Usa più interfacce (ripetibile):

    root@kitploit:~
    python capture_outbound.py --interface "Ethernet" --interface "Wi-Fi"
    

    Oppure con nomi separati da virgola:

    root@kitploit:~
    python capture_outbound.py --interfaces "Ethernet,Wi-Fi"
    

    Cattura solo Pcap (A) con GeoIP offline:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --geoip-db "C:\Path\GeoLite2-Country.mmdb"
    

    Cattura Pcap + correlazione netstat (B) con GeoIP offline:

    root@kitploit:~
    python capture_outbound.py --mode pcap_plus_netstat --duration 20 --interface "Ethernet" --geoip-db "C:\Path\GeoLite2-Country.mmdb"
    

    Unione Pcap + netstat (A+B):

    root@kitploit:~
    python capture_outbound.py --mode both --duration 20 --interface "Ethernet" --geoip-db "C:\Path\GeoLite2-Country.mmdb"
    

    GeoIP online (gratuito, con limite di richieste, memorizzato nella cache su disco):

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --geoip-online ipapi
    

    GeoIP online con token IPinfo:

    root@kitploit:~
    $env:IPINFO_TOKEN="your_token_here"
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --geoip-online ipinfo
    

    Oppure passa il token esplicitamente:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --geoip-online ipinfo --geoip-online-token "your_token_here"
    

    Regola timeout e tentativi del GeoIP online:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --geoip-online ipapi --geoip-timeout 2.5 --geoip-retries 1
    

    Disabilita DNS inverso (esecuzioni più veloci):

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --no-dns
    

    Regola timeout DNS:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --dns-timeout 0.5
    

    Limita la cattura per numero di pacchetti:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 60 --packet-limit 5000
    

    Filtra per protocollo, porta remota e CIDR IP:

    root@kitploit:~
    python capture_outbound.py --filter-protocol tcp --filter-port 80,443,1000-2000 --allow-ip 1.2.3.0/24 --deny-ip 1.2.3.4/32
    

    Riepiloghi per gruppo e primi N:

    root@kitploit:~
    python capture_outbound.py --group-by remote_ip,process --top 10
    

    Traccia i byte totali per connessione:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --track-bytes
    

    Disabilita output di avanzamento:

    root@kitploit:~
    python capture_outbound.py --no-progress
    

    Disabilita output console:

    root@kitploit:~
    python capture_outbound.py --no-console
    

    Esempi di utilizzo (combinazioni avanzate)

    Unione Pcap + netstat (A+B) + GeoIP online + Scrivi pcap + CSV + HTML:

    root@kitploit:~
    python capture_outbound.py --mode both --duration 20 --interface "Ethernet,Wi-Fi" --geoip-online ipapi --pcap-out "C:\Path\capture.pcap" --csv "C:\Path\outbound.csv" --html "C:\Path\outbound.html"
    

    Solo Pcap + cartella di output + nomi CSV/JSON personalizzati:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --output-dir "C:\Path\Reports" --csv "C:\Path\Reports\outbound.csv" --json "C:\Path\Reports\outbound.json"
    

    Rilevamento di attività simili a beacon (callback lenti e costanti):

    root@kitploit:~
    python capture_outbound.py --duration 300 --beacon-min-duration 120 --beacon-min-interval 60 --beacon-max-interval 1800 --beacon-max-jitter 10 --beacon-min-packets 6 --beacon-max-rate 0.05
    

    Rilevamento di pattern (intervalli costanti, jitter, destinazioni ripetute, dimensioni consistenti):

    root@kitploit:~
    python capture_outbound.py --duration 300 --track-bytes --pattern-high-jitter 120 --pattern-repeat-destination 4 --pattern-max-byte-jitter 64 --dns-pattern-min-queries 4
    

    Soglie strette per beacon + pattern con filtri:

    root@kitploit:~
    python capture_outbound.py --duration 600 --filter-protocol tcp --filter-port 443 --track-bytes --beacon-min-duration 180 --beacon-min-interval 90 --beacon-max-interval 900 --beacon-max-jitter 5 --beacon-min-packets 8 --pattern-high-jitter 60 --pattern-repeat-destination 5 --pattern-max-byte-jitter 32
    

    Cattura focalizzata su DNS (ricerca DNS veloce + pattern DNS):

    root@kitploit:~
    python capture_outbound.py --duration 180 --dns-timeout 0.25 --dns-pattern-min-queries 5 --pattern-repeat-destination 3
    

    Output

    • Tabella console di default
    • CSV: outbound_connections.csv
    • JSON: outbound_connections.json
    • HTML: --html "report.html"
    • Risultati beacon: *_beacon_findings.csv / *_beacon_findings.json
    • Pattern di connessione: *_connection_patterns.csv / *_connection_patterns.json
    • Pattern DNS: *_dns_patterns.csv / *_dns_patterns.json
    • Connessioni uniche: *_unique_connections.csv / *_unique_connections.json
    • Processi unici: *_unique_processes.csv / *_unique_processes.json
    • Riepiloghi per gruppo: *_group_remote_ip*.csv/json, *_group_process*.csv/json, *_group_country*.csv/json

    Percorsi personalizzati per output CSV/JSON:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --csv "C:\Path\outbound.csv" --json "C:\Path\outbound.json"
    

    Invia tutti gli output in una cartella:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --output-dir "C:\Path\Reports"
    

    Scrivi output HTML:

    root@kitploit:~
    python capture_outbound.py --html "outbound.html"
    

    Scrivi un file pcap:

    root@kitploit:~
    python capture_outbound.py --mode pcap --duration 20 --interface "Ethernet" --pcap-out "capture.pcap"
    

    Opzioni della riga di comando

    • --mode {pcap,pcap_plus_netstat,both}: Strategia di cattura (default: pcap)
    • --duration SECONDS: Durata della cattura (default: 15)
    • --packet-limit COUNT: Ferma dopo N pacchetti (0 = illimitato)
    • --list-interfaces: Mostra le interfacce Npcap ed esci
    • --interface NAME: Nome dell'interfaccia di cattura (ripetibile)
    • --interfaces "NAME,NAME": Nomi di interfaccia separati da virgola
    • --filter-protocol tcp,udp: Filtro protocollo (ripetibile o separato da virgola)
    • --filter-port 80,443,1000-2000: Filtri porta remota
    • --allow-ip CIDR: Consenti CIDR IP remoto(i)
    • --deny-ip CIDR: Nega CIDR IP remoto(i)
    • --group-by remote_ip,process,country: Output riepilogo per gruppo
    • --top N: Limita i riepiloghi di gruppo ai primi N risultati
    • --beacon-min-duration SECONDS: Durata minima per rilevamento beacon
    • --beacon-min-packets COUNT: Numero minimo di pacchetti per rilevamento beacon
    • --beacon-min-interval SECONDS: Intervallo medio minimo per rilevamento beacon
    • --beacon-max-interval SECONDS: Intervallo medio massimo per rilevamento beacon
    • --beacon-max-jitter SECONDS: Jitter massimo dell'intervallo per rilevamento beacon
    • --beacon-max-rate PPS: Pacchetti massimi al secondo per rilevamento beacon
    • --pattern-high-jitter SECONDS: Soglia di jitter dell'intervallo per pattern randomizzati
    • --pattern-repeat-destination COUNT: Connessioni minime per segnalare destinazioni ripetute
    • --pattern-max-byte-jitter BYTES: Intervallo massimo di dimensione in byte per consistenza
    • --dns-pattern-min-queries COUNT: Query DNS minime per segnalare pattern
    • --csv PATH: Percorso output CSV (default: outbound_connections.csv)
    • --json PATH: Percorso output JSON (default: outbound_connections.json)
    • --html PATH: Percorso output report HTML
    • --pcap-out PATH: Scrive i pacchetti catturati in un file pcap
    • --output-dir PATH: Scrive tutti i file di output in questa directory
    • --no-console: Disabilita output tabella console
    • --no-progress: Disabilita output di avanzamento
    • --log-json: Emette avvisi/errori come righe JSON su stderr
    • --track-bytes: Traccia i byte totali per connessione quando disponibile
    • --geoip-db PATH: Percorso database GeoIP (.mmdb o IP2Location .BIN)
    • --geoip-db-type {auto,maxmind,dbip,ip2location}: Tipo database GeoIP (default: auto)
    • --geoip-online {ipapi,ip-api,ipinfo}: Usa servizio GeoIP online gratuito (con limite di richieste)
    • --geoip-online-token TOKEN: Token API per provider GeoIP online (es. IPinfo)
    • --geoip-cache-path PATH: Override del percorso cache JSON GeoIP online
    • --geoip-timeout SECONDS: Timeout richiesta GeoIP online (default: 3.0)
    • --geoip-retries COUNT: Tentativi di ripetizione GeoIP online (default: 2)
    • --no-dns: Disabilita la risoluzione DNS inversa
    • --dns-timeout SECONDS: Timeout risoluzione DNS (default: 2.0)

    Dati di output

    Gli output principali (--csv/--json) includono i campi:

    • protocol, local_ip, local_port
    • remote_ip, remote_port, remote_hostname, remote_fqdn, remote_country
    • pid, process_name, packet_count
    • duration_seconds, avg_interval_seconds, interval_jitter_seconds
    • first_seen, last_seen, source
    • byte_count (quando --track-bytes è attivato)

    Gli output derivati includono:

    • Connessioni uniche: remote_ip, remote_port, remote_hostname, remote_fqdn, remote_country
    • Processi unici: pid, process_name, connection_count, unique_remote_ips
    • Riepiloghi per gruppo: conteggi e metriche uniche per remote_ip, process o country
    • Risultati beacon: campi dell'output principale più beacon_reason
    • Pattern di connessione: campi dell'output principale più pattern_type/pattern_reason, byte_min/byte_max/byte_range (con --track-bytes) e totali destinazione
    • Pattern DNS: dns_query, query_count, IP/porta risolutore, dettagli pattern e byte_min/byte_max/byte_range (con --track-bytes)

    Note

    • Usa PowerShell come Amministratore per catturare traffico elevato e mappare i PID.
    • --mode pcap_plus_netstat arricchisce solo le connessioni catturate con dati PID/processo.
    • --mode both aggiunge le connessioni solo netstat all'output finale.
    • Se la cattura dei pacchetti fallisce o Npcap/scapy è mancante, lo script ricade sui soli risultati netstat e termina con codice 2 dopo aver scritto gli output.
    • --log-json formatta avvisi/errori come righe JSON (utile per l'inserimento).
    • --duration è in secondi.
    • --packet-limit ferma la cattura dopo N pacchetti anche se la durata non è scaduta.
    • --no-dns salta la risoluzione DNS inversa (hostname/FQDN saranno vuoti).
    • --dns-timeout controlla i timeout della risoluzione DNS (secondi).
    • I risultati GeoIP online vengono memorizzati nella cache in geoip_online_cache.json nella directory di output (o directory di lavoro) a meno che non venga sovrascritto con --geoip-cache-path.
    • --geoip-db-type auto utilizza l'estensione del file: .mmdb -> MaxMind/DB-IP, .BIN -> IP2Location.
    • IPinfo restituisce codici paese ISO (es. US) invece dei nomi completi del paese.
    • Il rilevamento dei pattern DNS deriva dai pacchetti di query DNS catturati in modalità pcap.
    • Se --geoip-db viene omesso, la colonna remote_country rimane vuota a meno che non si usi --geoip-online.
    • Se sono impostati sia --geoip-db che --geoip-online, viene utilizzato il database.
    • --filter-port si applica alla porta remota (destinazione in uscita).
    • --track-bytes aggiunge colonne byte_count e abilita i pattern di consistenza delle dimensioni.
    Scarica lo strumento