def run(self):
if self.run_time > 0:
print "Running Project for roughly (runtime + 5) = " + str(
self.run_time + 5) + " secs ..."
start_time = time.time()
while 1:
if time.time() - start_time >= self.run_time + 5.0:
break
else:
recv_msg = ''
dummy_id, recv_msg = self.sharedBufferArray.read(
"cmd-channel-buffer")
if len(recv_msg) != 0:
if recv_msg == "START":
self.disable_TCP_RST()
if recv_msg == "END":
self.enable_TCP_RST()
sleep(0.05)
else:
print "Running Project forever. Press Ctrl-C to quit ..."
try:
while 1:
recv_msg = ''
dummy_id, recv_msg = self.sharedBufferArray.read(
"cmd-channel-buffer")
if len(recv_msg) != 0:
if recv_msg == "START":
self.disable_TCP_RST()
if recv_msg == "END":
self.enable_TCP_RST()
sleep(0.05)
except KeyboardInterrupt:
print "Interrupted ..."
def disable_TCP_RST(self):
for i in xrange(len(self.network_configuration.roles)):
mininet_host = self.network_configuration.mininet_obj.hosts[i]
self.send_cmd_to_node(mininet_host.name,"sudo iptables -I OUTPUT -p tcp --tcp-flags RST RST -j DROP")
sleep(1)
print "Attack Orchestrator: DISABLED TCP RST"
def main():
# 1. Extend IDataObserver and IStackObserver
# 2. Add a Physical Layer (TCP Client) to the StackManager
# 3. Create a MasterConfig.
# 4. Add a Master Stack to the StackManager
# 5. Let the process run
print "Running the Slave"
stack_observer = StackObserver()
# observer = DataObserver()
acceptor = CmdAcceptor()
phys_layer_settings = opendnp3.PhysLayerSettings()
stack_manager = opendnp3.StackManager()
# stack_manager.AddTCPClient('tcpclient', phys_layer_settings, '127.0.0.1', 20000)
stack_manager.AddTCPServer('tcpserver', phys_layer_settings, '10.0.0.2',
20000)
#stack_manager.AddTCPServer('tcpserver', phys_layer_settings, '10.0.60.17', 20000)
# master_stack_config = opendnp3.MasterStackConfig()
slave_stack_config = opendnp3.SlaveStackConfig()
# master_stack_config.master.DoUnsolOnStartup = True
# master_stack_config.link.LocalAddr = 100
# master_stack_config.link.RemoteAddr = 1
slave_stack_config.link.LocalAddr = 1
slave_stack_config.link.RemoteAddr = 100
# master_stack_config.link.useConfirms = True
# set the stack observer callback to our Python-extended class
# master_stack_config.master.mpObserver = stack_observer
slave_stack_config.slave.mpObserver = stack_observer
# the integrity rate is the # of milliseconds between integrity scans
#master_stack_config.master.IntegrityRate = 1000
# The third argument needs to be a log FilterLevel. The Python
# API does not have access to this enum, but it can be "fed" to
# the AddMaster method because the PhysLayerSettings LogLevel
# member is a FilterLevel enum.
# command_acceptor = stack_manager.AddMaster('tcpclient', 'master', phys_layer_settings.LogLevel, observer, master_stack_config)
command_acceptor = stack_manager.AddSlave('tcpserver', 'slave',
phys_layer_settings.LogLevel,
acceptor, slave_stack_config)
# Need to wait because the polling is now occurring on its own
# thread. If we exited immediately, the callbacks would never
# be called.
sleep(2)
print('Binaries: %d' % (len(binary_list)))
print('Analogs: %d' % (len(analog_list)))
print('Counters: %d' % (len(counter_list)))
print('ControlStatus: %d' % (len(controlstatus_list)))
print('Setpointstatus: %d' % (len(setpointstatus_list)))
while (True):
sleep(60)
def main(hostID, netCfgFile, logFile, runTime, projectName, isControlHost):
hostIPMap, powerSimIdMap = extractIPMapping(netCfgFile)
log = logger.Logger(logFile, "Host" + str(hostID) + ": ")
sharedBufferArray = shared_buffer_array()
if isControlHost == True:
hostIPCLayer = __import__(
"projects." + str(projectName) + ".hostControlLayer", globals(),
locals(), ['hostControlLayer'], -1)
hostIPCLayer = hostIPCLayer.hostControlLayer
#hostAttackLayer = __import__("basicHostAttackLayer", globals(), locals(), ['basicHostAttackLayer'], -1)
#hostAttackLayer = hostAttackLayer.basicHostAttackLayer
hostAttackLayer = __import__(
"projects." + str(projectName) + ".hostAttackLayer", globals(),
locals(), ['hostAttackLayer'], -1)
hostAttackLayer = hostAttackLayer.hostAttackLayer
else:
hostIPCLayer = __import__("basicHostIPCLayer", globals(), locals(),
['basicHostIPCLayer'], -1)
hostIPCLayer = hostIPCLayer.basicHostIPCLayer
hostAttackLayer = __import__(
"projects." + str(projectName) + ".hostAttackLayer", globals(),
locals(), ['hostAttackLayer'], -1)
hostAttackLayer = hostAttackLayer.hostAttackLayer
IPCLayer = hostIPCLayer(hostID, logFile, sharedBufferArray)
IPCLayer.setPowerSimIdMap(powerSimIdMap)
NetLayer = basicNetworkServiceLayer(hostID, logFile, hostIPMap)
AttackLayer = hostAttackLayer(hostID, logFile, IPCLayer, NetLayer,
sharedBufferArray)
IPCLayer.setAttackLayer(AttackLayer)
NetLayer.setAttackLayer(AttackLayer)
assert (IPCLayer != None and NetLayer != None and AttackLayer != None)
NetLayer.start()
AttackLayer.start()
IPCLayer.start()
if runTime != 0: # dont run forever
sleep(runTime)
IPCLayer.cancelThread()
AttackLayer.cancelThread()
NetLayer.cancelThread()
else: # run forever
while True:
sleep(1)
IPCLayer.join()
AttackLayer.join()
NetLayer.join()
print "Shutting Down Host ", hostID
def onRxPktFromAttackLayer(self, pkt):
ret = 0
self.log.info("Relaying pkt: " + str(pkt) + " to core")
while ret <= 0:
ret = self.sharedBufferArray.write(self.sharedBufName, pkt,
PROXY_NODE_ID)
sleep(0.05)
# print "Return val = ", ret
self.log.info("Relayed pkt: " + str(pkt) + " to core")
def run(self):
while True:
self.controlLayer.stoppingLock.acquire()
if self.controlLayer.stopping:
self.controlLayer.stoppingLock.release()
break
self.controlLayer.stoppingLock.release()
u = np.dot(self.Cpi, self.alpha *
(self.vp0 - self.controlLayer.vp)).A1 # 1-d base array
u *= -1
self.vg = np.array(self.vg + u)
for i in range(GEN_NO):
busnum, gid, voltsp = GEN_ID[i][0], GEN_ID[i][1], self.vg[i]
#self.controlLayer.txPktToPowerSim("%d;%d"%(busnum,gid), str(voltsp))
# self.controlLayer.txPktToPowerSim("2","HelloWorld!")
sleep(0.5)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--input_params_file_path",
dest="input_params_file_path")
print "Started emulation driver ..."
sys.stdout.flush()
args = parser.parse_args()
with open(args.input_params_file_path) as f:
input_params = json.load(f)
d = EmulationDriver(input_params)
print "Waiting for START command ... buf = ", str(
d.driver_id) + "main-cmd-channel-buffer"
sys.stdout.flush()
recv_msg = ''
while "START" not in recv_msg:
recv_msg = ''
dummy_id, recv_msg = d.sharedBufferArray.read(
str(d.driver_id) + "main-cmd-channel-buffer")
print "Triggered emulation driver at ", str(datetime.now())
sys.stdout.flush()
d.trigger()
print "Waiting for exit command at ", str(datetime.now())
sys.stdout.flush()
recv_msg = ''
i = 1
while "EXIT" not in recv_msg:
recv_msg = ''
print "Checking for EXIT for the ", i, " time at: ", str(
datetime.now())
sys.stdout.flush()
i = i + 1
sleep(1)
dummy_id, recv_msg = d.sharedBufferArray.read(
str(d.driver_id) + "main-cmd-channel-buffer")
print "Shutting down driver ..."
sys.stdout.flush()
def trigger(self):
if self.type == TRAFFIC_FLOW_ONE_SHOT:
sleep(int(self.offset))
print "Started command at ", str(datetime.now())
sys.stdout.flush()
#os.system(self.cmd + " &")
try:
cmd_list = self.cmd.split(' ')
print cmd_list
print self.cmd
sys.stdout.flush()
p = subprocess.Popen(cmd_list, shell=False)
except:
print "Error running command: ", sys.exec_info()[0]
elif self.type == TRAFFIC_FLOW_EXPONENTIAL:
pass
elif self.type == TRAFFIC_FLOW_PERIODIC:
pass
def main(netCfgFile, logFile, runTime, powerSimIP, controlCenterID):
hostIPMap, powerSimIdMap = extractIPMapping(netCfgFile)
hostIDList = hostIPMap.keys()
#print "HostID List = ", hostIDList
if controlCenterID == None:
controlCenterID = max(hostIDList)
IPCLayer = proxyIPCLayer(logFile, hostIDList)
IPCLayer.setControlCenterID(controlCenterID)
IPCLayer.setPowerSimIdMap(powerSimIdMap)
NetLayer = proxyNetworkServiceLayer(logFile, powerSimIP)
TransportLayer = proxyTransportLayer(logFile, IPCLayer, NetLayer)
assert (IPCLayer != None and NetLayer != None and TransportLayer != None)
IPCLayer.setTransportLayer(TransportLayer)
NetLayer.setTransportLayer(TransportLayer)
NetLayer.start()
TransportLayer.start()
IPCLayer.start()
if runTime != 0: # dont run forever
sleep(runTime)
IPCLayer.cancelThread()
TransportLayer.cancelThread()
NetLayer.cancelThread()
else: # run forever
while True:
sleep(1)
IPCLayer.join()
TransportLayer.join()
NetLayer.join()
def init_shared_buffers(hostID,runTime,sharedBufferArray):
result = sharedBufferArray.open(bufName="h" + str(hostID) + "main-cmd-channel-buffer",isProxy=False)
if result == BUF_NOT_INITIALIZED or result == FAILURE:
print "Cmd channel buffer open failed!. Not starting any threads !"
sys.stdout.flush()
if runTime == 0 :
while True:
sleep(1)
start_time = time.time()
sleep(runTime + 2)
while time.time() < start_time + float(runTime):
sleep(1)
sys.exit(0)
def init_shared_buffers(self, run_time):
result = self.sharedBufferArray.open(bufName=str(self.driver_id) + "main-cmd-channel-buffer", isProxy=False)
if result == BUF_NOT_INITIALIZED or result == FAILURE:
print "Cmd channel buffer open failed !"
sys.stdout.flush()
if run_time == 0:
while True:
sleep(1)
start_time = time.time()
sleep(run_time + 2)
while time.time() < start_time + float(run_time):
sleep(1)
sys.exit(0)
print "Cmd channel buffer open succeeded !"
sys.stdout.flush()
def run(self):
if self.run_time > 0:
print "########################################################################"
print ""
print " Starting Experiment. Run time = ", self.run_time
print ""
print "########################################################################"
# Before starting
while True:
recv_msg = self.recv_from_attack_orchestrator()
if recv_msg == "PCAPS-LOADED":
break
sleep(0.5)
print "Attack Orchestrator: LOADED ALL PCAPS"
if self.enable_timekeeper == 1 :
start_time = get_current_virtual_time_pid(self.switch_pids[0])
else:
start_time = time.time()
self.trigger_all_processes("START")
sys.stdout.flush()
prev_time = start_time
run_time = self.run_time
n_rounds_progressed = 0
#progress for 20ms which is the smallest timestep in powerworld
if self.timeslice > 20*NS_PER_MS :
n_rounds = 1
else:
n_rounds = int(20*NS_PER_MS/self.timeslice)
k = 0
while True:
if self.enable_timekeeper == 1 :
curr_time = get_current_virtual_time_pid(self.switch_pids[0])
#print "N rounds progressed = ", n_rounds_progressed, " Time =", curr_time
sys.stdout.flush()
progress_exp_cbe(n_rounds)
n_rounds_progressed += n_rounds
if k >= run_time :
sys.stdout.flush()
break
else :
if curr_time - prev_time >= 1.0 :
k = k + int(curr_time - prev_time)
print k," secs of virtual time elapsed. Local time = ", datetime.now()
sys.stdout.flush()
prev_time = curr_time
else :
if k >= run_time :
break
k= k + 1
print k," secs of real time elapsed"
# sleep until runtime expires
time.sleep(0.5)
recv_msg = self.recv_from_attack_orchestrator()
if recv_msg == "START-REPLAY":
self.disable_TCP_RST()
self.send_to_attack_orchestrator("ACK")
if recv_msg == "END-REPLAY":
self.enable_TCP_RST()
self.send_to_attack_orchestrator("ACK")
time.sleep(0.5)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--slave_ip',
dest="slave_ip",
help='IP Address of the slave node.',
required=True)
parser.add_argument('--life_time',
dest="life_time",
help='Time after which slave must die!',
required=True)
parser.add_argument('--vt',
dest="vt",
help='Is virtual time enabled',
required=True)
args = parser.parse_args()
# 1. Extend IDataObserver and IStackObserver
# 2. Add a Physical Layer (TCP Client) to the StackManager
# 3. Create a MasterConfig.
# 4. Add a Master Stack to the StackManager
# 5. Let the process run
print "Running the Slave. Pid = ", os.getpid()
stack_observer = StackObserver()
# observer = DataObserver()
acceptor = CmdAcceptor()
phys_layer_settings = opendnp3.PhysLayerSettings()
stack_manager = opendnp3.StackManager()
stack_manager.AddTCPServer('tcpserver', phys_layer_settings, args.slave_ip,
20000)
# master_stack_config = opendnp3.MasterStackConfig()
slave_stack_config = opendnp3.SlaveStackConfig()
# master_stack_config.master.DoUnsolOnStartup = True
# master_stack_config.link.LocalAddr = 100
# master_stack_config.link.RemoteAddr = 1
slave_stack_config.link.LocalAddr = 1
slave_stack_config.link.RemoteAddr = 100
# master_stack_config.link.useConfirms = True
# set the stack observer callback to our Python-extended class
# master_stack_config.master.mpObserver = stack_observer
slave_stack_config.slave.mpObserver = stack_observer
# the integrity rate is the # of milliseconds between integrity scans
#master_stack_config.master.IntegrityRate = 1000
# The third argument needs to be a log FilterLevel. The Python
# API does not have access to this enum, but it can be "fed" to
# the AddMaster method because the PhysLayerSettings LogLevel
# member is a FilterLevel enum.
# command_acceptor = stack_manager.AddMaster('tcpclient', 'master', phys_layer_settings.LogLevel, observer, master_stack_config)
command_acceptor = stack_manager.AddSlave('tcpserver', 'slave',
phys_layer_settings.LogLevel,
acceptor, slave_stack_config)
# Need to wait because the polling is now occurring on its own
# thread. If we exited immediately, the callbacks would never
# be called.
sleep(2)
print('Binaries: %d' % (len(binary_list)))
print('Analogs: %d' % (len(analog_list)))
print('Counters: %d' % (len(counter_list)))
print('ControlStatus: %d' % (len(controlstatus_list)))
print('Setpointstatus: %d' % (len(setpointstatus_list)))
sys.stdout.flush()
if int(args.vt) == 0:
for tid in get_thread_ids(os.getpid()):
set_def_cpu_affinity(tid, "2-3")
while (True):
sleep(int(args.life_time) - 2)
break
def trigger_replay(self, pcap_file_path):
print "Replaying PCAP file ", pcap_file_path, "at time:", str(datetime.now())
sys.stdout.flush()
send_events, recv_events = self.loaded_pcaps[pcap_file_path]
curr_send_idx = 0
curr_send_event = None
payload = None
dst_ip = None
send_sleep_time = 0.0
curr_rtt = self.rtt[pcap_file_path]
while True:
if curr_send_event == None :
if curr_send_idx < len(send_events):
curr_send_event = send_events[curr_send_idx]
payload = binascii.unhexlify(str(curr_send_event[0]))
dst_ip = curr_send_event[1]
n_required_recv_events = curr_send_event[2]
send_sleep_time = float(curr_send_event[3]) - curr_rtt
print "Sending Replay Event: Dst = ", dst_ip, " N Req Recv events = ", n_required_recv_events
sys.stdout.flush()
if curr_send_event == None:
break
if n_required_recv_events == 0:
if send_sleep_time > 0 :
sleep(send_sleep_time)
self.raw_tx_sock.sendto(payload, (dst_ip, 0))
curr_send_event = None
curr_send_idx = curr_send_idx + 1
else:
try:
raw_pkt = self.raw_rx_sock.recv(MAXPKTSIZE)
except socket.error as e:
raw_pkt = None
continue
assert len(raw_pkt) != 0
raw_ip_pkt = get_raw_ip_pkt(raw_pkt)
ip_payload = binascii.hexlify(raw_ip_pkt.__str__( ))
try:
if len(recv_events[ip_payload]) > 0:
first_send_window = recv_events[ip_payload][0]
assert (first_send_window >= curr_send_idx)
if first_send_window == curr_send_idx :
n_required_recv_events = n_required_recv_events - 1
else:
recv_events[ip_payload].pop(0)
send_events[first_send_window] = [send_events[first_send_window][0], send_events[first_send_window][1], send_events[first_send_window][2] - 1]
else:
pass
except KeyError as e:
pass
self.raw_rx_sock.close()
self.raw_tx_sock.close()
print "curr_send_idx:", curr_send_idx
print "Closed socket, signalling End of Replay Stage at ", str(datetime.now())
sys.stdout.flush()
self.send_command_message("DONE")
def main(hostID,netCfgFile,logFile,runTime,projectName,isControlHost) :
hostIPMap,powerSimIdMap = extractIPMapping(netCfgFile)
log = logger.Logger(logFile,"Host" + str(hostID) + ": ")
sharedBufferArray = shared_buffer_array()
if isControlHost == True :
hostIPCLayer = __import__("projects." + str(projectName) + ".hostControlLayer", globals(), locals(), ['hostControlLayer'], -1)
hostIPCLayer = hostIPCLayer.hostControlLayer
hostAttackLayer = __import__("projects." + str(projectName) + ".hostAttackLayer", globals(), locals(),['hostAttackLayer'], -1)
hostAttackLayer = hostAttackLayer.hostAttackLayer
else:
hostIPCLayer = __import__("basicHostIPCLayer", globals(), locals(), ['basicHostIPCLayer'], -1)
hostIPCLayer = hostIPCLayer.basicHostIPCLayer
hostAttackLayer = __import__("projects." + str(projectName) + ".hostAttackLayer", globals(), locals(), ['hostAttackLayer'], -1)
hostAttackLayer = hostAttackLayer.hostAttackLayer
print "Initializing main channel buffer"
sys.stdout.flush()
init_shared_buffers(hostID, runTime,sharedBufferArray)
print "Cmd channel buffer open suceeded !"
sys.stdout.flush()
IPCLayer = hostIPCLayer(hostID,logFile,sharedBufferArray)
IPCLayer.setPowerSimIdMap(powerSimIdMap)
NetLayer = basicNetworkServiceLayer(hostID,logFile,hostIPMap)
AttackLayer = hostAttackLayer(hostID,logFile,IPCLayer,NetLayer,sharedBufferArray)
IPCLayer.setAttackLayer(AttackLayer)
NetLayer.setAttackLayer(AttackLayer)
assert(IPCLayer != None and NetLayer != None and AttackLayer != None)
print "Waiting for start command ... buf = ", "h" + str(hostID) + "main-cmd-channel-buffer"
sys.stdout.flush()
recv_msg = ''
while "START" not in recv_msg:
recv_msg = ''
dummy_id, recv_msg = sharedBufferArray.read("h" + str(hostID) + "main-cmd-channel-buffer")
NetLayer.start()
AttackLayer.start()
IPCLayer.start()
print "Signalled Start threads at ", str(datetime.now())
sys.stdout.flush()
recv_msg = ''
print "Waiting for exit command ..."
sys.stdout.flush()
i = 1
while "EXIT" not in recv_msg:
recv_msg = ''
print "Checking for EXIT for the ", i ," time at: ", str(datetime.now())
i = i + 1
sys.stdout.flush()
sleep(1)
dummy_id, recv_msg = sharedBufferArray.read("h" + str(hostID) + "main-cmd-channel-buffer")
IPCLayer.cancelThread()
AttackLayer.cancelThread()
NetLayer.cancelThread()
#IPCLayer.join()
#AttackLayer.join()
#NetLayer.join()
print "Shutting Down Host ", hostID
sys.stdout.flush()
