def hill_2x2(text):
matrix_list = text2matrix_2x2(group_text(text, 2))
possible_keys = generate_keys_2x2()
results = []
for keys in possible_keys:
result = []
l = []
for matrices in matrix_list:
result = matrix_multiplication_2x2_2x1_undermod26(
keys[0], matrices)
string = matrix2text_2x1(result)
l.append(string)
char = ''.join(l)
results.append([keys[1], char])
top_score = []
for each in results:
score = get_english_score(each[1])
top_score.append(score)
howmany = 5
for i in range(1, howmany + 1):
highscore = sorted(top_score)[-i]
index = top_score.index(highscore)
if isinstance(index, int):
print([top_score[index], results[index][0], results[index][1]])
def decrypt_all_trasposition(text, max_columns=7, min_colums=2, easy=False):
outputfile = open('output.txt', 'w')
plaintext = extract_alphabets(text)
factors = get_factors(len(plaintext))
factors_to_check = []
for f in factors:
if max_columns >= f >= min_colums:
factors_to_check.append(f)
else:
pass
results = []
for f in factors_to_check:
start = time.time()
if easy:
table = text_split_in_order(plaintext, f)
else:
table = groupcharactors(plaintext, f)
for combination in generate_permutation(f):
result = []
arranged_table = swape_colume(table, combination)
answer = return_to_text(arranged_table)
scores = get_all_english_score_in_text(answer)
score = get_english_score(answer)
result.append(score)
result.append(combination)
outputfile.write(str(scores) + ", ")
for c in combination:
outputfile.write(str(c) + ", ")
outputfile.write("\n")
results.append(result)
print('Done: ' + str(f))
print(time.time() - start)
return results
def check_map_with_keyword(text, keyword, index_e=-1, reverse=False):
map = get_map_with_keyword(keyword)
if index_e != -1:
if map[4][1] != alphabets[index_e]:
return False
original = decrypt_mapping(text, map)
if reverse:
score1 = get_english_score(original)
reversedtext = reverse_text(original)
score2 = get_english_score(reversedtext)
if score1 >= score2:
result = [score1, keyword, original]
else:
result = [score2, keyword, reversedtext]
else:
result = [get_english_score(original), keyword, original]
return result
def check_all_with_keyword(text, keyword, index_e=-1, reverse=False):
maps = get_maps_with_keyword(keyword)
results = []
for map in maps:
if index_e != -1:
if map[4][1] == alphabets[index_e]:
original = decrypt_mapping(text, map)
if reverse:
original = reverse_text(original)
score = get_english_score(original)
# if score > 100:
results.append([score, keyword, original])
else:
original = decrypt_mapping(text, map)
if reverse:
original = reverse_text(original)
score = get_english_score(original)
# if score > 100:
results.append([score, keyword, original])
return results
def decipher_vigenere_all_possible_combination_of_a(text,
k,
a_for_each,
affine=False,
reverse=False):
list_texts = textksplit(extract_alphabets(text), k)
all_combinations_of_a = gen_permination(a_for_each)
answers = []
print(len(all_combinations_of_a))
for a_s in all_combinations_of_a:
deciphered_texts = []
first = True
for i in range(len(list_texts)):
list_text_string = ''.join(list_texts[i])
if affine:
if first:
add = [a_s[len(a_s) - 2], a_s[len(a_s) - 1]]
a_s = a_s[0:len(a_s) - 2]
a_s.append(add)
first = False
answer = decrypt_mapping(
list_text_string,
get_map_of_ax_plus_b(int(a_s[i][0]), int(a_s[i][1])))
else:
answer = decrypt_mapping(list_text_string,
get_map_of_x_plus_a(a_s[i]))
deciphered_texts.append(answer)
length = 0
for deciphered_text in deciphered_texts:
length += len(deciphered_text)
answer = ''
for i in range(length):
answer += deciphered_texts[(i % k)][int((i - (i % k)) / k)]
if not reverse:
answers.append([get_english_score(answer), a_s, answer])
elif reverse:
reversed_text = reverse_text(answer)
answers.append(
[get_english_score(reversed_text), a_s, reversed_text])
return answers
def decipher_vigenere_with_a(text, a_s):
k = len(a_s)
list_texts = textksplit(extract_alphabets(text), k)
deciphered_texts = []
for i in range(len(list_texts)):
list_text_string = ''.join(list_texts[i])
answer = decrypt_mapping(list_text_string, get_map_of_x_plus_a(a_s[i]))
deciphered_texts.append(answer)
length = 0
for deciphered_text in deciphered_texts:
length += len(deciphered_text)
answer = ''
for i in range(length):
answer += deciphered_texts[(i % k)][int((i - (i % k)) / k)]
answer = [get_english_score(answer), a_s, answer]
return answer
def decipher_by_english_check(text):
# x+a
# for a in range(26):
# # print(a, end=' ')
# result = []
# text_decrypted = decrypt_mapping(text, get_map_of_x_plus_a(a))
# # print(get_all_english_score_in_text(text_decrypted))
# score = get_english_score(text_decrypted)
results = []
# ax+b
a_possible = [1, 3, 5, 7, 9, 11, 15, 17, 19, 21, 23, 25]
for a in a_possible:
for b in range(26):
result = []
text_decrypted = decrypt_mapping(text, get_map_of_ax_plus_b(a, b))
score = get_english_score(text_decrypted)
result.append(score)
result.append([a, b])
results.append(result)
# Show results
numbertop = 5
topnumbers = []
for i in range(numbertop):
biggest = []
for result in results:
try:
if result[0] > biggest[0]:
biggest = result
except IndexError:
biggest = result
topnumbers.append(biggest)
results.remove(biggest)
print(topnumbers)
for result in topnumbers:
print(round(result[0], 2), end=', ')
print("a=", end='')
print(result[1][0], end=', ')
print("b=", end='')
print(result[1][1], end=', ')
print(decrypt_mapping(text, get_map_of_ax_plus_b(result[1][0], result[1][1])))
def hill_climbing(text, config_dict):
T = config_dict['T0']
T_lowest = config_dict['T_lowest']
NumberOfIterationPerT = config_dict['NumberOfIterationPerT']
FunctionT = config_dict['FunctionT']
CipherType = config_dict['CipherType']
KeywordorGrid = config_dict['Keyword/Grid']
LengthOfKey_lower = config_dict['LengthOfKey_lower']
LengthOfKey_upper = config_dict['LengthOfKey_upper']
Probability_threshold = config_dict['Probability_threshold']
Starting_Keyword = config_dict['Starting_Keyword']
count = 1
e = 2.71828182846
PlainText = re.sub(r'\W', '', text)
if KeywordorGrid == 'grid':
parent_keyword = generate_random_5x5grid(deleted_letter='J')
else:
parent_keyword = generate_random_keyword(LengthOfKey_lower,
LengthOfKey_upper,
alphabets())
if not Starting_Keyword == '':
parent_keyword = Starting_Keyword
parent_score = get_english_score(CipherType(PlainText, parent_keyword))
#print(parent_score)
highest_score = parent_score
all_keys = []
while T > T_lowest:
print(count)
countOfinter = 0
while countOfinter <= NumberOfIterationPerT:
meth = random_minor_change(KeywordorGrid)
child_keyword = meth(parent_keyword)
#print(child_keyword)
if child_keyword not in all_keys:
all_keys.append(table2str(child_keyword))
resultText = CipherType(PlainText, child_keyword)
child_score = get_english_score(resultText)
dF = child_score - parent_score
#print(child_score)
if dF >= 0:
displayscore = parent_score
parent_keyword = child_keyword
parent_score = child_score
if child_score > highest_score:
highest_score = child_score
print('#Iteration: ' + str(count) + ' Keyword: ' +
table2str(parent_keyword) + ' Score: ' +
str(child_score) + ' Highest score: ' +
str(highest_score) + ' Parent score: ' +
str(displayscore))
else:
prob = e**(dF / T)
if prob > Probability_threshold:
parent_keyword = child_keyword
parent_score = child_score
print('#Iteration: ' + str(count) + ' Keyword: ' +
table2str(parent_keyword) + ' Score: ' +
str(parent_score) + ' Highest score: ' +
str(highest_score) + ' Probability: ' +
str(prob))
# else:
# print('#Iteration: ' + str(count) + ' Unsuccessful' + ' Probability: ' + str(prob) + ' ' + str(T) + ' ' + str(dF))
countOfinter += 1
count += 1
T = FunctionT(T, count)