3rd-party/libtins
1
0
Fork 0
mirror of https://github.com/mfontanini/libtins synced 2026-01-23 02:35:57 +01:00
Code Issues Releases Wiki Activity

Add initial code for new TCP reassembly mechanism

Browse Source
This commit is contained in:
Matias Fontanini
2016-02-07 11:29:24 -08:00
parent 785ee7b47b
commit 76b0c919b9
5 changed files with 1062 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/src/CMakeLists.txt
View File

@@ -83,6 +83,7 @@ ADD_CUSTOM_TARGET(
SLLTest
SNAPTest
STPTest
TCPIPTest
TCPTest
TCPStreamTest
UDPTest
@@ -128,6 +129,7 @@ ADD_EXECUTABLE(SLLTest EXCLUDE_FROM_ALL sll.cpp)
ADD_EXECUTABLE(SNAPTest EXCLUDE_FROM_ALL snap.cpp)
ADD_EXECUTABLE(STPTest EXCLUDE_FROM_ALL stp.cpp)
ADD_EXECUTABLE(TCPTest EXCLUDE_FROM_ALL tcp.cpp)
ADD_EXECUTABLE(TCPIPTest EXCLUDE_FROM_ALL tcp_ip.cpp)
ADD_EXECUTABLE(TCPStreamTest EXCLUDE_FROM_ALL tcp_stream.cpp)
ADD_EXECUTABLE(UDPTest EXCLUDE_FROM_ALL udp.cpp)
ADD_EXECUTABLE(UtilsTest EXCLUDE_FROM_ALL utils.cpp)
@@ -208,6 +210,7 @@ ADD_TEST(SLL SLLTest)
ADD_TEST(SNAP SNAPTest)
ADD_TEST(STP STPTest)
ADD_TEST(TCP TCPTest)
ADD_TEST(TCPIP TCPIPTest)
ADD_TEST(TCPStream TCPStreamTest)
ADD_TEST(UDP UDPTest)
ADD_TEST(Utils UtilsTest)

319
tests/src/tcp_ip.cpp Normal file
View File

@@ -0,0 +1,319 @@
#include "cxxstd.h"
#if TINS_IS_CXX11
#include <gtest/gtest.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <limits>
#include <cassert>
#include "tcp_ip.h"
#include "tcp.h"
#include "ip.h"
#include "ip_address.h"
#include "ipv6_address.h"
#include "ethernetII.h"
#include "rawpdu.h"
#include "utils.h"
using namespace std;
using namespace Tins;
using namespace Tins::TCPIP;
class TCPFlowTest : public testing::Test {
public:
struct order_element {
order_element(size_t payload_index, uint32_t payload_size)
: payload_index(payload_index),payload_size(payload_size) {
}
size_t payload_index;
uint32_t payload_size;
};
static const size_t num_packets = 20;
static EthernetII packets[], overlapped_packets1[],
overlapped_packets2[], overlapped_packets3[],
overlapped_packets4[], overlapped_packets5[];
static const string payload;
typedef vector<order_element> ordering_info_type;
void cumulative_flow_data_handler(TCPFlow& flow);
void cumulative_stream_client_data_handler(TCPStream& stream);
void cumulative_stream_server_data_handler(TCPStream& stream);
void buffered_payload_handle(TCPFlow& session);
void run_test(uint32_t initial_seq, const ordering_info_type& chunks,
const string& payload);
void run_test(uint32_t initial_seq, const ordering_info_type& chunks);
void run_tests(const ordering_info_type& chunks, const string& payload);
void run_tests(const ordering_info_type& chunks);
ordering_info_type split_payload(const string& payload, uint32_t chunk_size);
string merge_chunks(const vector<TCPFlow::payload_type>& chunks);
vector<EthernetII> chunks_to_packets(uint32_t initial_seq,
const ordering_info_type& chunks,
const string& payload);
vector<EthernetII> three_way_handshake(uint32_t client_seq, uint32_t server_seq,
IPv4Address client_addr, uint16_t client_port,
IPv4Address server_addr, uint16_t server_port);
void set_endpoints(vector<EthernetII>& packets, IPv4Address src_addr,
uint16_t src_port, IPv4Address dst_addr,
uint16_t dst_port);
vector<TCPFlow::payload_type> flow_payload_chunks;
vector<TCPFlow::payload_type> stream_client_payload_chunks;
vector<TCPFlow::payload_type> stream_server_payload_chunks;
};
const string TCPFlowTest::payload = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. "
"Sed at aliquam arcu. Sed at iaculis magna. Nam ut dolor "
"eget velit mattis posuere ut non dui. Aliquam faucibus "
"erat pretium ligula tincidunt eget tristique justo placerat. "
"Phasellus turpis tellus, ornare ultricies egestas vitae, "
"mollis sed neque. Sed et libero in nunc pharetra auctor ut "
"a eros. Mauris quis faucibus nibh. \nLorem ipsum dolor sit "
"amet, consectetur adipiscing elit. Sed at aliquam arcu. "
"Sed at iaculis magna. Nam ut dolor eget velit mattis "
"posuere ut non dui. Aliquam faucibus erat pretium ligula "
"tincidunt eget tristique justo placerat. Phasellus turpis "
"tellus, ornare ultricies egestas vitae, mollis sed neque. "
"Sed et libero in nunc pharetra auctor ut a eros. Mauris "
"quis faucibus nibh. \n\n\nCurabitur sem erat, bibendum "
"quis condimentum ut, imperdiet at est. Duis sagittis rhoncus "
"felis at ultricies. In libero urna, dignissim eu elementum "
"quis, consectetur a neque. Praesent leo sem, cursus sed lobortis "
"sit amet, ornare ac augue. Mauris tristique semper ipsum at "
"consequat. Sed fringilla dolor ut lacus sagittis quis ultricies "
"leo vulputate. Maecenas dignissim imperdiet justo. Cras libero "
"odio, vehicula et adipiscing quis, luctus vel ante. \nAliquam "
"imperdiet est quis nunc malesuada eget convallis tellus "
"ullamcorper. Vivamus ullamcorper eros sit amet odio sollicitudin "
"rutrum. Donec pellentesque faucibus nulla, ut fringilla risus "
"aliquam eget. Sed et ante mi. Morbi a turpis et tellus dapibus "
"iaculis. Etiam faucibus tellus sed metus consequat rutrum. "
"Fusce sit amet nulla massa, tempus vulputate sem. Cras tincidunt "
"quam in libero rutrum interdum. Aliquam quam sapien, facilisis "
"at vestibulum et, venenatis id mauris. Morbi rutrum gravida "
"ultricies. \nAenean et justo ut libero euismod sollicitudin. "
"Nullam enim dui, iaculis vitae bibendum et, commodo in tellus. "
"Nullam eget purus mi, a ullamcorper lorem. Suspendisse potenti. "
"Duis ac justo ut leo euismod gravida sit amet at lectus. Lorem "
"ipsum dolor sit amet, consectetur adipiscing elit. Maecenas sed "
"arcu vitae nisi sollicitudin gravida. Nulla facilisis nibh turpis. "
"Maecenas quis imperdiet arcu. Sed sit amet nulla urna, at "
"vestibulum mauris. Suspendisse quis elit dui. Class aptent taciti "
"sociosqu ad litora torquent per conubia nostra, per inceptos "
"himenaeos. \n";
void TCPFlowTest::cumulative_flow_data_handler(TCPFlow& flow) {
flow_payload_chunks.push_back(flow.payload());
flow.payload().clear();
}
void TCPFlowTest::cumulative_stream_client_data_handler(TCPStream& stream) {
stream_client_payload_chunks.push_back(stream.client_flow().payload());
stream.client_flow().payload().clear();
}
void TCPFlowTest::cumulative_stream_server_data_handler(TCPStream& stream) {
stream_server_payload_chunks.push_back(stream.server_flow().payload());
stream.server_flow().payload().clear();
}
void TCPFlowTest::buffered_payload_handle(TCPFlow& session) {
}
void TCPFlowTest::run_test(uint32_t initial_seq, const ordering_info_type& chunks,
const string& payload) {
using std::placeholders::_1;
flow_payload_chunks.clear();
TCPFlow flow(IPv4Address("1.2.3.4"), 22, initial_seq);
flow.data_callback(bind(&TCPFlowTest::cumulative_flow_data_handler, this, _1));
vector<EthernetII> packets = chunks_to_packets(initial_seq, chunks, payload);
for (size_t i = 0; i < packets.size(); ++i) {
flow.process_packet(packets[i]);
}
string flow_payload = merge_chunks(flow_payload_chunks);
EXPECT_EQ(payload, string(flow_payload.begin(), flow_payload.end()));
}
void TCPFlowTest::run_test(uint32_t initial_seq, const ordering_info_type& chunks) {
run_test(initial_seq, chunks, payload);
}
void TCPFlowTest::run_tests(const ordering_info_type& chunks, const string& payload) {
run_test(0, chunks, payload);
run_test(20, chunks, payload);
run_test(numeric_limits<uint32_t>::max() / 2, chunks, payload);
run_test(numeric_limits<uint32_t>::max() - 2, chunks, payload);
run_test(numeric_limits<uint32_t>::max() - 5, chunks, payload);
run_test(numeric_limits<uint32_t>::max() - 10, chunks, payload);
run_test(numeric_limits<uint32_t>::max() - 34, chunks, payload);
run_test(numeric_limits<uint32_t>::max() - 31, chunks, payload);
}
void TCPFlowTest::run_tests(const ordering_info_type& chunks) {
run_tests(chunks, payload);
}
TCPFlowTest::ordering_info_type TCPFlowTest::split_payload(const string& payload,
uint32_t chunk_size) {
ordering_info_type output;
uint32_t chunk_count = payload.size() / chunk_size;
for (uint32_t i = 0; i < chunk_count; ++i) {
output.push_back(order_element(i * chunk_size, chunk_size));
}
if (chunk_count * chunk_size < payload.size()) {
uint32_t index = chunk_count * chunk_size;
output.push_back(order_element(index, payload.size() - index));
}
return output;
}
string TCPFlowTest::merge_chunks(const vector<TCPFlow::payload_type>& chunks) {
string output;
for (size_t i = 0; i < chunks.size(); ++i) {
TCPFlow::payload_type this_chunk = chunks[i];
output += string(this_chunk.begin(), this_chunk.end());
}
return output;
}
vector<EthernetII> TCPFlowTest::chunks_to_packets(uint32_t initial_seq,
const ordering_info_type& chunks,
const string& payload) {
vector<EthernetII> output;
for (size_t i = 0; i < chunks.size(); ++i) {
const order_element& element = chunks[i];
assert(element.payload_index + element.payload_size <= payload.size());
TCP tcp;
RawPDU raw(payload.begin() + element.payload_index,
payload.begin() + element.payload_index + element.payload_size);
tcp.seq(initial_seq + element.payload_index);
output.push_back(EthernetII() / IP() / tcp / raw);
}
return output;
}
vector<EthernetII> TCPFlowTest::three_way_handshake(uint32_t client_seq, uint32_t server_seq,
IPv4Address client_addr, uint16_t client_port,
IPv4Address server_addr, uint16_t server_port) {
vector<EthernetII> output;
output.push_back(EthernetII() / IP(server_addr, client_addr) / TCP(server_port, client_port));
output.push_back(EthernetII() / IP(client_addr, server_addr) / TCP(client_port, server_port));
output.push_back(EthernetII() / IP(server_addr, client_addr) / TCP(server_port, client_port));
output[0].rfind_pdu<TCP>().flags(TCP::SYN);
output[0].rfind_pdu<TCP>().seq(client_seq);
output[1].rfind_pdu<TCP>().flags(TCP::SYN | TCP::ACK);
output[1].rfind_pdu<TCP>().seq(server_seq);
output[1].rfind_pdu<TCP>().ack_seq(client_seq + 1);
output[2].rfind_pdu<TCP>().flags(TCP::ACK);
output[2].rfind_pdu<TCP>().seq(client_seq + 1);
output[2].rfind_pdu<TCP>().ack_seq(server_seq + 1);
return output;
}
void TCPFlowTest::set_endpoints(vector<EthernetII>& packets, IPv4Address src_addr,
uint16_t src_port, IPv4Address dst_addr,
uint16_t dst_port) {
for (size_t i = 0; i < packets.size(); ++i) {
packets[i].rfind_pdu<IP>().src_addr(src_addr);
packets[i].rfind_pdu<IP>().dst_addr(dst_addr);
packets[i].rfind_pdu<TCP>().sport(src_port);
packets[i].rfind_pdu<TCP>().dport(dst_port);
}
}
TEST_F(TCPFlowTest, ReassembleStreamPlain) {
ordering_info_type chunks = split_payload(payload, 5);
run_tests(chunks);
}
TEST_F(TCPFlowTest, ReassembleStreamReordering) {
ordering_info_type chunks = split_payload(payload, 5);
// e.g. input [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// after this it's [2, 1, 0, 3, 6, 5, 4, 7, 10, 9, 8]
for (size_t i = 0; i < chunks.size(); i += 4) {
if (i + 2 < chunks.size()) {
swap(chunks[i], chunks[i + 2]);
}
}
run_tests(chunks);
}
TEST_F(TCPFlowTest, ReassembleStreamReversed) {
ordering_info_type chunks = split_payload(payload, 5);
reverse(chunks.begin(), chunks.end());
run_tests(chunks);
}
TEST_F(TCPFlowTest, Overlapping) {
string payload = "Hello world. This is a payload";
ordering_info_type chunks;
// "Hello "
chunks.push_back(order_element(0, 6));
// "ello Wo"
chunks.push_back(order_element(1, 7));
// "lo World"
chunks.push_back(order_element(3, 8));
chunks.push_back(order_element(10, payload.size() - 10));
chunks.push_back(order_element(9, 1));
run_tests(chunks, payload);
reverse(chunks.begin(), chunks.end());
run_tests(chunks, payload);
swap(chunks[2], chunks[4]);
run_tests(chunks, payload);
}
TEST_F(TCPFlowTest, TCPStreamFollower_ThreeWayHandshake) {
using std::placeholders::_1;
vector<EthernetII> packets = three_way_handshake(29, 60, "1.2.3.4", 22, "4.3.2.1", 25);
TCPStreamFollower follower;
follower.client_data_callback(bind(&TCPFlowTest::cumulative_stream_client_data_handler,
this, _1));
for (size_t i = 0; i < packets.size(); ++i) {
follower.process_packet(packets[i]);
}
TCPStream& stream = follower.find_stream("1.2.3.4", 22, "4.3.2.1", 25);
EXPECT_EQ(TCPFlow::ESTABLISHED, stream.client_flow().state());
EXPECT_EQ(TCPFlow::SYN_SENT, stream.server_flow().state());
EXPECT_EQ(30, stream.client_flow().sequence_number());
EXPECT_EQ(60, stream.server_flow().sequence_number());
EXPECT_EQ(IPv4Address("4.3.2.1"), stream.client_flow().dst_addr_v4());
EXPECT_EQ(25, stream.client_flow().dport());
EXPECT_EQ(IPv4Address("1.2.3.4"), stream.server_flow().dst_addr_v4());
EXPECT_EQ(22, stream.server_flow().dport());
IP server_packet = IP("1.2.3.4", "4.3.2.1") / TCP(22, 25);
server_packet.rfind_pdu<TCP>().flags(TCP::ACK);
follower.process_packet(server_packet);
EXPECT_EQ(TCPFlow::ESTABLISHED, stream.server_flow().state());
EXPECT_EQ(61, stream.server_flow().sequence_number());
}
TEST_F(TCPFlowTest, TCPStreamFollower_FollowStream) {
using std::placeholders::_1;
vector<EthernetII> packets = three_way_handshake(29, 60, "1.2.3.4", 22, "4.3.2.1", 25);
ordering_info_type chunks = split_payload(payload, 5);
vector<EthernetII> chunk_packets = chunks_to_packets(30 /*initial_seq*/, chunks, payload);
set_endpoints(chunk_packets, "1.2.3.4", 22, "4.3.2.1", 25);
packets.insert(packets.end(), chunk_packets.begin(), chunk_packets.end());
TCPStreamFollower follower;
follower.client_data_callback(bind(&TCPFlowTest::cumulative_stream_client_data_handler,
this, _1));
for (size_t i = 0; i < packets.size(); ++i) {
follower.process_packet(packets[i]);
}
EXPECT_EQ(chunk_packets.size(), stream_client_payload_chunks.size());
EXPECT_EQ(payload, merge_chunks(stream_client_payload_chunks));
}
#endif // TINS_IS_CXX11