def main(file, substitution=None, save=None, output=None):
try:
if file is None:
raise FileNotFoundError('Select file for encrypt.')
except FileNotFoundError as e:
print(e)
return e
if substitution:
subst = read_json_file(substitution, 'utf-8')
else:
subst = generate_substitution('A-Za-z')
if not file:
result = code_stdin(subst)
else:
result = code_text_from_file(file, 'utf-8', subst)
if save:
write_json_in_file('substitution.txt', subst, 'utf-8')
if output:
with open(output, 'w', encoding='utf-8') as file:
file.write(result)
else:
sys.stdout.write(result)
def main(stat, filename, iterations, top, debug):
global workdone
if stat is None:
raise FileNotFoundError('Select file with statistics.')
if filename is None:
raise FileNotFoundError('Select file with ecrypted text.')
if iterations is None:
raise Exception('Iterations')
print(
'Stat file: {}\nEncrypted file: {}\nIterations: {}\nPopular words: {}\n'
.format(stat, filename, iterations, top))
with open(filename, 'rb') as file:
original_text = file.read().decode('utf-8')
coded_text = encryptor.code(original_text,
encryptor.generate_substitution('A-Za-z'))
result = {}
for n in range(1, iterations + 1):
sample = coded_text[:n * 50]
original_sample = original_text[:n * 50]
data = Decryptor('A-Za-z',
stat,
'utf-8',
text_input=sample,
top=top,
benchmark=True)
data.decrypt()
decoded_sample = data.decode_text(sample)
diff = count_diff(decoded_sample, original_sample)
res = ((len(sample) - diff) * 100) / len(sample)
result[n * 50] = res
if debug:
print(
"\rTotal text's length: {}, Piece's length: {}, Iteration: {}, Recognized: {}%;\n"
.format(str(len(coded_text)), str(n * 25), str(n),
str(round(res, 2))),
end="",
flush=True)
if len(coded_text) < n * 50:
break
workdone = n / (iterations)
print("\rProgress: [{0:50s}] {1:.1f}%".format('#' * int(workdone * 50),
workdone * 100),
end="",
flush=True)
if workdone == 1:
workdone = 0
print(decoded_sample)
plt.figure()
plt.plot(list(result.keys()), list(result.values()))
plt.xlabel("Text's length")
plt.ylabel("Success rate, %")
plt.title("Benchmark")
plt.grid(True)
plt.savefig("benchmark.png")
coords = list(result.keys()), list(result.values())
return coords
def test_decode_from_file(self):
subst = e.generate_substitution(self.alph_en)
code = e.code_text_from_file(make_big_en_file(), 'utf-8', subst)
rev_subst = e.reverse_substitution(subst)
with make_big_en_file() as f:
f.seek(0)
original = f.read().decode(ENCODING)
decode = e.code(code, rev_subst)
self.assertEqual(original, decode)
def test_decode_from_file(self):
subst = e.generate_substitution(self.alph_en)
with open('Harry.txt', 'rb') as f:
self.file = f.read().decode('utf-8')
code = e.code_text_from_file('Harry.txt', 'utf-8', subst)
rev_subst = e.reverse_substitution(subst)
decode = e.code(code, rev_subst)
print(decode)
self.assertEqual(self.file, decode)
def code_decode(text, language):
"""
Code and then decode text in a given language, using reversed substitution
:param text:
:param language:
:return:
"""
subst = e.generate_substitution(language)
code = e.code(text, subst)
rev_subst = e.reverse_substitution(subst)
return e.code(code, rev_subst)
def replace_unrecognized_letters(substitution, alphabet):
"""
Замена нерасшифрованных букв.
"""
key = generate_substitution(alphabet)
for coded_letter in substitution.keys():
if len(substitution[coded_letter]) == 1:
key[coded_letter] = list(substitution[coded_letter])[0]
else:
key[coded_letter] = '_'
unrecognized = [letter for letter in key.keys() if key[letter] == "_"]
unused = [letter for letter in key.keys() if letter not in key.values()]
if len(unrecognized) == 1:
key[unrecognized[0]] = unused[0]
return key
def find_final_substitution(substitution, alphabet):
"""
Replace unsolved letters with underscore
:param substitution:
:param alphabet:
:return:
"""
key = generate_substitution(alphabet)
for coded_letter in substitution.keys():
if len(substitution[coded_letter]) == 1:
key[coded_letter] = list(substitution[coded_letter])[0]
else:
key[coded_letter] = '_'
free_keys = [letter for letter in key.keys() if key[letter] == "_"]
unused_letters = [
letter for letter in key.keys() if letter not in key.values()
]
if len(free_keys) == 1:
key[free_keys[0]] = unused_letters[0]
return key
def test_reverse(self):
subst = e.generate_substitution(self.alph_en)
rev_subst = e.reverse_substitution(subst)
double_rev = e.reverse_substitution(rev_subst)
self.assertDictEqual(subst, double_rev)
def main():
parser = argparse.ArgumentParser(
usage='{} [OPTIONS] ALPHABET STAT FILE'.format(
os.path.basename(sys.argv[0])),
description='count the percentage of correctly guessed letters')
parser.add_argument(
'alph',
metavar='alphabet',
help='language, in which text is written (for example: A-Za-z)')
parser.add_argument(
'stat',
metavar='stat',
help='statistics of the language')
parser.add_argument(
'fn',
metavar='FILE',
nargs='?',
type=argparse.FileType('r'),
default=sys.stdin,
help='name of the file with text')
parser.add_argument(
'-o',
'--output',
type=str,
dest='output',
metavar="FILENAME",
help='choose, where to store output')
parser.add_argument(
'-d',
'--debug',
action='store_true',
dest='debug',
help='enable debug output')
parser.add_argument(
'-n',
'--num',
type=int,
dest='num',
default=51,
help='choose a quantity of iterations')
parser.add_argument(
'-e',
'--encoding',
type=str,
dest='encoding',
default='utf-8',
help='choose FILE (and output file, if key -o is chosen) encoding')
parser.add_argument('-t', '--top', type=int, dest='top', default=15000,
help='choose, how many popular words will be stored')
args = parser.parse_args()
with open(args.fn.name) as file:
original_text = file.read()
coded_text = e.code(original_text,
e.generate_substitution(args.alph))
result = {}
for n in range(1, args.num):
sample = coded_text[:n * 25]
original_sample = original_text[:n * 25]
hacker = SubstitutionHacker(
args.alph,
args.stat,
args.encoding,
code_text=sample,
top=args.top)
hacker.hack()
decoded_sample = hacker.decode_text(sample)
diff = count_diff(decoded_sample, original_sample)
res = ((len(sample) - diff) * 100) / len(sample)
result[n * 25] = res
if args.debug:
print("Text\'s length {0}; Sample\'s length; {1} n is {2}; "
"Correctly guessed {3}%;"
.format(str(len(coded_text)), str(n * 25), str(n),
str(round(res, 2))))
if len(coded_text) < n * 25:
break
if args.output:
write_json_in_file(args.output, result, args.encoding)
else:
pprint(result)
print("Last variant:\n", decoded_sample)
plt.figure()
plt.xlabel("Text's length")
plt.ylabel("Success rate, %")
plt.scatter(list(result.keys()), list(result.values()))
plt.grid(True)
plt.savefig("dependency_chart.png")
plt.show()
def main():
parser = argparse.ArgumentParser(
usage='{} [OPTIONS] ALPHABET FILE'.format(os.path.basename(
sys.argv[0])),
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description='Encode text using substitution cipher')
subst_group = parser.add_mutually_exclusive_group()
subst_group.add_argument('-s',
'--substitution',
type=str,
dest='substitution',
metavar="FILENAME",
help='file with the substitution in json format')
subst_group.add_argument(
'-r',
'--reverse',
type=str,
dest='reverse',
metavar="FILENAME",
help='reverse substitution from file, and use it to encode text')
subst_group.add_argument(
'-g',
'--generate',
type=str,
dest='generate',
metavar="FILENAME",
default="subst.txt",
help='generate substitution and choose where to store it')
parser.add_argument(
'alph',
metavar='alphabet',
help='language, in which text is written (for example: A-Za-z)')
parser.add_argument('fn',
metavar='FILE',
nargs='?',
default=None,
help='name of the file with text')
parser.add_argument('-o',
'--output',
type=str,
dest='output',
metavar="FILENAME",
help='choose, where to store output')
parser.add_argument(
'-e',
'--encoding',
type=str,
dest='encoding',
default='utf-8',
help='choose FILE (and output file, if key -o is chosen) encoding')
args = parser.parse_args()
if not args.alph:
sys.exit("Error: alphabet must be specified")
if args.substitution:
subst = read_json_file(args.substitution, args.encoding)
elif args.reverse:
subst = reverse_substitution(
read_json_file(args.reverse, args.encoding))
elif args.generate:
subst = generate_substitution(args.alph)
else:
subst = generate_substitution(args.alph)
if not args.fn:
result = code_stdin(subst)
else:
result = code_text_from_file(args.fn, args.encoding, subst)
# print("Saving substitution to '{}{}'...".format(os.path.sep, SUBST_FILE))
if args.generate:
write_json_in_file(args.generate, subst, args.encoding)
# print("DONE")
if args.output:
with open(args.output, 'w', encoding=args.encoding) as file:
file.write(result)
else:
sys.stdout.write(result)
