import subprocess
import time
import hashcat_attack_name as han
# 进制转换
# 进制字符串， 待转换至10进制的字符串
# 返回，10进制数字
def base_change_special_normal(_rule_str, _special):
_rule_str = "".join(_rule_str)
_special = "".join(_special)
t_base = _rule_str.__str__().__len__()
t_total = 0
t_length = _special.__len__()
t_s = _special.__getitem__(t_length - 1)
t_total = t_total + _rule_str.index(t_s)
t_unit_base = t_base
for i in range(t_length-2, -1, -1):
t_total = t_total + t_unit_base * _rule_str.index(_special.__getitem__(i))
t_unit_base = t_unit_base*t_base
return t_total
# 进制转换
# 进制字符串，10进制数字， 填充长度
# 返回，给定进制字符串形式的进制
def base_change_normal_special(_rule_str, _decimal, _fill_length):
# 进制基数
t_base = _rule_str.__str__().__len__().__int__()
t_list = []
t_decimal = _decimal.__int__()
while t_decimal > 0:
t_mod = t_decimal % t_base
t_decimal = t_decimal // t_base
t_list.append(_rule_str.__getitem__(t_mod))
if _fill_length > 0 and t_list.__len__() < _fill_length:
for i in range(t_list.__len__(), _fill_length):
t_list.append(_rule_str.__getitem__(0))
t_list.reverse()
return "".join(t_list)
# dict_string表示所有组合的字符源，task_mount表示分割的任务数，task_length表示生成的长度
# task_starts指定开始的字符串，task_stops指定结束的字符串
# 返回一个列表，以[开始字符串，结束字符串，开始字符串，结束字符串，。。。]的形式返回
def str_task_split(_dict_str, _task_mount, _task_length, _task_starts, _task_stops):
_task_mount = int(_task_mount)
_task_length = int(_task_length)
if str(_task_starts).__len__() != str(_task_stops).__len__():
print("str_task_split 参数错误，4,5长度不等")
return 0
if _task_length != str(_task_starts).__len__():
print("str_task_split 参数错误，长度不匹配")
return 0
# 进制转换
t_starts_d = base_change_special_normal(_dict_str, _task_starts)
t_stops_d = base_change_special_normal(_dict_str, _task_stops)
# 剩余需要生成的总数
t_total = t_stops_d-t_starts_d
# 每个任务的数量
t_task_average = t_total // _task_mount
# 任务余数，这个加在最后一个任务里
t_task_mod = t_total % _task_mount
t_return_list = []
for i in range(0, _task_mount - 1):
t_return_list.append(base_change_normal_special(_dict_str, t_starts_d, _task_length))
print(t_starts_d, end="-->")
t_stops_d = t_starts_d + t_task_average
print(t_stops_d)
t_return_list.append(base_change_normal_special(_dict_str, t_stops_d, _task_length))
t_starts_d = t_stops_d+1
t_return_list.append(base_change_normal_special(_dict_str, t_starts_d, _task_length))
print(t_stops_d, end="-->")
t_stops_dt_stops_d = t_stops_d + t_task_average + t_task_mod
t_return_list.append(base_change_normal_special(_dict_str, t_stops_d, _task_length))
print(t_stops_d)
return t_return_list
# 检测是否子进程是否找到密码并输出文件，文件内容是否包含密码
# 文件名前缀，进程数量，文件扩展名
# 返回True表示找到密码
def hashcat_attack_sub_has_passwd(_out_pre, _mount, _out_type):
_mount = int(_mount)
_has_passwd = False
for i in range(0,_mount):
_file_name = _out_pre+str(i)+_out_type
try:
f = open(_file_name, 'r')
if f.readline().find('KEY FOUND') >= 0:
_has_passwd = True
f.close()
break
except IOError:
pass
return _has_passwd
# 得到分配列表
# 分配进程
# 读取子进程进度，记录子进程已完成的密码，显示子进程已完成的密码
def hashcat_attack_tasks_malloc(_dict_str, _task_mount, _task_length, _task_starts, _task_stops):
_task_mount = int(_task_mount)
_task_length = int(_task_length)
# 检测是否存在上一次的任务，并且是否继续上一次的任务
print(time.asctime(time.localtime(time.time())))
_has_load_task = False
try:
continue_file = open(han.continue_file_name, 'r')
__task_mount = continue_file.readline().strip()
_is_finish = continue_file.readline().strip()
continue_file.close()
if _is_finish == han.continue_flag:
ask = input('是否继续未完成的任务（Y/n）：')
print(ask)
if ask.lower() == 'yes' or ask.lower() == 'y' or ask == '\n':
task_str_list = list()
for i in range(0, _task_mount):
_task_load_file = open(han.split_load_file_pre+str(i)+han.split_load_file_type)
task_str_list.append(_task_load_file.readline().strip())
_has_load_task = True
_task_mount = int(__task_mount)
except IOError:
pass
# 分配列表
if not _has_load_task:
task_str_list = str_task_split(_dict_str, _task_mount, _task_length, _task_starts, _task_stops)
task_list = list()
# 创建任务列表
for i in range(0, _task_mount):
task_argument_list = ['python', 'hashcat_attack_task.py', _dict_str, task_str_list[i * 2], task_str_list[i * 2 + 1], str(i)]
task_list.append(subprocess.Popen(task_argument_list))
# 创建记录文件
continue_file = open(han.continue_file_name, 'w')
continue_file.write(str(_task_mount)+'\n')
continue_file.write(han.continue_flag)
continue_file.close()
while True:
# 60秒查询一次子进程的状态，当有进程得到密码时，停止所有的进程
time.sleep(60)
# 用于判断所有进程是否结束
task_all_over = 0
# 检测任务是否结束，检测子进程是否输出密码文件
for i in range(0, _task_mount):
if task_list[i].poll().__str__().strip() == "None":
# 检测是否输出密码文件的函数
if hashcat_attack_sub_has_passwd(han.output_pre, _task_mount, han.output_type):
# 结束所有进程
task_all_over = _task_mount
# 写入任务完成
continue_file = open(han.continue_file_name, 'w')
continue_file.write(str(_task_mount) + '\n')
continue_file.write(han.continue_flag)
continue_file.close()
print('找到密码请查看目录下文件')
print(time.asctime(time.localtime(time.time())))
else:
task_all_over = task_all_over+1
if task_all_over == _task_mount:
for i in range(0,_task_mount):
task_list[i].terminate()
break
print('当前字符集所有组合已经全部尝试')
dict_str = "1234567890"
task_length = 10
task_mount = 4
task_starts = "1234491111"
task_stops = "1234560000"
hashcat_attack_tasks_malloc(dict_str, task_mount, task_length, task_starts, task_stops)
