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()