130 lines
3.9 KiB
Python
130 lines
3.9 KiB
Python
import pprint
|
|
import math
|
|
|
|
secret="OUHRSTHFSOENOFETURFELIRFTSNEMOEEMELNTARETOKCAETBFIHFTTTNMEELEEOHYBAERORCRSEDNCEUUTHITOYRSTEDSBEIEOTNLRMOEFPOHHAYLAGXYISNIARAUABGBURILFERPEEHTECDINNDITHFFIEHTKESYTDHEREOALGNABSMWEHVEFSOAMETAOCRFTAHEOFSINAMEOTRNGRINTHFFIEHTIEGMELNTSTEOMCOHEOWTEWREAIDANHTRARARTEHEETVFIYREAHVSAONDPROSTRAEUOYCTTTHWISANMUHETENTIISEDHETSUSENTEITNG OOLEEB L"
|
|
col_key="EJALMVWUSTRPOBY" # (16)missing 1 char
|
|
row_key="GHPTYPAMTAPQRNDHD" # (21) missing 4 chars one of which is 'D'
|
|
col_alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
row_alpha="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
|
|
|
|
|
|
#As we know from the cold wars in the galaxy with the KLI, the Mondoshiva used the double transposition cipher with first/inner column and second/outer row transformation for encryption to secure the most powerful information. Furthermore, they usually used the longer keys for the rows
|
|
|
|
|
|
def cell_length(text_length,key_length):
|
|
return math.ceil(text_length/key_length)
|
|
|
|
def padded_length(text_length,key_length):
|
|
return cell_length(text_length,key_length)*key_length
|
|
|
|
def revert_key(key):
|
|
return [x[0] for x in sorted(enumerate(key), key=lambda x: x[1])]
|
|
|
|
def mosh(text,key):
|
|
tmp=sorted(zip(text,key), key=lambda x: x[1])
|
|
return [x[0] for x in tmp]
|
|
|
|
|
|
def cols(text,key_length):
|
|
# col_length=cell_length(len(text),key_length)
|
|
columns=[ "" for i in range(0,key_length) ]
|
|
cursor=0
|
|
for c in text:
|
|
columns[cursor%key_length]+=c
|
|
cursor += 1
|
|
return columns
|
|
|
|
def rows(text,key_length):
|
|
# row_length=math.ceil(len(text)/key_length)
|
|
rows=[text[i:i+key_length] for i in range(0,len(text),key_length)]
|
|
return rows
|
|
|
|
def cols_to_str(a):
|
|
max_length=max([len(i) for i in a] )
|
|
result=""
|
|
for i in range(0,max_length):
|
|
for x in a:
|
|
try:
|
|
result+=x[i]
|
|
except:
|
|
pass
|
|
return result
|
|
|
|
def rows_to_str(a):
|
|
return "".join(a)
|
|
|
|
def pcols(a):
|
|
print("COLUMS:")
|
|
text=cols_to_str(a)
|
|
split_text=rows(text,len(a))
|
|
for x in split_text:
|
|
print(x)
|
|
|
|
def prows(a,header=None):
|
|
print("ROWS:")
|
|
counter=0
|
|
for x in a:
|
|
if header:
|
|
heading="{}".format(header[counter]).ljust(5)
|
|
else:
|
|
heading="{}".format(counter).ljust(5)
|
|
counter+=1
|
|
print("%s : %s"%(heading,x))
|
|
|
|
|
|
def encode(text,key):
|
|
text=text.ljust(math.ceil(len(text)/len(key))*len(key),'_')
|
|
# print("encoding <%s>"%text)
|
|
columnized_text=cols(text,len(key))
|
|
# pcols(columnized_text)
|
|
shuffled_colums=mosh(columnized_text,key)
|
|
# pcols(shuffled_colums)
|
|
return rows_to_str(shuffled_colums)
|
|
|
|
def decode(text,key):
|
|
# print("decoding <%s>"%text)
|
|
row_data=rows(text,cell_length(len(text), len(key)))
|
|
# prows(row_data)
|
|
reorderd=mosh(row_data,revert_key(key))
|
|
# prows(reorderd)
|
|
return cols_to_str(reorderd)
|
|
|
|
|
|
def decross(text,key_rows,key_cols):
|
|
#revert row transformation
|
|
matrix_cells=len(key_rows)*len(key_cols)
|
|
if len(text) != matrix_cells:
|
|
print("!!TEXT HAD TO BE PADDED!!")
|
|
text=text.ljust(matrix_cells,'_')
|
|
#generate rows with a length of the column-key
|
|
matrix=rows(text,len(key_cols))
|
|
prows(matrix,key_rows)
|
|
|
|
def get_col_keys():
|
|
for x in col_alpha:
|
|
yield col_key+x
|
|
|
|
def get_row_keys():
|
|
for x in row_alpha:
|
|
for y in row_alpha:
|
|
for z in row_alpha:
|
|
for d in row_alpha:
|
|
yield(row_key+d+x+y+z)
|
|
|
|
# yield(row_key+"D"+x+y+z)
|
|
# yield(row_key+x+"D"+y+z)
|
|
# yield(row_key+x+y+"D"+z)
|
|
# yield(row_key+x+y+z+"D")
|
|
|
|
|
|
def decryptor():
|
|
for col_key in get_col_keys():
|
|
for row_key in get_row_keys():
|
|
text=encode(encode(secret,col_key),row_key)
|
|
yield "{};{};{}".format(row_key,col_key,text)
|
|
|
|
with open("output3.txt",'w') as f:
|
|
for possiblematch in decryptor():
|
|
f.write(possiblematch+'\n')
|