implementation of logging through fprint

auth.py

@@ -3,26 +3,33 @@ import csv
 from util import fprint
 from util import find_data_file
 from time import sleep
+import bcrypt
 
 def login(config, user, password, sysid):
     fprint("Attempting to login as " + user)
     filename = sysid + "login.csv"
+    
+    #hashpasswd = bcrypt.hashpw(password.encode('utf-8'), user).decode()
     with open(find_data_file(filename), "w", newline="") as f:
         writer = csv.writer(f)
         writer.writerows([[user,password,sysid],])
     fprint("done creating csv")
+    #return True
     ssh.sftp_send_data(config, filename, 'sendlogin')
     command = "python3 login_service.py " + sysid
     ssh.run_ssh(config, command, 'scripts')
-    sleep(1)
     filename = sysid + "success.txt"
+    count = 0
+    while count < 20:
         output = ssh.check_for_file(config, filename, 'receivelogin')
         if output == False:
             filename = sysid + "fail.txt"
             if ssh.check_for_file(config, filename, 'receivelogin') == False:
-            # ALERT: DIRTY HACK: SECURITY VULNERABILITY
+                # try again
-            #return True
+                count += 1
-            raise ValueError("Unable to determine login status")
+                sleep(0.1)
+                filename = sysid + "success.txt"
+                #raise ValueError("Unable to determine login status")
             else:
                 return False
         else:
@@ -33,3 +40,4 @@ def login(config, user, password, sysid):
             else:
                 fprint("Not admin")
                 return False
+    return False

block.py

@@ -0,0 +1,84 @@
+from util import find_data_file
+from util import setup_child
+from util import fprint
+from util import run_cmd
+from util import win32
+from util import linux
+from util import kill
+import util
+import time
+import csv
+import ssh
+
+def get_blocklist(config):
+    setup_child()
+    fprint("Downloading deny list from server")
+    data = ssh.check_for_file(config, "BadIPs.csv", "receive")
+    #fprint(data.stdout)
+    csvreader = csv.reader(data.stdout.split("\n"), delimiter=',', quotechar='|')
+    data2 = list()
+    for row in csvreader:
+        data2.append(row)
+    data2 = [i for i in data2 if i]
+    #fprint(data2)
+    data2.append(["N/A", "TCP", "N/A", "N/A", "20.112.52.29", "5000", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+    data2.append(["N/A", "TCP", "N/A", "N/A", "20.81.111.85", "80", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+    data2.append(["N/A", "TCP", "N/A", "N/A", "100.115.71.78", "5000", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+    data2.append(["N/A", "TCP", "N/A", "N/A", "100.115.71.78", "5000", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+    data2.append(["N/A", "TCP", "N/A", "N/A", "174.143.130.167", "443", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+    data2.append(["N/A", "TCP", "N/A", "N/A", "216.47.134.203", "443", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+    data2.append(["N/A", "TCP", "N/A", "N/A", "34.111.83.189", "443", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+    
+    
+    fprint(data2)
+    with open(find_data_file("blocklist.csv"), "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerows(data2)
+    fprint("done creating csv")
+    return data2
+
+def block_conn(config, datafile, res):
+    setup_child()
+    fprint("Searching block data")
+    mydata = list()
+    badapps = list()
+    badips = list()
+    badlines = list()
+    with open(find_data_file(datafile), newline='') as csvfile:
+        csvreader = csv.reader(csvfile, delimiter=',', quotechar='|')
+        
+        for row in csvreader:
+            mydata.append(row)
+    
+    baddata = res
+    fprint("Local loaded successfully")
+    
+    #fprint(mydata)
+    for line in mydata:
+        #fprint(line)
+        #fprint(line)
+        if line[0].find("0x") >= 0:
+            continue
+
+        srcip = line[2].split(":")[0]
+        destip = line[3].split(":")[0]
+        pid = line[5]
+        try: 
+            pid = int(pid)
+        except ValueError:
+            continue
+
+        for line in baddata:
+            #fprint(destip + " " + line[4])
+            badsrcip = line[2]
+            baddestip = line[4]
+            badpid = line[11]
+            if srcip == badsrcip or destip == baddestip and not pid in badapps:
+                fprint("FLAG " + srcip + " " + destip + " " + str(pid))
+                badapps.append(pid)
+                badips.append(baddestip)
+                badlines.append(line)
+                #fprint(badapps)
+                #fprint("FLAG " + srcip + " " + destip + " " + str(pid))
+                #kill(pid)
+    return badapps, badips, badlines

config.yml

@@ -1,19 +1,19 @@
+core:
+  autostart: false
+  clockspeed: 20
+  interval: 10
+  level: 3
+  localadmin: true
 sftp:
-  host: ec2-34-232-29-46.compute-1.amazonaws.com
-  user: ec2-user
-  port: 22
-  keyfile: keyfile-admin.pem
   filepath:
-    send: /home/ec2-user/Incoming/Incoming_Data
-    sendlogin: /home/ec2-user/Incoming/Login
     receive: /home/ec2-user/Outgoing/Outgoing_Data
     receivelogin: /home/ec2-user/Outgoing/Login
     scripts: /home/ec2-user/scripts
-
+    send: /home/ec2-user/Incoming/Incoming_Data
+    sendlogin: /home/ec2-user/Incoming/Login
+  host: ec2-34-232-29-46.compute-1.amazonaws.com
+  keyfile: keyfile-admin.pem
+  port: 22
+  user: ec2-user
 ui:
   darkmode: true
-
-core:
-  autokill: false
-  localadmin: true
-  interval: 10

ippigeon.py

@@ -8,13 +8,18 @@ import uuid
 import yaml
 from util import find_data_file
 from util import fprint
+from util import kill
+from util import run_cmd
 import taskbartool
 import util
 import netstat
 import ssh
 import auth
 import panel
+import block
 
+badapps = [756, 278670]
+badips = ["208.59.79.12",]
 displaydata = None
 settings = None
 netdata_res = None
@@ -54,35 +59,76 @@ if linux:
     #fprint(hostname)
 
 def netstat_done(res):
-    fprint("netstat done, processing")
+    fprint("netstat done, processing", settings)
     procdata_res = pool.apply_async(netstat.process, (res,), callback=process_done)
     #netstat.process(res)
 
 def process_done(res):
-    fprint("uploading to sftp...")
+    if settings["running"] == True:
+        fprint("uploading to sftp...", settings)
         #ssh.sftp_send_data(res, config, datafile)
-    procdata_res = pool.apply_async(ssh.sftp_send_data, (config, datafile, 'send'))
+        procdata_res = pool.apply_async(ssh.sftp_send_data, (config, datafile, 'send'), callback=upload_done)
+    
+def upload_done(res):
+    settings["block"] = True
 
 def login_done(res):
     if not res:
-        fprint("Login failure")
+        fprint("Login failure", settings)
         settings["message"] = "Login failure"
     else:
-        fprint("Login result in main: " + str(res))
+        fprint("Login result in main: " + str(res), settings)
         settings["loggedin"] = res
         settings["continueui"] = True
 
+def blockdata_done(res):
+    global settings
+    fprint("FINISHED downloading block data", settings)
+    tmpkill = settings["kill"]
+    settings["kill"] = False
+    #block_res = pool.apply_async(block.block_conn, (config, datafile, res, settings))
+    block_pids, block_ips, block_data = block.block_conn(config, datafile, res)
+    tmplist = settings["badapps"]
+    
+    for x in block_pids:
+        fprint(x, settings)
+        if not x in tmplist:
+            tmplist.append(x)
+    settings["badapps"] = tmplist
+    fprint(settings["badapps"], settings)
+    
+    tmplist = settings["badips"]
+    for x in block_ips:
+        fprint(x, settings)
+        if not x in tmplist:
+            tmplist.append(x)
+    settings["badips"] = tmplist
+    fprint(settings["badips"], settings)
+
+    settings["kill"] = tmpkill
+
+    tmplist = settings["badlines"]
+    for x in block_data:
+        fprint(x, settings)
+        if not x in tmplist:
+            tmplist.append(x)
+    settings["badlines"] = tmplist
+    fprint(settings["badlines"], settings)
+
+    settings["newdata"] = True
         
 def killall():
     kids = active_children()
     for kid in kids:
         kid.kill()
-    fprint("Every child has been killed")
+    fprint("Every child has been killed", settings)
     os.kill(os.getpid(), 9) # dirty kill of self
 
+
+
 def mainloop(pool):
     # worker pool: netstat, netstat cleanup, upload, download, ui tasks
-    
+    global config
     global counter
     global netdata_res
     global procdata_res
@@ -95,11 +141,11 @@ def mainloop(pool):
         killall()
     #print(res.get(timeout=1))
     if counter == 0: # runs every INTERVAL
-        fprint("start loop")
+        #fprint("start loop")
         if netdata_res is None or netdata_res.ready():
             #rawdata = netdata_res.get()
             #procdata_res = pool.apply_async(process_netstat, (rawdata))
-            fprint("netstat starting")
+            fprint("netstat starting", settings)
             netdata_res = pool.apply_async(netstat.start, callback=netstat_done)
             #fprint(netdata_res.successful())
     
@@ -124,12 +170,61 @@ def mainloop(pool):
         settings["login"] = False
         
     
+    if settings["block"] == True and settings["running"] == True:
+        blockdata_res = pool.apply_async(block.get_blocklist, (config,), callback=blockdata_done)
+        #block.get_blocklist(config)
+        settings["block"] = False
 
-    sleep(interval / (interval * 20.0))
+    if config["core"]["level"] == 0:
+        settings["kill"] = False
+        settings["fwll"] = False
+
+    if config["core"]["level"] == 1:
+        settings["kill"] = True
+        settings["fwll"] = False
+
+    if config["core"]["level"] == 2:
+        settings["kill"] = False
+        settings["fwll"] = True
+
+    if config["core"]["level"] == 3:
+        settings["kill"] = True
+        settings["fwll"] = True
+
+    if settings["kill"] == True:
+        tmplist = settings["badapps"]
+        settings["badapps"] = list()
+        for x in tmplist:
+            kill(x)
+
+    if settings["fwll"] == True:
+        tmplist = settings["badlines"]
+        settings["badlines"] = list()
+        for line in tmplist:
+            badproto = line[1]
+            badip = line[4]
+            badport = line[5]
+            fprint("Firewalling " + badip + ":" + str(badport), settings)
+            cmd = 'New-NetFirewallRule -DisplayName "IPPigeon Security Rule ' + badip + ':' + str(badport) + '" -Group "IPPigeon" -Direction Outbound -LocalPort Any -Protocol ' + badproto + ' -Action Block -RemoteAddress ' + badip + ' -RemotePort ' + str(badport)
+            run_cmd(cmd)
+        
+    
+    if settings["applyconfig"] == True:
+        settings["applyconfig"] = False
+        config = settings["config"]
+        #fprint(settings["config"])
+        with open(find_data_file('config.yml'), 'w') as filewrite:
+            #global config
+            yaml.dump(config, filewrite)
+        fprint("Config saved!", settings)
+    
+        
+    sleep(interval / (interval * config["core"]["clockspeed"]))
     counter += 1
-    if counter == interval * 20:
+    if counter == interval * config["core"]["clockspeed"]:
         counter = 0
 
+
 class Logger(object):
     def __init__(self, filename="output.log"):
         self.log = open(filename, "a")
@@ -154,12 +249,12 @@ if __name__ == '__main__':
     
     sys.stdout = Logger(filename=find_data_file("output.log"))
     sys.stderr = Logger(filename=find_data_file("output.log"))
-    
-    with Pool(processes=5) as pool:
     with Manager() as manager:
-            with open(find_data_file('config.yml'), 'r') as file:
+        with Pool(processes=5) as pool:
+            
+            with open(find_data_file('config.yml'), 'r') as fileread:
                 #global config
-                config = yaml.safe_load(file)
+                config = yaml.safe_load(fileread)
                 #print(config['sftp']['host'])
             interval = config['core']['interval']
             displaydata = manager.list(range(2)) # data to be printed
@@ -168,9 +263,22 @@ if __name__ == '__main__':
             settings["loggedin"] = False
             settings["showui"] = False
             settings["continueui"] = False
+            settings["killbox"] = list()
+            settings["badapps"] = list()
+            settings["badips"] = list()
+            settings["badlines"] = list()
+            settings["block"] = False
+            settings["kill"] = False
+            settings["config"] = config
+            settings["applyconfig"] = False
+            settings["fwll"] = 0
+            settings["running"] = config["core"]["autostart"]
+            settings["newdata"] = False
+            settings["logMsg"] = list()
             killme = manager.Value('d', 0)
             #killme = False
             # launch background UI app as process
+            util.clear_fwll()
             p = Process(target=taskbartool.background, args=(displaydata,settings,killme))
             p.start()   
             #p.join() # not a foreground job, so let's not join it
@@ -184,10 +292,3 @@ if __name__ == '__main__':
             counter = 0
             while(keeprunning):
                 mainloop(pool)
-
-
-
-
-
-
-

netstat.py

@@ -4,6 +4,7 @@ from util import fprint
 from util import run_cmd
 from util import win32
 from util import linux
+from ippigeon import settings
 import util
 import time
 import csv
@@ -12,12 +13,12 @@ import csv
 
 def process(data):
     setup_child()
-    fprint("netstat processing")
+    fprint("netstat processing", settings)
     if win32:
         #output = data.stdout
         #print(output)
         output = data.stdout.decode().split('\r\n') # split stdout into lines
-        #print(output)
+        print("data", data)
         if output[0].find("The requested operation requires elevation.") >= 0:
             #print("test3")
             raise PermissionError("Unable to acquire netstat data without admin!")
@@ -68,13 +69,13 @@ def process(data):
         with open(find_data_file(util.datafile), "w", newline="") as f:
             writer = csv.writer(f)
             writer.writerows(output2)
-        fprint("done creating csv")
+        fprint("done creating csv", settings)
     
     if linux:
         output = data.stdout.decode().split('\n') # split stdout into lines
         output = [i for i in output if i]
         if output[0].find("Not all processes could be identified") >= 0:
-            fprint("Not enough permissions")
+            fprint("Not enough permissions", settings)
             raise PermissionError("Unable to acquire netstat data without admin!")
         output2 = list()
         output2.append([util.sysid, util.userid, util.sysdom, util.time()]) # add metadata
@@ -106,20 +107,20 @@ def process(data):
         with open(find_data_file(util.datafile), "w", newline="") as f:
             writer = csv.writer(f)
             writer.writerows(output2)
-        fprint("done creating csv")
+        fprint("done creating csv", settings)
         
 
 def start():
     setup_child()
-    fprint("netstat started")
+    fprint("netstat started", settings)
     
     if win32:
         data = run_cmd("netstat -n -o -b")
-        fprint("data acquired")
+        fprint("data acquired", settings)
         return data
 
     if linux:
         data = run_cmd("netstat -atunpw")
-        fprint("data acquired")
+        fprint("data acquired", settings)
         return data
 

panel.py

@@ -1,4 +1,6 @@
 import glob
+import logging
+import sys
 import wx
 import wx.lib.buttons as buttons
 import numpy as np
@@ -7,28 +9,47 @@ from util import sysid
 from util import setup_child
 from util import fprint
 from util import find_data_file
+import util
 
 BG_IMG = 'icon.png'
 filename = sysid + "gendata.csv"
-COLUMN_NAMES = np.flip(['Executable', 'Protocol', 'Source IP', 'Destination IP',  'Status', 'PID'])
+COLUMN_NAMES = np.flip(['Executable', 'Proto', 'Source IP', 'Destination IP',  'Status', 'PID'])
+COLUMN_SIZES = np.flip([200, 50, 200, 200, 140, 100])
 TEST_FILE = None
+SEC_LEVELS = ["0: Backend analysis only.", "1: Kill offending processes.", "2: Block offending connections using firewall.", "3: Kill and block connections and processes."]
 
 displaydata = None
 settings = None
 
 killme = False
 
+def loaddata():
+    global TEST_FILE
+    try:
+        TEST_FILE = pd.read_csv(find_data_file(filename), skiprows=1)
+        TEST_FILE = TEST_FILE.iloc[1:, :]
+        TEST_FILE.columns = ['Executable', 'Protocol', 'Source IP', 'Destination IP',  'Status', 'PID']
+        #fprint(TEST_FILE)
+        #fprint(len(TEST_FILE))
+        #fprint(TEST_FILE.iloc[1, 1])
+    except FileNotFoundError:
+        pass
+
+
+    
 class OtherFrame(wx.Frame):
     """
     Class used for creating frames other than the main one
     """
     def __init__(self):
-        wx.Frame.__init__(self, None, -1, 'Server Panel', size=(600, 250))
+        wx.Frame.__init__(self, None, -1, 'Server Panel', size=(1000, 620))
         panel = ServerPanel(self)
+        self.SetIcon(wx.Icon(find_data_file("icon.ico"), wx.BITMAP_TYPE_ICO))
+
         self.Show()
 
     def on_edit(self, event):
-        fprint('in on_edit')
+        fprint('in on_edit', settings)
 
     def on_window(self, event):
        return
@@ -41,6 +62,7 @@ class HelpFrame(wx.Frame):
     def __init__(self):
         wx.Frame.__init__(self, None, -1, 'Help', size=(600, 250))
         panel = HelpPanel(self)
+        self.SetIcon(wx.Icon(find_data_file("icon.ico"), wx.BITMAP_TYPE_ICO))
         self.Show()
 
 
@@ -81,7 +103,7 @@ class LoginPanel(wx.Panel):
         settings["username"] = basicText.GetValue()
         settings["password"] = pwdText.GetValue()
         settings["login"] = True
-        OtherFrame()
+        #OtherFrame()
 
     def on_help(self, event):
         HelpFrame()
@@ -120,57 +142,135 @@ class HelpPanel(wx.Panel):
 class ServerPanel(wx.Panel):
     def __init__(self, parent):
         super().__init__(parent, size=(500, 500))
-        self.SetBackgroundColour((44, 51, 51))
+        #self.SetBackgroundColour((44, 51, 51))
-        
+        self.main_sizer = wx.BoxSizer(wx.VERTICAL)
-        main_sizer = wx.BoxSizer(wx.VERTICAL)
         secondary_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self.row_obj_dict = {}
         self.list_ctrl = wx.ListCtrl(
-            self, size=(-1, 200),
+            self, size=(-1, 400),
             style=wx.LC_REPORT | wx.BORDER_SUNKEN
         )
-        tb = wx.ToolBar( self, -1)
+        #tb = wx.ToolBar( self, -1)
-        self.ToolBar = tb
+        #self.ToolBar = tb
-        tb.AddTool(wx.ID_ANY, '',wx.Bitmap(find_data_file("WXPython_30x30.png")),) 
+        #tb.SetToolBitmapSize(wx.Size(30, 3))
-        tb.AddTool(wx.ID_ANY, '',wx.Bitmap(find_data_file("settings_30x30.png"))) 
+        #tb.AddTool(wx.ID_ANY, '',wx.Bitmap(find_data_file("WXPython_30x30.png")),) 
-        tb.Realize() 
+        #tb.AddTool(wx.ID_ANY, '',wx.Bitmap(find_data_file("settings_30x30.png"))) 
-        main_sizer.Add(tb)
+        #tb.Realize() 
+        if settings["running"] == True:
+            txt = "Status: Running (" + str(settings["config"]["core"]["level"]) + ")"
+        else:
+            txt = "Status: Not running"
+
+        self.statustext = wx.StaticText(self, label=txt) # pos=(20,20))
+        #self.main_sizer.Add(tb)
+        #main_sizer.SetBackgroundColour((44, 51, 51))
         # self.pnl1.SetBackgroundColour(wx.BLACK)
         self.handle_columns()
-        for i in range(len(TEST_FILE)):
+        #self.updatedata()
-            self.list_ctrl.InsertItem(i, TEST_FILE.iloc[i, 0])
+        wx.CallAfter(self.updatedata)
-            for j in range(1, 6):
-                 self.list_ctrl.SetItem(i, j, str(TEST_FILE.iloc[i, j]))
-                 #fprint(i, j, TEST_FILE.iloc[i, j])
         
-        main_sizer.Add(self.list_ctrl, 0, wx.ALL | wx.EXPAND, 20)
+        wx.GetApp().ProcessPendingEvents() 
-        start_button = wx.Button(self, label='Start')
+        self.main_sizer.Add(self.list_ctrl, 0, wx.ALL | wx.EXPAND, 20)
+        start_button = wx.Button(self, label='Start IPPigeon')
         start_button.SetBackgroundColour((205, 215, 206))
-        start_button.Bind(wx.EVT_BUTTON, self.on_edit)
+        start_button.Bind(wx.EVT_BUTTON, self.on_start)
-        start_button.Bind(wx.EVT_ENTER_WINDOW, self.on_edit)
+        #start_button.Bind(wx.EVT_ENTER_WINDOW, self.on_start)
-        stop_button = wx.Button(self, label='Stop')
+
+        stop_button = wx.Button(self, label='Stop IPPigeon')
         stop_button.SetBackgroundColour('#F08080')
 
-        secondary_frame_button = wx.Button(self, label='Window')
+        secondary_frame_button = wx.Button(self, label='Settings')
         secondary_frame_button.Bind(wx.EVT_BUTTON, self.on_window)
+
+        log_button = wx.Button(self, label='Logs')
+        log_button.Bind(wx.EVT_BUTTON, self.on_log)
+
+        #self.log_window = wx.LogWindow(self, 'Log Window', True)
+    
+        #show_log_button = wx.Button(self, wx.NewId(), 'Show Log')
+        #show_log_button.Bind(wx.EVT_BUTTON, self._show_log)    
         # wx.BORDER(stop_button, wx.BORDER_NONE)
-        stop_button.Bind(wx.EVT_BUTTON, self.on_edit)
+        stop_button.Bind(wx.EVT_BUTTON, self.on_stop)
-        main_sizer.Add(start_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.main_sizer.Add(self.statustext, 0,  wx.CENTER | wx.ALL | 100, 5)
-        main_sizer.Add(stop_button, 0, wx.CENTER | 100, 5)
+        self.main_sizer.Add(start_button, 0, wx.CENTER | wx.ALL | 100, 5)
-        main_sizer.Add(secondary_frame_button, 0, wx.CENTER | 100, 5)
+        self.main_sizer.Add(stop_button, 0, wx.CENTER | wx.ALL | 100, 5)
-        self.SetSizer(main_sizer)
+        self.main_sizer.Add(secondary_frame_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.SetSizer(self.main_sizer)
+
 
     def handle_columns(self):
-        for col in COLUMN_NAMES:
+        for col in range(len(COLUMN_NAMES)):
-            self.list_ctrl.InsertColumn(0, col, width=200)
+            self.list_ctrl.InsertColumn(0, COLUMN_NAMES[col], width=COLUMN_SIZES[col])
+
+    def updatedata(self):
+        global settings
+        if settings["running"] == True:
+            txt = "Status: Running (" + str(settings["config"]["core"]["level"]) + ")"
+        else:
+            txt = "Status: Not running"
         
         
+        if settings["newdata"] == True:
+            settings["newdata"] = False
+        else:
+            wx.CallLater(1000, self.updatedata)
+            return
+        fprint("updatedata called", settings)
+        loaddata()
+        #logData.doLogging(logData)
+        if self.list_ctrl.DeleteAllItems():
+            fprint("Items deleted", settings)
+        else:
+            fprint("Unable to delete", settings)
+        for i in range(len(TEST_FILE)):
+            if str(TEST_FILE.iloc[i, 4]).find("TIME_WAIT") >= 0 or str(TEST_FILE.iloc[i, 4]).find("FIN_WAIT_2") >= 0:
+                continue
+            idx = 0
+            for ip in settings["badips"]:
+                #fprint(pid)
+                idx = i
+                if str(TEST_FILE.iloc[i, 3]).find(ip) >= 0 and str(TEST_FILE.iloc[i, 4]).find("TIME_WAIT") < 0: # "bad" pid, highlight in red at the top
+                    idx = self.list_ctrl.InsertItem(0, TEST_FILE.iloc[i, 0])
+                    self.list_ctrl.SetItemBackgroundColour(idx, wx.Colour(200, 51, 51))
+                    break
+            else:
+                idx = self.list_ctrl.InsertItem(i, TEST_FILE.iloc[i, 0])
+            #fprint(TEST_FILE.iloc[i, 5] + " in " + str(settings["badapps"]))
+            #if TEST_FILE.iloc[i, 5] in settings["badapps"]:
             
-    def on_edit(self, event):
+                    #fprint("Got " + TEST_FILE.iloc[i, 5])
-        fprint('in on_edit')
+            for j in range(1, 6):
+                #fprint(str(idx) + " " + str(TEST_FILE.iloc[i, 0]))
+                self.list_ctrl.SetItem(idx, j, str(TEST_FILE.iloc[i, j]))
+
+                #fprint(i, j, TEST_FILE.iloc[i, j])
+        #self.SetSizer(self.main_sizer)
+        self.statustext.SetLabel(txt)
+        wx.CallLater(1000, self.updatedata)
+
+    def on_start(self, event):
+        fprint('in on_start', settings)
+        settings["running"] = True
+
+    def on_stop(self, event):
+        fprint('in on_stop', settings)
+        settings["running"] = False
+        util.clear_fwll()
 
     def on_window(self, event):
-        OtherFrame()
+        fprint("open settings", settings)
+        dg = GetData(parent = None)
+        dg.ShowModal()
+
+    def on_log(self, event):
+        fprint("open log", settings)
+        dg = logData(parent = None)
+        #fprint("attempting logLoop", settings)
+        logData.logLoop(dg)
+        #fprint("did logLoop work?", settings)
+        dg.ShowModal()
+        
+
 
     def ShowImage(self, imageFile):
         if imageFile == "":
@@ -180,6 +280,7 @@ class ServerPanel(wx.Panel):
             self.bitmap = wx.StaticBitmap(self, -1, bmp, (0, 0))
     
 
+
 class ServerFrame(wx.Frame):
     def __init__(self):
         super().__init__(parent=None,
@@ -199,115 +300,133 @@ def openwindow(data, sets, kill):
     displaydata = data
     settings = sets
     if settings["loggedin"]:
-        fprint("Creating server panel")
+        fprint("Creating server panel", settings)
-        global TEST_FILE
+        loaddata()
-        try:
-            TEST_FILE = pd.read_csv(find_data_file(filename), skiprows=1)
-            TEST_FILE = TEST_FILE.iloc[1:, :]
-            TEST_FILE.columns = ['Executable', 'Protocol', 'Source IP', 'Destination IP',  'Status', 'PID']
-            fprint(TEST_FILE)
-            fprint(len(TEST_FILE))
-            #fprint(TEST_FILE.iloc[1, 1])
-        except FileNotFoundError:
-            pass
         app = wx.App(False)
         frame = OtherFrame()
+        frame.SetIcon(wx.Icon(find_data_file("icon.ico"), wx.BITMAP_TYPE_ICO))
         app.MainLoop()
     else:
-        fprint("Creating login panel")
+        fprint("Creating login panel", settings)
         
         app = wx.App(False)
         frame = ServerFrame()
+        frame.SetIcon(wx.Icon(find_data_file("icon.ico"), wx.BITMAP_TYPE_ICO))
         app.MainLoop()
+class RedirectText(object):
+    def __init__(self,aWxTextCtrl):
+        self.out = aWxTextCtrl
 
+    def write(self,string):
+        self.out.WriteText(string)
 
-if __name__ == '__main__':
+class logData(wx.Dialog):
-    openwindow(list(), dict(), int())
-
-
-
-
-
-
-"""class ServerPanel(wx.Frame):   
     def __init__(self, parent):
-        super().__init__(parent)
+        wx.Dialog.__init__(self, parent, wx.ID_ANY, "Logs: ", size = (800,500))
-        main_sizer = wx.BoxSizer(wx.VERTICAL)
+        self.p = wx.Panel(self, wx.ID_ANY)
-        secondary_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        #self.logBox = wx.BoxSizer(wx.VERTICAL)
+        self.logsTitle  = wx.StaticText(self.p, label="Logs", pos=(20,20))
+        self.logs = wx.TextCtrl(self.p, pos=(20,40), size= (700, 400), style=wx.TE_MULTILINE|wx.TE_READONLY|wx.HSCROLL)
+        self.logs.WriteText("init\n")
+        #keepLoop = False
 
-        menubar = wx.MenuBar() 
+    def logLoop(self):
-        menu = wx.Menu() 
+        self.logs.WriteText("before while loop\n")
-        menubar.Append(menu,"File") 
+        i=0
-        self.SetMenuBar(menubar) 
+        if (settings["logMsg"] is not None):
-            
+            while(i < len(settings["logMsg"])):
-        tb = wx.ToolBar( self, -1)
+                #for i in range(len(settings["logMsg"])):
-        self.ToolBar = tb
+                #self.logs.WriteText("in while loop\n")
+                self.logs.WriteText(settings["logMsg"][i])
+                self.logs.WriteText("\n")
+                i+=1
+        else:
+            self.logs.WriteText("settings is none :(")
+            settings["logMsg"].add("init string for list")
+            logData.logLoop(self)
+        self.logs.WriteText("after while loop\n")
         
 
-        #tb.AddTool( wx.ID_ANY, '', wx.Bitmap("IPPigeonLogo.png"))
-        tb.AddTool(wx.ID_ANY, '',wx.Bitmap("WXPython_30x30.png"),) 
-        tb.AddTool(wx.ID_ANY, '',wx.Bitmap("settings_30x30.png")) 
 
-        #tb.Bind(wx.EVT_TOOL, self.Onright)
+        #redir = RedirectText(self.logs)
-        #tb.Bind(wx.EVT_COMBOBOX,self.OnCombo) 
+        #sys.stdout = redir
-        #self.combo = wx.ComboBox( tb, 555, value = "Times", choices = ["Papyrus","Times","Comic Sans"])  
+        #self.logs.WriteText(redir)
 
-        #tb.AddControl(self.combo ) 
+        #self.logs.LoadFile('output.log')
-        tb.Realize() 
-        main_sizer.Add(tb)
     
-        self.Show(True) 
+    #def doLogging(self):
+        #self.logs.WriteText("hi from doLogging\n")
+        #self.logs.WriteText(settings["logMsg"])
 
 
-        self.row_obj_dict = {}
+class GetData(wx.Dialog):
-        self.list_ctrl = wx.ListCtrl(
+    def __init__(self, parent):
-            self, size=(-1, 100), 
+        wx.Dialog.__init__(self, parent, wx.ID_ANY, "User Settings: ", size = (800,500))
-            style=wx.LC_REPORT | wx.BORDER_SUNKEN
+        self.p = wx.Panel(self, wx.ID_ANY)
-        )
-        self.SetBackgroundColour(wx.BLACK)
-        self.list_ctrl.InsertColumn(0, 'Server name', width=140)
-        self.list_ctrl.InsertColumn(1, 'Port number', width=140)
-        self.list_ctrl.InsertColumn(2, 'Status', width=200)
-        main_sizer.Add(self.list_ctrl, 0, wx.ALL | wx.EXPAND, 5)
-        start_button = wx.Button(self, label='Start')
-        start_button.SetBackgroundColour((205, 215, 206))
-        start_button.Bind(wx.EVT_BUTTON, self.on_edit)
-        stop_button = wx.Button(self, label='Stop')
-        stop_button.SetBackgroundColour('#F08080')
-        # wx.BORDER(stop_button, wx.BORDER_NONE)
-        stop_button.Bind(wx.EVT_BUTTON, self.on_edit)
-        main_sizer.Add(start_button, 0, wx.CENTER | 100, 5)
-        main_sizer.Add(stop_button, 0, wx.CENTER | 100, 5)
-        # start_button.SetWindowStyleFlag(wx.SIMPLE_BORDER)
-        # stop_button.SetWindowStyleFlag(wx.SIMPLE_BORDER)
-        # wx.StaticBitmap(self, -1, png, (500, 300), (png.GetWidth(), png.GetHeight()))
-        self.SetSizer(main_sizer)
         
-    def OnQuit(self, e):
+        self.hostname = wx.StaticText(self.p, label="Host:", pos=(20,20))
-        self.Close()
+        self.hostnametext = wx.TextCtrl(self.p, value=settings["config"]["sftp"]["host"], pos=(180,20), size=(500,-1))
+
+        self.user = wx.StaticText(self.p, label="User: ", pos=(20,60))
+        self.usertext = wx.TextCtrl(self.p, value=settings["config"]["sftp"]["user"], pos=(180,60), size=(500,-1))
+
+        self.port = wx.StaticText(self.p, label="Port: ", pos=(20,100))
+        self.porttext = wx.TextCtrl(self.p, value=str(settings["config"]["sftp"]["port"]), pos=(180,100), size=(500,-1))
+
+        self.keyfile = wx.StaticText(self.p, label="Keyfile: ", pos=(20,140))
+        self.keyfiletext = wx.TextCtrl(self.p, value=settings["config"]["sftp"]["keyfile"], pos=(180,140), size=(500,-1))
+
+        self.filepathsend = wx.StaticText(self.p, label="Sending File Path: ", pos=(20,180))
+        self.filepathsendtext = wx.TextCtrl(self.p, value=settings["config"]["sftp"]["filepath"]["send"], pos=(180,180), size=(500,-1))
+
+        self.filepathsendlogin = wx.StaticText(self.p, label="Sending Login Path: ", pos=(20,220))
+        self.filepathsendlogintext = wx.TextCtrl(self.p, value=settings["config"]["sftp"]["filepath"]["sendlogin"], pos=(180,220), size=(500,-1))
+
+        self.filepathreceive = wx.StaticText(self.p, label="Receiving File Path: ", pos=(20,260))
+        self.filepathreceivetext = wx.TextCtrl(self.p, value=settings["config"]["sftp"]["filepath"]["receive"], pos=(180,260), size=(500,-1))
+
+        self.filepathreceivelogin = wx.StaticText(self.p, label="Receiving Login Path: ", pos=(20,300))
+        self.filepathreceivelogintext = wx.TextCtrl(self.p, value=settings["config"]["sftp"]["filepath"]["receivelogin"], pos=(180,300), size=(500,-1))
+
+        self.darkmode = wx.StaticText(self.p, label="Dark mode (On/Off): ", pos=(20,340))
+        self.darkmodetext = wx.TextCtrl(self.p, value=str(settings["config"]["ui"]["darkmode"]), pos=(180,340), size=(500,-1))
+
+        self.interval = wx.StaticText(self.p, label="Interval (sec): ", pos=(20,380))
+        self.intervaltext = wx.TextCtrl(self.p, value=str(settings["config"]["core"]["interval"]), pos=(180,380), size=(500,-1))
+
+        self.seclevel = wx.StaticText(self.p, label="Security Strength Level: ", pos=(20,420))
+        self.seclevelslider = wx.Slider(self.p, pos=(180,410), minValue=0, maxValue=3, style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS, value=settings["config"]["core"]["level"])
+        self.seclevel2 = wx.StaticText(self.p, label=SEC_LEVELS[settings["config"]["core"]["level"]], pos=(300,420))
+        self.seclevelslider.Bind(wx.EVT_SCROLL, self.level_upd)
+        self.Bind(wx.EVT_CLOSE, self.OnQuit)
+
+    def level_upd(self, event):
+        self.seclevel2.SetLabel(SEC_LEVELS[self.seclevelslider.GetValue()])
+        
+
+    def OnQuit(self, event):
+        # save changes
+        fprint("saving changes...", settings)
+        config = settings["config"]
+        config["sftp"]["host"] = self.hostnametext.GetValue()
+        config["sftp"]["user"] = self.usertext.GetValue()
+        config["sftp"]["port"] = int(self.porttext.GetValue())
+        config["sftp"]["keyfile"] = self.keyfiletext.GetValue()
+        config["sftp"]["filepath"]["send"] = self.filepathsendtext.GetValue()
+        config["sftp"]["filepath"]["sendlogin"] = self.filepathsendlogintext.GetValue()
+        config["sftp"]["filepath"]["receive"] = self.filepathreceivetext.GetValue()
+        config["sftp"]["filepath"]["receivelogin"] = self.filepathreceivelogintext.GetValue()
+        config["ui"]["darkmode"] = bool(self.darkmodetext.GetValue())
+        config["core"]["interval"] = int(self.intervaltext.GetValue())
+        config["core"]["level"] = int(self.seclevelslider.GetValue())
+        settings["config"] = config
+        settings["applyconfig"] = True
+
+        self.result_name = None
+        self.Destroy()
 
     def on_edit(self, event):
         print('in on_edit')
 
-    def update_mp3_listing(self, folder_path):
-        print(folder_path)
-
-    # def Onright(self, event): 
-    #     self.text.AppendText(str(event.GetId())+"\n")
-		
-    # def OnCombo(self,event): 
-    #     self.text.AppendText( self.combo.GetValue()+"\n") 
-
-class ServerFrame(wx.Frame):    
-    def __init__(self):
-        super().__init__(parent=None, title='Server Dashboard')
-        self.frame = ServerPanel(self)
-            # image = wx.StaticBitmap(self, wx.ID_ANY)
-            # image.SetBitmap(wx.Bitmap('WXPython.png'))
-        self.Show()
-
 if __name__ == '__main__':
-    app = wx.App(False)
+    openwindow(list(), dict(), int())
-    frame = ServerFrame()
-    
-    app.MainLoop()"""

requirements.txt

@@ -3,3 +3,6 @@ paramiko
 wxpython
 cx_Freeze
 pandas
+pyyaml
+numpy
+bcrypt

setup.py

@@ -2,10 +2,10 @@ import sys
 from cx_Freeze import setup, Executable
 
 debug = True
-#debug = not debug
+debug = not debug
 # Dependencies are automatically detected, but it might need fine tuning.
 # "packages": ["os"] is used as example only
-build_exe_options = {"packages": ["os"], "excludes": ["tkinter"], "include_msvcr": True, "include_files": ["icon.png", "config.yml", "keyfile-admin.pem"], "optimize": 2}
+build_exe_options = {"packages": ["os"], "excludes": ["tkinter"], "include_msvcr": True, "include_files": ["icon.png", "config.yml", "keyfile-admin.pem", "WXPython.png", "WXPython_30x30.png", "settings.png", "settings_30x30.png", "icon.ico"], "optimize": 1}
 
 # base="Win32GUI" should be used only for Windows GUI app
 base = None

ssh.py

@@ -5,25 +5,25 @@ from util import setup_child
 from util import fprint
 from invoke import exceptions
 import sys
-
+settings = None
 def sftp_send_data(config, filename, filetype):
     setup_child()
-    fprint("Connecting over SSH to " + config['sftp']['host'])
+    fprint("Connecting over SSH to " + config['sftp']['host'], settings)
     c = Connection(host=config['sftp']['host'], user=config['sftp']['user'], port=config['sftp']['port'], connect_kwargs={"key_filename": find_data_file(config['sftp']['keyfile']),})
-    fprint("Sending data over SFTP: " + filename)
+    fprint("Sending data over SFTP: " + filename, settings)
-    fprint(c.put(find_data_file(filename), remote=config['sftp']['filepath'][filetype]))
+    fprint(c.put(find_data_file(filename), remote=config['sftp']['filepath'][filetype]), settings)
-    fprint("Data sent over SFTP successfully")
+    fprint("Data sent over SFTP successfully", settings)
     #command = 'ls ' + config['sftp']['filepath'][filetype]
     #fprint(c.run(command))
 
 def check_for_file(config, filename, location):
     setup_child()
-    fprint("Connecting over SSH to " + config['sftp']['host'])
+    fprint("Connecting over SSH to " + config['sftp']['host'], settings)
     c = Connection(host=config['sftp']['host'], user=config['sftp']['user'], port=config['sftp']['port'], connect_kwargs={"key_filename": find_data_file(config['sftp']['keyfile']),})
-    fprint("Checking for existence of file " + config['sftp']['filepath'][location] + "/" + filename)
+    fprint("Checking for existence of file " + config['sftp']['filepath'][location] + "/" + filename, settings)
     try:
         res = c.run("ls -l " + config['sftp']['filepath'][location] + "/" + filename, hide=True)
-        fprint("File " + filename + " exists!")
+        fprint("File " + filename + " exists!", settings)
         return c.run("cat " + config['sftp']['filepath'][location] + "/" + filename, hide=True)
     except exceptions.UnexpectedExit:
         return False
@@ -32,8 +32,9 @@ def run_ssh(config, command, location):
     setup_child()
     fprint("Connecting over SSH to " + config['sftp']['host'])
     c = Connection(host=config['sftp']['host'], user=config['sftp']['user'], port=config['sftp']['port'], connect_kwargs={"key_filename": find_data_file(config['sftp']['keyfile']),})
-    fprint("cd to " + config['sftp']['filepath'][location])
+    fprint("cd to " + config['sftp']['filepath'][location], settings)
     with c.cd(config['sftp']['filepath'][location]):
-        fprint("Running ssh command: " + command)
+        fprint("Running ssh command: " + command, settings)
         res = c.run(command, hide=True, asynchronous=True)
         return res
+

taskbartool.py

@@ -42,7 +42,7 @@ class TaskBarIcon(wx.adv.TaskBarIcon):
         self.SetIcon(icon, TRAY_TOOLTIP)
 
     def on_left_down(self, event):      
-        fprint ('Tray icon was left-clicked.')
+        fprint ('Tray icon was left-clicked.', settings)
 
     def on_open(self, event):
         settings["showui"] = True
@@ -81,7 +81,7 @@ def background(data, sets, kill):
     app = TaskbarApp(False)
     displaydata = data
     settings = sets
-    fprint("Creating taskbar icon")
+    fprint("Creating taskbar icon", settings)
     app.MainLoop()
         
 TRAY_ICON = find_data_file('icon.png')

util.py

@@ -4,13 +4,16 @@ import subprocess
 import os
 from sys import platform
 import time as t
+from time import sleep
 import uuid
 
+logMsg = ""
+logCont = ""
 win32 = platform == "win32"
 linux = platform == "linux" or platform == "linux2"
 macos = platform == "darwin"
 datafile = ""
-
+settings=None
 if win32:
     sysid = hex(uuid.getnode())
     datafile += sysid
@@ -39,17 +42,31 @@ if linux:
 def time():
     return int(t.time())
 
-def fprint(msg):
+def kill(pid):
-    #if not getattr(sys, "frozen", False):
     setup_child()
+    if pid > 0:
+        fprint("Killing PID " + str(pid), settings)
+        os.kill(int(pid), 9)
+        fprint("Signal 9 sent to PID " + str(pid), settings)
+
+def fprint(msg, settings = None):
+    #if not getattr(sys, "frozen", False):
+    setup_child(settings)
     try:
         frm = inspect.stack()[1]
         
         mod = inspect.getmodule(frm[0])
-        print('[' + mod.__name__ + ":" + frm.function + ']:', str(msg))
+        logMsg = '[' + mod.__name__ + ":" + frm.function + ']:' + str(msg)
+        
+        print(logMsg)
+        if (settings is not None):
+            tmpList = settings["logMsg"]
+            tmpList.append(logMsg)
+            settings["logMsg"] = tmpList
     except Exception as e:
         try:
             print('[????:' + frm.function + ']:', str(msg))
+            print(e)
         except:
             print('[????]:', str(msg))
         
@@ -78,28 +95,38 @@ def run_cmd(cmd):
         #else:
         #    print("alt")
         startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW    # , "-WindowStyle", "hidden"
-        fprint("running PS command: " + cmd)
+        fprint("running PS command: " + cmd, settings)
         completed = subprocess.run(["powershell", "-Command", cmd], capture_output=True, startupinfo=startupinfo)
-        fprint("ran PS command successfully")
+        fprint("ran PS command successfully", settings)
         #completed = subprocess.run(["powershell", "-WindowStyle", "hidden", "-Command", cmd], capture_output=True, startupinfo=startupinfo)
         return completed
     if linux:
-        fprint("running sh command: " + cmd)
+        fprint("running sh command: " + cmd, settings)
         completed = subprocess.run(["sh", "-c", cmd], capture_output=True)
-        fprint("ran sh command successfully")
+        fprint("ran sh command successfully", settings)
         return completed
 
-def setup_child():
+def setup_child(sets=None):
     if not getattr(sys, "frozen", False):
         sys.stdout = Logger(filename=find_data_file("output.log"))
         sys.stderr = Logger(filename=find_data_file("output.log"))
+    if sets is not None:
+        settings = sets
+        
+
+
+
 
 class Logger(object):
     def __init__(self, filename="output.log"):
+        self.string = ""
         self.log = open(filename, "a")
         self.terminal = sys.stdout
 
     def write(self, message):
+        self.string += message
+        self.string += "\n"
+
         self.log.write(message)
         #close(filename)
         #self.log = open(filename, "a")
@@ -110,3 +137,7 @@ class Logger(object):
         
     def flush(self):
         print("", end="")
+
+def clear_fwll():
+    if win32:
+        run_cmd('Remove-NetFirewallRule -Group "IPPigeon"')