def __init__(self, task, results):
"""@param analysis_path: analysis folder path."""
self.task = task
self.results = results
self.analysis_path = os.path.join(CUCKOO_ROOT, "storage", "analyses", str(task["id"]))
self.cfg = Config("reporting")
self.task["options"] = parse_options(self.task["options"])
def __init__(self, task, results):
"""@param analysis_path: analysis folder path."""
self.task = task
self.results = results
self.analysis_path = os.path.join(CUCKOO_ROOT, "storage", "analyses", str(task["id"]))
self.cfg = Config("reporting")
self.task["options"] = parse_options(self.task["options"])
def __init__(self, task, error_queue):
"""@param task: task object containing the details for the analysis."""
threading.Thread.__init__(self)
self.task = task
self.errors = error_queue
self.cfg = Config()
self.storage = ""
self.binary = ""
self.machine = None
self.db = Database()
self.task.options = parse_options(self.task.options)
def determine_analyzer_path(self):
"""Determine the path of the analyzer. Basically creating a temporary
directory in the systemdrive, i.e., C:\\."""
systemdrive = self.determine_system_drive()
options = parse_options(self.options["options"])
if options.get("analpath"):
dirpath = systemdrive + options["analpath"]
r = self.post("/mkdir", data={"dirpath": dirpath})
self.analyzer_path = dirpath
else:
r = self.post("/mkdtemp", data={"dirpath": systemdrive})
self.analyzer_path = r.json()["dirpath"]
def __init__(self, task, error_queue):
"""@param task: task object containing the details for the analysis."""
threading.Thread.__init__(self)
self.task = task
self.errors = error_queue
self.cfg = Config()
self.storage = ""
self.binary = ""
self.machine = None
self.db = Database()
self.task.options = parse_options(self.task.options)
def index(request, task_id=None, sha1=None):
if request.method == "GET":
return render_index(request)
package = request.POST.get("package", "")
timeout = force_int(request.POST.get("timeout"))
options = request.POST.get("options", "")
priority = force_int(request.POST.get("priority"))
machine = request.POST.get("machine", "")
custom = request.POST.get("custom", "")
memory = bool(request.POST.get("memory", False))
enforce_timeout = bool(request.POST.get("enforce_timeout", False))
tags = request.POST.get("tags", None)
options = parse_options(options)
# The following POST fields take precedence over the options field.
if request.POST.get("route"):
options["route"] = request.POST.get("route")
if request.POST.get("free"):
options["free"] = "yes"
if request.POST.get("process_memory"):
options["procmemdump"] = "yes"
if request.POST.get("services"):
options["services"] = "yes"
if not request.POST.get("human"):
options["human"] = "0"
if request.POST.get("screenshots"):
options["screenshots"] = force_int(request.POST.get("screenshots"))
db = Database()
task_ids = []
task_machines = []
if machine.lower() == "all":
for entry in db.list_machines():
task_machines.append(entry.label)
else:
task_machines.append(machine)
# In case of resubmitting a file.
if request.POST.get("category") == "file":
task = Database().view_task(task_id)
for entry in task_machines:
task_id = db.add_path(file_path=task.target,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
elif request.FILES.getlist("sample"):
samples = request.FILES.getlist("sample")
for sample in samples:
# Error if there was only one submitted sample and it's empty.
# But if there are multiple and one was empty, just ignore it.
if not sample.size:
if len(samples) != 1:
continue
return render(request, "error.html", {
"error": "You uploaded an empty file.",
})
elif sample.size > settings.MAX_UPLOAD_SIZE:
return render(
request, "error.html", {
"error":
"You uploaded a file that exceeds that maximum allowed upload size.",
})
# Moving sample from django temporary file to Cuckoo temporary
# storage to let it persist between reboot (if user like to
# configure it in that way).
path = store_temp_file(sample.read(), sample.name)
for entry in task_machines:
task_id = db.add_path(file_path=path,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
# When submitting a dropped file.
elif request.POST.get("category") == "dropped_file":
filepath = dropped_filepath(task_id, sha1)
for entry in task_machines:
task_id = db.add_path(file_path=filepath,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
else:
url = request.POST.get("url").strip()
if not url:
return render(request, "error.html", {
"error": "You specified an invalid URL!",
})
for entry in task_machines:
task_id = db.add_url(url=url,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
tasks_count = len(task_ids)
if tasks_count > 0:
return render(
request, "submission/complete.html", {
"tasks": task_ids,
"tasks_count": tasks_count,
"baseurl": request.build_absolute_uri('/')[:-1],
})
else:
return render(request, "error.html", {
"error": "Error adding task to Cuckoo's database.",
})
def index(request, task_id=None, sha1=None):
if request.method == "GET":
return render_index(request)
package = request.POST.get("package", "")
timeout = force_int(request.POST.get("timeout"))
options = request.POST.get("options", "")
priority = force_int(request.POST.get("priority"))
machine = request.POST.get("machine", "")
custom = request.POST.get("custom", "")
memory = bool(request.POST.get("memory", False))
enforce_timeout = bool(request.POST.get("enforce_timeout", False))
tags = request.POST.get("tags", None)
options = parse_options(options)
# The following POST fields take precedence over the options field.
if request.POST.get("route"):
options["route"] = request.POST.get("route")
if request.POST.get("free"):
options["free"] = "yes"
if request.POST.get("process_memory"):
options["procmemdump"] = "yes"
if request.POST.get("services"):
options["services"] = "yes"
db = Database()
task_ids = []
task_machines = []
if machine.lower() == "all":
for entry in db.list_machines():
task_machines.append(entry.label)
else:
task_machines.append(machine)
# In case of resubmitting a file.
if request.POST.get("category") == "file":
task = Database().view_task(task_id)
for entry in task_machines:
task_id = db.add_path(file_path=task.target,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
elif request.FILES.getlist("sample"):
samples = request.FILES.getlist("sample")
for sample in samples:
# Error if there was only one submitted sample and it's empty.
# But if there are multiple and one was empty, just ignore it.
if not sample.size:
if len(samples) != 1:
continue
return render_to_response("error.html",
{"error": "You uploaded an empty file."},
context_instance=RequestContext(request))
elif sample.size > settings.MAX_UPLOAD_SIZE:
return render_to_response("error.html",
{"error": "You uploaded a file that exceeds that maximum allowed upload size."},
context_instance=RequestContext(request))
# Moving sample from django temporary file to Cuckoo temporary
# storage to let it persist between reboot (if user like to
# configure it in that way).
path = store_temp_file(sample.read(), sample.name)
for entry in task_machines:
task_id = db.add_path(file_path=path,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
# When submitting a dropped file.
elif request.POST.get("category") == "dropped_file":
filepath = dropped_filepath(task_id, sha1)
for entry in task_machines:
task_id = db.add_path(file_path=filepath,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
else:
url = request.POST.get("url").strip()
if not url:
return render_to_response("error.html",
{"error": "You specified an invalid URL!"},
context_instance=RequestContext(request))
for entry in task_machines:
task_id = db.add_url(url=url,
package=package,
timeout=timeout,
options=emit_options(options),
priority=priority,
machine=entry,
custom=custom,
memory=memory,
enforce_timeout=enforce_timeout,
tags=tags)
if task_id:
task_ids.append(task_id)
tasks_count = len(task_ids)
if tasks_count > 0:
return render_to_response("submission/complete.html",
{"tasks": task_ids,
"tasks_count": tasks_count,
"baseurl": request.build_absolute_uri('/')[:-1]},
context_instance=RequestContext(request))
else:
return render_to_response("error.html",
{"error": "Error adding task to Cuckoo's database."},
context_instance=RequestContext(request))
def options(self):
if not self._options:
return {}
return parse_options(self._options)
def options(self):
if not self._options:
return {}
return parse_options(self._options)
