Gfrktyl

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