def __init__(self, graph, n_words=None):
self.graph = graph
self.n_words = n_words = n_words or len(graph.wordlist) - 1
assert self.graph.wordlist[0] == ''
self.idx_to_graph = sorted(range(1, n_words + 1),
key=self.graph.wordlist.__getitem__)
graph_to_idx = [
self.idx_to_graph.index(n) for n in range(1, n_words + 1)
]
graph_to_idx = [None] + sorted(range(n_words),
key=self.idx_to_graph.__getitem__)
assert 0 not in self.idx_to_graph
assert 0 in graph_to_idx
for n in range(n_words):
assert n == graph_to_idx[self.idx_to_graph[n]], n
# print(self.idx_to_graph, [self.graph.wordlist[x] for x in self.idx_to_graph])
self.adjacency_lists = [0] * n_words
for n in range(1, n_words + 1):
self.adjacency_lists[graph_to_idx[n]] = sorted([
graph_to_idx[x] for x in digest.decode(self.graph.followers[n])
if x <= n_words
])
self.path_counts = []
self.total_paths = 0
def init_decrypt(self):
self.get_save_path()
self.write_error()
ciph_file = self.open_file(self.file_box.get(), "r")
if ciph_file:
try:
contents = [i.strip() for i in ciph_file.split(",")]
ck = (int(contents[0]), (int(contents[1]), int(contents[2])))
# temp0 = 0
# temp1 = []
# for i in ciph_file:
# temp0 += 1
# if i == ",":
# temp1.append(temp0)
# c = int(ciph_file[0:temp1[0] - 1])
# d = int(ciph_file[temp1[0]:temp1[1] - 1])
# n = int(ciph_file[temp1[1]:len(ciph_file)])
# ck = (c, (d, n))
encoded_text = decrypt(ck)
plain_text = decode(encoded_text)
decrypted_save_path = self.save_file_path + self.file_name + "_decrypted.txt"
self.write_output(plain_text)
self.open_file(decrypted_save_path, "w", plain_text)
self.write_error(
f"Successfully decrypted to {decrypted_save_path}.")
except IndexError:
self.write_error("Error: Invalid encrypted file")
except ValueError:
self.write_error("Error: Invalid encrypted file")
def decrypt():
"""Create decrypted file."""
try:
with open("encrypted.txt", "r") as encrypted_file:
cipher = encrypted_file.read()
encrypted_file.close()
except FileNotFoundError:
print("Error: 'encrypted.txt' not found.")
return main()
try:
with open("key.txt", "r") as key_file:
priv_key = key_file.read()
key_file.close()
except FileNotFoundError:
print("Error: 'key.txt' not found.")
return main()
temp_key = ""
key = []
for i in priv_key:
if i != ",":
temp_key += i
else:
key.append(temp_key)
temp_key = ""
decrypted = crypto.decrypt(int(cipher), int(key[0]), int(key[1]))
print(decrypted)
plaintext = digest.decode(decrypted)
print(plaintext)
with open("decrypted.txt", "w") as output_file:
output_file.write(str(plaintext))
output_file.close()
print("Decryption of 'encrypted.txt' completed successfully.\n\
Please check 'decrypted.txt'.")
def __init__(self, graph, n_words):
self.graph = graph
self.n_words = n_words
self.adjacency_lists = []
for n in xrange(n_words):
self.adjacency_lists.append([x for x in digest.decode(self.graph.followers[n])
if x < n_words])
def __init__(self, graph, n_words):
self.graph = graph
self.n_words = n_words
self.adjacency_lists = []
for n in xrange(n_words):
self.adjacency_lists.append(
[x for x in digest.decode(self.graph.followers[n])
if x < n_words])
def get_followers(self, node_number):
return set(digest.decode(self.followers[node_number]))
def wordgraph_dump(a, b):
for n in range(a, b):
print('#%d: %s: %.30s %s' % (n, graph.wordlist[n], graph.followers[n],
digest.decode(graph.followers[n])))
def get_followers(self, node_number):
return set(digest.decode(self.followers[node_number]))
def wordgraph_dump(a, b):
for n in xrange(a, b):
print '#%d: %s: %.30s %s' % (n, graph.wordlist[n], graph.followers[n],
digest.decode(graph.followers[n]))
