misc: refactored code to work as a setup.py based package

Signed-off-by: Simone Margaritelli <evilsocket@gmail.com>

pwnagotchi/plugins/default/auto-backup.py

@@ -0,0 +1,63 @@
+__author__ = '33197631+dadav@users.noreply.github.com'
+__version__ = '1.0.0'
+__name__ = 'auto-backup'
+__license__ = 'GPL3'
+__description__ = 'This plugin backups files when internet is availaible.'
+
+from pwnagotchi.utils import StatusFile
+import logging
+import os
+import subprocess
+
+OPTIONS = dict()
+READY = False
+STATUS = StatusFile('/root/.auto-backup')
+
+
+def on_loaded():
+    global READY
+
+    if 'files' not in OPTIONS or ('files' in OPTIONS and OPTIONS['files'] is None):
+        logging.error("AUTO-BACKUP: No files to backup.")
+        return
+
+    if 'interval' not in OPTIONS or ('interval' in OPTIONS and OPTIONS['interval'] is None):
+        logging.error("AUTO-BACKUP: Interval is not set.")
+        return
+
+    if 'commands' not in OPTIONS or ('commands' in OPTIONS and OPTIONS['commands'] is None):
+        logging.error("AUTO-BACKUP: No commands given.")
+        return
+
+    READY = True
+    logging.info("AUTO-BACKUP: Successfuly loaded.")
+
+
+def on_internet_available(display, config, log):
+    global STATUS
+
+    if READY:
+        if STATUS.newer_then_days(OPTIONS['interval']):
+            return
+
+        files_to_backup = " ".join(OPTIONS['files'])
+        try:
+            logging.info("AUTO-BACKUP: Backing up ...")
+            display.set('status', 'Backing up ...')
+            display.update()
+
+            for cmd in OPTIONS['commands']:
+                logging.info(f"AUTO-BACKUP: Running {cmd.format(files=files_to_backup)}")
+                process = subprocess.Popen(cmd.format(files=files_to_backup), shell=True, stdin=None,
+                                          stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
+                process.wait()
+                if process.returncode > 0:
+                    raise OSError(f"Command failed (rc: {process.returncode})")
+
+            logging.info("AUTO-BACKUP: backup done")
+            STATUS.update()
+        except OSError as os_e:
+            logging.info(f"AUTO-BACKUP: Error: {os_e}")
+
+        display.set('status', 'Backup done!')
+        display.update()

pwnagotchi/plugins/default/auto-update.py

@@ -0,0 +1,56 @@
+__author__ = 'evilsocket@gmail.com'
+__version__ = '1.0.0'
+__name__ = 'auto-update'
+__license__ = 'GPL3'
+__description__ = 'This plugin performs an "apt update && apt upgrade" when internet is availaible.'
+
+import logging
+import subprocess
+from pwnagotchi.utils import StatusFile
+
+OPTIONS = dict()
+READY = False
+STATUS = StatusFile('/root/.auto-update')
+
+
+def on_loaded():
+    global READY
+
+    if 'interval' not in OPTIONS or ('interval' in OPTIONS and OPTIONS['interval'] is None):
+        logging.error("AUTO-UPDATE: Interval is not set.")
+        return
+
+    READY = True
+
+
+def on_internet_available(display, config, log):
+    global STATUS
+
+    if READY:
+        if STATUS.newer_then_days(OPTIONS['interval']):
+            return
+
+        try:
+            display.set('status', 'Updating ...')
+            display.update()
+
+            logging.info("AUTO-UPDATE: updating packages index ...")
+
+            update = subprocess.Popen('apt update -y', shell=True, stdin=None,
+                                      stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
+            update.wait()
+
+            logging.info("AUTO-UPDATE: updating packages ...")
+
+            upgrade = subprocess.Popen('apt upgrade -y', shell=True, stdin=None,
+                                       stdout=open("/dev/null", "w"), stderr=None, executable="/bin/bash")
+            upgrade.wait()
+
+            logging.info("AUTO-UPDATE: complete.")
+
+            STATUS.update()
+        except Exception as e:
+            logging.exception("AUTO-UPDATE ERROR")
+
+        display.set('status', 'Updated!')
+        display.update()

pwnagotchi/plugins/default/example.py

@@ -0,0 +1,170 @@
+__author__ = 'evilsocket@gmail.com'
+__version__ = '1.0.0'
+__name__ = 'hello_world'
+__license__ = 'GPL3'
+__description__ = 'An example plugin for pwnagotchi that implements all the available callbacks.'
+
+import logging
+
+from pwnagotchi.ui.components import LabeledValue
+from pwnagotchi.ui.view import BLACK
+import pwnagotchi.ui.fonts as fonts
+
+
+# Will be set with the options in config.yml config['main']['plugins'][__name__]
+OPTIONS = dict()
+
+# called when the plugin is loaded
+def on_loaded():
+    logging.warning("WARNING: plugin %s should be disabled!" % __name__)
+
+
+# called in manual mode when there's internet connectivity
+def on_internet_available(ui, config, log):
+    pass
+
+
+# called to setup the ui elements
+def on_ui_setup(ui):
+    # add custom UI elements
+    ui.add_element('ups', LabeledValue(color=BLACK, label='UPS', value='0%/0V', position=(ui.width() / 2 - 25, 0),
+                                       label_font=fonts.Bold, text_font=fonts.Medium))
+
+
+# called when the ui is updated
+def on_ui_update(ui):
+    # update those elements
+    some_voltage = 0.1
+    some_capacity = 100.0
+
+    ui.set('ups', "%4.2fV/%2i%%" % (some_voltage, some_capacity))
+
+
+# called when the hardware display setup is done, display is an hardware specific object
+def on_display_setup(display):
+    pass
+
+
+# called when everything is ready and the main loop is about to start
+def on_ready(agent):
+    logging.info("unit is ready")
+    # you can run custom bettercap commands if you want
+    #   agent.run('ble.recon on')
+    # or set a custom state
+    #   agent.set_bored()
+
+
+# called when the AI finished loading
+def on_ai_ready(agent):
+    pass
+
+
+# called when the AI finds a new set of parameters
+def on_ai_policy(agent, policy):
+    pass
+
+
+# called when the AI starts training for a given number of epochs
+def on_ai_training_start(agent, epochs):
+    pass
+
+
+# called after the AI completed a training epoch
+def on_ai_training_step(agent, _locals, _globals):
+    pass
+
+
+# called when the AI has done training
+def on_ai_training_end(agent):
+    pass
+
+
+# called when the AI got the best reward so far
+def on_ai_best_reward(agent, reward):
+    pass
+
+
+# called when the AI got the worst reward so far
+def on_ai_worst_reward(agent, reward):
+    pass
+
+
+# called when a non overlapping wifi channel is found to be free
+def on_free_channel(agent, channel):
+    pass
+
+
+# called when the status is set to bored
+def on_bored(agent):
+    pass
+
+
+# called when the status is set to sad
+def on_sad(agent):
+    pass
+
+
+# called when the status is set to excited
+def on_excited(agent):
+    pass
+
+
+# called when the status is set to lonely
+def on_lonely(agent):
+    pass
+
+
+# called when the agent is rebooting the board
+def on_rebooting(agent):
+    pass
+
+
+# called when the agent is waiting for t seconds
+def on_wait(agent, t):
+    pass
+
+
+# called when the agent is sleeping for t seconds
+def on_sleep(agent, t):
+    pass
+
+
+# called when the agent refreshed its access points list
+def on_wifi_update(agent, access_points):
+    pass
+
+
+# called when the agent is sending an association frame
+def on_association(agent, access_point):
+    pass
+
+
+# callend when the agent is deauthenticating a client station from an AP
+def on_deauthentication(agent, access_point, client_station):
+    pass
+
+
+# callend when the agent is tuning on a specific channel
+def on_channel_hop(agent, channel):
+    pass
+
+
+# called when a new handshake is captured, access_point and client_station are json objects
+# if the agent could match the BSSIDs to the current list, otherwise they are just the strings of the BSSIDs
+def on_handshake(agent, filename, access_point, client_station):
+    pass
+
+
+# called when an epoch is over (where an epoch is a single loop of the main algorithm)
+def on_epoch(agent, epoch, epoch_data):
+    pass
+
+
+# called when a new peer is detected
+def on_peer_detected(agent, peer):
+    pass
+
+
+# called when a known peer is lost
+def on_peer_lost(agent, peer):
+    pass

pwnagotchi/plugins/default/gps.py

@@ -0,0 +1,46 @@
+__author__ = 'evilsocket@gmail.com'
+__version__ = '1.0.0'
+__name__ = 'gps'
+__license__ = 'GPL3'
+__description__ = 'Save GPS coordinates whenever an handshake is captured.'
+
+import logging
+import json
+import os
+
+device = '/dev/ttyUSB0'
+speed = 19200
+running = False
+
+
+def on_loaded():
+    logging.info("gps plugin loaded for %s" % device)
+
+
+def on_ready(agent):
+    global running
+
+    if os.path.exists(device):
+        logging.info("enabling gps bettercap's module for %s" % device)
+        try:
+            agent.run('gps off')
+        except:
+            pass
+
+        agent.run('set gps.device %s' % device)
+        agent.run('set gps.speed %d' % speed)
+        agent.run('gps on')
+        running = True
+    else:
+        logging.warning("no GPS detected")
+
+
+def on_handshake(agent, filename, access_point, client_station):
+    if running:
+        info = agent.session()
+        gps = info['gps']
+        gps_filename = filename.replace('.pcap', '.gps.json')
+
+        logging.info("saving GPS to %s (%s)" % (gps_filename, gps))
+        with open(gps_filename, 'w+t') as fp:
+            json.dump(gps, fp)

pwnagotchi/plugins/default/memtemp.py

@@ -0,0 +1,68 @@
+# tempmem shows memory infos and cpu temperature
+#
+# totalmem usedmem freemem cputemp
+#
+__author__ = 'https://github.com/xenDE'
+__version__ = '1.0.0'
+__name__ = 'memtemp'
+__license__ = 'GPL3'
+__description__ = 'A plugin that will add a memory and temperature indicator'
+
+import struct
+
+from pwnagotchi.ui.components import LabeledValue
+from pwnagotchi.ui.view import BLACK
+import pwnagotchi.ui.fonts as fonts
+
+import time
+
+
+class MEMTEMP:
+
+    # set the minimum seconds before refresh the values
+    refresh_wait = 30
+    
+    refresh_ts_last = time.time() - refresh_wait
+    
+    def __init__(self):
+        # only import when the module is loaded and enabled
+        import os
+
+    def get_temp(self):
+        try:
+            temp = os.popen('/opt/vc/bin/vcgencmd measure_temp').readlines()[0].split('=')[1].replace("\n", '').replace("'","")
+            return 'cpu:' + temp
+        except:
+            return 'cpu:0.0C'
+        # cpu:37.4C
+
+    def get_mem_info(self):
+        try:
+            # includes RAM + Swap Memory:
+#            total, used, free = map(int, os.popen('free -t -m').readlines()[-1].split()[1:])
+            # without Swap, only real memory:
+            total, used, free = map(int, os.popen('free -t -m').readlines()[-3].split()[1:4])
+            return "tm:"+str(total)+" um:"+str(used)+" fm:"+str(free)
+        except:
+            return "tm:0 um:0 fm:0"
+        # tm:532 um:82 fm:353
+
+
+memtemp = None
+
+
+def on_loaded():
+    global memtemp
+    memtemp = MEMTEMP()
+
+
+def on_ui_setup(ui):
+    ui.add_element('memtemp', LabeledValue(color=BLACK, label='SYS', value='tm:0 um:0 fm:0 0.0C', position=(0, ui.height()-28),
+                                       label_font=fonts.Bold, text_font=fonts.Medium))
+
+
+def on_ui_update(ui):
+    if time.time() > memtemp.refresh_ts_last + memtemp.refresh_wait:
+        ui.set('memtemp', "%s %s" % (memtemp.get_mem_info(), memtemp.get_temp()))
+        memtemp.refresh_ts_last = time.time()
+

pwnagotchi/plugins/default/onlinehashcrack.py

@@ -0,0 +1,84 @@
+__author__ = '33197631+dadav@users.noreply.github.com'
+__version__ = '1.0.0'
+__name__ = 'onlinehashcrack'
+__license__ = 'GPL3'
+__description__ = 'This plugin automatically uploades handshakes to https://onlinehashcrack.com'
+
+import os
+import logging
+import requests
+
+READY = False
+ALREADY_UPLOADED = None
+OPTIONS = dict()
+
+
+def on_loaded():
+    """
+    Gets called when the plugin gets loaded
+    """
+    global READY
+    global EMAIL
+    global ALREADY_UPLOADED
+
+    if not 'email' in OPTIONS or ('email' in OPTIONS and OPTIONS['email'] is None):
+        logging.error("OHC: Email isn't set. Can't upload to onlinehashcrack.com")
+        return
+
+    try:
+        with open('/root/.ohc_uploads', 'r') as f:
+            ALREADY_UPLOADED = f.read().splitlines()
+    except OSError:
+        logging.warning('OHC: No upload-file found.')
+        ALREADY_UPLOADED = []
+
+    READY = True
+
+
+def _upload_to_ohc(path, timeout=30):
+    """
+    Uploads the file to onlinehashcrack.com
+    """
+    with open(path, 'rb') as file_to_upload:
+        data = {'email': OPTIONS['email']}
+        payload = {'file': file_to_upload}
+
+        try:
+            result = requests.post('https://api.onlinehashcrack.com',
+                    data=data,
+                    files=payload,
+                    timeout=timeout)
+            if 'already been sent' in result.text:
+                logging.warning(f"{path} was already uploaded.")
+        except requests.exceptions.RequestException as e:
+            logging.error(f"OHC: Got an exception while uploading {path} -> {e}")
+            raise e
+
+
+def on_internet_available(display, config, log):
+    """
+    Called in manual mode when there's internet connectivity
+    """
+    if READY:
+        handshake_dir = config['bettercap']['handshakes']
+        handshake_filenames = os.listdir(handshake_dir)
+        handshake_paths = [os.path.join(handshake_dir, filename) for filename in handshake_filenames]
+        handshake_new = set(handshake_paths) - set(ALREADY_UPLOADED)
+
+        if handshake_new:
+            logging.info("OHC: Internet connectivity detected. Uploading new handshakes to onelinehashcrack.com")
+
+            for idx, handshake in enumerate(handshake_new):
+                display.set('status', f"Uploading handshake to onlinehashcrack.com ({idx + 1}/{len(handshake_new)})")
+                display.update(force=True)
+                try:
+                    _upload_to_ohc(handshake)
+                    ALREADY_UPLOADED.append(handshake)
+                    with open('/root/.ohc_uploads', 'a') as f:
+                        f.write(handshake + "\n")
+                    logging.info(f"OHC: Successfuly uploaded {handshake}")
+                except requests.exceptions.RequestException:
+                    pass
+                except OSError as os_e:
+                    logging.error(f"OHC: Got the following error: {os_e}")
+

pwnagotchi/plugins/default/twitter.py

@@ -0,0 +1,46 @@
+__author__ = '33197631+dadav@users.noreply.github.com'
+__version__ = '1.0.0'
+__name__ = 'twitter'
+__license__ = 'GPL3'
+__description__ = 'This plugin creates tweets about the recent activity of pwnagotchi'
+
+import logging
+from pwnagotchi.voice import Voice
+
+OPTIONS = dict()
+
+def on_loaded():
+    logging.info("twitter plugin loaded.")
+
+
+# called in manual mode when there's internet connectivity
+def on_internet_available(ui, config, log):
+    if log.is_new() and log.handshakes > 0:
+        try:
+            import tweepy
+        except ImportError:
+            logging.error("Couldn't import tweepy")
+            return
+
+        logging.info("detected a new session and internet connectivity!")
+
+        picture = '/dev/shm/pwnagotchi.png'
+
+        ui.on_manual_mode(log)
+        ui.update(force=True)
+        ui.image().save(picture, 'png')
+        ui.set('status', 'Tweeting...')
+        ui.update(force=True)
+
+        try:
+            auth = tweepy.OAuthHandler(OPTIONS['consumer_key'], OPTIONS['consumer_secret'])
+            auth.set_access_token(OPTIONS['access_token_key'], OPTIONS['access_token_secret'])
+            api = tweepy.API(auth)
+
+            tweet = Voice(lang=config['main']['lang']).on_log_tweet(log)
+            api.update_with_media(filename=picture, status=tweet)
+            log.save_session_id()
+
+            logging.info("tweeted: %s" % tweet)
+        except Exception as e:
+            logging.exception("error while tweeting")

pwnagotchi/plugins/default/ups_lite.py

@@ -0,0 +1,64 @@
+# Based on UPS Lite v1.1 from https://github.com/xenDE
+#
+# funtions for get UPS status - needs enable "i2c" in raspi-config
+#
+# https://github.com/linshuqin329/UPS-Lite
+#
+# For Raspberry Pi Zero Ups Power Expansion Board with Integrated Serial Port S3U4
+# https://www.ebay.de/itm/For-Raspberry-Pi-Zero-Ups-Power-Expansion-Board-with-Integrated-Serial-Port-S3U4/323873804310
+# https://www.aliexpress.com/item/32888533624.html
+__author__ = 'evilsocket@gmail.com'
+__version__ = '1.0.0'
+__name__ = 'ups_lite'
+__license__ = 'GPL3'
+__description__ = 'A plugin that will add a voltage indicator for the UPS Lite v1.1'
+
+import struct
+
+from pwnagotchi.ui.components import LabeledValue
+from pwnagotchi.ui.view import BLACK
+import pwnagotchi.ui.fonts as fonts
+
+
+# TODO: add enable switch in config.yml an cleanup all to the best place
+class UPS:
+    def __init__(self):
+        # only import when the module is loaded and enabled
+        import smbus
+        # 0 = /dev/i2c-0 (port I2C0), 1 = /dev/i2c-1 (port I2C1)
+        self._bus = smbus.SMBus(1)
+
+    def voltage(self):
+        try:
+            address = 0x36
+            read = self._bus.read_word_data(address, 2)
+            swapped = struct.unpack("<H", struct.pack(">H", read))[0]
+            return swapped * 1.25 / 1000 / 16
+        except:
+            return 0.0
+
+    def capacity(self):
+        try:
+            address = 0x36
+            read = self._bus.read_word_data(address, 4)
+            swapped = struct.unpack("<H", struct.pack(">H", read))[0]
+            return swapped / 256
+        except:
+            return 0.0
+
+
+ups = None
+
+
+def on_loaded():
+    global ups
+    ups = UPS()
+
+
+def on_ui_setup(ui):
+    ui.add_element('ups', LabeledValue(color=BLACK, label='UPS', value='0%/0V', position=(ui.width() / 2 - 25, 0),
+                                       label_font=fonts.Bold, text_font=fonts.Medium))
+
+
+def on_ui_update(ui):
+    ui.set('ups', "%4.2fV/%2i%%" % (ups.voltage(), ups.capacity()))

pwnagotchi/plugins/default/wpa-sec.py

@@ -0,0 +1,83 @@
+__author__ = '33197631+dadav@users.noreply.github.com'
+__version__ = '1.0.0'
+__name__ = 'wpa-sec'
+__license__ = 'GPL3'
+__description__ = 'This plugin automatically uploades handshakes to https://wpa-sec.stanev.org'
+
+import os
+import logging
+import requests
+
+READY = False
+ALREADY_UPLOADED = None
+
+
+def on_loaded():
+    """
+    Gets called when the plugin gets loaded
+    """
+    global READY
+    global API_KEY
+    global ALREADY_UPLOADED
+
+    if not 'api_key' in OPTIONS or ('api_key' in OPTIONS and OPTIONS['api_key'] is None):
+        logging.error("WPA_SEC: API-KEY isn't set. Can't upload to wpa-sec.stanev.org")
+        return
+
+    try:
+        with open('/root/.wpa_sec_uploads', 'r') as f:
+            ALREADY_UPLOADED = f.read().splitlines()
+    except OSError:
+        logging.warning('WPA_SEC: No upload-file found.')
+        ALREADY_UPLOADED = []
+
+    READY = True
+
+
+def _upload_to_wpasec(path, timeout=30):
+    """
+    Uploads the file to wpa-sec.stanev.org
+    """
+    with open(path, 'rb') as file_to_upload:
+        headers = {'key': OPTIONS['api_key']}
+        payload = {'file': file_to_upload}
+
+        try:
+            result = requests.post('https://wpa-sec.stanev.org/?submit',
+                    headers=headers,
+                    files=payload,
+                    timeout=timeout)
+            if ' already submitted' in result.text:
+                logging.warning(f"{path} was already submitted.")
+        except requests.exceptions.RequestException as e:
+            logging.error(f"WPA_SEC: Got an exception while uploading {path} -> {e}")
+            raise e
+
+
+def on_internet_available(display, config, log):
+    """
+    Called in manual mode when there's internet connectivity
+    """
+    if READY:
+        handshake_dir = config['bettercap']['handshakes']
+        handshake_filenames = os.listdir(handshake_dir)
+        handshake_paths = [os.path.join(handshake_dir, filename) for filename in handshake_filenames]
+        handshake_new = set(handshake_paths) - set(ALREADY_UPLOADED)
+
+        if handshake_new:
+            logging.info("WPA_SEC: Internet connectivity detected.\
+                          Uploading new handshakes to wpa-sec.stanev.org")
+
+            for idx, handshake in enumerate(handshake_new):
+                display.set('status', f"Uploading handshake to wpa-sec.stanev.org ({idx + 1}/{len(handshake_new)})")
+                display.update(force=True)
+                try:
+                    _upload_to_wpasec(handshake)
+                    ALREADY_UPLOADED.append(handshake)
+                    with open('/root/.wpa_sec_uploads', 'a') as f:
+                        f.write(handshake + "\n")
+                    logging.info(f"WPA_SEC: Successfuly uploaded {handshake}")
+                except requests.exceptions.RequestException:
+                    pass
+                except OSError as os_e:
+                    logging.error(f"WPA_SEC: Got the following error: {os_e}")