def _initialize_check(self):
"""Runs checks against virtualization software when a machine manager
is initialized.
@note: in machine manager modules you may override or superclass
his method.
@raise CuckooMachineError: if a misconfiguration or a unkown vm state
is found.
"""
try:
configured_vms = self._list()
except NotImplementedError:
return
for machine in self.machines():
# If this machine is already in the "correct" state, then we
# go on to the next machine.
if machine.label in configured_vms and \
self._status(machine.label) in [self.POWEROFF, self.ABORTED]:
continue
# This machine is currently not in its correct state, we're going
# to try to shut it down. If that works, then the machine is fine.
try:
self.stop(machine.label)
except CuckooMachineError as e:
msg = "Please update your configuration. Unable to shut " \
"'{0}' down or find the machine in its proper state:" \
" {1}".format(machine.label, e)
raise CuckooCriticalError(msg)
if not self.options_globals.timeouts.vm_state:
raise CuckooCriticalError("Virtual machine state change timeout "
"setting not found, please add it to "
"the config file.")
def __init__(self):
ip = cfg.resultserver.ip
port = cfg.resultserver.port
pool_size = cfg.resultserver.pool_size
sock = gevent.socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
sock.bind((ip, port))
except (OSError, socket.error) as e:
if e.errno == errno.EADDRINUSE:
raise CuckooCriticalError(
"Cannot bind ResultServer on port %d "
"because it was in use, bailing." % port)
elif e.errno == errno.EADDRNOTAVAIL:
raise CuckooCriticalError(
"Unable to bind ResultServer on %s:%s %s. This "
"usually happens when you start Cuckoo without "
"bringing up the virtual interface associated with "
"the ResultServer IP address. Please refer to "
"https://cuckoo.sh/docs/faq/#troubles-problem "
"for more information." % (ip, port, e))
else:
raise CuckooCriticalError(
"Unable to bind ResultServer on %s:%s: %s" % (ip, port, e))
# We allow user to specify port 0 to get a random port, report it back
# here
_, self.port = sock.getsockname()
sock.listen(128)
self.thread = Thread(target=self.create_server, args=(sock, pool_size))
self.thread.daemon = True
self.thread.start()
def initialize(self):
"""Initialize the machine manager."""
global machinery, machine_lock
machinery_name = self.cfg.cuckoo.machinery
max_vmstartup_count = self.cfg.cuckoo.max_vmstartup_count
if max_vmstartup_count:
machine_lock = threading.Semaphore(max_vmstartup_count)
else:
machine_lock = threading.Lock()
log.info("Using \"%s\" as machine manager", machinery_name)
# Get registered class name. Only one machine manager is imported,
# therefore there should be only one class in the list.
plugin = list_plugins("machinery")[0]
# Initialize the machine manager.
machinery = plugin()
# Find its configuration file.
conf = os.path.join(CUCKOO_ROOT, "conf", "%s.conf" % machinery_name)
if not os.path.exists(conf):
raise CuckooCriticalError("The configuration file for machine "
"manager \"{0}\" does not exist at path:"
" {1}".format(machinery_name, conf))
# Provide a dictionary with the configuration options to the
# machine manager instance.
machinery.set_options(Config(machinery_name))
# Initialize the machine manager.
try:
machinery.initialize(machinery_name)
except CuckooMachineError as e:
raise CuckooCriticalError("Error initializing machines: %s" % e)
# At this point all the available machines should have been identified
# and added to the list. If none were found, Cuckoo needs to abort the
# execution.
if not len(machinery.machines()):
raise CuckooCriticalError("No machines available.")
else:
log.info("Loaded %s machine/s", len(machinery.machines()))
if len(machinery.machines()) > 1 and self.db.engine.name == "sqlite":
log.warning("As you've configured Cuckoo to execute parallel "
"analyses, we recommend you to switch to a MySQL or"
"a PostgreSQL database as SQLite might cause some "
"issues.")
if len(machinery.machines()) > 4 and self.cfg.cuckoo.process_results:
log.warning("When running many virtual machines it is recommended "
"to process the results in a separate process.py to "
"increase throughput and stability. Please read the "
"documentation about the `Processing Utility`.")
def _initialize_check(self):
"""Ensures that credentials have been entered into the config file.
@raise CuckooCriticalError: if no credentials were provided or if
one or more physical machines are offline.
"""
if not self.options.physical.user or not self.options.physical.password:
raise CuckooCriticalError("Physical machine credentials are missing, please add it to the config file")
for machine in self.machines():
if self._status(machine.label) != self.RUNNING:
raise CuckooCriticalError("Physical machine is currently offline")
def _initialize_check(self):
"""Runs all checks when a machine manager is initialized.
@raise CuckooMachineError: if VBoxManage is not found.
"""
# VirtualBox specific checks.
if not self.options.virtualbox.path:
raise CuckooCriticalError("VirtualBox VBoxManage path missing, please add it to the config file")
if not os.path.exists(self.options.virtualbox.path):
raise CuckooCriticalError(f'VirtualBox VBoxManage not found at specified path "{self.options.virtualbox.path}"')
# Base checks.
super(VirtualBox, self)._initialize_check()
def _initialize_check(self):
"""Ensures that credentials have been entered into the config file.
@raise CuckooCriticalError: if no credentials were provided
"""
if not self.options.proxmox.username or not self.options.proxmox.password:
raise CuckooCriticalError(
"Proxmox credentials are missing, please add them to "
"the Proxmox machinery configuration file.")
if not self.options.proxmox.hostname:
raise CuckooCriticalError("Proxmox hostname not set")
super(Proxmox, self)._initialize_check()
def initialize(self):
"""Initialize the machine manager."""
global machinery
machinery_name = self.cfg.cuckoo.machinery
log.info("Using \"%s\" machine manager", machinery_name)
# Get registered class name. Only one machine manager is imported,
# therefore there should be only one class in the list.
plugin = list_plugins("machinery")[0]
# Initialize the machine manager.
machinery = plugin()
# Find its configuration file.
conf = os.path.join(CUCKOO_ROOT, "conf", "%s.conf" % machinery_name)
if not os.path.exists(conf):
raise CuckooCriticalError("The configuration file for machine "
"manager \"{0}\" does not exist at path:"
" {1}".format(machinery_name, conf))
# Provide a dictionary with the configuration options to the
# machine manager instance.
machinery.set_options(Config(machinery_name))
# Initialize the machine manager.
try:
machinery.initialize(machinery_name)
except CuckooMachineError as e:
raise CuckooCriticalError("Error initializing machines: %s" % e)
# At this point all the available machines should have been identified
# and added to the list. If none were found, Cuckoo needs to abort the
# execution.
if not len(machinery.machines()):
raise CuckooCriticalError("No machines available.")
else:
log.info("Loaded %s machine/s", len(machinery.machines()))
if len(machinery.machines()) > 1 and self.db.engine.name == "sqlite":
log.warning("The SQLite database is not compatible with "
"multi-threaded use-cases such as running multiple "
"virtual machine in parallel. Please upgrade to "
"PostgreSQL or MySQL when running multiple VMs.")
if len(machinery.machines()) > 3 and self.cfg.cuckoo.process_results:
log.warning("When running many virtual machines it is recommended "
"to process the results in a separate process.py to "
"increase throughput and stability. Please read the "
"documentation about the `Processing Utility`.")
def __init__(self, *args, **kwargs):
self.cfg = Config()
self.analysistasks = {}
self.analysishandlers = {}
ip = self.cfg.resultserver.ip
self.port = int(self.cfg.resultserver.port)
while True:
try:
server_addr = ip, self.port
SocketServer.ThreadingTCPServer.__init__(self,
server_addr,
ResultHandler,
*args,
**kwargs)
except Exception as e:
if e.errno == errno.EADDRINUSE:
if self.cfg.resultserver.force_port is True:
raise CuckooCriticalError("Cannot bind ResultServer on port %d, "
"bailing." % self.port
)
else:
# In Linux /usr/include/asm-generic/errno-base.h.
# EADDRINUSE 98 (Address already in use)
# In Mac OS X or FreeBSD:
# EADDRINUSE 48 (Address already in use)
log.warning("Cannot bind ResultServer on port %s, "
"trying another port.", self.port)
self.port += 1
elif e.errno == errno.EADDRNOTAVAIL:
raise CuckooCriticalError(
"Unable to bind ResultServer on %s:%s %s. This "
"usually happens when you start Cuckoo without "
"bringing up the virtual interface associated with "
"the ResultServer IP address. Please refer to "
"https://cuckoo.sh/docs/faq/#troubles-problem"
" for more information." % (ip, self.port, e)
)
else:
raise CuckooCriticalError(
"Unable to bind ResultServer on %s:%s: %s" %
(ip, self.port, e)
)
else:
log.debug("ResultServer running on {0}:{1}.".format(ip, self.port))
self.servethread = Thread(target=self.serve_forever)
self.servethread.setDaemon(True)
self.servethread.start()
break
def _initialize_check(self):
"""Runs all checks when a machine manager is initialized.
@raise CuckooMachineError: if QEMU binary is not found.
"""
# VirtualBox specific checks.
if not self.options.qemu.path:
raise CuckooCriticalError("QEMU binary path missing, "
"please add it to the config file")
if not os.path.exists(self.options.qemu.path):
raise CuckooCriticalError("QEMU binary not found at "
"specified path \"%s\"" %
self.options.qemu.path)
self.qemu_dir = os.path.dirname(self.options.qemu.path)
self.qemu_img = os.path.join(self.qemu_dir, "qemu-img")
def fog_init(self):
"""Initiate by indexing FOG regarding all available machines."""
self.fog_machines = {}
if self.options.fog.hostname == "none":
return
# TODO Handle exceptions such as not being able to connect.
# Parse the HTML.
r = requests.get(f"http://{self.options.fog.hostname}/fog/status", headers=headers, verify=False)
if r.status_code != 200:
raise CuckooCriticalError(f"The FOG server answered with the status code {r.status_code}")
r_hosts = requests.get(f"http://{self.options.fog.hostname}/fog/host", headers=headers, verify=False)
hosts = r_hosts.json()["hosts"]
hostnames = []
for host in hosts:
hostnames.append(host["name"])
print(f"Host {host['name']} has MAC {host['macs'][0]}")
# Check whether all our machines are available on FOG.
for machine in self.machines():
if machine.label not in hostnames:
raise CuckooMachineError(
f"The physical machine {machine.label} has not been defined in FOG, "
"please investigate and configure the configuration correctly"
)
def fog_init(self):
"""Initiate by indexing FOG regarding all available machines."""
self.fog_machines = {}
if not HAVE_FOG or self.options.fog.hostname == "none":
return
# TODO Handle exceptions such as not being able to connect.
r = self.fog_query("node=tasks&sub=listhosts")
# Parse the HTML.
b = bs4.BeautifulSoup(r.content, "html.parser")
if not b.find_all("table"):
raise CuckooCriticalError(
"The supplied FOG username and/or password do not allow us "
"to login into FOG, please configure the correct credentials.")
# Mapping for physical machine hostnames to their mac address and uri
# for "downloading" a safe image onto the host. Great piece of FOG API
# usage here.
for row in b.find_all("table")[0].find_all("tr")[1:]:
hostname, macaddr, download, upload, advanced = row.find_all("td")
self.fog_machines[hostname.text] = (
macaddr.text,
next(download.children).attrs["href"][1:],
)
# Check whether all our machines are available on FOG.
for machine in self.machines():
if machine.label not in self.fog_machines:
raise CuckooMachineError(
"The physical machine %s has not been defined in FOG, "
"please investigate and configure the configuration "
"correctly." % machine.label)
def __init__(self, *args, **kwargs):
self.cfg = Config()
self.analysistasks = {}
self.tasks = {}
self.analysishandlers = {}
# CHANGED: Save info about APIs, BPs and times for each trigger.
self.bps = []
self.volshell_bps = []
self.machinery = None
try:
server_addr = self.cfg.resultserver.ip, self.cfg.resultserver.port
SocketServer.ThreadingTCPServer.__init__(self,
server_addr,
Resulthandler,
*args,
**kwargs)
except Exception as e:
raise CuckooCriticalError("Unable to bind result server on "
"{0}:{1}: {2}".format(
self.cfg.resultserver.ip,
self.cfg.resultserver.port, str(e)))
else:
self.servethread = Thread(target=self.serve_forever)
self.servethread.setDaemon(True)
self.servethread.start()
def __init__(self, *args, **kwargs):
self.cfg = Config()
self.analysistasks = {}
self.analysishandlers = {}
ip = self.cfg.resultserver.ip
port = int(self.cfg.resultserver.port)
while True:
try:
server_addr = ip, port
SocketServer.ThreadingTCPServer.__init__(self,
server_addr,
Resulthandler,
*args,
**kwargs)
except Exception as e:
if e.errno == 98:
log.warning("Cannot bind ResultServer on port {0}, "
"trying another one...".format(port))
port += 1
else:
raise CuckooCriticalError("Unable to bind ResultServer on "
"{0}:{1}: {2}".format(
ip,
port,
str(e)))
else:
log.debug("ResultServer running on {0}:{1}".format(ip, port))
self.servethread = Thread(target=self.serve_forever)
self.servethread.setDaemon(True)
self.servethread.start()
break
def __init__(self, *args, **kwargs):
self.cfg = Config()
self.analysistasks = {}
self.analysishandlers = {}
ip = self.cfg.resultserver.ip
port = int(self.cfg.resultserver.port)
while True:
try:
server_addr = ip, port
SocketServer.ThreadingTCPServer.__init__(
self, server_addr, ResultHandler, *args, **kwargs)
except Exception as e:
# In Linux /usr/include/asm-generic/errno-base.h.
# EADDRINUSE 98 (Address already in use)
# In Mac OS X or FreeBSD:
# EADDRINUSE 48 (Address already in use)
if e.errno == 98 or e.errno == 48:
log.warning("Cannot bind ResultServer on port {0}, "
"trying another port.".format(port))
port += 1
else:
raise CuckooCriticalError("Unable to bind ResultServer on "
"{0}:{1}: {2}".format(
ip, port, str(e)))
else:
log.debug("ResultServer running on {0}:{1}.".format(ip, port))
self.servethread = Thread(target=self.serve_forever)
self.servethread.setDaemon(True)
self.servethread.start()
break
def start_emulator(self, label):
emulator_port = str(self.options.get(label)["emulator_port"])
task_id = self.get_task_id(label)
if task_id is None:
raise CuckooCriticalError(
"android emulator failed starting the machine ,can't find task_id"
)
"""Starts the emulator"""
pcap_dump_path = os.path.join(CUCKOO_ROOT, "storage", "analyses",
str(task_id), "dump.pcap")
cmd = [
self.options.avd.emulator_path, "@{0}".format(label),
"-no-snapshot-save", "-netspeed", "full", "-netdelay", "none",
"-port", emulator_port, "-tcpdump", pcap_dump_path
]
# In headless mode we remove the skin, audio, and window support.
if self.options.avd.mode == "headless":
cmd += ["-no-skin", "-no-audio", "-no-window"]
self.emulator_processes[label] = OSCommand.executeAsyncCommand(cmd)
time.sleep(10)
#if not self.__checkADBRecognizeEmu(label):
self.restart_adb_server()
# waits for device to be ready
self.wait_for_device_ready(label)
def _initialize_check(self):
"""Ensure that credentials have been entered into the config file.
@raise CuckooCriticalError: if no credentials were provided or if
one or more physical machines are offline.
"""
# TODO This should be moved to a per-machine thing.
if not self.options.physical.user or not self.options.physical.password:
raise CuckooCriticalError(
"Physical machine credentials are missing, please add it to "
"the Physical machinery configuration file."
)
global headers
headers = {
"fog-api-token": self.options.fog.apikey,
"fog-user-token": self.options.fog.user_apikey,
"Content-Type": "application/json"
}
self.fog_init()
for machine in self.machines():
status = self._status(machine.label)
if status == self.STOPPED:
# Send a Wake On Lan message (if we're using FOG).
self.wake_on_lan(machine.label)
elif status == self.ERROR:
raise CuckooMachineError(
"Unknown error occurred trying to obtain the status of "
"physical machine %s. Please turn it on and check the "
"Cuckoo Agent." % machine.label
)
def import_plugin(name):
try:
module = __import__(name, globals(), locals(), ["dummy"], -1)
except ImportError as e:
raise CuckooCriticalError("Unable to import plugin "
"\"{0}\": {1}".format(name, e))
else:
load_plugins(module)
def _connect(self):
try:
self.auth = [[
libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT
], self._auth_callback, None]
return libvirt.openAuth(self.dsn, self.auth, 0)
except libvirt.libvirtError as libvex:
raise CuckooCriticalError(
"libvirt returned an exception on connection: %s" % libvex)
def __init__(self, *args, **kwargs):
self.cfg = Config()
self.analysistasks = {}
self.analysishandlers = {}
ip = self.cfg.resultserver.ip
self.port = int(self.cfg.resultserver.port)
while True:
try:
server_addr = ip, self.port
SocketServer.ThreadingTCPServer.__init__(
self, server_addr, ResultHandler, *args, **kwargs
)
except Exception as e:
if e.errno == errno.EADDRINUSE:
if self.cfg.resultserver.get("force_port"):
raise CuckooCriticalError(
"Cannot bind ResultServer on port %d, "
"bailing." % self.port
)
else:
log.warning("Cannot bind ResultServer on port %s, "
"trying another port.", self.port)
self.port += 1
elif e.errno == errno.EADDRNOTAVAIL:
raise CuckooCriticalError(
"Unable to bind ResultServer on %s:%s %s. This "
"usually happens when you start Cuckoo without "
"bringing up the virtual interface associated with "
"the ResultServer IP address. Please refer to "
"http://docs.cuckoosandbox.org/en/latest/faq/#troubles-problem"
" for more information." % (ip, self.port, e)
)
else:
raise CuckooCriticalError(
"Unable to bind ResultServer on %s:%s: %s" %
(ip, self.port, e)
)
else:
log.debug("ResultServer running on %s:%s.", ip, self.port)
self.servethread = threading.Thread(target=self.serve_forever)
self.servethread.setDaemon(True)
self.servethread.start()
break
def _auth_callback(self, credentials, user_data):
for credential in credentials:
if credential[0] == libvirt.VIR_CRED_AUTHNAME:
credential[4] = self.options.esx.username
elif credential[0] == libvirt.VIR_CRED_NOECHOPROMPT:
credential[4] = self.options.esx.password
else:
raise CuckooCriticalError("ESX machinery did not recieve an object to inject a username or password into")
return 0
def fog_init(self):
"""Initiate by indexing FOG regarding all available machines."""
self.fog_machines = {}
if not HAVE_FOG or self.options.fog.hostname == "none":
return
# TODO Handle exceptions such as not being able to connect.
r = self.fog_query("node=task&sub=listhosts")
# Parse the HTML.
b = bs4.BeautifulSoup(r.content, "html.parser")
if not b.find_all("table"):
raise CuckooCriticalError(
"The supplied FOG username and/or password do not allow us "
"to login into FOG, please configure the correct credentials.")
# Pull out the FOG version from the header and raise error if it is not 1.3.4
v = b.find("div", {"id": "version"})
runningVer = re.match(r"Running Version\s+(([0-9]+\.)+[0-9]+)",
v.text).group(1)
if runningVer != "1.3.4": # This may be better suited to go in lib.cuckoo.common.constants
raise CuckooCriticalError(
"The current version of FOG was detected as %s. "
"The only supported version is 1.3.4." % runningVer)
# Mapping for physical machine hostnames to their mac address and uri
# for "downloading" a safe image onto the host. Great piece of FOG API
# usage here.
for row in b.find_all("table")[0].find_all("tr")[1:]:
hostinfo, imagename, actions = row.find_all("td")
self.fog_machines[hostinfo.find("a").text] = (
hostinfo.find("small").text,
actions.find(title="Deploy").parent.attrs["href"][1:],
)
# Check whether all our machines are available on FOG.
for machine in self.machines():
if machine.label not in self.fog_machines:
raise CuckooMachineError(
"The physical machine %s has not been defined in FOG, "
"please investigate and configure the configuration "
"correctly." % machine.label)
def import_plugin(name):
try:
module = __import__(name, globals(), locals(), ["dummy"], -1)
except ImportError as e:
raise CuckooCriticalError("Unable to import plugin " '"{0}": {1}'.format(name, e))
for name, value in inspect.getmembers(module):
if inspect.isclass(value):
if issubclass(value, Machinery) and value is not Machinery and value is not LibVirtMachinery:
return value
def _global_connect(self):
"""
set the single connection handle
"""
try:
self.auth = [[
libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT
], self._auth_callback, None]
return libvirt.openAuth(self.dsn, self.auth, 0)
except libvirt.libvirtError as libvex:
raise CuckooCriticalError(
f"libvirt returned an exception on connection: {libvex}")
def initialize(self):
"""Initialize the machine manager."""
global machinery
machinery_name = self.cfg.cuckoo.machinery
log.info("Using \"%s\" machine manager", machinery_name)
# Get registered class name. Only one machine manager is imported,
# therefore there should be only one class in the list.
plugin = list_plugins("machinery")[0]
# Initialize the machine manager.
machinery = plugin()
# Find its configuration file.
conf = os.path.join(CUCKOO_ROOT, "conf", "%s.conf" % machinery_name)
if not os.path.exists(conf):
raise CuckooCriticalError("The configuration file for machine "
"manager \"{0}\" does not exist at path:"
" {1}".format(machinery_name, conf))
# Provide a dictionary with the configuration options to the
# machine manager instance.
machinery.set_options(Config(conf))
# Initialize the machine manager.
try:
machinery.initialize(machinery_name)
except CuckooMachineError as e:
raise CuckooCriticalError("Error initializing machines: %s" % e)
# At this point all the available machines should have been identified
# and added to the list. If none were found, Cuckoo needs to abort the
# execution.
if not len(machinery.machines()):
raise CuckooCriticalError("No machines available")
else:
log.info("Loaded %s machine/s", len(machinery.machines()))
def _initialize_check(self):
"""Runs checks against virtualization software when a machine manager
is initialized.
@note: in machine manager modules you may override or superclass
his method.
@raise CuckooMachineError: if a misconfiguration or a unkown vm state
is found.
"""
try:
configured_vm = self._list()
except NotImplementedError:
return
for machine in self.machines():
if machine.label not in configured_vm:
raise CuckooCriticalError(
"Configured machine {0} was not detected or it's not in proper state"
.format(machine.label))
if not self.options_globals.timeouts.vm_state:
raise CuckooCriticalError(
"Virtual machine state change timeout setting not found, please add it to the config file"
)
def _initialize_check(self):
"""Runs all checks when a machine manager is initialized.
@raise CuckooMachineError: if the android emulator is not found.
"""
self.emulator_processes = {}
if not self.options.avd.emulator_path:
raise CuckooCriticalError("emulator path missing, "
"please add it to the config file")
if not os.path.exists(self.options.avd.emulator_path):
raise CuckooCriticalError("emulator not found at "
"specified path \"%s\"" %
self.options.avd.emulator_path)
if not self.options.avd.adb_path:
raise CuckooCriticalError("adb path missing, "
"please add it to the config file")
if not os.path.exists(self.options.avd.adb_path):
raise CuckooCriticalError("adb not found at "
"specified path \"%s\"" %
self.options.avd.adb_path)
if not self.options.avd.avd_path:
raise CuckooCriticalError("avd path missing, "
"please add it to the config file")
if not os.path.exists(self.options.avd.avd_path):
raise CuckooCriticalError("avd not found at "
"specified path \"%s\"" %
self.options.avd.avd_path)
if not self.options.avd.reference_machine:
raise CuckooCriticalError("reference machine path missing, "
"please add it to the config file")
machine_path = os.path.join(self.options.avd.avd_path,
self.options.avd.reference_machine)
if not os.path.exists("%s.avd" % machine_path) or \
not os.path.exists("%s.ini" % machine_path):
raise CuckooCriticalError("reference machine not found at "
"specified path \"%s\"" % machine_path)
def _initialize_check(self):
"""Runs all checks when a machine manager is initialized.
@raise CuckooMachineError: if VBoxManage is not found.
"""
#todo:remove
#self.options = Config(os.path.join(CUCKOO_ROOT, "conf", "avd_new.conf"))
#todo check!!!
self.emulator_processes = {}
if not self.options.avd.emulator_path:
raise CuckooCriticalError("emulator path missing, "
"please add it to the config file")
if not os.path.exists(self.options.avd.emulator_path):
raise CuckooCriticalError("emulator not found at "
"specified path \"%s\"" %
self.options.avd.emulator_path)
if not self.options.avd.adb_path:
raise CuckooCriticalError("adb path missing, "
"please add it to the config file")
if not os.path.exists(self.options.avd.adb_path):
raise CuckooCriticalError("adb not found at "
"specified path \"%s\"" %
self.options.avd.adb_path)
if not self.options.avd.avd_path:
raise CuckooCriticalError("avd path missing, "
"please add it to the config file")
if not os.path.exists(self.options.avd.avd_path):
raise CuckooCriticalError("avd not found at "
"specified path \"%s\"" %
self.options.avd.avd_path)
if not self.options.avd.reference_machine:
raise CuckooCriticalError("reference machine path missing, "
"please add it to the config file")
machine_path = os.path.join(self.options.avd.avd_path,
self.options.avd.reference_machine)
if not (os.path.exists(machine_path + ".avd")
and os.path.exists(machine_path + ".ini")):
raise CuckooCriticalError("reference machine not found at "
"specified path \"%s\"" % machine_path)
def __init__(self, *args, **kwargs):
self.cfg = Config()
self.analysistasks = {}
self.analysishandlers = {}
try:
SocketServer.ThreadingTCPServer.__init__(
self, (self.cfg.resultserver.ip, self.cfg.resultserver.port),
Resulthandler, *args, **kwargs)
except Exception as e:
raise CuckooCriticalError(
"Unable to bind result server on {0}:{1}: {2}".format(
self.cfg.resultserver.ip, self.cfg.resultserver.port,
str(e)))
else:
self.servethread = Thread(target=self.serve_forever)
self.servethread.setDaemon(True)
self.servethread.start()
def _initialize_check(self):
"""Ensures that credentials have been entered into the config file.
@raise CuckooCriticalError: if no credentials were provided or if
one or more physical machines are offline.
"""
# TODO This should be moved to a per-machine thing.
if not self.options.physical.user or not self.options.physical.password:
raise CuckooCriticalError(
"Physical machine credentials are missing, please add it to "
"the Physical machinery configuration file.")
self.fog_init()
for machine in self.machines():
status = self._status(machine.label)
if status == self.STOPPED:
self.wake_on_lan(machine.label)
elif status == self.ERROR:
raise CuckooMachineError(
"Unknown error occurred trying to obtain the status of "
"physical machine %s. Please turn it on and check the "
"Cuckoo Agent." % machine.label)
def _initialize(self, module_name):
"""Read configuration.
@param module_name: module name.
"""
super(KVMRemote, self)._initialize(module_name)
hypervs_labels = self.options.get("kvmremote")["hypervisors"]
hypervs_labels = ("".join(hypervs_labels.split())).split(",")
for machine in self.machines():
machine_cfg = self.options.get(machine.label)
if machine_cfg.hypervisor:
if machine_cfg.hypervisor not in hypervs_labels:
raise CuckooCriticalError(
"Unknown hypervisor %s for %s" %
(machine_cfg.hypervisor, machine.label))
hyperv_cfg = self.options.get(machine_cfg.hypervisor)
machine_cfg.dsn = hyperv_cfg.dsn
machine_cfg.interface = hyperv_cfg.interface