def encrypt(self):
if self.inputfile == "":
tk.messagebox.showwarning("Error", "No input file")
return
try:
password = tk.simpledialog.askstring("Password",
"Enter password",
show='*')
password = hashlib.sha512(
password.encode(encoding='UTF-8')).hexdigest()[0:30]
confirm_password = tk.simpledialog.askstring("Confirm password",
"Confirm password",
show='*')
confirm_password = hashlib.sha512(
confirm_password.encode(encoding='UTF-8')).hexdigest()[0:30]
while password != confirm_password:
password = tk.simpledialog.askstring("Passwords do not match",
"Re-enter password",
show='*')
password = hashlib.sha512(
password.encode(encoding='UTF-8')).hexdigest()[0:30]
confirm_password = tk.simpledialog.askstring(
"Confirm password", "Confirm password", show='*')
confirm_password = hashlib.sha512(
confirm_password.encode(
encoding='UTF-8')).hexdigest()[0:30]
encryptor.encrypt(
self.inputfile,
RSA.generate_key_from_pwd(password).generate_public_key(),
self.outputfile.get())
except IOError:
tk.messagebox.showerror("Error", "Cannot open file")
def test(self):
for testfile in os.listdir("./"):
print("Running test on: {filename}".format(filename=testfile),
file=sys.stderr)
encryptor.encrypt(testfile, encryptor.public_key_message,
"_encrypted")
decryptor.decrypt("_encrypted", decryptor.private_key_message,
"_decrypted")
self.assertTrue(
filecmp.cmp(testfile, "_decrypted"),
"Decrypted file is different from original: {filename}".format(
filename=testfile))
def get_db_prep_value(self, value, connection=None, prepared=False):
if isinstance(value, bytes):
value = value.decode('utf-8')
value = super().get_db_prep_value(value=value,
connection=connection,
prepared=prepared)
return encryptor.encrypt(value)
def test1(correct_output, offset=0):
fd, temp_path = tempfile.mkstemp()
os.remove(temp_path)
fh = os.fdopen(fd, 'w+')
uuid = 0
server = "server"
encrypt(correct_output, 0, fh, uuid, server)
fh.seek(0, os.SEEK_END)
enc_len = fh.tell()
fh.seek(0, os.SEEK_SET)
dec = decrypt(fh.read(enc_len), 0, True, uuid, server)
if (dec != correct_output):
sys.exit(1)
def test_encrypt_decrypt(self):
data = "encrypted decrypted \n data1"
key = b'1234567890123456'
encrypted = encryptor.encrypt(key,data)
decrypted = encryptor.decrypt(key,encrypted)
self.assertEqual(decrypted,data)
def test_encryption_standard(self):
data = "message 1"
key = b'1234567890123456'
encrypted_code = b'uWuoiYApeiS0i2cQ4tU7gQ=='
encrypted = encryptor.encrypt(key, data)
self.assertEqual(encrypted,encrypted_code)
def crack(input, output):
f = open(input, "r")
data = f.read()
f.close()
temp = filter(lambda x: x.isalpha(), data)
freq = {}
for i in "abcdefghijklmnopqrstuvwxyz":
freq[i] = 0
for c in temp:
freq[c] += 1
freq = sorted(freq.iteritems(), key=lambda (k, v): (-v, k))
letters = "\netaoinhsrdlumcwgfypbkvxjxz"
g = open("freq.txt", "w")
for key, value in freq:
g.write(key)
g.write(letters)
g.close()
encrypt(input, output, "freq.txt")
def crack(input, output):
f = open(input, "r")
data = f.read()
f.close()
temp = filter(lambda x: x.isalpha(), data)
freq = {}
for i in "abcdefghijklmnopqrstuvwxyz":
freq[i] = 0
for c in temp:
freq[c] += 1
freq = sorted(freq.iteritems(), key = lambda (k,v):(-v, k))
letters = "\netaoinhsrdlumcwgfypbkvxjxz"
g = open("freq.txt", "w")
for key, value in freq:
g.write(key)
g.write(letters)
g.close()
encrypt(input, output,"freq.txt")
def test_vigenere_cipher():
assert encrypt('vigenere', 'encode', 'aabdBE', 'ab') == 'abbeBF'
assert encrypt('vigenere', 'decode', 'abbeBF', 'ab') == 'aabdBE'
with open('./tests/text.txt') as input_file:
input_text = input_file.read()
key = 'afB wi!WEdjc#'
assert encrypt('vigenere', 'decode',
encrypt('vigenere', 'encode', input_text, key),
key) == input_text
assert encrypt('vigenere', 'encode', input_text, 'a') == input_text
assert encrypt('vigenere', 'decode', input_text, 'a') == input_text
assert encrypt('vigenere', 'encode', input_text,
'Le#') == encrypt('vigenere', 'encode', input_text,
'Le#Le#')
assert encrypt('vigenere', 'decode', input_text,
'Le#') == encrypt('vigenere', 'decode', input_text,
'Le#Le#')
def test_secret_encryption(self):
assert conf.get(ENCRYPTION_KEY) == 'my_key'
assert conf.get(ENCRYPTION_SECRET
) == 'qMGwKR21SAjprV0XOJUI4SoI-MLFoTxN1ahZndKREL4='
encryptor.validate()
encryptor.setup()
value = 'foo'
encrypted_value = encryptor.encrypt(value)
assert encrypted_value.startswith('{}my_key$'.format(
EncryptionManager.MARKER))
assert encryptor.decrypt(encrypted_value) == 'foo'
def askForData():
isValid = False
while not isValid:
user = input("Enter the bot's username > ")
pas = input("Enter the bot's password > ")
try:
scratch = scratchapi.ScratchUserSession(user, pas)
isValid = True
except:
print("Invalid username or password")
return user, str(encryptor.encrypt(pas), "utf-8")
def test_caesar_cipher():
assert encrypt('caesar', 'encode', 'abb2', 2) == 'cdd2'
assert encrypt('caesar', 'decode', 'cdd2', 2) == 'abb2'
assert encrypt('caesar', 'encode', 'defgEM', -2) == 'bcdeCK'
assert encrypt('caesar', 'decode', 'cdeabA', -2) == 'efgcdC'
with open('./tests/text.txt') as input_file:
input_text = input_file.read()
for i in range(0, 50, 2):
encrypted_text = encrypt('caesar', 'encode', input_text, i)
assert encrypted_text == encrypt('caesar', 'decode', input_text, -i)
if i != 0:
assert encrypted_text != input_text
assert encrypt('caesar', 'decode', encrypted_text, i) == input_text
assert encrypt('caesar', 'hack', encrypted_text) == input_text
def write():
while True:
input_message = f'{input("")}'
client_data_partial = {}
with open("data.pickle", "rb") as f:
client_data_partial = pickle.load(f)
if input_message.lower() == 'leave':
global is_running
is_running = False
client.send("leave".encode('utf-8'))
client_data_partial.pop(nickname.lower())
with open("data.pickle", "wb") as f:
pickle.dump(client_data_partial, f)
break
elif input_message.lower() == 'show':
show_users(client_data_partial)
else:
try:
receiver_nickname, input_text = input_message.split(' ', 1)
if input_text != '':
if receiver_nickname.lower() in client_data_partial.keys():
text = text_to_numeric_cipher(input_text)
encrypted_message = encrypt(
int(text),
client_data_partial[receiver_nickname.lower()][0],
client_data_partial[receiver_nickname.lower()][1])
message = f"{receiver_nickname} {encrypted_message}"
client.send(message.encode('utf-8'))
else:
print(
f"[No user with nickname {receiver_nickname.capitalize()} present]"
)
else:
print("[Empty Message]")
print("Follow - UserNickname Message")
except:
print("[Incorrect Message Format]")
print("Follow - UserNickname Message")
def write(self, path, buf, offset, fh):
fh.seek(0, 0)
self.externdata['size'] += len(buf)
# Get information from metadata for Custos
cuuid = self.externdata['cuuid']
suuid = self.externdata['suuid']
# Decrypt the data
dec = decrypt(fh.read(), 0, fh, cuuid, suuid)
enc_size = encrypt(dec+buf, 0, fh, cuuid, suuid)
#return enc_size
return len(buf)
def test_default_encryption(self):
assert conf.get(ENCRYPTION_KEY) is None
assert conf.get(ENCRYPTION_SECRET) is None
assert encryptor.encrypt('foo') == 'foo'
assert encryptor.decrypt('foo') == 'foo'
if message == 'Goodbye':
c.send("okay".encode())
else:
key = message
print('Key received!\n')
c.send("Thanks for the key!".encode())
else:
c.send("okay".encode())
while True:
sock.listen(5)
print("the server is listening...\n")
c, addr = sock.accept()
print("Connection established")
message = c.recv(1024).decode()
print("Message received")
print("It is: " + message)
decryMsg = decrypt(key, message)
encryMsg = encrypt(key, decryMsg)
c.send(encryMsg.encode())
print("Response sent\n")
c.close()
sock.close()
def get_output_text(self):
"""Вычисляет выходной текст, если вернулся None, делает текст пустым"""
self._output_text = encrypt(self._cipher, self._mode, self._input_text, self._key)
return self._output_text
# This code is written by Nicky Ru
from encryptor import encrypt
if __name__ == '__main__':
message = input("Enter your message: ") # e.g. 0123456789ABCDEF
key = input("Enter your key: ") # e.g. 133457799BBCDFF1
result = encrypt(message, key)
print("Your encrypted message is:", result.upper())
# See PyCharm help at https://www.jetbrains.com/help/pycharm/
def get_db_prep_value(self, value, connection=None, prepared=False):
value = super().get_db_prep_value(value=value, connection=connection, prepared=prepared)
return encryptor.encrypt(value)
if __name__ == '__main__':
# parse the arguments
parser = argparse.ArgumentParser(description='Secure your file system')
parser.add_argument('option', help='encrypt or decrypt')
parser.add_argument('path', help='path to target file')
args = parser.parse_args()
# get the password
password = getpass.getpass('Password: '******'Retype password: '******'Passwords don\'t match!')
exit(0)
# encrypt
if args.option.lower() == 'encrypt':
encryptor.encrypt(args.path, password)
# decrypt
elif args.option.lower() == 'decrypt':
encryptor.decrypt(args.path, password)
# invalid
else:
show_usage()
English letter frequency method would be accurate if the ciphertext is very long. \
For short ciphertext, it may not follow the statistical rule therefore the cracked text may not accurate or not accurate at all."
class DecryptMethod(Enum):
FREQUENCY = 1
HILL_CLIMBING = 2
WORD_PATTERN = 3
def decrypt(input, decrypt_method):
if decrypt_method == DecryptMethod.FREQUENCY:
key = get_key_by_frequency(input)
elif decrypt_method == DecryptMethod.HILL_CLIMBING:
key = get_key_by_hill_climbing(input)
elif decrypt_method == DecryptMethod.WORD_PATTERN:
raise NotImplementedError
else:
raise Exception("Undefined decrypt method")
return decrypt_from_key(input, key)
if __name__ == "__main__":
print(test_input)
encrypted = encrypt(test_input)
print(encrypted)
decrypted = decrypt(encrypted, DecryptMethod.FREQUENCY)
print(decrypted)
decrypted = decrypt(encrypted, DecryptMethod.HILL_CLIMBING)
print(decrypted)
def test_with_empty_text():
assert encrypt('caesar', 'encode', '', 123) == ''
assert encrypt('caesar', 'decode', '', 123) == ''
assert encrypt('caesar', 'hack', '') == ''
assert encrypt('vigenere', 'encode', '', 'acfjwe') == ''
assert encrypt('vigenere', 'decode', '', 'acfjwe') == ''
password.encode(encoding='UTF-8')).hexdigest()
confirm_password = getpass("Confirm password: "******"Encrypting " + file)
sys.stdout.flush()
encryptor.encrypt(file, public_key)
elif arguments.decrypt:
# getting the password for generating the private key
password = arguments.password
if password is None:
password = getpass("Enter password: "******"Decrypting " + file)
sys.stdout.flush()
try:
def findBigram(input, output, CALIBRE):
f = open(input, "r")
data = f.read()
f.close()
temp = filter(lambda x: x.isalpha() or x in " \n\t", data)
freq = {}
for i in xrange(len(temp) - 1):
if temp[i] in ' \n\t' or temp[i+1] in ' \t\n':
continue
try:
freq[temp[i] + temp[i+1]] +=1
except:
freq[temp[i] + temp[i+1]] = 1
freq = sorted(freq.iteritems(), key = lambda (k,v):(-v, k))
keyFile = open("freq.txt", "r")
alphabet = keyFile.readline().strip()
chipher = keyFile.readline().strip()
keyFile.close()
for i in xrange(len(alphabet)):
keys[alphabet[i]] = chipher[i]
bigrams = ' ' + open("bigramfreq.txt", "r").read() + ' '
def bigramUpdate():
global freqBigramsUnfound
global freqBigramsFound
global keys
freqDecrypted = {}
for key, value in freq:
freqDecrypted[keys[key[0]] + keys[key[1]]] = value
freqDecrypted = sorted(freqDecrypted.iteritems(), key = lambda (k,v):(-v, k))[:CALIBRE]
freqBigramsFound = 0
freqBigramsUnfound = []
for key, value in freqDecrypted:
if key in bigrams:
freqBigramsFound += 1
else:
freqBigramsUnfound.append(key)
def improveKey(curBigram):
for n in xrange(2):
c = curBigram [n]
i = chipher.index(c)
for di in (1, -1, 2, -2, 3, -3):
if (-1 < i + di < len(chipher)):
keys[alphabet[i]] = chipher[i + di]
keys [alphabet[i + di]] = chipher[i]
temp = ''.join(map(lambda x : keys[alphabet[i]] if x == c else x, curBigram))
if temp in bigrams:
return True
else:
keys[alphabet[i]] = chipher[i]
keys[alphabet[i + di]] = chipher[i + di]
return False
def improveBigram(i):
global keys
oldKey = keys.copy()
if not improveKey(i):
return
freqDecrypted = {}
for key, value in freq:
freqDecrypted[keys[key[0]] + keys[key[1]]] = value
freqDecrypted = sorted(freqDecrypted.iteritems(), key = lambda (k,v):(v, k))[-CALIBRE:]
count = 0
for key, value in freqDecrypted:
if key in bigrams:
count += 1
if count < freqBigramsFound:
keys = oldKey.copy()
else:
bigramUpdate()
bigramUpdate()
while freqBigramsUnfound:
improveBigram(freqBigramsUnfound.pop())
g = open("newKey.txt", "w")
g.write(alphabet + "\n")
for i in alphabet:
g.write(keys[i])
g.close()
encrypt(input, output, "newKey.txt")
import encryptor as e
import decryptor as d
if __name__ == "__main__":
mode = input(
"Please enter a mode. Enter 'e' for encryption and 'd' for decryption: "
)
if (mode.lower() == "e"):
e.encrypt()
elif (mode.lower() == "d"):
print(d.decrypt())
else:
print(
"Invalid mode. Exiting."
) #Eventually make this so that it loops until valid input is entered
input("\nPress Enter key to quit")
def findBigram(input, output, CALIBRE):
f = open(input, "r")
data = f.read()
f.close()
temp = filter(lambda x: x.isalpha() or x in " \n\t", data)
freq = {}
for i in xrange(len(temp) - 1):
if temp[i] in ' \n\t' or temp[i + 1] in ' \t\n':
continue
try:
freq[temp[i] + temp[i + 1]] += 1
except:
freq[temp[i] + temp[i + 1]] = 1
freq = sorted(freq.iteritems(), key=lambda (k, v): (-v, k))
keyFile = open("freq.txt", "r")
alphabet = keyFile.readline().strip()
chipher = keyFile.readline().strip()
keyFile.close()
for i in xrange(len(alphabet)):
keys[alphabet[i]] = chipher[i]
bigrams = ' ' + open("bigramfreq.txt", "r").read() + ' '
def bigramUpdate():
global freqBigramsUnfound
global freqBigramsFound
global keys
freqDecrypted = {}
for key, value in freq:
freqDecrypted[keys[key[0]] + keys[key[1]]] = value
freqDecrypted = sorted(freqDecrypted.iteritems(),
key=lambda (k, v): (-v, k))[:CALIBRE]
freqBigramsFound = 0
freqBigramsUnfound = []
for key, value in freqDecrypted:
if key in bigrams:
freqBigramsFound += 1
else:
freqBigramsUnfound.append(key)
def improveKey(curBigram):
for n in xrange(2):
c = curBigram[n]
i = chipher.index(c)
for di in (1, -1, 2, -2, 3, -3):
if (-1 < i + di < len(chipher)):
keys[alphabet[i]] = chipher[i + di]
keys[alphabet[i + di]] = chipher[i]
temp = ''.join(
map(lambda x: keys[alphabet[i]]
if x == c else x, curBigram))
if temp in bigrams:
return True
else:
keys[alphabet[i]] = chipher[i]
keys[alphabet[i + di]] = chipher[i + di]
return False
def improveBigram(i):
global keys
oldKey = keys.copy()
if not improveKey(i):
return
freqDecrypted = {}
for key, value in freq:
freqDecrypted[keys[key[0]] + keys[key[1]]] = value
freqDecrypted = sorted(freqDecrypted.iteritems(),
key=lambda (k, v): (v, k))[-CALIBRE:]
count = 0
for key, value in freqDecrypted:
if key in bigrams:
count += 1
if count < freqBigramsFound:
keys = oldKey.copy()
else:
bigramUpdate()
bigramUpdate()
while freqBigramsUnfound:
improveBigram(freqBigramsUnfound.pop())
g = open("newKey.txt", "w")
g.write(alphabet + "\n")
for i in alphabet:
g.write(keys[i])
g.close()
encrypt(input, output, "newKey.txt")
def save(self):
file = open(os.getcwd() + "/prop.prp", "w+")
file.write(encryptor.encrypt(str(self.silenceMode)) + "\n")
file.write(encryptor.encrypt(self.address) + "\n")
file.write(encryptor.encrypt(str(self.size) + "\n"))
file.close()
if (mode == '1'):
#encrypt message
print("\033[1;31m\nDon't use accent!!\033[m")
message = input('Digit your message: ').strip().lower()
key = encryptor.setKey()
save_in_text = input('Save in archive?[S/N] ').strip().lower()
if 's' in save_in_text:
save_in_text = 's'
else:
save_in_text = 'n'
encryptor.encrypt(message, key, save_in_text)
next = input ('Press enter >>> ')
elif mode == '2':
#descript message
message = input('Input the message to descript: ').strip().lower()
key = encryptor.setKey()
save_in_text = input('Save in archive?[S/N] ').strip().lower()
if 's' in save_in_text:
save_in_text = 's'
else:
save_in_text = 'n'
