gfwleak/stellar-stellar
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: add imitate_tcp_packet test case (TCP over GREv0: GRE enable checksum)

Browse Source
This commit is contained in:
luwenpeng
2024-07-15 15:07:38 +08:00
parent d31cfd02fd
commit 07ce636f64
13 changed files with 408 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/stellar/packet.h
View File

@@ -41,10 +41,10 @@ uint16_t packet_get_payload_len(const struct packet *pkt);
* tcp_ack: the acknowledgment number of the new TCP packet (in host byte order)
* tcp_options_len: the length of the options (must be a multiple of 4)
*/
struct packet *imitate_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_seq, uint32_t tcp_ack, uint8_t tcp_flags,
struct packet *craft_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_seq, uint32_t tcp_ack, uint8_t tcp_flags,
const char *tcp_options, uint16_t tcp_options_len,
const char *tcp_payload, uint16_t tcp_payload_len);
struct packet *imitate_udp_packet(const struct packet *origin_pkt, const char *udp_payload, uint16_t udp_payload_len);
struct packet *craft_udp_packet(const struct packet *origin_pkt, const char *udp_payload, uint16_t udp_payload_len);
struct packet *craft_packet_from_scratch(const struct layer larers[], uint16_t layer_count, const char *payload, uint16_t payload_len);
#ifdef __cplusplus

2
src/ip_reassembly/ip_reassembly.cpp
View File

@@ -723,7 +723,7 @@ static struct packet *ip_frag_reassemble(struct ip_reassembly *assy, struct ip_f
ip4_hdr_set_mf_flag(ip4_hdr, false); // update more fragment flag
ip4_hdr_set_frag_offset(ip4_hdr, 0); // update fragment offset
ip4_hdr->ip_sum = 0; // update checksum
ip4_hdr->ip_sum = checksum((const char *)ip4_hdr, flow->hdr.l3_len);
ip4_hdr->ip_sum = checksum((const void *)ip4_hdr, flow->hdr.l3_len);
}
else
{

2
src/packet/CMakeLists.txt
View File

@@ -1,4 +1,4 @@
add_library(packet packet_parse.cpp packet_build.cpp packet_dump.cpp packet_utils.cpp packet_ldbc.cpp packet_layer.cpp packet_tunnel.cpp checksum.cpp)
add_library(packet packet_parse.cpp packet_craft.cpp packet_dump.cpp packet_utils.cpp packet_ldbc.cpp packet_layer.cpp packet_tunnel.cpp checksum.cpp)
target_include_directories(packet PUBLIC ${CMAKE_CURRENT_LIST_DIR})
target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/deps/uthash)
target_include_directories(packet PUBLIC ${CMAKE_SOURCE_DIR}/include)

21
src/packet/checksum.cpp
View File

@@ -2,27 +2,22 @@
#include <arpa/inet.h>
uint16_t checksum(const char *data, uint16_t len)
uint16_t checksum(const void *data, int len)
{
uint16_t *ptr = (uint16_t *)data;
uint32_t sum = 0;
const uint16_t *ip1 = (const uint16_t *)data;
while (len > 1)
{
sum += *ip1++;
if (sum & 0x80000000)
{
sum = (sum & 0xFFFF) + (sum >> 16);
}
sum += *ptr++;
len -= 2;
}
while (sum >> 16)
if (len == 1)
{
sum = (sum & 0xFFFF) + (sum >> 16);
sum += *(uint8_t *)ptr;
}
return (~sum);
sum = (sum >> 16) + (sum & 0xFFFF);
sum += (sum >> 16);
return (uint16_t)~sum;
}
uint16_t checksum_v4(const void *l4_hdr_ptr, uint16_t l4_total_len, uint8_t l4_proto, struct in_addr *src_addr, struct in_addr *dst_addr)

2
src/packet/checksum.h
View File

@@ -7,7 +7,7 @@ extern "C"
#include <stdint.h>
uint16_t checksum(const char *data, uint16_t len);
uint16_t checksum(const void *data, int len);
uint16_t checksum_v4(const void *l4_hdr_ptr, uint16_t l4_total_len, uint8_t l4_proto, struct in_addr *src_addr, struct in_addr *dst_addr);
uint16_t checksum_v6(const void *l4_hdr_ptr, uint16_t l4_total_len, uint8_t l4_proto, struct in6_addr *src_addr, struct in6_addr *dst_addr);

2
src/packet/gre0_utils.h
View File

@@ -398,7 +398,7 @@ static inline int gre0_hdr_to_str(const struct gre0_hdr *hdr, char *buf, size_t
gre0_hdr_get_seq_flag(hdr), gre0_hdr_get_strict_flag(hdr), gre0_hdr_get_version(hdr), eth_proto_to_str(proto));
if (gre0_hdr_get_checksum_flag(hdr))
{
used += snprintf(buf + used, size - used, ", checksum=%u, offset=%u", gre0_hdr_get_checksum(hdr), gre0_hdr_get_offset(hdr));
used += snprintf(buf + used, size - used, ", checksum=0x%x, offset=%u", gre0_hdr_get_checksum(hdr), gre0_hdr_get_offset(hdr));
}
if (gre0_hdr_get_key_flag(hdr))
{

155
src/packet/packet_build.cpp → src/packet/packet_craft.cpp
View File

@@ -7,14 +7,15 @@
#include "ip4_utils.h"
#include "ip6_utils.h"
#include "gtp_utils.h"
#include "gre_utils.h"
#include "packet_def.h"
#include "packet_utils.h"
#include "packet_layer.h"
#include "packet_parse.h"
#include "packet_build.h"
#include "packet_craft.h"
#define PACKET_BUILD_LOG_DEBUG(format, ...) LOG_DEBUG("packet build", format, ##__VA_ARGS__)
#define PACKET_BUILD_LOG_ERROR(format, ...) LOG_ERROR("packet build", format, ##__VA_ARGS__)
#define PACKET_CRAFT_LOG_DEBUG(format, ...) LOG_DEBUG("packet craft", format, ##__VA_ARGS__)
#define PACKET_CRAFT_LOG_ERROR(format, ...) LOG_ERROR("packet craft", format, ##__VA_ARGS__)
struct fingerprint
{
@@ -24,15 +25,30 @@ struct fingerprint
uint16_t tcp_win;
};
static uint8_t append_sender_fingerprint = 0;
/******************************************************************************
* Private API
******************************************************************************/
static inline void calc_packet_fingerprint(struct fingerprint *finger)
{
if (append_sender_fingerprint)
{
#define RANGE(rand, start, end) (start + rand % (end - start + 1)) // [start, end]
struct timespec time;
clock_gettime(CLOCK_MONOTONIC, &time);
uint64_t random = 0x013579ABCDEF ^ time.tv_nsec;
finger->ip_id = (uint16_t)(RANGE(random, 32767, 65535));
finger->ip_ttl = (uint8_t)(RANGE(random, 48, 120));
finger->tcp_win = (uint16_t)(RANGE(random, 1000, 1460));
struct timespec time;
clock_gettime(CLOCK_MONOTONIC, &time);
uint64_t random = 0x013579ABCDEF ^ time.tv_nsec;
finger->ip_id = (uint16_t)(RANGE(random, 32767, 65535));
finger->ip_ttl = (uint8_t)(RANGE(random, 48, 120));
finger->tcp_win = (uint16_t)(RANGE(random, 1000, 1460));
}
else
{
finger->ip_id = 0;
finger->ip_ttl = 0;
finger->tcp_win = 0;
}
}
static void update_tcp_hdr(struct tcphdr *tcp, uint32_t seq, uint32_t ack, uint16_t win, uint8_t flags, uint16_t opts_len)
@@ -41,7 +57,10 @@ static void update_tcp_hdr(struct tcphdr *tcp, uint32_t seq, uint32_t ack, uint1
tcp_hdr_set_ack(tcp, ack);
tcp_hdr_set_hdr_len(tcp, sizeof(struct tcphdr) + opts_len);
tcp_hdr_set_flags(tcp, flags);
tcp_hdr_set_window(tcp, win);
if (win)
{
tcp_hdr_set_window(tcp, win);
}
tcp_hdr_set_urg_ptr(tcp, 0);
tcp_hdr_set_checksum(tcp, 0);
}
@@ -58,10 +77,16 @@ static void update_ip4_hdr(struct ip *ip, uint16_t ipid, uint8_t ttl, int trim_l
int hdr_len = ip4_hdr_get_hdr_len(ip);
uint16_t total = ip4_hdr_get_total_len(ip);
ip4_hdr_set_total_len(ip, total - trim_len);
ip4_hdr_set_ipid(ip, ipid);
ip4_hdr_set_ttl(ip, ttl);
if (ipid)
{
ip4_hdr_set_ipid(ip, ipid);
}
if (ttl)
{
ip4_hdr_set_ttl(ip, ttl);
}
ip->ip_sum = 0;
ip->ip_sum = checksum((const char *)ip, hdr_len);
ip->ip_sum = checksum((const void *)ip, hdr_len);
}
static void update_ip6_hdr(struct ip6_hdr *ip6, int trim_len)
@@ -76,7 +101,7 @@ static void update_gtp1_hdr(struct gtp1_hdr *gtp, int trim_len)
gtp1_hdr_set_msg_len(gtp, msg_len - trim_len);
if (gtp1_hdr_get_seq_flag(gtp) && gtp1_hdr_get_seq(gtp))
{
PACKET_BUILD_LOG_ERROR("imiated packets may be dropped by intermediate devices, the GTPv1 layer requires a sequence number");
PACKET_CRAFT_LOG_ERROR("crafted packets may be dropped by intermediate devices, the GTPv1 layer requires a sequence number");
}
}
@@ -86,22 +111,32 @@ static void update_gtp2_hdr(struct gtp2_hdr *gtp, int trim_len)
gtp2_hdr_set_msg_len(gtp, msg_len - trim_len);
if (gtp2_hdr_get_seq(gtp))
{
PACKET_BUILD_LOG_ERROR("imiated packets may be dropped by intermediate devices, the GTPv2 layer requires a sequence number");
PACKET_CRAFT_LOG_ERROR("crafted packets may be dropped by intermediate devices, the GTPv2 layer requires a sequence number");
}
}
static void update_gre1_hdr(struct gre1_hdr *gre, int trim_len)
{
uint16_t payload_len = gre1_hdr_get_payload_length(gre);
gre1_hdr_set_payload_length(gre, payload_len - trim_len);
}
static void update_packet_hdr(const struct packet *origin_pkt,
char *new_pkt_data, uint16_t new_pkt_len, int trim_len,
uint32_t tcp_seq, uint32_t tcp_ack, uint8_t tcp_flags, uint16_t tcp_opts_len)
{
uint8_t gtp_version = 0;
uint8_t version = 0;
uint16_t sum = 0;
char *curr_hdr_ptr = NULL;
char *last_hdr_ptr = NULL;
struct tcphdr *tcp = NULL;
struct udphdr *udp = NULL;
struct ip *ip4 = NULL;
struct ip6_hdr *ip6 = NULL;
struct gtp1_hdr *gtp1 = NULL;
struct gtp2_hdr *gtp2 = NULL;
struct gre0_hdr *gre0 = NULL;
struct gre1_hdr *gre1 = NULL;
struct raw_layer *curr_layer = NULL;
struct raw_layer *last_layer = NULL;
struct fingerprint finger = {0};
@@ -110,7 +145,9 @@ static void update_packet_hdr(const struct packet *origin_pkt,
for (int i = count - 1; i >= 0; i--)
{
curr_layer = (struct raw_layer *)packet_get_raw_layer(origin_pkt, i);
last_layer = (struct raw_layer *)packet_get_raw_layer(origin_pkt, i + 1);
curr_hdr_ptr = new_pkt_data + curr_layer->hdr_offset;
last_hdr_ptr = last_layer ? new_pkt_data + last_layer->hdr_offset : NULL;
switch (curr_layer->proto)
{
case LAYER_PROTO_TCP:
@@ -123,50 +160,63 @@ static void update_packet_hdr(const struct packet *origin_pkt,
break;
case LAYER_PROTO_IPV4:
ip4 = (struct ip *)curr_hdr_ptr;
last_layer = (struct raw_layer *)packet_get_raw_layer(origin_pkt, i + 1);
if (last_layer->proto == LAYER_PROTO_TCP)
if (last_layer && last_layer->proto == LAYER_PROTO_TCP)
{
tcp = (struct tcphdr *)(new_pkt_data + last_layer->hdr_offset);
tcp = (struct tcphdr *)last_hdr_ptr;
tcp->th_sum = checksum_v4(tcp, new_pkt_len - last_layer->hdr_offset, IPPROTO_TCP, &ip4->ip_src, &ip4->ip_dst);
}
if (last_layer->proto == LAYER_PROTO_UDP)
if (last_layer && last_layer->proto == LAYER_PROTO_UDP)
{
udp = (struct udphdr *)(new_pkt_data + last_layer->hdr_offset);
udp = (struct udphdr *)last_hdr_ptr;
udp->uh_sum = checksum_v4(udp, new_pkt_len - last_layer->hdr_offset, IPPROTO_UDP, &ip4->ip_src, &ip4->ip_dst);
}
update_ip4_hdr(ip4, finger.ip_id, finger.ip_ttl, trim_len);
break;
case LAYER_PROTO_IPV6:
ip6 = (struct ip6_hdr *)curr_hdr_ptr;
last_layer = (struct raw_layer *)packet_get_raw_layer(origin_pkt, i + 1);
if (last_layer->proto == LAYER_PROTO_TCP)
if (last_layer && last_layer->proto == LAYER_PROTO_TCP)
{
tcp = (struct tcphdr *)(new_pkt_data + last_layer->hdr_offset);
tcp = (struct tcphdr *)last_hdr_ptr;
tcp->th_sum = checksum_v6(tcp, new_pkt_len - last_layer->hdr_offset, IPPROTO_TCP, &ip6->ip6_src, &ip6->ip6_dst);
}
if (last_layer->proto == LAYER_PROTO_UDP)
if (last_layer && last_layer->proto == LAYER_PROTO_UDP)
{
udp = (struct udphdr *)(new_pkt_data + last_layer->hdr_offset);
udp = (struct udphdr *)last_hdr_ptr;
udp->uh_sum = checksum_v6(udp, new_pkt_len - last_layer->hdr_offset, IPPROTO_UDP, &ip6->ip6_src, &ip6->ip6_dst);
}
update_ip6_hdr(ip6, trim_len);
break;
case LAYER_PROTO_GTP_C: /* fall through */
case LAYER_PROTO_GTP_U:
gtp_version = peek_gtp_version(new_pkt_data + curr_layer->hdr_offset, curr_layer->hdr_len);
if (gtp_version == 1)
version = peek_gtp_version(curr_hdr_ptr, curr_layer->hdr_len);
if (version == 1)
{
gtp1 = (struct gtp1_hdr *)curr_hdr_ptr;
update_gtp1_hdr(gtp1, trim_len);
}
if (gtp_version == 2)
if (version == 2)
{
gtp2 = (struct gtp2_hdr *)curr_hdr_ptr;
update_gtp2_hdr(gtp2, trim_len);
}
break;
case LAYER_PROTO_GRE:
// TODO
version = peek_gre_version(curr_hdr_ptr, curr_layer->hdr_len);
if (version == 0)
{
gre0 = (struct gre0_hdr *)curr_hdr_ptr;
if (gre0_hdr_get_checksum_flag(gre0))
{
gre0_hdr_set_checksum(gre0, ntohs(0));
sum = checksum((const void *)curr_hdr_ptr, new_pkt_len - curr_layer->hdr_offset);
gre0_hdr_set_checksum(gre0, ntohs(sum));
}
}
if (version == 1)
{
gre1 = (struct gre1_hdr *)curr_hdr_ptr;
update_gre1_hdr(gre1, trim_len);
}
break;
default:
break;
@@ -174,14 +224,23 @@ static void update_packet_hdr(const struct packet *origin_pkt,
}
}
/******************************************************************************
* Public API
******************************************************************************/
void append_sender_fingerprint_to_crafted_packet()
{
append_sender_fingerprint = 1;
}
/*
* tcp_seq: the sequence number of the new TCP packet (in host byte order)
* tcp_ack: the acknowledgment number of the new TCP packet (in host byte order)
* tcp_options_len: the length of the options (must be a multiple of 4)
*/
struct packet *imitate_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_seq, uint32_t tcp_ack, uint8_t tcp_flags,
const char *tcp_options, uint16_t tcp_options_len,
const char *tcp_payload, uint16_t tcp_payload_len)
struct packet *craft_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_seq, uint32_t tcp_ack, uint8_t tcp_flags,
const char *tcp_options, uint16_t tcp_options_len,
const char *tcp_payload, uint16_t tcp_payload_len)
{
// check arguments
if (origin_pkt == NULL ||
@@ -189,7 +248,7 @@ struct packet *imitate_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_
(tcp_payload == NULL && tcp_payload_len != 0) || (tcp_payload != NULL && tcp_payload_len == 0) ||
(tcp_options_len && tcp_options_len % 4 != 0))
{
PACKET_BUILD_LOG_ERROR("imitate TCP packet failed, invalid arguments");
PACKET_CRAFT_LOG_ERROR("craft TCP packet failed, invalid arguments");
return NULL;
}
@@ -198,7 +257,7 @@ struct packet *imitate_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_
const struct raw_layer *tcp_layer = packet_get_raw_layer(origin_pkt, layers - 1);
if (tcp_layer == NULL || tcp_layer->proto != LAYER_PROTO_TCP)
{
PACKET_BUILD_LOG_ERROR("imitate TCP packet failed, the innermost layer of the original packet is not TCP");
PACKET_CRAFT_LOG_ERROR("craft TCP packet failed, the innermost layer of the original packet is not TCP");
return NULL;
}
@@ -208,7 +267,7 @@ struct packet *imitate_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_
struct packet *new_pkt = packet_new(new_pkt_len);
if (new_pkt == NULL)
{
PACKET_BUILD_LOG_ERROR("imitate TCP packet failed, no space to allocate new packet");
PACKET_CRAFT_LOG_ERROR("craft TCP packet failed, no space to allocate new packet");
return NULL;
}
@@ -231,12 +290,12 @@ struct packet *imitate_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_
return new_pkt;
}
struct packet *imitate_udp_packet(const struct packet *origin_pkt, const char *udp_payload, uint16_t udp_payload_len)
struct packet *craft_udp_packet(const struct packet *origin_pkt, const char *udp_payload, uint16_t udp_payload_len)
{
// check arguments
if (origin_pkt == NULL || (udp_payload == NULL && udp_payload_len != 0) || (udp_payload != NULL && udp_payload_len == 0))
{
PACKET_BUILD_LOG_ERROR("imitate UDP packet failed, invalid arguments");
PACKET_CRAFT_LOG_ERROR("craft UDP packet failed, invalid arguments");
return NULL;
}
@@ -245,7 +304,7 @@ struct packet *imitate_udp_packet(const struct packet *origin_pkt, const char *u
const struct raw_layer *udp_layer = packet_get_raw_layer(origin_pkt, layers - 1);
if (udp_layer == NULL || udp_layer->proto != LAYER_PROTO_UDP)
{
PACKET_BUILD_LOG_ERROR("imitate UDP packet failed, the innermost layer of the original packet is not UDP");
PACKET_CRAFT_LOG_ERROR("craft UDP packet failed, the innermost layer of the original packet is not UDP");
return NULL;
}
@@ -255,7 +314,7 @@ struct packet *imitate_udp_packet(const struct packet *origin_pkt, const char *u
struct packet *new_pkt = packet_new(new_pkt_len);
if (new_pkt == NULL)
{
PACKET_BUILD_LOG_ERROR("imitate UDP packet failed, no space to allocate new packet");
PACKET_CRAFT_LOG_ERROR("craft UDP packet failed, no space to allocate new packet");
return NULL;
}
@@ -279,7 +338,7 @@ struct packet *craft_packet_from_scratch(const struct layer layers[], uint16_t l
// check arguments
if (layers == NULL || layer_count == 0 || (payload == NULL && payload_len != 0) || (payload != NULL && payload_len == 0))
{
PACKET_BUILD_LOG_ERROR("craft packet from scratch failed, invalid arguments");
PACKET_CRAFT_LOG_ERROR("craft packet from scratch failed, invalid arguments");
return NULL;
}
@@ -289,7 +348,7 @@ struct packet *craft_packet_from_scratch(const struct layer layers[], uint16_t l
{
if (layers[i].hdr.raw == NULL || layers[i].hdr_len == 0)
{
PACKET_BUILD_LOG_ERROR("craft packet from scratch failed, the header of layer %d is invalid", i);
PACKET_CRAFT_LOG_ERROR("craft packet from scratch failed, the header of layer %d is invalid", i);
return NULL;
}
new_pkt_len += layers[i].hdr_len;
@@ -298,7 +357,7 @@ struct packet *craft_packet_from_scratch(const struct layer layers[], uint16_t l
struct packet *new_pkt = packet_new(new_pkt_len);
if (new_pkt == NULL)
{
PACKET_BUILD_LOG_ERROR("craft packet from scratch failed, no space to allocate new packet");
PACKET_CRAFT_LOG_ERROR("craft packet from scratch failed, no space to allocate new packet");
return NULL;
}
@@ -313,7 +372,7 @@ struct packet *craft_packet_from_scratch(const struct layer layers[], uint16_t l
memcpy(new_pkt_data + offset, payload, payload_len);
// update the headers of the new packet
uint8_t gtp_version = 0;
uint8_t version = 0;
uint16_t curr_hdr_len = 0;
char *curr_hdr_ptr = NULL;
struct tcphdr *tcp = NULL;
@@ -361,7 +420,7 @@ struct packet *craft_packet_from_scratch(const struct layer layers[], uint16_t l
ip4_hdr_set_hdr_len(ip4, curr_hdr_len);
ip4_hdr_set_total_len(ip4, curr_hdr_len + curr_payload_len);
ip4->ip_sum = 0;
ip4->ip_sum = checksum((const char *)ip4, curr_hdr_len);
ip4->ip_sum = checksum((const void *)ip4, curr_hdr_len);
curr_payload_len += curr_hdr_len;
break;
case LAYER_PROTO_IPV6:
@@ -383,14 +442,14 @@ struct packet *craft_packet_from_scratch(const struct layer layers[], uint16_t l
break;
case LAYER_PROTO_GTP_C: /* fall through */
case LAYER_PROTO_GTP_U:
gtp_version = peek_gtp_version(curr_hdr_ptr, curr_hdr_len);
if (gtp_version == 1)
version = peek_gtp_version(curr_hdr_ptr, curr_hdr_len);
if (version == 1)
{
gtp1 = (struct gtp1_hdr *)curr_hdr_ptr;
// update the GTP header
gtp1_hdr_set_msg_len(gtp1, curr_hdr_len + curr_payload_len - sizeof(struct gtp1_hdr));
}
if (gtp_version == 2)
if (version == 2)
{
gtp2 = (struct gtp2_hdr *)curr_hdr_ptr;
// update the GTP header

10
src/packet/packet_build.h → src/packet/packet_craft.h
View File

@@ -7,15 +7,17 @@ extern "C"
#include <stdint.h>
void append_sender_fingerprint_to_crafted_packet();
/*
* tcp_seq: the sequence number of the new TCP packet (in host byte order)
* tcp_ack: the acknowledgment number of the new TCP packet (in host byte order)
* tcp_options_len: the length of the options (must be a multiple of 4)
*/
struct packet *imitate_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_seq, uint32_t tcp_ack, uint8_t tcp_flags,
const char *tcp_options, uint16_t tcp_options_len,
const char *tcp_payload, uint16_t tcp_payload_len);
struct packet *imitate_udp_packet(const struct packet *origin_pkt, const char *udp_payload, uint16_t udp_payload_len);
struct packet *craft_tcp_packet(const struct packet *origin_pkt, uint32_t tcp_seq, uint32_t tcp_ack, uint8_t tcp_flags,
const char *tcp_options, uint16_t tcp_options_len,
const char *tcp_payload, uint16_t tcp_payload_len);
struct packet *craft_udp_packet(const struct packet *origin_pkt, const char *udp_payload, uint16_t udp_payload_len);
struct packet *craft_packet_from_scratch(const struct layer larers[], uint16_t layer_count, const char *payload, uint16_t payload_len);
#ifdef __cplusplus

4
src/packet/packet_parse.cpp
View File

@@ -157,7 +157,7 @@ static inline struct raw_layer *get_free_layer(struct packet *pkt)
(_layer)->pld_len = (_len) - (_hdr_len) - (_trim); \
(_pkt)->trim_len += (_trim); \
(_pkt)->layers_used++; \
PACKET_PARSE_LOG_DEBUG("layer[%d/%d]: %s, hdr_offset: %d, hdr_ptr: %p, hdr_len: %d, pld_ptr: %p, pld_len: %d", \
PACKET_PARSE_LOG_DEBUG("layer[%d/%d]: %s, header: {offset: %d, ptr: %p, len: %d}, payload: {ptr: %p, len: %d}", \
(_pkt)->layers_used - 1, (_pkt)->layers_size, layer_proto_to_str((_proto)), \
(_layer)->hdr_offset, (_layer)->hdr_ptr, (_layer)->hdr_len, (_layer)->pld_ptr, (_layer)->pld_len); \
}
@@ -1001,7 +1001,7 @@ void packet_print(const struct packet *pkt)
{
int used = 0;
const struct raw_layer *layer = &pkt->layers[i];
printf(" layer[%u]: %p, proto: %s, hdr_offset: %u, hdr_ptr: %p, hdr_len: %u, pld_ptr: %p, pld_len: %u\n",
printf(" layer[%u]: %p, proto: %s, header: {offset: %u, ptr: %p, len: %u}, payload: {ptr: %p, len: %u}\n",
i, layer, layer_proto_to_str(layer->proto), layer->hdr_offset,
layer->hdr_ptr, layer->hdr_len, layer->pld_ptr, layer->pld_len);
switch (layer->proto)

6
src/packet/test/CMakeLists.txt
View File

@@ -46,8 +46,8 @@ target_link_libraries(gtest_packet_frag packet gtest)
add_executable(gtest_packet_parse gtest_packet_parse.cpp)
target_link_libraries(gtest_packet_parse packet gtest)
add_executable(gtest_packet_build gtest_packet_build.cpp)
target_link_libraries(gtest_packet_build packet gtest)
add_executable(gtest_packet_craft gtest_packet_craft.cpp)
target_link_libraries(gtest_packet_craft packet gtest)
add_executable(gtest_packet_ldbc gtest_packet_ldbc.cpp)
target_link_libraries(gtest_packet_ldbc packet gtest)
@@ -69,5 +69,5 @@ gtest_discover_tests(gtest_gtp1_utils)
gtest_discover_tests(gtest_gtp2_utils)
gtest_discover_tests(gtest_packet_frag)
gtest_discover_tests(gtest_packet_parse)
gtest_discover_tests(gtest_packet_build)
gtest_discover_tests(gtest_packet_craft)
gtest_discover_tests(gtest_packet_ldbc)

286
src/packet/test/gtest_packet_build.cpp → src/packet/test/gtest_packet_craft.cpp
View File

@@ -6,11 +6,12 @@
#include "ip4_utils.h"
#include "ip6_utils.h"
#include "gtp_utils.h"
#include "gre_utils.h"
#include "packet_def.h"
#include "packet_dump.h"
#include "packet_layer.h"
#include "packet_parse.h"
#include "packet_build.h"
#include "packet_craft.h"
#define PRINT_GREEN(fmt, ...) printf("\033[0;32m" fmt "\033[0m\n", ##__VA_ARGS__)
#define PRINT_RED(fmt, ...) printf("\033[0;31m" fmt "\033[0m\n", ##__VA_ARGS__)
@@ -120,13 +121,13 @@ unsigned char data1[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
/*
* imitate_tcp_packet()
* craft_tcp_packet()
* -> ETH->IPv4->TCP
* -> with TCP options
* -> with TCP payload
*/
#if 1
TEST(PACKET_BUILD_TCP, ETH_IP4_TCP)
TEST(PACKET_CRAFT_TCP, ETH_IP4_TCP)
{
struct packet orig_pkt;
memset(&orig_pkt, 0, sizeof(orig_pkt));
@@ -134,13 +135,13 @@ TEST(PACKET_BUILD_TCP, ETH_IP4_TCP)
PRINT_GREEN("origin packet:");
packet_print(&orig_pkt);
struct packet *new_pkt = imitate_tcp_packet(&orig_pkt, 1, 2, TH_ACK, (const char *)&ts_pad_opt, sizeof(ts_pad_opt), "Hello", 5);
struct packet *new_pkt = craft_tcp_packet(&orig_pkt, 1, 2, TH_ACK, (const char *)&ts_pad_opt, sizeof(ts_pad_opt), "Hello", 5);
EXPECT_TRUE(new_pkt != nullptr);
PRINT_GREEN("new packet:");
packet_print(new_pkt);
packet_dump_hex(new_pkt, STDOUT_FILENO);
packet_dump_pcap(new_pkt, "imitate-eth-ipv4-tcp.pcap");
packet_dump_pcap(new_pkt, "craft-eth-ipv4-tcp.pcap");
const char *orig_pkt_data = packet_get_raw_data(&orig_pkt);
uint16_t orig_pkt_len = packet_get_raw_len(&orig_pkt);
@@ -155,25 +156,25 @@ TEST(PACKET_BUILD_TCP, ETH_IP4_TCP)
{
if (layer.proto == LAYER_PROTO_IPV4)
{
const struct ip *ip = (struct ip *)layer.hdr.raw;
const struct ip *ip = (const struct ip *)layer.hdr.raw;
EXPECT_TRUE(ip4_hdr_get_total_len(ip) == 57);
EXPECT_TRUE(ip4_hdr_get_checksum(ip) == 0xb7e1);
break;
}
if (layer.proto == LAYER_PROTO_TCP)
{
const struct tcphdr *tcp = (struct tcphdr *)layer.hdr.raw;
const struct tcphdr *tcp = (const struct tcphdr *)layer.hdr.raw;
EXPECT_TRUE(tcp_hdr_get_seq(tcp) == 1);
EXPECT_TRUE(tcp_hdr_get_ack(tcp) == 2);
EXPECT_TRUE(tcp_hdr_get_flags(tcp) == TH_ACK);
EXPECT_TRUE(tcp_hdr_get_hdr_len(tcp) == 32);
EXPECT_TRUE(tcp_hdr_get_checksum(tcp) == 0xaf73);
break;
}
}
for (uint16_t i = 0; i < new_pkt_len - 12 - 5; i++)
{
if ((16 <= i && i <= 17) || // skip IPv4 total length
(18 <= i && i <= 19) || // skip IPv4 identification
i == 22 || // skip IPv4 TTL
(24 <= i && i <= 25)) // skip IPv4 checksum
{
continue;
@@ -182,7 +183,6 @@ TEST(PACKET_BUILD_TCP, ETH_IP4_TCP)
(42 <= i && i <= 45) || // skip TCP ack
i == 46 || // skip TCP data offset
i == 47 || // skip TCP flags
(48 <= i && i <= 49) || // skip TCP window
(50 <= i && i <= 51)) // skip TCP checksum
{
continue;
@@ -257,12 +257,12 @@ unsigned char data2[] = {
0x04, 0x02};
/*
* imitate_tcp_packet()
* craft_tcp_packet()
* -> ETH->IPv4->IPv6->TCP
* -> with TCP payload
*/
#if 1
TEST(PACKET_BUILD_TCP, ETH_IP4_IP6_TCP)
TEST(PACKET_CRAFT_TCP, ETH_IP4_IP6_TCP)
{
struct packet orig_pkt;
memset(&orig_pkt, 0, sizeof(orig_pkt));
@@ -270,13 +270,13 @@ TEST(PACKET_BUILD_TCP, ETH_IP4_IP6_TCP)
PRINT_GREEN("origin packet:");
packet_print(&orig_pkt);
struct packet *new_pkt = imitate_tcp_packet(&orig_pkt, 1234, 2345, TH_ACK, NULL, 0, "Hello", 5);
struct packet *new_pkt = craft_tcp_packet(&orig_pkt, 1234, 2345, TH_ACK, NULL, 0, "Hello", 5);
EXPECT_TRUE(new_pkt != nullptr);
PRINT_GREEN("new packet:");
packet_print(new_pkt);
packet_dump_hex(new_pkt, STDOUT_FILENO);
packet_dump_pcap(new_pkt, "imitate-eth-ipv4-ipv6-tcp.pcap");
packet_dump_pcap(new_pkt, "craft-eth-ipv4-ipv6-tcp.pcap");
const char *orig_pkt_data = packet_get_raw_data(&orig_pkt);
uint16_t orig_pkt_len = packet_get_raw_len(&orig_pkt);
@@ -291,37 +291,36 @@ TEST(PACKET_BUILD_TCP, ETH_IP4_IP6_TCP)
{
if (layer.proto == LAYER_PROTO_IPV4)
{
const struct ip *ip = (struct ip *)layer.hdr.raw;
const struct ip *ip = (const struct ip *)layer.hdr.raw;
EXPECT_TRUE(ip4_hdr_get_total_len(ip) == 85);
EXPECT_TRUE(ip4_hdr_get_checksum(ip) == 0x09cf);
break;
}
if (layer.proto == LAYER_PROTO_IPV6)
{
const struct ip6_hdr *ip6 = (struct ip6_hdr *)layer.hdr.raw;
const struct ip6_hdr *ip6 = (const struct ip6_hdr *)layer.hdr.raw;
EXPECT_TRUE(ip6_hdr_get_payload_len(ip6) == 25);
break;
}
if (layer.proto == LAYER_PROTO_TCP)
{
const struct tcphdr *tcp = (struct tcphdr *)layer.hdr.raw;
const struct tcphdr *tcp = (const struct tcphdr *)layer.hdr.raw;
EXPECT_TRUE(tcp_hdr_get_seq(tcp) == 1234);
EXPECT_TRUE(tcp_hdr_get_ack(tcp) == 2345);
EXPECT_TRUE(tcp_hdr_get_flags(tcp) == TH_ACK);
EXPECT_TRUE(tcp_hdr_get_hdr_len(tcp) == 20);
EXPECT_TRUE(tcp_hdr_get_checksum(tcp) == 0xe350);
break;
}
}
for (uint16_t i = 0; i < new_pkt_len - 5; i++)
{
if ((16 <= i && i <= 17) || // skip IPv4 total length
(18 <= i && i <= 19) || // skip IPv4 identification
i == 22 || // skip IPv4 TTL
(24 <= i && i <= 25)) // skip IPv4 checksum
{
continue;
}
if ((38 <= i && i <= 39) || // skip IPv6 payload length
i == 41) // skip IPv6 hop limit
if (38 <= i && i <= 39) // skip IPv6 payload length
{
continue;
}
@@ -329,7 +328,6 @@ TEST(PACKET_BUILD_TCP, ETH_IP4_IP6_TCP)
(82 <= i && i <= 85) || // skip TCP ack
i == 86 || // skip TCP data offset
i == 87 || // skip TCP flags
(88 <= i && i <= 89) || // skip TCP window
(90 <= i && i <= 91)) // skip TCP checksum
{
continue;
@@ -473,12 +471,12 @@ unsigned char data3[] = {
0x4f, 0xe9, 0xf5, 0xf0, 0x61, 0x5d, 0x7f, 0xc4, 0xc4, 0xd1, 0x05, 0x54, 0x13, 0xdb};
/*
* imitate_tcp_packet()
* craft_tcp_packet()
* -> ETH->IPv6->UDP->GTP->IPv4->TCP
* -> with TCP payload
*/
#if 1
TEST(PACKET_BUILD_TCP, ETH_IP6_UDP_GTP_IP4_TCP)
TEST(PACKET_CRAFT_TCP, ETH_IP6_UDP_GTP_IP4_TCP)
{
struct packet orig_pkt;
memset(&orig_pkt, 0, sizeof(orig_pkt));
@@ -486,13 +484,13 @@ TEST(PACKET_BUILD_TCP, ETH_IP6_UDP_GTP_IP4_TCP)
PRINT_GREEN("origin packet:");
packet_print(&orig_pkt);
struct packet *new_pkt = imitate_tcp_packet(&orig_pkt, 1, 2, TH_ACK, NULL, 0, "Hello", 5);
struct packet *new_pkt = craft_tcp_packet(&orig_pkt, 1, 2, TH_ACK, NULL, 0, "Hello", 5);
EXPECT_TRUE(new_pkt != nullptr);
PRINT_GREEN("new packet:");
packet_print(new_pkt);
packet_dump_hex(new_pkt, STDOUT_FILENO);
packet_dump_pcap(new_pkt, "imitate-eth-ipv6-udp-gtp-ipv4-tcp.pcap");
packet_dump_pcap(new_pkt, "craft-eth-ipv6-udp-gtp-ipv4-tcp.pcap");
const char *orig_pkt_data = packet_get_raw_data(&orig_pkt);
uint16_t orig_pkt_len = packet_get_raw_len(&orig_pkt);
@@ -507,45 +505,46 @@ TEST(PACKET_BUILD_TCP, ETH_IP6_UDP_GTP_IP4_TCP)
{
if (layer.proto == LAYER_PROTO_IPV6)
{
const struct ip6_hdr *ip6 = (struct ip6_hdr *)layer.hdr.raw;
const struct ip6_hdr *ip6 = (const struct ip6_hdr *)layer.hdr.raw;
EXPECT_TRUE(ip6_hdr_get_payload_len(ip6) == 61);
break;
}
if (layer.proto == LAYER_PROTO_UDP)
{
const struct udphdr *udp = (struct udphdr *)layer.hdr.raw;
const struct udphdr *udp = (const struct udphdr *)layer.hdr.raw;
EXPECT_TRUE(udp_hdr_get_total_len(udp) == 61);
EXPECT_TRUE(udp_hdr_get_checksum(udp) == 0xd375);
break;
}
if (layer.proto == LAYER_PROTO_GTP_U)
{
EXPECT_TRUE(peek_gtp_version(layer.hdr.raw, layer.hdr_len) == 1);
const struct gtp1_hdr *gtp1 = (struct gtp1_hdr *)layer.hdr.raw;
const struct gtp1_hdr *gtp1 = (const struct gtp1_hdr *)layer.hdr.raw;
EXPECT_TRUE(gtp1_hdr_get_msg_len(gtp1) == 45);
break;
}
if (layer.proto == LAYER_PROTO_IPV4)
{
const struct ip *ip = (struct ip *)layer.hdr.raw;
const struct ip *ip = (const struct ip *)layer.hdr.raw;
EXPECT_TRUE(ip4_hdr_get_total_len(ip) == 45);
EXPECT_TRUE(ip4_hdr_get_checksum(ip) == 0x4906);
break;
}
if (layer.proto == LAYER_PROTO_TCP)
{
const struct tcphdr *tcp = (struct tcphdr *)layer.hdr.raw;
const struct tcphdr *tcp = (const struct tcphdr *)layer.hdr.raw;
EXPECT_TRUE(tcp_hdr_get_seq(tcp) == 1);
EXPECT_TRUE(tcp_hdr_get_ack(tcp) == 2);
EXPECT_TRUE(tcp_hdr_get_flags(tcp) == TH_ACK);
EXPECT_TRUE(tcp_hdr_get_hdr_len(tcp) == 20);
EXPECT_TRUE(tcp_hdr_get_checksum(tcp) == 0xcce5);
break;
}
}
for (uint16_t i = 0; i < new_pkt_len - 5; i++)
{
if ((18 <= i && i <= 19) || // skip IPv6 payload length
i == 20) // skip IPv6 hop limit
if (18 <= i && i <= 19) // skip IPv6 payload length
{
continue;
}
@@ -559,18 +558,221 @@ TEST(PACKET_BUILD_TCP, ETH_IP6_UDP_GTP_IP4_TCP)
continue;
}
if ((72 <= i && i <= 73) || // skip IPv4 total length
(74 <= i && i <= 75) || // skip IPv4 identification
i == 78 || // skip IPv4 TTL
(80 <= i && i <= 81)) // skip IPv4 checksum
{
continue;
}
if ((94 <= i && i <= 98) || // skip TCP seq
(99 <= i && i <= 103) || // skip TCP ack
i == 104 || // skip TCP data offset
i == 105 || // skip TCP flags
(106 <= i && i <= 107) || // skip TCP window
(108 <= i && i <= 109)) // skip TCP checksum
if ((94 <= i && i <= 98) || // skip TCP seq
(99 <= i && i <= 103) || // skip TCP ack
i == 104 || // skip TCP data offset
i == 105 || // skip TCP flags
(106 <= i && i <= 107)) // skip TCP checksum
{
continue;
}
// printf(("idx: %d, orig: %02x, new: %02x\n"), i, orig_pkt_data[i], new_pkt_data[i]);
EXPECT_TRUE(orig_pkt_data[i] == new_pkt_data[i]);
}
}
#endif
/******************************************************************************
* [Protocols in frame: eth:ethertype:ip:gre:ipv6:tcp]
******************************************************************************
*
* Frame 1: 102 bytes on wire (816 bits), 102 bytes captured (816 bits)
* Ethernet II, Src: a0:b1:c2:d3:e4:f5 (a0:b1:c2:d3:e4:f5), Dst: CIMSYS_33:44:55 (00:11:22:33:44:55)
* Destination: CIMSYS_33:44:55 (00:11:22:33:44:55)
* Address: CIMSYS_33:44:55 (00:11:22:33:44:55)
* .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Source: a0:b1:c2:d3:e4:f5 (a0:b1:c2:d3:e4:f5)
* Address: a0:b1:c2:d3:e4:f5 (a0:b1:c2:d3:e4:f5)
* .... ..0. .... .... .... .... = LG bit: Globally unique address (factory default)
* .... ...0 .... .... .... .... = IG bit: Individual address (unicast)
* Type: IPv4 (0x0800)
* Internet Protocol Version 4, Src: 10.0.0.1, Dst: 192.168.1.1
* 0100 .... = Version: 4
* .... 0101 = Header Length: 20 bytes (5)
* Differentiated Services Field: 0x00 (DSCP: CS0, ECN: Not-ECT)
* 0000 00.. = Differentiated Services Codepoint: Default (0)
* .... ..00 = Explicit Congestion Notification: Not ECN-Capable Transport (0)
* Total Length: 88
* Identification: 0x0001 (1)
* 000. .... = Flags: 0x0
* 0... .... = Reserved bit: Not set
* .0.. .... = Don't fragment: Not set
* ..0. .... = More fragments: Not set
* ...0 0000 0000 0000 = Fragment Offset: 0
* Time to Live: 64
* Protocol: Generic Routing Encapsulation (47)
* Header Checksum: 0xaecc [correct]
* [Header checksum status: Good]
* [Calculated Checksum: 0xaecc]
* Source Address: 10.0.0.1
* Destination Address: 192.168.1.1
* Generic Routing Encapsulation (IPv6)
* Flags and Version: 0x8000
* 1... .... .... .... = Checksum Bit: Yes
* .0.. .... .... .... = Routing Bit: No
* ..0. .... .... .... = Key Bit: No
* ...0 .... .... .... = Sequence Number Bit: No
* .... 0... .... .... = Strict Source Route Bit: No
* .... .000 .... .... = Recursion control: 0
* .... .... 0000 0... = Flags (Reserved): 0
* .... .... .... .000 = Version: GRE (0)
* Protocol Type: IPv6 (0x86dd)
* Checksum: 0x92e7 [correct]
* [Checksum Status: Good]
* Offset: 0
* Internet Protocol Version 6, Src: ::, Dst: 2001:db8::1
* 0110 .... = Version: 6
* .... 0000 0000 .... .... .... .... .... = Traffic Class: 0x00 (DSCP: CS0, ECN: Not-ECT)
* .... 0000 00.. .... .... .... .... .... = Differentiated Services Codepoint: Default (0)
* .... .... ..00 .... .... .... .... .... = Explicit Congestion Notification: Not ECN-Capable Transport (0)
* .... 0000 0000 0000 0000 0000 = Flow Label: 0x00000
* Payload Length: 20
* Next Header: TCP (6)
* Hop Limit: 64
* Source Address: ::
* Destination Address: 2001:db8::1
* Transmission Control Protocol, Src Port: 12345, Dst Port: 80, Seq: 0, Len: 0
* Source Port: 12345
* Destination Port: 80
* [Stream index: 0]
* [Conversation completeness: Incomplete, SYN_SENT (1)]
* ..0. .... = RST: Absent
* ...0 .... = FIN: Absent
* .... 0... = Data: Absent
* .... .0.. = ACK: Absent
* .... ..0. = SYN-ACK: Absent
* .... ...1 = SYN: Present
* [Completeness Flags: ·····S]
* [TCP Segment Len: 0]
* Sequence Number: 0
* [Next Sequence Number: 1]
* Acknowledgment Number: 0
* Acknowledgment number (raw): 0
* 0101 .... = Header Length: 20 bytes (5)
* Flags: 0x002 (SYN)
* 000. .... .... = Reserved: Not set
* ...0 .... .... = Accurate ECN: Not set
* .... 0... .... = Congestion Window Reduced: Not set
* .... .0.. .... = ECN-Echo: Not set
* .... ..0. .... = Urgent: Not set
* .... ...0 .... = Acknowledgment: Not set
* .... .... 0... = Push: Not set
* .... .... .0.. = Reset: Not set
* .... .... ..1. = Syn: Set
* [Expert Info (Chat/Sequence): Connection establish request (SYN): server port 80]
* [Connection establish request (SYN): server port 80]
* [Severity level: Chat]
* [Group: Sequence]
* .... .... ...0 = Fin: Not set
* [TCP Flags: ··········S·]
* Window: 8192
* [Calculated window size: 8192]
* Checksum: 0x31a0 [correct]
* [Calculated Checksum: 0x31a0]
* [Checksum Status: Good]
* Urgent Pointer: 0
* [Timestamps]
* [Time since first frame in this TCP stream: 0.000000000 seconds]
* [Time since previous frame in this TCP stream: 0.000000000 seconds]
*/
unsigned char data4[] = {
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0xa0, 0xb1, 0xc2, 0xd3, 0xe4, 0xf5, 0x08, 0x00, 0x45, 0x00, 0x00, 0x58, 0x00, 0x01, 0x00, 0x00, 0x40, 0x2f, 0xae, 0xcc,
0x0a, 0x00, 0x00, 0x01, 0xc0, 0xa8, 0x01, 0x01, 0x80, 0x00, 0x86, 0xdd, 0x92, 0xe7, 0x00, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x14, 0x06, 0x40, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x30, 0x39, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02, 0x20, 0x00, 0x31, 0xa0, 0x00, 0x00};
/*
* craft_tcp_packet()
* -> ETH->IPv4->GRE->IPv6->TCP
* -> with TCP payload
* -> with GRE checksum
*/
#if 1
TEST(PACKET_CRAFT_TCP, ETH_IP4_GRE_IP6_TCP)
{
struct packet orig_pkt;
memset(&orig_pkt, 0, sizeof(orig_pkt));
packet_parse(&orig_pkt, (const char *)data4, sizeof(data4));
PRINT_GREEN("origin packet:");
packet_print(&orig_pkt);
struct packet *new_pkt = craft_tcp_packet(&orig_pkt, 1, 2, TH_ACK, NULL, 0, "Hello", 5);
EXPECT_TRUE(new_pkt != nullptr);
PRINT_GREEN("new packet:");
packet_print(new_pkt);
packet_dump_hex(new_pkt, STDOUT_FILENO);
packet_dump_pcap(new_pkt, "craft-eth-ipv4-gre-ipv6-tcp.pcap");
const char *orig_pkt_data = packet_get_raw_data(&orig_pkt);
uint16_t orig_pkt_len = packet_get_raw_len(&orig_pkt);
const char *new_pkt_data = packet_get_raw_data(new_pkt);
uint16_t new_pkt_len = packet_get_raw_len(new_pkt);
EXPECT_TRUE(orig_pkt_len ==
new_pkt_len - 5); // trim TCP payload
struct layer layer;
PACKET_FOREACH_LAYER_INORDER(new_pkt, layer)
{
if (layer.proto == LAYER_PROTO_IPV4)
{
const struct ip *ip = (const struct ip *)layer.hdr.raw;
EXPECT_TRUE(ip4_hdr_get_total_len(ip) == 93);
EXPECT_TRUE(ip4_hdr_get_checksum(ip) == 0xaec7);
break;
}
if (layer.proto == LAYER_PROTO_GRE)
{
const struct gre0_hdr *gre = (const struct gre0_hdr *)layer.hdr.raw;
EXPECT_TRUE(gre0_hdr_get_version(gre) == 0);
EXPECT_TRUE(gre0_hdr_get_checksum(gre) == 0x92e7);
break;
}
if (layer.proto == LAYER_PROTO_IPV6)
{
const struct ip6_hdr *ip6 = (const struct ip6_hdr *)layer.hdr.raw;
EXPECT_TRUE(ip6_hdr_get_payload_len(ip6) == 25);
break;
}
if (layer.proto == LAYER_PROTO_TCP)
{
const struct tcphdr *tcp = (const struct tcphdr *)layer.hdr.raw;
EXPECT_TRUE(tcp_hdr_get_seq(tcp) == 1);
EXPECT_TRUE(tcp_hdr_get_ack(tcp) == 2);
EXPECT_TRUE(tcp_hdr_get_flags(tcp) == TH_ACK);
EXPECT_TRUE(tcp_hdr_get_hdr_len(tcp) == 20);
EXPECT_TRUE(tcp_hdr_get_checksum(tcp) == 0x0db8);
break;
}
}
for (uint16_t i = 0; i < new_pkt_len - 5; i++)
{
if ((16 <= i && i <= 17) || // skip IP total length
(24 <= i && i <= 25)) // skip IP checksum
{
continue;
}
if (38 <= i && i <= 39) // skip GRE checksum
{
continue;
}
if (47 <= i && i <= 48) // skip IPv6 payload length
{
continue;
}
if ((86 <= i && i <= 89) || // skip TCP seq
(90 <= i && i <= 93) || // skip TCP ack
i == 95 || // skip TCP flags
(98 <= i && i <= 99)) // skip TCP checksum
{
continue;
}

4
src/stellar/version.map
View File

@@ -14,8 +14,8 @@ global:
packet_get_raw_len;
packet_get_payload;
packet_get_payload_len;
imitate_tcp_packet;
imitate_udp_packet;
craft_tcp_packet;
craft_udp_packet;
craft_packet_from_scratch;
session_exdata_free;

60
test/packet_inject/packet_inject.cpp
View File

@@ -317,28 +317,28 @@ static inline uint32_t uint32_add(uint32_t seq, uint32_t inc)
return seq;
}
static void imitate_and_send_udp_packet(struct stellar *st, struct session *sess, struct packet_exdata *pkt_exdata,
enum flow_direction inject_dir, const char *udp_payload, uint16_t udp_payload_len)
static void craft_and_send_udp_packet(struct stellar *st, struct session *sess, struct packet_exdata *pkt_exdata,
enum flow_direction inject_dir, const char *udp_payload, uint16_t udp_payload_len)
{
const struct packet *origin_pkt = session_get_first_packet(sess, inject_dir);
if (origin_pkt == NULL)
{
LOG_ERR("imitate UDP packet failed, %s origin packet is NULL\n", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
LOG_ERR("craft UDP packet failed, %s origin packet is NULL\n", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
return;
}
struct packet *imitate_pkt = imitate_udp_packet(origin_pkt, udp_payload, udp_payload_len);
if (imitate_pkt == NULL)
struct packet *craft_pkt = craft_udp_packet(origin_pkt, udp_payload, udp_payload_len);
if (craft_pkt == NULL)
{
LOG_ERR("imitate UDP packet failed\n");
LOG_ERR("craft UDP packet failed\n");
return;
}
stellar_send_crafted_packet(st, imitate_pkt);
stellar_send_crafted_packet(st, craft_pkt);
}
static void imitate_and_send_tcp_packet(struct stellar *st, struct session *sess, struct packet_exdata *pkt_exdata,
enum flow_direction inject_dir, uint8_t tcp_flags, const char *tcp_payload, uint16_t tcp_payload_len)
static void craft_and_send_tcp_packet(struct stellar *st, struct session *sess, struct packet_exdata *pkt_exdata,
enum flow_direction inject_dir, uint8_t tcp_flags, const char *tcp_payload, uint16_t tcp_payload_len)
{
uint32_t tcp_seq = 0;
uint32_t tcp_ack = 0;
@@ -384,18 +384,18 @@ static void imitate_and_send_tcp_packet(struct stellar *st, struct session *sess
const struct packet *origin_pkt = session_get_first_packet(sess, inject_dir);
if (origin_pkt == NULL)
{
LOG_ERR("imitate TCP packet failed, %s origin packet is NULL\n", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
LOG_ERR("craft TCP packet failed, %s origin packet is NULL\n", inject_dir == FLOW_DIRECTION_C2S ? "C2S" : "S2C");
return;
}
struct packet *imitate_pkt = imitate_tcp_packet(origin_pkt, tcp_seq, tcp_ack, tcp_flags, NULL, 0, tcp_payload, tcp_payload_len);
if (imitate_pkt == NULL)
struct packet *craft_pkt = craft_tcp_packet(origin_pkt, tcp_seq, tcp_ack, tcp_flags, NULL, 0, tcp_payload, tcp_payload_len);
if (craft_pkt == NULL)
{
LOG_ERR("imitate TCP packet failed\n");
LOG_ERR("craft TCP packet failed\n");
return;
}
stellar_send_crafted_packet(st, imitate_pkt);
stellar_send_crafted_packet(st, craft_pkt);
}
/******************************************************************************
@@ -480,36 +480,36 @@ static void on_sess_msg(struct session *sess, int topic_id, const void *msg, voi
switch (config->type)
{
case INJECT_TCP_RST:
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0);
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0);
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0);
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0);
session_set_discard(sess);
break;
case INJECT_TCP_FIN:
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0);
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0);
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0);
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0);
session_set_discard(sess);
break;
case INJECT_TCP_PAYLOAD:
snprintf(buffer, sizeof(buffer), "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s", 5 + 5 + 2, "Hello");
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
session_set_discard(sess);
break;
case INJECT_TCP_PAYLOAD_FIN_RST:
snprintf(buffer, sizeof(buffer), "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s", 5 + 5 + 2, "Hello");
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0); // inject FIN to client
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0); // inject FIN to server
imitate_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, buffer, strlen(buffer)); // inject payload to client
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_ACK, "World\r\n", 7); // inject payload to client
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_FIN | TH_ACK, NULL, 0); // inject FIN to client
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, TH_RST | TH_ACK, NULL, 0); // inject RST to client
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_FIN | TH_ACK, NULL, 0); // inject FIN to server
craft_and_send_tcp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, TH_RST | TH_ACK, NULL, 0); // inject RST to server
session_set_discard(sess);
break;
case INJECT_UDP_PAYLOAD:
imitate_and_send_udp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, "Hello Server", 12);
imitate_and_send_udp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, "Hello Client", 12);
craft_and_send_udp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_C2S, "Hello Server", 12);
craft_and_send_udp_packet(st, sess, &pkt_exdata, FLOW_DIRECTION_S2C, "Hello Client", 12);
session_set_discard(sess);
break;
case INJECT_CTRL_MSG: