mitm_main.py

from ArpSpoofing import ArpSpoofing
from DiscoverHosts import select_device
from PySharkCapture import PySharkCapture
from StaticCSVAnalysis import StaticCSVAnalysis
from UserState import UserState
from subprocess import call, PIPE
import argparse
import os
import signal
import sys
import time
import threading
from app import FlaskApp
import keyboard

"""
Use cases:
1. Specify the IP of target IoT device and the IP of the gateway router. The script skips scanning hosts and starts ARP poisoning
    sudo python mitm_main.py -t 192.168.0.215 -g 192.168.0.1

2. Specify a subnet mask for host scanning and the IP of the gateway router. The script scans the given subnet, prompts the user to select a target device and starts ARP poisoning.
    sudo python mitm_main.py -s 192.168.0.0/24 -g 192.168.0.1

3. Don't specify anything (like a regular user). The script scans common residential subnets and continues the same way as (2).
    sudo python mitm_main.py

4. Specify the path to a csv containing captured data. The script will start the Flask server and output a graph of the data.
    python mitm_main.py -f csv/packetdump_192.168.1.13_1574744945.csv
"""


def get_arguments():
    parser = argparse.ArgumentParser()
    parser.add_argument("-t", "--target", dest="target",
                        help="Target IP")
    parser.add_argument("-f", "--file", dest="file",
                        help="CSV file containing captured data")
    parser.add_argument("-u", "--userstate", dest="userstate",
                        help="User State file containing user's interaction with the IoT device")
    parser.add_argument("-g", "--gateway", dest="gateway",
                        help="Gateway IP")
    parser.add_argument("-s", "--scan", dest="scan",
                        help="Subnet mask for scanning hosts")
    options = parser.parse_args()
    return options

def cleanup():
    """
    Clean up and exit the script after user issues SIGTERM
    """
    # Close the flask app
    flask_app.restore_flag.set()

    # Close the pyshark capture
    pyshark_capture.restore_flag.set()
    pyshark_capture.join()

    # Restore the ARP Spoofing tables
    arp_spoofing.restore_flag.set()
    arp_spoofing.join()

    print("Performing static analysis on CSV file now ... ")
    file_name = 'csv/packetdump_' + target + '_' + timestamp + '.csv'
    StaticCSVAnalysis(csv_file=file_name)

    print("Static analysis finished. Press Ctrl+C again to stop the Flask Server ...")

    sys.exit(0)

options = get_arguments()
if options.file:
    flask_app = FlaskApp(target_file=options.file, userstate_file=options.userstate,
                         target_ip=None, file_timestamp=None)
    flask_app.start()

    try:
        while True:
            pass
    except KeyboardInterrupt:
        # Close the flask app
        flask_app.restore_flag.set()
        sys.exit(0)
else:
    if os.geteuid() != 0:
        print("Root privilege is needed to discover hosts using nmap.")
        sys.exit(1)

    target, gateway = select_device(options)

    arp_spoofing = ArpSpoofing(target, gateway)
    arp_spoofing.start()

    timestamp = str(round(time.time()))
    pyshark_capture = PySharkCapture(target, timestamp)
    pyshark_capture.start()
    user_state = UserState(target, timestamp)

    flask_app = FlaskApp(target_file=None, userstate_file=None,
                         target_ip=target, file_timestamp=timestamp)
    flask_app.start()

    try:
        speaking_button_debouncing = None  # a Unix epoch for the last time the "user speaking button" is pressed
        while True:
            # User can press Space to log his interaction with the voice assistant.
            # Ex. press Space once and begin speaking to Alexa; press it again after finish speaking
            # Assume adjacent presses of the key is at least 1 second away to debounce keyboard key press check
            if speaking_button_debouncing is not None and time.time() < speaking_button_debouncing + 1:
                continue
            if keyboard.is_pressed('space'):
                user_state.toggle_user_speaking_state()
                speaking_button_debouncing = time.time()
            elif keyboard.is_pressed('ctrl+c'):
                print(" User pressed Ctrl-C.")
                cleanup()

    except KeyboardInterrupt:
        cleanup()