quick patch

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+build/
+config.yaml
+*.csv
+admin-key.ppk
+token.txt
+*.zip
+output.log
+output.log

auth.py

@@ -0,0 +1,43 @@
+import ssh
+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"
+    #return True
+    #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')
+    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:
+                # try again
+                count += 1
+                sleep(0.1)
+                filename = sysid + "success.txt"
+                #raise ValueError("Unable to determine login status")
+            else:
+                return False
+        else:
+            fprint(type(output))
+            if str(output).find("admin") >= 0 or str(output).find("Admin") >= 0:
+                fprint("Authorized as admin!")
+                return True
+            else:
+                fprint("Not admin")
+                return False
+    return False

block.py

@@ -0,0 +1,114 @@
+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, settings):
+    setup_child()
+    appendbad = settings["appendbad"]
+    whitelist = settings["whitelist"]
+    fprint("Downloading deny list from server")
+    try:
+        data = ssh.check_for_file(config, "BadIPs.csv", "receive")
+    except:
+        data = list()
+    #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)
+    for line in appendbad:
+        data2.append(line)
+    
+    for line in whitelist:
+        for line2 in data2:
+            if line[0] in line2 and line[1] in line2:
+                fprint("Whitelisting P1 " + line[0] + ":" + str(line[1]))
+                data2.remove(line2)
+                
+                if line[2] in settings["badapps"]:
+                    tmp = settings["badapps"]
+                    tmp.remove(line[2])
+                    settings["badapps"] = tmp
+                if line[0] in settings["badips"]:
+                    tmp = settings["badips"]
+                    tmp.remove(line[0])
+                    settings["badips"] = tmp
+                for line3 in settings["badlines"]:
+                    if line[0] in line3 and line[1] in line3:
+                        fprint("Whitelisting P2" + line[0] + ":" + str(line[1]))
+                        tmp = settings["badlines"]
+                        tmp.remove(line3)
+                        settings["badlines"] = tmp
+    
+    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")
+    goodct = 0
+    #fprint(mydata)
+    for line in mydata:
+        #fprint(line)
+        #fprint(line)
+        if line[0].find("0x") >= 0:
+            continue
+
+        srcip = line[2].split(":")[0]
+        srcport = line[2].split(":")[1]
+        destip = line[3].split(":")[0]
+        destport = line[3].split(":")[1]
+        pid = line[5]
+        try: 
+            pid = int(pid)
+        except ValueError:
+            continue
+        found = False
+        for line in baddata:
+            #fprint(destip + " " + line[4])
+            badsrcip = line[2]
+            badsrcport = line[3]
+            baddestip = line[4]
+            baddestport = line[5]
+            badpid = line[11]
+            
+            if ((srcip == badsrcip and srcport == badsrcport) or (destip == baddestip and destport == baddestport)) and not pid in badapps:
+                found = True
+                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)
+            
+        if not found:
+            goodct = goodct + 1
+    
+    return badapps, badips, badlines, goodct

config.yml

@@ -0,0 +1,19 @@
+core:
+  autostart: true
+  clockspeed: 20
+  interval: 10
+  level: 2
+  localadmin: true
+sftp:
+  filepath:
+    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

ippigeon.py

@@ -0,0 +1,354 @@
+import os
+import sys
+import subprocess
+from multiprocessing import Process, Manager, Pool, TimeoutError, freeze_support, active_children
+from sys import platform
+from time import sleep
+import uuid 
+import yaml
+from util import find_data_file
+from util import fprint
+from util import kill
+from util import run_cmd
+from notification import send_notification
+import taskbartool
+import util
+import netstat
+import ssh
+import auth
+import panel
+import block
+
+
+history = list()
+displaydata = None
+settings = None
+netdata_res = None
+procdata_res = None
+killme = None
+ppanel = None
+datafile = ""
+#print(datafile)
+config = None
+interval = 10
+win32 = platform == "win32"
+linux = platform == "linux" or platform == "linux2"
+macos = platform == "darwin"
+# Get unique system values
+if win32:
+    sysid = hex(uuid.getnode())
+    datafile += sysid
+    datafile += "gendata.csv"
+    # Python is running as Administrator (so netstat can get filename, to block, etc), 
+    # so we use this to see who is actually logged in
+    # it's very hacky
+    startupinfo = subprocess.STARTUPINFO()
+    #if not getattr(sys, "frozen", False):
+    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW # hide powershell window
+    res = subprocess.check_output(["WMIC", "ComputerSystem", "GET", "UserName"], universal_newlines=True, startupinfo=startupinfo)
+    _, username = res.strip().rsplit("\n", 1)
+    userid, sysdom = username.rsplit("\\", 1)
+
+if linux or macos:
+    sysid = hex(uuid.getnode())
+    #fprint(sysid)
+    datafile += sysid
+    datafile += "gendata.csv"
+    res = subprocess.check_output(["who",], universal_newlines=True)
+    userid = res.strip().split(" ")[0]
+    sysdom = subprocess.check_output(["hostname",], universal_newlines=True).strip()
+    #fprint(hostname)
+
+def netstat_done(res):
+    fprint("netstat done, processing", settings)
+    procdata_res = pool.apply_async(netstat.process, (res,), callback=process_done)
+    #netstat.process(res)
+
+def process_done(res):
+    if settings["running"] == True:
+        fprint("uploading to sftp...", settings)
+        #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
+    tmpstat = settings["stats"]
+    tmpstat[2] += 1
+    settings["stats"] = tmpstat
+
+def login_done(res):
+    if not res:
+        fprint("Login failure", settings)
+        settings["message"] = "Login failure"
+    else:
+        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, goodct = block.block_conn(config, datafile, res)
+    tmpstat = settings["stats"]
+    tmpstat[1] += goodct
+    if tmpstat[0] > 0 and goodct > 0:
+        tmpstat[4] = 1.0 / (goodct * 100.0 / tmpstat[0])
+    else: 
+        tmpstat[4] = 0.0
+    tmpstat[3] += 1
+    settings["stats"] = tmpstat
+
+    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 readstat_done(res):
+    settings["stats"] = res
+    fprint("Read stats!" + str(settings["stats"]), settings)
+
+
+def killall():
+    kids = active_children()
+    for kid in kids:
+        kid.kill()
+    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
+    global rawdata
+    global killme
+    global ppanel
+    #print(killme)
+    if killme.value > 0:
+        #print("killing")
+        util.clear_fwll() # clear the firewall rules before shutdown
+        killall()
+    #print(res.get(timeout=1))
+    if counter == 0: # runs every INTERVAL
+        #fprint("start loop")
+        if settings["stats"][1] > 0:
+            util.write_stats(settings["stats"])
+        if netdata_res is None or netdata_res.ready():
+            #rawdata = netdata_res.get()
+            #procdata_res = pool.apply_async(process_netstat, (rawdata))
+            fprint("netstat starting", settings)
+            netdata_res = pool.apply_async(netstat.start, callback=netstat_done)
+            #fprint(netdata_res.successful())
+    
+    # runs every 50ms
+    
+    if settings["continueui"] == True:
+        settings["continueui"] = False
+        #if ppanel is not None:
+            # login panel is already open
+        #    ppanel.terminate()
+        #    ppanel = Process(target=panel.openwindow, args=(displaydata,settings,killme))
+        #    ppanel.start()  
+
+    if settings["showui"] == True:
+        settings["showui"] = False
+        ppanel = Process(target=panel.openwindow, args=(displaydata,settings,killme))
+        ppanel.start()   
+
+    if settings["login"] == True:
+        login_res = pool.apply_async(auth.login, (config, settings["username"], settings["password"], sysid), callback=login_done)
+        #fprint(auth.login(config, settings["username"], settings["password"], sysid))
+        settings["login"] = False
+        
+    
+    if settings["block"] == True and settings["running"] == True:
+        #blockdata_res = pool.apply_async(block.get_blocklist, (config, settings), callback=blockdata_done)
+        res = block.get_blocklist(config, settings)
+        blockdata_done(res)
+        settings["block"] = False
+
+    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:
+            if x > 4 and x != 5316:
+                send_notification("Killing PID " + str(x))
+                kill(x)
+
+    if settings["fwll"] == True:
+        global history
+        tmplist = settings["badlines"]
+        tmpstat = settings["stats"]
+        tmpstat[0] += len(tmplist) 
+        settings["stats"] = tmpstat
+        settings["badlines"] = list()
+        for line in tmplist:
+            badproto = line[1]
+            badip = line[4]
+            badport = line[5]
+            
+            if (badip, badport) not in history:
+                fprint("Firewalling " + badip + ":" + str(badport), settings)
+                send_notification("Firewalling " + badip + ":" + str(badport))
+                history.append((badip, badport))
+                if win32:
+                    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 linux:
+                    cmd = "nft add rule ip ippigeon output ip daddr " + badip + " " + badproto.lower() + " dport " + str(badport) + " drop"
+                    run_cmd(cmd)
+                
+        settings["badapps"] = list()
+        
+    
+    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 * config["core"]["clockspeed"]:
+        counter = 0
+
+
+class Logger(object):
+    def __init__(self, filename="output.log"):
+        self.log = open(filename, "a")
+        self.terminal = sys.stdout
+
+    def write(self, message):
+        self.log.write(message)
+        #close(filename)
+        #self.log = open(filename, "a")
+        try:
+            self.terminal.write(message)
+        except:
+            sleep(0)
+        
+    def flush(self):
+        print("",end="")
+
+if __name__ == '__main__':
+    freeze_support() # required if packaged into single EXE
+    # create manager to share data to me, background, foreground
+    # create worker pool
+    
+    sys.stdout = Logger(filename=find_data_file("output.log"))
+    sys.stderr = Logger(filename=find_data_file("output.log"))
+    with Manager() as manager:
+        with Pool(processes=5) as pool:
+            
+            with open(find_data_file('config.yml'), 'r') as fileread:
+                #global config
+                config = yaml.safe_load(fileread)
+                #print(config['sftp']['host'])
+            interval = config['core']['interval']
+            displaydata = manager.list(range(2)) # data to be printed
+            settings = manager.dict() # configuration 
+            # setup shared data variables
+            settings["login"] = False
+            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["appendbad"] = list()
+            settings["logMsg"] = list()
+            settings["whitelist"] = list()
+            tmp = list()
+            tmp.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"])
+            tmp.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"])
+            tmp.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"])
+            tmp.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"])
+            tmp.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"])
+            tmp.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"])
+            tmp.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"])
+            settings["appendbad"] = tmp
+            # connections blocked, total connections allowed, count of data sent, data recieved, ratio blocked-unblocked
+            settings["stats"] = [0, 0, 0, 0, 0.0]
+
+            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
+            keeprunning = True
+
+            # initial setup
+            #netdata_res = pool.apply_async(netstat, callback=netstat_done)
+            if linux:
+                # clear existing nftables entries, create new table
+                run_cmd("nft delete table ip ippigeon")
+                run_cmd("nft create table ip ippigeon")
+                run_cmd("nft add chain ip ippigeon output { type filter hook output priority 0 \; policy accept\; }")
+                #run_cmd("nft add chain ippigeon filter")
+                
+            pool.apply_async(util.read_stats, callback=readstat_done)
+            # launch loop - non-blocking!
+            counter = 0
+            while(keeprunning):
+                mainloop(pool)

keyfile-admin.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAkKf5kPTTHIvL44Tfe7QO13K/JVfD+DbIwWQBURqa60ohVldN
+mWg7dngpMeHcr27JXLHfAT1c2ztbZR13ZZzKTpu1IbUtecVhCsduNtMzLehB8seQ
+0lPLAUeE76IK7KfYBUXNXnA5n9oFTS2DJwnYgSqAODbILOxbUpdRajTbacE3Mo0p
+nMLwvqcCwXXfKEhlcccclckDKkZYpwLfmuw7veD007NlBfq/lOezdFBERezEUIgr
++A22JP5KCsVeuQBJuuRrXdz8p334n2xaR4RDjN3p0cmMi2Oohm7M7MbhAImC/J+P
+HXOJMQpdEgD6Ea17Jr9ORPf08HrrjaZzA/SW7QIDAQABAoIBAEe07LKdmjTxW42a
+JUpl9GF6gSRawEs/pP6wuzJgFOGD6sipGE9uauOMJyeSBdp0+Z5YkepEZ85JO0IB
+fFlDgsm6x+xAqp1NaZB1Ub4draYZFu/pW3HXla85q706P14Wya+7bVVeHkKOSch7
+QiNM7yUAU3UKOuqB87caSYJzVzyxhUd5S6/ro2VNbXT/7vHSsKCja2scy+JaRhKn
+m4cc3P+ggI06JLfZsMZY1zJKDhbWiHGmB5ZdzqAJsu/bAtXWY25QsHowYAqPG7Uq
+7rcJlbbdkCASE4MXqi427uJfeqBB0vfykttSriBpQVBKus5wpcCEOMkpEho0zU0Z
+yx9bdeECgYEA9d0PDjAqIwrVSxjeOd6eXcSwmMzaK5fc5beptKRQA0U/O4swhn2+
+NOio6v6fTWuDwNHAsMZiDvW3boO357GCm2N7YkqvdarydfOt7IccsUnEROaAxOqx
+1wlnl0NkVIwaTo3XoRSWIcIqE3mCAaz8peqtRmIcXcQ/S9RGm3QeiAUCgYEAlp67
+vmn6Z1U0XLILnf4i9D3ECJlwJXEP64pB4XnXiHU/StaXY7CSRaCX+SxfgUR8pATQ
+ySYDRY1Ag6cHxSVIo1vkotT3P11x7/8yWnomvnEwRJqTMdN+/VuTi4tPzU1ScNXX
+F7aRqkNoGEkmsmi2wdszbJcruI74k4TGLcbNj8kCgYEAgG37AVRTjn6IMHRLETui
+yiSGgyrvBDqN30lzUrNKQIsZnsb0kCx7ATRPmIFtQYnaBw0KdM0MR/g+23HezR7C
+tNzghNWyleq4QLkLrzRc3pdD+SHXPgXC5Cs7e55ueGO/Ei2x56jTS8sbI5UjPjDY
+wOq3nL5/RtPOpJO8VlPv5ukCgYEAjytM/D9SdNyJzD61SjWiVhVL/HyVHBHvdw3R
+d5jQZfZE9kcqWekh8KspKgGiuoY2D9Y/+6N1YqxUkY+4lA3PkPAtURYr+wBA6Ebk
+PxpzL3z5y4w+tBL8V6mvguomLdj8ryKktPamWXh/Pu5xqQ5eAcDxjZvYRDMqV1bS
+5fpdtPkCgYEAoRVdlDSaj9u3NPoFkschl1bOZlJpm9tJVU+LoWxRe8tuLIwVDvXP
+JsZMcpfinEPWSrJN+hlGDuaq7k5LtSNeQoruaafhlE+CV54G7J2Khn8pRKWT+n/p
+36PfgGbhuLsZl8KDy+PXjS+L5A1kuTxB4rOBdHXIHm60aNCqB0BRcTM=
+-----END RSA PRIVATE KEY-----

known_hosts

@@ -0,0 +1 @@
+ec2-34-232-29-46.compute-1.amazonaws.com ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBM8sLlu0mu1PqYXk+a9XYHXXFiOaxk/2tIS5O3q+3ah13bd5Iz+NSxS0bXT7TdMTA/lD1kWMUXROEauADgIfT98=

netstat.py

@@ -0,0 +1,169 @@
+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 macos
+from ippigeon import settings
+import util
+import time
+import csv
+
+
+
+def process(data):
+    setup_child()
+    fprint("netstat processing", settings)
+    if win32:
+        #output = data.stdout
+        #print(output)
+        output = data.stdout.decode().split('\r\n') # split stdout into lines
+        #print(output)
+        if output[0].find("The requested operation requires elevation.") >= 0:
+            #print("test3")
+            raise PermissionError("Unable to acquire netstat data without admin!")
+        #print("test2")
+        output2 = list()
+        output2.append([util.sysid, util.userid, util.sysdom, util.time()]) # add metadata
+        #print(output2)
+        procname = ""
+        """for x in range(4, len(output)):
+                tmp = output[x].split(" ")
+                print(tmp)
+                tmp = [i for i in output[x] if i]
+                print(tmp)
+                print(len(tmp))
+                if len(len(tmp) == 1):
+                    procname = tmp[0]
+                    print(x)
+                else:
+                    print(x)
+                    output2[x] = list()
+                    output2[x].append(procname)
+                    output2[x].append(output[x].split(" "))
+                    output2[x] = [i for i in output2[x] if i]
+        output2 = [i for i in output2 if i]
+        print(output2)"""
+        x = len(output) - 1 # start at the end because filename comes after connection
+        procname = "Unknown" # if the very last connection happens to have no file (yes, it's possible), we can say unknown
+        while x > 3:
+            string = output[x]
+            #print("LINE: ", string)
+            string_split = string.split(" ")
+            string_split = [i for i in string_split if i]
+            if string.find("Can not obtain ownership information") >= 0: # Higher privilige than us, must be system
+                procname = "Windows System"
+            elif string.find("]") >= 0 and string.find("[") == 1: # generic [file.exe]
+                procname = string[2:-1]
+            elif len(string_split) == 5: # actual netstat line
+                tmp = [procname,] # add executable name first
+                tmp.extend(string.split(" "))
+                tmp = [i for i in tmp if i]
+                #print(tmp)
+                output2.append(tmp)
+            #else: # In case of an extra line above file, or an empty line, ignore it
+                #print("Garbage data", string)
+            x = x - 1
+        #output2 = output2[2:]
+        #print(output2)
+        with open(find_data_file(util.datafile), "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerows(output2)
+        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", settings)
+            raise PermissionError("Unable to acquire netstat data without admin!")
+        output2 = list()
+        output2.append([util.sysid, util.userid, util.sysdom, util.time()]) # add metadata
+        for line in output:
+            string_split = line.split(" ")
+            string_split = [i for i in string_split if i]
+            #fprint("Input: " + str(string_split))
+
+            if string_split[0].find("Active") >= 0 or string_split[0].find("Proto") >= 0:
+                continue
+            
+            if len(string_split) == 6: # no connection status
+                #fprint(string_split)
+                string_split.append(string_split[-1])
+                string_split[-2] = "UNKNOWN"
+                #fprint(string_split)
+            
+            procname = string_split[6]
+            if procname != "-":
+                string_split2 = procname.split("/")
+                procname = string_split2[1]
+                pid = string_split2[0]
+            else:
+                pid = "Unknown"
+            
+            output2.append([procname, string_split[0], string_split[3], string_split[4], string_split[5], pid]) 
+        #fprint(output2)
+        
+        with open(find_data_file(util.datafile), "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerows(output2)
+        fprint("done creating csv", settings)
+
+    if macos:
+        output = data.stdout.decode().split('\n') # split stdout into lines
+        #output = data.stdout.decode().split(',')
+        #fprint("output data: " + str(output))
+        output = [i for i in output if i]
+        if output[0].find("Not all processes could be identified") >= 0:
+            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
+        for line in output:
+            string_split = line.split(" ")
+            string_split = [i for i in string_split if i]
+            #fprint("Input: " + str(string_split))
+
+            if string_split[1].find("Multipath") >= 0:
+                break
+            if string_split[0].find("Active") >= 0 or string_split[0].find("Proto") >= 0:
+                continue
+            
+            if len(string_split) == 10: # no connection status
+                #fprint(string_split)
+                string_split.append(string_split[-1])
+                string_split[-7] = "UNKNOWN"
+                string_split[-4] = string_split[-5]
+                #fprint(string_split)
+            
+           
+            
+            output2.append(["Unknown", string_split[0], string_split[3], string_split[4], string_split[5], string_split[8]]) 
+        #fprint("FINAL CSV: " + str(output2))
+        
+        with open(find_data_file(util.datafile), "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerows(output2)
+        fprint("done creating csv", settings)
+
+
+def start():
+    setup_child()
+    fprint("netstat started", settings)
+    
+    if win32:
+        data = run_cmd("netstat -n -o -b")
+        fprint("data acquired", settings)
+        return data
+
+    if linux:
+        data = run_cmd("netstat -atunpw")
+        fprint("data acquired", settings)
+        return data
+
+    if macos:
+        data = run_cmd("netstat -anv")
+        fprint("data acquired", settings)
+        return data
+

notification.py

@@ -0,0 +1,19 @@
+from plyer import notification #for getting notification on your PC
+import sys
+from playsound import playsound #pip install playsound==1.2.2
+from util import find_data_file
+relative_path = (sys.path[0])
+sound = find_data_file('music.mp3')
+
+def send_notification(msg="Test notification"):
+    notification.notify(
+        title = "IP Pigeon",
+        message = msg,
+        app_name = "IPPigeon",
+        app_icon = find_data_file("icon.ico"),
+        timeout = 5 #number of seconds message is displayed
+    )
+    playsound(sound)
+
+if __name__ == '__main__':
+    send_notification() 

panel.py

@@ -0,0 +1,552 @@
+import glob
+import wx
+import logging
+import sys
+import wx.lib.buttons as buttons
+import numpy as np
+import pandas as pd
+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', '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=(1000, 675))
+        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', settings)
+
+    def on_window(self, event):
+       return
+
+
+class HelpFrame(wx.Frame):
+    """
+    Class used for creating frames other than the main one
+    """
+    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()
+
+
+# Panel with all the login widgets
+class LoginPanel(wx.Panel):
+    def __init__(self, parent):
+        super(LoginPanel, self).__init__(parent)
+        self.SetBackgroundColour((44, 51, 51))
+        basicLabel = wx.StaticText(self, -1, "Username")
+        basicLabel.SetForegroundColour((255,255,255))
+        global basicText
+        global pwdText
+        basicText = wx.TextCtrl(self, -1, "", size=(175, -1))
+        # basicText.SetInsertionPoint(0)
+        pwdLabel = wx.StaticText(self, -1, "Password")
+        pwdText = wx.TextCtrl(self, -1, "", size=(175, -1), style=wx.TE_PASSWORD)
+        #pwdText.Bind(wx.EVT_TEXT_ENTER, self.on_login) # press enter in password field to login
+        pwdLabel.SetForegroundColour((255, 255, 255))
+        vbox = wx.BoxSizer(wx.VERTICAL)
+        hbox = wx.BoxSizer(wx.HORIZONTAL)
+        vbox.Add(basicLabel, 0, wx.ALIGN_CENTER | 100, 5)
+        vbox.Add(basicText, 0, wx.ALIGN_CENTER | 100, 5)
+        vbox.Add(pwdLabel, 0, wx.ALIGN_CENTER | 100, 5)
+        vbox.Add(pwdText, 0, wx.ALIGN_CENTER | 100, 5)
+        login_button = wx.Button(self, label='Login')
+        login_button.Bind(wx.EVT_BUTTON, self.on_login)
+        #help_button = wx.Button(self, label='Help')
+        #help_button.Bind(wx.EVT_BUTTON, self.on_help)
+        # signup_button = wx.Button(self, label='Sign Up')
+        hbox.Add(login_button, 0, wx.ALL | 200, 20)
+        # hbox.Add(signup_button, 0, wx.ALL | 200, 20)
+        #hbox.Add(help_button, 0, wx.ALL | 200, 20)
+        vbox.Add(hbox, 0, wx.ALIGN_CENTER | 100, 5)
+        self.SetSizer(vbox)
+
+    def on_login(self, event):
+        # check for login verification
+        settings["username"] = basicText.GetValue()
+        settings["password"] = pwdText.GetValue()
+        settings["login"] = True
+        #self.Destroy()
+        self.Close()
+        self.Parent.Close()
+        #OtherFrame()
+
+    def on_help(self, event):
+        HelpFrame()
+
+
+# Panel with all the login widgets
+class HelpPanel(wx.Panel):
+    def __init__(self, parent):
+        super(HelpPanel, self).__init__(parent)
+        self.SetBackgroundColour((44, 51, 51))
+        # basicLabel = wx.StaticText(self, -1, "Username")
+        # basicLabel.SetForegroundColour((255,255,255))
+        # basicText = wx.TextCtrl(self, -1, "", size=(175, -1))
+        #
+        # # basicText.SetInsertionPoint(0)
+        # pwdLabel = wx.StaticText(self, -1, "Password")
+        # pwdText = wx.TextCtrl(self, -1, "", size=(175, -1), style=wx.TE_PASSWORD)
+        # pwdLabel.SetForegroundColour((255, 255, 255))
+        # vbox = wx.BoxSizer(wx.VERTICAL)
+        # hbox = wx.BoxSizer(wx.HORIZONTAL)
+        # vbox.Add(basicLabel, 0, wx.ALIGN_CENTER | 100, 5)
+        # vbox.Add(basicText, 0, wx.ALIGN_CENTER | 100, 5)
+        # vbox.Add(pwdLabel, 0, wx.ALIGN_CENTER | 100, 5)
+        # vbox.Add(pwdText, 0, wx.ALIGN_CENTER | 100, 5)
+        # login_button = wx.Button(self, label='Login')
+        # login_button.Bind(wx.EVT_BUTTON, self.on_login)
+        # help_button = wx.Button(self, label='Help')
+        # # signup_button = wx.Button(self, label='Sign Up')
+        # hbox.Add(login_button, 0, wx.ALL | 200, 20)
+        # # hbox.Add(signup_button, 0, wx.ALL | 200, 20)
+        # hbox.Add(help_button, 0, wx.ALL | 200, 20)
+        # vbox.Add(hbox, 0, wx.ALIGN_CENTER | 100, 5)
+        # self.SetSizer(vbox)
+
+
+class ServerPanel(wx.Panel):
+    def __init__(self, parent):
+        super().__init__(parent, size=(500, 500))
+        #self.SetBackgroundColour((44, 51, 51))
+        self.main_sizer = wx.BoxSizer(wx.VERTICAL)
+        self.secondary_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        self.sub_sizer_left = wx.BoxSizer(wx.VERTICAL)
+        self.sub_sizer_right = wx.BoxSizer(wx.VERTICAL)
+        self.sub_sizer_stats = wx.BoxSizer(wx.VERTICAL)
+        self.sub_sizer_filter = wx.BoxSizer(wx.VERTICAL)
+        self.row_obj_dict = {}
+        self.list_ctrl = wx.ListCtrl(
+            self, size=(-1, 400),
+            style=wx.LC_REPORT | wx.BORDER_SUNKEN
+        )
+        #tb = wx.ToolBar( self, -1)
+        #self.ToolBar = tb
+        #tb.SetToolBitmapSize(wx.Size(30, 3))
+        #tb.AddTool(wx.ID_ANY, '',wx.Bitmap(find_data_file("WXPython_30x30.png")),) 
+        #tb.AddTool(wx.ID_ANY, '',wx.Bitmap(find_data_file("settings_30x30.png"))) 
+        #tb.Realize() 
+        if settings["running"] == True:
+            txt = "Status: Running (" + str(settings["config"]["core"]["level"]) + ")"
+        else:
+            txt = "Status: Not running"
+
+        if settings["loggedin"] == True:
+            logintxt = "Logged in"
+        else:
+            logintxt = "Not logged in"
+        
+        stattxt = "Statistics:\nBlocked Connections: " + str(settings["stats"][0]) + " \nAllowed Connections: " + str(settings["stats"][1]) + " \nUpload count: " + str(settings["stats"][2]) + " \nDownload count: " + str(settings["stats"][3]) + " \nBlock ratio: " + str("{:.4f}".format(settings["stats"][4]))
+        self.statustext = wx.StaticText(self, label=txt) # pos=(20,20))
+        self.logintext = wx.StaticText(self, label=logintxt) # pos=(20,20))
+        self.stattext = wx.StaticText(self, label=stattxt)
+        #self.main_sizer.Add(tb)
+        #main_sizer.SetBackgroundColour((44, 51, 51))
+        # self.pnl1.SetBackgroundColour(wx.BLACK)
+        self.handle_columns()
+        #self.updatedata()
+        
+        self.main_sizer.Add(self.list_ctrl, 1, wx.ALL | wx.EXPAND, 20)
+        self.main_sizer.Add(self.secondary_sizer, 0, wx.ALL | wx.EXPAND, 20)
+        self.secondary_sizer.Add(self.sub_sizer_left, 0, wx.ALL | wx.CENTER, 20)
+        self.secondary_sizer.Add(self.sub_sizer_right, 0, wx.ALL | wx.CENTER, 20)
+        self.secondary_sizer.Add(self.sub_sizer_filter, 0, wx.ALL | wx.CENTER, 20)
+        self.secondary_sizer.Add(self.sub_sizer_stats, 0, wx.ALL | wx.CENTER, 20)
+        self.start_button = wx.Button(self, label='Start IPPigeon')
+        self.start_button.SetBackgroundColour((205, 215, 206))
+        self.start_button.Bind(wx.EVT_BUTTON, self.on_start)
+        #start_button.Bind(wx.EVT_ENTER_WINDOW, self.on_start)
+        self.stop_button = wx.Button(self, label='Stop IPPigeon')
+        self.stop_button.SetBackgroundColour('#F08080')
+        self.secondary_frame_button = wx.Button(self, label='Settings')
+        self.secondary_frame_button.Bind(wx.EVT_BUTTON, self.on_window)
+        # wx.BORDER(stop_button, wx.BORDER_NONE)
+        self.stop_button.Bind(wx.EVT_BUTTON, self.on_stop)
+
+        self.login_button = wx.Button(self, label='Login')
+        #self.login_button.SetBackgroundColour((205, 215, 206))
+        self.login_button.Bind(wx.EVT_BUTTON, self.on_login)
+        self.quit_button = wx.Button(self, label='Quit IPPigeon')
+        #self.login_button.SetBackgroundColour((205, 215, 206))
+        self.quit_button.Bind(wx.EVT_BUTTON, self.on_quit)
+
+        self.blacklist_button = wx.Button(self, label='Add to blacklist')
+        #self.login_button.SetBackgroundColour((205, 215, 206))
+        self.blacklist_button.Bind(wx.EVT_BUTTON, self.on_blacklist)
+
+        self.whitelist_button = wx.Button(self, label='Add to whitelist')
+        #self.login_button.SetBackgroundColour((205, 215, 206))
+        self.whitelist_button.Bind(wx.EVT_BUTTON, self.on_whitelist)
+        
+        self.log_button = wx.Button(self, label='Logs')
+        self.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)    
+
+        self.sub_sizer_right.Add(self.statustext, 0,  wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_right.Add(self.logintext, 0,  wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_left.Add(self.start_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_left.Add(self.stop_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_left.Add(self.secondary_frame_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_left.Add(self.log_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_right.Add(self.login_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_right.Add(self.quit_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_stats.Add(self.stattext, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_filter.Add(self.blacklist_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.sub_sizer_filter.Add(self.whitelist_button, 0, wx.CENTER | wx.ALL | 100, 5)
+        self.SetSizer(self.main_sizer)
+        self.start_button.Enable(enable=settings["loggedin"])
+        self.stop_button.Enable(enable=settings["loggedin"])
+        self.secondary_frame_button.Enable(enable=settings["loggedin"])
+        
+        wx.CallAfter(self.updatedata)
+        
+        wx.GetApp().ProcessPendingEvents() 
+
+    def handle_columns(self):
+        for col in range(len(COLUMN_NAMES)):
+            self.list_ctrl.InsertColumn(0, COLUMN_NAMES[col], width=COLUMN_SIZES[col])
+
+    def checklogin(self):
+        self.start_button.Enable(enable=settings["loggedin"])
+        self.stop_button.Enable(enable=settings["loggedin"])
+        self.secondary_frame_button.Enable(enable=settings["loggedin"])
+        self.quit_button.Enable(enable=settings["loggedin"])
+        if self.list_ctrl.GetFirstSelected() < 0:
+            self.blacklist_button.Enable(enable=False)
+            self.whitelist_button.Enable(enable=False)
+        else:
+            self.blacklist_button.Enable(enable=settings["loggedin"])
+            self.whitelist_button.Enable(enable=settings["loggedin"])
+    def updatedata(self):
+        global settings
+        if settings["running"] == True:
+            txt = "Status: Running (" + str(settings["config"]["core"]["level"]) + ")"
+        else:
+            txt = "Status: Not running"
+        #self.list_ctrl.SetSize(self.GetSize()[0] - 50, self.GetSize()[1] - 200)
+        self.checklogin()
+        if settings["loggedin"] == True:
+            logintxt = "   Logged in"
+            self.login_button.SetLabelText("Logout")
+        else:
+            self.login_button.SetLabelText("Login")
+            logintxt = "Not logged in"
+
+        stattxt = "Statistics:\nBlocked Connections: " + str(settings["stats"][0]) + " \nAllowed Connections: " + str(settings["stats"][1]) + " \nUpload count: " + str(settings["stats"][2]) + " \nDownload count: " + str(settings["stats"][3]) + " \nBlock ratio: " + str("{:.4f}".format(settings["stats"][4]))
+        
+        self.statustext.SetLabel(txt)
+        self.logintext.SetLabel(logintxt)
+        self.stattext.SetLabel(stattxt)
+        if settings["newdata"] == True:
+            settings["newdata"] = False
+        else:
+            wx.CallLater(100, self.updatedata)
+            return
+        fprint("updatedata called", settings)
+        loaddata()
+        list_total  = self.list_ctrl.GetItemCount()
+        list_top    = self.list_ctrl.GetTopItem()
+        list_pp     = self.list_ctrl.GetCountPerPage()
+        list_bottom = min(list_top + list_pp, list_total - 1)
+        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 app in settings["badapps"]:
+                #fprint(pid)
+                idx = i
+                if TEST_FILE.iloc[i, 5] == app: # "bad" pid, highlight in red at the top
+                    fprint("BAD APP UI: " + str(app), settings)
+                    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"]:
+            
+                    #fprint("Got " + TEST_FILE.iloc[i, 5])
+            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.list_ctrl.EnsureVisible((list_bottom - 1))
+        wx.CallLater(100, 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):
+        fprint("open settings", settings)
+        dg = GetData(parent = None)
+        dg.ShowModal()
+
+    def on_login(self, event):
+        fprint("open login", settings)
+        if settings["loggedin"] == True:
+            settings["loggedin"] = False
+            return
+        dg2 = ServerFrame()
+        
+        #dg2.ShowModal()
+    def on_quit(self, event):
+        global killme
+        killme.value += 1
+        self.Close()
+        self.Parent.Close()
+
+    def on_blacklist(self, event): 
+        global settings
+        tmp = settings["appendbad"]
+        idx = self.list_ctrl.GetFirstSelected()
+        if idx < 0:
+            return
+        proto = self.list_ctrl.GetItem(idx, 1).GetText()
+        dest = self.list_ctrl.GetItem(idx, 3).GetText()
+        destip, destport = dest.split(":")
+        fprint([proto, destip, destport], settings)
+        tmp.append(["N/A", proto, "N/A", "N/A", destip, destport, "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", "N/A"])
+        settings["appendbad"] = tmp
+        
+    def on_whitelist(self, event): 
+        global settings
+        tmp = settings["whitelist"]
+        idx = self.list_ctrl.GetFirstSelected()
+        if idx < 0:
+            return
+        proto = self.list_ctrl.GetItem(idx, 1).GetText()
+        dest = self.list_ctrl.GetItem(idx, 3).GetText()
+        pid = self.list_ctrl.GetItem(idx, 5).GetText()
+        destip, destport = dest.split(":")
+        fprint([proto, destip, destport], settings)
+        tmp.append([destip, destport, int(pid)])
+        settings["whitelist"] = tmp
+
+    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 == "":
+            self.bitmap = wx.StaticBitmap(self, -1, size=(0, 0))
+        else:
+            bmp = wx.Image(imageFile, wx.BITMAP_TYPE_ANY).ConvertToBitmap()
+            self.bitmap = wx.StaticBitmap(self, -1, bmp, (0, 0))
+    
+
+
+class ServerFrame(wx.Frame):
+    def __init__(self):
+        super().__init__(parent=None,
+                         title='Server Dashboard')
+
+        self.panel = LoginPanel(self)
+        # image = wx.StaticBitmap(self, wx.ID_ANY)
+        # image.SetBitmap(wx.Bitmap('WXPython.png'))
+        self.Show()
+
+def openwindow(data, sets, kill):
+    setup_child()
+    global killme
+    global settings
+    global displaydata
+    killme = kill
+    displaydata = data
+    settings = sets
+    #if settings["loggedin"]:
+    fprint("Creating server panel", settings)
+    loaddata()
+    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")
+    
+    #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)
+
+class logData(wx.Dialog):
+    def __init__(self, parent):
+        wx.Dialog.__init__(self, parent, wx.ID_ANY, "Logs: ", size = (800,500))
+        self.p = wx.Panel(self, wx.ID_ANY)
+        #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
+
+    def logLoop(self):
+        #self.logs.WriteText("before while loop\n")
+        i=0
+        #self.logs.Clear()
+        tmp = settings["logMsg"]
+        if (tmp is not None):
+            while(i < len(settings["logMsg"])):
+                #for i in range(len(settings["logMsg"])):
+                #self.logs.WriteText("in while loop\n")
+                self.logs.WriteText(settings["logMsg"][i])
+                self.logs.WriteText("\n")
+                tmp.remove(settings["logMsg"][i])
+                i+=1
+        else:
+            #self.logs.WriteText("settings is none :(")
+            tmp.add("init string for list")
+            logData.logLoop(self)
+        settings["logMsg"] = tmp
+        wx.CallLater(100, self.logLoop)
+        #self.logs.WriteText("after while loop\n")
+        
+
+
+        #redir = RedirectText(self.logs)
+        #sys.stdout = redir
+        #self.logs.WriteText(redir)
+
+        #self.logs.LoadFile('output.log')
+    
+    #def doLogging(self):
+        #self.logs.WriteText("hi from doLogging\n")
+        #self.logs.WriteText(settings["logMsg"])
+
+class GetData(wx.Dialog):
+    def __init__(self, parent):
+        wx.Dialog.__init__(self, parent, wx.ID_ANY, "User Settings: ", size = (800,500))
+        self.p = wx.Panel(self, wx.ID_ANY)
+        
+        self.hostname = wx.StaticText(self.p, label="Host:", pos=(20,20))
+        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')
+
+if __name__ == '__main__':
+    openwindow(list(), dict(), int())

release.sh

@@ -0,0 +1,57 @@
+#!/bin/bash
+#set -x
+
+TOKEN=$(< token.txt)
+EDITOR=nano git commit -a
+git push
+
+COMMIT=$(git log | head -n 1 | cut -d' ' -f2)
+echo $COMMIT
+export PATH=$PATH:"C:\Program Files\7-Zip"
+TAG=$(date +%s)
+"C:/Program Files/Python310/python.exe" setup.py build
+sleep 2
+mv ./build/exe.win-amd64-3.10/ ./build/ippigeon-win
+7z a -r release-$COMMIT.zip ./build/ippigeon-win
+7z a -sfx7z.sfx IPPigeon-install.exe ./build/ippigeon-win
+mv ./build/ippigeon-win/ ./build/exe.win-amd64-3.10
+#sleep 30
+DATA='{
+  "body": "Autogenerated release",
+  "draft": false,
+  "name": "Development release",
+  "prerelease": true,
+  "tag_name": "'$TAG'",
+  "target_commitish": "'$COMMIT'"
+}'
+OUT=$(curl -X 'POST' \
+  'https://git.deck.sh/api/v1/repos/Interfaz/ff/releases?token='$TOKEN'' \
+  -H 'accept: application/json' \
+  -H 'Content-Type: application/json' \
+  -d "$DATA")
+
+ID=$(echo $OUT | cut -d',' -f 1 | cut -d':' -f 2)
+
+OUT=$(curl -X 'POST' \
+  'https://git.deck.sh/api/v1/repos/Interfaz/ff/releases/'$ID'/assets?token='$TOKEN'' \
+  -H 'accept: application/json' \
+  -H 'Content-Type: multipart/form-data' \
+  -F 'attachment=@IPPigeon-install.exe;type=application/octet-stream')
+
+URL=$(echo $OUT | cut -d',' -f 7 | cut -d\" -f4)
+
+
+
+OUT=$(curl -X 'POST' \
+  'https://git.deck.sh/api/v1/repos/Interfaz/ff/releases/'$ID'/assets?token='$TOKEN'' \
+  -H 'accept: application/json' \
+  -H 'Content-Type: multipart/form-data' \
+  -F 'attachment=@'release-$COMMIT.zip';type=application/x-zip-compressed')
+
+URLZIP=$(echo $OUT | cut -d',' -f 7 | cut -d\" -f4)
+curl -d "Self extracting installer: $URL
+
+Portable Zip: $URLZIP" https://notify.deck.sh/ipro-release
+
+rm release-$COMMIT.zip
+rm IPPigeon-install.exe

requirements.txt

@@ -0,0 +1,10 @@
+fabric
+paramiko
+wxpython
+cx_Freeze
+pandas
+pyyaml
+numpy
+bcrypt
+plyer
+playsound==1.2.2

run.sh

@@ -0,0 +1,2 @@
+"C:/Program Files/Python310/python.exe" setup.py build
+

setup.py

@@ -0,0 +1,26 @@
+import sys
+from cx_Freeze import setup, Executable
+
+debug = True
+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", "plyer.platforms.win.notification"], "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", "music.mp3"], "optimize": 1}
+
+# base="Win32GUI" should be used only for Windows GUI app
+base = None
+if sys.platform == "win32" and not debug:
+    base = "Win32GUI"
+
+if sys.platform == "linux" or sys.platform == "linux2" or sys.platform == "darwin":
+    name = "IPPigeon"
+else:
+    name = "IPPigeon.exe"
+
+setup(
+    name="IP Pigeon",
+    version="0.2.4",
+    description="IP Pigeon client application",
+    options={"build_exe": build_exe_options},
+    executables=[Executable("ippigeon.py", base=base, icon="icon.ico", uac_admin=True, target_name=name)],
+)

ssh.py

@@ -0,0 +1,52 @@
+#from __future__ import with_statement
+from fabric import Connection
+from util import find_data_file
+from util import setup_child
+from util import fprint
+from util import macos
+from invoke import exceptions
+import sys
+
+c = None
+settings = None
+
+def sftp_send_data(config, filename, filetype):
+    setup_child()
+    if not macos:
+        fprint("Connecting over SSH to " + config['sftp']['host'], settings)
+        global c
+        if c is None:
+            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, settings)
+        fprint(c.put(find_data_file(filename), remote=config['sftp']['filepath'][filetype]), settings)
+        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'], settings)
+    global c
+    if c is None:
+        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, settings)
+    try:
+        res = c.run("ls -l " + config['sftp']['filepath'][location] + "/" + filename, hide=True)
+        fprint("File " + filename + " exists!", settings)
+        return c.run("cat " + config['sftp']['filepath'][location] + "/" + filename, hide=True)
+    except exceptions.UnexpectedExit:
+        return False
+
+def run_ssh(config, command, location):
+    setup_child()
+    fprint("Connecting over SSH to " + config['sftp']['host'], settings)
+    global c
+    if c is None:
+        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], settings)
+    with c.cd(config['sftp']['filepath'][location]):
+        fprint("Running ssh command: " + command, settings)
+        res = c.run(command, hide=True, asynchronous=True)
+        return res
+

taskbartool.py

@@ -0,0 +1,90 @@
+import glob
+import wx
+import wx.adv
+import os
+from time import sleep
+from sys import platform
+import sys
+from util import find_data_file
+from util import fprint
+from util import setup_child
+
+TRAY_TOOLTIP = 'IP Pigeon' 
+
+displaydata = None
+settings = None
+
+killme = False
+
+def create_menu_item(menu, label, func):
+    item = wx.MenuItem(menu, -1, label)
+    menu.Bind(wx.EVT_MENU, func, id=item.GetId())
+    menu.Append(item)
+    return item
+
+class TaskBarIcon(wx.adv.TaskBarIcon):
+    def __init__(self, frame):
+        self.frame = frame
+        super(TaskBarIcon, self).__init__()
+        self.set_icon(TRAY_ICON)
+        self.Bind(wx.adv.EVT_TASKBAR_LEFT_DOWN, self.on_left_down)
+
+    def CreatePopupMenu(self):
+        menu = wx.Menu()
+        create_menu_item(menu, 'Control Panel', self.on_open)
+        create_menu_item(menu, 'Login test', self.on_login)
+        menu.AppendSeparator()
+        create_menu_item(menu, 'Exit', self.on_exit)
+        return menu
+
+    def set_icon(self, path):
+        icon = wx.Icon(path)
+        self.SetIcon(icon, TRAY_TOOLTIP)
+
+    def on_left_down(self, event):      
+        fprint('Tray icon was left-clicked.', settings)
+
+    def on_open(self, event):
+        settings["showui"] = True
+        self.close_popup()
+
+    def on_login(self, event):
+        settings["username"] = "frontend"
+        settings["password"] = "qwertyuiop"
+        settings["login"] = True
+
+    def on_exit(self, event):
+        wx.CallAfter(self.Destroy)
+        global killme
+        killme.value += 1
+        self.close_popup()
+        #print("kill cmd")
+        
+
+    def close_popup(self):
+        self.frame.Close()
+
+class TaskbarApp(wx.App):
+    def OnInit(self):
+        frame=wx.Frame(None)
+        self.SetTopWindow(frame)
+        TaskBarIcon(frame)
+        
+        return True
+
+def background(data, sets, kill):
+    setup_child()
+    global killme
+    global settings
+    global displaydata
+    killme = kill
+    app = TaskbarApp(False)
+    displaydata = data
+    settings = sets
+    fprint("Creating taskbar icon", settings)
+    app.MainLoop()
+        
+TRAY_ICON = find_data_file('icon.png')
+
+if __name__ == "__main__":
+    background(list(), dict(), int())

taskbartool2.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env pythonw
+
+import wx
+import wx.adv
+import wx.lib.embeddedimage
+
+WXPdemo = wx.lib.embeddedimage.PyEmbeddedImage(
+    "iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAABHNCSVQICAgIfAhkiAAAAWlJ"
+    "REFUWIW1V1sSwjAIBMebeBU9db2KZ8EPmxbCI4TUnXGskWaXDQktwhjErjERP4XRhER08iPi"
+    "5SKiyQR5JyI7xxB3j7wn5GI6V2hFxM0gJtjYANFBiIjQu7L/1lYlwR0QxLDZhE0II1+CtwRC"
+    "RI8riBva7DL7CC9VAwDbbxwKtdDXwBi7K+1zCP99T1vDFedd8FBwYd6BCAUXuACEF7QsbET/"
+    "FaHs+gDQw4vOLNHkMojAnTw8nlNipIiwmR0DCXJbjCXkFCAL23BnpQgRWt1EMbyujCK9AZzZ"
+    "f+b3sX0oSqJQ6EorFeT4NiL6Wtj0+LXnQAzThYoAAsN6ehqR3sHExmcEqGeFApQLcTvm5Kt9"
+    "wkHGgb+RZwSkyc1dwOcpCtCoNKSz6FRCUQ3o7Nn+5Y+Lg+y5CIXlcyAk99ziiQS32+svz/UY"
+    "vClJoLpIC8gi+VwwfDecEiEtT/WZTJDf94uk1Ru8vbz0cvoF7S2DnpeVL9UAAAAASUVORK5C"
+    "YII=")
+
+class DemoTaskBarIcon(wx.adv.TaskBarIcon):
+    TBMENU_RESTORE = wx.NewId()
+    TBMENU_CLOSE   = wx.NewId()
+    TBMENU_CHANGE  = wx.NewId()
+    TBMENU_REMOVE  = wx.NewId()
+    
+    def __init__(self, frame):
+        wx.adv.TaskBarIcon.__init__(self)
+        self.frame = frame
+
+        # Set the image
+        icon = self.MakeIcon(WXPdemo.GetImage())
+        self.SetIcon(icon, "wxPython Demo")
+        self.imgidx = 1
+        
+        # bind some events
+        self.Bind(wx.adv.EVT_TASKBAR_LEFT_DCLICK, self.OnTaskBarActivate)
+        self.Bind(wx.EVT_MENU, self.OnTaskBarActivate, id=self.TBMENU_RESTORE)
+        self.Bind(wx.EVT_MENU, self.OnTaskBarClose, id=self.TBMENU_CLOSE)
+
+
+    def CreatePopupMenu(self):
+        """
+        This method is called by the base class when it needs to popup
+        the menu for the default EVT_RIGHT_DOWN event.  Just create
+        the menu how you want it and return it from this function,
+        the base class takes care of the rest.
+        """
+        menu = wx.Menu()
+        menu.Append(self.TBMENU_RESTORE, "Restore wxPython Demo")
+        menu.Append(self.TBMENU_CLOSE,   "Close wxPython Demo")
+        return menu
+
+
+    def MakeIcon(self, img):
+        """
+        The various platforms have different requirements for the
+        icon size...
+        """
+        if "wxMSW" in wx.PlatformInfo:
+            img = img.Scale(16, 16)
+        elif "wxGTK" in wx.PlatformInfo:
+            img = img.Scale(22, 22)
+        # wxMac can be any size upto 128x128, so leave the source img alone....
+        icon = wx.Icon("icon.png")
+        #self.SetIcon(icon, TRAY_TOOLTIP)
+        return icon
+    
+
+    def OnTaskBarActivate(self, evt):
+        if self.frame.IsIconized():
+            self.frame.Iconize(False)
+        if not self.frame.IsShown():
+            self.frame.Show(True)
+        self.frame.Raise()
+
+
+    def OnTaskBarClose(self, evt):
+        wx.CallAfter(self.frame.Close)
+
+
+
+class MainFrame(wx.Frame):
+    def __init__(self, parent):
+        wx.Frame.__init__(self, parent, title="Hello World")
+        self.tbicon = DemoTaskBarIcon(self)
+        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+    def OnCloseWindow(self, evt):
+        self.tbicon.Destroy()
+        evt.Skip()
+        
+
+app = wx.App(redirect=False)
+frame = MainFrame(None)
+frame.Show(True)
+app.MainLoop()

util.py

@@ -0,0 +1,173 @@
+import inspect
+import sys
+import subprocess
+import os
+from sys import platform
+import time as t
+from time import sleep
+import uuid
+import csv
+
+win32 = platform == "win32"
+linux = platform == "linux" or platform == "linux2"
+macos = platform == "darwin"
+datafile = ""
+logMsg = ""
+logCont = ""
+
+settings = None
+
+if win32:
+    sysid = hex(uuid.getnode())
+    datafile += sysid
+    datafile += "gendata.csv"
+    # Python is running as Administrator (so netstat can get filename, to block, etc), 
+    # so we use this to see who is actually logged in
+    # it's very hacky
+    startupinfo = subprocess.STARTUPINFO()
+    #if not getattr(sys, "frozen", False):
+    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW # hide powershell window
+    res = subprocess.check_output(["WMIC", "ComputerSystem", "GET", "UserName"], universal_newlines=True, startupinfo=startupinfo)
+    _, username = res.strip().rsplit("\n", 1)
+    userid, sysdom = username.rsplit("\\", 1)
+
+if linux or macos:
+    sysid = hex(uuid.getnode())
+    #fprint(sysid)
+    datafile += sysid
+    datafile += "gendata.csv"
+    res = subprocess.check_output(["who",], universal_newlines=True)
+    userid = res.strip().split(" ")[0]
+    sysdom = subprocess.check_output(["hostname",], universal_newlines=True).strip()
+    #fprint(sysdom)
+    #fprint("d")
+
+def time():
+    return int(t.time())
+
+def kill(pid):
+    setup_child()
+    try:
+        if pid > 4:
+            fprint("Killing PID " + str(pid), settings)
+            os.kill(int(pid), 9)
+            fprint("Signal 9 sent to PID " + str(pid), settings)
+    except:
+        fprint("Unable to kill " + str(pid), settings)
+
+def fprint(msg, settings = None):
+    #if not getattr(sys, "frozen", False):
+    setup_child()
+    try:
+        frm = inspect.stack()[1]
+        
+        mod = inspect.getmodule(frm[0])
+        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('[util:fprint]: ' + str(e))
+        except:
+            print('[????]:', str(msg))
+        
+        
+   # else:
+        #print(msg)
+
+def find_data_file(filename):
+    if getattr(sys, "frozen", False):
+        # The application is frozen
+        datadir = os.path.dirname(sys.executable)
+    else:
+        # The application is not frozen
+        # Change this bit to match where you store your data files:
+        datadir = os.path.dirname(__file__)
+    return os.path.join(datadir, filename)
+
+def run_cmd(cmd):
+    if win32:
+        startupinfo = subprocess.STARTUPINFO()
+        #print("DICKS")
+        #if not getattr(sys, "frozen", False):
+        #    print("test")
+        #    
+        #completed = subprocess.run(["powershell", "-Command", cmd], capture_output=True, startupinfo=startupinfo)
+        #else:
+        #    print("alt")
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW    # , "-WindowStyle", "hidden"
+        fprint("running PS command: " + cmd, settings)
+        completed = subprocess.run(["powershell", "-Command", cmd], capture_output=True, startupinfo=startupinfo)
+        fprint("ran PS command successfully", settings)
+        #completed = subprocess.run(["powershell", "-WindowStyle", "hidden", "-Command", cmd], capture_output=True, startupinfo=startupinfo)
+        return completed
+    if linux or macos:
+        fprint("running sh command: " + cmd, settings)
+        completed = subprocess.run(["sh", "-c", cmd], capture_output=True)
+        fprint("ran sh command successfully", settings)
+        return completed
+
+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.log = open(filename, "a")
+        self.terminal = sys.stdout
+
+    def write(self, message):
+        self.log.write(message)
+        #close(filename)
+        #self.log = open(filename, "a")
+        try:
+            self.terminal.write(message)
+        except:
+            sleep(0)
+        
+    def flush(self):
+        print("", end="")
+
+def clear_fwll():
+    if win32:
+        run_cmd('Remove-NetFirewallRule -Group "IPPigeon"')
+    if linux:
+        run_cmd("nft delete table ip ippigeon")
+
+
+def write_stats(stats):
+    fprint("Writing stats", settings)
+    tmp = list()
+    tmp.append(["connections blocked", "connections allowed", "data uploaded", "data recieved", "block ratio"])
+    tmp.append(stats)
+    
+    with open(find_data_file("stats.csv"), "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerows(tmp)
+    fprint("Done writing stats", settings)
+
+def read_stats():
+    with open(find_data_file("stats.csv"), newline='') as csvfile:
+        csvreader = csv.reader(csvfile, delimiter=',', quotechar='|')
+        header = True
+        fprint(csvreader, settings)
+        data = list()
+        for line in csvreader:
+            fprint(line, settings)
+            if header:
+                header = False
+                continue
+            data = line
+        for idx in range(len(data) - 1):
+            data[idx] = int(data[idx])
+        data[len(data) - 1] = float(data[len(data) - 1])
+        return data
+