def test_modify_tcp_header_shortcut(self):
"""
Tests injection of a packet with a modified tcp header using shortcutted send
"""
fake_port = random_free_port()
fake_addr = "10.10.10.10"
srv_port = self.server.server_address[1]
srv_addr = self.server.server_address[0]
text = "Hello World!"
client = FakeTCPClient((fake_addr, fake_port), text.encode("UTF-8"))
client_thread = threading.Thread(target=client.send)
f = "tcp.DstPort == %d or tcp.SrcPort == %d" % (fake_port, srv_port)
with Handle(filter=f, priority=1000) as handle:
# Initialize the fake tcp client
client_thread.start()
while True:
packet = handle.receive()
if packet.meta.is_outbound():
if packet.dst_port == fake_port:
packet.dst_port = srv_port
packet.dst_addr = srv_addr
if packet.src_port == srv_port:
packet.src_port = fake_port
packet.src_addr = fake_addr
handle.send(packet)
if hasattr(client, "response") and client.response:
break
client_thread.join(timeout=10)
self.assertEqual(text.upper(), client.response.decode("UTF-8"))
def test_modify_tcp_payload(self):
"""
Tests injection of a TCP packet with modified payload
"""
text = "Hello world! ZZZZ"
new_text = "Hello World!"
# Initialize the fake tcp client
client = FakeTCPClient(self.server.server_address,
text.encode("UTF-8"),
ipv6=True)
client_thread = threading.Thread(target=client.send)
f = "outbound and tcp.DstPort == %s and tcp.PayloadLength > 0" % self.server.server_address[
1]
with Handle(filter=f) as handle:
client_thread.start()
raw_packet, metadata = handle.recv()
if metadata.is_outbound():
packet = handle.driver.parse_packet(raw_packet)
self.assertEqual(text.encode("UTF-8"), packet.payload)
packet.payload = new_text.encode("UTF-8")
raw_packet = packet.raw
handle.send((raw_packet, metadata))
client_thread.join(timeout=10)
self.assertEqual(new_text.upper(), client.response.decode("UTF-8"))
def test_modify_udp_header(self):
"""
Tests injection of a packet with a modified udp header
"""
fake_port = random_free_port()
srv_port = self.server.server_address[1]
text = "Hello World!"
client = FakeUDPClient(("127.0.0.1", fake_port), text.encode("UTF-8"))
client_thread = threading.Thread(target=client.send)
f = "udp.DstPort == %d or udp.SrcPort == %d" % (fake_port, srv_port)
with Handle(filter=f, priority=1000) as handle:
# Initialize the fake tcp client
client_thread.start()
for i in range(2):
packet = handle.receive()
if packet.meta.is_outbound():
if packet.dst_port == fake_port:
packet.dst_port = srv_port
if packet.src_port == srv_port:
packet.src_port = fake_port
handle.send(packet)
client_thread.join(timeout=10)
self.assertEqual(text.upper(), client.response.decode("UTF-8"))
def test_implicit_construct_handle(self):
"""
Tests constructing an handle without passing a WinDivert instance
"""
handle = Handle(filter="tcp.DstPort == 23", priority=1000)
self.assertIsInstance(handle, Handle)
self.assertFalse(handle.is_opened)
def test_modify_tcp_header(self):
"""
Tests injection of a packet with a modified tcp header
"""
fake_port = random_free_port()
srv_port = self.server.server_address[1]
text = "Hello World!"
client = FakeTCPClient(("127.0.0.1", fake_port), text.encode("UTF-8"))
client_thread = threading.Thread(target=client.send)
f = "tcp.DstPort == %d or tcp.SrcPort == %d" % (fake_port, srv_port)
with Handle(filter=f, priority=1000) as handle:
# Initialize the fake tcp client
client_thread.start()
while True:
raw_packet, meta = handle.recv()
packet = handle.driver.parse_packet(raw_packet)
if meta.is_outbound():
if packet.dst_port == fake_port:
packet.dst_port = srv_port
if packet.src_port == srv_port:
packet.src_port = fake_port
packet = handle.driver.update_packet_checksums(packet)
handle.send((packet.raw, meta))
if hasattr(client, "response") and client.response:
break
client_thread.join(timeout=10)
self.assertEqual(text.upper(), client.response.decode("UTF-8"))
def test_handle_invalid(self):
"""
Tests constructing an handle from a WinDivert instance
"""
handle = Handle(filter="tcp.DstPort == 23", priority=1000)
#The handle is not opened so we expect an error
self.assertRaises(WindowsError, handle.close)
def test_construct_handle(self):
"""
Tests constructing an handle from a WinDivert instance
"""
driver = WinDivert()
handle = Handle(driver, filter="tcp.DstPort == 23", priority=1000)
self.assertIsInstance(handle, Handle)
self.assertFalse(handle.is_opened)
def test_queue_len_range(self):
"""
Tests setting the minimum value for queue length.
From docs: 1< default 512 <8192
"""
with Handle(filter="tcp.DstPort == 23", priority=1000) as filter0:
#TODO: this range should have a proper default representation
for value in (1, 512, 8192):
filter0.set_param(Param.QUEUE_LEN, value)
self.assertEqual(value, filter0.get_param(Param.QUEUE_LEN))
def test_getter_and_setter(self):
"""
Tests getting and setting params to WinDivert
"""
queue_len = 2048
queue_time = 64
with Handle(filter="tcp.DstPort == 23", priority=1000) as filter0:
filter0.set_param(Param.QUEUE_LEN, queue_len)
self.assertEqual(queue_len, filter0.get_param(Param.QUEUE_LEN))
filter0.set_param(Param.QUEUE_TIME, queue_time)
self.assertEqual(queue_time, filter0.get_param(Param.QUEUE_TIME))
def test_queue_time_range(self):
"""
Tests setting the minimum value for queue time.
From docs: 128 < default 512 < 2048
"""
with Handle(filter="tcp.DstPort == 23", priority=1000) as filter0:
# TODO: this range should have a proper default representation
def_range = (128, 512, 2048)
for value in def_range:
filter0.set_param(Param.QUEUE_TIME, value)
assert value == filter0.get_param(Param.QUEUE_TIME)
def test_syn_tcp_options(self):
"""
Tests the right capturing of tcp options field
"""
text = "Hello World!"
client = FakeTCPClient(self.server.server_address, text.encode("UTF-8"), ipv6=True)
client_thread = threading.Thread(target=client.send)
with Handle(filter="tcp.DstPort == %d" % self.server.server_address[1]) as handle:
client_thread.start()
packet = handle.receive()
assert packet.tcp_hdr.Syn == 1
assert hexlify(packet.tcp_hdr.Options) == b"0204ffc30103030801010402"
def test_pass_through(self):
"""
Tests capture and reinjection of data
"""
srv_port = self.server.server_address[1]
text = "Hello World!"
client = FakeTCPClient(self.server.server_address, text.encode("UTF-8"), ipv6=True)
client_thread = threading.Thread(target=client.send)
with Handle(filter="tcp.DstPort == %d and tcp.PayloadLength > 0" % srv_port) as handle:
client_thread.start()
handle.send(handle.receive())
client_thread.join(timeout=10)
assert text.upper() == client.response.decode()
def test_syn_tcp_options(self):
"""
Tests the right capturing of tcp options field
"""
text = "Hello World!"
client = FakeTCPClient(self.server.server_address,
text.encode("UTF-8"))
client_thread = threading.Thread(target=client.send)
with Handle(filter="tcp.DstPort == %d" %
self.server.server_address[1]) as handle:
client_thread.start()
packet = handle.receive()
self.assertEqual(packet.tcp_hdr.Syn, 1)
self.assertEqual(hexlify(packet.tcp_hdr.Options),
b"0204ffd70103030801010402")
client_thread.join(timeout=10)
def test_modify_udp_payload(self):
"""
Tests injection of a UDP packet with modified payload
"""
text = "Hello World!"
client = FakeUDPClient(("127.0.0.1", self.server.server_address[1]), text.encode("UTF-8"))
client_thread = threading.Thread(target=client.send)
filter_ = "outbound and udp.DstPort == %s" % self.server.server_address[1]
with Handle(filter=filter_) as handle:
client_thread.start()
packet = handle.receive()
assert text.encode("UTF-8") == packet.payload
handle.send(packet)
client_thread.join(timeout=10)
assert text.upper() == client.response.decode()
def test_pass_through_mtu_size(self):
"""
Tests sending a packet bigger than mtu
"""
srv_port = self.server.server_address[1]
text = b"#" * (Defaults.PACKET_BUFFER_SIZE + 1)
client = FakeTCPClient(("127.0.0.1", srv_port), text)
client_thread = threading.Thread(target=client.send)
f = "tcp.DstPort == {0} or tcp.SrcPort == {0} and tcp.PayloadLength > 0".format(srv_port)
with Handle(filter=f, priority=1000) as handle:
# Initialize the fake tcp client
client_thread.start()
while True:
handle.send(handle.receive())
if hasattr(client, "response") and client.response:
break
client_thread.join(timeout=10)
assert text == client.response
def test_context_manager(self):
"""
Tests usage of an Handle as a context manager
"""
with Handle(filter="tcp.DstPort == 23", priority=1000) as filter0:
self.assertNotEqual(str(filter0._handle), "-1")
