538 lines
15 KiB
Python
538 lines
15 KiB
Python
#!/bin/python3
|
|
#
|
|
# Created by Panagiotis Chartas (t3l3machus)
|
|
# https://github.com/t3l3machus
|
|
|
|
import argparse, sys, itertools
|
|
|
|
# Colors
|
|
MAIN = '\033[38;5;50m'
|
|
LOGO = '\033[38;5;41m'
|
|
LOGO2 = '\033[38;5;42m'
|
|
GREEN = '\033[38;5;82m'
|
|
ORANGE = '\033[0;38;5;214m'
|
|
PRPL = '\033[0;38;5;26m'
|
|
PRPL2 = '\033[0;38;5;25m'
|
|
RED = '\033[1;31m'
|
|
END = '\033[0m'
|
|
BOLD = '\033[1m'
|
|
|
|
# -------------- Arguments & Usage -------------- #
|
|
parser = argparse.ArgumentParser(
|
|
formatter_class=argparse.RawTextHelpFormatter,
|
|
epilog='''
|
|
Usage examples:
|
|
|
|
Basic:
|
|
python3 psudohash.py -w <keywords> -cpa
|
|
|
|
Thorough:
|
|
python3 psudohash.py -w <keywords> -cpa -cpb -an 3 -y 1990-2022
|
|
'''
|
|
)
|
|
|
|
parser.add_argument("-w", "--words", action="store", help = "Comma seperated keywords to mutate", required = True)
|
|
parser.add_argument("-an", "--append-numbering", action="store", help = "Append numbering range at the end of each word mutation (before appending year or common paddings).\nThe LEVEL value represents the minimum number of digits. LEVEL must be >= 1. \nSet to 1 will append range: 1,2,3..100\nSet to 2 will append range: 01,02,03..100 + previous\nSet to 3 will append range: 001,002,003..100 + previous.\n\n", type = int, metavar='LEVEL')
|
|
parser.add_argument("-nl", "--numbering-limit", action="store", help = "Change max numbering limit value of option -an. Default is 50. Must be used with -an.", type = int, metavar='LIMIT')
|
|
parser.add_argument("-y", "--years", action="store", help = "Singe OR comma seperated OR range of years to be appended to each word mutation (Example: 2022 OR 1990,2017,2022 OR 1990-2000)")
|
|
parser.add_argument("-ap", "--append-padding", action="store", help = "Add comma seperated values to common paddings (must be used with -cpb OR -cpa)", metavar='VALUES')
|
|
parser.add_argument("-cpb", "--common-paddings-before", action="store_true", help = "Append common paddings before each mutated word")
|
|
parser.add_argument("-cpa", "--common-paddings-after", action="store_true", help = "Append common paddings after each mutated word")
|
|
parser.add_argument("-cpo", "--custom-paddings-only", action="store_true", help = "Use only user provided paddings for word mutations (must be used with -ap AND (-cpb OR -cpa))")
|
|
parser.add_argument("-o", "--output", action="store", help = "Output filename (default: output.txt)", metavar='FILENAME')
|
|
parser.add_argument("-q", "--quiet", action="store_true", help = "Do not print the banner on startup")
|
|
|
|
args = parser.parse_args()
|
|
|
|
def exit_with_msg(msg):
|
|
parser.print_help()
|
|
print(f'\n[{RED}Debug{END}] {msg}\n')
|
|
sys.exit(1)
|
|
|
|
|
|
|
|
def unique(l):
|
|
|
|
unique_list = []
|
|
|
|
for i in l:
|
|
if i not in unique_list:
|
|
unique_list.append(i)
|
|
|
|
return unique_list
|
|
|
|
|
|
# Append numbering
|
|
if args.numbering_limit and not args.append_numbering:
|
|
exit_with_msg('Option -nl must be used with -an.')
|
|
|
|
if args.append_numbering <= 0:
|
|
exit_with_msg('Numbering level must be > 0.')
|
|
|
|
_max = args.numbering_limit + 1 if args.numbering_limit and isinstance(args.numbering_limit, int) else 51
|
|
|
|
|
|
# Create years list
|
|
if args.years:
|
|
|
|
years = []
|
|
|
|
if args.years.count(',') == 0 and args.years.count('-') == 0 and args.years.isdecimal() and int(args.years) >= 1000 and int(args.years) <= 3200:
|
|
years.append(str(args.years))
|
|
|
|
elif args.years.count(',') > 0:
|
|
for year in args.years.split(','):
|
|
if year.strip() != '' and year.isdecimal() and int(year) >= 1000 and int(year) <= 3200:
|
|
years.append(year)
|
|
else:
|
|
exit_with_msg('Illegal year(s) input. Acceptable years range: 1000 - 3200.')
|
|
|
|
elif args.years.count('-') == 1:
|
|
years_range = args.years.split('-')
|
|
start_year = years_range[0]
|
|
end_year = years_range[1]
|
|
|
|
if (start_year.isdecimal() and int(start_year) < int(end_year) and int(start_year) >= 1000) and (end_year.isdecimal() and int(end_year) <= 3200):
|
|
for y in range(int(years_range[0]), int(years_range[1])+1):
|
|
years.append(str(y))
|
|
else:
|
|
exit_with_msg('Illegal year(s) input. Acceptable years range: 1000 - 3200.')
|
|
else:
|
|
exit_with_msg('Illegal year(s) input. Acceptable years range: 1000 - 3200.')
|
|
|
|
|
|
def banner():
|
|
|
|
pad = ' '
|
|
print('\n')
|
|
print(f'{pad}{LOGO}█▀▄{PRPL}░{LOGO}▄▀▀{PRPL}░{LOGO}█{PRPL}▒{LOGO}█{PRPL}░{LOGO}█▀▄{PRPL}░{LOGO}▄▀▄{PRPL2}░{LOGO}█▄█{PRPL}▒{LOGO}▄▀▄{PRPL2}░{LOGO}▄▀▀{PRPL}░{LOGO}█▄█')
|
|
print(f'{pad}{LOGO2}█▀{PRPL2}▒▒{LOGO2}▄██{PRPL}░{LOGO2}█▄█{PRPL2}▒{LOGO2}█▄▀{PRPL}░{LOGO2}▀▄▀{PRPL}▒{LOGO2}█{PRPL2}▒{LOGO2}█{PRPL}░{LOGO2}█▀█{PRPL}▒{LOGO2}▄██{PRPL2}▒{LOGO2}█{PRPL}▒{LOGO2}█{END}')
|
|
print('\t Created by t3l3machus\n')
|
|
|
|
|
|
# ----------------( Base Settings )---------------- #
|
|
mutations_cage = []
|
|
basic_mutations = []
|
|
outfile = args.output if args.output else 'output.txt'
|
|
trans_keys = []
|
|
|
|
transformations = [
|
|
{'a' : '@'},
|
|
{'b' : '8'},
|
|
{'e' : '3'},
|
|
{'g' : ['9', '6']},
|
|
{'i' : ['1', '!']},
|
|
{'o' : '0'},
|
|
{'s' : ['$', '5']},
|
|
{'t' : '7'}
|
|
]
|
|
|
|
for t in transformations:
|
|
for key in t.keys():
|
|
trans_keys.append(key)
|
|
|
|
# Paddings
|
|
if (args.custom_paddings_only or args.append_padding) and not (args.common_paddings_before or args.common_paddings_after):
|
|
exit_with_msg('Options -ap and -cpo must be used with -cpa or -cpb.')
|
|
|
|
|
|
elif (args.common_paddings_before or args.common_paddings_after) and not args.custom_paddings_only:
|
|
|
|
common_paddings = [
|
|
'!', '@', '#', '$', '%', '^', '&', '*', ',', '.', '?', '-' \
|
|
'123', '234', '345', '456', '567', '678', '789', '890',\
|
|
'!@', '@#', '#$', '$%', '%^', '^&', '&*', '*(', '()', \
|
|
'!@#', '@#$', '#$%', '$%^', '%^&', '^&*', '&*(', '*()', ')_+',\
|
|
'1!1', '2@2', '3#3', '4$4', '5%5', '6^6', '7&7', '8*8', '9(9', '0)0',\
|
|
'@2@', '#3#', '$4$', '%5%', '^6^', '&7&', '*8*', '(9(', \
|
|
'!@!', '@#@', '!@#$%', '1234', '12345', '123456', '123!@#', \
|
|
'!!!', '@@@', '###', '$$$', '%%%', '^^^', '&&&', '***', '(((', ')))', '---', '+++'
|
|
]
|
|
|
|
elif (args.common_paddings_before or args.common_paddings_after) and (args.custom_paddings_only and args.append_padding):
|
|
common_paddings = []
|
|
|
|
elif not (args.common_paddings_before or args.common_paddings_after):
|
|
common_paddings = []
|
|
|
|
else:
|
|
exit_with_msg('\nIllegal padding settings.\n')
|
|
|
|
if args.append_padding:
|
|
for val in args.append_padding.split(','):
|
|
if val.strip() != '' and val not in common_paddings:
|
|
common_paddings.append(val)
|
|
|
|
|
|
if (args.common_paddings_before or args.common_paddings_after):
|
|
common_paddings = unique(common_paddings)
|
|
|
|
# ----------------( Functions )---------------- #
|
|
def evalTransformations(w):
|
|
|
|
trans_chars = []
|
|
total = 1
|
|
c = 0
|
|
w = list(w)
|
|
|
|
for char in w:
|
|
for t in transformations:
|
|
if char in t.keys():
|
|
trans_chars.append(c)
|
|
if isinstance(t[char], list):
|
|
total *= 3
|
|
else:
|
|
total *= 2
|
|
c += 1
|
|
|
|
return [trans_chars, total]
|
|
|
|
|
|
|
|
def mutate(tc, word):
|
|
|
|
global trans_keys, mutations_cage, basic_mutations
|
|
|
|
i = trans_keys.index(word[tc].lower())
|
|
trans = transformations[i][word[tc].lower()]
|
|
limit = len(trans) * len(mutations_cage)
|
|
c = 0
|
|
|
|
for m in mutations_cage:
|
|
w = list(m)
|
|
|
|
if isinstance(trans, list):
|
|
for tt in trans:
|
|
w[tc] = tt
|
|
transformed = ''.join(w)
|
|
mutations_cage.append(transformed)
|
|
c += 1
|
|
else:
|
|
w[tc] = trans
|
|
transformed = ''.join(w)
|
|
mutations_cage.append(transformed)
|
|
c += 1
|
|
|
|
if limit == c: break
|
|
|
|
return mutations_cage
|
|
|
|
|
|
|
|
def mutations_handler(kword, trans_chars, total):
|
|
|
|
global mutations_cage, basic_mutations
|
|
|
|
container = []
|
|
|
|
for word in basic_mutations:
|
|
mutations_cage = [word.strip()]
|
|
for tc in trans_chars:
|
|
results = mutate(tc, kword)
|
|
container.append(results)
|
|
|
|
for m_set in container:
|
|
for m in m_set:
|
|
basic_mutations.append(m)
|
|
|
|
basic_mutations = unique(basic_mutations)
|
|
|
|
with open(outfile, 'a') as wordlist:
|
|
for m in basic_mutations:
|
|
wordlist.write(m + '\n')
|
|
|
|
|
|
|
|
def mutateCase(word):
|
|
trans = list(map(''.join, itertools.product(*zip(word.upper(), word.lower()))))
|
|
return trans
|
|
|
|
|
|
|
|
def caseMutationsHandler(word, mutability):
|
|
|
|
global basic_mutations
|
|
case_mutations = mutateCase(word)
|
|
|
|
for m in case_mutations:
|
|
basic_mutations.append(m)
|
|
|
|
if not mutability:
|
|
|
|
basic_mutations = unique(basic_mutations)
|
|
|
|
with open(outfile, 'a') as wordlist:
|
|
for m in basic_mutations:
|
|
wordlist.write(m + '\n')
|
|
|
|
|
|
|
|
def append_numbering():
|
|
|
|
global _max
|
|
first_cycle = True
|
|
previous_list = []
|
|
lvl = args.append_numbering
|
|
|
|
with open(outfile, 'a') as wordlist:
|
|
for word in basic_mutations:
|
|
for i in range(1, lvl+1):
|
|
for k in range(1, _max):
|
|
if first_cycle:
|
|
wordlist.write(f'{word}{str(k).zfill(i)}\n')
|
|
wordlist.write(f'{word}_{str(k).zfill(i)}\n')
|
|
previous_list.append(f'{word}{str(k).zfill(i)}')
|
|
|
|
else:
|
|
if previous_list[k - 1] != f'{word}{str(k).zfill(i)}':
|
|
wordlist.write(f'{word}{str(k).zfill(i)}\n')
|
|
wordlist.write(f'{word}_{str(k).zfill(i)}\n')
|
|
previous_list[k - 1] = f'{word}{str(k).zfill(i)}'
|
|
|
|
first_cycle = False
|
|
del previous_list
|
|
|
|
|
|
|
|
def mutate_years():
|
|
|
|
current_mutations = basic_mutations.copy()
|
|
|
|
with open(outfile, 'a') as wordlist:
|
|
for word in current_mutations:
|
|
for y in years:
|
|
wordlist.write(f'{word}{y}\n')
|
|
wordlist.write(f'{word}_{y}\n')
|
|
wordlist.write(f'{word}{y[2:]}\n')
|
|
basic_mutations.append(f'{word}{y}')
|
|
basic_mutations.append(f'{word}_{y}')
|
|
basic_mutations.append(f'{word}{y[2:]}')
|
|
|
|
del current_mutations
|
|
|
|
|
|
|
|
def check_underscore(word, pos):
|
|
if word[pos] == '_':
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
|
|
def append_paddings_before():
|
|
|
|
current_mutations = basic_mutations.copy()
|
|
|
|
with open(outfile, 'a') as wordlist:
|
|
for word in current_mutations:
|
|
for val in common_paddings:
|
|
wordlist.write(f'{val}{word}\n')
|
|
if not check_underscore(val, -1):
|
|
wordlist.write(f'{val}_{word}\n')
|
|
|
|
|
|
del current_mutations
|
|
|
|
|
|
|
|
def append_paddings_after():
|
|
|
|
current_mutations = basic_mutations.copy()
|
|
|
|
with open(outfile, 'a') as wordlist:
|
|
for word in current_mutations:
|
|
for val in common_paddings:
|
|
wordlist.write(f'{word}{val}\n')
|
|
if not check_underscore(val, 0):
|
|
wordlist.write(f'{word}_{val}\n')
|
|
|
|
del current_mutations
|
|
|
|
|
|
|
|
def calculate_output(keyw):
|
|
|
|
global trans_keys
|
|
|
|
c = 0
|
|
total = 1
|
|
basic_total = 1
|
|
basic_size = 0
|
|
size = 0
|
|
numbering_count = 0
|
|
numbering_size = 0
|
|
|
|
# Basic mutations calc
|
|
for char in keyw:
|
|
if char in trans_keys:
|
|
i = trans_keys.index(keyw[c].lower())
|
|
trans = transformations[i][keyw[c].lower()]
|
|
basic_total *= (len(trans) + 2)
|
|
else:
|
|
basic_total = basic_total * 2 if char.isalpha() else basic_total
|
|
|
|
c += 1
|
|
|
|
total = basic_total
|
|
basic_size = total * (len(keyw) + 1)
|
|
size = basic_size
|
|
|
|
# Words numbering mutations calc
|
|
if args.append_numbering:
|
|
global _max
|
|
word_len = len(keyw) + 1
|
|
first_cycle = True
|
|
previous_list = []
|
|
lvl = args.append_numbering
|
|
|
|
for w in range(0, total):
|
|
for i in range(1, lvl+1):
|
|
for k in range(1, _max):
|
|
n = str(k).zfill(i)
|
|
if first_cycle:
|
|
numbering_count += 2
|
|
numbering_size += (word_len * 2) + (len(n) * 2) + 1
|
|
previous_list.append(f'{w}{n}')
|
|
|
|
else:
|
|
if previous_list[k - 1] != f'{w}{n}':
|
|
numbering_size += (word_len * 2) + (len(n) * 2) + 1
|
|
numbering_count += 2
|
|
previous_list[k - 1] = f'{w}{n}'
|
|
|
|
first_cycle = False
|
|
|
|
del previous_list
|
|
|
|
# Adding years mutations calc
|
|
if args.years:
|
|
patterns = 3
|
|
year_chars = 4
|
|
_year = 5
|
|
year_short = 2
|
|
yrs = len(years)
|
|
size += (basic_size * patterns * yrs) + (basic_total * year_chars * yrs) + (basic_total * _year * yrs) + (basic_total * year_short * yrs)
|
|
total += total * len(years) * 3
|
|
basic_total = total
|
|
basic_size = size
|
|
|
|
# Common paddings mutations calc
|
|
patterns = 2
|
|
|
|
if args.common_paddings_after or args.common_paddings_before:
|
|
paddings_len = len(common_paddings)
|
|
pads_wlen_sum = sum([basic_total*len(w) for w in common_paddings])
|
|
_pads_wlen_sum = sum([basic_total*(len(w)+1) for w in common_paddings])
|
|
|
|
if args.common_paddings_after and args.common_paddings_before:
|
|
size += ((basic_size * patterns * paddings_len) + pads_wlen_sum + _pads_wlen_sum) * 2
|
|
total += (total * len(common_paddings) * 2) * 2
|
|
|
|
elif args.common_paddings_after or args.common_paddings_before:
|
|
size += (basic_size * patterns * paddings_len) + pads_wlen_sum + _pads_wlen_sum
|
|
total += total * len(common_paddings) * 2
|
|
|
|
return [total + numbering_count, size + numbering_size]
|
|
|
|
|
|
|
|
def check_mutability(word):
|
|
|
|
global trans_keys
|
|
m = 0
|
|
|
|
for char in word:
|
|
if char in trans_keys:
|
|
m += 1
|
|
|
|
return m
|
|
|
|
|
|
|
|
def chill():
|
|
pass
|
|
|
|
|
|
|
|
def main():
|
|
|
|
banner() if not args.quiet else chill()
|
|
|
|
global basic_mutations, mutations_cage
|
|
keywords = []
|
|
|
|
for w in args.words.split(','):
|
|
if w.strip().isdecimal():
|
|
exit_with_msg('Unable to mutate digit-only keywords.')
|
|
|
|
elif w.strip() not in [None, '']:
|
|
keywords.append(w.strip())
|
|
|
|
# Calculate total words and size of output
|
|
total_size = [0, 0]
|
|
|
|
for keyw in keywords:
|
|
count_size = calculate_output(keyw.strip().lower())
|
|
total_size[0] += count_size[0]
|
|
total_size[1] += count_size[1]
|
|
|
|
size = round(((total_size[1]/1000)/1000), 1) if total_size[1] > 100000 else total_size[1]
|
|
prefix = 'bytes' if total_size[1] <= 100000 else 'MB'
|
|
fsize = f'{size} {prefix}'
|
|
|
|
print(f'[{MAIN}Info{END}] Calculating total words and size...')
|
|
concent = input(f'[{ORANGE}Warning{END}] This operation will produce {BOLD}{total_size[0]}{END} words, {BOLD}{fsize}{END}. Are you sure you want to proceed? [y/n]: ')
|
|
|
|
if concent.lower() not in ['y', 'yes']:
|
|
sys.exit(f'\n[{RED}X{END}] Aborting.')
|
|
|
|
else:
|
|
|
|
open(outfile, "w").close()
|
|
|
|
for word in keywords:
|
|
print(f'[{GREEN}*{END}] Mutating keyword: {GREEN}{word}{END} ')
|
|
mutability = check_mutability(word.lower())
|
|
|
|
# Produce case mutations
|
|
print(f' ├─ Producing character case-based transformations... ')
|
|
caseMutationsHandler(word.lower(), mutability)
|
|
|
|
if mutability:
|
|
# Produce char substitution mutations
|
|
print(f' ├─ Mutating word based on commonly used char-to-symbol and char-to-number substitutions... ')
|
|
trans = evalTransformations(word.lower())
|
|
mutations_handler(word, trans[0], trans[1])
|
|
|
|
else:
|
|
print(f' ├─ {ORANGE}No character substitution instructions match this word.{END}')
|
|
|
|
# Append numbering
|
|
if args.append_numbering:
|
|
print(f' ├─ Appending numbering to each word mutation... ')
|
|
append_numbering()
|
|
|
|
# Handle years
|
|
if args.years:
|
|
print(f' ├─ Appending year patterns after each word mutation... ')
|
|
mutate_years()
|
|
|
|
# Append common paddings
|
|
if args.common_paddings_after or args.custom_paddings_only:
|
|
print(f' ├─ Appending common paddings after each word mutation... ')
|
|
append_paddings_after()
|
|
|
|
if args.common_paddings_before:
|
|
print(f' ├─ Appending common paddings before each word mutation... ')
|
|
append_paddings_before()
|
|
|
|
basic_mutations = []
|
|
mutations_cage = []
|
|
print(f' └─ Done!')
|
|
|
|
print(f'\n[{MAIN}Info{END}] Completed! List saved in {outfile}\n')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|