10 Best Network Traffic Packet Generator Software Tools (in 2021)

In the Networking and IT world we usually design and implement networks and server infrastructure taking for granted that the hardware and applications will withstand any volume of traffic.

Stress Testing a network or IT system with high volume of traffic will give us significant insights about the behavior of such systems in abnormal conditions such as DDoS attacks, sudden influx of traffic (e.g during backup transfers over the network) etc.

Traffic packet generators are hardware or software tools that are concerned with the technical aspects of traffic and how it affects network and system resources.

Since a big part of creating a positive user experience is your percentage of uptime and absence of slow response, packet loss, link overload etc, measuring how traffic spikes and fluctuations in user activity affect system performance and resources allocation is an important, and sometimes overlooked, function of IT operations.

When you’re using a network traffic packet generator tool, you’re going to try to perform isolated tests in such a way that it eliminates variables and mitigates the role the packet generator in creating bottlenecks and other traffic-related issues. A comprehensive testing system will include:

• Traffic sources, evaluation tools or equipment, and sinks
• The specific device under test (DUT)
• Physical connections and barriers between the traffic sources and DUT

Performing stress tests and simulating traffic flows should be done both during network creation and on actual working networks once you go live. This will help prevent problems like data loss and dropped connections.

You’ve got the rest of the components, here are the tools: Our top 10 list of the best software network traffic packet generators on the market right now. The list below includes both free and commercial options.

Table of Contents

1. Ostinato

This company strives to create a network testing tool and traffic generator for every engineer and IT specialist, but that’s impossible in today’s tech climate. What it does do is provide you with a packet generator that has a friendly GUI and a lot of power.

This free, open source tool is licensed under GNU GPLv3, and is supported by donations of cash, code, or other types of positive contributions.

Top features include:

• Support for all major operating systems
• Exclusive port control to provide a controlled testing environment
• Opens and edits PCAP files, replays, and saves back
• Sets values for any testing field
• Supports most protocols, including IPv4 & 6, IP-in-IP, tunneling, stateless TCP, WLAN, Ethernet, and more
• Accessible via GUI or Python API
• Performs load and functional testing
• Creates and supports multiple streams

Drawbacks:

• Doesn’t support stateful, connection-oriented TCP connections
• Only experimental support for user-defined script to substitute unimplemented protocols

2. Nping (Nmap)

This is another free, open source tool that provides more than just packet generation testing.

It is part of the well-known Nmap tool which is used mainly for network mapping and discovery in security assessments.

With this robust tool, you’ll also be able to perform response analysis and time measurements.

These are also essential to providing a high degree of user satisfaction. It provides a complete, command-line based interface that’s as powerful as it is convenient.

Use this tool to send normal ICMP ping packets for active hosts discovery as well as to send raw network packets for stress testing, detecting packet corruption, and exposing a range of attack weaknesses in your network.

Top Features include:

• Custom generation for ARP, TCP, UDP, and ICMP (ping) packets
• Supports multiple target port and host specifications
• Echo mode to allow advanced testing
• Supports all major operating systems (Windows, Linux, Mac)
• Route tracing capabilities
• Flexible and easy to customize

Drawbacks:

• Only experimental support for IPv6

3. TRex by Cisco

This tool bills itself as a “realistic traffic generator. As such, you can look for TRex for stateful and stateless DPDK-powered traffic generation that allows smart replay of actual traffic templates.

It allows analysis of multiple streams, and provides individualized, per-stream jitter, latency, and statistics reporting.

This tool can also be used for stateful benchmark and stress testing load balancers, ISPs, DPI, NAT, and firewall protection as well as stateless traffic stream generation.

Features include:

• Supports stateful feature sets like emulating L7 with a scalable TCP layer
• Supports up to 20 million pps (stateless)
• Up to 200-400 Gbs through one Cisco UCS (stateful)
• Continuous multi-burst/single burst support
• Interactive GUI console
• Python API automation
• Support for stateful DPDK 1/2.5/5/10/25/40/50/100 Gbps interfaces
• NAT and PAT dynamic translation learning

Drawbacks:

• Router plugin support is not open

4. Solarwinds WAN Killer

SolarWinds is a trusted company that puts a range of testing, management and monitoring tools at your disposal.

Their WAN Killer tool performs proactive network stress and load testing by sending fully-customizable real traffic to specific host or IP address.

It allows you to set the packet size and bandwidth percentage during network WAN testing, track TCP/UDP packets under specific load conditions, and set the IP address or host name for random packet generation.

This tool is not available for free, but there is a 14-day free trial version with full functionality before you have to purchase a license.

Features of WAN Killer include:

• Monitors bandwidth and WLC traffic
• App traffic alerting and network analysis
• Integrates with other Solar Winds tools and Orion platforms
• Advanced NBAR2 app recognition
• CBQoS policy optimization
• Identifies malicious and malformed traffic patterns
• Combines NTA with Network Configuration Manager (NCM)

Drawbacks:

• Prices start at more than $1,000
• Only works on Windows OS

5. Packet Sender

This multi-purpose app allows you to send and receive simulated UDP, TCP, and SSL packets, configure and select ports, and run client and server software simultaneously.

It also offers a great deal of flexibility and customization for methodology and input through command line or GUI.

Packet Sender also includes built-in ASCII and Hex readers, and it supports all major operating systems. Best of all, this tool is completely free and open source.

Features

• Hot key function
• Performs concurrent malware analysis
• Test environment automation and scripting
• Runs traffic generation testing between two separate machines
• Probes firewall integrity
• Supports all major operating systems
• Built-in ASCII and Hex readers
• Scales up or down to provide customized testing environments

Drawbacks:

• None that we could see

6. NTGM

Not only does this easy app test incoming traffic, it also performs stress and load testing right over your network. With this tool, you can analyse the behavior of your network by sending TCP/IP and ICMP traffic as well as UDP packets. Once you install this app, you are offered 20 each of UDP, TCP generators/servers and clients.

This is a paid tool but with a very affordable price tag of around $79 for the personal license.

Features

• Easy to use interface
• Supports 20 UDP generators and clients for each installation
• Supports 20 TCP servers and clients for each installation
• Measures different types of TCP traffic
• Also acts as a network monitor
• Emulates both client and server activity

Drawbacks:

• Not free (but affordable)
• Only compatible with Windows

7. Packet Flooder Tool

This tool has one purpose: to flood your network with UDP packets as fast as possible to see how much it can take.

This is very useful to test how your network and security defences will behave during a volumetric DDoS attack for example.

Although it doesn’t offer as wide a testing environment, as many features, or some of the bells and whistles of other traffic generators, it does what it was designed to do, and it does it well.

This app does allow you to set testing parameters, including target port, payload, and send rates. The baseline is set at 100BaseT ethernet interface with up to 98 percent usage, dependent on your hardware/software configuration.

Features:

• Supports IPv4 & 6
• Offers control over target ports, payloads, and send rates
• Evaluates heavy traffic/high payloads
• Trial version available

Drawbacks:

• Only generates UDP packets
• Must pay for licensing after free trial

8. PackETH

This tool was created for generating and analyzing Ethernet traffic and networks. It’s accessible via command line or GUI interface, and you can adjust the parameters to simulate a range of conditions.

The latest generation of this tool, 2.0, even checks for dropped connections, and it supports Linux-based operating systems.

Packeth supports a wide range of protocols, including ethernet II, ethernet 802.3, 802.1q, QinQ, TCP ADP as well as user-defined Ethernet frameworks, network payloads, and transport layer payloads. Free and open source and best suited for LAN environments.

Features:

• Creates delays between packets
• Defines number of packets
• Allows changing parameters mid-test
• Supports nearly all protocols and RTP payloads
• Includes ramp and speed setting options
• Supports PCAP formats of file (saving and reading).
• Supports JUMBO frames with appropriate network drivers enabled
• Easy to use, shallow learning curve

Drawbacks:

• Only supports Linux-based OS
• CLI version only sends packers already stored in PCAP files
• Depending on Linux distribution and installation, may need additional packages

9. iperf2

This traffic generation tool gets back to basics with its second gen release. It measures both TCP and UDP performance under a range of traffic conditions with the goal of maintaining active iperf coding and preserving that coding which is inoperable.

Iperf 2 also adds Python code control to enable centralized testing, and it releases timing-related statistics that include recording end-to-end latency.

Features:

• Supports most major operating systems
• Supports intervals as short as five minutes
• Can do enhanced reporting
• Displays target loop time in the initial UDP header
• Supports SO_RCVTIMEOUT, O_SNDTIMEO, and SO_TIMESTAMP
• Binds to allow OS to determine target port
• Multicast SSM support for IPv4 and 6
• Free, open source

Drawbacks:

• Not compatible with iperf 3

10. Emutex

This tool utilizes Intel DPDK (Data Plane Development Kit) technology to create a real-world solution for cloud-based, high-speed networks.

One thing it has over other network traffic generators is datagrams transmission, which is necessary for testing applications such as Open vSwitch.

This Linux-supported solution deploys C and Python based network packet generation frameworks to analyze network latency, loads, and TCP network setup/teardown.

Features:

• Evaluates datagram transmission
• Performs network latency testing
• Customizable
• Free, open source

Drawbacks:

• Only supports Linux-based OS

Final Thoughts

Packet generators allow you to simulate traffic and its effects over a multitude of platforms and circumstances.

They can be applied to test and gauge the effectiveness of your security controls or evaluate system and network performance.

Our review should help you to find the tool that’s right for your needs and computing environment.

Packet crafting как он есть

Создание пакетов или packet crafting — это техника, которая позволяет сетевым инженерам или пентестерам исследовать сети, проверять правила фаерволлов и находить уязвимые места.
Делается это обычно вручную, отправляя пакеты на различные устройства в сети.
В качестве цели может быть брандмауэр, системы обнаружения вторжений (IDS), маршрутизаторы и любые другие участники сети.
Создание пакетов вручную не означает, что нужно писать код на каком-либо высокоуровневом языке программирования, можно воспользоваться готовым инструментом, например, Scapy.

Scapy — это один из лучших, если не самый лучший, инструмент для создания пакетов вручную.
Утилита написана с использованием языка Python, автором является Philippe Biondi.
Возможности утилиты практически безграничны — это и сборка пакетов с последующей отправкой их в сеть, и захват пакетов, и чтение их из сохраненного ранее дампа, и исследование сети, и многое другое.
Всё это можно делать как в интерактивном режиме, так и создавая скрипты.
С помощью Scapy можно проводить сканирование, трассировку, исследования, атаки и обнаружение хостов в сети.
Scapy предоставляет среду или даже фреймворк, чем-то похожий на Wireshark, только без красивой графической оболочки.
Утилита разрабатывается под UNIX-подобные операционные системы, но тем не менее, некоторым удается запустить ее и в среде Windows.
Эта утилита так же может взаимодействовать и с другими программами: для наглядного декодирования пакетов можно подключать тот же Wireshark, для рисования графиков — GnuPlot и Vpython.
Для работы потребуется права суперпользователя (root, UID 0), так как это достаточно низкоуровневая утилита и работает напрямую с сетевой картой.
И что важно, для работы с этой утилитой не потребуются глубокие знания программирования на Python.

Приступаем

Официальный сайт проекта — www.secdev.org/projects/scapy
Установку можно провести разными способами, например apt-get install python-scapy, в случае дистрибутивов на основе Debian.
Так же можно просто скачать свежую версию с сайта разработчиков:
# cd /tmp
# wget scapy.net
# unzip scapy-latest.zip
# cd scapy-2.*
# sudo python setup.py install
После этого запуск происходит непосредственно командой scapy.
На экране отобразится примерно так:

Мы видим стандартное приглашение для ввода, все действия будут выполняться в интерактивном режиме.
Выход происходит комбинацией Ctrl+D, либо набрав функцию exit().

Изучаем инструмент

На самом деле Scapy сильно отличается от привычных утилит. Он работает в текстовом режиме, но любое взаимодействие осуществляется не через привычные ключи и параметры командной строки, а через интерпретатор Python’а.
Такой подход вначале может показаться несколько неудобным и непривычным, но со временем и с практикой приходит понимание того, что это было правильным решением, и что это действительно удобно.

Вначале посмотрим на поддерживаемые протоколы, для этого вызовем функцию ls().

Вывалится более 300 разнообразных протоколов, с которыми можно работать, включая прикладные вроде HTTP, транспортные TCP и UDP, сетевого уровня IPv4 и IPv6 и канального уровня Ether (Ethernet).
Важно обращать внимание на регистр: большинство протоколов пишутся в Scapy с заглавными буквами.
Для того чтобы подробно рассмотреть поля определенного протокола, можно вызвать функцую ls() с указанием протокола: ls(TCP)

В результате будут выведены все поля, которые можно модифицировать в процессе создания пакетов. В скобках показаны значения, которые используются по умолчанию, можно заметить, что порт отправителя 20 (это ftp-data) и порт получателя – 80 (это естественно HTTP), так же установлен флаг SYN (flags = 2).

К примеру, если рассмотреть канальный уровень (Ethernet), то тут возможностей будет поменьше:

В дополнение к функции ls(), есть полезная функция lsc(), которая выведет практически весь основной функционал Scapy:

Для того чтобы получить более подробную информацию о каждой функции, можно использовать help(имя_функции), например:

Видим нечто похожее на MAN страницу в Unix системах.
Для выхода можно использовать опять же привычную в Linux клавишу Q.

Мы посмотрели на протоколы и функции, теперь можно перейти к делу — к созданию пакетов.

Крафтим

Можно создавать сразу пакеты высоких уровней (сетевого и прикладного), и Scapy автоматически дополнит низлежащие уровни, а можно вручную собирать, начиная с канального уровня.
Разделяются уровни модели OSI символом прямого слэша (/).
Нужно обратить внимание на то, что Scapy читает пакет от нижнего уровня слева, до более высокого справа. Поначалу это может немного сбивать с толку, но после небольшой практики всё станет вполне привычно.
К слову, в терминологии Scapy сетевой пакет разделяется на слои, и каждый слой представляется как экземпляр объекта.
Собранный пакет в упрощенном виде может выглядеть как:
Ether()/IP()/TCP()/”App Data”
В большинстве случаев используется только уровень L3, предоставляя Scapy возможность самостоятельно заполнять канальный уровень, на основе информации из ОС.
Меняя значения полей каждого протокола мы меняем стандартные значения (их выводит функция ls()).

Теперь создадим какой-нибудь простой пакет.

Всё очень просто: мы указали адрес назначения, порт и вобщем-то нагрузку в виде слова «TEST».
Сам пакет был незамысловато назван packet, мы увидим очень подробно и развернуто наш свежесозданный пакет:
И теперь, выполнив знакомую уже функцию ls(packet):

Уровни в нем разделяются символами «—«.

Вместо того, чтобы создавать пакет за один раз можно создавать его частями:

В этом примере мы создали переменные под каждый уровень модели OSI.
В качестве имен переменных можно использовать и буквы и цифры, при этом, не забывая о регистре.

И теперь собираем всё в один пакет:

Видно, что результат получится аналогичный.

Углубляемся в пакеты

Мы уже смотрели на вывод функции ls(), но не всегда нужна такая подробная информация о пакете.
Достаточно просто набрать имя переменной и сразу увидеть краткую сводку:

Так же можно использовать метод summary():

Если же нужно чуть больше информации, то есть метод show():

Кроме того, можно просмотреть любое поле, просто указав его:

Разумеется, это работает только в том случае, если такие поля уникальны в пределах пакета.
Если, например, взять поле flags, которое присутствует как в TCP, так и в IP, тут уже нужно конкретизировать, что мы хотим увидеть. В противном случае Scapy выведет значение первого найденного поля (IP flags в нашем примере).
Конкретизация происходит путем указания протокола в квадратных скобках:

К слову, по умолчанию установленные флаги выводятся в цифровом представлении.
Если все управляющие биты будут включены (установлены в 1), то получим значение равное 255. В нашем случае значение 2 говорит о том, что установлен SYN бит.

Но существует возможность отобразить управляющие биты и в символьном отображении:

Как уже говорилось, в любой момент можно достаточно просто поменять значение любого поля:

А в случае, если поле не является уникальным, то нужно указать протокол:

Вторым способом является использование конструкции payload, которая позволяет перепрыгнуть через один уровень (через L3 в нашем случае):

Здесь мы вначале просматриваем вывод слоев над L3, затем просматриваем значение TCP флагов и устанавливаем для них новое значение.
Кстати, можно даже несколько раз вызвать payload, поднимаясь при этом выше и выше:

Можно еще посмотреть на содержимое пакета в шестнадцатеричном виде, для этого есть функция hexdump():

Разбираемся с адресацией

Scapy и в деле указания адреса получателя так же проявляет большую гибкость.
Масса вариантов — здесь и привычная десятичная форма, и доменное имя и CIDR нотация:

В последнем случае пакет будет отправлен на каждый адрес в подсети.

Множество адресов можно задать, просто разделяя их запятой, не забыв про квадратные скобки:

На этом этапе может возникнуть мысль: «А что если нужно задать множество портов?».
И тут Scapy предоставляет широкие возможности, можно указать как диапазон, так и просто перечислить множество:

Обращаю внимание на различие в скобках, в случае диапазона они круглые, а в случае множества – квадратные.
И завершая разговор про указание целей, рассмотрим ситуацию, когда нужно отправить множество пакетов на множество портов.
Для того, чтобы увидеть какие пакеты будут отправлены придется задействовать цикл for, не забываем, что язык программирования у нас Python.
На самом деле ничего сложного, всё очень логично:

Вначале мы уже привычно создаем пакет, в котором указываем подсеть и диапазон портов.
Затем, используя цикл, создаем список, где переменной «а» присваивается каждый элемент структуры пакета. В Python’е отсутствуют массивы в привычном понимании. Вместо них для хранения объектов используются списки.
Мы используем цикл for, для того чтобы «распаковать» всю структуру и отобразить ее в таком наглядном виде.

Отправляем пакеты в путь

С таким же размахом и широтой происходит и отправка пакетов:

• функция send() – отправляет пакеты, используя сетевой (L3) уровень, никак не обрабатывая ответы. Используется принцип — отправили и забыли;
• функция sendp() – отправляет пакеты, используя канальный (L2) уровень, учитываются указанные параметры и заголовки Ethernet кадров. Ответы всё так же не ожидаются и не обрабатываются;
• функция sr() – является аналогичной send(), исключение составляет то, что она уже ожидает ответные пакеты;
• функция srp() – отправляет и принимает пакеты, уровень L2
• функция sr1() – отправляет пакет третьего уровня и забирает только первый ответ, множество ответов не предусматривается;
• функция srp1() – аналогично sr1(), только уже канальный уровень.

Каждую из этих функций можно вызвать и без дополнительных параметров, просто указывая имя переменной, содержащей пакет.

Но вместе с тем существует много дополнительных опций, которые могут быть иногда полезны.
Например, timeout – укажет, сколько времени (в секундах) нужно ждать до получения ответного пакета, retry – сколько раз нужно повторно слать пакет, если ответ не был получен и одна из самых полезных опций – это filter, синтаксис которого очень похож на tcpdump.

В качестве наглядного примера отправим пакет в сеть:

Здесь мы используем функцию, которая после отправки ожидает ответ, устанавливаем таймаут 0.1 секунды и фильтруем ответы, которые подпадают под указанное правило.

Как поступать с ответными пакетами?
Можно взять и назначить переменную, которая и будет содержать ответ:

А смотреть уже привычным способом, просто вызывая переменную response.
Видно, что ответ сохранился в двух вариантах – Results и Unanswered, результаты и без ответа, соответственно.
Указывая смещение, можно вывести только необходимую часть ответа:

Или подробную информацию:

Если же пакет был отправлен в сеть без указания переменной (например, просто функцией sr()), то по умолчанию пакет будет числиться за переменной «_» (символ подчеркивания).

Чтобы достать оттуда эти пакеты, можно использовать конструкцию:

При этом разные результаты сохранятся в двух разных переменных (res и unans).

Более подробный вывод достигается опять же путем указания смещения:

Ловим ответные пакеты

Теперь рассмотрим ситуацию, если пакетов в ответ приходит много.

То, что мы увидели, было по сути, самое что ни есть сканирование портов.

Открытые порты будут с флагами SA (SYN/ACK), например:

Мы смотрим именно на пакет по номеру, счет традиционно начинается нуля.

Можно пойти дальше и распаковать этот результат:

Здесь мы извлекли из результата отправленный пакет (под номером 21) и ответ на него.
Но это только один пакет, а как быть, если нужно обработать все пакеты?
В таком случае придется вновь обращаться к циклу for:

Берем и разбиваем каждый элемент списка res на части a и b. Затем обрезаем часть “a”, заливая это всё в список “allsent”.
Аналогично создаем список allrec, только уже оставляем другую часть.
Всё это, конечно, хорошо, но хотелось бы в более удобном виде получить список открытых и закрытых портов.
Еще раз посмотрим на список res, a точнее на элемент res[0], который состоит из двух частей: пакет, который мы отправили res[0][0], и ответ, который получили res[0][1].

В ответе можно обнаружить три части — заголовок IP (res[0][1][0]), заголовок TCP (res[0][1][1]) и собственно сами данные (res[0][1][2]).

Используем цикл for для извлечения каждого элемента res[N] в переменную «а».

Теперь в переменной «a»содержится результат для каждого пакета. Другими словами «а» представляет собой ans[N].
Нам остается только проверить значения a[1][1], которые будут означать res[N][1][1] в заголовке TCP.
Если быть еще более точным, требуется значение 18, которое означает установленные флаги SYN-ACK.

В тех случаях, когда это условие сработает, мы еще выведем порт отправителя из заголовка TCP:

В итоге, получим результат в виде списка открытых портов.
Все вышеозначенные конструкции набираются за один раз, важно так же уделять внимание отступам (обычно это 4 пробела).

Мы только что вручную написали простой сканер портов, не больше и не меньше.

Сниффер и наоборот

В Scapy входит также и небольшой сниффер, за который отвечает функция sniff().
Естественно, с ним можно использовать фильтры (похожие на фильтры tcpdump), за это отвечает параметр filter, так же можно ограничивать количество пакетов с помощью параметра count.
Как всегда вызов help(sniff) выведет вполне подробную информацию по этой функции.
Не следует забывать, что это сильно упрощенный сниффер, и ожидать от него хорошей скорости особо не приходится.
Стандартная комбинация Ctrl+C прервет процесс захвата трафика и выведет результат.
Как и любая неопределенная переменная, результат попадет в «_».
Выполнив метод summary(), можно увидеть статистику по захваченным пакетам:

Вместо захвата трафика из сети, можно прочитать его из заранее сохраненного дампа (pcap файла).

Кроме того, можно и наоборот, записать пойманные пакеты в файл, используя функцию wrpcap():

И завершая тему сниффинга, можно вызвать Wireshark прямо из интерфейса Scapy, для этого можно использовать одноименную функцию wireshark().

Подробно про Wireshark можно в моей предыдущей статье по адресу http://linkmeup.ru/blog/115.html.

Автоматизация

Казалось бы, что уже всё готово, но не тут то было.
При очередной попытке подгрузить ospf модуль:
>>> load_contrib(‘ospf’), получаем всё ту же ошибу «ERROR: No module named contrib.ospf»
Для того, чтобы модуль окончательно заработал, осталось создать скрипт инициализации (пустой файл):
touch /usr/lib/python2.7/dist-packages/scapy/contrib/__init__.py
После этого, уже можно будет создавать пакеты для OSPF.

Создаем трехэтапное TCP-соединение

Для этого нужно будет поймать SYN/ACK ответ, извлечь из него TCP sequence number, увеличить значение на единицу и, собственно, и поместить полученное значение в поле acknowledgement number.
Непростая задача на первый взгляд, но Scapy может справиться и с ней.
Вначале рассмотрим, что нам нужно, для того чтобы всё прошло успешно.

1) Отправить SYN принимающей стороне:

• собрать заголовок IP, не забыть про адрес отправителя и получателя;
• собрать TCP заголовок, в котором нужно будет указать TCP порты отправителя и назначения, установить TCP флаги (SYN бит) и сгенерировать ISN (Initial Sequence Number).

2) Поймать ответный пакет:

• сохранить ответ;
• извлечь из него TCP sequence number и увеличить это значение на единицу.

3) Создать подтверждение (ACK) на полученный ответный пакет:

• собрать заголовок IP, содержащий такие же адреса отправителя и получателя, как в случае SYN пакета;
• собрать TCP заголовок, с такими же номерами портов, как и в SYN сегменте, но уже установить ACK флаг, увеличить значение ISN на единицу и установить acknowledgement в извлеченный и увеличенный, на втором шаге, sequence number.

Для того чтобы стало еще понятней, рассмотрим уже более подробно, с использованием произвольно взятых значений.
К примеру, соединение прошло таким образом:

192.168.10.200 1024 > 192.168.10.50 80 flags=SYN seq=12345
192.168.10.50 80 > 192.168.10.200 1024 flags=SYN, ACK seq=9998 ack=12346
192.168.10.200 1024 > 192.168.10.50 80 flags=ACK seq=12346 ack=9999

Что в итоге нужно было сделать.

1) Отправить SYN принимающей стороне:

• собрать заголовок IP, в котором указать в качестве отправителя 192.168.10.200 и 192.168.10.50 в качестве получателя;
• собрать TCP заголовок с портом источника (source) 1024 и портом назначения (destination) 80. Так же установить SYN флаг и сгенерировать ISN равный 12345.

2) Поймать ответный пакет:

• сохранить ответ;
• извлечь из него TCP sequence number (9998) и увеличить это значение на единицу, получим 9999.

3) Создать подтверждение (ACK) на полученный ответный пакет:

• собрать заголовок IP, в котором указать в качестве отправителя 192.168.10.200 и 192.168.10.50 в качестве получателя;
• собрать TCP заголовок с такими же портами источника и назначения (1024 и 80 соответственно), установить ACK флаг, увеличить ISN на единицу (12346) и установить acknowledgement в увеличенное значение пойманного seq number (9999).

Начнем собирать пакет:

Здесь уже всё должно быть знакомым: пакет собираем из двух частей, инкапсулируя TCP в IP.

Теперь помня о том, что нам нужно будет перехватить ответ, извлечь оттуда sequence number и увеличить на единицу, делаем:

Происходит следующее – функция sr1 отправляет ранее созданный пакет в сеть, а первый пришедший ответ помещается в переменную SYNACK.
А затем, используя конструкцию SYNACK.seq, извлекаем TCP sequence number, увеличиваем его на единицу и сохраняем в переменной my_ack.

Создаем новый заголовок TCP и называем его ACK. В нем устанавливается другой флаг (A — ACK) и увеличивается значение sequence number.
Кроме того, в качестве acknowledgement указывается переменная my_ack.
Затем собранный пакет выбрасывается в сеть командой send (помним, что это L3 команда, которая даже не слушает, что придет в ответ).
Если всё было сделано правильно, то классическое TCP-соединение состоялось.
Осталось только создать TCP сегмент без каких-либо флагов и тоже отправить в сеть.

Как можно увидеть, мы в очередной раз создали экземпляр TCP заголовка (в этот раз, назвав его PUSH), без флагов и со всеми остальными знакомыми уже значениями.
После этого добавили немного данных, используя переменную data, и отправили в сеть, используя ту же функцию send.
И соответственно от получателя должен будет прийти acknowledgement на этот сегмент.

>>> ip=IP(src=«192.168.10.200»,dst=«192.168.10.50»)
>>> SYN=TCP(sport=1024,dport=80,flags=«S»,seq=12345)
>>> packet=ip/SYN
>>> SYNACK=sr1(packet)
>>> my_ack=SYNACK.seq+1
>>> ACK=TCP(sport=1024,dport=80,flags=«A»,seq=12346,ack=my+ack)
>>>send(ip/ACK)

Но здесь есть и несколько подводных камней.
Если посмотреть на этот обмен в Wireshark, можно увидеть, что до того как ушел наш ACK пакет, внезапно был отправлен RST:

Дело в том, что Scapy работает мимо TCP/IP стека ОС. Это означает то, что ОС не подозревает о том, что Scapy отправляет какие-то пакеты.
Соответственно ОС не будет ожидать появления SYN/ACK пакетов. И, следовательно, соединение будет сразу же сброшено.
Очевидно, что это совсем не тот результат, который нам нужен.
Одним из решений такой проблемы будет использование функционала пакетного фильтра, в частности iptables, который сможет блокировать исходящие RST пакеты.
Например, таким образом:
# iptables -A OUTPUT -p tcp -d 192.168.10.50 -s 192.168.10.200 —dport 80 —tcp-flags RST RST -j DROP
Выполнение такой конструкции приведет к тому, что все исходящие пакеты с адресом назначения 192.168.10.50 и с адресом отправителя 192.168.10.200 на 80-й порт, с установленным RST флагом, будут отбрасываться.
Пакеты будут все так же генерироваться силами ОС, но они просто не будут вылетать за ее пределы.
В итоге уже ничего не будет мешать Scapy делать полноценную TCP-сессию:

Продолжаем исследования

Используя Scapy, можно находить хосты в сети, среди указанного множества адресов:

В этом случае мы используем протокол ICMP и применяем знакомый прием по разделению полученных ответов.

По умолчанию, установлен 8-й тип для ICMP, это и есть классический эхо-запрос.

Углубляясь в тему ИБ, попробуем определить версию ОС используя Scapy и nmap.

Итак, рассмотрим что было сделано.
Вначале был подключен внешний модуль, в данном случае nmap.
Затем проверяем, что у нас есть файл (nmap-os-fingerprints) с отпечатками различных ОС.
И запускаем непосредственно определение удаленной операционной системы, за это отвечает функция nmap_fp, где в качестве параметров помимо самой цели, можно еще указать открытый (oport) и закрытый (cport) порты.
Правильно указанные порты помогут сильно улучшить точность определения ОС.

Визуализируем пакеты

Все время мы смотрели на текстовый вывод, местами была псевдографика, но Scapy умеет и выводить некоторые результаты в графическом виде.
Посмотрим, что нам предлагается.
Самое простое — это метод conversations():

При его выполнении, запустится окно ImageMagick, в котором отрисуется схема нашего обмена пакетами, не ахти красиво, но достаточно наглядно.
Это способ, вероятно, лучше всего подойдет, для визуализации дампов с трафиком.

Второй способ заключается в построении 2D графиков, с последующим экспортом их в pdf-файл.

За это уже отвечает функция pdfdump().
Результаты выглядят примерно так:

В данном случае уже вполне неплохо.
Кроме того, функция graph() опять откроет окно ImageMagick, но уже с детальной прорисовкой:

Здесь мы видим результат трассировки, с подробным отображением автономных систем и прочей визуализацией.

И, завершая тему визуализации, а вместе с ней и статью, посмотрим на 3D отображения трассы.
Для этого потребуется VPython и команда trace3D().

Здесь отображена трасса из предыдущего графика.

Но иногда бывают и такие варианты:

В этом примере была проведена трассировка сразу нескольких целей, с использованием нескольких (80, 443) tcp портов.
Левый клик на любом объекте приведет к появлению IP-адреса над ним, а левый клик с зажатой клавишей CTRL – к отображению более подробной информации — портам, как в этом случае.

Эпилог

Итак, мы рассмотрели лишь малую часть утилиты Scapy, но уже это впечатляет.
Возможности, которые предоставляются действительно очень большие.
Статья призвана вызвать у читателя интерес в изучении сетевых протоколов, и не является исчерпывающим руководством по инструменту Scapy.
За использование этой утилиты в каких-либо противоправных целях автор ответственности не несет.

В процессе написания статьи использовались материалы Института SANS и официальная документация проекта.