如何高效又安全地加密和解密大型文件？

对于大型文件，可以使用对称加密算法进行加密，如AES加密算法。为了提高效率，在加密前需要对文件进行分块处理，每个块的大小可以根据具体情况而定，通常为几MB到几十MB。而为了保证安全性，在加密过程中需要使用一个安全的密钥，并在加密后对密文进行认证，比如使用HMAC算法进行消息认证。同时，建议将加密后的密文存储在分布式文件系统中，以保证数据的可靠性和可恢复性。

以下是一个示例代码，用于加密和解密大型文件：

加密：

import os
import struct
import hashlib
from Crypto.Cipher import AES

BLOCK_SIZE = 16  # bytes
CHUNK_SIZE = 1024 * 1024  # 1 MB
HMAC_SIZE = 32  # bytes
FILE_PATH = '/path/to/file'
KEY = 'this is a secret key'.encode('utf-8')


def encrypt(file_path, key):
    iv = os.urandom(BLOCK_SIZE)
    cipher = AES.new(key, AES.MODE_CBC, iv)
    hmac_key = os.urandom(BLOCK_SIZE)
    with open(file_path, 'rb') as f_in:
        with open(file_path + '.enc', 'wb') as f_out:
            f_out.write(iv)
            f_out.write(struct.pack('<Q', os.path.getsize(file_path)))
            while True:
                data = f_in.read(CHUNK_SIZE)
                if not data:
                    break
                if len(data) % BLOCK_SIZE != 0:
                    data += b' ' * (BLOCK_SIZE - len(data) % BLOCK_SIZE)
                enc_data = cipher.encrypt(data)
                f_out.write(enc_data)
            f_out.write(hmac(hmac_key, f_out.getvalue()))
            f_out.write(hmac_key)
    os.remove(file_path)


def hmac(key, data):
    h = hashlib.sha256(key)
    return h.digest() + hashlib.sha256(h.digest() + data).digest()[:HMAC_SIZE - BLOCK_SIZE]


if __name__ == '__main__':
    encrypt(FILE_PATH, KEY)

解密：

import os
import struct
import hashlib
from Crypto.Cipher import AES

BLOCK_SIZE = 16  # bytes
CHUNK_SIZE = 1024 * 1024  # 1 MB
HMAC_SIZE = 32  # bytes
FILE_PATH = '/path/to/file.enc'
KEY = 'this is a secret key'.encode('utf-8')


def decrypt(file_path, key):
    with open(file_path, 'rb') as f_in:
        iv = f_in.read(BLOCK_SIZE)
        orig_size = struct.unpack('<Q', f_in.read(struct.calcsize('<Q')))[0]
        cipher = AES.new(key, AES.MODE_CBC, iv)
        hmac_key = f_in.read(BLOCK_SIZE)
        while True:
            data = f_in.read(CHUNK_SIZE + BLOCK_SIZE)
            if not data:
                break
            enc_data = data[:-BLOCK_SIZE]
            if len(data) % BLOCK_SIZE != 0:
                raise ValueError('Invalid data length')
            dec_data = cipher.decrypt(enc_data)
            if orig_size > CHUNK_SIZE:
                yield dec_data
                orig_size -= len(dec_data)
            else:
                yield dec_data[:orig_size]
                orig_size = 0
        if orig_size != 0:
            raise ValueError('Wrong file