Criptografía en Python - Aumentando la seguridad, trucos y aplicativos en la vida real

import os
import struct

from Crypto.Cipher import AES

# El tamaño de la división del archivo
chunk_size = 1024*64

# La extensión del archivo a la hora
# de encriptarlo.
extension = 'enc'

def encrypt_file(key, filename):
    # Concatenamos el nombre del archivo
    # con el nombre de la extensión.
    output = filename + '.' + extension

    # Obtenemos el tamaño del archivo
    filesize = os.path.getsize(filename)
    
    with open(filename, 'rb') as fd_in:
        with open(output, 'wb') as fd_out:
            # Escribimos el tamaño del archivo.
            #
            # <: Little Indian
            # Q: unsigned long long
            fd_out.write(
                struct.pack('<Q', filesize)

            )

            while (True):
                # Leemos según el tamaño de división
                # proporcionado por el usuario.
                chunk = fd_in.read(chunk_size)

                # Termino de leer, sale
                if (len(chunk) == 0):
                    break

                cipher = AES.new(key, AES.MODE_EAX)
                ciphertext, tag = cipher.encrypt_and_digest(chunk)

                # Escribimos las partes relevantes
                fd_out.write(cipher.nonce)
                fd_out.write(tag)
                fd_out.write(ciphertext)

                # Vaciar el buffer de la memoria y pasarlo al disco
                fd_out.flush()
                # Forzar la escritura de cualquier buffer 
                # (ya sea del sistema operativo o del mismo programa)
                # al disco.
                os.fsync(fd_out)

def decrypt_file(key, filename):
    # Obtenemos el verdadero nombre, que ahora será el de salida
    (output, _) = os.path.splitext(filename)

    with open(filename, 'rb') as fd_in:
        with open(output, 'wb') as fd_out:
            # Obtenemos el tamaño del archivo original
            filesize = struct.unpack('<Q', fd_in.read(struct.calcsize('<Q')))[0]

            while (True):
                # Leemos el tamaño de la división mas el tamaño del bloque,
                # pero se le multiplica por 2, porque se necesita calcular
                # el nonce, tag y el mismísimo texto.
                chunk = fd_in.read(chunk_size + AES.block_size * 2)

                if (len(chunk) == 0):
                    break

                nonce = chunk[:AES.block_size]
                tag = chunk[AES.block_size:AES.block_size * 2]
                ciphertext = chunk[AES.block_size * 2:]
                cipher = AES.new(key, AES.MODE_EAX, nonce)

                text_plain = cipher.decrypt(ciphertext)
                
                fd_out.write(text_plain)
                fd_out.truncate(filesize)
                fd_out.flush()
                os.fsync(fd_out)