appneta/tcpreplayModifica e riproduci il traffico di rete catturato a velocità arbitrarie — una suite di strumenti pcap per *NIX e Windows.
<p align="center">
<img src="https://raw.githubusercontent.com/appneta/tcpreplay/master/docs/guide/assets/images/logo.svg" alt="" width="96" height="96">
</p>
<h1 align="center">Tcpreplay</h1>
[](https://github.com/appneta/tcpreplay/actions/workflows/github-actions-ci.yml)
[](https://scan.coverity.com/projects/12017)
[](https://github.com/appneta/tcpreplay/actions/workflows/codeql.yml)
[](https://github.com/appneta/tcpreplay/actions/workflows/c-linter.yml)
[](https://tcpreplay.appneta.com)
[](https://github.com/appneta/tcpreplay/releases)
Tcpreplay è una suite di utilità con licenza [GPLv3] per UNIX (e Windows sotto
[Cygwin]) per modificare e riprodurre traffico di rete precedentemente catturato da
strumenti come [tcpdump] e [Wireshark]. Classifica il traffico come client o
server, riscrive le intestazioni di Livello 2/3/4 e lo riproduce sulla rete
attraverso switch, router, firewall, NIDS e IPS — a qualsiasi velocità, da un
flusso minimo fino alla piena velocità del collegamento. Tcpreplay supporta sia la
modalità a singola NIC che a doppia NIC, per testare sia dispositivi di sniffing che in-line.
Tcpreplay è utilizzato da numerosi fornitori di firewall, IDS, IPS, NetFlow e altre
soluzioni di networking, aziende, università, laboratori e progetti
open source. Se la tua organizzazione utilizza Tcpreplay, faccelo sapere: chi
sei e per cosa lo usi, così possiamo continuare a dare priorità alle funzionalità che
contano.
Dalla versione 4.0, Tcpreplay è anche specificamente orientato al testing di
appliance [IP Flow][flow]/[NetFlow]: temporizzazione accurata della riproduzione ad alta velocità e reportistica dei risultati,
statistiche Flows Per Second (fps) e analisi della scadenza dei flussi per ottimizzare le
impostazioni di timeout di un prodotto flow — fino a centinaia di migliaia di flussi/sec,
a seconda delle dimensioni dei flussi nel file pcap.
📖 **La documentazione completa è disponibile su <https://tcpreplay.appneta.com>** — una
guida introduttiva, una pagina per ogni strumento, ricette pratiche, i concetti alla base della
suite, le pagine man e le FAQ. Questo README è la panoramica rapida; il sito è
il riferimento.
- [La suite](#the-suite)
- [Novità nella 4.6](#whats-new-in-46)
- [Installare una release](#installing-a-release)
- [Compilare dai sorgenti](#building-from-source)
- [Autotools](#autotools)
- [CMake](#cmake-recommended)
- [Prestazioni: netmap, AF\_XDP, io\_uring](#performance-netmap-af_xdp-io_uring)
- [Riproduzione su interfacce IP raw (L3)](#replaying-onto-raw-ip-l3-interfaces)
- [Libreria C libtcpreplay](#libtcpreplay-c-library)
- [Eseguire la suite di test](#running-the-test-suite)
- [Ottenere aiuto](#getting-help)
- [Contribuire](#contributing)
- [Licenza](#license)
- [Autori](#authors)
La Suite
=========
Riproduzione di rete:
--------------------------
* **tcpreplay** / **tcpreplay-edit** — riproduce file pcap a velocità arbitrarie
sulla rete, modificando opzionalmente i pacchetti al volo (`tcpreplay-edit`)
o randomizzando gli indirizzi IP (`tcpreplay`)
* **tcpliveplay** — riproduce una sessione TCP catturata su una rete live in modo
che un server remoto risponda effettivamente (contribuito da Yazan
Siam, sponsorizzato da [Cisco], per testare l'intero stack di rete fino al
livello applicativo — il normale `tcpreplay` rimane di solito al Livello 2)
Editor e utilità per file pcap:
--------------------------------
* **tcpprep** — pre-processore pcap multi-pass che classifica i pacchetti come
client o server e scrive un file di cache consumato da tcpreplay/tcprewrite
* **tcprewrite** — riscrive le intestazioni dei pacchetti TCP/IP e di Livello 2 in un file pcap
* **tcpbridge** — collega due segmenti di rete usando la logica di riscrittura di tcprewrite
* **tcpcapinfo** — decodificatore e debugger di file pcap raw
Novità nella 4.6
==================
* [CMake](#cmake-recommended) è ora il sistema di build principale e consigliato
(autotools è ancora utilizzato per i tarball di rilascio)
* [io_uring](#performance-netmap-af_xdp-io_uring) e
[AF_XDP](#performance-netmap-af_xdp-io_uring) per l'iniezione di pacchetti sul fast-path,
insieme al supporto netmap esistente — entrambi richiedono meno configurazione rispetto a netmap
e nessun driver modificato
* [libtcpreplay](#libtcpreplay-c-library), una libreria C statica per incorporare
il motore di replay direttamente nel proprio programma
* Supporto automatico per il [replay su interfacce IP raw (L3)](#replaying-onto-raw-ip-l3-interfaces)
come WireGuard e dispositivi tun
Consultare il [CHANGELOG](https://github.com/appneta/tcpreplay/blob/master/docs/CHANGELOG) per la cronologia completa delle release.
Installazione di una Release
=====================
[](https://github.com/appneta/tcpreplay/releases)
[](https://sourceforge.net/projects/tcpreplay)
Scaricare l'ultimo [tarball di rilascio](https://github.com/appneta/tcpreplay/releases/latest)
(disponibile anche su [SourceForge](https://sourceforge.net/projects/tcpreplay)),
poi:
```
tar xf tcpreplay-*.tar.xz && cd tcpreplay-*
./configure && make && sudo make install
```
Un tarball di rilascio include i parser CLI e le pagine man pre-generati, quindi non
serve altro oltre a un compilatore C e libpcap — vedi
[Compilazione dal sorgente](#building-from-source) qui sotto solo se stai lavorando
da un checkout git, oppure se vuoi il supporto a CMake, netmap, AF_XDP o io_uring.
Istruzioni più dettagliate specifiche per piattaforma sono nel file `INSTALL`
incluso nel tarball (stesso contenuto di [`docs/INSTALL`](https://github.com/appneta/tcpreplay/blob/master/docs/INSTALL) qui).
Compilazione dal sorgente
=====================
La compilazione da un checkout git richiede `python3` e `asciidoctor` (con
entrambi i sistemi di build) per generare i parser delle opzioni CLI e le pagine man dai
file `*_opts.def` — questo ha sostituito GNU AutoGen per tale scopo nella 4.6
(AutoGen è EOL; questi no). AutoGen stesso è ancora necessario solo per un
header interno (`src/tcpedit/tcpedit_stub.h`) — vedi
[`scripts/autoopts/README.md`](https://github.com/appneta/tcpreplay/blob/master/scripts/autoopts/README.md). Nulla di tutto ciò è
necessario quando si compila un tarball di rilascio, che include già questi file generati.
Autotools
---------
```
./autogen.sh # only needed once, from a git checkout
./configure
make
sudo make install
```
CMake (consigliato)
--------------------
A partire dalla versione 4.6, la suite può essere compilata anche con [CMake](https://cmake.org)
(3.16+) — **il modo consigliato e principale per compilare Tcpreplay**.
Autotools è ancora fornito e utilizzato per i tarball di rilascio, ma
verrà eventualmente ritirato, quindi i nuovi script/pacchetti dovrebbero puntare a CMake.
```
cmake -B build
cmake --build build
sudo cmake --install build
```
Ogni flag di `./configure` ha un equivalente CMake — vedi la tabella all'inizio di [`CMakeLists.txt`](https://github.com/appneta/tcpreplay/blob/master/CMakeLists.txt). Alcuni esempi:
```
# debug build with support for the -d option
cmake -B build -DENABLE_DEBUG=ON
# AddressSanitizer or ThreadSanitizer build
cmake -B build -DENABLE_ASAN=ON
cmake -B build -DENABLE_TSAN=ON
# custom libpcap install, static linking, custom tcpdump path
cmake -B build -DWITH_LIBPCAP=/usr/local/opt/libpcap \
-DENABLE_STATIC_LINK=ON -DWITH_TCPDUMP=/usr/sbin/tcpdump
# force a specific packet injection method
cmake -B build -DFORCE_INJECT_PCAP_SENDPACKET=ON
# several configurations side by side
cmake -B build-debug -DENABLE_DEBUG=ON
cmake -B build-release
```
`cmake --build build --target manpages` rigenera le pagine man
(python3 + asciidoctor); un semplice `cmake --build build` non le tocca mai.
Gli utenti di VS Code con l'estensione CMake Tools possono semplicemente aprire la cartella
del repository e scegliere un preset di configurazione quando richiesto.
Prestazioni: netmap, AF_XDP, io_uring
--------------------------------------
Se il percorso socket predefinito non è abbastanza veloce, Tcpreplay dispone di tre
modi a basso overhead per inviare pacchetti direttamente alla NIC. Provali all'incirca in
quest'ordine — io_uring richiede la configurazione minima, netmap quella massima:
<details>
<summary><b>io_uring</b> (Linux, richiede <code>liburing-dev</code> — nessun driver modificato necessario)</summary>
Rilevato su sistemi Linux con `liburing-dev` installato e un kernel con
supporto [io_uring](https://man7.org/linux/man-pages/man7/io_uring.7.html).
I pacchetti vengono comunque inviati tramite un normale socket raw PF_PACKET, ma gli invii vengono
sottomessi in modo asincrono attraverso una coda io_uring, riducendo l'overhead delle syscall
per singolo pacchetto.
```
sudo apt-get install liburing-dev
cmake -B build && cmake --build build && sudo cmake --install build
sudo tcpreplay -i eth0 --io-uring test.pcap
```
</details>
<details>
<summary><b>AF_XDP</b> (Linux, richiede <code>libxdp-dev</code>/<code>libbpf-dev</code> + un driver compatibile con eBPF)</summary>
Rilevato su sistemi Linux con `libxdp-dev` e `libbpf-dev` installati. Quando
selezionato (`--xdp`), lo stack di rete del kernel viene bypassato e i pacchetti
vengono inviati direttamente attraverso un driver abilitato a eBPF — line rate
completo su adattatori commerciali, paragonabile ai generatori di traffico
commerciali, senza modificare il driver.
```
sudo apt-get install libxdp-dev libbpf-dev
cmake -B build && cmake --build build && sudo cmake --install build
sudo tcpreplay -i eth0 --xdp test.pcap
```
</details>
<details>
<summary><b>netmap</b> (Linux/BSD, richiede driver di rete con patch netmap — il più invasivo, il massimo potenziale)</summary>
[netmap] bypassa il driver di rete per la durata del replay e
scrive direttamente nei buffer TX della NIC. Questa è l'opzione più invasiva
delle tre — lo stack di rete si spegne su quell'interfaccia mentre è
attivo, quindi **non testare sull'interfaccia da cui ti sei connesso via SSH** — ma ha il
massimo potenziale di throughput sull'hardware supportato.
Scarica e installa netmap dalla [pagina del progetto][netmap]. Se lo hai
estratto in `/usr/src` o `/usr/local/src` verrà rilevato
automaticamente; altrimenti punta la build verso di esso:
```
cmake -B build -DWITH_NETMAP=/home/fklassen/git/netmap
cmake --build build
sudo cmake --install build
```
</details>
Riproduzione su interfacce IP raw (L3)
--------------------------------------
Su Linux, tcpreplay può riprodurre direttamente su interfacce di solo livello 3 come
i dispositivi WireGuard e tun — non è necessaria alcuna opzione di compilazione o flag da riga di comando. Qualsiasi
header di livello 2 nel file di input (Ethernet inclusi i tag VLAN, Linux SLL,
loopback, ...) viene rimosso automaticamente e i pacchetti vengono inviati come
IPv4/IPv6 puri con il protocollo corretto, come richiesto da driver quali WireGuard:
```
sudo tcpreplay -i wg0 test.pcap
```
Tieni presente che i pacchetti non-IP (ad es. ARP) non possono essere inviati su queste interfacce e
vengono segnalati come falliti, e che `--io-uring` non è supportato su di esse.
libreria libtcpreplay
-----------------------
Dalla versione 4.6 la suite installa **libtcpreplay**, una libreria statica che espone lo
stesso motore di replay utilizzato dal binario `tcpreplay` tramite `tcpreplay_api.h`.
Le applicazioni possono riprodurre file pcap e leggere statistiche in tempo reale
a livello di programmazione, invece di eseguire il fork del binario e analizzarne l'output:
```
cc myapp.c $(pkg-config --cflags --libs --static libtcpreplay) -o myapp
```
Le intestazioni vengono installate in `include/tcpreplay/`; entrambi i sistemi di build installano la libreria e il suo `libtcpreplay.pc`. Vedi [`examples/`](https://github.com/appneta/tcpreplay/blob/master/examples) per un programma completo.
Esecuzione della suite di test
------------------------
```
cd test
sudo make test
```
Richiede root (raw socket/iniezione di pacchetti) e invia traffico reale sulle
NIC di test configurate — non eseguirlo su un'interfaccia attraverso cui sei
connesso. `make test` è solo per autotools; vedi [`docs/INSTALL`](https://github.com/appneta/tcpreplay/blob/master/docs/INSTALL)
per configurare le NIC di test con `--with-testnic`/`--with-testnic2`.
Ottenere assistenza
===================
Pensi di aver trovato un bug o hai una domanda? Cerca prima tra le
[issue esistenti](https://github.com/appneta/tcpreplay/issues), poi
[aprine una nuova](https://github.com/appneta/tcpreplay/issues/new) se non è
già stata trattata. Includi:
* La versione di Tcpreplay (`-V`/`--version`) e la piattaforma
* Se è un problema di build: l'output di `configure`/`cmake` e `make`
* Se è un problema di runtime: la riga di comando esatta e una descrizione (o
il pcap allegato) di ciò che stavi cercando di fare
* Qualsiasi altra cosa che sembri rilevante — più dettagli fornisci, più velocemente possiamo aiutarti
Hai trovato una vulnerabilità di sicurezza specifica? Segui invece
[`SECURITY.md`](https://github.com/appneta/tcpreplay/blob/master/SECURITY.md) anziché aprire una issue pubblica.
Ti invitiamo inoltre a consultare prima il
[sito della documentazione](https://tcpreplay.appneta.com) — le
[guide](https://tcpreplay.appneta.com/guides/),
le [FAQ](https://tcpreplay.appneta.com/faq/) e
le [man page](https://tcpreplay.appneta.com/reference/man-pages/) — prima di scrivere
alla mailing list tcpreplay-users
([mailing list](https://lists.sourceforge.net/lists/listinfo/tcpreplay-users)),
e ti preghiamo di non scrivere direttamente ai maintainer, così anche altri possono trarre beneficio
(e aiutare a rispondere) alla tua domanda.
Contribuire
===========
1. Esegui il [Fork] del repository e [configura git][git] se non l'hai già fatto
2. Crea un branch per la tua funzionalità o correzione di bug
3. Apporta la tua modifica — vedi [`docs/HACKING`](https://github.com/appneta/tcpreplay/blob/master/docs/HACKING) per gli standard
di codifica e per ciò che implica contribuire il tuo codice a livello di licenza
4. Esegui il push sul tuo fork e [invia una pull request][pr] verso `master`
La esamineremo e ne discuteremo con te su GitHub; una volta accettata, viene applicata
direttamente a `master`. Vedi anche le
[guide per sviluppatori](https://tcpreplay.appneta.com/developers/) per il materiale
a livello architetturale — scrivere un plugin DLT, incorporare
libtcpreplay/libtcpedit e il design dei plugin.
Licenza
=======
Tcpreplay è distribuito con licenza [GPLv3] e include software sviluppato dalla
University of California, Berkeley, Lawrence Berkeley Laboratory e dai suoi
contributori. Vedi [`LICENSE`](https://github.com/appneta/tcpreplay/blob/master/LICENSE) per il testo completo.
Questo vale per i file scritti per il progetto; alcuni file distribuiti con
la Tcpreplay Suite sono protetti da copyright di altri autori e riportano una licenza
diversa, e sono contrassegnati come tali all'interno del file. Domande sulla licenza
applicabile a uno specifico file o modulo possono essere inviate alla
[mailing list tcpreplay-users](https://sourceforge.net/p/tcpreplay/mailman/tcpreplay-users/).
Autori
======
Tcpreplay è stato creato da Aaron Turner. Fred Klassen ([AppNeta by Broadcom][AppNeta])
ne ha assunto la manutenzione nel 2013, a partire dalla release 4.0, aggiungendo
le funzionalità di prestazioni e flow-testing descritte sopra.
[GPLv3]: http://www.gnu.org/licenses/gpl-3.0.html
[netmap]: https://github.com/luigirizzo/netmap
[flow]: https://en.wikipedia.org/wiki/Traffic_flow_(computer_networking)
[NetFlow]: http://www.cisco.com/go/netflow
[Cygwin]: http://www.cygwin.com/
[Wireshark]: https://www.wireshark.org
[tcpdump]: http://www.tcpdump.org
[Cisco]: http://www.cisco.com
[AppNeta]: https://www.broadcom.com/products/software/network-management/appneta
[git]: https://help.github.com/articles/set-up-git
[Fork]: https://help.github.com/articles/fork-a-repo
[pr]: https://help.github.com/articles/using-pull-requests