def DESe(k, messages):
print("Generating DES Times")
times = list()
for msg in messages:
t_start = time()
key = str.encode(k[0:16])
DES3.adjust_key_parity(key)
cipher = DES3.new(key, DES3.MODE_EAX)
cipher_text = cipher.nonce + cipher.encrypt(str.encode(msg))
t_end = time()
total_time = t_end - t_start
times.append(total_time)
return times
def __init__(self, CIPHER, MODE, key=None, iv=None, nonce=None):
key = b64decode(key) if key else get_random_bytes(
24) # Generamos la llave aleatoria
if CIPHER not in self.CIPHERS:
return 1
CIPHER = self.CIPHERS[CIPHER] # Obtenemos el Cipher elejido
if CIPHER == DES3:
key = DES3.adjust_key_parity(key) # Key Parity para 3DES
if MODE not in self.MODES:
return 1
mode = self.MODES[MODE] #Obtenemos el modo de operación
if (CIPHER != AES) and (MODE == "CTR"):
nonce = b64decode(nonce) if nonce else get_random_bytes(4)
cipher = CIPHER.new(key, mode, nonce=nonce)
elif MODE == "ECB":
cipher = CIPHER.new(key, mode)
elif MODE == "CTR":
nonce = b64decode(nonce) if nonce else None
cipher = CIPHER.new(key, mode, nonce=nonce)
else:
iv = b64decode(iv) if iv else None
cipher = CIPHER.new(key, mode, iv=iv)
self.cipher = cipher
self.mode = MODE
self.key = key
def test_parity_option3(self):
before_3k = unhexlify(
"AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCC")
after_3k = DES3.adjust_key_parity(before_3k)
self.assertEqual(
after_3k,
unhexlify("ABABABABABABABABBABABABABABABABACDCDCDCDCDCDCDCD"))
def decryptDocument(e_type: bytes, e_key: bytes, iv: bytes, ciphertext: bytes):
'''
Decrypt document via 3DES or AES.
Returns: plaintext
'''
print("\ndecryptDocument()")
print("Encryption Type: ", type(e_type))
print("Encryption Type: ", e_type)
encryption_type = str(e_type, "UTF-8")
print("Encryption Type After String Conversion: ", encryption_type)
if encryption_type == "AES128" or encryption_type == "AES256":
print("\nAES DECRYPTION")
cipher = AES.new(e_key, AES.MODE_CBC, iv)
plaintext = cipher.decrypt(ciphertext)
plaintext = unpad(plaintext, AES.block_size)
if encryption_type == "3DES":
print("\n3DES DECRYPTION")
e_key = DES3.adjust_key_parity(e_key)
cipher = DES3.new(e_key, DES3.MODE_CBC, iv)
plaintext = cipher.decrypt(ciphertext)
plaintext = unpad(plaintext, DES3.block_size)
if DEBUG_DECRYPT_DOCUMENT:
print("Plaintext Type:\n", plaintext)
print("Plaintext:\n", plaintext) # Print entire doc
return plaintext
def compute_key(key_seed: bytes, key_type: str, alg: str) -> bytes:
"""Compute enc and mac keys from key_seed.
key_seed -- 16 bytes
key_type -- type of key to be created (choices "enc", "mac", "pace")
alg -- which algorithm to create keys for (choices "3DES", "AES-128", "AES-192", "AES-256")
:returns: 3DES or AES key
"""
if key_type == "enc":
c = b"\x00\x00\x00\x01"
elif key_type == "mac":
c = b"\x00\x00\x00\x02"
elif key_type == "pace":
c = b"\x00\x00\x00\x03"
else:
raise ValueError('key_type must either be "enc" or "mac"')
D = key_seed + c
if alg == "3DES":
hash_of_D = hashlib.sha1(D).digest()
key_a = hash_of_D[:8]
key_b = hash_of_D[8:16]
return DES3.adjust_key_parity(key_a + key_b) # set parity bits
if alg == "AES-128":
return hashlib.sha1(D).digest()[:16]
if alg == "AES-192":
return hashlib.sha256(D).digest()[:24]
if alg == "AES-256":
return hashlib.sha256(D).digest()
else:
raise ValueError("[-] Unknown encryption algorithm!")
def decrypt_3des_ecb(p_bytes):
BLOCK_SIZE = 8 # bytes
key = DES3.adjust_key_parity("abcdefghijklmnop".encode('utf8'))
decipher = DES3.new(key, DES3.MODE_ECB)
msg = decipher.decrypt(p_bytes)
with open("des3_ecb_decrypt.txt", 'ab') as output_file:
output_file.write(msg)
def DES(self, password: str) -> bytes:
"""Encrypt data according to DES3 algorithm."""
# Generating the key according to password
key = DES3.adjust_key_parity(get_key(password, 24))
# Encrypting the data
cipher_object = DES3.new(key, DES3.MODE_CBC)
return (cipher_object.iv + cipher_object.encrypt(pad(self.data, 8)))
def encrypt_3des_cbc(p_bytes):
BLOCK_SIZE = 8 # bytes
key = DES3.adjust_key_parity("abcdefghijklmnop".encode('utf8'))
cipher = DES3.new(key, DES3.MODE_CBC, iv=des3_iv)
msg = cipher.encrypt(pad(p_bytes, BLOCK_SIZE))
with open("des3_cbc.txt", 'ab') as output_file:
output_file.write(msg)
def DES_decrypt(key, msg):
key = str(key)
if (len(key) < 15):
key = key + '0' * (15 - len(key))
key = key.encode()
while (len(key) != 24):
key += b"\0"
key = DES3.adjust_key_parity(key)
cipher = DES3.new(key, DES3.MODE_ECB)
plaintext = cipher.decrypt(msg)
return plaintext
def DES(self, password: str) -> bytes:
"""Decrypt data according to DES algorithm."""
# Generating the key according to password
key = DES3.adjust_key_parity(get_key(password, 24))
# Splitting data into IV & Data
iv = self.data[:8]
data = self.data[8:]
# Decrypting the data
cipher_object = DES3.new(key, DES3.MODE_CBC, IV=iv)
return unpad(cipher_object.decrypt(data), 8)
def encrypt_3des(path):
data = open_binary(path)
while True:
try:
key = DES3.adjust_key_parity(get_random_bytes(24))
break
except ValueError:
pass
cipher = DES3.new(key, DES3.MODE_CFB)
cipher_bytes = cipher.encrypt(data)
iv = cipher.iv
cipher_path = path.split(".")[0] + ".enc"
write_binary(cipher_path, data=cipher_bytes)
insert(cipher_path, "3DES", path.split(".")[1], key, iv)
def DES_encrypt(key, plaintext, isFile):
key = str(key)
if (len(key) < 15):
key = key + '0' * (15 - len(key))
key = key.encode()
#print("" + len(key))
while (len(key) != 24):
key += b"\0"
key = DES3.adjust_key_parity(key)
cipher = DES3.new(key, DES3.MODE_ECB)
if isFile:
msg = cipher.encrypt(pad(plaintext, BLOCK_SIZE))
return msg
else:
msg = cipher.encrypt(pad(plaintext.encode(), BLOCK_SIZE))
return msg
def encryptMsg(cls, msg_file):
with open(msg_file, 'r') as secret_msg_file:
secret_msg = secret_msg_file.read()
while True:
try:
key = DES3.adjust_key_parity(get_random_bytes(24))
break
except ValueError:
pass
#('KEY SIZE ERROR AUDIO STEG')
enc_msg = encryptTripleDES(secret_msg, key)
cls.TDES_key = b64encode(key).decode('utf-8')
with open('encrypted_msg_audio.txt', 'w') as enc_file:
enc_file.write(enc_msg)
def Encrypt(g_key, img_file):
given_key = bytes(g_key, 'utf-8')
while True:
try:
key = DES3.adjust_key_parity(given_key)
break
except ValueError:
pass
input_file = open(img_file, "rb")
input_data = input_file.read()
input_file.close()
iv = b"abcdefgh"
cipher = DES3.new(key, DES3.MODE_CFB, iv)
enc_data = cipher.encrypt(input_data)
return enc_data
def Decrypt(g_key, img_file):
given_key = bytes(g_key, 'utf-8')
while True:
try:
key = DES3.adjust_key_parity(given_key)
break
except ValueError:
pass
enc_file = open(img_file, "rb")
enc_data = enc_file.read()
enc_file.close()
iv = b"abcdefgh"
decipher = DES3.new(key, DES3.MODE_CFB, iv)
plain_text = decipher.decrypt(enc_data)
return plain_text
def process_DES3(text):
des3 = None
length = None
while True:
key = input("key(must be 16 or 24 bytes): ").encode('utf-8')
length = len(key)
try:
key = DES3.adjust_key_parity(key)
des3 = DES3.new(key, DES3.MODE_ECB)
break
except ValueError:
pass
target_text = text_padding(text, 8)
encrypted = des3.encrypt(target_text)
print("encrypted: " + str(encrypted))
decrypted = des3.decrypt(encrypted)
decrypted = decrypted.decode('utf-8')
print("decrypted: " + decrypted)
def encrypter(cls, msg_file, msg_save_to):
with open(msg_file, 'r') as txt:
plain_txt = txt.read()
while True:
try:
key = DES3.adjust_key_parity(get_random_bytes(24))
if len(key) == 24:
break
except ValueError:
print('TDES KEY SIZE ERROR')
cipher_txt_encoded = encryptTripleDES(plain_txt, key)
key_encoded = b64encode(key).decode('utf-8')
with open(msg_save_to, 'w') as enc_msg_file:
enc_msg_file.write(cipher_txt_encoded)
cls.key['TDES'] = key_encoded
return msg_save_to
def encrypt(key_file, input_file, output_file):
"""
Encrypt a file using DES3.
:param key_file: path to the file containing key
:param input_file: path to the message file which we want to encrypt
:param output_file: path where the encrypted file shall be saved.
:return: nothing
"""
k = utils.read_file_b(key_file)
message = utils.read_file_s(input_file)
data = utils.message_to_data(message, DES3.block_size)
while True:
try:
key = DES3.adjust_key_parity(k)
break
except ValueError:
pass
cipher = DES3.new(key, DES3.MODE_CFB)
msg = cipher.iv + cipher.encrypt(data)
utils.write_to_file_b(output_file, msg)
def encryptDocument(encryption_type: str, encryption_key: bytes,
plaintext: bytes):
'''
Pad byte array to appropriate block size. Encrypt document in manner specified by config scheme w/ AES_CBC or3DES_CBC
Returns: initialization vector and ciphertext
'''
print("\nencryptDocument()")
if DEBUG_ENCRYPT_DOCUMENT_I:
print("Encryption Type Type: ", type(encryption_type))
print("Encryption Type: ", encryption_type)
print("Encryption Key Type: ", type(encryption_key))
print("Encryption Key Length: ", len(encryption_key))
print("Encryption Key: ", encryption_key)
print("Plaintext Type: ", type(plaintext))
# print("Plaintext: ", plaintext) # print whole doc
if encryption_type == "AES128" or encryption_type == "AES256":
print("\nAES ENCRYPTION")
cipher = AES.new(encryption_key, AES.MODE_CBC)
ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))
iv = cipher.iv
if encryption_type == "3DES":
print("\n3DES ENCRYPTION")
encryption_key = DES3.adjust_key_parity(encryption_key)
cipher = DES3.new(encryption_key, DES3.MODE_CBC)
ciphertext = cipher.encrypt(pad(plaintext, DES3.block_size))
iv = cipher.iv
if DEBUG_ENCRYPT_DOCUMENT_O:
print("IV Type: ", type(iv))
print("IV: ", iv, end='\n\n')
print("Ciphertext Type: ", type(ciphertext))
# print("Ciphertext:\n", ciphertext, end='\n\n') # Prints whole document
return iv, ciphertext
def contenidoHTML(texto_plano, llave):
llave = bytes(llave, 'utf-8') #la llave se codifica a bytes con utf-8
while True:
try:
key = DES3.adjust_key_parity(llave)
break
except ValueError:
pass
cipher = DES3.new(
key, DES3.MODE_ECB
) #define tipo de cifrado 3DES modo ECB con la llave entregada
textoPad = pad(texto_plano) #se añade el pad al string de textoplano
text = bytes(
textoPad,
'utf-8') # el textoplano con pad se codifica a bytes con utf-8
msg_cifrado = cipher.encrypt(text) #se encripta el texto
return f"""
def DES3Function(plain) :
while True :
key = input("key(16 / 24) : ")
if (len(key) == 16 and key[:7] != key[8:15]) or (len(key) == 24 and key[:7] != key[8:15] and key[8:15] != key[16:23]) :
DES3key = DES3.adjust_key_parity(key.encode())
cipher = DES3.new(DES3key, DES3.MODE_ECB)
# make plaintext 8 bytes through padding because DES3 has a fixed data block size of 8 bytes
# use underbar for padding char
# DES3.block_size = 8
plain = plain + ((DES3.block_size - (len(plain) % DES3.block_size)) * '_')
cipherText = cipher.encrypt(plain.encode())
print("encrypted : ", cipherText)
dePlain = cipher.decrypt(cipherText)
print("decrypted : ", dePlain.decode())
return
else :
print("Please enter a key that is 16 or 24 in length.")
print("If you enter a 16-digit key, the first eight parts and the last eight parts must be different. ")
print("If you enter a 24-digit key, the eight parts in the middle mush be different form the first eight and the last eight")
return True, end - start
except:
print("Error at CFB Decryption...")
exit(1)
if __name__ == '__main__':
# Generation of our pseudorandom key base64
print("================ KEY GENERATION ================\n")
# Store it into a file
key_file = open('Keys/3des_key.txt', "w", encoding='utf8')
# Avoid Option 3
while True:
try:
generated_key = DES3.adjust_key_parity(
Random.get_random_bytes(KEY_112))
break
except ValueError:
pass
# Encoding key in base64 and dumping it into a json format
key64 = base64.b64encode(generated_key).decode('utf-8')
json_key = json.dumps({'key': key64})
# Write to file
key_file.write(json_key)
# Close file
key_file.close()
print(
"================ INITIALIZATION VECTOR GENERATION ================\n")
# Store it into a file
def test_parity_option2(self):
before_2k = unhexlify("CABF326FA56734324FFCCABCDEFACABF")
after_2k = DES3.adjust_key_parity(before_2k)
self.assertEqual(after_2k,
unhexlify("CBBF326EA46734324FFDCBBCDFFBCBBF"))
def post(self):
args = des3_encrypt_parser.parse_args()
key_1 = args["key_1"]
key_2 = args["key_2"]
key_3 = args["key_3"]
mode = args["mode"].upper()
iv = args["iv"]
message = args["message"]
try:
key = DES3.adjust_key_parity(
str.encode(key_1) + str.encode(key_2) + str.encode(key_3)
)
except Exception as e:
print(e)
abort(
400,
"Invalid key format, each key must be of length 8. The three keys must be different from each other or key_1 == key_3 != key_2",
)
if iv:
if mode == "ECB":
abort(400, "Mode 'ECB' doesn't use an Initialization vector")
elif len(iv.encode("utf-8")) != 8:
abort(400, "Initialization vector must be of length 8")
else:
iv = str.encode(iv)
message = str.encode(message)
try:
# Electronic Code Book
if mode == "ECB":
cipher = DES3.new(key, DES3.MODE_ECB)
encrypted = cipher.encrypt(pad(message, DES3.block_size))
cipher_iv = ""
# Cipher-Block Chaining
elif mode == "CBC":
cipher = DES3.new(key, DES3.MODE_CBC, iv)
encrypted = cipher.encrypt(pad(message, DES3.block_size))
cipher_iv = b64encode(cipher.iv).decode("utf-8")
# Cipher FeedBack
elif mode == "CFB":
cipher = DES3.new(key, DES3.MODE_CFB, iv)
encrypted = cipher.encrypt(message)
cipher_iv = b64encode(cipher.iv).decode("utf-8")
# Output FeedBack
elif mode == "OFB":
cipher = DES3.new(key, DES3.MODE_OFB, iv)
encrypted = cipher.encrypt(message)
cipher_iv = b64encode(cipher.iv).decode("utf-8")
except Exception as e:
print(e)
abort(500, "Unknown error")
# Return base64
data = {
"iv": cipher_iv,
"encrypted_message": b64encode(encrypted).decode("utf-8"),
}
return jsonify(data)
from Crypto.Cipher import DES3
from Crypto import Random
#----GENERATING KEY & IV---------
k = Random.get_random_bytes(24) # 24x8=192bits
#to adjust parity bits the key size must be 16 or 24 bytes
print("key taken=", k, "length=", len(k))
key = DES3.adjust_key_parity(k) #setting parity bits for 3-des
print("key after parity drop=", key, "length=", len(key))
iv = Random.new().read(
DES3.block_size
) #initialize initialization vector(iv) randomly for mode CBC ,i.e., 8 block size
#-----ENCRYPTION------
#making an object for encryption in CBC
cipher_des3 = DES3.new(key, DES3.MODE_CBC, iv)
p = input(str("Enter plaintext: "))
while len(
p
) % 8 != 0: #length of plaintext must be multiple of 8, to make it suitable for CBC mode
p += " "
enc_text = cipher_des3.encrypt(
p.encode('utf-8')) # .encode() is used to convert string to byte stream
print("encypted text = ", enc_text)
#------DECRYPTION-------
print("Decryption.....")
#making decryption object
decipher_des3 = DES3.new(key, DES3.MODE_CBC, iv)
dec_text = decipher_des3.decrypt(enc_text)
print("decypted text = ",
print "El tiempo de ejecucion fue:", tiempo_ejecucion
############### FIN SHA256 #########
############### INICIO DES #########
from Crypto.Cipher import DES3
from Crypto import Random
from Crypto.Util import Counter
print('\n' + "--------DES---------" + '\n')
tiempo_inicial = time()
f = open("DES.txt", "r")
x = 0
for x in range(30):
key = str.encode(f.readline()[0:16])
DES3.adjust_key_parity(key)
cipher = DES3.new(key, DES3.MODE_EAX)
msg = cipher.nonce + cipher.encrypt(str.encode(f.readline()))
tiempo_final = time()
tiempo_ejecucion = tiempo_final - tiempo_inicial
print "El tiempo de ejecucion fue:", tiempo_ejecucion
############### FIN DES #########
############### INICIO AES #########
from Crypto.Cipher import AES
print('\n' + "--------AES---------" + '\n')
tiempo_inicial = time()
f = open("AES.txt", "r")
x = 0
def test_parity_option2(self):
before_2k = unhexlify("CABF326FA56734324FFCCABCDEFACABF")
after_2k = DES3.adjust_key_parity(before_2k)
self.assertEqual(after_2k,
unhexlify("CBBF326EA46734324FFDCBBCDFFBCBBF"))
print( 'Texto cifrado: {}' .format( ciphertext ) )
decipher = AES.new(key, AES.MODE_EAX, nonce=nonce)
plaintext = decipher.decrypt(ciphertext)
try:
decipher.verify( tag )
print( 'Mensaje verificado' )
print( 'Decifrando mensaje: {}' .format( plaintext ) )
except:
print( 'Key incorrect or message corrupted' )
#3DES
while True:
try:
key_3_Des = DES3.adjust_key_parity( get_random_bytes(24) )
break
except ValueError:
pass
#cipher
plaintext = b'Cifrando con triple DES '
iv = get_random_bytes(8)
cipher = DES3.new( key=key_3_Des , mode=DES3.MODE_CFB , iv=iv )
msg = cipher.encrypt( plaintext )
print( 'Cifrando con DES' )
print( 'Texto original: {}' .format( plaintext ) )
print( 'key: {}' .format( key_3_Des ) )
print( 'Texto cifrado: {}' .format( msg ) )
#decipher
def test_parity_option3(self):
before_3k = unhexlify("AAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCC")
after_3k = DES3.adjust_key_parity(before_3k)
self.assertEqual(after_3k,
unhexlify("ABABABABABABABABBABABABABABABABACDCDCDCDCDCDCDCD"))
def post(self):
args = des3_decrypt_parser.parse_args()
key_1 = args["key_1"]
key_2 = args["key_2"]
key_3 = args["key_3"]
mode = args["mode"].upper()
iv_mode = args["iv_mode"]
iv = args["iv"]
encrypted_message = args["encrypted_message"]
# Error handling
try:
key = DES3.adjust_key_parity(
str.encode(key_1) + str.encode(key_2) + str.encode(key_3)
)
except Exception as e:
print(e)
abort(
400,
"Invalid key format, each key must be of length 8. The three keys must be different from each other or key_1 == key_3 != key_2",
)
if iv:
if mode == "ECB":
abort(400, "Mode 'ECB' doesn't use an Initialization vector")
# Accept both utf-8 and base64
if iv_mode == "base64":
try:
iv = b64decode(iv)
except Exception as e:
print(e)
abort(400, "Invalid base64 string")
elif len(iv.encode("utf-8")) != 8:
abort(400, "Initialization vector must be of length 8")
else:
iv = str.encode(iv)
try:
encrypted_message = b64decode(encrypted_message)
except binascii.Error as e:
print(e)
abort(400, "Message has to be encoded in base64")
try:
# Electronic Code Book
if mode == "ECB":
cipher = DES3.new(key, DES3.MODE_ECB)
decrypted = unpad(cipher.decrypt(encrypted_message), DES3.block_size)
# Cipher-Block Chaining
elif mode == "CBC":
cipher = DES3.new(key, DES3.MODE_CBC, iv)
decrypted = unpad(cipher.decrypt(encrypted_message), DES3.block_size)
# Cipher FeedBack
elif mode == "CFB":
cipher = DES3.new(key, DES3.MODE_CFB, iv)
decrypted = cipher.decrypt(encrypted_message)
# Output FeedBack
elif mode == "OFB":
cipher = DES3.new(key, DES3.MODE_OFB, iv)
decrypted = cipher.decrypt(encrypted_message)
except Exception as e:
print(e)
abort(500, "Unknown error")
# Return base64
data = {"decrypted_message": decrypted.decode()}
return jsonify(data)
