1499

pending completion

Build # 1499

Build Type

push

travis-ci

Committed by

jbremer

Commit Message

<a href="https://github.com/cuckoosandbox/cuckoo/commit/99dd2dd2e">a few unittests for the moloch redirection #1329 (thanks SparkyNZL)

Apparently the assumption that it would &quot;probably work&quot; from [1] wasn&#39;t
accurate, so here&#39;s the small bugfix including some unittests.

[1]: </a><a class="double-link" href="https://github.com/cuckoosandbox/cuckoo/commit/947fabe78">947fabe78</a>

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

7180 of 14906 relevant lines covered (48.17%)

0.48 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

63.49

/cuckoo/common/dns.py

# Copyright (C) 2010-2013 Claudio Guarnieri.
# Copyright (C) 2014-2016 Cuckoo Foundation.
# This file is part of Cuckoo Sandbox - http://www.cuckoosandbox.org
# See the file 'docs/LICENSE' for copying permission.

import select
import socket
import threading

try:
    import pycares
    HAVE_CARES = True
except:
    HAVE_CARES = False

# try:
#    import gevent, gevent.socket
#    HAVE_GEVENT = True
# except:
HAVE_GEVENT = False


# these are used by all resolvers
DNS_TIMEOUT = 5
DNS_TIMEOUT_VALUE = ""

def set_timeout(value):
    global DNS_TIMEOUT
    DNS_TIMEOUT = value

def set_timeout_value(value):
    global DNS_TIMEOUT_VALUE
    DNS_TIMEOUT_VALUE = value


# standard gethostbyname in thread
# http://code.activestate.com/recipes/473878/
def with_timeout(func, args=(), kwargs={}):
    """This function will spawn a thread and run the given function
    using the args, kwargs and return the given default value if the
    timeout_duration is exceeded.
    """
    class ResultThread(threading.Thread):
        daemon = True

        def __init__(self):
            threading.Thread.__init__(self)
            self.result, self.error = None, None

        def run(self):
            try:
                self.result = func(*args, **kwargs)
            except Exception, e:
                self.error = e

    it = ResultThread()
    it.start()
    it.join(DNS_TIMEOUT)
    if it.isAlive():
        return DNS_TIMEOUT_VALUE
    else:
        if it.error:
            raise it.error
        return it.result

def resolve_thread(name):
    return with_timeout(gethostbyname, (name,))

def gethostbyname(name):
    try:
        ip = socket.gethostbyname(name)
    except socket.gaierror:
        ip = ""
    return ip


# C-ARES (http://c-ares.haxx.se/)
def resolve_cares(name):
    # create new c-ares channel
    careschan = pycares.Channel(timeout=DNS_TIMEOUT, tries=1)

    # if we don't get a response we return the default value
    result = Resultholder()
    result.value = DNS_TIMEOUT_VALUE

    def setresult_cb(res, error):
        # ignore error and just take first result ip (randomized anyway)
        if res and res.addresses:
            result.value = res.addresses[0]

    # resolve with cb
    careschan.gethostbyname(name, socket.AF_INET, setresult_cb)

    # now do the actual work
    readfds, writefds = careschan.getsock()
    canreadfds, canwritefds, _ = select.select(readfds, writefds, [],
                                               DNS_TIMEOUT)
    for rfd in canreadfds:
        careschan.process_fd(rfd, -1)

    # if the query did not succeed, setresult was not called and we just
    # return result destroy the channel first to not leak anything
    careschan.destroy()
    return result.value

# workaround until py3 nonlocal (for c-ares and gevent)
class Resultholder:
    pass


# gevent based resolver with timeout
"""def resolve_gevent(name):
    result = resolve_gevent_real(name)
    # if it failed, do this a second time because of strange libevent behavior
    # basically sometimes the Timeout fires immediately instead of after
    # DNS_TIMEOUT
    if result == DNS_TIMEOUT_VALUE:
        result = resolve_gevent_real(name)
    return result

def resolve_gevent_real(name):
    result = DNS_TIMEOUT_VALUE
    with gevent.Timeout(DNS_TIMEOUT, False):
        try:
            result = gevent.socket.gethostbyname(name)
        except socket.gaierror:
            pass

    return result
"""

# choose resolver automatically
def resolve(name):
    if HAVE_CARES:
        return resolve_cares(name)
    # elif HAVE_GEVENT:
    #    return resolve_gevent(name)
    else:
        return resolve_thread(name)

# another alias
resolve_best = resolve

1	# Copyright (C) 2010-2013 Claudio Guarnieri.
2	# Copyright (C) 2014-2016 Cuckoo Foundation.
3	# This file is part of Cuckoo Sandbox - http://www.cuckoosandbox.org
4	# See the file 'docs/LICENSE' for copying permission.
5
6	import select	1✔
7	import socket	1✔
8	import threading	1✔
9
10	try:	1✔
11	import pycares	1✔
12	HAVE_CARES = True	×
13	except:	1✔
14	HAVE_CARES = False	1✔
15
16	# try:
17	# import gevent, gevent.socket
18	# HAVE_GEVENT = True
19	# except:
20	HAVE_GEVENT = False	1✔
21
22
23	# these are used by all resolvers
24	DNS_TIMEOUT = 5	1✔
25	DNS_TIMEOUT_VALUE = ""	1✔
26
27	def set_timeout(value):	1✔
28	global DNS_TIMEOUT
29	DNS_TIMEOUT = value	×
30
31	def set_timeout_value(value):	1✔
32	global DNS_TIMEOUT_VALUE
33	DNS_TIMEOUT_VALUE = value	×
34
35
36	# standard gethostbyname in thread
37	# http://code.activestate.com/recipes/473878/
38	def with_timeout(func, args=(), kwargs={}):	1✔
39	"""This function will spawn a thread and run the given function
40	using the args, kwargs and return the given default value if the
41	timeout_duration is exceeded.
42	"""
43	class ResultThread(threading.Thread):	1✔
44	daemon = True	1✔
45
46	def __init__(self):	1✔
47	threading.Thread.__init__(self)	1✔
48	self.result, self.error = None, None	1✔
49
50	def run(self):	1✔
51	try:	1✔
52	self.result = func(args, *kwargs)	1✔
53	except Exception, e:	×
54	self.error = e	×
55
56	it = ResultThread()	1✔
57	it.start()	1✔
58	it.join(DNS_TIMEOUT)	1✔
59	if it.isAlive():	1✔
60	return DNS_TIMEOUT_VALUE	×
61	else:
62	if it.error:	1✔
63	raise it.error	×
64	return it.result	1✔
65
66	def resolve_thread(name):	1✔
67	return with_timeout(gethostbyname, (name,))	1✔
68
69	def gethostbyname(name):	1✔
70	try:	1✔
71	ip = socket.gethostbyname(name)	1✔
72	except socket.gaierror:	×
73	ip = ""	×
74	return ip	1✔
75
76
77	# C-ARES (http://c-ares.haxx.se/)
78	def resolve_cares(name):	1✔
79	# create new c-ares channel
80	careschan = pycares.Channel(timeout=DNS_TIMEOUT, tries=1)	×
81
82	# if we don't get a response we return the default value
83	result = Resultholder()	×
84	result.value = DNS_TIMEOUT_VALUE	×
85
86	def setresult_cb(res, error):	×
87	# ignore error and just take first result ip (randomized anyway)
88	if res and res.addresses:	×
89	result.value = res.addresses[0]	×
90
91	# resolve with cb
92	careschan.gethostbyname(name, socket.AF_INET, setresult_cb)	×
93
94	# now do the actual work
95	readfds, writefds = careschan.getsock()	×
96	canreadfds, canwritefds, _ = select.select(readfds, writefds, [],	×
97	DNS_TIMEOUT)
98	for rfd in canreadfds:	×
99	careschan.process_fd(rfd, -1)	×
100
101	# if the query did not succeed, setresult was not called and we just
102	# return result destroy the channel first to not leak anything
103	careschan.destroy()	×
104	return result.value	×
105
106	# workaround until py3 nonlocal (for c-ares and gevent)
107	class Resultholder:	1✔
108	pass	1✔
109
110
111	# gevent based resolver with timeout
112	"""def resolve_gevent(name):
113	result = resolve_gevent_real(name)
114	# if it failed, do this a second time because of strange libevent behavior
115	# basically sometimes the Timeout fires immediately instead of after
116	# DNS_TIMEOUT
117	if result == DNS_TIMEOUT_VALUE:
118	result = resolve_gevent_real(name)
119	return result
120
121	def resolve_gevent_real(name):
122	result = DNS_TIMEOUT_VALUE
123	with gevent.Timeout(DNS_TIMEOUT, False):
124	try:
125	result = gevent.socket.gethostbyname(name)
126	except socket.gaierror:
127	pass
128
129	return result
130	"""
131
132	# choose resolver automatically
133	def resolve(name):	1✔
134	if HAVE_CARES:	1✔
135	return resolve_cares(name)	×
136	# elif HAVE_GEVENT:
137	# return resolve_gevent(name)
138	else:
139	return resolve_thread(name)	1✔
140
141	# another alias
142	resolve_best = resolve	1✔

cuckoosandbox / cuckoo / 1499

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous