pip install pycryptodome 

import os
import argparse
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad
import hashlib
 
class FileEncryptor:
    def __init__(self):
        self.SALT_SIZE = 16
        self.IV_SIZE = 16
        self.KEY_SIZE = 32
        self.BLOCK_SIZE = AES.block_size
        self.ITERATIONS = 100000
    
    def derive_key(self, password, salt):
        return PBKDF2(password, salt, dkLen=self.KEY_SIZE, count=self.ITERATIONS, 
                     hmac_hash_module=hashlib.sha256)
    
    def encrypt_file(self, input_file, output_file, password):
        salt = get_random_bytes(self.SALT_SIZE)
        iv = get_random_bytes(self.IV_SIZE)
        key = self.derive_key(password.encode(), salt)
        
        cipher = AES.new(key, AES.MODE_CBC, iv)
        
        with open(input_file, 'rb') as f_in:
            with open(output_file, 'wb') as f_out:
                f_out.write(salt + iv)
                
                while True:
                    chunk = f_in.read(64 * 1024)
                    if len(chunk) == 0:
                        break
                    elif len(chunk) % self.BLOCK_SIZE != 0:
                        chunk = pad(chunk, self.BLOCK_SIZE)
                    
                    f_out.write(cipher.encrypt(chunk))
    
    def decrypt_file(self, input_file, output_file, password):
        with open(input_file, 'rb') as f_in:
            salt = f_in.read(self.SALT_SIZE)
            iv = f_in.read(self.IV_SIZE)
            key = self.derive_key(password.encode(), salt)
            
            cipher = AES.new(key, AES.MODE_CBC, iv)
            
            with open(output_file, 'wb') as f_out:
                while True:
                    chunk = f_in.read(64 * 1024)
                    if len(chunk) == 0:
                        break
                    
                    decrypted = cipher.decrypt(chunk)
                    try:
                        decrypted = unpad(decrypted, self.BLOCK_SIZE)
                    except ValueError:
                        pass
                    
                    f_out.write(decrypted)
 
def main():
    parser = argparse.ArgumentParser(description='文件加密解密工具')
    parser.add_argument('mode', choices=['encrypt', 'decrypt'], help='操作模式')
    parser.add_argument('input', help='輸入文件路徑')
    parser.add_argument('output', help='輸出文件路徑')
    parser.add_argument('-p', '--password', required=True, help='加密/解密密碼')
    
    args = parser.parse_args()
    encryptor = FileEncryptor()
    
    try:
        if args.mode == 'encrypt':
            encryptor.encrypt_file(args.input, args.output, args.password)
            print(f"文件已成功加密并保存到 {args.output}")
        else:
            encryptor.decrypt_file(args.input, args.output, args.password)
            print(f"文件已成功解密并保存到 {args.output}")
    except Exception as e:
        print(f"操作失敗: {str(e)}")
 
if __name__ == '__main__':
    main()

python file_crypto.py encrypt input.txt encrypted.bin -p yourpassword 

python file_crypto.py decrypt encrypted.bin output.txt -p yourpassword