12.加密模块

框架 > Unity框架 > 基础框架框架 Unity框架基础框架

发布时间 : 2025-10-29 08:45

字数:5.5k 阅读 :

评论:

12.加密模块
1. 12.1 知识点
2. 12.2 知识点代码

12.加密模块

12.1 知识点

加密模块的作用

在游戏开发中，数据安全是一个重要的问题。玩家可能使用内存修改器（如Cheat Engine）来修改游戏数据，实现作弊效果。

常见的作弊场景：

修改玩家金币：直接修改内存中的金币数值
修改玩家血量：让角色变无敌
修改游戏分数：刷排行榜
修改角色属性：增加攻击力、防御力等

问题根源：

内存中的数据是明文存储的：玩家可以直接在内存中看到和修改数值
缺乏防护机制：没有对存储的数据进行加密
容易被检测：使用修改器容易找到并修改相关数值

解决方案：
通过在内存中对关键数据进行加密存储，即使玩家使用修改器找到了内存地址，也无法直接修改或理解数据的真实值。

主要功能：

数据加密：将明文数据加密后存储在内存中
数据解密：需要使用时将加密数据解密还原
随机密钥：为每个对象生成唯一密钥，增强安全性
异或加密：使用简单高效的异或加密算法

加密模块的基本原理

设计理念：

透明加密：对使用方透明，不需要关心具体加密实现
高效加密：使用异或等位运算，加密解密速度快
随机密钥：每个对象使用不同密钥，防止全局破解
可逆操作：加密和解密必须是对称的可逆操作

工作原理：

初始化时生成密钥：每个数据对象创建时生成随机密钥
写入时加密：设置值的时候，先加密再存储
读取时解密：获取值的时候，先解密再返回
内存中存储密文：实际内存中存储的是加密后的值

加密模块实现

为什么需要加密模块

传统数据存储方式的问题：

// 传统方式：直接存储明文数据
public class Player
{
    private int hp = 100;
    private int atk = 50;
    
    public int HP
    {
        get { return hp; }
        set { hp = value; }
    }
}

存在的问题：

内存明文存储：使用Cheat Engine可以直接搜索到100、50这样的值
容易被修改：玩家可以轻松将100改成99999
缺乏保护：没有任何防止修改的机制

加密后的数据存储方式：

// 加密方式：存储加密后的数据
public class Player
{
    private int encryptedHp;
    private int key;
    
    public Player()
    {
        key = EncryptionUtil.GetRandomKey(); // 生成随机密钥
    }
    
    public int HP
    {
        get 
        { 
            // 读取时解密
            return EncryptionUtil.UnLockValue(encryptedHp, key); 
        }
        set 
        { 
            // 写入时加密
            encryptedHp = EncryptionUtil.LockValue(value, key); 
        }
    }
}

优势：

内存中存储密文：实际存储的是加密后的值，如”12345678”
难以理解：玩家不知道真实值是什么
难以修改：即使修改了，也不容易算出正确的加密值

加密模块实现

核心思想：使用异或加密

异或运算的特点：

A ^ B ^ B = A（异或两次会还原）
加密和解密可以使用相同的算法

EncryptionUtil实现：EncryptionUtil.cs

using UnityEngine;

/// <summary>
/// 加密工具类
/// 主要提供加密需求
/// </summary>
public class EncryptionUtil
{
    /// <summary>
    /// 获取随机密钥
    /// </summary>
    /// <returns>返回1-10000之间的随机密钥</returns>
    public static int GetRandomKey()
    {
        return Random.Range(1, 10000) + 5;
    }

    /// <summary>
    /// 加密int数据
    /// </summary>
    /// <param name="value">要加密的值</param>
    /// <param name="key">加密密钥</param>
    /// <returns>加密后的值</returns>
    public static int LockValue(int value, int key)
    {
        // 主要采用异或加密
        value = value ^ (key % 9);
        value = value ^ 0xADAD;
        value = value ^ (1 << 5);
        value += key;
        return value;
    }

    /// <summary>
    /// 加密long数据
    /// </summary>
    /// <param name="value">要加密的值</param>
    /// <param name="key">加密密钥</param>
    /// <returns>加密后的值</returns>
    public static long LockValue(long value, int key)
    {
        // 主要采用异或加密
        value = value ^ (key % 9);
        value = value ^ 0xADAD;
        value = value ^ (1 << 5);
        value += key;
        return value;
    }

    /// <summary>
    /// 解密int数据
    /// </summary>
    /// <param name="value">要解密的值</param>
    /// <param name="key">解密密钥</param>
    /// <returns>解密后的值</returns>
    public static int UnLockValue(int value, int key)
    {
        // 有可能还没有加密过 没有初始化过的数据 直接想要获取 那么就不用解密了
        // 这种时候数值肯定是0
        if (value == 0)
            return value;
        
        // 逆向操作还原数据（操作顺序相反）
        value -= key;
        value = value ^ (1 << 5);
        value = value ^ 0xADAD;
        value = value ^ (key % 9);
        return value;
    }

    /// <summary>
    /// 解密long数据
    /// </summary>
    /// <param name="value">要解密的值</param>
    /// <param name="key">解密密钥</param>
    /// <returns>解密后的值</returns>
    public static long UnLockValue(long value, int key)
    {
        // 有可能还没有加密过 没有初始化过的数据 直接想要获取 那么就不用解密了
        // 这种时候数值肯定是0
        if (value == 0)
            return value;
        
        // 逆向操作还原数据（操作顺序相反）
        value -= key;
        value = value ^ (1 << 5);
        value = value ^ 0xADAD;
        value = value ^ (key % 9);
        return value;
    }
}

加密流程说明：

// 假设要加密的值是 100，密钥是 999
int value = 100;
int key = 999;

// 加密步骤：
// 1. value = 100 ^ (999 % 9) = 100 ^ 3
// 2. value = value ^ 0xADAD
// 3. value = value ^ (1 << 5) = value ^ 32
// 4. value = value + 999

// 解密步骤（逆向）：
// 1. value = value - 999
// 2. value = value ^ 32
// 3. value = value ^ 0xADAD
// 4. value = value ^ 3
// 5. 得到原始值 100

加密算法的组成部分：

**^ (key % 9)**：使用密钥的模9值进行异或
**^ 0xADAD**：使用固定值0xADAD进行异或（混淆）
**^ (1 << 5)**：使用32（2的5次方）进行异或（再次混淆）
**+= key**：加上密钥值（增加复杂性）

这样设计的好处：

多层加密：多次异或和加法操作，增加破解难度
密钥相关：加密结果与密钥相关，不同对象有不同的密文
可逆操作：所有操作都可以逆向，保证能正确解密

加密模块使用示例

基础使用示例：

using UnityEngine;

/// <summary>
/// 加密模块使用示例
/// </summary>
public class EncryptionExample : MonoBehaviour
{
    void Start()
    {
        // 创建玩家对象
        Player player = new Player();
        
        // 设置血量
        player.HP = 100;
        Debug.Log($"设置血量：100");
        
        // 获取血量（会解密）
        int currentHP = player.HP;
        Debug.Log($"当前血量：{currentHP}");
        // 输出：当前血量：100
        
        // 修改血量
        player.HP = 80;
        Debug.Log($"修改后血量：{player.HP}");
        // 输出：修改后血量：80
    }
}

/// <summary>
/// 玩家类（带加密保护）
/// </summary>
public class Player
{
    private int encryptedHp;
    private int encryptedAtk;
    private int encryptedMoney;
    
    /// <summary>
    /// 加密密钥
    /// </summary>
    private int key;

    public Player()
    {
        // 初始化时生成随机密钥
        key = EncryptionUtil.GetRandomKey();
        Debug.Log($"生成密钥：{key}");
    }

    /// <summary>
    /// 血量（加密属性）
    /// </summary>
    public int HP
    {
        get
        {
            // 读取时解密
            return EncryptionUtil.UnLockValue(encryptedHp, key);
        }
        set
        {
            // 写入时加密
            encryptedHp = EncryptionUtil.LockValue(value, key);
        }
    }

    /// <summary>
    /// 攻击力（加密属性）
    /// </summary>
    public int Atk
    {
        get
        {
            return EncryptionUtil.UnLockValue(encryptedAtk, key);
        }
        set
        {
            encryptedAtk = EncryptionUtil.LockValue(value, key);
        }
    }

    /// <summary>
    /// 金币（加密属性）
    /// </summary>
    public int Money
    {
        get
        {
            return EncryptionUtil.UnLockValue(encryptedMoney, key);
        }
        set
        {
            encryptedMoney = EncryptionUtil.LockValue(value, key);
        }
    }
}

实际应用场景：

using UnityEngine;

/// <summary>
/// 加密模块实际应用示例
/// </summary>
public class EncryptionUsageExample : MonoBehaviour
{
    void Start()
    {
        // 测试加密功能
        TestEncryption();
        
        // 测试玩家数据加密
        TestPlayerEncryption();
    }

    /// <summary>
    /// 测试加密功能
    /// </summary>
    private void TestEncryption()
    {
        Debug.Log("=== 测试加密功能 ===");
        
        int key = EncryptionUtil.GetRandomKey();
        Debug.Log($"生成密钥：{key}");
        
        // 测试加密和解密
        int originalValue = 100;
        int encryptedValue = EncryptionUtil.LockValue(originalValue, key);
        int decryptedValue = EncryptionUtil.UnLockValue(encryptedValue, key);
        
        Debug.Log($"原始值：{originalValue}");
        Debug.Log($"加密后：{encryptedValue}");
        Debug.Log($"解密后：{decryptedValue}");
        
        // 输出：
        // 原始值：100
        // 加密后：某个随机的大数字（每次不同）
        // 解密后：100
        
        Debug.Log(originalValue == decryptedValue ? "✓ 加密解密成功" : "✗ 加密解密失败");
    }

    /// <summary>
    /// 测试玩家数据加密
    /// </summary>
    private void TestPlayerEncryption()
    {
        Debug.Log("=== 测试玩家数据加密 ===");
        
        GamePlayer player = new GamePlayer();
        
        // 设置玩家属性
        player.Level = 10;
        player.Exp = 1000;
        player.Gold = 5000;
        player.Diamond = 100;
        
        Debug.Log($"玩家等级：{player.Level}");
        Debug.Log($"玩家经验：{player.Exp}");
        Debug.Log($"玩家金币：{player.Gold}");
        Debug.Log($"玩家钻石：{player.Diamond}");
        
        // 模拟多次读写
        player.Gold += 1000;
        Debug.Log($"增加金币后：{player.Gold}");
    }
}

/// <summary>
/// 游戏玩家数据（加密保护）
/// </summary>
public class GamePlayer
{
    private int encryptedLevel;
    private int encryptedExp;
    private int encryptedGold;
    private int encryptedDiamond;
    
    private int key;

    public GamePlayer()
    {
        key = EncryptionUtil.GetRandomKey();
    }

    public int Level
    {
        get { return EncryptionUtil.UnLockValue(encryptedLevel, key); }
        set { encryptedLevel = EncryptionUtil.LockValue(value, key); }
    }

    public int Exp
    {
        get { return EncryptionUtil.UnLockValue(encryptedExp, key); }
        set { encryptedExp = EncryptionUtil.LockValue(value, key); }
    }

    public int Gold
    {
        get { return EncryptionUtil.UnLockValue(encryptedGold, key); }
        set { encryptedGold = EncryptionUtil.LockValue(value, key); }
    }

    public int Diamond
    {
        get { return EncryptionUtil.UnLockValue(encryptedDiamond, key); }
        set { encryptedDiamond = EncryptionUtil.LockValue(value, key); }
    }
}

加密模块进阶优化

当前实现的问题：

加密强度较低：异或加密对专业破解者来说不够强
密钥管理简单：只有一个密钥，如果密钥泄露，所有数据都暴露
不支持字符串：只能加密int和long类型

进阶优化建议：

using UnityEngine;
using System.Text;

/// <summary>
/// 增强型加密工具类
/// </summary>
public class AdvancedEncryptionUtil
{
    /// <summary>
    /// 加密字符串
    /// </summary>
    public static string LockString(string value, int key)
    {
        if (string.IsNullOrEmpty(value))
            return value;
        
        byte[] bytes = Encoding.UTF8.GetBytes(value);
        for (int i = 0; i < bytes.Length; i++)
        {
            bytes[i] = (byte)(bytes[i] ^ (key % 256));
        }
        
        return System.Convert.ToBase64String(bytes);
    }

    /// <summary>
    /// 解密字符串
    /// </summary>
    public static string UnLockString(string value, int key)
    {
        if (string.IsNullOrEmpty(value))
            return value;
        
        try
        {
            byte[] bytes = System.Convert.FromBase64String(value);
            for (int i = 0; i < bytes.Length; i++)
            {
                bytes[i] = (byte)(bytes[i] ^ (key % 256));
            }
            return Encoding.UTF8.GetString(bytes);
        }
        catch
        {
            return value;
        }
    }

    /// <summary>
    /// 加密float类型
    /// </summary>
    public static float LockFloat(float value, int key)
    {
        // 将float转换为int进行加密
        int intValue = System.BitConverter.ToInt32(BitConverter.GetBytes(value), 0);
        int encrypted = EncryptionUtil.LockValue(intValue, key);
        byte[] bytes = BitConverter.GetBytes(encrypted);
        return BitConverter.ToSingle(bytes, 0);
    }

    /// <summary>
    /// 解密float类型
    /// </summary>
    public static float UnLockFloat(float value, int key)
    {
        // 将加密的float转换为int进行解密
        int intValue = System.BitConverter.ToInt32(BitConverter.GetBytes(value), 0);
        int decrypted = EncryptionUtil.UnLockValue(intValue, key);
        byte[] bytes = BitConverter.GetBytes(decrypted);
        return BitConverter.ToSingle(bytes, 0);
    }
}

多密钥管理：

using UnityEngine;

/// <summary>
/// 多密钥加密数据
/// 为每个属性使用不同的密钥
/// </summary>
public class SecurePlayerData
{
    // 每个属性使用不同的密钥
    private int key1;
    private int key2;
    private int key3;
    
    private int encryptedHp;
    private int encryptedAtk;
    private int encryptedDef;

    public SecurePlayerData()
    {
        // 初始化多个密钥
        key1 = EncryptionUtil.GetRandomKey();
        key2 = EncryptionUtil.GetRandomKey();
        key3 = EncryptionUtil.GetRandomKey();
    }

    public int HP
    {
        get { return EncryptionUtil.UnLockValue(encryptedHp, key1); }
        set { encryptedHp = EncryptionUtil.LockValue(value, key1); }
    }

    public int Atk
    {
        get { return EncryptionUtil.UnLockValue(encryptedAtk, key2); }
        set { encryptedAtk = EncryptionUtil.LockValue(value, key2); }
    }

    public int Def
    {
        get { return EncryptionUtil.UnLockValue(encryptedDef, key3); }
        set { encryptedDef = EncryptionUtil.LockValue(value, key3); }
    }
}

测试和使用

完整的测试示例：

using UnityEngine;

/// <summary>
/// 加密模块完整测试
/// </summary>
public class EncryptionCompleteTest : MonoBehaviour
{
    void Start()
    {
        // 测试基本加密解密
        TestBasicEncryption();
        
        // 测试玩家数据加密
        TestPlayerDataEncryption();
        
        // 测试多次读写
        TestMultipleReadWrite();
        
        // 测试不同对象
        TestMultipleObjects();
    }

    /// <summary>
    /// 测试基本加密解密
    /// </summary>
    private void TestBasicEncryption()
    {
        Debug.Log("=== 测试基本加密解密 ===");
        
        int[] testValues = { 0, 1, 100, 999, 10000 };
        int key = 123;
        
        foreach (int originalValue in testValues)
        {
            int encrypted = EncryptionUtil.LockValue(originalValue, key);
            int decrypted = EncryptionUtil.UnLockValue(encrypted, key);
            
            Debug.Log($"原始: {originalValue} -> 加密: {encrypted} -> 解密: {decrypted}");
            
            if (originalValue != decrypted)
            {
                Debug.LogError($"加密解密失败！原始值: {originalValue}, 解密值: {decrypted}");
            }
        }
        
        Debug.Log("基本加密解密测试完成");
    }

    /// <summary>
    /// 测试玩家数据加密
    /// </summary>
    private void TestPlayerDataEncryption()
    {
        Debug.Log("=== 测试玩家数据加密 ===");
        
        Player player = new Player();
        player.HP = 100;
        player.Atk = 50;
        player.Money = 1000;
        
        Debug.Log($"玩家HP: {player.HP}（正确值应该是100）");
        Debug.Log($"玩家Atk: {player.Atk}（正确值应该是50）");
        Debug.Log($"玩家Money: {player.Money}（正确值应该是1000）");
        
        // 验证值是否正确
        bool success = player.HP == 100 && player.Atk == 50 && player.Money == 1000;
        Debug.Log(success ? "✓ 玩家数据加密测试通过" : "✗ 玩家数据加密测试失败");
    }

    /// <summary>
    /// 测试多次读写
    /// </summary>
    private void TestMultipleReadWrite()
    {
        Debug.Log("=== 测试多次读写 ===");
        
        Player player = new Player();
        
        // 多次读写操作
        for (int i = 0; i < 10; i++)
        {
            player.HP = 100 - i;
            int readValue = player.HP;
            
            if (readValue != 100 - i)
            {
                Debug.LogError($"多次读写失败！期望: {100 - i}, 实际: {readValue}");
                return;
            }
        }
        
        Debug.Log("✓ 多次读写测试通过");
    }

    /// <summary>
    /// 测试不同对象
    /// </summary>
    private void TestMultipleObjects()
    {
        Debug.Log("=== 测试不同对象 ===");
        
        Player player1 = new Player();
        Player player2 = new Player();
        
        // 设置相同的初始值
        player1.HP = 100;
        player2.HP = 100;
        
        // 应该都能正确读取
        bool success = player1.HP == 100 && player2.HP == 100;
        
        if (success)
        {
            Debug.Log("✓ 不同对象加密测试通过");
            Debug.Log($"玩家1 HP: {player1.HP}");
            Debug.Log($"玩家2 HP: {player2.HP}");
        }
        else
        {
            Debug.LogError("✗ 不同对象加密测试失败");
        }
    }
}

进阶和拓展

进阶优化建议：

AES加密：对于高价值数据使用AES等高级加密算法
密钥派生：使用PBKDF2等算法派生更复杂的密钥
数据完整性校验：使用HMAC等机制验证数据未被篡改
混淆保护：对关键代码进行混淆，防止逆向工程
服务端校验：关键数据在服务端进行二次校验
反调试机制：检测调试器和修改器
运行时加密：在运行时动态生成和销毁密钥

注意事项：

性能影响：加密解密会有一定的性能开销
不适用于所有数据：频繁更新的数据（如帧率）不适合加密
内存占用：加密数据和密钥都会占用额外内存
不能完全防止：专业的破解者仍然可能通过内存分析破解
密钥管理：密钥的生成和存储需要谨慎处理

最佳实践：

只加密关键数据：如金币、钻石、血量等重要属性
配合服务端校验：本地加密要配合服务端的数据校验
定期更换密钥：在合适的时机更换加密密钥
多层防护：加密 + 校验 + 混淆 + 反调试
性能权衡：根据游戏类型和需求选择合适的加密强度

12.2 知识点代码

EncryptionUtil.cs（加密工具类 - 最终版本）

using UnityEngine;

/// <summary>
/// 加密工具类
/// 主要提供加密需求
/// </summary>
public class EncryptionUtil
{
    /// <summary>
    /// 获取随机密钥
    /// 生成1-10004之间的随机整数
    /// </summary>
    /// <returns>返回随机密钥</returns>
    public static int GetRandomKey()
    {
        return Random.Range(1, 10000) + 5;
    }

    /// <summary>
    /// 加密int数据
    /// 使用异或加密算法进行多层加密
    /// </summary>
    /// <param name="value">要加密的值</param>
    /// <param name="key">加密密钥</param>
    /// <returns>加密后的值</returns>
    public static int LockValue(int value, int key)
    {
        // 主要采用异或加密
        value = value ^ (key % 9);
        value = value ^ 0xADAD;
        value = value ^ (1 << 5);
        value += key;
        return value;
    }

    /// <summary>
    /// 加密long数据
    /// 使用异或加密算法进行多层加密
    /// </summary>
    /// <param name="value">要加密的值</param>
    /// <param name="key">加密密钥</param>
    /// <returns>加密后的值</returns>
    public static long LockValue(long value, int key)
    {
        // 主要采用异或加密
        value = value ^ (key % 9);
        value = value ^ 0xADAD;
        value = value ^ (1 << 5);
        value += key;
        return value;
    }

    /// <summary>
    /// 解密int数据
    /// 逆向执行加密操作还原数据
    /// </summary>
    /// <param name="value">要解密的值</param>
    /// <param name="key">解密密钥</param>
    /// <returns>解密后的值</returns>
    public static int UnLockValue(int value, int key)
    {
        // 有可能还没有加密过 没有初始化过的数据 直接想要获取 那么就不用解密了
        // 这种时候数值肯定是0
        if (value == 0)
            return value;
        
        // 逆向操作还原数据（操作顺序相反）
        value -= key;
        value = value ^ (1 << 5);
        value = value ^ 0xADAD;
        value = value ^ (key % 9);
        return value;
    }

    /// <summary>
    /// 解密long数据
    /// 逆向执行加密操作还原数据
    /// </summary>
    /// <param name="value">要解密的值</param>
    /// <param name="key">解密密钥</param>
    /// <returns>解密后的值</returns>
    public static long UnLockValue(long value, int key)
    {
        // 有可能还没有加密过 没有初始化过的数据 直接想要获取 那么就不用解密了
        // 这种时候数值肯定是0
        if (value == 0)
            return value;
        
        // 逆向操作还原数据（操作顺序相反）
        value -= key;
        value = value ^ (1 << 5);
        value = value ^ 0xADAD;
        value = value ^ (key % 9);
        return value;
    }
}

SecurePlayer.cs（加密玩家数据类）

using UnityEngine;

/// <summary>
/// 带加密保护的玩家数据类
/// </summary>
public class SecurePlayer
{
    #region 私有字段

    /// <summary>
    /// 加密密钥
    /// </summary>
    private int key;

    /// <summary>
    /// 加密后的血量
    /// </summary>
    private int encryptedHp;

    /// <summary>
    /// 加密后的攻击力
    /// </summary>
    private int encryptedAtk;

    /// <summary>
    /// 加密后的防御力
    /// </summary>
    private int encryptedDef;

    /// <summary>
    /// 加密后的金币
    /// </summary>
    private int encryptedGold;

    #endregion

    #region 构造函数

    /// <summary>
    /// 构造函数
    /// 初始化时生成随机密钥
    /// </summary>
    public SecurePlayer()
    {
        key = EncryptionUtil.GetRandomKey();
        Debug.Log($"玩家密钥生成：{key}");
    }

    #endregion

    #region 公开属性

    /// <summary>
    /// 血量（加密属性）
    /// </summary>
    public int HP
    {
        get { return EncryptionUtil.UnLockValue(encryptedHp, key); }
        set { encryptedHp = EncryptionUtil.LockValue(value, key); }
    }

    /// <summary>
    /// 攻击力（加密属性）
    /// </summary>
    public int Atk
    {
        get { return EncryptionUtil.UnLockValue(encryptedAtk, key); }
        set { encryptedAtk = EncryptionUtil.LockValue(value, key); }
    }

    /// <summary>
    /// 防御力（加密属性）
    /// </summary>
    public int Def
    {
        get { return EncryptionUtil.UnLockValue(encryptedDef, key); }
        set { encryptedDef = EncryptionUtil.LockValue(value, key); }
    }

    /// <summary>
    /// 金币（加密属性）
    /// </summary>
    public int Gold
    {
        get { return EncryptionUtil.UnLockValue(encryptedGold, key); }
        set { encryptedGold = EncryptionUtil.LockValue(value, key); }
    }

    #endregion
}

EncryptionModuleTest.cs（加密模块测试）

using UnityEngine;

/// <summary>
/// 加密模块完整测试
/// </summary>
public class EncryptionModuleTest : MonoBehaviour
{
    #region 生命周期

    void Start()
    {
        Debug.Log("=== 加密模块测试 ===");
        
        // 测试基本加密解密
        TestBasicEncryption();
        
        // 测试玩家数据加密
        TestPlayerDataEncryption();
        
        // 测试多次读写
        TestMultipleReadWrite();
        
        // 测试不同对象
        TestMultipleObjects();
    }

    #endregion

    #region 测试方法

    /// <summary>
    /// 测试基本加密解密
    /// </summary>
    private void TestBasicEncryption()
    {
        Debug.Log("--- 测试1：基本加密解密 ---");
        
        int[] testValues = { 0, 1, 100, 999, 10000, -100 };
        int key = EncryptionUtil.GetRandomKey();
        
        Debug.Log($"使用密钥：{key}");
        
        foreach (int originalValue in testValues)
        {
            int encrypted = EncryptionUtil.LockValue(originalValue, key);
            int decrypted = EncryptionUtil.UnLockValue(encrypted, key);
            
            Debug.Log($"原始: {originalValue} -> 加密: {encrypted} -> 解密: {decrypted}");
            
            if (originalValue != decrypted)
            {
                Debug.LogError($"✗ 加密解密失败！原始值: {originalValue}, 解密值: {decrypted}");
            }
        }
        
        Debug.Log("✓ 基本加密解密测试完成");
    }

    /// <summary>
    /// 测试玩家数据加密
    /// </summary>
    private void TestPlayerDataEncryption()
    {
        Debug.Log("--- 测试2：玩家数据加密 ---");
        
        SecurePlayer player = new SecurePlayer();
        
        // 设置玩家属性
        player.HP = 100;
        player.Atk = 50;
        player.Def = 30;
        player.Gold = 1000;
        
        // 读取并验证
        bool success = player.HP == 100 && player.Atk == 50 && 
                       player.Def == 30 && player.Gold == 1000;
        
        if (success)
        {
            Debug.Log("✓ 玩家数据加密测试通过");
            Debug.Log($"玩家HP: {player.HP}");
            Debug.Log($"玩家Atk: {player.Atk}");
            Debug.Log($"玩家Def: {player.Def}");
            Debug.Log($"玩家Gold: {player.Gold}");
        }
        else
        {
            Debug.LogError("✗ 玩家数据加密测试失败");
        }
    }

    /// <summary>
    /// 测试多次读写
    /// </summary>
    private void TestMultipleReadWrite()
    {
        Debug.Log("--- 测试3：多次读写 ---");
        
        SecurePlayer player = new SecurePlayer();
        player.HP = 100;
        
        // 模拟多次读写操作
        for (int i = 0; i < 10; i++)
        {
            player.HP = 100 - i;
            int readValue = player.HP;
            
            if (readValue != 100 - i)
            {
                Debug.LogError($"✗ 多次读写失败！期望: {100 - i}, 实际: {readValue}");
                return;
            }
        }
        
        Debug.Log("✓ 多次读写测试通过");
    }

    /// <summary>
    /// 测试不同对象
    /// </summary>
    private void TestMultipleObjects()
    {
        Debug.Log("--- 测试4：不同对象 ---");
        
        SecurePlayer player1 = new SecurePlayer();
        SecurePlayer player2 = new SecurePlayer();
        
        // 设置相同的初始值
        player1.HP = 100;
        player1.Gold = 500;
        
        player2.HP = 100;
        player2.Gold = 500;
        
        // 验证每个对象的数据
        bool success = player1.HP == 100 && player2.HP == 100 &&
                       player1.Gold == 500 && player2.Gold == 500;
        
        if (success)
        {
            Debug.Log("✓ 不同对象加密测试通过");
            Debug.Log($"玩家1 HP: {player1.HP}, Gold: {player1.Gold}");
            Debug.Log($"玩家2 HP: {player2.HP}, Gold: {player2.Gold}");
        }
        else
        {
            Debug.LogError("✗ 不同对象加密测试失败");
        }
    }

    #endregion
}

EncryptionUsageExample.cs（加密模块使用示例）

using UnityEngine;

/// <summary>
/// 加密模块实际使用示例
/// </summary>
public class EncryptionUsageExample : MonoBehaviour
{
    private SecurePlayer player;
    
    void Start()
    {
        Debug.Log("=== 加密模块使用示例 ===");
        
        // 初始化玩家
        InitializePlayer();
        
        // 演示各种操作
        DemonstrateOperations();
    }

    /// <summary>
    /// 初始化玩家
    /// </summary>
    private void InitializePlayer()
    {
        player = new SecurePlayer();
        player.HP = 100;
        player.Atk = 50;
        player.Def = 30;
        player.Gold = 1000;
        
        Debug.Log("玩家初始化完成");
        Debug.Log($"初始HP: {player.HP}, Atk: {player.Atk}, Def: {player.Def}, Gold: {player.Gold}");
    }

    /// <summary>
    /// 演示各种操作
    /// </summary>
    private void DemonstrateOperations()
    {
        // 1. 增加金币
        Debug.Log("--- 操作1：增加金币 ---");
        player.Gold += 500;
        Debug.Log($"增加500金币后：{player.Gold}");
        
        // 2. 扣除血量
        Debug.Log("--- 操作2：扣除血量 ---");
        player.HP -= 20;
        Debug.Log($"扣除20血量后：{player.HP}");
        
        // 3. 升级攻击力
        Debug.Log("--- 操作3：升级攻击力 ---");
        player.Atk += 10;
        Debug.Log($"增加10攻击力后：{player.Atk}");
        
        // 4. 购买装备（消耗金币和增加防御）
        Debug.Log("--- 操作4：购买装备 ---");
        if (player.Gold >= 300)
        {
            player.Gold -= 300;
            player.Def += 15;
            Debug.Log($"购买装备消耗300金币，增加15防御");
            Debug.Log($"当前金币: {player.Gold}, 当前防御: {player.Def}");
        }
    }
}

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 785293209@qq.com