简介：使用Python实现的简单且安全的日记加密/解密脚本，使用行业标准的AES加密算法，通过密码保护你的.txt文件

核心功能：

①加密：将普通的 .txt 日记加密成 .enc 文件（并自动删除原文件，防止泄露）

②解密：将 .enc 文件解密回 .txt 供你编辑

一、准备环境

安装Python环境

安装加密库：打开cmd，输入命令👇

pip install pycryptodome

二、代码脚本

将以下代码复制并保存为 diary_lock.py（放在你存放日记的文件夹里）

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 os

# 配置参数
SALT_SIZE = 16  # 盐值大小
IV_SIZE = 16    # AES 初始向量大小
KEY_SIZE = 32   # AES-256 密钥大小
ITERATIONS = 100000  # 密钥派生迭代次数

def get_key(password: bytes, salt: bytes) -> bytes:
    """使用密码和盐值生成AES密钥"""
    return PBKDF2(password, salt, dkLen=KEY_SIZE, count=ITERATIONS)

def encrypt_file(file_path: str, password: str):
    """加密文件"""
    if not os.path.exists(file_path):
        print(f"错误：找不到文件 {file_path}")
        return

    # 读取原文件内容
    with open(file_path, 'rb') as f:
        data = f.read()

    # 生成随机盐值和IV
    salt = get_random_bytes(SALT_SIZE)
    iv = get_random_bytes(IV_SIZE)
    key = get_key(password.encode(), salt)

    # 开始加密
    cipher = AES.new(key, AES.MODE_CBC, iv)
    encrypted_data = cipher.encrypt(pad(data, AES.block_size))

    # 将盐值、IV和密文写入新文件
    encrypted_file_path = file_path + ".enc"
    with open(encrypted_file_path, 'wb') as f:
        f.write(salt + iv + encrypted_data)

    # 删除原文件（为了安全）
    os.remove(file_path)
    print(f"✅ 加密成功！\n已创建: {encrypted_file_path}\n已删除原文件。")

def decrypt_file(file_path: str, password: str):
    """解密文件"""
    if not file_path.endswith(".enc"):
        print("错误：这不是一个加密文件 (.enc)")
        return
    if not os.path.exists(file_path):
        print(f"错误：找不到文件 {file_path}")
        return

    # 读取加密文件内容
    with open(file_path, 'rb') as f:
        salt = f.read(SALT_SIZE)
        iv = f.read(IV_SIZE)
        encrypted_data = f.read()

    key = get_key(password.encode(), salt)

    try:
        # 开始解密
        cipher = AES.new(key, AES.MODE_CBC, iv)
        decrypted_data = unpad(cipher.decrypt(encrypted_data), AES.block_size)
    except (ValueError, KeyError):
        print("❌ 解密失败！密码错误或文件已损坏。")
        return

    # 写入解密后的文件
    original_file_path = file_path[:-4]  # 去掉 .enc 后缀
    with open(original_file_path, 'wb') as f:
        f.write(decrypted_data)

    # 删除加密文件
    os.remove(file_path)
    print(f"✅ 解密成功！\n已恢复: {original_file_path}\n现在可以去编辑了。")

def main():
    print("=== 日记加密/解密工具 ===")
    print("1. 加密日记 (.txt -> .enc)")
    print("2. 解密日记 (.enc -> .txt)")
    
    choice = input("请输入选项 (1 或 2): ").strip()
    filename = input("请输入文件名 (例如 my_diary.txt): ").strip()
    password = input("请设置/输入密码: ").strip()

    if choice == '1':
        encrypt_file(filename, password)
    elif choice == '2':
        decrypt_file(filename, password)
    else:
        print("无效选项")

if __name__ == "__main__":
    main()

使用步骤

场景 1：写好日记后加密
1.你先正常写日记，保存为 my_diary.txt
2.双击运行 diary_lock.py（或者在 CMD 里运行 python diary_lock.py）
3.输入 1 选择加密
4.输入文件名 my_diary.txt
5.输入你的密码
6.程序会生成 my_diary.txt.enc 并删除原来的 txt，别人就算打开电脑也看不了
场景 2：想写新日记时解密
1.运行 diary_lock.py
2.输入 2 选择解密
3.输入文件名 my_diary.txt.enc
4.输入密码
5.程序会还原 my_diary.txt，你就可以打开继续写了，写完记得重复 “场景 1” 再加密

代码的详细注释

# ================= 第一部分：导入必要的库 =================
# Crypto 是 pycryptodome 库提供的加密工具箱
from Crypto.Cipher import AES          # 导入 AES 对称加密算法核心
from Crypto.Protocol.KDF import PBKDF2 # 导入密钥派生函数（将密码变成安全的密钥）
from Crypto.Random import get_random_bytes # 生成密码学安全的随机数
from Crypto.Util.Padding import pad, unpad # 处理数据填充（AES要求数据长度固定）
import os                               # 用于操作文件（删除、检查是否存在）

# ================= 第二部分：配置加密参数（密码学常识） =================
SALT_SIZE = 16  # 盐值（Salt）大小：16字节。
                # 作用：防止黑客用“彩虹表”批量破解密码，即使两个人密码一样，生成的密钥也不同。
                
IV_SIZE = 16    # 初始向量（IV）大小：16字节（AES块大小固定为16字节）。
                # 作用：让相同的原文加密后产生不同的密文，防止通过密文模式猜测原文。
                
KEY_SIZE = 32   # 密钥大小：32字节（对应 AES-256）。
                # 说明：16字节是AES-128，24字节是AES-192，32字节是AES-256（目前最安全的规格之一）。
                
ITERATIONS = 100000  # 密钥派生迭代次数：10万次。
                      # 作用：让黑客暴力破解时计算变慢，你自己用只慢一点点，但黑客破解要慢几万倍。

# ================= 第三部分：核心工具函数 =================
def get_key(password: bytes, salt: bytes) -> bytes:
    """
    【功能】将用户输入的简单密码（如 "123456"）转换成安全的AES密钥。
    【参数】
        password: 用户输入的密码（字节格式）
        salt: 随机盐值（防止彩虹表攻击）
    【返回】
        一个固定长度的、安全的AES密钥
    """
    # PBKDF2 算法：通过反复哈希计算，把简单密码“拉伸”成安全的密钥
    return PBKDF2(password, salt, dkLen=KEY_SIZE, count=ITERATIONS)

# ================= 第四部分：加密逻辑 =================
def encrypt_file(file_path: str, password: str):
    """
    【功能】加密指定的文件，并删除原文件（防止泄露）。
    【参数】
        file_path: 要加密的文件路径（如 "my_diary.txt"）
        password: 用户设置的密码
    """
    # 1. 安全检查：如果文件不存在，直接报错退出
    if not os.path.exists(file_path):
        print(f"错误：找不到文件 {file_path}")
        return

    # 2. 读取原文件内容
    # 'rb' 表示以“二进制只读”模式打开。
    # 原因：加密算法不区分文字还是图片，只认 0 和 1 的字节流。
    with open(file_path, 'rb') as f:
        data = f.read()

    # 3. 生成随机“盐值”和“初始向量”
    # 这两个东西必须是随机的，且不需要保密，会直接存放在加密文件的开头。
    salt = get_random_bytes(SALT_SIZE)
    iv = get_random_bytes(IV_SIZE)
    
    # 4. 生成真正的AES加密密钥
    key = get_key(password.encode(), salt) # password.encode() 把字符串密码转成字节

    # 5. 初始化 AES 加密器
    # MODE_CBC: 密码分组链接模式，是一种常用且安全的加密模式。
    cipher = AES.new(key, AES.MODE_CBC, iv)
    
    # 6. 执行加密
    # pad(data, ...): 数据填充。
    # 原因：AES 是“块加密”算法，每次只能处理 16 字节的数据。如果你的数据最后不够 16 字节，必须补齐。
    encrypted_data = cipher.encrypt(pad(data, AES.block_size))

    # 7. 写入加密后的新文件
    encrypted_file_path = file_path + ".enc" # 新文件加个 .enc 后缀表示加密
    with open(encrypted_file_path, 'wb') as f:
        # 写入顺序很重要：盐值(16字节) -> IV(16字节) -> 真正的密文
        # 因为解密时必须先用盐值生成密钥，用IV初始化解密器。
        f.write(salt + iv + encrypted_data)

    # 8. 删除原文件（安全措施）
    # 注意：如果是非常重要的日记，建议确认加密文件没问题后再手动删除，这里为了方便直接自动删了。
    os.remove(file_path)
    print(f"✅ 加密成功！\n已创建: {encrypted_file_path}\n已删除原文件。")

# ================= 第五部分：解密逻辑（加密的逆过程） =================
def decrypt_file(file_path: str, password: str):
    """
    【功能】解密 .enc 文件，恢复原文件，并删除加密文件。
    【参数】
        file_path: 要解密的文件路径（如 "my_diary.txt.enc"）
        password: 用户输入的密码
    """
    # 1. 基础检查：文件名必须以 .enc 结尾
    if not file_path.endswith(".enc"):
        print("错误：这不是一个加密文件 (.enc)")
        return
    # 2. 基础检查：文件必须存在
    if not os.path.exists(file_path):
        print(f"错误：找不到文件 {file_path}")
        return

    # 3. 读取加密文件的内容
    with open(file_path, 'rb') as f:
        # 按照加密时的顺序依次读取：
        salt = f.read(SALT_SIZE)      # 先读前16字节：盐值
        iv = f.read(IV_SIZE)          # 再读接下来的16字节：初始向量
        encrypted_data = f.read()     # 剩下的所有内容：真正的密文

    # 4. 生成密钥（和加密时用的是同一个逻辑，确保密钥一致）
    key = get_key(password.encode(), salt)

    try:
        # 5. 初始化 AES 解密器
        cipher = AES.new(key, AES.MODE_CBC, iv)
        
        # 6. 执行解密
        # unpad(...): 去掉加密时填充的多余字节，恢复原始数据长度。
        decrypted_data = unpad(cipher.decrypt(encrypted_data), AES.block_size)
    except (ValueError, KeyError):
        # 如果报错，通常是两个原因：
        # 1. 密码输错了（KeyError）
        # 2. 文件被篡改过，或者盐值/IV损坏了（ValueError）
        print("❌ 解密失败！密码错误或文件已损坏。")
        return

    # 7. 写入恢复后的原文件
    original_file_path = file_path[:-4]  # 切片操作：去掉文件名最后 4 个字符 ".enc"
    with open(original_file_path, 'wb') as f:
        f.write(decrypted_data)

    # 8. 删除加密文件
    os.remove(file_path)
    print(f"✅ 解密成功！\n已恢复: {original_file_path}\n现在可以去编辑了。")

# ================= 第六部分：用户交互界面 =================
def main():
    """
    【功能】主函数，处理和用户的对话逻辑
    """
    print("=== 日记加密/解密工具 ===")
    print("1. 加密日记 (.txt -> .enc)")
    print("2. 解密日记 (.enc -> .txt)")
    
    # 获取用户输入
    choice = input("请输入选项 (1 或 2): ").strip()      # strip() 去掉用户不小心输入的空格
    filename = input("请输入文件名 (例如 my_diary.txt): ").strip()
    password = input("请设置/输入密码: ").strip()

    # 根据用户选择执行不同功能
    if choice == '1':
        encrypt_file(filename, password)
    elif choice == '2':
        decrypt_file(filename, password)
    else:
        print("无效选项")

# 程序入口：只有直接运行这个脚本时才会执行 main()
if __name__ == "__main__":
    main()

三、优势

(1)支持跨平台：即使换了电脑，只要以下三样东西还在，就能接着使用

①你的 .enc 加密日记文件（不能删改、损坏）
②正确的密码
③同一份加密逻辑的 Python 代码（就是现在这份）

(2)密码支持任意数字、字母、特殊字符，但千万要牢记，忘了谁都解不开