028_密码学实战：XOR加密基础技术深度解析——从原理到应用的完整指南

def xor_encrypt_decrypt(data, key):
    """
    使用XOR操作进行加密或解密
    
    参数：
        data: 要加密或解密的数据（字节串）
        key: 密钥（字节串）
    
    返回：
        加密或解密后的数据（字节串）
    """
    result = bytearray()
    key_length = len(key)
    
    for i, byte in enumerate(data):
        # 对每个数据字节与相应位置的密钥字节进行XOR操作
        result.append(byte ^ key[i % key_length])
    
    return bytes(result)

# 示例使用
def example_usage():
    # 原始明文（需要转换为字节串）
    plaintext = "Hello, XOR Encryption!"
    plaintext_bytes = plaintext.encode('utf-8')
    
    # 密钥（也需要是字节串）
    key = "SecretKey"
    key_bytes = key.encode('utf-8')
    
    # 加密
    ciphertext = xor_encrypt_decrypt(plaintext_bytes, key_bytes)
    print(f"密文（十六进制）: {ciphertext.hex()}")
    
    # 解密
    decrypted_bytes = xor_encrypt_decrypt(ciphertext, key_bytes)
    decrypted_text = decrypted_bytes.decode('utf-8')
    print(f"解密后的明文: {decrypted_text}")

# 运行示例
if __name__ == "__main__":
    example_usage()

import os
from base64 import b64encode, b64decode

def generate_random_key(length):
    """
    生成指定长度的随机密钥
    
    参数：
        length: 密钥长度（字节）
    
    返回：
        随机密钥（字节串）
    """
    return os.urandom(length)

def xor_with_variable_key(data, initial_key):
    """
    使用可变密钥进行XOR加密
    每次加密后更新密钥，避免简单的密钥重复
    
    参数：
        data: 要加密的数据（字节串）
        initial_key: 初始密钥（字节串）
    
    返回：
        加密后的数据（字节串）和最终密钥（字节串）
    """
    result = bytearray()
    current_key = bytearray(initial_key)
    key_length = len(current_key)
    
    for i, byte in enumerate(data):
        # 获取当前密钥字节
        key_byte = current_key[i % key_length]
        # XOR操作
        result_byte = byte ^ key_byte
        result.append(result_byte)
        # 更新密钥（简单的反馈机制）
        current_key[i % key_length] = result_byte
    
    return bytes(result), bytes(current_key)

def xor_file_encryption(input_file, output_file, key):
    """
    使用XOR加密/解密文件
    
    参数：
        input_file: 输入文件路径
        output_file: 输出文件路径
        key: 加密/解密密钥（字节串）
    """
    try:
        # 读取输入文件
        with open(input_file, 'rb') as f:
            data = f.read()
        
        # 执行XOR操作
        result = xor_encrypt_decrypt(data, key)
        
        # 写入输出文件
        with open(output_file, 'wb') as f:
            f.write(result)
        
        print(f"文件已成功{'加密' if input_file != output_file else '解密'}: {output_file}")
    except Exception as e:
        print(f"处理文件时出错: {e}")

def base64_xor_encrypt(plaintext, key):
    """
    使用XOR加密并进行Base64编码，便于传输
    
    参数：
        plaintext: 明文字符串
        key: 密钥字符串
    
    返回：
        Base64编码的密文字符串
    """
    plaintext_bytes = plaintext.encode('utf-8')
    key_bytes = key.encode('utf-8')
    encrypted_bytes = xor_encrypt_decrypt(plaintext_bytes, key_bytes)
    return b64encode(encrypted_bytes).decode('utf-8')

def base64_xor_decrypt(ciphertext_b64, key):
    """
    解码Base64并使用XOR解密
    
    参数：
        ciphertext_b64: Base64编码的密文字符串
        key: 密钥字符串
    
    返回：
        解密后的明文字符串
    """
    ciphertext_bytes = b64decode(ciphertext_b64)
    key_bytes = key.encode('utf-8')
    decrypted_bytes = xor_encrypt_decrypt(ciphertext_bytes, key_bytes)
    return decrypted_bytes.decode('utf-8')

def break_single_byte_xor(ciphertext):
    """
    破解单字节XOR加密
    
    参数：
        ciphertext: 密文字节串
    
    返回：
        可能的明文、密钥和得分的列表，按得分排序
    """
    results = []
    # 尝试所有可能的单字节密钥（0-255）
    for key in range(256):
        # 构建密钥字节串
        key_bytes = bytes([key]) * len(ciphertext)
        # 解密
        plaintext = xor_encrypt_decrypt(ciphertext, key_bytes)
        
        # 尝试将解密结果转换为文本
        try:
            text = plaintext.decode('utf-8')
            # 计算得分（基于常见英文字母的频率）
            score = score_english_text(text)
            results.append((score, text, key))
        except UnicodeDecodeError:
            # 如果无法解码为UTF-8，跳过
            pass
    
    # 按得分排序（得分越高，越可能是正确的解密结果）
    results.sort(reverse=True)
    return results[:5]  # 返回前5个最可能的结果

def score_english_text(text):
    """
    评估文本是否为英文的得分函数
    基于英文字母（不区分大小写）和空格的频率
    
    参数：
        text: 要评估的文本
    
    返回：
        文本得分
    """
    # 英文字母频率表（基于百分比）
    frequency = {
        'a': 8.167, 'b': 1.492, 'c': 2.782, 'd': 4.253, 'e': 12.702, 'f': 2.228, 'g': 2.015,
        'h': 6.094, 'i': 6.966, 'j': 0.153, 'k': 0.772, 'l': 4.025, 'm': 2.406, 'n': 6.749,
        'o': 7.507, 'p': 1.929, 'q': 0.095, 'r': 5.987, 's': 6.327, 't': 9.056, 'u': 2.758,
        'v': 0.978, 'w': 2.360, 'x': 0.150, 'y': 1.974, 'z': 0.074, ' ': 13.0
    }
    
    score = 0
    for char in text.lower():
        if char in frequency:
            score += frequency[char]
        else:
            # 非常见字符降低得分
            score -= 5
    
    return score

def find_xor_key_length(ciphertext, max_length=64):
    """
    使用汉明距离估计重复密钥XOR加密的密钥长度
    
    参数：
        ciphertext: 密文字节串
        max_length: 最大密钥长度
    
    返回：
        可能的密钥长度及其得分的列表
    """
    results = []
    
    # 尝试不同的密钥长度
    for length in range(2, max_length + 1):
        # 如果密文太短，无法进行有效比较，则跳过
        if len(ciphertext) < 2 * length:
            continue
        
        # 计算多个块之间的平均汉明距离
        distances = []
        # 取多个块进行比较，以提高准确性
        num_blocks = min(4, len(ciphertext) // length - 1)
        
        for i in range(num_blocks):
            block1 = ciphertext[i * length:(i + 1) * length]
            block2 = ciphertext[(i + 1) * length:(i + 2) * length]
            distances.append(hamming_distance(block1, block2))
        
        # 计算归一化的平均距离
        avg_distance = sum(distances) / len(distances) / length
        results.append((avg_distance, length))
    
    # 按距离排序（距离越小，越可能是正确的密钥长度）
    results.sort()
    return results[:5]

def hamming_distance(bytes1, bytes2):
    """
    计算两个字节串之间的汉明距离
    汉明距离是两个等长字符串对应位置上不同字符的数量
    
    参数：
        bytes1, bytes2: 要比较的两个字节串
    
    返回：
        汉明距离
    """
    distance = 0
    for b1, b2 in zip(bytes1, bytes2):
        # 计算两个字节之间的异或结果，然后统计1的位数
        distance += bin(b1 ^ b2).count('1')
    return distance

def break_repeating_key_xor(ciphertext, key_length):
    """
    破解重复密钥XOR加密
    
    参数：
        ciphertext: 密文字节串
        key_length: 估计的密钥长度
    
    返回：
        可能的密钥和明文
    """
    key = bytearray()
    
    # 对每个密钥字节进行单字节XOR破解
    for i in range(key_length):
        # 提取与当前密钥字节对应的密文字节
        block = ciphertext[i::key_length]
        
        # 对这个块进行单字节XOR破解
        possible_keys = break_single_byte_xor(block)
        if possible_keys:
            # 选择得分最高的密钥字节
            key.append(possible_keys[0][2])
        else:
            # 如果无法破解，使用默认值
            key.append(0)
    
    # 使用找到的密钥解密整个密文
    key_bytes = bytes(key)
    plaintext = xor_encrypt_decrypt(ciphertext, key_bytes)
    
    return key_bytes, plaintext

# 使用cryptography库进行更安全的加密示例
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def secure_encrypt(plaintext, key=None):
    """
    使用AES-GCM进行安全加密（比纯XOR更安全）
    
    参数：
        plaintext: 要加密的文本
        key: 可选的密钥（如果不提供，将生成新密钥）
    
    返回：
        (密文, 密钥, nonce, 标签)的元组
    """
    # 确保文本是字节串
    if isinstance(plaintext, str):
        plaintext_bytes = plaintext.encode('utf-8')
    else:
        plaintext_bytes = plaintext
    
    # 如果未提供密钥，生成新密钥
    if key is None:
        key = os.urandom(32)  # AES-256需要32字节密钥
    
    # 生成随机nonce
    nonce = os.urandom(12)  # GCM推荐使用12字节nonce
    
    # 创建密码对象
    cipher = Cipher(algorithms.AES(key), modes.GCM(nonce), backend=default_backend())
    encryptor = cipher.encryptor()
    
    # 加密
    ciphertext = encryptor.update(plaintext_bytes) + encryptor.finalize()
    
    # 获取认证标签
    tag = encryptor.tag
    
    return (ciphertext, key, nonce, tag)

def secure_decrypt(ciphertext, key, nonce, tag):
    """
    解密使用secure_encrypt加密的数据
    
    参数：
        ciphertext: 密文
        key: 加密密钥
        nonce: 随机nonce
        tag: 认证标签
    
    返回：
        解密后的文本
    """
    # 创建密码对象
    cipher = Cipher(algorithms.AES(key), modes.GCM(nonce, tag), backend=default_backend())
    decryptor = cipher.decryptor()
    
    # 解密
    plaintext_bytes = decryptor.update(ciphertext) + decryptor.finalize()
    
    # 尝试转换为字符串
    try:
        return plaintext_bytes.decode('utf-8')
    except UnicodeDecodeError:
        return plaintext_bytes

# 单字节XOR加密挑战解决方案
ciphertext_hex = "73626960647f6b206821204f21254f7d694f7624662065626c636960647f6b206a6f"
# 转换为字节串
ciphertext = bytes.fromhex(ciphertext_hex)

# 使用之前定义的break_single_byte_xor函数
results = break_single_byte_xor(ciphertext)

# 输出结果
print("可能的解密结果:")
for i, (score, plaintext, key) in enumerate(results):
    print(f"\n#{i+1}:")
    print(f"  密钥 (十进制): {key}")
    print(f"  密钥 (十六进制): {hex(key)}")
    print(f"  密钥 (字符): {chr(key) if 32 <= key <= 126 else '[不可打印]'}")
    print(f"  得分: {score:.2f}")
    print(f"  明文: {plaintext}")

# 正确的解
# 通常得分最高的就是正确结果
# 在这个案例中，密钥是16，明文是"crypto{i_love_cryptography}"

Burning 'em, if you ain't quick and nimble
I go crazy when I hear a cymbal

# 重复密钥XOR加密挑战解决方案
plaintext = "Burning 'em, if you ain't quick and nimble\nI go crazy when I hear a cymbal"
key = "ICE"

# 将文本和密钥转换为字节串
plaintext_bytes = plaintext.encode('utf-8')
key_bytes = key.encode('utf-8')

# 使用之前定义的xor_encrypt_decrypt函数
ciphertext = xor_encrypt_decrypt(plaintext_bytes, key_bytes)

# 输出十六进制结果
print(f"加密结果 (十六进制): {ciphertext.hex()}")

# 正确的结果应该是:
# 0b3637272a2b2e63622c2e69692a23693a2a3c6324202d623d63343c2a26226324272765272
# a282b2f20430a652e2c652a3124333a653e2b2027630c692b20283165286326302e27282f

# 未知密钥长度的重复密钥XOR加密挑战解决方案

# 假设我们有一段密文字节串
# ciphertext = ... (实际应用中替换为真实的密文)

def solve_repeating_key_xor(ciphertext):
    # 步骤1: 估计密钥长度
    print("估计密钥长度...")
    possible_lengths = find_xor_key_length(ciphertext)
    print("可能的密钥长度:")
    for score, length in possible_lengths:
        print(f"  长度: {length}, 归一化汉明距离: {score:.4f}")
    
    # 步骤2: 对于每个可能的密钥长度，尝试破解
    solutions = []
    for _, key_length in possible_lengths[:3]:  # 尝试前3个最可能的密钥长度
        print(f"\n尝试密钥长度: {key_length}")
        key, plaintext = break_repeating_key_xor(ciphertext, key_length)
        
        # 尝试将解密结果转换为文本
        try:
            text = plaintext.decode('utf-8')
            # 计算得分
            score = score_english_text(text)
            solutions.append((score, key_length, key, text))
            print(f"  密钥: {key}")
            print(f"  密钥 (文本): {key.decode('utf-8', errors='replace')}")
            print(f"  得分: {score:.2f}")
            print(f"  明文前100个字符: {text[:100]}...")
        except Exception as e:
            print(f"  处理错误: {e}")
    
    # 按得分排序
    if solutions:
        solutions.sort(reverse=True)
        print("\n最佳解决方案:")
        best_score, best_length, best_key, best_text = solutions[0]
        print(f"  密钥长度: {best_length}")
        print(f"  密钥: {best_key}")
        print(f"  密钥 (文本): {best_key.decode('utf-8', errors='replace')}")
        print(f"  得分: {best_score:.2f}")
        print(f"  明文: {best_text}")
        return best_key, best_text
    else:
        print("无法找到有效的解决方案")
        return None, None

def detect_xor_encrypted_traffic(packet_data):
    """
    检测数据包是否可能使用XOR加密
    
    参数：
        packet_data: 数据包的字节内容
    
    返回：
        一个字典，包含检测结果和可能的密钥长度
    """
    results = {
        'is_xor_likely': False,
        'reason': [],
        'possible_key_lengths': []
    }
    
    # 检查数据包长度是否合理
    if len(packet_data) < 16:
        results['reason'].append("数据包太短，无法确定")
        return results
    
    # 检查字节分布
    byte_counts = [0] * 256
    for byte in packet_data:
        byte_counts[byte] += 1
    
    # 计算字节频率的熵
    import math
    entropy = 0
    for count in byte_counts:
        if count > 0:
            p = count / len(packet_data)
            entropy -= p * math.log2(p)
    
    # 如果熵接近8，可能是加密数据
    if entropy > 7.5:
        results['reason'].append(f"高熵值: {entropy:.2f} (接近8.0)")
    
    # 尝试检测可能的密钥长度
    # 对于可能的密钥长度，检查每个位置上的字节分布
    possible_lengths = []
    for key_length in range(2, min(64, len(packet_data) // 2)):
        # 对每个密钥位置提取字节
        position_distributions = []
        for pos in range(key_length):
            # 提取与该位置对应的所有字节
            position_bytes = packet_data[pos::key_length]
            if len(position_bytes) < 4:  # 需要足够的样本
                break
            
            # 计算该位置的字节分布熵
            pos_counts = [0] * 256
            for byte in position_bytes:
                pos_counts[byte] += 1
            
            pos_entropy = 0
            for count in pos_counts:
                if count > 0:
                    p = count / len(position_bytes)
                    pos_entropy -= p * math.log2(p)
            
            position_distributions.append(pos_entropy)
        
        # 如果所有位置的熵都低于总体熵，可能表示存在XOR加密
        if len(position_distributions) == key_length:
            avg_pos_entropy = sum(position_distributions) / key_length
            if avg_pos_entropy < entropy - 0.5:
                possible_lengths.append((key_length, entropy - avg_pos_entropy))
    
    # 按差异排序
    possible_lengths.sort(key=lambda x: x[1], reverse=True)
    results['possible_key_lengths'] = [l for l, _ in possible_lengths[:5]]
    
    # 判断是否可能是XOR加密
    if entropy > 7.0 and len(possible_lengths) > 0:
        results['is_xor_likely'] = True
        results['reason'].append("发现可能的密钥长度模式")
    elif entropy < 7.0:
        results['reason'].append(f"低熵值: {entropy:.2f} (可能不是加密数据)")
    
    return results

def analyze_xor_obfuscation(protocol_data, sample_size=100):
    """
    分析协议数据中可能的XOR混淆模式
    
    参数：
        protocol_data: 协议数据样本列表
        sample_size: 要分析的样本数量
    
    返回：
        可能的混淆密钥和分析结果
    """
    # 限制样本数量
    samples = protocol_data[:sample_size]
    
    # 检查样本长度是否一致
    lengths = set(len(sample) for sample in samples)
    if len(lengths) > 1:
        print("警告: 样本长度不一致，可能不适合XOR混淆分析")
    
    # 对于每个可能的位置，尝试找出共同的密钥字节
    possible_keys = {}
    max_length = max(len(sample) for sample in samples)
    
    for pos in range(max_length):
        # 收集所有样本在该位置的字节
        position_bytes = []
        for sample in samples:
            if pos < len(sample):
                position_bytes.append(sample[pos])
        
        # 如果样本数量不足，跳过
        if len(position_bytes) < 3:
            continue
        
        # 假设明文在该位置可能是常见值，尝试找出可能的密钥
        common_plaintext_bytes = [0x00, 0x01, 0x02, 0x20, 0x30, 0x41, 0x61]  # 常见字节
        possible_key_bytes = {}
        
        for plaintext_byte in common_plaintext_bytes:
            for ciphertext_byte in position_bytes:
                key_byte = plaintext_byte ^ ciphertext_byte
                if key_byte in possible_key_bytes:
                    possible_key_bytes[key_byte] += 1
                else:
                    possible_key_bytes[key_byte] = 1
        
        # 找出最可能的密钥字节
        if possible_key_bytes:
            sorted_keys = sorted(possible_key_bytes.items(), key=lambda x: x[1], reverse=True)
            if sorted_keys[0][1] > len(position_bytes) * 0.3:  # 如果超过30%的样本支持该密钥
                possible_keys[pos] = sorted_keys[0]
    
    # 分析可能的密钥模式
    print(f"发现 {len(possible_keys)} 个可能的固定位置密钥字节")
    for pos, (key_byte, count) in sorted(possible_keys.items()):
        print(f"  位置 {pos}: 密钥字节 {key_byte:02x} (支持 {count} 个样本)")
    
    return possible_keys

def analyze_obfuscated_file(file_path):
    """
    分析可能使用XOR混淆的文件
    
    参数：
        file_path: 文件路径
    
    返回：
        分析结果和可能的解密方法
    """
    try:
        # 读取文件
        with open(file_path, 'rb') as f:
            data = f.read()
        
        print(f"文件大小: {len(data)} 字节")
        
        # 检查文件头
        file_header = data[:16].hex()
        print(f"文件头 (前16字节): {file_header}")
        
        # 检查是否可能是XOR混淆
        results = detect_xor_encrypted_traffic(data)
        print(f"\nXOR加密检测结果: {results['is_xor_likely']}")
        
        # 尝试单字节XOR解密
        print("\n尝试单字节XOR解密:")
        top_results = break_single_byte_xor(data[:1024])  # 只分析前1KB以提高速度
        
        for score, text, key in top_results[:3]:
            # 检查解密后是否包含文件头特征
            decrypted_header = xor_encrypt_decrypt(data[:16], bytes([key])).hex()
            print(f"\n密钥 {key:02x}: 得分 {score:.2f}")
            print(f"  解密后文件头: {decrypted_header}")
            
            # 检查是否匹配常见文件头
            common_headers = {
                b'GIF89a': 'GIF图像',
                b'GIF87a': 'GIF图像',
                b'\xff\xd8': 'JPEG图像',
                b'\x89PNG\r\n\x1a\n': 'PNG图像',
                b'BM': 'BMP图像',
                b'PK\x03\x04': 'ZIP文件',
                b'Rar!': 'RAR文件',
                b'\x1f\x8b': 'GZIP文件',
                b'#!/': '脚本文件',
                b'MZ': 'Windows可执行文件',
            }
            
            decrypted_sample = xor_encrypt_decrypt(data[:16], bytes([key]))
            for header, description in common_headers.items():
                if decrypted_sample.startswith(header):
                    print(f"  匹配文件类型: {description}")
                    # 尝试解密整个文件
                    output_file = file_path + f".decrypted_{key:02x}"
                    with open(output_file, 'wb') as f:
                        f.write(xor_encrypt_decrypt(data, bytes([key])))
                    print(f"  已保存解密文件到: {output_file}")
                    break
        
        # 尝试检测重复密钥
        if results['possible_key_lengths']:
            print("\n尝试检测重复密钥XOR:")
            for key_length in results['possible_key_lengths'][:3]:
                print(f"  尝试密钥长度: {key_length}")
                key, plaintext = break_repeating_key_xor(data[:1024], key_length)
                try:
                    text = plaintext.decode('utf-8', errors='replace')
                    print(f"    密钥: {key.hex()}")
                    print(f"    密钥 (文本): {text[:50]}...")
                except:
                    print(f"    无法解码解密结果")
        
        return {
            'file_size': len(data),
            'file_header': file_header,
            'is_xor_likely': results['is_xor_likely'],
            'possible_key_lengths': results['possible_key_lengths']
        }
        
    except Exception as e:
        print(f"分析文件时出错: {e}")
        return None

[database]
host = localhost
user = admin
password = 73626960647f6b206821204f21254f7d694f7624

# 配置文件中的XOR加密密码破解
def crack_config_password(encrypted_hex):
    # 转换为字节串
    encrypted = bytes.fromhex(encrypted_hex)
    
    print("尝试破解配置文件中的密码...")
    results = break_single_byte_xor(encrypted)
    
    print("\n可能的密码:")
    for score, password, key in results[:5]:
        # 过滤掉包含不可打印字符的结果
        if all(32 <= ord(c) <= 126 or c in '\t\n\r' for c in password):
            print(f"  密钥 {key:02x}: '{password}'")
    
    # 另外，尝试常见的多字节密钥
    common_keys = [
        "password", "admin", "secret", "key", "config",
        "123456", "default", "system", "user"
    ]
    
    print("\n尝试常见的多字节密钥:")
    for common_key in common_keys:
        key_bytes = common_key.encode('utf-8')
        decrypted = xor_encrypt_decrypt(encrypted, key_bytes)
        try:
            password = decrypted.decode('utf-8')
            if all(32 <= ord(c) <= 126 or c in '\t\n\r' for c in password):
                print(f"  密钥 '{common_key}': '{password}'")
        except:
            pass

# 运行破解
crack_config_password("73626960647f6b206821204f21254f7d694f7624")

def chacha20_block(key, counter, nonce, rounds=20):
    """
    简化版ChaCha20块函数实现
    注意：这只是用于教育目的的简化实现，不应用于实际安全场景
    """
    # ChaCha20的核心是基于32位整数的四阶段操作：
    # 1. 初始化状态数组
    # 2. 执行指定轮数的quarter-round操作
    # 3. 将初始状态与最终状态相加
    # 4. 提取结果作为密钥流块
    
    # 常量
    constants = [0x61707865, 0x3320646e, 0x79622d32, 0x6b206574]
    
    # 初始化状态数组
    state = constants + list(key) + [counter] + list(nonce)
    
    # 创建工作副本
    working_state = state.copy()
    
    # 执行轮次
    for _ in range(rounds // 2):
        # 列操作
        quarter_round(working_state, 0, 4, 8, 12)
        quarter_round(working_state, 1, 5, 9, 13)
        quarter_round(working_state, 2, 6, 10, 14)
        quarter_round(working_state, 3, 7, 11, 15)
        
        # 对角线操作
        quarter_round(working_state, 0, 5, 10, 15)
        quarter_round(working_state, 1, 6, 11, 12)
        quarter_round(working_state, 2, 7, 8, 13)
        quarter_round(working_state, 3, 4, 9, 14)
    
    # 与初始状态相加
    for i in range(16):
        working_state[i] = (working_state[i] + state[i]) & 0xffffffff
    
    # 返回结果
    return working_state

def quarter_round(state, a, b, c, d):
    """ChaCha20的quarter-round操作"""
    # 这是ChaCha20中XOR操作的关键应用点
    state[a] = (state[a] + state[b]) & 0xffffffff
    state[d] = rotate_left(state[d] ^ state[a], 16)
    
    state[c] = (state[c] + state[d]) & 0xffffffff
    state[b] = rotate_left(state[b] ^ state[c], 12)
    
    state[a] = (state[a] + state[b]) & 0xffffffff
    state[d] = rotate_left(state[d] ^ state[a], 8)
    
    state[c] = (state[c] + state[d]) & 0xffffffff
    state[b] = rotate_left(state[b] ^ state[c], 7)

def rotate_left(x, n):
    """32位整数左移n位"""
    return ((x << n) | (x >> (32 - n))) & 0xffffffff

def aes_add_round_key(state, round_key):
    """
    AES的密钥加步骤，使用XOR操作将轮密钥与状态矩阵混合
    """
    for i in range(4):
        for j in range(4):
            state[i][j] ^= round_key[i][j]
    return state

def simple_data_obfuscation(data, key=b'confidential'):
    """
    简单的数据混淆函数，用于非安全敏感场景
    """
    obfuscated = bytearray(len(data))
    for i in range(len(data)):
        obfuscated[i] = data[i] ^ key[i % len(key)]
    return bytes(obfuscated)

# 使用示例
original = b"Configuration setting: value123"
key = b"my_secret_key"

# 混淆数据
obfuscated = simple_data_obfuscation(original, key)
print(f"混淆后: {obfuscated.hex()}")

# 还原数据
deobfuscated = simple_data_obfuscation(obfuscated, key)
print(f"还原后: {deobfuscated.decode()}")

def advanced_obfuscation(data, key):
    """
    高级数据混淆，结合多种操作增强混淆效果
    """
    # 1. 初始XOR混淆
    temp = bytearray(len(data))
    for i in range(len(data)):
        temp[i] = data[i] ^ key[i % len(key)]
    
    # 2. 字节置换
    permutation = [5, 2, 9, 1, 7, 3, 8, 0, 4, 6]  # 示例置换表
    permuted = bytearray(len(temp))
    for i in range(len(temp)):
        permuted[i] = temp[permutation[i % len(permutation)]]
    
    # 3. 第二轮XOR混淆
    obfuscated = bytearray(len(permuted))
    for i in range(len(permuted)):
        obfuscated[i] = permuted[i] ^ key[(i+3) % len(key)]
    
    return bytes(obfuscated)

def deobfuscate(obfuscated, key):
    """
    对应的解混淆函数
    """
    # 1. 反向第二轮XOR
    temp1 = bytearray(len(obfuscated))
    for i in range(len(obfuscated)):
        temp1[i] = obfuscated[i] ^ key[(i+3) % len(key)]
    
    # 2. 反向字节置换
    permutation = [5, 2, 9, 1, 7, 3, 8, 0, 4, 6]
    inverse_permutation = [8, 3, 1, 5, 8, 0, 9, 4, 6, 2]  # 逆置换表
    temp2 = bytearray(len(temp1))
    for i in range(len(temp1)):
        temp2[i] = temp1[inverse_permutation[i % len(inverse_permutation)]]
    
    # 3. 反向初始XOR
    original = bytearray(len(temp2))
    for i in range(len(temp2)):
        original[i] = temp2[i] ^ key[i % len(key)]
    
    return bytes(original)

def parity_check(data):
    """
    计算数据的奇偶校验位
    返回True表示偶数个1，False表示奇数个1
    """
    parity = True  # 初始假设偶数个1
    for byte in data:
        for i in range(8):
            if (byte >> i) & 1:
                parity = not parity  # 每遇到一个1就翻转奇偶性
    return parity

# 使用示例
data = b"Hello, XOR world!"
parity = parity_check(data)
print(f"数据 '{data.decode()}' 的奇偶性: {'偶数' if parity else '奇数'}个1")

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def aes_encrypt(plaintext, key=None):
    """
    使用AES-GCM模式加密数据
    """
    if key is None:
        key = os.urandom(32)  # 生成256位随机密钥
    
    # 生成随机IV
    iv = os.urandom(12)  # GCM模式推荐12字节IV
    
    # 创建加密器
    encryptor = Cipher(
        algorithms.AES(key),
        modes.GCM(iv),
        backend=default_backend()
    ).encryptor()
    
    # 加密数据
    ciphertext = encryptor.update(plaintext) + encryptor.finalize()
    
    # 获取认证标签
    tag = encryptor.tag
    
    return {
        'ciphertext': ciphertext,
        'key': key,
        'iv': iv,
        'tag': tag
    }

def aes_decrypt(ciphertext, key, iv, tag):
    """
    使用AES-GCM模式解密数据
    """
    try:
        # 创建解密器
        decryptor = Cipher(
            algorithms.AES(key),
            modes.GCM(iv, tag),
            backend=default_backend()
        ).decryptor()
        
        # 解密数据
        plaintext = decryptor.update(ciphertext) + decryptor.finalize()
        return plaintext
    except Exception as e:
        print(f"解密失败: {e}")
        return None

# 使用示例
plaintext = b"这是一段需要高安全性保护的数据"
encrypted_data = aes_encrypt(plaintext)
print(f"加密成功: {encrypted_data['ciphertext'].hex()}")

decrypted = aes_decrypt(
    encrypted_data['ciphertext'],
    encrypted_data['key'],
    encrypted_data['iv'],
    encrypted_data['tag']
)
if decrypted:
    print(f"解密成功: {decrypted.decode()}")

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

def chacha20_encrypt(plaintext, key=None):
    """
    使用ChaCha20-Poly1305模式加密数据
    """
    if key is None:
        key = os.urandom(32)  # 生成256位随机密钥
    
    # 生成随机nonce
    nonce = os.urandom(12)  # ChaCha20-Poly1305推荐12字节nonce
    
    # 创建加密器
    encryptor = Cipher(
        algorithms.ChaCha20(key, nonce),
        backend=default_backend()
    ).encryptor()
    
    # 加密数据
    ciphertext = encryptor.update(plaintext) + encryptor.finalize()
    
    return {
        'ciphertext': ciphertext,
        'key': key,
        'nonce': nonce
    }

def chacha20_decrypt(ciphertext, key, nonce):
    """
    使用ChaCha20解密数据
    """
    try:
        # 创建解密器
        decryptor = Cipher(
            algorithms.ChaCha20(key, nonce),
            backend=default_backend()
        ).decryptor()
        
        # 解密数据
        plaintext = decryptor.update(ciphertext) + decryptor.finalize()
        return plaintext
    except Exception as e:
        print(f"解密失败: {e}")
        return None

# 使用示例
plaintext = b"这是使用ChaCha20加密的高安全性数据"
encrypted_data = chacha20_encrypt(plaintext)
print(f"ChaCha20加密成功: {encrypted_data['ciphertext'].hex()}")

decrypted = chacha20_decrypt(
    encrypted_data['ciphertext'],
    encrypted_data['key'],
    encrypted_data['nonce']
)
if decrypted:
    print(f"解密成功: {decrypted.decode()}")

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend

def generate_rsa_keys():
    """
    生成RSA密钥对
    """
    private_key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
        backend=default_backend()
    )
    public_key = private_key.public_key()
    return private_key, public_key

def rsa_encrypt(plaintext, public_key):
    """
    使用RSA公钥加密数据
    注意：RSA适合加密少量数据，如对称密钥
    """
    # RSA加密限制了明文大小，这里我们假设明文足够小
    ciphertext = public_key.encrypt(
        plaintext,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )
    return ciphertext

def rsa_decrypt(ciphertext, private_key):
    """
    使用RSA私钥解密数据
    """
    try:
        plaintext = private_key.decrypt(
            ciphertext,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        return plaintext
    except Exception as e:
        print(f"解密失败: {e}")
        return None

# 使用示例 (仅用于演示，实际RSA应只用于加密对称密钥等小数据)
private_key, public_key = generate_rsa_keys()

# 由于RSA加密数据大小限制，这里只加密少量数据
short_plaintext = b"Small secret message"
ciphertext = rsa_encrypt(short_plaintext, public_key)
print(f"RSA加密成功: {ciphertext.hex()[:50]}...")

decrypted = rsa_decrypt(ciphertext, private_key)
if decrypted:
    print(f"解密成功: {decrypted.decode()}")

def lattice_based_example():
    """
    格基密码学中的XOR操作示例（简化版）
    这只是一个教学示例，不代表实际格基密码学算法
    """
    # 格基向量
    basis = [
        [1, 0, 1],
        [0, 1, 1],
        [1, 1, 0]
    ]
    
    # 明文消息（二进制）
    message = [1, 0, 1]
    
    # 错误向量
    error = [0, 1, 0]
    
    # 加密过程（简化版）
    ciphertext = []
    for i in range(len(message)):
        # 计算线性组合
        linear_comb = 0
        for j in range(len(basis)):
            linear_comb += message[j] * basis[j][i]
        
        # 添加错误并进行模2运算（等效于XOR）
        ciphertext.append((linear_comb + error[i]) % 2)
    
    print(f"格基加密示例：")
    print(f"  明文: {message}")
    print(f"  错误向量: {error}")
    print(f"  密文: {ciphertext}")
    
    return ciphertext

# 运行示例
lattice_based_example()

def quantum_safe_xor_example():
    """
    量子安全上下文中的XOR操作示例
    """
    # 假设我们有一个量子安全的随机数生成器
    # 在实际应用中，这应该是一个经过认证的量子随机数源
    def quantum_random_bit():
        # 示例函数，返回模拟的量子随机位
        import random
        return random.randint(0, 1)
    
    # 生成量子安全的一次性密钥
    def generate_quantum_safe_key(length):
        return [quantum_random_bit() for _ in range(length)]
    
    # 量子安全的一次性密码本加密（使用XOR）
    message = [1, 0, 1, 1, 0, 0, 1, 0]
    key = generate_quantum_safe_key(len(message))
    
    # XOR加密
    ciphertext = [(m ^ k) for m, k in zip(message, key)]
    
    # XOR解密
    decrypted = [(c ^ k) for c, k in zip(ciphertext, key)]
    
    print(f"量子安全XOR加密示例：")
    print(f"  明文: {message}")
    print(f"  密钥: {key}")
    print(f"  密文: {ciphertext}")
    print(f"  解密: {decrypted}")
    
    # 在量子安全场景中，密钥必须：
    # 1. 真正随机（非伪随机）
    # 2. 长度与消息相同
    # 3. 只使用一次
    # 4. 安全地分发给通信双方
    
# 运行示例
quantum_safe_xor_example()

def recommend_encryption_method(scenario, security_level, data_size):
    """
    根据场景推荐合适的加密方法
    """
    if security_level == "low" and scenario in ["data_obfuscation", "internal_debug"]:
        return "XOR加密（适合非安全敏感场景）"
    elif security_level == "medium" and scenario in ["data_storage", "network_communication"]:
        if data_size < 1024:  # 小数据
            return "AES-GCM（128位密钥）"
        else:  # 大数据
            return "ChaCha20-Poly1305（性能更好）"
    elif security_level == "high":
        if scenario == "key_exchange":
            return "RSA（2048位）或ECDHE（椭圆曲线Diffie-Hellman）"
        elif scenario == "data_storage" or scenario == "network_communication":
            return "AES-GCM（256位密钥）"
        elif scenario == "digital_signature":
            return "RSA-SHA256或ECDSA"
    elif security_level == "quantum_resistant":
        return "后量子密码学算法（如CRYSTALS-Kyber、NTRU）"
    
    return "根据具体需求定制加密方案"

# 使用示例
print("加密方法推荐：")
print(f"  内部配置混淆（低安全）: {recommend_encryption_method('data_obfuscation', 'low', 100)}")
print(f"  数据存储（中等安全，大数据）: {recommend_encryption_method('data_storage', 'medium', 1000000)}")
print(f"  银行通信（高安全）: {recommend_encryption_method('network_communication', 'high', 1000)}")
print(f"  未来量子安全需求: {recommend_encryption_method('general', 'quantum_resistant', 1000)}")