Ttykuu

I wrote this code to make easy use of the Python library Cryptography to encrypt data

Is this safe and secure given the user inputs a strong password?

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import padding, hashes, hmac
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
import base64
import os
import secrets

def encrypt_(data, password, mode = "aes256"):
 salt = get_salt()
 if mode == "fernet":
 key = get_hmac_key(password, salt)
 f = Fernet(key)
 return b''.join((b'FERNET001SALT_', # description 0 - 14
 salt, # salt 14 - 46
 b'_CT_', # ct label 46 - 50
 base64.b64encode(f.encrypt(data)))) # cipher text 50 +

 elif mode == "aes256":
 key = get_scrypt_key(password, salt) # get scrypt key
 iv = os.urandom(16) # get secure random iv
 cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend = default_backend())# start cipher
 encryptor = cipher.encryptor() # start encryptor
 ct = encryptor.update(pad_data(data)) + encryptor.finalize() # produce cipher text, base64 encoded
 h = hmac.HMAC(get_hmac_key(password, salt),
 hashes.SHA256(),
 backend=default_backend()) # start hmac
 h.update(iv + ct) # produce hmac of iv + ct
 hmac_ = h.finalize() # output hmac as hmac_ to avoid mixing names # base64 encode hmac_, iv and ct to allow .split() when decrypting
 return b''.join((b'AES256001SALT_', # description 0 - 14
 salt, # salt 13 - 46
 b'_HMAC_', # hmac label 46 - 52
 base64.b64encode(hmac_), # hmac 52 - 84
 b'_IV_', # iv label 84 - 88
 base64.b64encode(iv), # iv 88 - 104
 b'_CT_', # ct label 104 - 108
 base64.b64encode(ct))) # cipher text 108 +

def decrypt_(data, password, mode = "aes256"):
 data = data.split(b'_')
 data[3] = base64.b64decode(data[3])
 if mode == "fernet":
 key = get_hmac_key(password, data[1])
 f = Fernet(key)
 return f.decrypt(data[3])

 elif mode == "aes256":
 data[5] = base64.b64decode(data[5])
 data[7] = base64.b64decode(data[7])
 key = get_scrypt_key(password, data[1])
 h = hmac.HMAC(get_hmac_key(password, data[1]),
 hashes.SHA256(),
 backend=default_backend())
 h.update(data[5] + data[7])
 h.verify(data[3])
 cipher = Cipher(algorithms.AES(key), modes.CBC(data[5]), backend = default_backend())
 decryptor = cipher.decryptor()
 return unpad_data(decryptor.update(data[7]) + decryptor.finalize())

def get_scrypt_key(password, salt):
 kdf = Scrypt(salt = salt,
 length = 32,
 n = 2**14,
 r = 8,
 p = 1,
 backend = default_backend())
 return kdf.derive(password.encode())

def get_hmac_key(password, salt):
 kdf = PBKDF2HMAC(algorithm = hashes.SHA256(),
 length = 32,
 salt = salt,
 iterations = 100000,
 backend = default_backend())
 return base64.urlsafe_b64encode(kdf.derive(password.encode()))

def get_salt(length = 32):
 chars = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
 return "".join([secrets.choice(chars) for i in range(length)]).encode()

def pad_data(data):
 padder = padding.PKCS7(128).padder()
 padded_data = padder.update(data)
 padded_data += padder.finalize()
 return padded_data

def unpad_data(padded_data):
 unpadder = padding.PKCS7(128).unpadder()
 data = unpadder.update(padded_data)
 data += unpadder.finalize()
 return data


def test_enc(s = "testingnline2", password = "key"):
 x = encrypt_(s.encode(), password)
 z = decrypt_(x, password).decode()
 q = encrypt_(s.encode(), password, mode = "fernet")
 p = decrypt_(q, password, mode = "fernet").decode()
 if z == s and p == s:
 return True
 return False

print (test_enc())
#True