appneta/tcpreplayNetzwerkverkehr bearbeiten und mit beliebiger Geschwindigkeit wiedergeben — eine Suite von pcap-Tools für *NIX und 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 ist eine Sammlung von unter [GPLv3] lizenzierten Werkzeugen für UNIX (und Windows unter
[Cygwin]) zum Bearbeiten und erneuten Abspielen von Netzwerkverkehr, der zuvor mit
Tools wie [tcpdump] und [Wireshark] aufgezeichnet wurde. Es klassifiziert den Verkehr als Client- oder
Server-Verkehr, schreibt Layer-2/3/4-Header um und spielt ihn über Switches, Router, Firewalls, NIDS und IPS zurück ins Netzwerk
– von einem Rinnsal bis hin zur vollen Leitungskapazität. Tcpreplay unterstützt sowohl Single- als auch Dual-NIC-
Modi, um sowohl sniffende als auch Inline-Geräte zu testen.
Tcpreplay wird von zahlreichen Firewall-, IDS-, IPS-, NetFlow- und anderen
Netzwerk-Anbietern, Unternehmen, Universitäten, Laboren und Open-Source-
Projekten eingesetzt. Wenn Ihre Organisation Tcpreplay verwendet, lassen Sie uns bitte wissen, wer Sie
sind und wofür Sie es nutzen, damit wir weiterhin die Funktionen priorisieren können, die
wichtig sind.
Seit 4.0 zielt Tcpreplay außerdem gezielt auf das Testen von [IP Flow][flow]/[NetFlow]-
Appliances ab: präzises Timing bei hohen Raten und Ergebnisberichte,
Flows-Per-Second-(fps)-Statistiken und Flow-Expiry-Analyse zur Abstimmung der
Timeout-Einstellungen eines Flow-Produkts – bis zu Hunderttausende Flows/Sek.,
abhängig von den Flow-Größen in der pcap-Datei.
📖 **Die vollständige Dokumentation finden Sie unter <https://tcpreplay.appneta.com>** – ein
Leitfaden für den Einstieg, eine Seite pro Tool, How-to-Rezepte, die Konzepte hinter der
Suite, die Manpages und die FAQ. Dieses README ist der schnelle Überblick; die Website ist
die Referenz.
- [Die Suite](#the-suite)
- [Was ist neu in 4.6](#whats-new-in-46)
- [Installation einer Version](#installing-a-release)
- [Aus dem Quellcode bauen](#building-from-source)
- [Autotools](#autotools)
- [CMake](#cmake-recommended)
- [Performance: netmap, AF\_XDP, io\_uring](#performance-netmap-af_xdp-io_uring)
- [Abspielen auf Raw-IP-(L3)-Schnittstellen](#replaying-onto-raw-ip-l3-interfaces)
- [libtcpreplay-C-Bibliothek](#libtcpreplay-c-library)
- [Ausführen der Testsuite](#running-the-test-suite)
- [Hilfe erhalten](#getting-help)
- [Mitwirken](#contributing)
- [Lizenz](#license)
- [Autoren](#authors)
Die Suite
=========
Netzwerk-Wiedergabe:
--------------------------
* **tcpreplay** / **tcpreplay-edit** – spielt pcap-Dateien mit beliebiger Geschwindigkeit
ins Netzwerk ab, optional mit Bearbeitung der Pakete während des Abspielens (`tcpreplay-edit`)
oder Randomisierung der IP-Adressen (`tcpreplay`)
* **tcpliveplay** – spielt eine aufgezeichnete TCP-Sitzung in einem Live-Netzwerk so ab,
dass ein entfernter Server tatsächlich antwortet (beigesteuert von Yazan
Siam, gesponsert von [Cisco], zum Testen des vollständigen Netzwerk-Stacks bis hinauf in
die Anwendung – normales `tcpreplay` bleibt üblicherweise auf Layer 2)
Pcap-Datei-Editoren und Werkzeuge:
--------------------------------
* **tcpprep** – Multi-Pass-pcap-Vorprozessor, der Pakete als
Client oder Server klassifiziert und eine Cache-Datei schreibt, die von tcpreplay/tcprewrite verwendet wird
* **tcprewrite** – schreibt TCP/IP- und Layer-2-Paketheader in einer pcap-Datei um
* **tcpbridge** – überbrückt zwei Netzwerksegmente unter Verwendung der Umschreib-Logik von tcprewrite
* **tcpcapinfo** – Raw-pcap-Datei-Decoder und Debugger
Neu in 4.6
==================
* [CMake](#cmake-recommended) ist jetzt das primäre, empfohlene Build-System
(autotools wird weiterhin für Release-Tarballs verwendet)
* [io_uring](#performance-netmap-af_xdp-io_uring) und
[AF_XDP](#performance-netmap-af_xdp-io_uring) Fast-Path-Paketinjektion,
neben der bestehenden netmap-Unterstützung — beide benötigen weniger Einrichtung als netmap
und keine gepatchten Treiber
* [libtcpreplay](#libtcpreplay-c-library), eine statische C-Bibliothek zum Einbetten
der Replay-Engine direkt in Ihr eigenes Programm
* Automatische Unterstützung für das [Replay auf Raw-IP-(L3-)Schnittstellen](#replaying-onto-raw-ip-l3-interfaces)
wie WireGuard und tun-Geräte
Siehe das [CHANGELOG](https://github.com/appneta/tcpreplay/blob/master/docs/CHANGELOG) für die vollständige Release-Historie.
Installieren einer Version
=====================
[](https://github.com/appneta/tcpreplay/releases)
[](https://sourceforge.net/projects/tcpreplay)
Laden Sie das neueste [Release-Tarball](https://github.com/appneta/tcpreplay/releases/latest) herunter
(auch gespiegelt auf [SourceForge](https://sourceforge.net/projects/tcpreplay)),
dann:
```
tar xf tcpreplay-*.tar.xz && cd tcpreplay-*
./configure && make && sudo make install
```
Ein Release-Tarball enthält bereits vorab generierte CLI-Parser und Manpages, daher wird nichts außer einem C-Compiler und libpcap benötigt — siehe
[Building from source](#building-from-source) unten nur, wenn du von einem Git-Checkout aus arbeitest oder CMake-, netmap-, AF_XDP- oder io_uring-Unterstützung möchtest.
Detailliertere plattformspezifische Anweisungen findest du in der Datei `INSTALL`, die im Tarball enthalten ist (gleicher Inhalt wie [`docs/INSTALL`](https://github.com/appneta/tcpreplay/blob/master/docs/INSTALL) hier).
Building From Source
=====================
Das Bauen aus einem Git-Checkout erfordert `python3` und `asciidoctor` (je nach Build-System), um die CLI-Optionsparser und Manpages aus den `*_opts.def`-Dateien zu generieren — dies ersetzte GNU AutoGen für diesen Zweck in 4.6 (AutoGen ist EOL; diese nicht). AutoGen selbst wird nur noch für einen internen Header (`src/tcpedit/tcpedit_stub.h`) benötigt — siehe
[`scripts/autoopts/README.md`](https://github.com/appneta/tcpreplay/blob/master/scripts/autoopts/README.md). Nichts davon ist beim Bauen eines Release-Tarballs erforderlich, da dieser diese bereits generiert enthält.
Autotools
---------
```
./autogen.sh # only needed once, from a git checkout
./configure
make
sudo make install
```
CMake (empfohlen)
--------------------
Ab Version 4.6 kann die Suite auch mit [CMake](https://cmake.org)
(3.16+) gebaut werden — **der empfohlene und primäre Weg, Tcpreplay zu kompilieren**.
Autotools wird weiterhin bereitgestellt und für Release-Tarballs verwendet, wird
aber letztendlich eingestellt, sodass neue Skripte/Paketierungen auf CMake abzielen sollten.
```
cmake -B build
cmake --build build
sudo cmake --install build
```
Jedes `./configure`-Flag hat ein CMake-Äquivalent — siehe die Tabelle am Anfang von [`CMakeLists.txt`](https://github.com/appneta/tcpreplay/blob/master/CMakeLists.txt). Einige Beispiele:
```
# 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` erzeugt die Manpages neu
(python3 + asciidoctor); ein einfaches `cmake --build build` berührt sie nie.
VS-Code-Nutzer mit der CMake-Tools-Erweiterung können einfach den Repository-
Ordner öffnen und bei Aufforderung ein Configure-Preset auswählen.
Performance: netmap, AF_XDP, io_uring
--------------------------------------
Wenn der Standard-Socket-Pfad nicht schnell genug ist, bietet Tcpreplay drei
Wege mit geringerem Overhead, um Pakete direkt an die NIC zu senden. Probieren
Sie sie ungefähr in dieser Reihenfolge aus — io_uring erfordert den geringsten
Aufwand, netmap den größten:
<details>
<summary><b>io_uring</b> (Linux, benötigt <code>liburing-dev</code> — kein gepatchter Treiber erforderlich)</summary>
Wird auf Linux-Systemen erkannt, auf denen `liburing-dev` installiert ist und
der Kernel
[io_uring](https://man7.org/linux/man-pages/man7/io_uring.7.html) unterstützt.
Pakete werden weiterhin über einen regulären PF_PACKET-Raw-Socket gesendet,
aber die Sendevorgänge werden asynchron über eine io_uring-Warteschlange
eingereicht, wodurch der Syscall-Overhead pro Paket reduziert wird.
```
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, benötigt <code>libxdp-dev</code>/<code>libbpf-dev</code> + einen eBPF-fähigen Treiber)</summary>
Wird auf Linux-Systemen erkannt, auf denen `libxdp-dev` und `libbpf-dev` installiert sind. Wenn
ausgewählt (`--xdp`), wird der Kernel-Netzwerkstack umgangen und Pakete werden
direkt über einen eBPF-fähigen Treiber gesendet — volle Leitungsrate auf Standard-
Adaptern, vergleichbar mit kommerziellen Traffic-Generatoren, ohne den
Treiber zu patchen.
```
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, benötigt netmap-gepatchte Netzwerktreiber — am invasivsten, höchste Obergrenze)</summary>
[netmap] umgeht den Netzwerktreiber für die Dauer des Replays und
schreibt direkt in die TX-Puffer der NIC. Dies ist die invasivste der
drei Optionen — der Netzwerk-Stack geht auf dieser Schnittstelle dunkel, während sie
aktiv ist, also **teste nicht auf der Schnittstelle, über die du dich per SSH verbunden hast** —, hat aber
die höchste Durchsatzobergrenze auf unterstützter Hardware.
Lade netmap von der [Projektseite][netmap] herunter und installiere es. Wenn du
es nach `/usr/src` oder `/usr/local/src` entpackt hast, wird es
automatisch erkannt; andernfalls verweise den Build darauf:
```
cmake -B build -DWITH_NETMAP=/home/fklassen/git/netmap
cmake --build build
sudo cmake --install build
```
</details>
Wiedergabe auf Raw-IP-(L3-)Schnittstellen
--------------------------------------
Unter Linux kann tcpreplay direkt auf reine Layer-3-Schnittstellen wie
WireGuard- und tun-Geräte wiedergeben – es ist weder eine Build-Option noch ein
Kommandozeilen-Flag erforderlich. Jeder Layer-2-Header in der Eingabedatei
(Ethernet einschließlich VLAN-Tags, Linux SLL,
Loopback, ...) wird automatisch entfernt und Pakete werden als reine
IPv4/IPv6 mit dem korrekten Protokoll gesendet, was Treiber wie WireGuard erfordern:
```
sudo tcpreplay -i wg0 test.pcap
```
Beachten Sie, dass Nicht-IP-Pakete (z. B. ARP) auf diesen Schnittstellen nicht gesendet werden können und als fehlgeschlagen gemeldet werden, und dass `--io-uring` auf ihnen nicht unterstützt wird.
libtcpreplay C-Bibliothek
-----------------------
Seit 4.6 installiert die Suite **libtcpreplay**, eine statische Bibliothek, die dieselbe Replay-Engine bereitstellt, die die Binärdatei `tcpreplay` über `tcpreplay_api.h` verwendet.
Anwendungen können pcap-Dateien wiedergeben und Live-Statistiken programmatisch auslesen, anstatt die Binärdatei zu forken und ihre Ausgabe zu parsen:
```
cc myapp.c $(pkg-config --cflags --libs --static libtcpreplay) -o myapp
```
Header werden unter `include/tcpreplay/` installiert; beide Build-Systeme installieren die Bibliothek und ihre `libtcpreplay.pc`. Siehe [`examples/`](https://github.com/appneta/tcpreplay/blob/master/examples) für ein vollständiges Programm.
Ausführen der Testsuite
------------------------
```
cd test
sudo make test
```
Erfordert Root-Rechte (Raw Sockets/Paketinjektion) und sendet Live-Traffic auf den
konfigurierten Test-NICs — führe es nicht gegen eine Schnittstelle aus, über die du
verbunden bist. `make test` ist nur mit autotools verfügbar; siehe [`docs/INSTALL`](https://github.com/appneta/tcpreplay/blob/master/docs/INSTALL)
zum Konfigurieren der Test-NICs mit `--with-testnic`/`--with-testnic2`.
Hilfe erhalten
==============
Glaubst du, einen Bug gefunden zu haben, oder hast du eine Frage? Durchsuche zuerst
[die bestehenden Issues](https://github.com/appneta/tcpreplay/issues) und
[eröffne dann ein neues](https://github.com/appneta/tcpreplay/issues/new), falls es noch nicht
abgedeckt ist. Bitte gib Folgendes an:
* Die Tcpreplay-Version (`-V`/`--version`) und die Plattform
* Bei einem Build-Problem: die Ausgabe von `configure`/`cmake` und `make`
* Bei einem Laufzeitproblem: die exakte Befehlszeile und eine Beschreibung (oder
ein angehängtes pcap) dessen, was du versucht hast zu tun
* Alles andere, was relevant erscheint — je mehr Details, desto schneller können wir helfen
Hast du speziell eine Sicherheitslücke gefunden? Bitte folge stattdessen
[`SECURITY.md`](https://github.com/appneta/tcpreplay/blob/master/SECURITY.md), anstatt ein öffentliches Issue zu eröffnen.
Wir empfehlen außerdem, zuerst die
[Dokumentationsseite](https://tcpreplay.appneta.com) zu prüfen — die
[Anleitungen](https://tcpreplay.appneta.com/guides/),
[FAQ](https://tcpreplay.appneta.com/faq/) und
[Manpages](https://tcpreplay.appneta.com/reference/man-pages/) — bevor du an die
tcpreplay-users-[Mailingliste](https://lists.sourceforge.net/lists/listinfo/tcpreplay-users)
schreibst, und bitte schreibe den Maintainern nicht direkt, damit auch andere von
deiner Frage profitieren (und bei der Beantwortung helfen) können.
Mitwirken
============
1. [Forke] das Repository und [richte git ein][git], falls noch nicht geschehen
2. Erstelle einen Branch für dein Feature oder deinen Bugfix
3. Nimm deine Änderung vor — siehe [`docs/HACKING`](https://github.com/appneta/tcpreplay/blob/master/docs/HACKING) für Coding-
Standards und was das Beitragen deines Codes lizenzrechtlich bedeutet
4. Pushe in deinen Fork und [sende einen Pull Request][pr] gegen `master`
Wir prüfen und besprechen ihn mit dir auf GitHub; nach Annahme wird er direkt
auf `master` angewendet. Siehe auch die
[Entwickleranleitungen](https://tcpreplay.appneta.com/developers/) für Material
auf Architekturebene — das Schreiben eines DLT-Plugins, das Einbetten von
libtcpreplay/libtcpedit und das Plugin-Design.
Lizenz
=======
Tcpreplay ist unter [GPLv3] lizenziert und enthält Software, die von der
University of California, Berkeley, dem Lawrence Berkeley Laboratory und seinen
Mitwirkenden entwickelt wurde. Den vollständigen Text findest du in [`LICENSE`](https://github.com/appneta/tcpreplay/blob/master/LICENSE).
Dies gilt für die für das Projekt geschriebenen Dateien; einige mit der
Tcpreplay Suite vertriebene Dateien sind urheberrechtlich von anderen Autoren
geschützt und tragen eine andere Lizenz, was in den Dateien entsprechend vermerkt ist.
Fragen zur Lizenzierung, die für eine bestimmte Datei oder ein bestimmtes Modul gilt, können an die
[tcpreplay-users-Mailingliste](https://sourceforge.net/p/tcpreplay/mailman/tcpreplay-users/) gerichtet werden.
Autoren
=======
Tcpreplay wurde von Aaron Turner erstellt. Fred Klassen ([AppNeta by Broadcom][AppNeta])
übernahm 2013 die Wartung, beginnend mit der Version 4.0, und fügte die
oben beschriebenen Performance- und Flow-Testing-Funktionen hinzu.
[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