class Daemon():
""" """
def __init__(self, ETLHandler, run_interval_hrs=0.1):
self.pid = '/tmp/mongotosql-daemon.pid'
self.ETL = ETLHandler
self.run_interval_sec = self.hours_to_sec(run_interval_hrs)
logging.basicConfig(format='%(asctime)s -- %(levelname)s: %(message)s',
filename='ETLactivity.log',
level=logging.DEBUG,
datefmt='%m/%d/%Y %I:%M:%S %p')
self.daemon = Daemonize(app='MongoToSqlD-Daemon',
pid=self.pid,
action=self.start_action,
foreground=True)
def hours_to_sec(self, t):
""" convert hours to seconds (sec = hrs x 60min x 60sec) """
return float(t * 3600)
def start_action(self):
""" runs the program as a linux daemon or windows service
"""
while True:
self.ETL.get_from_mongo()
self.ETL.push_to_sql()
self.ETL.send_email_update()
logging.info(" <daemon> pulled from mongo")
logging.info(" <daemon> sleeping for {} sec".format(
self.run_interval_sec))
time.sleep(self.run_interval_sec)
def start(self):
""" """
self.daemon.start()
def stop(self):
""" """
self.daemon.exit()
class serviceProvider(object):
""" Service handler class. Contains all objects """
objList = None
daemonObj = None
def __init__(self):
""" Init all objects and init handlers """
self.services = [self.communication_handler]
self.handlers = [
self.handle_datalink, self.handle_networklayer,
self.handle_transportlayer, self.handle_dns
]
self.daemonObj = Daemonize(app=config.APP_NAME,
pid=config.PID_FILE,
action=self.start_app_service)
def main(self):
""" Start the daemon service """
self.daemonObj.start()
def start_app_service(self):
""" Main function to handle everything """
self.init_logger() # logger in self.logger
self.init_objects()
self.logger.info("Starting service...")
self.start_services()
self.start_sniffing()
def start_sniffing(self):
""" Starts sniffing """
self.logger.info("Starting sniffer...")
try:
sniff(store=False, prn=self.packet_handler)
except Exception as e:
self.logger.error(e)
def start_services(self):
for service in self.services:
t = threading.Thread(target=service)
t.start()
def unit_communication_handler(self, conn):
""" Handles communication for each connection """
cmd = conn.recv_data()
feature = cmd['feature']
args = cmd['args']
self.logger.debug("Recivied commands: {} {}".format(feature, args))
if feature == 'service':
if args[0] == 'stop':
conn.send_data({
'status': 'Success',
'message': 'Stoping daemon service'
})
self.daemonObj.exit()
else:
args = (time.time(),
args[0].upper()) + args[1:] # Capitalize BLOCK or ALLOW
try:
self.rule_updater_for_single_obj(feature, args)
except Exception as e:
conn.send_data({'status': 'Error', 'message': e.args[0]})
conn.close()
return False
conn.send_data({
'status': 'Success',
'message': 'Update successfull.'
})
conn.close()
return True
return True
def rule_updater_for_single_obj(self, layer, new_rules):
""" Handles the rules updation for a single a layer. Handles all errors and replies"""
new_list = self.objList[layer]['rules'].copy()
new_list.append(new_rules)
self.objList[layer]['obj'].update_list(new_list)
return True
def communication_handler(self):
""" Blocking listener function. Calls unit_communication_handler for each connection"""
self.serverObj = ipcAPI.ipcServer(config.SOCKET_FILE)
self.serverObj.start_listening(self.unit_communication_handler)
def init_logger(self):
""" Creates logger object """
fmt = "[\033[36m%(asctime)s\033[0m] [%(levelname)s] \033[1m%(module)s\033[0m \t: %(message)s"
self.logger = logging.getLogger(config.APP_NAME)
tempHandler = logging.FileHandler(config.LOG_FILE, "a")
tempHandler.setLevel(logging.DEBUG)
formatHandler = coloredLogs(fmt, datefmt='%H:%M:%S')
tempHandler.setFormatter(formatHandler)
self.logger.addHandler(tempHandler)
# self.keep_fds = [self.logger.root.handlers[0].stream.fileno()]
def init_objects(self):
""" Init all objects in the objList"""
from features.dnsBlocker import dnsBlocker
from features.dataLinkLayer import dataLinkLayer
from features.networkLayer import networkLayer
from features.transportLayer import transportLayer
self.objList = {
'dataLinkLayer': {
'obj':
dataLinkLayer([], self.logger), #[(0,'BLOCK','*','docker0')]),
'rules': []
},
'networkLayer': {
'obj': networkLayer([], self.logger), #[(0,'BLOCK','icmp')]),
'rules': []
},
'transportLayer': {
'obj': transportLayer(
[], self.logger), #[(0,'BLOCK','*','*','*','7596')]),
'rules': []
},
'dnsBlocker': {
'obj':
dnsBlocker([], self.logger), #[(0,'BLOCK','*.blockme.com')]),
'rules': []
},
}
return True
def packet_handler(self, packet):
""" Callback function for scapy """
for handler_function in self.handlers:
t = threading.Thread(target=handler_function, args=(packet, ))
t.start()
def handle_datalink(self, packet):
""" Handler for dataLinkLayer """
if packet.haslayer('Ether'):
self.objList['dataLinkLayer']['obj'].handler(packet)
return True
return False
def handle_networklayer(self, packet):
""" Handler for networkLayer """
if packet.haslayer('IP'):
self.objList['networkLayer']['obj'].handler(packet)
return True
return False
def handle_transportlayer(self, packet):
""" Handler for transportLayer """
if packet.haslayer('IP'):
self.objList['transportLayer']['obj'].handler(packet)
return True
return False
def handle_dns(self, packet):
""" Handler applicationLayer(DNS) """
if packet.haslayer('DNS'):
self.objList['dnsBlocker']['obj'].handler(packet)
return True
return False
def main():
if sc.rtm_connect():
while True:
for rtm in sc.rtm_read():
if rtm["type"] == "message":
response(rtm)
time.sleep(1)
else:
print("Connection Failed")
logger = logging.getLogger(__name__)
d = Daemonize(app=app_name, pid=app_name + ".pid", action=main, logger=logger)
daemon = len(sys.argv) >= 2 and sys.argv[1] == "-d"
kill = len(sys.argv) >= 2 and sys.argv[1] == "-k"
restart = len(sys.argv) >= 2 and sys.argv[1] == "-r"
if len(sys.argv) < 2:
print("NON Daemon Mode")
main()
else:
if sys.argv[1] == "stop":
d.exit()
elif sys.argv[1] == "start":
print("Daemon Mode: pid =", pid)
d.start()
else:
sys.stderr.write("Unknown Option")
