apt2/core/actionModule.py at master · moss1993/apt2 · 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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
import time
from multiprocessing.pool import ThreadPool

from core.events import EventHandler
from core.keystore import KeyStore as kb
from core.packetcap import pktcap

class actionModule(object):
    seentargets = dict()

    def __init__(self, config, display, lock):
        self.display = display
        self.config = config
        self.safelevel = 1
        self.targets = []
        self.title = ""
        self.shortName = ""
        self.triggers = []
        self.requirements = []
        self.description = ""
        self.vector = ""
        self.lock = lock
        self.maxThreads = 100
        self.types = []

    def getTitle(self):
        return self.title

    def getDescription(self):
        return self.description

    def getSafeLevel(self):
        return self.safeLevel

    def getTriggers(self):
        return self.triggers

    def getRequirements(self):
        return self.requirements

    def getTypes(self):
        return self.types

    def getShortName(self):
        return self.shortName

    def getTargets(self):
        return None

    def getMaxThreads(self):
        return self.maxThreads

    def getVector(self):
        return self.vector

    def process(self):
        return

    def go(self, vector):
        self.vector = vector
        self.display.verbose("-> Running : " + self.getTitle())
        self.display.debug("---> " + self.getDescription())
        return self.process()

    def fire(self, trigger):
        EventHandler.fire(trigger + ":" + self.vector + "-" + self.shortName)

    def getVectorDepth(self):
        return len(self.vector.split('-'))

    def pktCap(self, filter="", packetcount=10, timeout=60, srcip="", dstip=""):
        pool = ThreadPool(processes=1)
        p = pktcap()

        # create new thread/process for the packet capture
        async_result = pool.apply_async(p.capture, (filter, timeout, packetcount, srcip, dstip,))

        # slepp for a second to allow everything to get set up
        time.sleep(1)

        return async_result

    def getPktCap(self, obj):
        if (obj):
            return obj.get()
        return ""

    def addseentarget(self, target):
        self.lock.acquire()

        if not self.getShortName() in actionModule.seentargets:
            actionModule.seentargets[self.getShortName()] = list()

        if not target in actionModule.seentargets[self.getShortName()]:
            actionModule.seentargets[self.getShortName()].append(target)
        self.lock.release()

    def seentarget(self, target):
        self.lock.acquire()

        # set default value
        value = False
        # check if "shortname" is a key in seentargets
        if self.getShortName() in actionModule.seentargets:
            # check if target is an element in the list
            if target in actionModule.seentargets[self.getShortName()]:
                value = True

        self.lock.release()

        return value

    def print_dict(self, d):
        string = ""
        for key, value in d:
            string += "%s: %s\n" % (key, value)
        return string

    def getUsers(self, host):
        return kb.get('host/' + host + '/user/')

    def getHostnames(self, host):
        return kb.get('host/' + host + '/hostname/')

    def addVuln(self, host, vuln, details={}):
        kb.add("host/" + host + "/vuln/" + vuln + "/module/" + self.shortName)
        kb.add("host/" + host + "/vuln/" + vuln + "/vector/" + self.vector)
        for key in details:
            kb.add("host/" + host + "/vuln/" + vuln + "/" + key + "/" + details[key])