def scan(ip):
arp_request = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="FF:FF:FF:FF:FF:FF")
arp_request_broadcast = broadcast/arp_request
answered, unanswered = scapy.srp(arp_request_broadcast, timeout=1)
def fetch_mac(ip):
arpb = scapy.Ether(dst="ff:ff:ff:ff:ff:ff") / scapy.ARP(
op=1, pdst=ip) #op=1 is who-has
received = scapy.srp(arpb, timeout=2, verbose=False)
return received[0][0][1].hwsrc
def traffic_sender(linkid, vlanid):
payload = s.Ether() / s.Dot1Q(vlan=int(vlanid)) / s.IP() / s.ICMP()
s.sendp(payload, iface=linkid, count=number_of_packets)
def main():
parser = argparse.ArgumentParser(
"frag6.py", description="IPv6 fragementation test tool")
parser.add_argument(
'--sendif',
nargs=1,
required=True,
help='The interface through which the packet will be sent')
parser.add_argument('--recvif',
nargs=1,
required=True,
help='The interface on which to check for the packet')
parser.add_argument('--src',
nargs=1,
required=True,
help='The source IP address')
parser.add_argument('--to',
nargs=1,
required=True,
help='The destination IP address')
parser.add_argument('--debug',
required=False,
action='store_true',
help='Enable test debugging')
args = parser.parse_args()
# Start sniffing on recvif
sniffer = Sniffer(args, check_icmp6_error)
sniffer2 = Sniffer(args, check_icmp6_error_2)
########################################################################
#
# Two fragments with payload and offset set to add up to >64k.
#
# Make a first fragment arrive and a second to explode everything.
#
# A: Reassembly failure.
# R: ICMPv6 param prob, param header.
# R: ICMPv6 timeout (1st frag, off=0)
#
data = "6" * 1280
ip6f01 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrFragment(offset=0, m=1, id=7) / \
sp.UDP(dport=3456, sport=6543) / \
data
ip6f02 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrFragment(offset=0x1fff, m=1, id=7) / \
sp.UDP(dport=3456, sport=6543) / \
data
if args.debug:
ip6f01.display()
ip6f02.display()
sp.sendp(ip6f01, iface=args.sendif[0], verbose=False)
sp.sendp(ip6f02, iface=args.sendif[0], verbose=False)
sleep(1.00)
sniffer.setEnd()
sniffer.join()
if not sniffer.foundCorrectPacket:
sys.exit(1)
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ##
#
# A fragment with payload and offset set to add up to >64k.
#
# Try again with the first packet to make things explode.
#
# A: Reassembly failure.
# R: ICMPv6 param prob, param header.
#
# Start sniffing on recvif
sniffer = Sniffer(args, check_icmp6_error)
ip6f01 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrFragment(offset=0x1fff, m=1, id=0x7001) / \
sp.UDP(dport=3456, sport=6543) / \
data
if args.debug:
ip6f01.display()
sp.sendp(ip6f01, iface=args.sendif[0], verbose=False)
sleep(0.10)
sniffer.setEnd()
sniffer.join()
if not sniffer.foundCorrectPacket:
sys.exit(1)
# Wait for expiry from first test run.
sleep(75)
sniffer2.setEnd()
sniffer2.join()
if not sniffer2.foundCorrectPacket:
sys.exit(1)
sys.exit(0)
2: "PTCH_REQ",
3: "DATA_FNSD",
4: "PTCH_DATA",
5: "DATA",
6: "FEEDBACK"
},
),
scapy.XByteField("appID", 2),
scapy.XByteField("dataID", 0),
scapy.XByteField("sn", 0),
scapy.XByteField("dataSize", 11),
]
data_eth = scapy.Ether(src="aa:bb:cc:dd:ee:01",
dst="11:22:33:44:55:01",
type=0x0800)
print("Size of data_eth:", len(bytes(data_eth)))
data_ip = scapy.IP(src="10.1.0.1", dst="10.0.0.1")
print("Size of data_ip:", len(bytes(data_ip)))
data_udp = scapy.UDP(sport=10001, dport=10002)
print("Size of data_udp:", len(bytes(data_udp)))
unlabeled_data_mdc = MDCData(addr=0x1A1B, mode=0x02, label=0x01)
print("Size of unlabeled_data_mdc:", len(bytes(unlabeled_data_mdc)))
unlabeled_data_pkt = data_eth / data_ip / data_udp / unlabeled_data_mdc
print("Sendiing unlabeled_data_mdc_header: ", bytes(unlabeled_data_mdc))
print("Size of unlabeled_data_pkt:", len(bytes(unlabeled_data_pkt)))
print("Connecting...")
if os.path.exists("/tmp/mdc_dp_p.sock"):
#-- define spark usual and streaming contexts
cont_0 = pyspark.SparkContext(appName="pkt_dissector")
cont_0.setLogLevel("ERROR")
s_cont_0 = pyspark_streaming.StreamingContext(cont_0, 5)
#-- kafka integration (notice, that we receive packets as a bytes struct)
brokers = "192.168.122.71:9092,192.168.122.72:9092,192.168.122.73:9092"
kafka_dstream = pyspark_kafka.KafkaUtils.createDirectStream(
s_cont_0, ["test1"], {"metadata.broker.list": brokers},
valueDecoder=lambda x: bytes(x))
#
# Lazy evaluation rules
#
#-- Kafka message comes as a 2-tuple: (key, value). The code below will
#-- select the actual message (i.e. packet) and dissects it.
pkts = kafka_dstream.map(lambda x: scapy.Ether(x[1]))
filtered_pkts = pkts.filter(common._pkt_filter). \
map(lambda x: (x, x.summary()))
#-- DEBUG
#-- print to the console
filtered_pkts.pprint()
#
# Driver code
#
#-- start the stream and wait until it is terminated
s_cont_0.start()
s_cont_0.awaitTermination()
def getmac(ip):
arp_request_header = scapy.ARP(pdst = ip)
ether_header = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_request_packet = ether_header/arp_request_header
answered_list = scapy.srp(arp_request_packet,timeout=1,verbose=False)[0]
return answered_list[0][1].hwsrc
def scan(ip):
arp_request = scapy.ARP(op=1, pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_request_broadcast = broadcast / arp_request
scan_list = scapy.srp(arp_request_broadcast, timeout=1, verbose=False)[0]
return scan_list
import sys
import scapy.all as scapy
if sys.version_info.major == 3:
input("Press Enter to continue...")
else:
raw_input("Press Enter to continue...")
scapy.sendp(scapy.Ether(type=0x9999) /
"\x70\x6c\x61\x69\x6e\x20\x74\x65\x78\x74\x20\x20\x20\x20\x20\x20",
count=1000)
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. import scapy.all as scapy ## CRASH TESTS ## m0 = ArpResponder() CRASH_TEST_INPUTS.append([m0, 1, 1]) ## OUTPUT TESTS ## m1 = ArpResponder() eth_header = scapy.Ether(src='02:1e:67:9f:4d:ae', dst='ff:ff:ff:ff:ff:ff') arp_header = scapy.ARP(op=1, pdst='1.2.3.4') arp_req = eth_header / arp_header m1.add(ip='1.2.3.4', mac_addr='A0:22:33:44:55:66') arp_reply = arp_req.copy() arp_reply[scapy.Ether].src = 'A0:22:33:44:55:66' arp_reply[scapy.Ether].dst = '02:1e:67:9f:4d:ae' arp_reply[scapy.ARP].op = 2 arp_reply[scapy.ARP].hwdst = arp_req[scapy.ARP].hwsrc arp_reply[scapy.ARP].hwsrc = 'A0:22:33:44:55:66' arp_reply[scapy.ARP].pdst = arp_req[scapy.ARP].psrc arp_reply[scapy.ARP].psrc = '1.2.3.4'
import scapy.all as scapy
# program to check promiscous mode of network interface.
# scan for all network devices using custom ARP packet. If we get response from network then
# it confirms that the network interface is indeed in promiscous mode.
net_iface = "enp0s3" # set your interface name
my_mac = "60:36:DD:98:B6:53" # set custom source MAC address to be used in ARP packet.
ip_range = "192.168.0.0/24" # set IP address range to scan. Use your network IP range.
# Send an ARP request
pkt = scapy.Ether(src=my_mac, dst="FF:FF:FF:FF:FF:FF") / scapy.ARP(
pdst=ip_range, hwsrc=my_mac)
ans, unans = scapy.srp(pkt, timeout=2, iface=net_iface)
if ans:
ans.summary(lambda (s, r): r.sprintf("%Ether.dst% %ARP.psrc%"))
def scan(ip):
arp_packet = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst='ff:ff:ff:ff:ff:ff')
arp_packet_broadcast = broadcast / arp_packet
ans, unans = scapy.srp(arp_packet_broadcast, timeout=1)
print(ans.summary())
def get_mac(ip):
pack = scapy.ARP(pdst=ip)
frame = scapy.Ether(dst='ff:ff:ff:ff:ff:ff')
arp_req = frame / pack
answerd = scapy.srp(arp_req, timeout=1, verbose=False)[0]
return answerd[0][1].hwsrc
def scan_arp_answer_only(ip):
return scapy.srp(scapy.Ether(dst='ff:ff:ff:ff:ff:ff') / scapy.ARP(pdst=ip),
timeout=1,
verbose=False)[0]
def generate_from_server_to_t1(self):
"""
@summary: Generate (not send) the packets to be sent from server to T1
"""
logger.info("Generating server to T1 packets")
if self.tor_vlan_intf:
vlan_src_intfs = [self.tor_vlan_intf]
# If destination VLAN intf is specified,
# use only the connected server
else:
# Otherwise send packets to all servers
vlan_src_intfs = self.vlan_interfaces
ptf_intf_to_mac_map = {}
for ptf_intf in self.ptf_intf_to_server_ip_map.keys():
ptf_intf_to_mac_map[ptf_intf] = self.ptfadapter.dataplane.get_mac(
0, ptf_intf)
logger.info("-" * 20 + "Server to T1 packet" + "-" * 20)
if self.tor_vlan_intf is None:
src_mac = 'random'
src_ip = 'random'
else:
ptf_port = self.tor_to_ptf_intf_map[self.tor_vlan_intf]
src_mac = ptf_intf_to_mac_map[ptf_port]
src_ip = self.ptf_intf_to_server_ip_map[ptf_port]
logger.info("Ethernet address: dst: {} src: {}".format(
self.vlan_mac, src_mac))
logger.info("IP address: dst: {} src: {}".format('random', src_ip))
logger.info("TCP port: dst: {} src: 1234".format(TCP_DST_PORT))
logger.info("Active ToR MAC: {}, Standby ToR MAC: {}".format(
self.active_mac, self.standby_mac))
logger.info("VLAN MAC: {}".format(self.vlan_mac))
logger.info("-" * 50)
self.packets_list = []
# Create packet #1 for each server and append to the list,
# then packet #2 for each server, etc.
# This way, when sending packets we continuously send for all servers
# instead of sending all packets for server #1, then all packets for
# server #2, etc.
tcp_tx_packet_orig = testutils.simple_tcp_packet(
eth_dst=self.vlan_mac, tcp_dport=TCP_DST_PORT)
tcp_tx_packet_orig = scapyall.Ether(str(tcp_tx_packet_orig))
payload_suffix = "X" * 60
for i in range(self.packets_per_server):
for vlan_intf in vlan_src_intfs:
ptf_src_intf = self.tor_to_ptf_intf_map[vlan_intf]
server_ip = self.ptf_intf_to_server_ip_map[ptf_src_intf]
eth_src = ptf_intf_to_mac_map[ptf_src_intf]
payload = str(i) + payload_suffix
packet = tcp_tx_packet_orig.copy()
packet[scapyall.Ether].src = eth_src
packet[scapyall.IP].src = server_ip
packet[scapyall.IP].dst = self.random_host_ip()
packet.load = payload
packet[scapyall.TCP].chksum = None
packet[scapyall.IP].chksum = None
self.packets_list.append((ptf_src_intf, str(packet)))
self.sent_pkt_dst_mac = self.vlan_mac
self.received_pkt_src_mac = [self.active_mac, self.standby_mac]
def get_mac(ip):
arp_request = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_req_brd = broadcast/arp_request
ans = scapy.srp(arp_req_brd, timeout=1, verbose=False)[0]
return ans[0][1].hwsrc
def get_mac_address(ip_address):
broadcast_layer = scapy.Ether(dst='ff:ff:ff:ff:ff:ff')
arp_layer = scapy.ARP(pdst=ip_address)
get_mac_packet = broadcast_layer/arp_layer
answer = scapy.srp(get_mac_packet, timeout=2, verbose=False)[0]
return answer[0][1].hwsrc
def createBroadCastPacket(self):
"""paket yayını yapmak için broadcast paketleri oluşturur"""
return scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
def createPacket(ip):
arp_request = scapy.ARP(pdst=ip) # create a ARP request object by scapy
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff") # We have set the destination
arp_request_broadcast = broadcast / arp_request
return (arp_request_broadcast)
def scan(ip):
arp_request = scapy.ARP(pdst=ip)
mac_request = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_mac_request = mac_request / arp_request
answered = scapy.srp(arp_mac_request, timeout=1, verbose=False)[0]
return answered
def main():
parser = argparse.ArgumentParser(
"frag6.py", description="IPv6 fragementation test tool")
parser.add_argument(
'--sendif',
nargs=1,
required=True,
help='The interface through which the packet will be sent')
parser.add_argument('--recvif',
nargs=1,
required=True,
help='The interface on which to check for the packet')
parser.add_argument('--src',
nargs=1,
required=True,
help='The source IP address')
parser.add_argument('--to',
nargs=1,
required=True,
help='The destination IP address')
parser.add_argument('--debug',
required=False,
action='store_true',
help='Enable test debugging')
args = parser.parse_args()
########################################################################
#
# Two fragments with different ECN (Traffic Clas) bits to trigger
# error cases.
#
# A: Reassembly failure.
# R: ip6f02 dropped / Timeout (not waiting for).
#
data = "6" * 8
# IPTOS_ECN_NOTECT
ip6f01 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0], tc=0x00) / \
sp.IPv6ExtHdrFragment(offset=0, m=1, id=13) / \
sp.UDP(dport=3456, sport=6543) / \
data
# IPTOS_ECN_CE
ip6f02 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0], tc=0x03) / \
sp.IPv6ExtHdrFragment(offset=16, m=0, id=13) / \
sp.UDP(dport=3456, sport=6543) / \
data
if args.debug:
ip6f01.display()
ip6f02.display()
sp.sendp(ip6f01, iface=args.sendif[0], verbose=False)
sp.sendp(ip6f02, iface=args.sendif[0], verbose=False)
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ##
#
# Two fragments with different ECN (Traffic Clas) bits to trigger
# error cases.
#
# A: Reassembly failure.
# R: ip6f02 dropped / Timeout (not waiting for).
#
# IPTOS_ECN_ECT1
ip6f01 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0], tc=0x01) / \
sp.IPv6ExtHdrFragment(offset=0, m=1, id=0x1301) / \
sp.UDP(dport=3456, sport=6543) / \
data
# IPTOS_ECN_NOTECT
ip6f02 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0], tc=0x00) / \
sp.IPv6ExtHdrFragment(offset=16, m=0, id=0x1301) / \
sp.UDP(dport=3456, sport=6543) / \
data
if args.debug:
ip6f01.display()
ip6f02.display()
sp.sendp(ip6f01, iface=args.sendif[0], verbose=False)
sp.sendp(ip6f02, iface=args.sendif[0], verbose=False)
# Wait for expiry.
sleep(75)
sys.exit(0)
def mac_bul(self, ip):
arp_istek = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_istek_broadcast = broadcast / arp_istek
cevap = scapy.srp(arp_istek_broadcast, timeout=1, verbose=False)[0]
return cevap[0][1].hwsrc
def get_mac(ip): #get mac address from the network request = scapy.ARP(pdst = ip) brodcast = scapy.Ether(dst = "ff:ff:ff:ff:ff:ff") arp_brodcast = brodcast/request useful = scapy.srp(arp_brodcast, timeout = 1,verbose = False)[0] return useful[0][1].hwsrc
def get_mac(ip):
arp_packet = scapy.ARP(pdst=ip)
broadcast_packet = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_broadcast_packet = broadcast_packet/arp_packet
answered_list = scapy.srp(arp_broadcast_packet, timeout=1, verbose=False)[0]
return answered_list[0][1].hwsrc
def main():
parser = argparse.ArgumentParser("frag6.py",
description="IPv6 fragementation test tool")
parser.add_argument('--sendif', nargs=1,
required=True,
help='The interface through which the packet will be sent')
parser.add_argument('--recvif', nargs=1,
required=True,
help='The interface on which to check for the packet')
parser.add_argument('--src', nargs=1,
required=True,
help='The source IP address')
parser.add_argument('--to', nargs=1,
required=True,
help='The destination IP address')
parser.add_argument('--debug',
required=False, action='store_true',
help='Enable test debugging')
args = parser.parse_args()
# Start sniffing on recvif
sniffer = Sniffer(args, check_icmp6_error)
########################################################################
#
# Send a proper first fragment (off=0) and a second fragment which
# just fits the 64k. The re-send the first fragment with an extra
# unfragmentable part making the 64k to exceed the limit.
# This is to make sure we don't allow to update meta-data for a
# 1st fragmented packet should a second arrive but given the
# fragmentable part is an exact duplicate only that fragment
# will be silently discarded.
#
# A: Reassembly failure, timeout after
# R: ICMPv6 time exceeded / statistics for the duplicate
#
data = "6" * 8
ip6f00 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrFragment(offset=0, m=1, id=20) / \
sp.UDP(dport=3456, sport=6543) / \
data
data = "6" * 15
ip6f01 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrFragment(offset=0x1ffc, m=0, id=20) / \
sp.UDP(dport=3456, sport=6543) / \
data
data = "6" * 8
ip6f02 = \
sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrDestOpt(options = \
sp.PadN(optdata="\x00\x00\x00\x00\x00\x00")) / \
sp.IPv6ExtHdrFragment(offset=0, m=1, id=20) / \
sp.UDP(dport=3456, sport=6543) / \
data
if args.debug :
ip6f00.display()
ip6f01.display()
ip6f02.display()
sp.sendp(ip6f00, iface=args.sendif[0], verbose=False)
sp.sendp(ip6f01, iface=args.sendif[0], verbose=False)
sp.sendp(ip6f02, iface=args.sendif[0], verbose=False)
sleep(75)
sniffer.setEnd()
sniffer.join()
if not sniffer.foundCorrectPacket:
sys.exit(1)
sys.exit(0)
def main():
parser = argparse.ArgumentParser("frag6.py",
description="IPv6 fragementation test tool")
parser.add_argument('--sendif', nargs=1,
required=True,
help='The interface through which the packet will be sent')
parser.add_argument('--recvif', nargs=1,
required=True,
help='The interface on which to check for the packet')
parser.add_argument('--src', nargs=1,
required=True,
help='The source IP address')
parser.add_argument('--to', nargs=1,
required=True,
help='The destination IP address')
parser.add_argument('--debug',
required=False, action='store_true',
help='Enable test debugging')
args = parser.parse_args()
########################################################################
#
# Sysctl set to accept maximum 3 segments on a fragmented packet.
# The 4th packet will flush the entire q6.
#
# A: 4 Discarded.
# R: Silence (statistics only) no ICMPv6 as we skip the off=0 segment.
#
data = "66666666"
for i in range(4):
foffset=16 + (i * (0x100 + (int)(16 / 8)))
ip6f01 = sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrFragment(offset=foffset, m=1, id=15) / \
sp.UDP(dport=3456, sport=6543) / \
data
if args.debug :
ip6f01.display()
sp.sendp(ip6f01, iface=args.sendif[0], verbose=False)
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # ##
#
# Sysctl set to accept maximum 3 segments on a fragmented packet.
# The 4th packet will flush the entire q6.
# This time we play proper offset/length games on the packets in order
# to trigger the 2nd test case, with the last packet still having m=1.
#
# A: 4 Discarded.
# R: ICMPv6 timeout expired.
#
data = "66666666"
for i in range(4):
foffset=(i * (int)(16 / 8))
ip6f01 = sp.Ether() / \
sp.IPv6(src=args.src[0], dst=args.to[0]) / \
sp.IPv6ExtHdrFragment(offset=foffset, m=1, id=0x1501) / \
sp.UDP(dport=3456, sport=6543) / \
data
if args.debug :
ip6f01.display()
sp.sendp(ip6f01, iface=args.sendif[0], verbose=False)
sys.exit(0)
def get_mac(ip):
arp_request = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_request_broadcast = broadcast/arp_request
mac_list = scapy.srp(arp_request_broadcast, timeout=1, verbose=False)[0]
return mac_list[0][1].hwsrc
def generate_from_t1_to_server(self):
"""
@summary: Generate (not send) the packets to be sent from T1 to server
"""
logger.info("Generating T1 to server packets")
eth_dst = self.dut_mac
ip_ttl = 255
if self.tor_pc_intf and self.tor_pc_intf in self.tor_pc_intfs:
# If a source portchannel intf is specified,
# get the corresponding PTF info
ptf_t1_src_intf = self.tor_to_ptf_intf_map[self.tor_pc_intf]
eth_src = self.ptfadapter.dataplane.get_mac(0, ptf_t1_src_intf)
random_source = False
else:
# If no source portchannel specified, randomly choose one
# during packet generation
logger.info('Using random T1 source intf')
ptf_t1_src_intf = None
eth_src = None
random_source = True
if self.tor_vlan_intf:
# If destination VLAN intf is specified,
# use only the connected server
ptf_port = self.tor_to_ptf_intf_map[self.tor_vlan_intf]
server_ip_list = [self.ptf_intf_to_server_ip_map[ptf_port]]
else:
# Otherwise send packets to all servers
server_ip_list = self.ptf_intf_to_server_ip_map.values()
logger.info("-" * 20 + "T1 to server packet" + "-" * 20)
logger.info("PTF source intf: {}".format(
'random' if random_source else ptf_t1_src_intf))
logger.info("Ethernet address: dst: {} src: {}".format(
eth_dst, 'random' if random_source else eth_src))
logger.info("IP address: dst: {} src: random".format(
'all' if len(server_ip_list) > 1 else server_ip_list[0]))
logger.info("TCP port: dst: {}".format(TCP_DST_PORT))
logger.info("DUT mac: {}".format(self.dut_mac))
logger.info("VLAN mac: {}".format(self.vlan_mac))
logger.info("-" * 50)
self.packets_list = []
# Create packet #1 for each server and append to the list,
# then packet #2 for each server, etc.
# This way, when sending packets we continuously send for all servers
# instead of sending all packets for server #1, then all packets for
# server #2, etc.
tcp_tx_packet_orig = testutils.simple_tcp_packet(
eth_dst=eth_dst,
eth_src=eth_src,
ip_ttl=ip_ttl,
tcp_dport=TCP_DST_PORT)
tcp_tx_packet_orig = scapyall.Ether(str(tcp_tx_packet_orig))
payload_suffix = "X" * 60
for i in range(self.packets_per_server):
for server_ip in server_ip_list:
packet = tcp_tx_packet_orig.copy()
if random_source:
tor_pc_src_intf = random.choice(self.tor_pc_intfs)
ptf_t1_src_intf = self.tor_to_ptf_intf_map[tor_pc_src_intf]
eth_src = self.ptfadapter.dataplane.get_mac(
0, ptf_t1_src_intf)
packet[scapyall.Ether].src = eth_src
packet[scapyall.IP].src = self.random_host_ip()
packet[scapyall.IP].dst = server_ip
payload = str(i) + payload_suffix
packet.load = payload
packet[scapyall.TCP].chksum = None
packet[scapyall.IP].chksum = None
self.packets_list.append((ptf_t1_src_intf, str(packet)))
self.sent_pkt_dst_mac = self.dut_mac
self.received_pkt_src_mac = [self.vlan_mac]
import sys
import scapy.all as scapy
from time import sleep
if sys.version_info.major == 3:
input("Press Enter to continue...")
else:
raw_input("Press Enter to continue...")
for n in range(0, 1000):
#print("\nTriggering Key {}".format(n))
sleep(0.100)
scapy.srp1(scapy.Ether(type=0x812) / ("\x00" * 33), timeout=0)
def getMAC(ip):
arp_req = scapy.ARP(pdst=ip)
broadcast = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_req_broadcast = broadcast / arp_req
answered_list = scapy.srp(arp_req_broadcast, timeout=1)[0]
return answered_list[0][1].hwsrc
