def preprocessor_keyspace(self, task, chunk):
preprocessor = task.get_preprocessor()
if preprocessor['keyspaceCommand'] is None: # in case there is no keyspace flag, we just assume the task will be that large to run forever
return chunk.send_keyspace(-1, task.get_task()['taskId'])
binary = preprocessor['executable']
if Initialize.get_os() != 1:
binary = "./" + binary
if not os.path.isfile(binary):
split = binary.split(".")
binary = '.'.join(split[:-1]) + get_bit() + "." + split[-1]
full_cmd = binary + " " + preprocessor['keyspaceCommand'] + " " + update_files(task.get_task()['preprocessorCommand'])
if Initialize.get_os() == 1:
full_cmd = full_cmd.replace("/", '\\')
try:
logging.debug("CALL: " + full_cmd)
output = subprocess.check_output(full_cmd, shell=True, cwd="preprocessor/" + str(task.get_task()['preprocessor']))
except subprocess.CalledProcessError:
logging.error("Error during preprocessor keyspace measure")
send_error("Preprocessor keyspace measure failed!", self.config.get_value('token'), task.get_task()['taskId'], None)
sleep(5)
return False
output = output.decode(encoding='utf-8').replace("\r\n", "\n").split("\n")
keyspace = "0"
for line in output:
if not line:
continue
keyspace = line
# as the keyspace of preprocessors can get very very large, we only save it in case it's small enough to fit in a long,
# otherwise we assume that the user will abort the task earlier anyway
if int(keyspace) > 9000000000000000000: # close to max size of a long long int
return chunk.send_keyspace(-1, task.get_task()['taskId'])
return chunk.send_keyspace(int(keyspace), task.get_task()['taskId'])
def build_preprocessor_command(self, task, chunk, preprocessor):
binary = "../../preprocessor/" + str(task['preprocessor']) + "/" + preprocessor['executable']
if Initialize.get_os() != 1:
binary = "./" + binary
if not os.path.isfile(binary):
split = binary.split(".")
binary = '.'.join(split[:-1]) + get_bit() + "." + split[-1]
# in case the skip or limit command are not available, we try to achieve the same with head/tail (the more chunks are run, the more inefficient it might be)
if preprocessor['skipCommand'] is not None and preprocessor['limitCommand'] is not None:
pre_args = " " + preprocessor['skipCommand'] + " " + str(chunk['skip']) + " " + preprocessor['limitCommand'] + " " + str(chunk['length']) + ' '
else:
pre_args = ""
pre_args += ' ' + update_files(task['preprocessorCommand'])
# TODO: add support for windows as well (pre-built tools)
if preprocessor['skipCommand'] is None or preprocessor['limitCommand'] is None:
pre_args += " | head -n " + str(chunk['skip'] + chunk['length']) + " | tail -n " + str(chunk['length'])
post_args = " --machine-readable --quiet --status --remove --restore-disable --potfile-disable --session=hashtopolis"
post_args += " --status-timer " + str(task['statustimer'])
post_args += " --outfile-check-timer=" + str(task['statustimer'])
post_args += " --outfile-check-dir=../../hashlist_" + str(task['hashlistId'])
post_args += " -o ../../hashlists/" + str(task['hashlistId']) + ".out --outfile-format=" + self.get_outfile_format() + " -p \"" + str(chr(9)) + "\""
post_args += " --remove-timer=" + str(task['statustimer'])
post_args += " ../../hashlists/" + str(task['hashlistId'])
post_args += update_files(task['attackcmd']).replace(task['hashlistAlias'], '')
return binary + pre_args + " | " + self.callPath + post_args + task['cmdpars']
def __init__(self, cracker_id, binary_download):
self.config = Config()
self.io_q = Queue()
# Build cracker executable name by taking basename plus extension
self.executable_name = binary_download.get_version()['executable']
k = self.executable_name.rfind(".")
self.executable_name = self.executable_name[:k] + "." + self.executable_name[k + 1:]
self.cracker_path = "crackers/" + str(cracker_id) + "/"
self.callPath = self.executable_name
if Initialize.get_os() != 1:
self.callPath = "./" + self.callPath
if not os.path.isfile(self.cracker_path + self.callPath): # in case it's not the new hashcat filename, try the old one (hashcat<bit>.<ext>)
self.executable_name = binary_download.get_version()['executable']
k = self.executable_name.rfind(".")
self.executable_name = self.executable_name[:k] + get_bit() + "." + self.executable_name[k + 1:]
self.cracker_path = "crackers/" + str(cracker_id) + "/"
self.callPath = self.executable_name
if Initialize.get_os() != 1:
self.callPath = "./" + self.callPath
self.lock = Lock()
self.cracks = []
self.first_status = False
self.usePipe = False
self.progressVal = 0
self.statusCount = 0
self.last_update = 0
self.uses_slow_hash_flag = False
self.wasStopped = False
def __init__(self, cracker_id, binary_download):
self.config = Config()
self.io_q = Queue()
self.version_string = ""
# Build cracker executable name by taking basename plus extension
self.executable_name = binary_download.get_version()['executable']
k = self.executable_name.rfind(".")
self.executable_name = self.executable_name[:k] + "." + self.executable_name[k + 1:]
self.cracker_path = "crackers/" + str(cracker_id) + "/"
self.callPath = self.executable_name
if Initialize.get_os() != 1:
self.callPath = "./" + self.callPath
# Symlink hashcat.osx in macOS
if not os.path.isfile(self.cracker_path + "hashcat.osx"): # in case it's not the
if Initialize.get_os() == 2: # macOS
try:
output = subprocess.check_output("ln -s $(which hashcat) hashcat.osx", shell=True, cwd=self.cracker_path)
except subprocess.CalledProcessError as e:
logging.error("Error during version detection: " + str(e))
sleep(5)
if not os.path.isfile(self.cracker_path + self.callPath): # in case it's not the new hashcat filename, try the old one (hashcat<bit>.<ext>)
self.executable_name = binary_download.get_version()['executable']
k = self.executable_name.rfind(".")
self.executable_name = self.executable_name[:k] + get_bit() + "." + self.executable_name[k + 1:]
self.cracker_path = "crackers/" + str(cracker_id) + "/"
self.callPath = self.executable_name
if Initialize.get_os() != 1:
self.callPath = "./" + self.callPath
cmd = self.callPath + " --version"
output = ''
try:
logging.debug("CALL: " + cmd)
output = subprocess.check_output(cmd, shell=True, cwd=self.cracker_path)
except subprocess.CalledProcessError as e:
logging.error("Error during version detection: " + str(e))
sleep(5)
self.version_string = output.decode().replace('v', '')
self.lock = Lock()
self.cracks = []
self.first_status = False
self.usePipe = False
self.progressVal = 0
self.statusCount = 0
self.last_update = 0
self.uses_slow_hash_flag = False
self.wasStopped = False
def __init__(self, cracker_id, binary_download):
self.config = Config()
self.io_q = Queue()
self.executable_name = binary_download.get_version()['executable']
k = self.executable_name.rfind(".")
self.executable_name = self.executable_name[:k] + get_bit() + "." + self.executable_name[k + 1:]
self.cracker_path = "crackers/" + str(cracker_id) + "/"
self.callPath = self.executable_name
if Initialize.get_os() != 1:
self.callPath = "./" + self.callPath
self.lock = Lock()
self.cracks = []
self.first_status = False
self.last_update = 0
def __init__(self, cracker_id, binary_download):
self.config = Config()
self.io_q = Queue()
# Build cracker executable name by taking basename and adding 32/64 plus extension
self.executable_name = binary_download.get_version()['executable']
k = self.executable_name.rfind(".")
self.executable_name = self.executable_name[:k] + get_bit(
) + "." + self.executable_name[k + 1:]
self.cracker_path = "crackers/" + str(cracker_id) + "/"
self.callPath = self.executable_name
if Initialize.get_os() != 1:
self.callPath = "./" + self.callPath
self.lock = Lock()
self.cracks = []
self.first_status = False
self.usePipe = False
self.progressVal = 0
self.statusCount = 0
self.last_update = 0
self.uses_slow_hash_flag = False
self.wasStopped = False
