def test_fallback():
"""
Tests fallback behavior.
"""
fragment = actions.fragment.FragmentAction(correct_order=False, fragsize=2, segment=False)
assert str(fragment) == "fragment{ip:2:False}", "Fragment returned incorrect string representation: %s" % str(fragment)
fragment.parse("fragment{ip:0:False}", logger)
packet = actions.packet.Packet(IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06)/UDP(sport=2222, dport=3333, chksum=0x4444)/("thisissomedata"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert str(packet1) == str(packet2)
fragment.parse("fragment{tcp:-1:False}", logger)
packet = actions.packet.Packet(IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06)/UDP(sport=2222, dport=3333, chksum=0x4444)/("thisissomedata"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert str(packet1) == str(packet2)
fragment.parse("fragment{tcp:-1:False}", logger)
packet = actions.packet.Packet(IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06)/TCP(sport=2222, dport=3333, chksum=0x4444))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert str(packet1) == str(packet2)
fragment.parse("fragment{ip:-1:False}", logger)
packet = actions.packet.Packet(IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert str(packet1) == str(packet2)
def test_reverse_fragment(logger):
"""
Tests fragmentation with reversed packets
"""
fragment = actions.fragment.FragmentAction(correct_order=False,
fragsize=3,
segment=False)
assert str(
fragment
) == "fragment{ip:3:False}", "Fragment returned incorrect string representation: %s" % str(
fragment)
packet = layers.packet.Packet(
IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06) /
TCP(sport=2222, dport=3333, seq=100, ack=100, flags="S") /
("thisissomedata"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert str(packet1["Raw"].load) != str(
packet2["Raw"].load), "Packets were not different"
assert packet2[
"Raw"].load == b'\x08\xae\r\x05\x00\x00\x00d\x00\x00\x00dP\x02 \x00zp\x00\x00this', "Left packet incorrectly fragmented"
assert packet1[
"Raw"].load == b'issomedata', "Right packet incorrectly fragmented"
assert packet2["Raw"].load + packet1[
"Raw"].load == b'\x08\xae\r\x05\x00\x00\x00d\x00\x00\x00dP\x02 \x00zp\x00\x00thisissomedata', "Packets fragmentation was incorrect"
def test_odd_fragment(logger):
"""
Tests long IP fragmentation
"""
fragment = actions.fragment.FragmentAction(correct_order=True,
segment=False)
assert str(
fragment
) == "fragment{ip:-1:True}", "Fragment returned incorrect string representation: %s" % str(
fragment)
packet = layers.packet.Packet(
IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06) /
TCP(sport=2222, dport=3333, seq=100, ack=100, flags="S") /
("dataisodd"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert str(packet1["Raw"].load) != str(
packet2["Raw"].load), "Packets were not different"
assert packet1[
"Raw"].load == b'\x08\xae\r\x05\x00\x00\x00d', "Left packet incorrectly fragmented"
assert packet2[
"Raw"].load == b'\x00\x00\x00dP\x02 \x00e\xc1\x00\x00dataisodd', "Right packet incorrectly fragmented"
assert packet1["Raw"].load + packet2[
"Raw"].load == b'\x08\xae\r\x05\x00\x00\x00d\x00\x00\x00dP\x02 \x00e\xc1\x00\x00dataisodd', "Packets fragmentation was incorrect"
def test_udp_fragment():
"""
Tests fragmentation with reversed packets
"""
fragment = actions.fragment.FragmentAction(correct_order=False, fragsize=2, segment=False)
assert str(fragment) == "fragment{ip:2:False}", "Fragment returned incorrect string representation: %s" % str(fragment)
packet = actions.packet.Packet(IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06)/UDP(sport=2222, dport=3333, chksum=0x4444)/("thisissomedata"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert str(packet1["Raw"].load) != str(packet2["Raw"].load), "Packets were not different"
def test_segment_reverse():
"""
Tests the duplicate action primitive in reverse!
"""
fragment = actions.fragment.FragmentAction(correct_order=False)
assert str(fragment) == "fragment{tcp:-1:False}", "Fragment returned incorrect string representation: %s" % str(fragment)
packet = actions.packet.Packet(IP(src="127.0.0.1", dst="127.0.0.1")/TCP()/("data"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert packet1["Raw"].load != packet2["Raw"].load, "Packets were not different"
assert packet1["Raw"].load == b'ta', "Left packet incorrectly fragmented"
assert packet2["Raw"].load == b"da", "Right packet incorrectly fragmented"
def test_ip_only_fragment():
"""
Tests fragmentation without higher protocols.
"""
fragment = actions.fragment.FragmentAction(correct_order=True)
fragment.parse("fragment{ip:-1:True}", logger)
packet = actions.packet.Packet(IP(src="127.0.0.1", dst="127.0.0.1")/("datadata11datadata"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert packet1["Raw"].load != packet2["Raw"].load, "Packets were not different"
assert packet1["Raw"].load == b'datadata', "Left packet incorrectly fragmented"
assert packet2["Raw"].load == b"11datadata", "Right packet incorrectly fragmented"
def test_mutate(logger):
"""
Tests mutating the fragment action
"""
fragment = actions.fragment.FragmentAction(correct_order=False,
fragsize=2,
segment=False)
assert str(
fragment
) == "fragment{ip:2:False}", "Fragment returned incorrect string representation: %s" % str(
fragment)
for _ in range(0, 200):
fragment.mutate()
fragment.parse(str(fragment), logger)
packet = layers.packet.Packet(
IP(src="127.0.0.1", dst="127.0.0.1", proto=0x06) /
TCP(sport=2222, dport=3333, chksum=0x4444) / ("thisissomedata"))
packet1, packet2 = fragment.run(packet, logger)
def test_segment_wrap3(logger):
"""
Tests if segment numbers can wrap around testing for off-by-one
"""
fragment = actions.fragment.FragmentAction(correct_order=True)
assert str(
fragment
) == "fragment{tcp:-1:True}", "Fragment returned incorrect string representation: %s" % str(
fragment)
packet = layers.packet.Packet(
IP(src="127.0.0.1", dst="127.0.0.1") / TCP() / ("data"))
packet["TCP"].seq = MAX_UINT - 2
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert packet1["Raw"].load != packet2[
"Raw"].load, "Packets were not different"
assert packet1["Raw"].load == b'da', "Left packet incorrectly fragmented"
assert packet2["Raw"].load == b"ta", "Right packet incorrectly fragmented"
assert packet1["TCP"].seq == MAX_UINT - 2
assert packet2["TCP"].seq == MAX_UINT
def test_overlapping_segment_out_of_bounds():
"""
Basic test for overlapping segments overlapping beyond the edge of the packet.
"""
fragment = actions.fragment.FragmentAction(correct_order=True)
fragment.parse("fragment{tcp:-1:True:20}", logger)
packet = layers.packet.Packet(
IP(src="127.0.0.1", dst="127.0.0.1") / TCP(seq=100) /
("datadata11datadata"))
packet1, packet2 = fragment.run(packet, logger)
assert id(packet1) != id(packet2), "Duplicate aliased packet objects"
assert packet1["Raw"].load != packet2[
"Raw"].load, "Packets were not different"
assert packet1[
"Raw"].load == b'datadata11datadata', "Left packet incorrectly segmented"
assert packet2[
"Raw"].load == b"1datadata", "Right packet incorrectly fragmented"
assert packet1["TCP"].seq == 100, "First packet sequence number incorrect"
assert packet2["TCP"].seq == 109, "Second packet sequence number incorrect"
