def __init__(self, config, filename):
Thread.__init__(self)
try:
import pcapy
self.pcap = pcapy
except:
print_dizzy(
"No usable pcap library found. Be sure you have pcapy installed!"
)
print_dizzy("Pcap recording disabled!")
self.pcap = None
return
self.interface = config.get("interface", "any")
check_root("use the PCAP feature")
print_dizzy("pcap/init: listening on interface '%s'." % self.interface,
VERBOSE_1)
if not self.interface is "any":
if not self.interface in self.pcap.findalldevs():
print_dizzy(
"Device '%s' not found, recording on _all_ interfaces.")
self.interface = "any"
self.filter = config.get("filter", "")
if not self.filter is "":
print_dizzy("pcap/init: using bpf '%s'." % self.filter, VERBOSE_1)
self.snaplen = config.getint("snaplen", 8192)
self.promisc = config.getboolean("promisc", True)
self.to_ms = config.getint("to_ms", 10)
self.cooldown = config.getint("cooldown", 0)
self.filename = filename
self.is_open = False
def parse_interaction(file,
filename,
fuzz="std",
start_at=0,
config_values={}):
def not_impl(*args, **kwargs):
raise InteractParseException("Not implemented")
def load_dizz_conf(*args, **kwargs):
if not 'config_values' in kwargs:
kwargs['config_values'] = config_values
return load_dizz(*args, **kwargs)
def config_value(name):
return config_values[name]
ns = {
"Dizzy": load_dizz_conf,
"NullDizzy": null_dizz,
"copy": not_impl,
"call": call,
"f": not_impl,
"print_dizz": not_impl,
"print_field": not_impl,
"global": CONFIG["GLOBALS"]["INTERACTION_GLOBALS"],
"get_session": lambda: CONFIG["GLOBALS"]["SESSION"],
"config_value": config_value
}
exec(compile(file, filename, 'exec'), ns)
act = Interaction(ns["name"], ns["objects"], ns["functions"], fuzz,
start_at)
print_dizzy("interaction/%s: '%s'." % (act.name, act.dump()), DEBUG)
return act
def probe(self):
try:
self.socket = socket(self.af, SOCK_STREAM)
if self.target_host == "255.255.255.255":
self.socket.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
self.socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.socket.settimeout(self.timeout)
if not self.source_host is None and not self.source_port is None:
self.socket.bind((self.source_host, self.source_port))
except Exception as e:
if not self.socket is None:
self.socket.close()
print_dizzy("probe/tcp: open error: %s" % e)
print_dizzy(e, DEBUG)
for attempt in range(1, self.retry + 1):
print_dizzy("probe/tcp: probe attempt: %d" % attempt, VERBOSE_1)
try:
self.socket.connect((self.target_host, self.target_port))
except (ConnectionAbortedError, ConnectionRefusedError) as e:
pass
except Exception as e:
print_dizzy("probe/tcp: probe error: '%s'" % type(e))
print_dizzy(e, DEBUG)
else:
self.socket.close()
return True
return False
def check_root(text):
if hasattr(os, 'geteuid'):
if os.geteuid() != 0:
print_dizzy("You must be root to " + text + ".")
exit(1)
else:
if ctypes.windll.shell32.IsUserAnAdmin() != 1:
print_dizzy("You must be Admin to " + text + ".")
exit(1)
def open(self):
try:
self.socket = socket(self.af, SOCK_RAW, self.proto)
except error as e:
if not self.socket is None:
self.socket.close()
print_dizzy("probe/icmp: open error: '%s'" % e)
print_dizzy(e, DEBUG)
self.is_open = True
def func(dizzy_iterator):
if target not in dizzy_iterator.current_mutated_objects:
size = dizzy_iterator[target].size
value = Value(
pack_with_length(dizzy_iterator[start:stop].size, size,
endian), size)
print_dizzy("length/%s: seting to %s." % (target, value), DEBUG)
dizzy_iterator[target] = value
else:
print_dizzy("length/%s: is not updated." % (target, ), DEBUG)
def send(self, data):
try:
self.s.sendto(data, (self.dest, self.dport))
except Exception as e:
if self.auto_reopen:
print_dizzy("session/udp: session got closed '%s', autoreopening..." % e, DEBUG)
self.close()
self.open()
else:
self.close()
raise SessionException("error on sending '%s', connection closed." % e)
def func(dizzy_iterator):
if target not in dizzy_iterator.current_mutated_objects:
size = str((dizzy_iterator[start:stop].size + 7) // 8)
value = Value(bytes(size, encoding), len(size) * 8)
print_dizzy(
"length_string_bytes/%s: seting to %s." % (target, value),
DEBUG)
dizzy_iterator[target] = value
else:
print_dizzy("length_string_bytes/%s: is not updated." % (target, ),
DEBUG)
def send(self, data):
try:
self.f.write(hexlify(data))
except Exception as e:
if self.auto_reopen:
print_dizzy(
"session/stdout-hex: session got closed '%s', autoreopening..."
% e, DEBUG)
self.close()
self.open()
else:
self.close()
raise SessionException(
"error on sending '%s', connection closed." % e)
def all_methods(self):
(addr, port) = self.client_address
if addr == self.dest:
print_dizzy(
"http/request_handler: handling request from %s" %
addr, VERBOSE_2)
while True and not self.server._BaseServer__shutdown_request:
with self.recv_lock:
if len(self.rlist) == 0:
break
print_dizzy("http/request_handler: rlist not empty",
DEBUG)
sleep(0.1)
with self.recv_lock:
length = int(self.headers['content-length'])
self.rlist.append(self.rfile.read(length))
while True and not self.server._BaseServer__shutdown_request:
with self.send_lock:
if len(self.slist) == 1:
break
print_dizzy("http/request_handler: slist empty", DEBUG)
sleep(0.1)
with self.send_lock:
data = self.slist.pop()
self.send_response(200)
for i in self.set_headers:
self.send_header(i, self.set_headers[i])
self.send_header('Content-Length', len(data))
self.end_headers()
self.wfile.write(data)
else:
print_dizzy(
"http/request_handler: denied access for %s" % addr,
VERBOSE_2)
def stop(self):
if self.pcap is None:
return
if self.cooldown > 0:
print_dizzy(
"pcap/stop: cooling down for %d seconds." % self.cooldown,
VERBOSE_1)
sleep(self.cooldown)
self.run = False
self.is_open = False
self.pcap_dumper.close()
print_dizzy(
"pcap/stop: pcap dumper closed for file '%s'." % self.filename,
VERBOSE_2)
def probe(self):
if not self.is_open:
print_dizzy("probe/tcp: not opened.", DEBUG)
return False
for attempt in range(1, self.retry + 1):
print_dizzy("probe/icmp: probe attempt: %d" % attempt, VERBOSE_1)
try:
if self.af == AF_INET6:
self.socket.sendto(self.header + self.data, (self.target_host, 0, 0, 0))
else:
self.socket.sendto(self.header + self.data, (self.target_host, 0))
if self.af == AF_INET6:
(data, (address, _, _, _)) = self.socket.recvfrom(2048)
if address == self.target_host:
pid, = unpack("!H", data[4:6])
if data[0] == self.ICMP6_ECHO_REPLY and pid == self.pid:
return True
else:
(data, (address, _)) = self.socket.recvfrom(2048)
if address == self.target_host:
hl = (data[0] & 0x0f) * 4
pid, = unpack("!H", data[hl + 4:hl + 6])
if data[hl] == self.ICMP_ECHO_REPLY and pid == self.pid:
return True
except error as e:
print_dizzy("probe/icmp: reopening: '%s'" % e)
print_dizzy(e, DEBUG)
self.close()
self.open()
return False
def call_functions(self, when=PRE):
# Call the functions of the objects, if it is a dizz object(nested dizz)
for a in self.state:
if a.is_dizz():
a.call_functions(when)
# Call the functions
for (func, call_at) in self.dizz.functions:
if call_at == when or call_at == BOTH:
try:
func(self)
except Exception as e:
print_dizzy("%s: Exception in function: %s" %
(self.dizz, e))
return self.get_current_state()
def do_probe(self):
res = True
if not self.probe is None:
if 'pcap' in self.config:
self.pcap = Pcap(self.config['pcap'], path.join(self.tempdir.name, "trace-%s-probe.pcap" % self.index))
self.pcap.start()
while not self.pcap.is_open:
sleep(0.1)
res = self.probe.probe()
if not self.pcap is None:
self.pcap.stop()
self.pcap.join()
if not res:
print_dizzy("job/run: probe failed")
return res
def read_with_length(data, length, endian='!'):
try:
out = None
if length <= 8:
(out,) = unpack("%sB" % endian, data[0])
elif length <= 16:
(out,) = unpack("%sH" % endian, data[0:1])
elif length <= 32:
(out,) = unpack("%sI" % endian, data[0:3])
elif length <= 64:
(out,) = unpack("%sQ" % endian, data[0:7])
else:
raise DizzyRuntimeException("cant read with len >64")
except Exception as e:
print_dizzy("Can't unpack %s: %s" % (data, str(e)), DEBUG)
raise e
def call_functions(self):
if self.current_object is None:
return None
# Call the act functions
if self.index in self.interaction.functions:
# There is a function list to call
for func in self.interaction.functions[self.index]:
try:
func(self, self.current_object.iter,
self.interaction.response)
except Exception as e:
print_dizzy("%s: Exception in function" % self.interaction)
print_dizzy(e)
# Call the dizz functions(for example to correct the length fields) and return the current state
return self.current_object.call_functions(POST)
def send(self, data):
try:
if not self.server_side:
headers = self.headers
cookies = ";".join(
["%s=%s" % (n, v) for (n, v) in self.cookies.items()])
if len(cookies) > 0:
headers.update({"Cookie": cookies})
self.connection.request(self.method,
self.url,
body=data,
headers=headers)
self.res = self.connection.getresponse()
headers = dict(self.res.getheaders())
for h in headers:
if h == "Set-Cookie":
try:
nv = headers[h].split(";")[0].split("=")
self.cookies[nv[0]] = nv[1]
except:
print_dizzy(
"http/send: failed to parse set-cookie: %s" %
headers[h], VERBOSE_1)
else:
while True:
with self.send_lock:
if len(self.slist) == 0:
break
print_dizzy("http/send: slist not empty", DEBUG)
sleep(0.1)
with self.send_lock:
self.slist.append(data)
print_dizzy("http/send: pushed %s" % data, DEBUG)
except Exception as e:
if self.auto_reopen:
print_dizzy(
"http/send: session got closed '%s', auto reopening..." %
e, DEBUG)
print_dizzy(e, DEBUG)
self.close()
self.open()
else:
self.close()
raise SessionException(
"http/send: error on sending '%s', connection closed." % e)
def recv(self):
#from traceback import print_stack
#print_stack()
if not self.server_side:
if not self.res is None:
return self.res.read()
else:
while True:
with self.recv_lock:
if len(self.rlist) == 1:
break
print_dizzy("http/recv: rlist empty", DEBUG)
sleep(0.1)
with self.recv_lock:
data = self.rlist.pop()
print_dizzy("http/recv: poped %s" % data, DEBUG)
return data
def run(self):
if self.pcap is None:
return
self.run = True
self.pcap_object = self.pcap.open_live(self.interface, self.snaplen,
self.promisc, self.to_ms)
print_dizzy("pcap/run: pcap object opened.", VERBOSE_2)
if not self.filter is "":
self.pcap_object.setfilter(self.filter)
self.pcap_dumper = self.pcap_object.dump_open(self.filename)
print_dizzy(
"pcap/run: pcap dumper opened for file '%s'." % self.filename,
VERBOSE_2)
self.is_open = True
while self.run:
hdr, data = self.pcap_object.next()
if not hdr is None:
if self.is_open:
self.pcap_dumper.dump(hdr, data)
def send(self, data, streamid=None):
try:
if not self.maxsize is None and len(data) > self.maxsize:
data = data[:self.maxsize - 1]
print_dizzy("session/sctp: Truncated data to %d byte." % self.maxsize, DEBUG)
if not streamid is None:
sndrcvinfo = sctp_sndrcvinfo()
sndrcvinfo.sinfo_stream = streamid
sndrcvinfo.sinfo_ppid = htonl(self.ppid)
self.s.sendmsg([data], [(self.IPPROTO_SCTP, self.SCTP_SNDRCV, sndrcvinfo)], 0, (self.dest, self.dport))
else:
self.s.sendto(data, (self.dest, self.dport))
except Exception as e:
if self.auto_reopen:
print_dizzy("session/sctp: session got closed '%s', autoreopening..." % e, DEBUG)
self.close()
self.open()
else:
self.close()
raise SessionException("error on sending '%s', connection closed." % e)
def send(self, data):
try:
if not self.maxsize is None and len(data) > self.maxsize:
data = data[:self.maxsize - 1]
print_dizzy("Truncated data to %d byte." % self.maxsize, DEBUG)
if self.server_side:
if not self.cs:
raise SessionException("no client connection, cant send")
self.cs.send(data)
else:
self.s.send(data)
except Exception as e:
if self.auto_reopen:
print_dizzy("session got closed '%s', autoreopening..." % e,
DEBUG)
self.close()
self.open()
else:
self.close()
raise SessionException(
"error on sending '%s', connection closed." % e)
def probe(self):
if not self.is_open:
print_dizzy("probe/http: not opened.", DEBUG)
return False
for attempt in range(1, self.retry + 1):
print_dizzy("probe/http: probe attempt: %d" % attempt, VERBOSE_1)
try:
self.connection.request(self.method, self.url, body=self.body, headers=self.headers)
self.res = self.connection.getresponse()
self.connection.close()
except Exception as e:
print_dizzy("probe/http: probe error: '%s'" % type(e))
print_dizzy(e, DEBUG)
else:
return True
return False
def print_status(self):
self.state_lock.acquire()
self.time_list.append(time() - self.start_time)
time_mean = mean(self.time_list)
if len(self.time_list) > self.TIME_LIST_MAX_LEN:
self.time_list = [time_mean] * 50
secs = (self.mutations - self.index) * time_mean
m, s = divmod(secs, 60)
h, m = divmod(m, 60)
d, h = divmod(h, 24)
self.start_time = time()
status = "%05.2f%% %i/%i iterations done.\n" % ((self.index / self.mutations) * 100, self.index, self.mutations)
if d == 0:
status += "eta %02d:%02d:%02d" % (h, m, s)
else:
status += "eta %d days %02d:%02d:%02d" % (d, h, m, s)
if self.print_index == self.index or print_level == DEBUG:
print_dizzy(status)
self.print_index *= 2
self.state_lock.release()
def __init__(self, config_file, start_at=0, options={}, daemon=True):
Thread.__init__(self, daemon=daemon)
self.config_file = config_file
self.config = ConfigParser(allow_no_value=True, interpolation=None)
if path.exists(config_file):
self.config.read(config_file)
elif config_file in CONFIG["JOB"]:
self.config.read_string(CONFIG["JOB"][config_file])
else:
raise JobParseException("Job '%s' not found." % config_file)
self.config.read_dict(options)
self.outfile = self.config['job'].get('outfile', './outfile_%s.tar.xz' % strftime("%Y-%m-%d_%H-%M-%S"))
self.tempdir = TemporaryDirectory(prefix="dizzy-")
atexit.register(create_archive, self.outfile, self.tempdir)
sys.stdout = Logger(sys.stdout, path.join(self.tempdir.name, "stdout.log"))
print_dizzy("job/run: cmd was: '%s'." % " ".join(sys.argv))
if 'job' not in self.config:
raise JobParseException("No 'job' section found in conf.")
if 'file' not in self.config['job']:
raise JobParseException("No 'file' found in conf.")
if 'mode' not in self.config['job']:
raise JobParseException("No 'mode' found in conf.")
self.mode = self.config['job']['mode']
self.file = self.config['job']['file']
self.delay = self.config['job'].getfloat('delay', 1)
self.verbose = self.config['job'].getint('verbose', NORMAL)
set_print_level(self.verbose)
if 'output' not in self.config:
raise JobParseException("No 'output' section found in conf.")
if 'type' not in self.config['output']:
raise JobParseException("No 'type' found in conf.")
self.out_type = self.config['output']['type']
self.session_reopen = self.config['output'].getboolean('session_reopen', False)
if 'values' in self.config:
self.config_values = dict(self.config['values'])
else:
self.config_values = {}
self.config_values['_output'] = dict(self.config['output'])
if self.file.endswith('.act'):
self.act = load_interaction(self.file, self.mode, start_at, \
config_values=self.config_values)
self.dizz = None
self.mutations = self.act.iterations()
elif self.file.endswith('.dizz'):
self.dizz = load_dizz(self.file, self.file, 0, self.mode, start_at, \
config_values=self.config_values)
self.act = None
self.mutations = self.dizz.length()
else:
raise JobParseException("Wrong input file in conf.")
self.state_lock = RLock()
self.probe = None
self.probe_type = None
if 'probe' in self.config:
self.probe_type = self.config['probe'].get('type', None)
if not self.probe_type is None:
if self.probe_type in CONFIG["PROBE"]:
self.probe = CONFIG["PROBE"][self.probe_type].DizzyProbe(self.config["probe"])
else:
print_dizzy("job/init: target probe '%s' not found." % self.probe_type)
exit(1)
if self.out_type in CONFIG["SESSION"]:
self.session = CONFIG["SESSION"][self.out_type].DizzySession(self.config['output'])
CONFIG["GLOBALS"]["SESSION"] = self.session
else:
print_dizzy("job/init: session '%s' not found." % self.out_type)
exit(1)
self.print_index = start_at + 1
self.start_time = 0
self.index = 0
self.time_list = []
self.session_reset = False
self.pcap = None
def read(self, session, read_back=None):
d = b""
reconnect = False
try:
reading = True
while reading:
r = session.recv()
if not r:
reading = False
print_dizzy("job/read: read end on NONE", DEBUG)
else:
d += r
#print_dizzy(d, DEBUG)
if not read_back is None:
if len(d) >= read_back:
reading = False
except socket.timeout:
print_dizzy("job/read: read end on timeout", VERBOSE_2)
except socket.error as e:
print_dizzy("job/read: read end on sock error '%s', reopening..." % str(e), VERBOSE_2)
reconnect = True
except Exception as e:
print_dizzy("job/read: cant read input: %s" % str(e), VERBOSE_2)
return "", True
if not read_back is None and read_back > 0 and len(d) < read_back:
print_dizzy("job/read: len(read): %i < rlen: %i, reconnect..." % (len(d), read_back), DEBUG)
reconnect = True
print_dizzy("job/read: data: %s reconnect: %s" % (d, reconnect), DEBUG)
return d, reconnect
def run(self):
self.start_time = time()
self.session.open()
if self.probe:
self.probe.open()
if not self.probe.probe():
print_dizzy("job/run: initial probe failed")
return
if self.act is None:
for self.index, value in enumerate(self.dizz, self.print_index):
if 'pcap' in self.config:
self.pcap = Pcap(self.config['pcap'], path.join(self.tempdir.name, "trace-%s.pcap" % self.index))
self.pcap.start()
while not self.pcap.is_open:
sleep(0.1)
try:
self.session.send(value.byte)
except Exception as e:
print_dizzy(e)
print_exc()
self.read(self.session, 1)
if not self.pcap is None:
self.pcap.stop()
self.pcap.join()
if not self.do_probe():
break
self.print_status()
else:
if 'pcap' in self.config:
self.pcap = Pcap(self.config['pcap'], path.join(self.tempdir.name, "trace-%s.pcap" % self.index))
self.pcap.start()
while not self.pcap.is_open:
sleep(0.1)
if self.session.read_first:
self.act.response, session_reset = self.read(self.session, 1)
for self.index, value in enumerate_interactions(self.act, self.print_index):
print_dizzy("job/run: index: %d, value: %s" % (self.index, value), DEBUG)
if self.session_reset:
print_dizzy("job/run: Session reset triggered", DEBUG)
if not value is None:
continue
if value is None:
if self.session_reopen or self.session_reset:
print_dizzy("job/run: Reseting session", DEBUG)
self.session.close()
if not self.pcap is None:
self.pcap.stop()
self.pcap.join()
sleep(self.delay)
if 'pcap' in self.config:
self.pcap = Pcap(self.config['pcap'], path.join(self.tempdir.name, "trace-%s.pcap" % self.index))
self.pcap.start()
while not self.pcap.is_open:
sleep(0.1)
self.session.open()
self.session_reset = False
if not self.do_probe():
break
self.print_status()
continue
try:
self.session.send(value.byte)
except Exception as e:
print_dizzy(e)
self.session_reset = True
continue
self.act.response, session_reset = self.read(self.session, value.dizz_iterator.dizz.readback)
print_dizzy("job/run: end")
if not self.pcap is None:
self.pcap.stop()
self.pcap.join()
if self.probe:
self.probe.close()
def load(self):
inventory = self.zipimport.load_module(self.name).__all__
if "deps" in inventory:
depspath = self.path + "/" + self.name + "/deps"
sys.path.insert(0, depspath)
print_dizzy(
"mod:%s/load: added dependency path '%s'" %
(self.name, depspath), VERBOSE_1)
sys.path.insert(0, self.path)
if "dizz" in inventory:
dizz = __import__(self.name + ".dizz").dizz
self.dizz = []
for i in dizz.__all__:
name = self.name + "/dizz/" + i
obj = dizz.__loader__.get_data(name)
self.dizz.append(name)
self.global_config["DIZZ"][name] = obj.decode(
self.global_config["GLOBALS"]["CODEC"])
print_dizzy(
"mod:%s/load: Loaded %d dizz files." %
(self.name, len(self.dizz)), VERBOSE_1)
print_dizzy("mod:%s/load: %s" % (self.name, self.dizz), DEBUG)
if "act" in inventory:
act = __import__(self.name + ".act").act
self.act = []
for i in act.__all__:
name = self.name + "/act/" + i
obj = act.__loader__.get_data(name)
self.act.append(name)
self.global_config["ACT"][name] = obj.decode(
self.global_config["GLOBALS"]["CODEC"])
print_dizzy(
"mod:%s/load: Loaded %d act files." %
(self.name, len(self.act)), VERBOSE_1)
print_dizzy("mod:%s/load: %s" % (self.name, self.act), DEBUG)
if "job" in inventory:
job = __import__(self.name + ".job").job
self.job = []
for i in job.__all__:
name = self.name + "/job/" + i
obj = job.__loader__.get_data(name)
self.job.append(name)
self.global_config["JOB"][name] = obj.decode(
self.global_config["GLOBALS"]["CODEC"])
print_dizzy(
"mod:%s/load: Loaded %d job files." %
(self.name, len(self.job)), VERBOSE_1)
print_dizzy("mod:%s/load: %s" % (self.name, self.job), DEBUG)
if "probe" in inventory:
probe = __import__(self.name + ".probe").probe
self.probe = []
for i in probe.__all__:
name = self.name + ".probe." + i
obj = getattr(__import__(name).probe, i)
self.probe.append(name)
self.global_config["PROBE"][name] = obj
print_dizzy(
"mod:%s/load: Loaded %d target probes." %
(self.name, len(self.probe)), VERBOSE_1)
print_dizzy("mod:%s/load: %s" % (self.name, self.probe), DEBUG)
if "session" in inventory:
session = __import__(self.name + ".session").session
self.session = []
for i in session.__all__:
name = self.name + ".session." + i
obj = getattr(__import__(name).session, i)
self.session.append(name)
self.global_config["SESSION"][name] = obj
print_dizzy(
"mod:%s/load: Loaded %d sessions." %
(self.name, len(self.session)), VERBOSE_1)
print_dizzy("mod:%s/load: %s" % (self.name, self.session), DEBUG)
sys.path.remove(self.path)
def print_config():
print_dizzy("### global sessions ###")
for i in CONFIG["SESSION"]:
if i.startswith("session."):
print_dizzy(" - %s" % i)
print_dizzy("### global probes ###")
for i in CONFIG["PROBE"]:
if i.startswith("probe."):
print_dizzy(" - %s" % i)
for i in CONFIG["MODULES"]:
print_dizzy("### module '%s' loaded from '%s' v%s ###" % (i, CONFIG["MODULES"][i].path, CONFIG["MODULES"][i].version))
for j in CONFIG["DIZZ"]:
if j.startswith("%s/" % i):
print_dizzy(" - %s" % j)
for j in CONFIG["ACT"]:
if j.startswith("%s/" % i):
print_dizzy(" - %s" % j)
for j in CONFIG["JOB"]:
if j.startswith("%s/" % i):
print_dizzy(" - %s" % j)
for j in CONFIG["SESSION"]:
if j.startswith("%s." % i):
print_dizzy(" - %s" % j)
for j in CONFIG["PROBE"]:
if j.startswith("%s." % i):
print_dizzy(" - %s" % j)
def init_config():
try:
#read main config
global CONFIG
cfg = ConfigParser(allow_no_value=True)
root = Path(CONFIG["GLOBALS"]["ROOTDIR"]).expanduser()
str_lib_path = root / CONFIG["GLOBALS"]["DEFAULT_STR_LIB_NAME"]
CONFIG["GLOBALS"]["DEFAULT_STR_LIB"] = str(str_lib_path)
if not root.exists():
Path.mkdir(root)
if (root / CONFIG["GLOBALS"]["CONFIGFILE"]).exists():
cfg.read(str(root / CONFIG["GLOBALS"]["CONFIGFILE"]))
else:
print_dizzy("config/init: no config file found, creating default config.")
cfg['dizzy'] = {'module_path' : '%s/modules' % CONFIG["GLOBALS"]["ROOTDIR"],
'overwrite_path' : '%s/local' % CONFIG["GLOBALS"]["ROOTDIR"]}
with (root / CONFIG["GLOBALS"]["CONFIGFILE"]).open('x') as cfile:
cfg.write(cfile)
Path.mkdir(root / "modules", exist_ok=True)
Path.mkdir(root / "local", exist_ok=True)
if not str_lib_path.exists():
if str_lib_path.is_symlink():
str_lib_path.unlink()
dflt_str_lib_path = Path(prefix + CONFIG["GLOBALS"]["DEFAULT_STR_LIB_NAME"])
if dflt_str_lib_path.exists():
print_dizzy("config/init: creating symlink to std_lib.")
str_lib_path.symlink_to(dflt_str_lib_path.resolve())
dflt_str_lib_path = Path("./lib/" + CONFIG["GLOBALS"]["DEFAULT_STR_LIB_NAME"])
if dflt_str_lib_path.exists():
print_dizzy("config/init: creating symlink to std_lib.")
str_lib_path.symlink_to(dflt_str_lib_path.resolve())
CONFIG.update(dict(cfg))
modp = CONFIG['dizzy'].get("module_path")
if modp is None:
print_dizzy("config/init: no module_path in config file.")
exit(1)
print_dizzy("config/init: using module path '%s'." % modp, VERBOSE_1)
#check dependencies
CONFIG["DEPS"] = {}
try:
import exrex
except:
CONFIG["DEPS"]["exrex"] = False
else:
CONFIG["DEPS"]["exrex"] = True
try:
import Crypto
except:
CONFIG["DEPS"]["Crypto"] = False
else:
CONFIG["DEPS"]["Crypto"] = True
#load modules
CONFIG["DIZZ"] = {}
CONFIG["ACT"] = {}
CONFIG["JOB"] = {}
CONFIG["MODULES"] = {}
CONFIG["PROBE"] = {}
CONFIG["SESSION"] = {}
module_path = Path(modp).expanduser()
for f in module_path.glob("*.zip"):
if f.is_dir():
continue
print_dizzy("config/init: trying to load module '%s'." % f, VERBOSE_2)
try:
mod = DizzyModule(str(f), CONFIG)
except Exception as e:
print_dizzy("config/init: can't init module '%s'." % f)
print_dizzy(e, DEBUG)
load = True
#check module dependencies
for d in mod.dependencies:
if d in CONFIG["DEPS"]:
if not CONFIG["DEPS"][d]:
print_dizzy("config/init: can't load module '%s', dependency '%s' not found." % (mod.name, d), VERBOSE_1)
load = False
continue
else:
try:
__import__(d)
except:
CONFIG["DEPS"][d] = False
print_dizzy("config/init: can't load module '%s', dependency '%s' not found." % (mod.name, d), VERBOSE_1)
load = False
continue
CONFIG["DEPS"][d] = True
if load:
try:
mod.load()
except Exception as e:
print_dizzy("config/init: can't load module '%s'." % f)
print_dizzy(e, DEBUG)
continue
CONFIG["MODULES"][mod.name] = mod
if mod.name in CONFIG["MODULES"]:
print_dizzy("config/init: module %s loaded successfully." % mod.name, VERBOSE_1)
#load default sessions
sessions = __import__("dizzy.session").session.__all__
for i in sessions:
CONFIG["SESSION"]["session." + i] = getattr(__import__('dizzy.session.' + i).session, i)
#load default probes
probes = __import__("dizzy.probe").probe.__all__
for i in probes:
CONFIG["PROBE"]["probe." + i] = getattr(__import__('dizzy.probe.' + i).probe, i)
#look for overwrite folder
overwritep = CONFIG["dizzy"].get("overwrite_path")
if not overwritep is None:
overwrite_path = Path(overwritep).expanduser()
if not overwrite_path.is_dir():
print_dizzy("config/init: overwrite_path is not a directory.", VERBOSE_1)
else:
for module in overwrite_path.iterdir():
if not module.is_dir():
print_dizzy("config/init: %s is not a directory, skipping." % module, VERBOSE_2)
continue
for component in module.iterdir():
if not component.is_dir():
print_dizzy("config/init: %s is not a directory, skipping." % component, VERBOSE_2)
continue
if component.stem == "act":
for act in component.iterdir():
if not act.is_file():
print_dizzy("config/init: %s is not a file, skipping." % act, VERBOSE_2)
continue
with act.open() as input:
name = "%s/%s/%s" % (module.stem, component.stem, act.name)
CONFIG["ACT"][name] = input.read()
print_dizzy("Overwriting %s from %s" % (name, act))
elif component.stem == "dizz":
for dizz in component.iterdir():
if not dizz.is_file():
print_dizzy("config/init: %s is not a file, skipping." % dizz, VERBOSE_2)
continue
with dizz.open() as input:
name = "%s/%s/%s" % (module.stem, component.stem, dizz.name)
CONFIG["DIZZ"][name] = input.read()
print_dizzy("Overwriting %s from %s" % (name, dizz))
elif component.stem == "job":
for job in component.iterdir():
if not job.is_file():
print_dizzy("config/init: %s is not a file, skipping." % job, VERBOSE_2)
continue
with job.open() as input:
name = "%s/%s/%s" % (module.stem, component.stem, job.name)
CONFIG["JOB"][name] = input.read()
print_dizzy("Overwriting %s from %s" % (name, job))
elif component.stem == "probe":
for probe in component.iterdir():
if not probe.is_file():
print_dizzy("config/init: %s is not a file, skipping." % probe, VERBOSE_2)
continue
name = "%s.%s.probe.%s" % (overwrite_path.stem, module.stem, probe.stem)
obj = getattr(getattr(__import__(name), module.stem).probe, probe.stem)
name = "%s.probe.%s" % (module.stem, probe.stem)
CONFIG["PROBE"][name] = obj
print_dizzy("Overwriting %s from %s" % (name, probe))
elif component.stem == "session":
for session in component.iterdir():
if not session.is_file():
print_dizzy("config/init: %s is not a file, skipping." % session, VERBOSE_2)
continue
name = "%s.%s.session.%s" % (overwrite_path.stem, module.stem, session.stem)
obj = getattr(getattr(__import__(name), module.stem).session, session.stem)
name = "%s.session.%s" % (module.stem, session.stem)
CONFIG["SESSION"][name] = obj
print_dizzy("Overwriting %s from %s" % (name, session))
if not module.stem in CONFIG["MODULES"]:
class Object(object):
pass
obj = Object()
obj.path = "%s" % module
obj.version = 0
name = "%s" % module.stem
CONFIG["MODULES"][name] = obj
print_dizzy("config/init: init finished, config:", DEBUG)
#pprint_dizzy(CONFIG, DEBUG)
except Exception as e:
raise DizzyParseException("Can't read config file %s: %s" % (CONFIG["GLOBALS"]["CONFIGFILE"], e))
def open(self):
try:
self.socket = socket(self.af, SOCK_STREAM)
if self.dest == "255.255.255.255":
self.socket.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
self.socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
self.socket.settimeout(self.timeout)
sendbuf = self.socket.getsockopt(SOL_SOCKET, SO_SNDBUF)
if sendbuf < self.maxsize:
self.maxsize = sendbuf
if not self.sport is None and not self.src is None:
if self.af == AF_INET:
self.socket.bind((self.src, self.sport))
elif self.af == AF_INET6:
try:
#this should be the way for v6 addr, for some reason failed on me ):
#self.socket.bind((self.src, self.sport, 0, 0))
self.socket.bind((self.src, self.sport))
except:
if not self.interface is '':
(_, _, _, _, addri) = getaddrinfo(
"%s%%%s" % (self.src, self.interface),
self.sport,
family=AF_INET6,
proto=IPPROTO_TCP)[0]
self.socket.bind(addri)
else:
raise SessionException(
"cant bind to ipv6 LL without interface!")
if self.server_side:
self.socket.listen(1)
(self.client_socket, (rip, rport)) = self.socket.accept()
if self.dport:
while self.dport != rport or self.src != rip:
if self.dport != rport:
print_dizzy(
"session/tcp: remote port %i not destination port %i"
% (rport, self.dport), DEBUG)
if self.src != rip:
print_dizzy(
"session/tcp: remote ip %s not destination ip %i"
% (rip, self.dst))
(self.client_socket, (sip,
rport)) = self.socket.accept()
self.client_socket.settimeout(self.timeout)
else:
connected = False
attempt = 1
try:
self.socket.connect((self.dest, self.dport))
connected = True
except timeout:
print_dizzy(
"session/tcp: Connection attempt %d timed out." %
(attempt))
while not connected and attempt <= self.connect_retry:
try:
(r, w, x) = select([], [self.socket], [],
self.timeout)
if self.socket in w:
connected = True
except:
pass
attempt += 1
if not connected:
raise SessionException("too much connection attempts")
except Exception as e:
raise SessionException("cant open session: %s" % e)
else:
self.is_open = True
