def entropy_test(FilePath, DesType, Key):
try:
file_object = open(FilePath, 'rb')
except FileNotFoundError:
print("File Not Found. ")
print("Exiting...")
sys.exit()
plaintext = file_object.read()
# Check the DesType.
if DesType == 'des':
d = pydes.des()
ciphertext = d.encrypt(Key, plaintext)
elif DesType == 'des96':
d = pydes96.des()
ciphertext = d.encrypt(Key, plaintext)
elif DesType == 'tripledes':
Key0 = Key[0:8]
Key1 = Key[8:16]
Key2 = Key[16:24]
plaintext, ciphertext = tripledes.tripledes(FilePath, Key0, Key1, Key2)
# Return entropies of plaintext and ciphertext.
return find_entropy(plaintext), find_entropy(ciphertext)
def encrypt(self, data, key):
print()
print('BEFORE encrypt:', data)
encrypted = des().encrypt(str(key), str(data), padding=True)
print('AFTER encrypt:', encrypted)
print()
return encrypted
def avalanche_test_on_message(FilePath, DesType, Key):
try:
file_object = open(FilePath, 'rb')
except FileNotFoundError:
print("File Not Found. ")
print("Exitting...")
sys.exit()
if DesType == 'des':
d = pydes.des()
elif DesType == 'des96':
d = pydes96.des()
print("Reading and encrypting original plaintext. ")
# Original Plaintext
plaintext_0 = file_object.read()
ciphertext_0 = d.encrypt(Key, plaintext_0)
print(plaintext_0, ciphertext_0)
print("Reading and encrypting plaintext with 1 bit difference")
# Changing 1 bit.
plaintext_1 = change_bits(plaintext_0, 1)
ciphertext_1 = d.encrypt(Key, plaintext_1)
print(plaintext_1, ciphertext_1)
def TestPydes():
data = "Pleaseencrypt my data"
k = pydes.des("DESCRYPT",
pydes.CBC,
"\0\0\0\0\0\0\0\0",
pad=None,
padmode=pydes.PAD_PKCS5)
k1 = pydes.des("DESCRYP1",
pydes.CBC,
"\0\0\0\0\0\0\0\0",
pad=None,
padmode=pydes.PAD_PKCS5)
d = k.encrypt(data)
print("Encrypted:")
print(d)
print("Decrypted: ")
print(k1.decrypt(d))
def encoder(data, key):
k = pyDes.des(key[:8],
pyDes.CBC,
"\0\0\0\0\0\0\0\0",
pad=None,
padmode=pyDes.PAD_PKCS5)
d = k.encrypt(data)
return str(d)[2:-1]
def decrypt(self, data, key):
print()
print('BEFORE decrypt:', data)
decrypted = des().decrypt(str(key), data, padding=True)
decrypted = make_tuple(decrypted)
print('AFTER decrypt:', decrypted)
print()
return decrypted
def decoder(data, key):
k = pyDes.des(key[:8],
pyDes.CBC,
"\0\0\0\0\0\0\0\0",
pad=None,
padmode=pyDes.PAD_PKCS5)
b = bytes(data, "utf-8")
b = b.decode('unicode-escape').encode('ISO-8859-1')
return str(k.decrypt(b))[2:-1]
def descifrarDES():
key = entry_1.get()
name_file = entry_2.get()
file = open(name_file, 'r')
text = file.read()
d = des()
plain = d.decrypt(key, text, padding=True)
file = open('msjDescifradoDES.txt', 'w')
file.write(plain)
file.close()
print("Descifrado DES: ", plain)
def cifrarDES():
key = entry_1.get()
name_file = entry_2.get()
file = open(name_file, 'r')
text = file.read()
d = des()
ciphered = d.encrypt(key, text, padding=True)
file = open('msjCifradoDES.txt', 'w')
file.write(ciphered)
file.close()
print("Cifrado DES: %r" % ciphered)
def DES_ED(num, key, mess):
d = des()
if num == 1:
cipher = d.encrypt(key, mess, padding=True)
cipher = 'The Calculated Cipher is : ' + cipher
Result = tk.Label(E_Result, font=A_Trans, text=cipher, bg="#d8d2d6")
Result.pack(side='top')
if num == 2:
message = d.decrypt(key, mess, padding=True)
message = 'The Calculated Message is : ' + message
dResult = tk.Label(D_Result, font=A_Trans, text=message, bg="#d8d2d6")
dResult.pack(side='top')
def cbc_encrypt(plain):
enc = des()
enc.setkey(KEY)
iv = os.urandom(8)
plain = pad(plain)
blocks = [plain[i:i + 8] for i in range(0, len(plain), 8)]
ct = iv
for block in blocks:
pt = ''.join([chr(ord(a) ^ ord(b)) for a, b in zip(iv, block)])
iv = enc.encrypt_block(pt)
ct += iv
return ct
def calc_mac_cbc(**kw):
""" 计算报文MAC值(CBC算法) """
tmk = kw.get("TMK", "159D86C7C1F779EA29F77A6858E0DA2A")
mak = kw.get("MAK", "E6218EF29513B143")
vec = kw.get("IV", "\x00\x00\x00\x00\x00\x00\x00\x00")
mab = kw.get("MAB", None)
vec = vec.encode('latin1')
mab += ''.rjust(8 - len(mab) % 8, '\x00').encode('latin1')
des3 = pydes.triple_des(unhexlify(tmk))
mackey = des3.decrypt(unhexlify(mak))
des = pydes.des(mackey)
for i in range(0, len(mab), 8):
vec = bytes(list(map(lambda a, b: a ^ b, vec, mab[i:i + 8])))
vec = des.encrypt(vec)
return hexlify(vec).upper().decode('latin1')
def calc_mac_ecb(**kw):
""" 计算报文MAC值(ECB算法) """
tmk = kw.get("TMK", "159D86C7C1F779EA29F77A6858E0DA2A")
mak = kw.get("MAK", "E6218EF29513B143")
mab = kw.get("MAB", None)
mab += ''.rjust(8 - len(mab) % 8, '\x00').encode('latin1')
mab = reduce(lambda x, y: bytes(list(map(lambda a, b: a ^ b, x, y))),
[mab[i:i + 8] for i in range(0, len(mab), 8)])
des3 = pydes.triple_des(unhexlify(tmk))
mackey = des3.decrypt(unhexlify(mak))
des = pydes.des(mackey)
ret = des.encrypt(hexlify(mab[:4]).upper())
ret = bytes(list(map(lambda x, y: x ^ y, ret, hexlify(mab[4:]).upper())))
ret = des.encrypt(ret)
return hexlify(hexlify(ret[:4]).upper()).decode('latin1')
def tripledes(FilePath, Key0, Key1, Key2):
try:
file_object = open(FilePath, 'rb')
except FileNotFoundError:
print("File Not Found. ")
print("Exitting...")
sys.exit()
plaintext = file_object.read()
if len(plaintext) % 8 != 0:
plaintext = plaintext + (8 - (len(plaintext) % 8)) * '0'
D = pydes.des()
print("Stage1: Encrypt(E1 Stage)")
E_Output0 = D.encrypt(Key0, plaintext)
print("Stage1: Encrypt done. ")
print("Stage2: Decrypt(D Stage)")
E_Output1 = D.decrypt(Key1, E_Output0)
print("Stage2: Decrypt done. ")
print("Stage3: Encrypt(E2 Stage)")
E_Output2 = D.encrypt(Key2, E_Output1)
print("Stage3: Encrypt done. ")
print("Complete Encryption done. ")
ciphertext = E_Output2
# Decryption process - DED
#D_Output0 = D.decrypt(k2, ciphertext)
#D_Output1 = D.encrypt(k1, D_Output0)
#D_Output2 = D.decrypt(k0, D_Output1)
#plaintext_1 = D_Output2
file_object.close()
return plaintext, ciphertext
def random_test_des(FilePath, Key) :
try:
file_object = open(FilePath, 'rb')
except FileNotFoundError :
print("File Not Found.")
print("Exiting...")
sys.exit()
# Store the complete binary in the buffer
plaintext = str(file_object.read())
# Encrypt the plaintext
d = pydes.des()
ciphertext = d.encrypt(Key, plaintext, True)
plaintext_zero_count, plaintext_one_count = count_zero_one(plaintext)
ciphertext_zero_count, ciphertext_one_count = count_zero_one(ciphertext)
return plaintext_zero_count, plaintext_one_count, ciphertext_zero_count, ciphertext_one_count
def avalanche_test_on_key(FilePath, DesType, Key0, Key1, Key2, Key3):
try:
file_object = open(FilePath, 'rb')
except FileNotFoundError:
print("File Not Found. ")
print("Exitting...")
sys.exit()
if DesType == 'des':
d = pydes.des()
elif DesType == 'des96':
d = pydes96.des()
print("Reading and encrypting original plaintext. ")
# Original Plaintext
plaintext_0 = file_object.read()
if len(plaintext_0) % 8 != 0:
x = len(plaintext_0) - len(plaintext_0) % 8
plaintext_0 = plaintext_0[:x]
ciphertext_0 = d.encrypt(Key0, plaintext_0)
#print(plaintext_0, ciphertext_0)
file_object.close()
ciphertext_1 = d.encrypt(Key1, plaintext_0)
ciphertext_2 = d.encrypt(Key2, plaintext_0)
ciphertext_3 = d.encrypt(Key3, plaintext_0)
# Find the hamming distance.
hamming_distance_01 = find_hamming_distance(ciphertext_0, ciphertext_1)
hamming_distance_02 = find_hamming_distance(ciphertext_0, ciphertext_2)
hamming_distance_03 = find_hamming_distance(ciphertext_0, ciphertext_3)
return hamming_distance_01, hamming_distance_02, hamming_distance_03
else :
unpack('H', char)
print(char)
#bit_char = bin(int(char))
#print(byte_array)
return bitarray
if __name__ == '__main__' :
file_object = open("./test_files/ls", 'rb')
plaintext = file_object.read()
d = pydes.des()
ciphertext = d.encrypt('12345678', plaintext)
plaintext = list(plaintext)
ciphertext = list(ciphertext)
plaintext_bitarray = bit_array_gen(plaintext)
ciphertext_bitarray = bit_array_gen(ciphertext)
def chat(self, data):
"""接收聊天信息并打印"""
sender = data['from']
receiver = data['to']
logArea = self.father.logArea
log = ctime() + " Receive Message\n\n"
encryptedMessage = data['encryptedMessage']
encryptedKey = data['encryptedKey']
signature = data['signature']
senderPubKey = data['senderPubKey']
decryptionType = self.father.father.selfInfo['decryptionType']
# message = ''
r = RSA(0)
priKey = self.father.father.selfInfo['priKey']
key = r.decryption(encryptedKey, priKey)
if self.father.father.selfInfo['communicationType'] == 'rsa':
# priKey = self.father.father.selfInfo['priKey']
if len(encryptedMessage) > 5:
result = r.verify(encryptedMessage[0:6], signature,
senderPubKey)
else:
result = r.verify(encryptedMessage, signature,
senderPubKey)
if result:
log += ctime() + " Verify Successfully\n\n"
# father.father.logArea.insert(tk.END)
key = r.decryption(encryptedKey, priKey)
if decryptionType == 'caesar':
c = Caesar()
key = int(key)
message = c.decryption(encryptedMessage, key)
# pass
elif decryptionType == 'playfair':
p = Playfair(0)
p.generateMatrix(key)
message = p.decryption(encryptedMessage)
# pass
elif decryptionType == 'des':
d = des()
message = d.decrypt(key, encryptedMessage)
else:
d = des()
less = data['less']
# print("--------------------",key1, key2, encryptedMessage)
message = d.tdecrypt(key[2:10], key[14:22],
encryptedMessage)
message = message[0:-less]
# print("--------------------",message)
# pass
else:
# 输出不合格
pass
else:
r = RSA(0)
if len(encryptedMessage) > 5:
result = r.verify(encryptedMessage[0:6], signature,
senderPubKey)
else:
result = r.verify(encryptedMessage, signature,
senderPubKey)
if result:
log += ctime() + " Verify Successfully\n\n"
if decryptionType == 'caesar':
key = self.father.father.selfInfo['key']
c = Caesar(key)
ct, secretKey = c.encryption('aaa')
message = c.decryption(encryptedMessage[0],
secretKey)
print('-----------pass')
elif decryptionType == 'playfair':
p = Playfair(0)
p.generateMatrix(key)
message = p.decryption(encryptedMessage)
elif decryptionType == 'des':
d = des()
message = d.decrypt(key, encryptedMessage)
else:
d = des()
less = data['less']
message = d.tdecrypt(key[2:10], key[14:22],
encryptedMessage)
message = message[0:-less]
# pass
else:
print('-----------not pass')
pass
# print("i am here")
textArea = self.father.textArea
text = '['+ sender + ' -> ' + receiver + ' ' + \
ctime() + ']\n\t' + message + '\n'
textArea.insert(tk.END, text)
textArea.see(tk.END)
logArea.insert(tk.END, log)
logArea.see(tk.END)
print("i am here")
def send(self, data):
receiverCertificate = data['certificate']
inputEntry = self.father.inputEntry
message = inputEntry.get()
sender = self.father.father.username
receiver = receiverCertificate['username']
encryptionType = receiverCertificate['encryptionType']
receiverPublicKey = receiverCertificate['publicKey']
communicationType = receiverCertificate['communicationType']
less = 0
logArea = self.father.logArea
log = ctime() + " Receive Certificate\n\n"
if communicationType == 'rsa':
log += ctime() + " Communication Type: RSA\n\n"
# logArea.insert(tk.END, log + '\n\n')
# logArea.see(tk.END)
if encryptionType == 'caesar':
# encryption = Caesar()
c = Caesar()
cypherText, key = c.encryption(message)
r = RSA(0)
encryptedKey = r.encryption(key, receiverPublicKey)
# print(cypherText, self.father.father.selfInfo['priKey'])
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: Caesar\n\n"
# logArea.insert(tk.END, log + '\n\n')
# logArea.see(tk.END)
elif encryptionType == 'playfair':
p = Playfair()
cypherText, key = p.encryption(message)
r = RSA(0)
encryptedKey = r.encryption(key, receiverPublicKey)
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: Playfair\n\n"
elif encryptionType == 'des':
d = des()
key, temp = d.randomkey()
cypherText = d.encrypt(key, message)
# if message
r = RSA(0)
encryptedKey = r.encryption(key, receiverPublicKey)
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: DES\n\n"
# pass
else:
d = des()
keys = d.randomkey()
# less = 0
if len(message) % 8 != 0:
less = 8 - (len(message) - len(message) // 8 * 8)
for i in range(less):
message += '0'
print(message)
# print("--------------------", keys[0], keys[1])
cypherText = d.tencrypt(keys[0], keys[1], message)
print("--------------------", keys[0], keys[1],
cypherText)
r = RSA(0)
encryptedKey = r.encryption(keys, receiverPublicKey)
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'less': less,
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: 3DES\n\n"
else:
mA = data['mA']
key = pow(mA, self.father.father.selfInfo['secretB'],
self.father.father.selfInfo['pAndg'][0])
if encryptionType == 'caesar':
c = Caesar(key)
cypherText = c.encryption(message)
r = RSA(0)
encryptedKey = r.encryption(key, receiverPublicKey)
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: Playfair\n\n"
elif encryptionType == 'playfair':
p = Playfair()
cypherText, key = p.encryption(message)
r = RSA(0)
encryptedKey = r.encryption(key, receiverPublicKey)
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: Playfair\n\n"
elif encryptionType == 'des':
d = des()
key, temp = d.randomkey()
cypherText = d.encrypt(key, message)
# if message
r = RSA(0)
encryptedKey = r.encryption(key, receiverPublicKey)
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: DES\n\n"
# pass
else:
d = des()
keys = d.randomkey()
# less = 0
if len(message) % 8 != 0:
less = 8 - (len(message) - len(message) // 8 * 8)
for i in range(less):
message += '0'
print(message)
# print("--------------------", keys[0], keys[1])
cypherText = d.tencrypt(keys[0], keys[1], message)
print("--------------------", keys[0], keys[1],
cypherText)
r = RSA(0)
encryptedKey = r.encryption(keys, receiverPublicKey)
if len(cypherText) > 5:
signature = r.sign(
cypherText[0:6],
self.father.father.selfInfo['priKey'])
else:
signature = r.sign(
cypherText,
self.father.father.selfInfo['priKey'])
data = {
'less': less,
'type': 'singleChat',
'encryptedMessage': cypherText,
'encryptedKey': encryptedKey,
'signature': signature,
'to': receiver,
'from': sender
}
log += ctime() + " Encryption Type: 3DES\n\n"
# pAndg = receiverCertificate['pAndg']
# self.father.father.selfInfo['secretB'] = getPrimeNum(20)
# mB = pow(pAndg[1], self.father.father.selfInfo['secretB'], pAndg[0])
# receiverCertificate['mB'] = mB
pass
jData = json.dumps(data)
self.socket.send(jData.encode())
print('__send__' + jData)
# update log
log += ctime() + " Send Message Success\n\n"
logArea.insert(tk.END, log)
logArea.see(tk.END)
# update text
textArea = self.father.textArea
if less != 0:
message = message[0:-less]
text = '['+ sender + ' -> ' + receiver + ' ' + \
ctime() + ']\n\t' + message + '\n'
textArea.insert(tk.END, text)
textArea.see(tk.END)
inputEntry.delete(0, tk.END)
import select
import errno
import sys
import base64
from Crypto.Cipher import AES
from Crypto import Random
from Crypto.Protocol.KDF import PBKDF2
import time
from time import perf_counter_ns
import os
import hashlib
from pydes import des
BLOCK_SIZE = 8
key = "secret_k"
d = des()
# First let us encrypt secret message
"""encrypted = encrypt("This is a secret message", password)
print(encrypted)
# Let us decrypt using our original password
decrypted = decrypt(encrypted, password)
print(bytes.decode(decrypted)) """
HEADER_LENGTH = 10
IP = "127.0.0.1"
port = 1234
my_username = input("Enter Username")
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect((IP, port))
client_socket.setblocking(False)
def avalanche_test_on_message(FilePath, DesType, Key):
try:
file_object = open('./test_files/ls', 'rb')
except FileNotFoundError:
print("File Not Found. ")
print("Exitting...")
sys.exit()
if DesType == 'des':
d = pydes.des()
elif DesType == 'des96':
d = pydes96.des()
print("Reading and encrypting original plaintext. ")
# Original Plaintext
plaintext_0 = file_object.read()
ciphertext_0 = d.encrypt(Key, plaintext_0)
#print(plaintext_0, ciphertext_0)
file_object.close()
print("Reading and encrypting plaintext with 1 bit difference")
# Changing 1 bit.
file_object = open('./test_files/ls_1', 'rb')
plaintext_1 = file_object.read()
# plaintext_1 = change_bits(plaintext_0, 1)
if len(plaintext_1) % 8 != 0:
x = len(plaintext_1) - len(plaintext_1) % 8
plaintext_1 = plaintext_1[:x]
#print(plaintext_1, ciphertext_1)
ciphertext_1 = d.encrypt(Key, plaintext_1)
file_object.close()
print("Reading and Encrypting plaintext with 2 bits difference")
# Changing 2 bits.
file_object = open('./test_files/ls_2', 'rb')
plaintext_2 = file_object.read()
# plaintext_2 = change_bits(plaintext_0, 2)
if len(plaintext_2) % 8 != 0:
x = len(plaintext_2) - len(plaintext_2) % 8
plaintext_2 = plaintext_2[:x]
ciphertext_2 = d.encrypt(Key, plaintext_2)
#print(plaintext_2, ciphertext_2)
file_object.close()
print("Reading and Encrypting plaintext with 3 bits difference")
# Changing 3 bits.
file_object = open('./test_files/ls_3', 'rb')
plaintext_3 = file_object.read()
# plaintext_3 = change_bits(plaintext_0, 3)
if len(plaintext_3) % 8 != 0:
x = len(plaintext_3) - len(plaintext_3) % 8
plaintext_3 = plaintext_3[:x]
ciphertext_3 = d.encrypt(Key, plaintext_3)
#print(plaintext_3, ciphertext_3)
file_object.close()
# Find the hamming distance.
hamming_distance_01 = find_hamming_distance(ciphertext_0, ciphertext_1)
hamming_distance_02 = find_hamming_distance(ciphertext_0, ciphertext_2)
hamming_distance_03 = find_hamming_distance(ciphertext_0, ciphertext_3)
return hamming_distance_01, hamming_distance_02, hamming_distance_03
#!/usr/bin/env python
# -*- coding: utf8 -*-
# author: xiaofengfeng
# create: 2016-12-09 16:48:19
import pydes
if __name__ == '__main__':
des = pydes.des('12345678',
pydes.CBC,
b"\0\0\0\0\0\0\0\0",
pad=None,
padmode=pydes.PAD_PKCS5)
message = "qwertyuiopasdfghjklzxcvbnm"
miwen = des.encrypt(message)
print("encrypt: %r" % miwen)
message = des.decrypt(miwen)
print("decrypt: %r" % message)
plainlb3 = Label(window, text="PLAIN TEXT", font=("Arial", 14))
plainlb3.grid(column=0, row=3, sticky="E")
plaintxt = Entry(window, width=20)
plaintxt.grid(column=1, row=3)
KEYlb4 = Label(window, text="KEY", font=("Arial", 14))
KEYlb4.grid(column=2, row=3, sticky="E")
SecretKey = Entry(window, width=20)
SecretKey.grid(column=3, row=3)
lb5 = Label(window, text="CIPHER TEXT", font=("Arial", 14))
lb5.grid(column=0, row=4, sticky="E")
ciphertxt3 = Entry(window, width=20)
ciphertxt3.grid(column=1, row=4)
denctxt3 = Entry(window, width=20)
denctxt3.grid(column=3, row=4)
d = des()
algo = AES
mode = algo.MODE_ECB
ciphered = ""
iv = Random.new().read(algo.block_size)
description = {
"AES (pycrypto)":
'* Độ dài KEY 16 (AES-128), 24 (AES-192), 32 (AES-256)\n* Độ dài PLAINTEXT là bội của 16',
'DES (pycrypto)':
'* Độ dài KEY 16 hoặc 24\n* Độ dài PLAINTEXT là bội của 8',
"DES (pydes)": '* Độ dài KEY >= 8\n* Độ dài PLAINTEXT là bội của 8'
}
def bin2txt(bin_val):
