class DroneDaemon:
def __init__(self, name, port):
signal.signal(signal.SIGINT, self.SIGINT)
self.port = port
self.name = name
self.logutil = KBLogUtil(self.name, 'Daemon', os.getpid())
self.interfaces = {}
self.plugins = {}
self.pid = os.getpid()
def SIGINT(self, s, f):
#TODO find a cleaner way to do only handle signals from the parent process ?
if self.pid == os.getpid():
self.logutil.log("SIGINT")
signal.signal(signal.SIGINT, signal.SIG_IGN)
self.shutdown = True
self.shutdownDaemon()
def handleException(self):
etb = traceback.format_exc()
print(etb)
self.logutil.trace(etb)
return json.dumps({'success':False, 'data':str(etb)})
def runChecks(self):
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', self.port))
s.close()
except socket.error:
print("Error Starting Drone:")
print("Socket TCP {0} already bound".format(self.port))
sys.exit()
def startDaemon(self):
self.runChecks()
self.logutil.writePID()
self.logutil.startlog()
self.logutil.log("Starting DroneDaemon")
self.enumerateInterfaces()
self.startRestServer()
def shutdownDaemon(self):
self.logutil.log('Initiating shutdown')
self.stopRunningPlugins()
self.logutil.log('Completed shutdown')
self.logutil.cleanup()
# TODO: verify that all subprocess have been terminated
sys.exit()
def startRestServer(self):
self.logutil.log('Starting REST Server on port {0}'.format(self.port))
app = flask.Flask(__name__)
app.add_url_rule('/task', None, self.processTaskRequest, methods=['POST'])
app.add_url_rule('/detask', None, self.processDetaskRequest, methods=['POST'])
app.add_url_rule('/status', None, self.processStatusGetRequest, methods=['POST'])
app.run(port=self.port, threaded=True)
def handleUnknownException(self):
etb = traceback.format_exc()
self.logutil.trace(etb)
return self.formatResult(error=ec.ERROR_UnknownException, data=str(etb))
def formatResponse(self, error, data):
return json.dumps({'error':error, 'data':data})
def processTaskRequest(self):
self.logutil.log('Processing Task Request')
try:
data = json.loads(flask.request.data)
uuid = data.get('uuid')
plugin = data.get('plugin')
channel = data.get('channel')
parameters = data.get('parameters')
self.logutil.log('Processing Task Request: {0} ({1})'.format(uuid, plugin))
(error,data) = self.taskPlugin(plugin, channel, uuid, parameters)
return self.formatResponse(error,data)
except Exception:
return self.handleUnknownException()
def processDetaskRequest(self):
self.logutil.log('Processing Detask Request')
try:
data = json.loads(flask.request.data)
uuid = data.get('uuid')
(error,data) = self.detaskPlugin(uuid)
return self.formatResponse(error,None)
except Exception:
return self.handleUnknownException()
def processStatusGetRequest(self):
self.logutil.log('Processing Status Get Request')
try:
status = {}
status['config'] = {}
status['config']['pid'] = self.pid
status['config']['name'] = self.name
status['interfaces'] = list((interface.info() for interface in self.interfaces.values()))
status['plugins'] = list((plugin.info() for plugin in self.plugins.values()))
return self.formatResponse(None, status)
except Exception:
self.handleUnknownException()
def loadPluginClass(self, plugin):
if plugin == 'CapturePlugin':
return CapturePlugin
def taskPlugin(self, plugin, channel, uuid, parameters):
self.logutil.debug('Tasking Plugin ({0},{1})'.format(plugin,channel))
pluginObject = self.plugins.get((plugin,channel), None)
if pluginObject == None:
self.logutil.log('No Instance of ({0},{1}) Found - Starting New one'.format(plugin, channel))
(error,data) = self.startPlugin(plugin,channel)
if error == None:
pluginObject = data
else:
return (error,data)
try:
self.logutil.log('Tasking Plugin: ({0}, ch.{1}) with Task {2}'.format(plugin, channel, uuid))
success = pluginObject.task(uuid, parameters)
if success == False:
error = ec.ERROR_DRONE_UnknownTaskingFailure
else:
error = None
return (error,None)
except Exception:
self.handleException()
def startPlugin(self, plugin, channel):
self.logutil.debug('Starting Plugin ({0},{1})'.format(plugin,channel))
try:
interface = self.getAvailableInterface()
if interface == None:
self.logutil.log('Failed to Start Plugin - No Avilable Interfaces')
error = ec.ERROR_DRONE_UnavailableInterface
return (error, None)
pluginClass = self.loadPluginClass(plugin)
if pluginClass == None:
self.logutil.log('Failed to Start Plugin - Plugin Module: {0} does not exist'.format(plugin))
error = ec.ERROR_DroneFailedToLoadPlugin
return (error,plugin)
self.logutil.log('Acquired Interface: {0}'.format(interface.device))
self.logutil.log('Loaded Plugin Class: {0}'.format(pluginClass))
pluginObject = pluginClass([interface], channel, self.name)
self.plugins[(plugin,channel)] = pluginObject
self.logutil.log('Successfully Started Plugin')
time.sleep(0.5)
error = None
data = pluginObject
return (error,data)
except Exception:
self.handleException()
def detaskPlugin(self, uuid):
self.logutil.log('Processing Detask Request for {0}'.format(uuid))
try:
for pluginKey,pluginObject in self.plugins.items():
for task_uuid in pluginObject.tasks.keys():
if task_uuid == uuid:
detask_success = pluginObject.detask(uuid)
if detask_success == False:
error = ec.ERROR_DroneUnknownDetaskingFailure
return (error,None)
time.sleep(2)
if pluginObject.active == False:
del(self.plugins[pluginKey])
self.logutil.log('Succesfully detasked {0} from {1}'.format(uuid, str(pluginObject.desc)))
return (None,None)
except Exception:
return self.handleException()
def stopRunningPlugins(self):
self.logutil.log('Stopping Running Plugins')
for plugin in self.plugins.values():
if plugin.active == True:
self.logutil.log("Stopping Plugin: {0}".format(plugin.desc))
plugin.shutdown()
if plugin.active:
print("had a problem shutting down plugin")
self.logutil.log('Running plugins have been terminated')
def getAvailableInterface(self):
for interface in self.interfaces.values():
if not interface.active:
return interface
return None
def enumerateInterfaces(self):
self.logutil.log("Enumerating Interfaces")
try:
for interface in kbutils.devlist():
device = interface[0]
description = interface[1]
self.logutil.log("Added new interface: {0}".format(device))
self.interfaces[device] = KBInterface(device)
except Exception:
self.handleUnknownException()
class WIDSDaemon:
def __init__(self, parameters=None, config=None):
signal.signal(signal.SIGINT, self.SIGINT)
self.config = WIDSConfig(parameters, config)
self.config.daemon_pid = os.getpid()
self.logutil = KBLogUtil(self.config.name, 'Daemon')
self.database = DatabaseHandler(self.config.name)
self.engine = None
self.module_store = {}
self.module_counter = 0
self.task_store = {}
self.task_counter = 0
self.drone_store = {}
self.drone_counter = 0
def SIGINT(self, s, f):
if self.config.daemon_pid == os.getpid():
self.logutil.log('SIGINT')
self.stopDaemon()
def startDaemon(self):
self.logutil.writePID()
self.logutil.startlog()
self.logutil.log('Starting Daemon')
self.loadDrones()
self.loadModules()
self.startServer()
def stopDaemon(self):
self.logutil.log('Initiating Shutdown')
self.unloadModules()
self.unloadDrones()
self.logutil.log('Successfull Shutdown')
self.logutil.cleanup()
sys.exit()
def loadDrones(self):
count = len(self.config.drones)
self.logutil.log('Loading Drones (Found {0} Drones in the Config)'.format(count))
for droneConfig in self.config.drones:
self.loadDrone(droneConfig)
def loadDrone(self, droneConfigDict):
try:
print(droneConfigDict)
drone_ip = str(droneConfigDict.get('ip', None))
drone_port = str(droneConfigDict.get('port', None))
if drone_ip == None or drone_port == None:
error = 'Error: Missing Parameter: "address"'
self.logutil.log(error)
return self.formatResponse(error, None)
else:
droneIndex = self.drone_counter
droneObject = DroneContainer(droneIndex, drone_ip, drone_port)
self.drone_store[droneIndex] = droneObject
self.drone_counter += 1
self.logutil.log('Loading Drone {0} - {1}:{2}'.format(droneIndex, drone_ip, drone_port))
return self.formatResponse(None, None)
except:
self.handleException()
def unloadDrones(self):
self.logutil.log('Unloading Drones')
self.logutil.log('Found {0} Active Drones'.format(len(self.drone_store)))
for i in range(len(self.drone_store)):
self.unloadDrone(i)
def unloadDrone(self, droneIndexInt):
try:
droneObject = self.drone_store.get(droneIndexInt, None)
if droneObject == None:
error = 'Error: Drone with Index {0} does not exist'.format(droneIndexInt)
self.logutil.log(error)
return self.formatResponse(False, error)
else:
droneObject.release()
self.logutil.log('Releasing Drone {0} - {1}:{2}'.format(droneIndexInt, droneObject.address, droneObject.port))
del(self.drone_store[droneIndexInt])
del(droneObject)
return self.formatResponse(True, None)
except:
self.handleException()
def taskDrone(self, taskConfigDict):
try:
droneIndexList = taskConfigDict.get('droneIndexList')
for droneIndexInt in droneIndexList:
droneObject = self.drone_store.get(droneIndexInt, None)
task_uuid = taskConfigDict.get('uuid', None)
task_plugin = taskConfigDict.get('plugin', None)
task_channel = taskConfigDict.get('channel', None)
task_parameters = taskConfigDict.get('parameters', None)
module_index = taskConfigDict.get('module_index', None)
if droneObject == None:
error = ec.ERROR_DRONE_InvalidDroneIndex
data = droneIndexInt
return (error,data)
if task_uuid == None:
error = ec.ERROR_DRONE_MissingDroneTaskParameter
data = 'uuid'
return (error, data)
if task_channel == None:
error = ec.ERROR_DRONE_MissingDroneTaskParameter
data = 'channel'
return (error, data)
if task_plugin == None:
error = ec.ERROR_MissingDroneTaskParameter
data = 'plugin'
return (error, data)
if task_parameters == None:
error = ec.ERROR_MissingDroneTaskParameter
data = 'parameters'
return (error, data)
(data,error) = droneObject.api.task(task_plugin, task_channel, task_uuid, task_parameters)
if error == None:
self.task_store[self.task_counter] = TaskContainer(self.task_counter, task_uuid, task_plugin, task_channel, task_parameters, droneIndexList, module_index)
self.task_counter += 1
return (data,error)
except:
self.handleException()
def detaskDrone(self, droneIndexList, task_uuid):
try:
for int_DroneIndex in droneIndexList:
droneObject = self.drone_store.get(int_DroneIndex, None)
droneObject.api.detask(task_uuid)
except Exception:
self.handleException()
def loadModules(self):
count = len(self.config.modules)
self.logutil.log('Loading Modules (Found {0} Modules in the Config)'.format(count))
for moduleConfigDict in self.config.modules:
self.loadModule(moduleConfigDict)
pass
def unloadModules(self):
self.logutil.log('Unloading Modules')
self.logutil.log('Found {0} Active Modules'.format(len(self.module_store)))
for i in range(len(self.module_store)):
self.unloadModule(i)
def loadModuleClass(self, module):
if module == 'BeaconRequestMonitor' : return BeaconRequestMonitor
if module == 'DisassociationStormMonitor' : return DisassociationStormMonitor
if module == 'DosAesCtrMonitor' : return DosAesCtrMonitor
def loadModule(self, moduleConfigDict):
self.logutil.debug('Loading Module: {0}'.format(moduleConfigDict))
try:
moduleName = moduleConfigDict.get('name', None)
moduleSettings = moduleConfigDict.get('settings', None)
moduleClass = self.loadModuleClass(moduleName)
if moduleName == None:
error = ec.ERROR_WIDS_MissingModuleParameter
data = 'name'
self.logutil.log('Failed to Load Module - Missing Parameter: "name" in {0}\n'.format(moduleConfigDict))
return self.formatResponse(error,data)
elif moduleSettings == None:
error = ec.ERROR_WIDS_MissingModuleParameter
data = 'settings'
self.logutil.log('Failed to Load Module - Missing Parameter: "settings" in {0}\n'.format(moduleConfigDict))
return self.formatResponse(error,data)
elif moduleClass == None:
error = ec.ERROR_WIDS_MissingModuleClass
data = moduleName
self.logutil.log('Failed to Load Module - Could not load class: {0}'.format(moduleName))
return self.formatResponse(error,data)
else:
moduleIndex = self.module_counter
moduleShutdownEvent = Event()
moduleSettings['module_index'] = moduleIndex
self.logutil.debug('Found module class: {0}'.format(moduleClass))
'''
(error,data) = moduleClass.validate_settings(moduleSettings)
if not error == None:
return self.formatResponse(error,data)
'''
moduleProcess = moduleClass(moduleSettings, self.config, moduleShutdownEvent)
moduleProcess.start()
moduleObject = ModuleContainer(moduleIndex, moduleName, moduleSettings, moduleProcess, moduleShutdownEvent)
self.module_store[moduleIndex] = moduleObject
self.module_counter += 1
self.logutil.log('Loading Module {0} - {1}'.format(moduleIndex, moduleObject.name))
return self.formatResponse(None, None)
except:
self.handleException()
def unloadModule(self, moduleIndexInt):
try:
moduleObject = self.module_store.get(moduleIndexInt, None)
if moduleObject == None:
error = 'Error: Module with Index {0} does not exist'.format(moduleIndexInt)
self.logutil.log(error)
return self.formatResponse(False, error)
else:
self.logutil.log('Unloading Module {0} ({1} - {2})'.format(moduleIndexInt, moduleObject.name, moduleObject.process.pid))
self.logutil.log('Detasking Module Tasks')
for taskObject in self.task_store.values():
if taskObject.module_index == moduleObject.index:
drones = taskObject.drones
uuid = taskObject.uuid
self.logutil.log('Removing Task {0} from Drones {1}'.format(uuid, drones))
self.detaskDrone(drones, uuid)
moduleObject.process.terminate()
moduleObject.process.join()
del(self.module_store[moduleIndexInt])
del(moduleObject)
return self.formatResponse(True, None)
except:
self.handleException()
def startServer(self):
self.logutil.log('Starting Server on port {0}'.format(self.config.server_port))
app = flask.Flask(__name__)
app.add_url_rule('/active', None, self.processActiveGetRequest, methods=['GET'] )
app.add_url_rule('/status', None, self.processStatusGetRequest, methods=['GET'] )
app.add_url_rule('/data/upload', None, self.processDataUploadRequest, methods=['POST'])
app.add_url_rule('/data/download', None, self.processDataDownloadRequest, methods=['POST'])
app.add_url_rule('/drone/task', None, self.processDroneTaskRequest, methods=['POST'])
app.add_url_rule('/drone/detask', None, self.processDroneDetaskRequest, methods=['POST'])
app.add_url_rule('/drone/add', None, self.processDroneAddRequest, methods=['POST'])
app.add_url_rule('/drone/delete', None, self.processDroneDeleteRequest, methods=['POST'])
app.add_url_rule('/alerts', None, self.processAlertGetRequest, methods=['POST'])
app.add_url_rule('/alerts/generate', None, self.processAlertGenerateRequest, methods=['POST'])
app.add_url_rule('/module/load', None, self.processModuleLoadRequest, methods=['POST'])
app.add_url_rule('/module/unload', None, self.processModuleUnloadRequest, methods=['POST'])
app.run(threaded=True, port=int(self.config.server_port))
def handleException(self):
etb = traceback.format_exc()
self.logutil.trace(etb)
return self.formatResponse(error=ec.ERROR_GENERAL_UnknownException, data=str(etb))
def formatResponse(self, error, data):
return json.dumps({'error':error, 'data':data})
def processActiveGetRequest(self):
self.logutil.debug('Processing Active Get Request')
return self.formatResponse(error=None, data=True)
def processDataUploadRequest(self):
self.logutil.debug('Processing Data Upload Request')
try:
data = json.loads(flask.request.data)
packetdata = data.get('pkt')
self.database.storePacket(packetdata)
return self.formatResponse(error=None, data=None)
except Exception:
return self.handleException()
def processDataDownloadRequest(self):
self.logutil.debug('Processing Data Upload Request')
try:
return self.formatResponse(error=None, data=None)
except Exception:
return self.handleException()
def processDroneTaskRequest(self):
self.logutil.debug('Processing Drone Task Request')
try:
request_data = json.loads(flask.request.data)
(error,data) = self.taskDrone(request_data)
return self.formatResponse(error,data)
except Exception:
return self.handleException()
def processDroneDetaskRequest(self):
self.logutil.debug('Processing Drone Detask Request')
try:
data = json.loads(flask.request.data)
return self.detaskDrone(data)
except Exception:
return self.handleException()
def processDroneAddRequest(self):
self.logutil.debug('Processing Drone Add Request')
try:
data = json.loads(flask.request.data)
return self.loadDrone(data)
except Exception:
return self.handleException()
def processDroneDeleteRequest(self):
self.logutil.debug('Processing Drone Delete Request')
try:
data = json.loads(flask.request.data)
drone_index = int(data.get('drone_index'))
return self.unloadDrone(drone_index)
except:
return self.handleException()
def processModuleLoadRequest(self):
self.logutil.debug('Processing Module Load Request')
try:
data = json.loads(flask.request.data)
return self.loadModule(data)
except:
return self.handleException()
def processModuleUnloadRequest(self):
self.logutil.debug('Processing Module Unload Request')
try:
data = json.loads(flask.request.data)
module_index = int(data.get('module_index'))
return self.unloadModule(module_index)
except:
return self.handleException()
def processAlertGenerateRequest(self):
self.logutil.debug('Processing Alert Generate Request')
try:
data = json.loads(flask.request.data)
alert_name = str(data.get('alert_name'))
self.database.storeAlert(alert_name)
return self.formatResponse(True, None)
except:
return self.handleException()
def processAlertGetRequest(self):
#self.logutil.debug('Processing Alert Request')
try:
alerts = []
for alert in self.database.session.query(Alert).all():
alerts.append('{0} - {1}'.format(microToDate(alert.datetime), alert.name))
return self.formatResponse(None, alerts)
except:
return self.handleException()
def processStatusGetRequest(self):
self.logutil.log('Processing Status Request')
try:
config = self.config.json()
modules = list((module.json() for module in self.module_store.values()))
tasks = list((task.json() for task in self.task_store.values()))
rules = list((rule.json() for rule in self.rule_store.values()))
drones = list((drone.json() for drone in self.drone_store.values()))
status = {'config':config, 'modules':modules, 'tasks':tasks, 'drones':drones, 'rules':rules}
return json.dumps({'success':True, 'data':status})
except:
return self.handleException()
class WIDSDaemon:
def __init__(self, parameters=None, config=None):
signal.signal(signal.SIGINT, self.SIGINT)
self.config = WIDSConfig(parameters, config)
self.config.daemon_pid = os.getpid()
self.logutil = KBLogUtil(self.config.name, 'Daemon')
self.database = DatabaseHandler(self.config.name)
self.engine = None
self.module_store = {}
self.module_counter = 0
self.task_store = {}
self.task_counter = 0
self.drone_store = {}
self.drone_counter = 0
def SIGINT(self, s, f):
if self.config.daemon_pid == os.getpid():
self.logutil.log('SIGINT')
self.stopDaemon()
def startDaemon(self):
self.logutil.writePID()
self.logutil.startlog()
self.logutil.log('Starting Daemon')
self.loadDrones()
self.loadModules()
self.startServer()
def stopDaemon(self):
self.logutil.log('Initiating Shutdown')
self.unloadModules()
self.unloadDrones()
self.logutil.log('Successfull Shutdown')
self.logutil.cleanup()
sys.exit()
def loadDrones(self):
count = len(self.config.drones)
self.logutil.log(
'Loading Drones (Found {0} Drones in the Config)'.format(count))
for droneConfig in self.config.drones:
self.loadDrone(droneConfig)
def loadDrone(self, droneConfigDict):
try:
print(droneConfigDict)
drone_ip = str(droneConfigDict.get('ip', None))
drone_port = str(droneConfigDict.get('port', None))
if drone_ip == None or drone_port == None:
error = 'Error: Missing Parameter: "address"'
self.logutil.log(error)
return self.formatResponse(error, None)
else:
droneIndex = self.drone_counter
droneObject = DroneContainer(droneIndex, drone_ip, drone_port)
self.drone_store[droneIndex] = droneObject
self.drone_counter += 1
self.logutil.log('Loading Drone {0} - {1}:{2}'.format(
droneIndex, drone_ip, drone_port))
return self.formatResponse(None, None)
except:
self.handleException()
def unloadDrones(self):
self.logutil.log('Unloading Drones')
self.logutil.log('Found {0} Active Drones'.format(len(
self.drone_store)))
for i in range(len(self.drone_store)):
self.unloadDrone(i)
def unloadDrone(self, droneIndexInt):
try:
droneObject = self.drone_store.get(droneIndexInt, None)
if droneObject == None:
error = 'Error: Drone with Index {0} does not exist'.format(
droneIndexInt)
self.logutil.log(error)
return self.formatResponse(False, error)
else:
droneObject.release()
self.logutil.log('Releasing Drone {0} - {1}:{2}'.format(
droneIndexInt, droneObject.address, droneObject.port))
del (self.drone_store[droneIndexInt])
del (droneObject)
return self.formatResponse(True, None)
except:
self.handleException()
def taskDrone(self, taskConfigDict):
try:
droneIndexList = taskConfigDict.get('droneIndexList')
for droneIndexInt in droneIndexList:
droneObject = self.drone_store.get(droneIndexInt, None)
task_uuid = taskConfigDict.get('uuid', None)
task_plugin = taskConfigDict.get('plugin', None)
task_channel = taskConfigDict.get('channel', None)
task_parameters = taskConfigDict.get('parameters', None)
module_index = taskConfigDict.get('module_index', None)
if droneObject == None:
error = ec.ERROR_DRONE_InvalidDroneIndex
data = droneIndexInt
return (error, data)
if task_uuid == None:
error = ec.ERROR_DRONE_MissingDroneTaskParameter
data = 'uuid'
return (error, data)
if task_channel == None:
error = ec.ERROR_DRONE_MissingDroneTaskParameter
data = 'channel'
return (error, data)
if task_plugin == None:
error = ec.ERROR_MissingDroneTaskParameter
data = 'plugin'
return (error, data)
if task_parameters == None:
error = ec.ERROR_MissingDroneTaskParameter
data = 'parameters'
return (error, data)
(data, error) = droneObject.api.task(task_plugin, task_channel,
task_uuid,
task_parameters)
if error == None:
self.task_store[self.task_counter] = TaskContainer(
self.task_counter, task_uuid, task_plugin,
task_channel, task_parameters, droneIndexList,
module_index)
self.task_counter += 1
return (data, error)
except:
self.handleException()
def detaskDrone(self, droneIndexList, task_uuid):
try:
for int_DroneIndex in droneIndexList:
droneObject = self.drone_store.get(int_DroneIndex, None)
droneObject.api.detask(task_uuid)
except Exception:
self.handleException()
def loadModules(self):
count = len(self.config.modules)
self.logutil.log(
'Loading Modules (Found {0} Modules in the Config)'.format(count))
for moduleConfigDict in self.config.modules:
self.loadModule(moduleConfigDict)
pass
def unloadModules(self):
self.logutil.log('Unloading Modules')
self.logutil.log('Found {0} Active Modules'.format(
len(self.module_store)))
for i in range(len(self.module_store)):
self.unloadModule(i)
def loadModuleClass(self, module):
if module == 'BeaconRequestMonitor': return BeaconRequestMonitor
if module == 'DisassociationStormMonitor':
return DisassociationStormMonitor
if module == 'DosAesCtrMonitor': return DosAesCtrMonitor
def loadModule(self, moduleConfigDict):
self.logutil.debug('Loading Module: {0}'.format(moduleConfigDict))
try:
moduleName = moduleConfigDict.get('name', None)
moduleSettings = moduleConfigDict.get('settings', None)
moduleClass = self.loadModuleClass(moduleName)
if moduleName == None:
error = ec.ERROR_WIDS_MissingModuleParameter
data = 'name'
self.logutil.log(
'Failed to Load Module - Missing Parameter: "name" in {0}\n'
.format(moduleConfigDict))
return self.formatResponse(error, data)
elif moduleSettings == None:
error = ec.ERROR_WIDS_MissingModuleParameter
data = 'settings'
self.logutil.log(
'Failed to Load Module - Missing Parameter: "settings" in {0}\n'
.format(moduleConfigDict))
return self.formatResponse(error, data)
elif moduleClass == None:
error = ec.ERROR_WIDS_MissingModuleClass
data = moduleName
self.logutil.log(
'Failed to Load Module - Could not load class: {0}'.format(
moduleName))
return self.formatResponse(error, data)
else:
moduleIndex = self.module_counter
moduleShutdownEvent = Event()
moduleSettings['module_index'] = moduleIndex
self.logutil.debug(
'Found module class: {0}'.format(moduleClass))
'''
(error,data) = moduleClass.validate_settings(moduleSettings)
if not error == None:
return self.formatResponse(error,data)
'''
moduleProcess = moduleClass(moduleSettings, self.config,
moduleShutdownEvent)
moduleProcess.start()
moduleObject = ModuleContainer(moduleIndex, moduleName,
moduleSettings, moduleProcess,
moduleShutdownEvent)
self.module_store[moduleIndex] = moduleObject
self.module_counter += 1
self.logutil.log('Loading Module {0} - {1}'.format(
moduleIndex, moduleObject.name))
return self.formatResponse(None, None)
except:
self.handleException()
def unloadModule(self, moduleIndexInt):
try:
moduleObject = self.module_store.get(moduleIndexInt, None)
if moduleObject == None:
error = 'Error: Module with Index {0} does not exist'.format(
moduleIndexInt)
self.logutil.log(error)
return self.formatResponse(False, error)
else:
self.logutil.log('Unloading Module {0} ({1} - {2})'.format(
moduleIndexInt, moduleObject.name,
moduleObject.process.pid))
self.logutil.log('Detasking Module Tasks')
for taskObject in self.task_store.values():
if taskObject.module_index == moduleObject.index:
drones = taskObject.drones
uuid = taskObject.uuid
self.logutil.log(
'Removing Task {0} from Drones {1}'.format(
uuid, drones))
self.detaskDrone(drones, uuid)
moduleObject.process.terminate()
moduleObject.process.join()
del (self.module_store[moduleIndexInt])
del (moduleObject)
return self.formatResponse(True, None)
except:
self.handleException()
def startServer(self):
self.logutil.log('Starting Server on port {0}'.format(
self.config.server_port))
app = flask.Flask(__name__)
app.add_url_rule('/active',
None,
self.processActiveGetRequest,
methods=['GET'])
app.add_url_rule('/status',
None,
self.processStatusGetRequest,
methods=['GET'])
app.add_url_rule('/data/upload',
None,
self.processDataUploadRequest,
methods=['POST'])
app.add_url_rule('/data/download',
None,
self.processDataDownloadRequest,
methods=['POST'])
app.add_url_rule('/drone/task',
None,
self.processDroneTaskRequest,
methods=['POST'])
app.add_url_rule('/drone/detask',
None,
self.processDroneDetaskRequest,
methods=['POST'])
app.add_url_rule('/drone/add',
None,
self.processDroneAddRequest,
methods=['POST'])
app.add_url_rule('/drone/delete',
None,
self.processDroneDeleteRequest,
methods=['POST'])
app.add_url_rule('/alerts',
None,
self.processAlertGetRequest,
methods=['POST'])
app.add_url_rule('/alerts/generate',
None,
self.processAlertGenerateRequest,
methods=['POST'])
app.add_url_rule('/module/load',
None,
self.processModuleLoadRequest,
methods=['POST'])
app.add_url_rule('/module/unload',
None,
self.processModuleUnloadRequest,
methods=['POST'])
app.run(threaded=True, port=int(self.config.server_port))
def handleException(self):
etb = traceback.format_exc()
self.logutil.trace(etb)
return self.formatResponse(error=ec.ERROR_GENERAL_UnknownException,
data=str(etb))
def formatResponse(self, error, data):
return json.dumps({'error': error, 'data': data})
def processActiveGetRequest(self):
self.logutil.debug('Processing Active Get Request')
return self.formatResponse(error=None, data=True)
def processDataUploadRequest(self):
self.logutil.debug('Processing Data Upload Request')
try:
data = json.loads(flask.request.data)
packetdata = data.get('pkt')
self.database.storePacket(packetdata)
return self.formatResponse(error=None, data=None)
except Exception:
return self.handleException()
def processDataDownloadRequest(self):
self.logutil.debug('Processing Data Upload Request')
try:
return self.formatResponse(error=None, data=None)
except Exception:
return self.handleException()
def processDroneTaskRequest(self):
self.logutil.debug('Processing Drone Task Request')
try:
request_data = json.loads(flask.request.data)
(error, data) = self.taskDrone(request_data)
return self.formatResponse(error, data)
except Exception:
return self.handleException()
def processDroneDetaskRequest(self):
self.logutil.debug('Processing Drone Detask Request')
try:
data = json.loads(flask.request.data)
return self.detaskDrone(data)
except Exception:
return self.handleException()
def processDroneAddRequest(self):
self.logutil.debug('Processing Drone Add Request')
try:
data = json.loads(flask.request.data)
return self.loadDrone(data)
except Exception:
return self.handleException()
def processDroneDeleteRequest(self):
self.logutil.debug('Processing Drone Delete Request')
try:
data = json.loads(flask.request.data)
drone_index = int(data.get('drone_index'))
return self.unloadDrone(drone_index)
except:
return self.handleException()
def processModuleLoadRequest(self):
self.logutil.debug('Processing Module Load Request')
try:
data = json.loads(flask.request.data)
return self.loadModule(data)
except:
return self.handleException()
def processModuleUnloadRequest(self):
self.logutil.debug('Processing Module Unload Request')
try:
data = json.loads(flask.request.data)
module_index = int(data.get('module_index'))
return self.unloadModule(module_index)
except:
return self.handleException()
def processAlertGenerateRequest(self):
self.logutil.debug('Processing Alert Generate Request')
try:
data = json.loads(flask.request.data)
alert_name = str(data.get('alert_name'))
self.database.storeAlert(alert_name)
return self.formatResponse(True, None)
except:
return self.handleException()
def processAlertGetRequest(self):
#self.logutil.debug('Processing Alert Request')
try:
alerts = []
for alert in self.database.session.query(Alert).all():
alerts.append('{0} - {1}'.format(microToDate(alert.datetime),
alert.name))
return self.formatResponse(None, alerts)
except:
return self.handleException()
def processStatusGetRequest(self):
self.logutil.log('Processing Status Request')
try:
config = self.config.json()
modules = list(
(module.json() for module in self.module_store.values()))
tasks = list((task.json() for task in self.task_store.values()))
rules = list((rule.json() for rule in self.rule_store.values()))
drones = list(
(drone.json() for drone in self.drone_store.values()))
status = {
'config': config,
'modules': modules,
'tasks': tasks,
'drones': drones,
'rules': rules
}
return json.dumps({'success': True, 'data': status})
except:
return self.handleException()
