appneta/tcpreplayModifiez et rejouez le trafic réseau capturé à des vitesses arbitraires — une suite d'outils pcap pour *NIX et 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 est une suite d'utilitaires sous licence [GPLv3] pour UNIX (et Windows sous
[Cygwin]) permettant d'éditer et de rejouer du trafic réseau préalablement capturé par
des outils comme [tcpdump] et [Wireshark]. Il classe le trafic comme client ou
serveur, réécrit les en-têtes de couche 2/3/4, et le rejoue sur le réseau
à travers des commutateurs, routeurs, pare-feu, NIDS et IPS — à un débit allant d'un
filet jusqu'au débit maximal du lien. Tcpreplay prend en charge les modes à une ou deux cartes réseau,
pour tester à la fois les dispositifs d'écoute et les dispositifs en ligne.
Tcpreplay est utilisé par de nombreux fournisseurs de pare-feu, IDS, IPS, NetFlow et autres
équipements réseau, des entreprises, des universités, des laboratoires et des
projets open source. Si votre organisation utilise Tcpreplay, merci de nous indiquer qui vous
êtes et à quoi vous l'utilisez, afin que nous puissions continuer à prioriser les fonctionnalités qui
comptent.
Depuis la version 4.0, Tcpreplay cible également spécifiquement les tests d'appliances [IP Flow][flow]/[NetFlow]
: un timing de rejeu précis à haut débit et un rapport de résultats,
des statistiques de flux par seconde (fps), et une analyse d'expiration des flux pour ajuster les
paramètres de timeout d'un produit de flux — jusqu'à des centaines de milliers de flux/seconde,
selon la taille des flux dans le fichier pcap.
📖 **La documentation complète se trouve sur <https://tcpreplay.appneta.com>** — un
guide de démarrage, une page par outil, des recettes pratiques, les concepts derrière la
suite, les pages de manuel et la FAQ. Ce README est la visite rapide ; le site est
la référence.
- [La suite](#the-suite)
- [Nouveautés de la 4.6](#whats-new-in-46)
- [Installer une version publiée](#installing-a-release)
- [Compiler depuis les sources](#building-from-source)
- [Autotools](#autotools)
- [CMake](#cmake-recommended)
- [Performance : netmap, AF\_XDP, io\_uring](#performance-netmap-af_xdp-io_uring)
- [Rejouer sur des interfaces IP brutes (L3)](#replaying-onto-raw-ip-l3-interfaces)
- [Bibliothèque C libtcpreplay](#libtcpreplay-c-library)
- [Exécuter la suite de tests](#running-the-test-suite)
- [Obtenir de l'aide](#getting-help)
- [Contribuer](#contributing)
- [Licence](#license)
- [Auteurs](#authors)
La suite
=========
Rejeu réseau :
--------------------------
* **tcpreplay** / **tcpreplay-edit** — rejoue des fichiers pcap à des vitesses arbitraires
sur le réseau, en éditant éventuellement les paquets à la volée (`tcpreplay-edit`)
ou en randomisant les adresses IP (`tcpreplay`)
* **tcpliveplay** — rejoue une session TCP capturée sur un réseau actif d'une
manière à laquelle un serveur distant répondra réellement (contribution de Yazan
Siam, sponsorisée par [Cisco], pour tester toute la pile réseau jusqu'à
l'application — `tcpreplay` seul reste normalement au niveau de la couche 2)
Éditeurs et utilitaires de fichiers pcap :
--------------------------------
* **tcpprep** — pré-processeur pcap multi-passes qui classe les paquets comme
client ou serveur et écrit un fichier cache consommé par tcpreplay/tcprewrite
* **tcprewrite** — réécrit les en-têtes de paquets TCP/IP et de couche 2 dans un fichier pcap
* **tcpbridge** — pont entre deux segments réseau en utilisant la logique de réécriture de tcprewrite
* **tcpcapinfo** — décodeur et débogueur de fichiers pcap bruts
Nouveautés de la version 4.6
==================
* [CMake](#cmake-recommended) est désormais le système de build principal et recommandé
(autotools est toujours utilisé pour les archives de version)
* Injection de paquets en fast-path via [io_uring](#performance-netmap-af_xdp-io_uring) et
[AF_XDP](#performance-netmap-af_xdp-io_uring),
en complément du support netmap existant — les deux nécessitent moins de configuration que netmap
et aucun pilote patché
* [libtcpreplay](#libtcpreplay-c-library), une bibliothèque C statique pour intégrer
le moteur de rejeu directement dans votre propre programme
* Prise en charge automatique du [rejeu sur des interfaces IP brutes (L3)](#replaying-onto-raw-ip-l3-interfaces)
comme WireGuard et les périphériques tun
Consultez le [CHANGELOG](https://github.com/appneta/tcpreplay/blob/master/docs/CHANGELOG) pour l'historique complet des versions.
Installer une version
=====================
[](https://github.com/appneta/tcpreplay/releases)
[](https://sourceforge.net/projects/tcpreplay)
Téléchargez la dernière [archive de version](https://github.com/appneta/tcpreplay/releases/latest)
(également disponible en miroir sur [SourceForge](https://sourceforge.net/projects/tcpreplay)),
puis :
```
tar xf tcpreplay-*.tar.xz && cd tcpreplay-*
./configure && make && sudo make install
```
Une archive de version publiée contient des analyseurs CLI et des pages de manuel pré-générés, donc cela ne nécessite rien de plus qu'un compilateur C et libpcap — voir
[Compiler depuis les sources](#building-from-source) ci-dessous uniquement si vous travaillez
à partir d'un dépôt git, ou si vous souhaitez le support de CMake, netmap, AF_XDP ou io_uring.
Des instructions plus détaillées spécifiques à chaque plateforme se trouvent dans le fichier `INSTALL`
inclus dans l'archive (même contenu que [`docs/INSTALL`](https://github.com/appneta/tcpreplay/blob/master/docs/INSTALL) ici).
Compiler depuis les sources
=====================
Compiler depuis un dépôt git nécessite `python3` et `asciidoctor` (quel que soit
le système de compilation) pour générer les analyseurs d'options CLI et les pages de manuel à partir des
fichiers `*_opts.def` — cela a remplacé GNU AutoGen à cette fin dans la version 4.6
(AutoGen est en fin de vie ; ceux-ci ne le sont pas). AutoGen lui-même n'est encore nécessaire que pour un
en-tête interne (`src/tcpedit/tcpedit_stub.h`) — voir
[`scripts/autoopts/README.md`](https://github.com/appneta/tcpreplay/blob/master/scripts/autoopts/README.md). Rien de tout cela n'est
nécessaire lors de la compilation d'une archive de version publiée, qui contient déjà ces éléments générés.
Autotools
---------
```
./autogen.sh # only needed once, from a git checkout
./configure
make
sudo make install
```
CMake (recommandé)
--------------------
Depuis la version 4.6, la suite peut également être compilée avec [CMake](https://cmake.org)
(3.16+) — **la méthode recommandée et principale pour compiler Tcpreplay**.
Autotools est toujours fourni et utilisé pour les archives de version, mais sera
finalement abandonné, donc les nouveaux scripts/packages devraient cibler CMake.
```
cmake -B build
cmake --build build
sudo cmake --install build
```
Chaque option de `./configure` a un équivalent CMake — voir le tableau en haut de [`CMakeLists.txt`](https://github.com/appneta/tcpreplay/blob/master/CMakeLists.txt). Quelques exemples :
```
# 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` régénère les pages de manuel
(python3 + asciidoctor) ; un simple `cmake --build build` n'y touche jamais.
Les utilisateurs de VS Code disposant de l'extension CMake Tools peuvent simplement ouvrir le dossier
du dépôt et choisir un preset de configuration lorsque cela leur est proposé.
Performance : netmap, AF_XDP, io_uring
--------------------------------------
Si le chemin de socket par défaut n'est pas assez rapide, Tcpreplay dispose de trois
moyens à moindre surcoût pour pousser les paquets directement vers la carte réseau. Essayez-les approximativement dans
cet ordre — io_uring nécessite le moins de configuration, netmap le plus :
<details>
<summary><b>io_uring</b> (Linux, nécessite <code>liburing-dev</code> — aucun pilote patché requis)</summary>
Détecté sur les systèmes Linux avec `liburing-dev` installé et un noyau prenant en charge
[io_uring](https://man7.org/linux/man-pages/man7/io_uring.7.html).
Les paquets sortent toujours via un socket brut PF_PACKET classique, mais les envois sont
soumis de manière asynchrone via une file io_uring, ce qui réduit le surcoût d'appel système
par paquet.
```
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, nécessite <code>libxdp-dev</code>/<code>libbpf-dev</code> + un pilote compatible eBPF)</summary>
Détecté sur les systèmes Linux avec `libxdp-dev` et `libbpf-dev` installés. Lorsqu'il
est sélectionné (`--xdp`), la pile réseau du noyau est contournée et les paquets sont
envoyés directement via un pilote compatible eBPF — débit de ligne complet sur des
adaptateurs standards, comparable aux générateurs de trafic commerciaux, sans patcher le
pilote.
```
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, nécessite des pilotes réseau patchés pour netmap — le plus invasif, le plus haut plafond)</summary>
[netmap] contourne le pilote réseau pendant toute la durée du rejeu et
écrit directement dans les tampons TX de la carte réseau. C'est l'option la
plus invasive des trois — la pile réseau devient inactive sur cette interface pendant qu'elle est
active, donc **ne testez pas sur l'interface par laquelle vous êtes connecté en SSH** — mais elle offre le
plus haut plafond de débit sur le matériel pris en charge.
Téléchargez et installez netmap depuis la [page du projet][netmap]. Si vous
l'avez extrait dans `/usr/src` ou `/usr/local/src`, il sera détecté
automatiquement ; sinon, indiquez-le à la compilation :
```
cmake -B build -DWITH_NETMAP=/home/fklassen/git/netmap
cmake --build build
sudo cmake --install build
```
</details>
Rejouer sur des interfaces IP brutes (L3)
--------------------------------------
Sous Linux, tcpreplay peut rejouer directement sur des interfaces de couche 3 uniquement telles que
les périphériques WireGuard et tun — aucune option de compilation ni indicateur de ligne de commande n'est nécessaire. Tout
en-tête de couche 2 présent dans le fichier d'entrée (Ethernet, y compris les balises VLAN, Linux SLL,
loopback, ...) est supprimé automatiquement et les paquets sont envoyés en IPv4/IPv6
bruts avec le protocole correct, ce que les pilotes comme WireGuard exigent :
```
sudo tcpreplay -i wg0 test.pcap
```
Notez que les paquets non-IP (par exemple ARP) ne peuvent pas être envoyés sur ces interfaces et
sont signalés comme ayant échoué, et que `--io-uring` n'est pas pris en charge sur celles-ci.
Bibliothèque C libtcpreplay
-----------------------
Depuis la version 4.6, la suite installe **libtcpreplay**, une bibliothèque statique exposant le
même moteur de rejeu que celui utilisé par le binaire `tcpreplay` via `tcpreplay_api.h`.
Les applications peuvent rejouer des fichiers pcap et lire des statistiques en direct
par programmation, au lieu de lancer le binaire en sous-processus et d'analyser sa sortie :
```
cc myapp.c $(pkg-config --cflags --libs --static libtcpreplay) -o myapp
```
Les en-têtes s'installent sous `include/tcpreplay/` ; les deux systèmes de build installent la bibliothèque et son fichier `libtcpreplay.pc`. Voir [`examples/`](https://github.com/appneta/tcpreplay/blob/master/examples) pour un programme complet.
Exécution de la suite de tests
------------------------
```
cd test
sudo make test
```
Nécessite les droits root (sockets bruts/injection de paquets) et envoie du trafic réel sur les
NIC de test configurées — ne l'exécutez pas sur une interface par laquelle vous êtes connecté.
`make test` est réservé à autotools ; consultez [`docs/INSTALL`](https://github.com/appneta/tcpreplay/blob/master/docs/INSTALL)
pour configurer les NIC de test avec `--with-testnic`/`--with-testnic2`.
Obtenir de l'aide
=================
Vous pensez avoir trouvé un bug, ou vous avez une question ? Recherchez d'abord dans les
[issues existantes](https://github.com/appneta/tcpreplay/issues), puis
[ouvrez-en une nouvelle](https://github.com/appneta/tcpreplay/issues/new) si le sujet n'est pas
déjà couvert. Veuillez inclure :
* La version de Tcpreplay (`-V`/`--version`) et la plateforme
* S'il s'agit d'un problème de compilation : la sortie de `configure`/`cmake` et de `make`
* S'il s'agit d'un problème d'exécution : la ligne de commande exacte, et une description (ou
un pcap en pièce jointe) de ce que vous essayiez de faire
* Tout autre élément qui semble pertinent — plus vous donnez de détails, plus nous pourrons aider rapidement
Vous avez trouvé une vulnérabilité de sécurité spécifiquement ? Veuillez suivre
[`SECURITY.md`](https://github.com/appneta/tcpreplay/blob/master/SECURITY.md) au lieu de déposer une issue publique.
Nous vous encourageons également à consulter d'abord le
[site de documentation](https://tcpreplay.appneta.com) — les
[guides](https://tcpreplay.appneta.com/guides/),
la [FAQ](https://tcpreplay.appneta.com/faq/) et
les [pages de manuel](https://tcpreplay.appneta.com/reference/man-pages/) — avant de poster
sur la [liste de diffusion](https://lists.sourceforge.net/lists/listinfo/tcpreplay-users)
tcpreplay-users, et veuillez ne pas envoyer d'e-mail directement aux mainteneurs, afin que d'autres puissent également bénéficier de
(et aider à répondre à) votre question.
Contribuer
==========
1. [Forkez] le dépôt et [configurez git][git] si ce n'est pas déjà fait
2. Créez une branche pour votre fonctionnalité ou correction de bug
3. Effectuez votre modification — consultez [`docs/HACKING`](https://github.com/appneta/tcpreplay/blob/master/docs/HACKING) pour les normes
de codage et ce qu'implique votre contribution en termes de licence
4. Poussez vers votre fork et [envoyez une pull request][pr] vers `master`
Nous l'examinerons et en discuterons avec vous sur GitHub ; une fois acceptée, elle est appliquée
directement à `master`. Consultez également les
[guides développeurs](https://tcpreplay.appneta.com/developers/) pour le matériel
au niveau de l'architecture — écrire un plugin DLT, intégrer
libtcpreplay/libtcpedit, et la conception des plugins.
Licence
=======
Tcpreplay est distribué sous [GPLv3], et inclut des logiciels développés par
l'University of California, Berkeley, Lawrence Berkeley Laboratory et ses
contributeurs. Consultez [`LICENSE`](https://github.com/appneta/tcpreplay/blob/master/LICENSE) pour le texte complet.
Cela couvre les fichiers écrits pour le projet ; certains fichiers distribués avec
la Tcpreplay Suite sont protégés par le droit d'auteur d'autres auteurs et portent une licence
différente, et sont signalés comme tels dans le fichier. Les questions concernant la licence
applicable à un fichier ou module spécifique peuvent être adressées à la
[liste de diffusion tcpreplay-users](https://sourceforge.net/p/tcpreplay/mailman/tcpreplay-users/).
Auteurs
=======
Tcpreplay a été créé par Aaron Turner. Fred Klassen ([AppNeta by Broadcom][AppNeta])
a repris la maintenance en 2013, à partir de la version 4.0, en ajoutant les
fonctionnalités de performance et de test de flux décrites ci-dessus.
[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