def SetupDNSServer(server):
node = server.node_name
workload = server.workload_name
dir_path = os.path.dirname(os.path.realpath(__file__))
zonefile = dir_path + '/' + "example.com.zone"
api.Logger.info("fullpath %s" % (zonefile))
resp = api.CopyToWorkload(node, workload, [zonefile], 'dnsdir')
if resp is None:
return None
named_conf = dir_path + '/' + "named.conf"
resp = api.CopyToWorkload(node, workload, [named_conf], 'dnsdir')
if resp is None:
return None
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddCommand(req, node, workload,
"yes | cp dnsdir/named.conf /etc/")
api.Trigger_AddCommand(
req, node, workload,
"ex -s -c \'%s/192.168.100.102/%s/g|x\' /etc/named.conf" %
("%s", server.ip_address))
api.Trigger_AddCommand(req, node, workload,
"yes | cp dnsdir/example.com.zone /var/named/")
api.Trigger_AddCommand(req, node, workload, "systemctl start named")
api.Trigger_AddCommand(req, node, workload, "systemctl enable named")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
for cmd in trig_resp.commands:
api.PrintCommandResults(cmd)
return api.types.status.SUCCESS
def Setup(tc):
api.Logger.info("Setup.")
tc.pcap_file_name = None
tc.dir_path = os.path.dirname(os.path.realpath(__file__))
tc.test_mss = 900
if tc.iterators.kind == "remote":
pairs = api.GetRemoteWorkloadPairs()
if not pairs:
api.Logger.info("no remtote eps")
return api.types.status.SUCCESS
else:
pairs = api.GetLocalWorkloadPairs()
tc.resp_flow = getattr(tc.args, "resp_flow", 0)
tc.cmd_cookies = {}
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
if pairs[0][0].IsNaples():
tc.client, tc.server = pairs[0]
else:
tc.server, tc.client = pairs[0]
fullpath = tc.dir_path + '/' + "scapy_3way.py"
resp = api.CopyToWorkload(tc.server.node_name, tc.server.workload_name,
[fullpath])
resp = api.CopyToWorkload(tc.client.node_name, tc.client.workload_name,
[fullpath])
cmd_cookie = start_nc_server(tc.server, "1237")
add_command(req, tc, 'server', tc.server, cmd_cookie, True)
ret = __add_remove_tcp_drop_rule(tc.client)
if ret != api.types.status.SUCCESS:
api.Logger.error(
f"Failed to drop the drop rule on {tc.client.workload_name}")
return ret
#start session
cmd_cookie = "sudo -E python3 ./scapy_3way.py {} {}".format(
tc.client.ip_address, tc.server.ip_address)
api.Trigger_AddCommand(req, tc.client.node_name, tc.client.workload_name,
cmd_cookie, False)
cmd_cookie = "/nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format(
tc.server.ip_address)
add_command(req, tc, 'show before', tc.client, cmd_cookie, naples=True)
tc.first_resp = api.Trigger(req)
cmd = tc.first_resp.commands[-1]
api.PrintCommandResults(cmd)
tc.pre_ctrckinf = get_conntrackinfo(cmd)
if getattr(tc.args, 'vmotion_enable', False):
vmotion_utils.PrepareWorkloadVMotion(tc, [tc.client])
return api.types.status.SUCCESS
def Setup(tc):
tc.skip = False
tc.workload_pairs = tc.selected
if len(tc.workload_pairs) == 0:
api.Logger.info("Skipping Testcase due to no workload pairs.")
tc.skip = True
wloads = set()
for w1, w2, port in tc.workload_pairs:
wloads.add(w1)
wloads.add(w2)
fullpath = api.GetTopDir() + '/iota/bin/fuz'
for w in wloads:
resp = api.CopyToWorkload(w.node_name, w.workload_name, [fullpath], '')
#Create a symlink at top level
realPath = "realpath fuz"
req = api.Trigger_CreateExecuteCommandsRequest()
api.Trigger_AddCommand(req,
w.node_name,
w.workload_name,
realPath,
background=False)
resp = api.Trigger(req)
for cmd in resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
return api.types.status.FAILURE
FUZ_EXEC[cmd.entity_name] = cmd.stdout.split("\n")[0]
return api.types.status.SUCCESS
def copyTestCommand(tc):
test_reject_file = os.path.join(os.path.dirname(__file__),
"test_reject.py")
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
path_to_copy = "test_reject_script"
for w in tc.workload_dict.keys():
api.Logger.info("Copying file %s to %s:%s"%
(test_reject_file, w.workload_name,
path_to_copy))
resp = api.CopyToWorkload(w.node_name, w.workload_name,
[test_reject_file], path_to_copy)
if resp is None:
api.Logger.error("Failed to copy test reject command to %s"%w.workload_name)
return False
api.Trigger_AddCommand(req, w.node_name, w.workload_name,
"yes | mv %s/test_reject.py /usr/local/bin"%(path_to_copy))
api.Trigger_AddCommand(req, w.node_name, w.workload_name,
"yes | chmod 755 /usr/local/bin/test_reject.py")
trig_resp = api.Trigger(req)
for cmd in trig_resp.commands:
api.PrintCommandResults(cmd)
return True
def SetupNFSServer(server, client, nfs=True):
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
node = server.node_name
workload = server.workload_name
api.Trigger_AddCommand(req, node, workload, "sudo chkconfig nfs on")
api.Trigger_AddCommand(req, node, workload, "sudo service rpcbind start")
api.Trigger_AddCommand(req, node, workload, "sudo service nfs start")
if (nfs == True):
api.Trigger_AddCommand(req, client.node_name, client.workload_name,
"rpcinfo -s %s" % (server.ip_address))
api.Trigger_AddCommand(req, node, workload, "mkdir /home/sunrpcmntdir")
api.Trigger_AddCommand(req, node, workload,
"sudo chmod 777 /home/sunrpcmntdir")
api.Trigger_AddCommand(
req, node, workload,
"sudo echo \'/home/sunrpcmntdir %s(rw,sync,no_subtree_check,no_root_squash)\' | sudo tee -a /etc/exports"
% (client.ip_address))
api.Trigger_AddCommand(req, node, workload, "sudo exportfs -ra")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
for cmd in trig_resp.commands:
api.PrintCommandResults(cmd)
rpcfile = dir_path + '/' + "sunrpc_file.txt"
f = open(rpcfile, "w")
f.write("Hello World!!!\n")
f.close()
resp = api.CopyToWorkload(client.node_name, client.workload_name,
[rpcfile], 'sunrpcdir')
os.remove(rpcfile)
return api.types.status.SUCCESS
def SetupPacketScapy(tc):
pktscapyscript = api.GetTopDir() + '/' + dir_path + "packet_scapy.py"
for wl in tc.workloads:
resp = api.CopyToWorkload(wl.node_name, wl.workload_name, [pktscapyscript], "")
if resp is None:
api.Logger.info("Failed to copy packet scapy script to WL:%s"%wl.workload_name)
return api.types.status.FAILURE
return api.types.status.SUCCESS
def SetupTFTPClient(client):
node = client.node_name
workload = client.workload_name
fullpath = dir_path + '/' + "tftp_client.txt"
api.Logger.info("fullpath %s" % (fullpath))
resp = api.CopyToWorkload(node, workload, [fullpath], 'tftpdir')
if resp is None:
return None
return api.types.status.SUCCESS
def Trigger(tc):
pairs = api.GetLocalWorkloadPairs()
server = pairs[0][0]
client = pairs[0][1]
tc.cmd_cookies = []
naples = server
if not server.IsNaples():
naples = client
if not client.IsNaples():
return api.types.status.SUCCESS
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\
(server.workload_name, server.ip_address, client.workload_name, client.ip_address)
api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr))
dir_path = os.path.dirname(os.path.realpath(__file__))
fullpath = dir_path + '/' + "small.vob"
api.Logger.info("fullpath %s" % (fullpath))
resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir')
if resp is None:
return api.types.status.FAILURE
api.Trigger_AddCommand(req, client.node_name, client.workload_name,
"ls -al | grep video")
tc.cmd_cookies.append("Before RTSP")
server_cmd = "cd rtspdir && live555MediaServer"
api.Trigger_AddCommand(req, server.node_name, server.workload_name,
server_cmd, background = True)
tc.cmd_cookies.append("Run RTSP server")
api.Trigger_AddCommand(req, client.node_name, client.workload_name,
"openRTSP rtsp://%s/small.vob" % server.ip_address)
tc.cmd_cookies.append("Run RTSP client")
## Add Naples command validation
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show session --alg rtsp --yaml")
tc.cmd_cookies.append("show session RTSP established")
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show nwsec flow-gate | grep RTSP")
tc.cmd_cookies.append("show flow-gate")
api.Trigger_AddCommand(req, client.node_name, client.workload_name,
"ls -al | grep video")
tc.cmd_cookies.append("After RTSP")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
return api.types.status.SUCCESS
def copy_to_entity(entity):
fullpath = api.GetTopDir() + '/iota/bin/fuz'
resp = api.CopyToWorkload(entity.node_name, entity.workload_name, [fullpath], '')
#Create a symlink at top level
realPath = "realpath fuz"
req = api.Trigger_CreateExecuteCommandsRequest()
api.Trigger_AddCommand(req, entity.node_name, entity.workload_name, realPath, background = False)
resp = api.Trigger(req)
for cmd in resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code != 0:
return api.types.status.FAILURE
tc.fuz_exec[cmd.entity_name] = cmd.stdout.split("\n")[0]
return api.types.status.SUCCESS
def Trigger(tc):
if tc.skip: return api.types.status.SUCCESS
store = tc.GetBundleStore()
cps = int(getattr(tc.args, "cps", 500))
attempts = int(getattr(tc.args, "attempts", 3))
sessions = int(getattr(tc.args, "num_sessions", 1))
session_time = str(getattr(tc.args, "session_time", "10")) + "s"
static_arp = int(getattr(tc.args, "static_arp", False))
if static_arp:
#install arp entries before running
arpReqs = store["arp_ctx"]
api.Trigger(arpReqs)
#Spread CPS evenly
clientReq = api.Trigger_CreateAllParallelCommandsRequest()
cps_per_node = int(cps / len(store["client_ctxts"]))
for index, (_, client) in enumerate(store["client_ctxts"].items()):
jsonInput = {"connections": []}
for serverIPPort in client.GetServers():
jsonInput["connections"].append({
"ServerIPPort": serverIPPort,
"proto": "tcp"
})
outfile = api.GetTestDataDirectory(
) + "/" + client.workload_name + "_fuz.json"
with open(outfile, 'w') as fp:
json.dump(jsonInput, fp)
api.CopyToWorkload(client.node_name, client.workload_name, [outfile],
"")
clientCmd = fuz_init.FUZ_EXEC[
client.workload_name] + " -attempts " + str(
attempts) + " -duration " + session_time + " -conns " + str(
sessions) + " -cps " + str(
cps_per_node
) + " -talk --jsonOut --jsonInput " + os.path.basename(
outfile)
api.Trigger_AddCommand(clientReq,
client.node_name,
client.workload_name,
clientCmd,
background=True)
#Initiate connections
store["client_req"] = api.Trigger(clientReq)
return api.types.status.SUCCESS
def SetupFTPClient(node, workload):
ftpdata = dir_path + '/' + "ftp_client.txt"
api.Logger.info("fullpath %s" % (ftpdata))
resp = api.CopyToWorkload(node, workload, [ftpdata], 'ftpdir')
if resp is None:
return None
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddCommand(req, node, workload, "mkdir /home/admin/ftp")
api.Trigger_AddCommand(req, node, workload,
"cp ftpdir/ftp_client.txt /home/admin/ftp/")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
for cmd in trig_resp.commands:
api.PrintCommandResults(cmd)
return api.types.status.SUCCESS
def SetupFTPMediator(node, workload):
ftpcommand = dir_path + '/' + ".lftprc"
f = open(ftpcommand, "w")
f.write("set ftp:use-fxp true\n")
f.close()
resp = api.CopyToWorkload(node, workload, [ftpcommand], 'ftpdir')
if resp is None:
return None
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddCommand(req, node, workload, "cp ftpdir/.lftprc ~/")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
for cmd in trig_resp.commands:
api.PrintCommandResults(cmd)
return api.types.status.SUCCESS
def _createTrexCfg(self):
cfgFile = None
try:
req = api.Trigger_CreateExecuteCommandsRequest()
self._removeTrexCfg()
if self.role == 'client':
cfgFile = self._getTrexCfg(self.workload.interface, "dummy", \
self.workload.ip_address, "0.0.0.0", \
self.gw, "0.0.0.0")
else:
cfgFile = self._getTrexCfg("dummy", self.workload.interface, \
"0.0.0.0", self.workload.ip_address, \
"0.0.0.0", self.gw)
api.Logger.info("Configuration for TRex server file:%s, workload: %s"%
(cfgFile.name, self.workload.workload_name))
cfgFileName = cfgFile.name.split("/")[-1]
resp = api.CopyToWorkload(self.workload.node_name, self.workload.workload_name,
[cfgFile.name])
if not resp:
raise Exception("Failed to copy TRex configuration to %s "%())
api.Trigger_AddCommand(req, self.workload.node_name, self.workload.workload_name,
"yes | mv %s %s"%(cfgFileName, DEFAULT_TREX_CFG_PATH))
resp = api.Trigger(req)
for cmd in resp.commands:
api.PrintCommandResults(cmd)
if cmd.exit_code:
raise Exception("Failed to create TRex configuration on %s"%
self.workload.workload_name)
self._verifyTrexCfg()
api.Logger.info("Created TRex configuration on %s"%
self.workload.workload_name)
finally:
if cfgFile:
cfgFile.close()
def ICMPv6Test(tc, packet_type):
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
tc.cmd_cookies = []
for wl in tc.workloads:
# Use only untagged WL for now
if wl.uplink_vlan != 0:
continue
# Pick Naples workload as the source for packet tx
if not wl.IsNaples():
continue
# Form ICMPv6 NS Packet PCAP file and copy to WL
pcap_file_full_path, pcap_file = GetICMPv6PacketPcap(wl, packet_type)
if pcap_file is None:
api.Logger.error("Failed to get PCAP file for packet: %s, for WL:%s"%(packet_type,wl.workload_name))
continue
resp = api.CopyToWorkload(wl.node_name, wl.workload_name, [pcap_file_full_path], "")
if resp is None:
api.Logger.error("Failed to copy PCAP file %s to WL:%s"%(pcap_file,wl.workload_name))
continue
# get drop stats before test
naples_cmd = r"/nic/bin/pdsctl show system statistics drop | grep nacl"
api.Trigger_AddNaplesCommand(req, wl.node_name, naples_cmd)
tc.cmd_cookies.append("NACL Drops at start of test")
# Send ICMPv6 NS
cmd_cookie = "Send %s packets from %s(%s, %s)" % \
(packet_type, wl.workload_name, "2001:bade:cd8::1", wl.interface)
tc.cmd_cookies.append(cmd_cookie)
cmd = "sh -c 'chmod +x packet_scapy.py && ./packet_scapy.py --pcap-file %s --iface %s --count %s'"%(pcap_file,wl.interface,icmpv6_pkt_count)
api.Trigger_AddCommand(req, wl.node_name, wl.workload_name, cmd)
# get drop stats before test
naples_cmd = r"/nic/bin/pdsctl show system statistics drop | grep nacl"
api.Trigger_AddNaplesCommand(req, wl.node_name, naples_cmd)
tc.cmd_cookies.append("NACL Drops at end of test")
tc.resp = api.Trigger(req)
if tc.resp is None:
return api.types.status.FAILURE
return api.types.status.SUCCESS
def SetupDNSClient(client, server, qtype="NONE"):
node = client.node_name
workload = client.workload_name
dnsscapy = dir_path + '/' + "dnsscapy.py"
f = open(dnsscapy, "w")
f.write("#! /usr/bin/python3\n")
f.write("from scapy.all import *\n")
f.write("import codecs\n")
f.write("ip=IP(src=\"%s\", dst=\"%s\")\n" %
(client.ip_address, server.ip_address))
if qtype == "LARGE_DOMAIN_NAME":
f.write(
"dnspkt=UDP(sport=53333,dport=53)/DNS(rd=1, qd=DNSQR(qname=\'%s\'))\n"
% (LARGE_DOMAIN_NAME))
elif qtype == "LONG_LABEL":
f.write(
"data=\'0000010000010000000000003b49737468697361626967656e6f756768646f6d61696e6e616d65666f72617265616c6c6c6c6c6c7979797979626967646f6d61696e736572766572446f77746f636f6e73747275637461646f6d61696e6e616d65197468617469736c61726765727468616e7468656d6178696d756d646f6d61696e6e616d6573697a6518646f0e736e74736503636f6d0000010001\'\n"
)
f.write(
"dnspkt=UDP(sport=53333,dport=53)/codecs.decode(data, 'hex')\n")
elif qtype == "MULTI_QUESTION":
f.write(
"dnspkt=UDP(sport=53333,dport=53)/DNS(rd=2,qd=DNSQR(qname='www.thepacketgeek.com')/DNSQR(qname='test3.example.com'))\n"
)
elif qtype == "LABEL_PARSING_ERROR":
f.write(
"data=\'0000010000010000000000003b49737468697361626967656e6f756768646f6d61696e6e616d65666f72617265616c6c6c6c6c6c7979797979626967646f6d61696e736572766572686f77746f636f6e73747275637461646f6d61696e6e616d65197468617469736c61726765727468616e7468656d6178696d756d646f6d61696e6e616d6573697a6518646f0e736e74736503636f6d0000010001\'\n"
)
f.write("sendp(Ether(src=\"%s\", dst=\"%s\")/ip/dnspkt, iface=\"%s\")\n" %
(client.mac_address, server.mac_address, client.interface))
f.close()
resp = api.CopyToWorkload(node, workload, [dnsscapy], 'dnsdir')
if resp is None:
return None
os.remove(dnsscapy)
def SetupFTPClient(node, workload, server, mode):
dir_path = os.path.dirname(os.path.realpath(__file__))
ftpcommand = dir_path + '/' + "ftp.sh"
f = open(ftpcommand, "w")
f.write("#!/bin/bash\n")
f.write("ftp -inv %s <<EOF\n" % (server.ip_address))
f.write("user admin linuxpassword\n")
f.write("cd /home/admin/ftp\n")
f.write("pwd\n")
f.write("dir\n")
if (mode == 'active'):
f.write("pass\n")
f.write("ls\n")
f.write("sleep 60\n")
f.write("ls\n")
f.write("sleep 120\n")
f.write("mget ftp_server.txt\n")
f.close()
resp = api.CopyToWorkload(node, workload, [ftpcommand], 'ftpdir')
if resp is None:
return None
return api.types.status.SUCCESS
def SetupTFTPServer(server, non_standard_port=False):
node = server.node_name
workload = server.workload_name
fullpath = dir_path + '/' + "tftp_server.txt"
api.Logger.info("fullpath %s" % (fullpath))
resp = api.CopyToWorkload(node, workload, [fullpath], 'tftpdir')
if resp is None:
return None
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddCommand(req, node, workload,
"cp tftpdir/tftp_server.txt /var/lib/tftpboot")
api.Trigger_AddCommand(req, node, workload,
"touch /var/lib/tftpboot/tftp_client.txt")
api.Trigger_AddCommand(req, node, workload,
"chmod 666 /var/lib/tftpboot/tftp_client.txt")
if non_standard_port == True:
api.Trigger_AddCommand(req, node, workload, "systemctl disable tftp")
api.Trigger_AddCommand(req, node, workload, "systemctl stop tftp")
api.Trigger_AddCommand(
req, node, workload,
"/usr/sbin/in.tftpd -s /var/lib/tftpboot -l --address %s:%s" %
(server.ip_address, TFTP_NONSTD_PORT))
api.Trigger_AddCommand(req, node, workload,
"touch /var/lib/tftpboot/tftp_client.txt")
api.Trigger_AddCommand(req, node, workload,
"chmod 666 /var/lib/tftpboot/tftp_client.txt")
else:
api.Trigger_AddCommand(req, node, workload, "systemctl start tftp")
api.Trigger_AddCommand(req, node, workload, "systemctl enable tftp")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
for cmd in trig_resp.commands:
api.PrintCommandResults(cmd)
return api.types.status.SUCCESS
def Trigger(tc):
api.Logger.info("Trigger.")
if tc.iterators.kind == "remote":
pairs = api.GetRemoteWorkloadPairs()
if not pairs:
api.Logger.info("no remtote eps")
return api.types.status.SUCCESS
else:
pairs = api.GetLocalWorkloadPairs()
resp_flow = getattr(tc.args, "resp_flow", 0)
tc.cmd_cookies = {}
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
if pairs[0][0].IsNaples():
client,server = pairs[0]
else:
server,client = pairs[0]
dir_path = os.path.dirname(os.path.realpath(__file__))
fullpath = dir_path + '/' + "scapy_3way.py"
resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath])
resp = api.CopyToWorkload(client.node_name, client.workload_name, [fullpath])
cmd_cookie = start_nc_server(server, "1237")
add_command(req, tc, 'server', server, cmd_cookie, True)
#start session
cmd_cookie = "sudo -E python3 ./scapy_3way.py {} {}".format(client.ip_address, server.ip_address)
api.Trigger_AddCommand(req, client.node_name, client.workload_name, cmd_cookie,False)
cmd_cookie = "/nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format(server.ip_address)
add_command(req, tc, 'show before', client, cmd_cookie, naples=True)
'''
iseq_num, iack_num, iwindo_sz, iwinscale, rseq_num, rack_num, rwindo_sz, rwinscale = get_conntrackinfo(cmd)
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
if resp_flow:
new_seq_num = rseq_num + iwindo_sz * (2 ** iwinscale)
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
#left out of window - retransmit
cmd_cookie = "hping3 -c 1 -s 1237 -p 52255 -M {} -L {} --ack --tcp-timestamp {} -d 10".format(wrap_around(rseq_num, 0), rack_num, client.ip_address)
add_command(req, tc, 'fail ping', server, cmd_cookie)
else:
new_seq_num = iseq_num + rwindo_sz * (2 ** rwinscale)
#left out of window - retransmit
cmd_cookie = "hping3 -c 1 -s 52255 -p 1237 -M {} -L {} --ack --tcp-timestamp {} -d 10".format(wrap_around(iseq_num, 0), iack_num, server.ip_address)
add_command(req, tc,"fail ping", client, cmd_cookie)
cmd_cookie = "sleep 3 && /nic/bin/halctl show session --dstport 1237 --dstip {} --yaml".format(server.ip_address)
add_command(req, tc, 'show after', client, cmd_cookie, naples=True)
'''
cmd_cookie = "/nic/bin/halctl clear session"
add_command(req, tc, 'clear', client, cmd_cookie, naples=True)
if server.IsNaples():
cmd_cookie = "/nic/bin/halctl clear session"
add_command(req, tc, 'clear', server, cmd_cookie, naples=True)
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
return api.types.status.SUCCESS
def Trigger(tc):
if tc.skip: return api.types.status.SUCCESS
store = tc.GetBundleStore()
cps = int(getattr(tc.args, "cps", 500))
pcap_capture = int(getattr(tc.args, "pcap", False))
sessions = int(getattr(tc.args, "num_sessions", 1))
session_time = str(getattr(tc.args, "session_time", "10")) + "s"
static_arp = int(getattr(tc.args, "static_arp", False))
if static_arp:
#install arp entries before running
arpReqs = store["arp_ctx"]
api.Trigger(arpReqs)
#Spread CPS evenly
clientReq = api.Trigger_CreateAllParallelCommandsRequest()
clientPcapReq = api.Trigger_CreateAllParallelCommandsRequest()
cps_per_node = int(cps / len(store["client_ctxts"]))
for index, (_, client) in enumerate(store["client_ctxts"].items()):
jsonInput = {"connections": []}
for serverIPPort in client.GetServers():
jsonInput["connections"].append({
"ServerIPPort": serverIPPort,
"proto": "tcp"
})
outfile = api.GetTestDataDirectory(
) + "/" + client.workload_name + "_fuz.json"
with open(outfile, 'w') as fp:
json.dump(jsonInput, fp)
api.CopyToWorkload(client.node_name, client.workload_name, [outfile],
"")
api.Trigger_AddCommand(clientPcapReq,
client.node_name,
client.workload_name,
"tcpdump -i eth1 -w %s.pcap" %
(client.workload_name),
background=True)
clientCmd = fuz_init.FUZ_EXEC[
client.
workload_name] + " -attempts 6 -duration " + session_time + " -conns " + str(
sessions) + " -cps " + str(
cps_per_node
) + " -talk --jsonOut --jsonInput " + os.path.basename(
outfile)
api.Trigger_AddCommand(clientReq,
client.node_name,
client.workload_name,
clientCmd,
timeout=0)
if pcap_capture:
#Start Server Pcap
serverPcapReq = api.Trigger_CreateAllParallelCommandsRequest()
for pcap_info in store["server_pcap_info"]:
node_name, intf, pcap_file = pcap_info[0], pcap_info[1], pcap_info[
2]
api.Trigger_AddHostCommand(serverPcapReq,
node_name,
"tcpdump -i %s -w %s" %
(intf, pcap_file),
background=True)
tc.server_pcap_resp = api.Trigger(serverPcapReq)
tc.fuz_client_pcap_resp = api.Trigger(clientPcapReq)
#Initiate connections
tc.fuz_client_resp = api.Trigger(clientReq)
if pcap_capture:
#Stop tcpdump
api.Trigger_TerminateAllCommands(tc.fuz_client_pcap_resp)
api.Trigger_TerminateAllCommands(tc.server_pcap_resp)
for _, client in store["client_ctxts"].items():
api.CopyFromWorkload(client.node_name, client.workload_name,
[client.workload_name + ".pcap"],
tc.GetLogsDir())
#Stop server Pcaps too
#for pcap_info in store["server_pcap_info"]:
# node_name, intf, pcap_file = pcap_info[0], pcap_info[1], pcap_info[2]
# api.CopyFromHost(node_name, [pcap_file], tc.GetLogsDir())
return api.types.status.SUCCESS
def Trigger(tc):
pairs = api.GetLocalWorkloadPairs()
server = pairs[0][0]
client = pairs[0][1]
tc.cmd_cookies = []
tc.controlageout_fail = 0
naples = server
if not server.IsNaples():
naples = client
if not client.IsNaples():
return api.types.status.SUCCESS
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\
(server.workload_name, server.ip_address, client.workload_name, client.ip_address)
api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr))
dir_path = os.path.dirname(os.path.realpath(__file__))
fullpath = dir_path + '/' + "small.vob"
api.Logger.info("fullpath %s" % (fullpath))
resp = api.CopyToWorkload(server.node_name, server.workload_name,
[fullpath], 'rtspdir')
if resp is None:
return api.types.status.FAILURE
api.Trigger_AddCommand(req, client.node_name, client.workload_name,
"ls -al | grep video")
tc.cmd_cookies.append("Before RTSP")
api.Trigger_AddCommand(req, server.node_name, server.workload_name,
"ip route del 224.0.0.0/4")
tc.cmd_cookies.append("ip route del server")
api.Trigger_AddCommand(req, client.node_name, client.workload_name,
"ip route del 224.0.0.0/4")
tc.cmd_cookies.append("ip route del client")
api.Trigger_AddCommand(
req, server.node_name, server.workload_name,
"ip route add 224.0.0.0/4 dev %s" % (server.interface))
tc.cmd_cookies.append("ip route server")
server_cmd = "cd rtspdir && vobStreamer -p 2004 small.vob"
api.Trigger_AddCommand(req,
server.node_name,
server.workload_name,
server_cmd,
background=True,
timeout=300)
tc.cmd_cookies.append("Run RTSP server")
api.Trigger_AddCommand(
req, client.node_name, client.workload_name,
"ip route add 224.0.0.0/4 dev %s" % (client.interface))
tc.cmd_cookies.append("ip route client")
api.Trigger_AddCommand(req,
client.node_name,
client.workload_name,
"openRTSP rtsp://%s:2004/vobStream" %
(server.ip_address),
timeout=300)
tc.cmd_cookies.append("Run RTSP client")
## Add Naples command validation
api.Trigger_AddNaplesCommand(
req, naples.node_name,
"/nic/bin/halctl show session --alg rtsp --yaml")
tc.cmd_cookies.append("show session RTSP established")
api.Trigger_AddNaplesCommand(req,
naples.node_name,
"sleep 30",
timeout=300)
tc.cmd_cookies.append("sleep")
api.Trigger_AddNaplesCommand(
req, naples.node_name,
"/nic/bin/halctl show session --alg rtsp --yaml")
tc.cmd_cookies.append("show yaml")
trig_resp = api.Trigger(req)
control_seen = 0
data_seen = 0
cmd = trig_resp.commands[-1]
api.PrintCommandResults(cmd)
alginfo = get_alginfo(cmd, APP_SVC_RTSP)
for info in alginfo:
if info['rtspinfo']['iscontrol'] == True:
control_seen = 1
if info['rtspinfo']['iscontrol'] == False:
data_seen = 1
if control_seen == 0 and data_seen == 1: tc.controlageout_fail = 1
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
return api.types.status.SUCCESS
def Trigger(tc):
pairs = api.GetLocalWorkloadPairs()
server = pairs[0][0]
client = pairs[0][1]
tc.cmd_cookies = []
tc.memleak = 0
naples = server
if not server.IsNaples():
naples = client
if not client.IsNaples():
return api.types.status.SUCCESS
tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\
(server.workload_name, server.ip_address, client.workload_name, client.ip_address)
api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr))
dir_path = os.path.dirname(os.path.realpath(__file__))
fullpath = dir_path + '/' + "small.vob"
api.Logger.info("fullpath %s" % (fullpath))
resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir')
if resp is None:
return api.types.status.FAILURE
memreq = api.Trigger_CreateExecuteCommandsRequest(serial = True)
api.Trigger_AddNaplesCommand(memreq, naples.node_name,
"/nic/bin/halctl clear session")
api.Trigger_AddNaplesCommand(memreq, naples.node_name,
"/nic/bin/halctl show system memory slab --yaml")
mem_trig_resp = api.Trigger(memreq)
cmd = mem_trig_resp.commands[-1]
for command in mem_trig_resp.commands:
api.PrintCommandResults(command)
meminfo = get_meminfo(cmd, 'rtsp')
for info in meminfo:
if (info['inuse'] != 0 or info['allocs'] != info['frees']):
tc.memleak = 1
mem_term_resp = api.Trigger_TerminateAllCommands(mem_trig_resp)
mem_resp = api.Trigger_AggregateCommandsResponse(mem_trig_resp, mem_term_resp)
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
server_cmd = "cd rtspdir && live555MediaServer"
api.Trigger_AddCommand(req, server.node_name, server.workload_name,
server_cmd, background = True)
tc.cmd_cookies.append("Run RTSP server")
for cnt in range(tc.args.count):
api.Trigger_AddCommand(req, client.node_name, client.workload_name,
"openRTSP rtsp://%s/small.vob" % server.ip_address)
tc.cmd_cookies.append("Run RTSP client")
## Add Naples command validation
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show session --alg rtsp")
tc.cmd_cookies.append("show session RTSP established")
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show nwsec flow-gate | grep RTSP")
tc.cmd_cookies.append("show flow-gate")
api.Trigger_AddNaplesCommand(req, naples.node_name,
"sleep 250", timeout=300)
tc.cmd_cookies.append("sleep")
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show session --alg rtsp")
tc.cmd_cookies.append("show session RTSP established")
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show system memory slab --yaml")
tc.cmd_cookies.append("show memory slab")
trig_resp = api.Trigger(req)
cmd = trig_resp.commands[-1]
meminfo_after = get_meminfo(cmd, 'rtsp')
for idx in range(0, len(meminfo)):
if (meminfo[idx]['inuse'] != meminfo_after[idx]['inuse'] or \
meminfo_after[idx]['allocs'] != meminfo_after[idx]['frees']):
tc.memleak = 1
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
return api.types.status.SUCCESS
def Trigger(tc):
if tc.local_or_remote == "local":
pairs = api.GetLocalWorkloadPairs()
else:
pairs = api.GetRemoteWorkloadPairs()
if not len(pairs):
return api.types.status.FAILURE
server = pairs[0][0]
client = pairs[0][1]
if tc.node_to_move == "client":
tc.vm_node = client
else:
tc.vm_node = server
vm_utils.get_vm_dbg_stats(tc)
tc.cmd_cookies = []
serverReq = None
clientReq = None
serverReq = api.Trigger_CreateExecuteCommandsRequest(serial=False)
clientReq = api.Trigger_CreateExecuteCommandsRequest(serial=False)
tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\
(server.workload_name, server.ip_address, client.workload_name, client.ip_address)
api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr))
dir_path = os.path.dirname(os.path.realpath(__file__))
fullpath = dir_path + '/' + "sample.vob"
resp = api.CopyToWorkload(server.node_name, server.workload_name,
[fullpath], 'rtspdir')
if resp is None:
return api.types.status.FAILURE
api.Trigger_AddCommand(serverReq,
server.node_name,
server.workload_name,
"cd rtspdir && live555MediaServer",
background=True)
tc.cmd_cookies.append("Run RTSP server")
api.Trigger_AddCommand(clientReq, client.node_name, client.workload_name,
"openRTSP rtsp://%s/sample.vob" % server.ip_address)
tc.cmd_cookies.append("Run RTSP client")
# Trigger the commands
tc.server_resp = api.Trigger(serverReq)
tc.client_resp = api.Trigger(clientReq)
tc.resp = api.Trigger_AggregateCommandsResponse(tc.server_resp,
tc.client_resp)
# Trigger vMotion
new_node = vm_utils.find_new_node_to_move_to(tc, tc.vm_node)
vm_utils.update_move_info(tc, [tc.vm_node], False, new_node)
vm_utils.do_vmotion(tc, True)
vm_utils.update_node_info(tc, tc.client_resp)
# After vMotion - Wait for Commands to end
tc.client_resp = api.Trigger_WaitForAllCommands(tc.client_resp)
api.Trigger_TerminateAllCommands(tc.server_resp)
# After vMotion - Show sessions dump after vMotion
tc.cmd_cookies = []
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddNaplesCommand(
req, tc.vm_node.node_name,
"/nic/bin/halctl show session --alg rtsp --yaml")
tc.cmd_cookies.append("show session RTSP")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
return api.types.status.SUCCESS
def Trigger(tc):
triplet = GetThreeWorkloads()
server = triplet[0][0]
client1 = triplet[0][1]
client2 = triplet[0][2]
tc.cmd_cookies = []
naples = server
if not server.IsNaples():
naples = client1
if not client1.IsNaples():
naples = client2
if not client2.IsNaples():
return api.types.status.SUCCESS
req = api.Trigger_CreateExecuteCommandsRequest(serial = True)
tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\
(server.workload_name, server.ip_address, client1.workload_name, client1.ip_address)
api.Logger.info("Starting RTSP test from %s" % (tc.cmd_descr))
dir_path = os.path.dirname(os.path.realpath(__file__))
fullpath = dir_path + '/' + "small.vob"
api.Logger.info("fullpath %s" % (fullpath))
resp = api.CopyToWorkload(server.node_name, server.workload_name, [fullpath], 'rtspdir')
if resp is None:
return api.types.status.FAILURE
api.Trigger_AddCommand(req, client1.node_name, client1.workload_name,
"ls -al | grep video")
tc.cmd_cookies.append("Before RTSP")
server_cmd = "cd rtspdir && vobStreamer -p 2004 small.vob"
api.Trigger_AddCommand(req, server.node_name, server.workload_name,
server_cmd, background = True)
tc.cmd_cookies.append("Run RTSP server")
api.Trigger_AddCommand(req, client1.node_name, client1.workload_name,
"openRTSP rtsp://%s:2004/vobStream" % server.ip_address)
tc.cmd_cookies.append("Run RTSP client1")
## Add Naples command validation
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show session --alg rtsp")
tc.cmd_cookies.append("show session RTSP established")
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show nwsec flow-gate | grep RTSP")
tc.cmd_cookies.append("show flow-gate")
api.Trigger_AddCommand(req, client1.node_name, client1.workload_name,
"ls -al | grep video")
tc.cmd_cookies.append("After RTSP")
trig_resp = api.Trigger(req)
dest = trig_resp.commands[2].stdout.find("Transport: RTP/AVP;multicast;destination=")
dest += 41
ip = trig_resp.commands[2].stdout[dest:dest+35]
end = ip.find(";")
req2 = api.Trigger_CreateExecuteCommandsRequest(serial = True)
api.Trigger_AddCommand(req2, client2.node_name, client2.workload_name,
"ip route add 224.0.0.0/4 dev %s"%(client2.interface), background = True)
tc.cmd_cookies.append("ip route client2")
api.Trigger_AddCommand(req2, client2.node_name, client2.workload_name,
"sed -i 's/geteuid/getppid/' /usr/bin/vlc && cvlc -vvv rtp://%s:8888 --start-time=00 --run-time=5" % ip[0:end])
tc.cmd_cookies.append("Run RTP client2")
api.Trigger_AddNaplesCommand(req2, naples.node_name,
"/nic/bin/halctl show session --srcip %s "%(client2.ip_address))
tc.cmd_cookies.append("show session RTP")
trig_resp2 = api.Trigger(req2)
term_resp2 = api.Trigger_TerminateAllCommands(trig_resp2)
tc.resp2 = api.Trigger_AggregateCommandsResponse(trig_resp2, term_resp2)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
tc.resp = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
ForceReleasePort("554/tcp", server)
ForceReleasePort("554/tcp", client1)
ForceReleasePort("554/tcp", client2)
return api.types.status.SUCCESS
def Trigger(tc):
pairs = api.GetLocalWorkloadPairs()
server = pairs[0][0]
client = pairs[0][1]
tc.cmd_cookies = []
naples = server
if not server.IsNaples():
naples = client
if not client.IsNaples():
return api.types.status.SUCCESS
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
tc.cmd_descr = "Server: %s(%s) <--> Client: %s(%s)" %\
(server.workload_name, server.ip_address, client.workload_name, client.ip_address)
api.Logger.info("Starting MSRPC test from %s" % (tc.cmd_descr))
api.Trigger_AddCommand(req,
server.node_name,
server.workload_name,
"tcpdump -nni %s > out.txt" % (server.interface),
background=True)
tc.cmd_cookies.append("tcpdump")
api.Trigger_AddCommand(req,
client.node_name,
client.workload_name,
"tcpdump -nni %s > out.txt" % (client.interface),
background=True)
tc.cmd_cookies.append("tcpdump")
api.Trigger_AddCommand(req,
server.node_name,
server.workload_name,
"sudo nc -l %s" % (MSRPC_PORT),
background=True)
tc.cmd_cookies.append("netcat start-server")
client_port = api.AllocateTcpPort()
api.Trigger_AddCommand(req,
client.node_name,
client.workload_name,
"sudo nc %s %s -p %s" %
(server.ip_address, MSRPC_PORT, client_port),
background=True)
tc.cmd_cookies.append("netcat start-client")
msrpcscript = dir_path + '/' + "msrpcscapy.py"
resp = api.CopyToWorkload(server.node_name, server.workload_name,
[msrpcscript], 'msrpcdir')
if resp is None:
return api.types.status.SUCCESS
resp = api.CopyToWorkload(client.node_name, client.workload_name,
[msrpcscript], 'msrpcdir')
if resp is None:
return api.types.status.SUCCESS
api.Trigger_AddNaplesCommand(
req, naples.node_name,
"/nic/bin/halctl show session --dstport 135 --yaml")
tc.cmd_cookies.append("show session yaml")
sesssetup = api.Trigger(req)
cmd = sesssetup.commands[-1]
api.PrintCommandResults(cmd)
tc.pre_ctrckinf = get_conntrackinfo(cmd)
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
msrpcpcap = dir_path + '/' + "msrpc_first_bind.pcap"
pkts = rdpcap(msrpcpcap)
clientidx = 0
serveridx = 0
client_ack = tc.pre_ctrckinf.i_tcpacknum
server_ack = tc.pre_ctrckinf.r_tcpacknum
filename = None
for pkt in pkts:
node = client.node_name
workload = client.workload_name
if pkt[IP].src == "172.31.9.1":
filename = ("msrpcscapy" + "%s" + ".pcap") % (clientidx)
msrpcscapy = dir_path + '/' + filename
pkt[Ether].src = client.mac_address
pkt[IP].src = client.ip_address
pkt[Ether].dst = server.mac_address
pkt[IP].dst = server.ip_address
pkt[TCP].sport = client_port
pkt[TCP].dport = 135
if clientidx == 0:
client_start_seq = pkt[TCP].seq
client_start_ack = pkt[TCP].ack
pkt[TCP].seq = tc.pre_ctrckinf.i_tcpseqnum + (pkt[TCP].seq -
client_start_seq)
pkt[TCP].ack = client_ack
server_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1
clientidx += 1
else:
filename = ("msrpcscapy" + "%s" + ".pcap") % (serveridx)
msrpcscapy = dir_path + '/' + filename
pkt[Ether].src = server.mac_address
pkt[IP].src = server.ip_address
pkt[Ether].dst = client.mac_address
pkt[IP].dst = client.ip_address
node = server.node_name
workload = server.workload_name
pkt[TCP].dport = client_port
pkt[TCP].sport = 135
if serveridx == 0:
server_start_seq = pkt[TCP].seq
server_start_ack = pkt[TCP].ack
pkt[TCP].seq = tc.pre_ctrckinf.r_tcpseqnum + (pkt[TCP].seq -
server_start_seq)
pkt[TCP].ack = server_ack
client_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1
serveridx += 1
del pkt[IP].chksum
del pkt[TCP].chksum
a = pkt.show(dump=True)
print(a)
wrpcap(msrpcscapy, pkt)
resp = api.CopyToWorkload(node, workload, [msrpcscapy], 'msrpcdir')
if resp is None:
continue
api.Trigger_AddCommand(
req, node, workload,
"sh -c 'cd msrpcdir && chmod +x msrpcscapy.py && ./msrpcscapy.py %s'"
% (filename))
tc.cmd_cookies.append("running #%s on node %s workload %s" %
(filename, node, workload))
os.remove(msrpcscapy)
api.Trigger_AddNaplesCommand(
req, naples.node_name,
"/nic/bin/halctl show session --dstport 135 --yaml")
tc.cmd_cookies.append("show session yaml")
firstbind = api.Trigger(req)
cmd = firstbind.commands[-1]
api.PrintCommandResults(cmd)
tc.post_ctrckinf = get_conntrackinfo(cmd)
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
msrpcpcap = dir_path + '/' + "msrpc_second_bind.pcap"
pkts = rdpcap(msrpcpcap)
client_ack = tc.post_ctrckinf.i_tcpacknum
server_ack = tc.post_ctrckinf.r_tcpacknum
clientidx = 0
serveridx = 0
filename = None
for pkt in pkts:
node = client.node_name
workload = client.workload_name
if pkt[IP].src == "172.31.9.1":
filename = ("msrpcscapy" + "%s" + ".pcap") % (clientidx)
msrpcscapy = dir_path + '/' + filename
pkt[Ether].src = client.mac_address
pkt[IP].src = client.ip_address
pkt[Ether].dst = server.mac_address
pkt[IP].dst = server.ip_address
pkt[TCP].sport = client_port
pkt[TCP].dport = 135
if clientidx == 0:
client_start_seq = pkt[TCP].seq
client_start_ack = pkt[TCP].ack
pkt[TCP].seq = tc.post_ctrckinf.i_tcpseqnum + (pkt[TCP].seq -
client_start_seq)
pkt[TCP].ack = client_ack
server_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1
clientidx += 1
else:
filename = ("msrpcscapy" + "%s" + ".pcap") % (serveridx)
msrpcscapy = dir_path + '/' + filename
pkt[Ether].src = server.mac_address
pkt[IP].src = server.ip_address
pkt[Ether].dst = client.mac_address
pkt[IP].dst = client.ip_address
node = server.node_name
workload = server.workload_name
pkt[TCP].dport = client_port
pkt[TCP].sport = 135
if serveridx == 0:
server_start_seq = pkt[TCP].seq
server_start_ack = pkt[TCP].ack
pkt[TCP].seq = tc.post_ctrckinf.r_tcpseqnum + (pkt[TCP].seq -
server_start_seq)
pkt[TCP].ack = server_ack
client_ack = pkt[TCP].seq + len(pkt[TCP].payload) + 1
serveridx += 1
del pkt[IP].chksum
del pkt[TCP].chksum
a = pkt.show(dump=True)
print(a)
wrpcap(msrpcscapy, pkt)
resp = api.CopyToWorkload(node, workload, [msrpcscapy], 'msrpcdir')
if resp is None:
continue
api.Trigger_AddCommand(
req, node, workload,
"sh -c 'cd msrpcdir && chmod +x msrpcscapy.py && ./msrpcscapy.py %s'"
% (filename))
tc.cmd_cookies.append("running #%s on node %s workload %s" %
(filename, node, workload))
os.remove(msrpcscapy)
api.Trigger_AddCommand(req,
server.node_name,
server.workload_name,
"sudo nc -l 49134",
background=True)
tc.cmd_cookies.append("msrpc start-server")
api.Trigger_AddCommand(req,
client.node_name,
client.workload_name,
"sudo nc %s 49134 -p 59374" % (server.ip_address),
background=True)
tc.cmd_cookies.append("msrpc start-client")
# Add Naples command validation
#api.Trigger_AddNaplesCommand(req, naples.node_name,
# "/nic/bin/halctl show security flow-gate | grep MSRPC")
#tc.cmd_cookies.append("show security flow-gate")
api.Trigger_AddNaplesCommand(req, naples.node_name,
"/nic/bin/halctl show session")
tc.cmd_cookies.append("show session")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
tc.resp2 = api.Trigger_AggregateCommandsResponse(trig_resp, term_resp)
term_resp = api.Trigger_TerminateAllCommands(firstbind)
tc.resp1 = api.Trigger_AggregateCommandsResponse(firstbind, term_resp)
term_resp = api.Trigger_TerminateAllCommands(sesssetup)
tc.resp = api.Trigger_AggregateCommandsResponse(sesssetup, term_resp)
#GetTcpdumpData(client)
#GetTcpdumpData(server)
return api.types.status.SUCCESS
def SetupFTPServer(node,
workload,
promiscous=False,
bind_fail=False,
listen_port=FTP_STANDARD_PORT,
restart=True):
ftpdata = dir_path + '/' + "ftp_server.txt"
api.Logger.info("fullpath %s" % (ftpdata))
resp = api.CopyToWorkload(node, workload, [ftpdata], 'ftpdir')
if resp is None:
return None
if promiscous == True:
if bind_fail == True:
vsftpd_file = "lftp_vsftpd_bind_fail.conf"
vsftpd_conf = dir_path + '/' + "lftp_vsftpd_bind_fail.conf"
else:
vsftpd_file = "lftp_vsftpd.conf"
vsftpd_conf = dir_path + '/' + "lftp_vsftpd.conf"
else:
vsftpd_file = "vsftpd.conf"
vsftpd_conf = dir_path + '/' + "vsftpd.conf"
resp = api.CopyToWorkload(node, workload, [vsftpd_conf], 'ftpdir')
if resp is None:
return None
req = api.Trigger_CreateExecuteCommandsRequest(serial=True)
api.Trigger_AddCommand(
req, node, workload,
"cp ftpdir/%s /etc/vsftpd/vsftpd.conf" % (vsftpd_file))
if listen_port != FTP_STANDARD_PORT:
api.Trigger_AddCommand(
req, node, workload,
"echo \"listen_port=%d\" | tee -a /etc/vsftpd/vsftpd.conf" %
(listen_port))
api.Trigger_AddCommand(req, node, workload,
"useradd -m -c \"admin\" -s /bin/bash admin")
api.Trigger_AddCommand(req, node, workload,
"useradd -m -c \"admin1\" -s /bin/bash admin1")
api.Trigger_AddCommand(req, node, workload,
"echo \"admin\" | tee -a /etc/vsftpd.userlist")
api.Trigger_AddCommand(req, node, workload,
"echo \"admin1\" | tee -a /etc/vsftpd.userlist")
api.Trigger_AddCommand(req, node, workload,
"echo \"linuxpassword\" | passwd --stdin admin")
api.Trigger_AddCommand(req, node, workload,
"echo \"docker\" | passwd --stdin admin1")
api.Trigger_AddCommand(req, node, workload,
"echo \"docker\" | passwd --stdin admin1")
api.Trigger_AddCommand(
req, node, workload,
"mkdir /home/admin/ftp && mv ftpdir/ftp_server.txt /home/admin/ftp")
api.Trigger_AddCommand(
req, node, workload,
"touch /home/admin/ftp/ftp_client.txt && chmod 666 /home/admin/ftp/ftp_client.txt"
)
if restart == True:
api.Trigger_AddCommand(req, node, workload, "systemctl stop vsftpd")
api.Trigger_AddCommand(req, node, workload, "systemctl start vsftpd")
api.Trigger_AddCommand(req, node, workload, "systemctl enable vsftpd")
trig_resp = api.Trigger(req)
term_resp = api.Trigger_TerminateAllCommands(trig_resp)
for cmd in trig_resp.commands:
api.PrintCommandResults(cmd)
return api.types.status.SUCCESS
