Unity

Unity 游戏的核心逻辑通常位于 C# 编译的 DLL（Mono）或 C++ 编译的 IL2CPP 文件中

编译方式

方式 脚本后端 包含文件 难度
Mono C# → IL → .NET DLL Assembly-CSharp.dll 等 低
IL2CPP C# → IL → C++ → 原生代码 libil2cpp.so / GameAssembly.dll + global-metadata.dat 较高

实战案例

Mine Sweeping（Unity）

pasted_1784452494440_ldg9s1.png

打开附件可以看到这是一个 Unity 游戏，Unity C# 题的核心逻辑通常都在 Mine Sweeping_Data/Managed/Assembly-CSharp.dll

直接用 dnSpy 反编译，其中

1
2
Elements    单个格子的逻辑
Grids       整个扫雷棋盘的逻辑

pasted_1784485727027_csth12.png

在 Elements.Awake() 中有一段非常关键的判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private void Awake()
{
    // 获取当前对象的网格坐标
    int num = (int)base.transform.position.x;
    int num2 = (int)base.transform.position.y;

    // 通过异或和运算判断该格是否为“雷”
    // 条件：(MayWorldBeAtPeace[x,y] ^ AreYouFerryMen[x,y] - 233) / 2333 == 1
    this.bIsMine = (((Elements.MayWorldBeAtPeace[num, num2] ^ Elements.AreYouFerryMen[num, num2]) - 233) / 2333 == 1);

    // 将当前对象注册到网格管理器
    Grids._instance.eleGrids[(int)base.transform.position.x, (int)base.transform.position.y] = this;
    // 标记该格的状态（1 为雷，0 为安全）
    Grids._instance.DevilsInHeaven[(int)base.transform.position.x, (int)base.transform.position.y] = (this.bIsMine ? 1 : 0);

    // 隐藏重置按钮，防止棋盘被重置
    this.resetButton = GameObject.FindGameObjectWithTag("resetButton");
    if (this.resetButton)
    {
        this.resetButton.SetActive(false);
    }
}

也就是 “雷” 的生成逻辑是先异或，再减 233，再整除 2333

思路一是通过这一步直接逆向写脚本生成所有雷所在的位置，但是很麻烦，我们可以直接 patch 游戏逻辑

比如修改 OnMouseUpAsButton()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
private void OnMouseUpAsButton()
{
    // 检查游戏是否已经结束，并且当前格子是否还没有被翻开
    // bGameEnd 为 true 表示游戏已结束（赢或输），bIsOpen 为 true 表示该格子已翻开
    if (!Grids._instance.bGameEnd && !this.bIsOpen)
    {
        // 将当前格子标记为已翻开，防止重复点击
        this.bIsOpen = true;

        // 获取当前格子在网格中的坐标（x, y），使用世界坐标的整数部分
        int num = (int)base.transform.position.x;   // 列索引 x
        int num2 = (int)base.transform.position.y;  // 行索引 y

        // 根据 Awake 中计算出的 bIsMine 来判断是否踩雷
        if (this.bIsMine)
        {
            // ---------- 踩到地雷的处理 ----------
            // 调用 SafeAndThunder(0) 显示地雷的视觉表现（参数 0 可能代表雷）
            this.SafeAndThunder(0);

            // 设置游戏结束标志，并调用 GameLose() 执行失败逻辑（如显示所有雷）
            Grids._instance.bGameEnd = true;
            Grids._instance.GameLose();

            // 在控制台输出失败信息（调试用）
            MonoBehaviour.print("game over: lose");
        }
        else
        {
            // ---------- 安全格子的处理 ----------
            // 计算当前格子周围 8 个方向的地雷数量
            int adjcent = Grids._instance.CountAdjcentNum(num, num2);

            // 显示周围雷数（若为 0 则可能显示空白）
            this.SafeAndThunder(adjcent);

            // 触发 Flood Fill 自动翻开相邻的安全格子（传入一个表示已访问格的布尔数组）
            // 这里数组大小 29x29 可能对应游戏网格尺寸（索引 0-28）
            Grids._instance.Flush(num, num2, new bool[29, 29]);
        }

        // 每次翻开操作后都检查是否满足胜利条件
        if (Grids._instance.GameWin())
        {
            // 所有安全格子都被翻开，游戏胜利
            Grids._instance.bGameEnd = true;
            MonoBehaviour.print("game over: win");
        }
    }
}

我们可以完全取消输赢判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
using System;
using UnityEngine;

// Token: 0x02000003 RID: 3
public partial class Elements : MonoBehaviour
{
	// Token: 0x0600000A RID: 10
	private void OnMouseUpAsButton()
	{
		if (!this.bIsOpen)
		{
			this.bIsOpen = true;

			int x = (int)base.transform.position.x;
			int y = (int)base.transform.position.y;

			if (this.bIsMine)
			{
				// 雷格显示雷
				this.SafeAndThunder(0);
			}
			else
			{
				// 安全格显示周围雷数
				int adjcent = Grids._instance.CountAdjcentNum(x, y);
				this.SafeAndThunder(adjcent);
			}
		}
	}
}

pasted_1784488161284_1ycf9b.png

最后保存模块

pasted_1784487968933_vypkh6.png

这样子最后会得到一张二维码图片，但还是需要手动点击

pasted_1784488210922_j8h85y.png

熟悉这个流程过后我们可以直接修改 Elements.Awake() 逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private void Awake()
{
    int num = (int)base.transform.position.x;
    int num2 = (int)base.transform.position.y;

    this.bIsMine =
        (((Elements.MayWorldBeAtPeace[num, num2] ^
           Elements.AreYouFerryMen[num, num2]) - 233) / 2333 == 1);

    Grids._instance.eleGrids[num, num2] = this;
    Grids._instance.DevilsInHeaven[num, num2] = this.bIsMine ? 1 : 0;

    // 新增：初始化时直接显示雷
    if (this.bIsMine)
    {
        this.SafeAndThunder(0);
    }

    this.resetButton = GameObject.FindGameObjectWithTag("resetButton");
    if (this.resetButton)
    {
        this.resetButton.SetActive(false);
    }
}

pasted_1784488438600_j1s3hm.png

最后得到 flag：de1ctf{G3t_F1@g_AFt3R_Sw3ep1ng_M1n3s}

TankGame（Unity）

附件目录名提示使用 Mono 反编译，直接用 dnSpy 反编译 /Managed/Assembly-CSharp.dll

找到了 WinGame() 函数

pasted_1787304152154_l7nq52.png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static void WinGame()
{
    // 防止重复触发胜利，且只有摧毁数量为 4 或 5 时才允许胜利
    if (!MapManager.winGame && (MapManager.nDestroyNum == 4 || MapManager.nDestroyNum == 5))
    {
        // 构建地图状态字符串（21x17 的格子状态拼接）
        string text = "clearlove9";
        for (int i = 0; i < 21; i++)
        {
            for (int j = 0; j < 17; j++)
            {
                text += MapManager.MapState[i, j].ToString();
            }
        }
        // 计算地图状态的 SHA1 哈希值，与硬编码值比对
        string a = MapManager.Sha1(text);
        if (a == "3F649F708AAFA7A0A94138DC3022F6EA611E8D01")
        {
            // 哈希匹配，显示胜利 UI，并生成 Flag（格式：RoarCTF{wm- + MD5(地图状态) + }）
            FlagText._instance.gameObject.SetActive(true);
            FlagText.str = "RoarCTF{wm-" + MapManager.Md5(text) + "}";
            MapManager.winGame = true; // 标记胜利，防止再次触发
        }
    }
}

也就是说 flag 取决于地图状态，接下来去看初始地图

pasted_1787304581098_ix56h7.png

但是 WinGame() 检查的是游戏结束时的地图，两者可能不同，比如：坦克开炮，子弹撞墙

在代码中有这样一个条件 if(nDestroyNum == 4 || nDestroyNum == 5)

所以接下来的思路就是找可以被破坏的位置，查看 MapCreation.Initmap()

pasted_1787305357708_f4k9ls.png

这里唯一 100% 确定的是 if(num != 8)，当 MapState 的值为 8 时，不创建任何游戏物体。即空地

前面代码没有读取 MapState，而是直接 this.item[6] 生成一圈东西，总共四次，应该对应着边界

1
2
3
4
5
6
7
for (int i = -11; i < 12; i++)
{
    this.CreateItem(this.item[6],
        new Vector3((float)i,9f,0f),
        Quaternion.identity,
        6);
}

继续分析 CreateItem 虽然传入了 id，但是没用

pasted_1787305714227_gbkn5e.png

继续分析其他的类，在 Bullect 类中找到核心逻辑

1
2
3
4
5
6
7
8
9
10
11
12
// 当子弹击中墙壁时
if(tag=="Wall")
{
    // 在地图状态数组中标记该位置为已摧毁（值为 8）
    MapManager.MapState[num+10, num2+8] = 8;
    // 增加已摧毁墙壁数量
    MapManager.nDestroyNum++;

    // 销毁墙壁对象和子弹自身
    Destroy(collision.gameObject);
    Destroy(this.gameObject);
}

这里 MapManager.nDestroyNum++;，所以玩家需要摧毁 4 个墙或者摧毁 5 个墙

继续往后看

1
2
3
4
5
6
7
8
9
10
11
// 当子弹击中非墙壁物体（如敌人）时
else
{
    // 在地图状态数组中标记该位置为已处理（值为 9，可能表示敌人被击毁）
    MapManager.MapState[num+10, num2+8] = 9;
    // 增加已摧毁物体数量（与墙壁共享同一计数）
    MapManager.nDestroyNum++;

    // 发送 Die 消息给被击中的物体，触发其死亡逻辑
    collision.SendMessage("Die");
}

现在所有变化规则确定，打墙和打敌人都会增加已摧毁物体数量

解题思路就是将 21×17 的二维地图压缩成一维字符串，预先记录所有可破坏 Wall 的位置，通过枚举被摧毁的 4/5 个 Wall（以及 Heart+Wall组合），直接修改对应字符生成候选 MapState，计算 SHA1 与目标值比对，找到正确地图后再计算 MD5 生成 flag

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
import hashlib
import itertools    # 用于生成组合
import time

target = "3F649F708AAFA7A0A94138DC3022F6EA611E8D01"

Map = [
    [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
    [8, 8, 4, 5, 8, 1, 1, 1, 1, 1, 1, 8, 8, 8, 8, 4, 8],
    [8, 2, 8, 1, 8, 8, 5, 1, 8, 8, 8, 1, 8, 1, 8, 4, 8],
    [8, 5, 8, 2, 8, 8, 8, 8, 1, 8, 8, 4, 8, 1, 1, 5, 8],
    [8, 8, 8, 8, 2, 4, 8, 1, 1, 8, 8, 1, 8, 5, 1, 5, 8],
    [8, 8, 8, 8, 5, 8, 8, 1, 5, 1, 8, 8, 8, 1, 8, 8, 8],
    [8, 8, 8, 1, 8, 8, 8, 8, 8, 8, 8, 8, 1, 8, 1, 5, 8],
    [8, 1, 8, 8, 1, 8, 8, 1, 1, 4, 8, 8, 8, 8, 8, 1, 8],
    [8, 4, 1, 8, 8, 5, 1, 8, 8, 8, 8, 8, 4, 2, 8, 8, 8],
    [1, 1, 8, 5, 8, 2, 8, 5, 1, 4, 8, 8, 8, 1, 5, 1, 8],
    [0, 1, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
    [1, 1, 8, 1, 8, 8, 2, 1, 8, 8, 5, 2, 1, 8, 8, 8, 8],
    [8, 8, 8, 8, 4, 8, 8, 2, 1, 1, 8, 2, 1, 8, 1, 8, 8],
    [8, 1, 1, 8, 8, 4, 4, 1, 8, 4, 2, 4, 8, 4, 8, 8, 8],
    [8, 4, 8, 8, 1, 2, 8, 8, 8, 8, 1, 8, 8, 1, 8, 1, 8],
    [8, 1, 1, 5, 8, 8, 8, 8, 8, 8, 8, 8, 1, 8, 8, 8, 8],
    [8, 8, 1, 1, 5, 2, 8, 8, 8, 8, 8, 8, 8, 8, 2, 8, 8],
    [8, 8, 4, 8, 1, 8, 2, 8, 1, 5, 8, 8, 4, 8, 8, 8, 8],
    [8, 8, 2, 8, 1, 8, 8, 1, 8, 8, 1, 8, 2, 2, 5, 8, 8],
    [8, 2, 1, 8, 8, 8, 8, 2, 8, 4, 5, 8, 1, 1, 2, 5, 8],
    [8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8]
]

# ==========================================================================
# 构建基础字符串数组及索引信息（将地图展平为一维）
# 展平方式：按行优先，i 从 0 到 20，j 从 0 到 16，每个位置对应一维索引 idx = i*17 + j
# ==========================================================================

base = []          # 存储每个格子的原始数值（字符串形式），长度为 21*17 = 357
walls = []         # 记录所有墙壁（值为 1）的一维索引，用于后续组合枚举
heart = None       # 记录 Heart（值为 0）的一维索引，用于特殊组合

for i in range(21):
    for j in range(17):
        idx = i * 17 + j        # 计算一维索引
        v = Map[i][j]
        base.append(str(v))     # 将数值转为字符串存入 base

        if v == 1:
            walls.append(idx)   # 收集所有墙壁索引
        elif v == 0:
            heart = idx         # 记录心脏索引（唯一，此地图中只有一个 0）

def calc(change):
    # 复制基础字符串列表，避免修改原始数据
    s = base.copy()
    
    # 对每个被攻击的位置进行标记替换
    for idx in change:
        if idx == heart:
            s[idx] = '9'          # Heart 被攻击时改为 '9'
        else:
            s[idx] = '8'          # 墙壁被攻击时改为 '8'

    # 拼接固定前缀 "clearlove9" 和地图状态字符串（357个字符）
    text = "clearlove9" + "".join(s)

    # 计算 SHA1 并与目标比较（注意转换为大写）
    if hashlib.sha1(text.encode()).hexdigest().upper() == target:
        print("FOUND!")
        print("change:", change)
        # 计算 MD5 并取前 10 位作为 flag 的一部分
        md5 = hashlib.md5(text.encode()).hexdigest().upper()
        print("flag:", "RoarCTF{wm-" + md5[:10] + "}")
        exit()   # 找到后立即退出，不再继续搜索

start = time.time()

# ----------- 情况 1: 仅摧毁 4 个墙壁（无 Heart） -----------
# 对应游戏 nDestroyNum == 4，且未攻击 Heart
print("try 4 walls")
cnt = 0
for x in itertools.combinations(walls, 4):  # 生成从 walls 列表中选取任意 4 个元素的所有不重复组合（不考虑顺序）
    calc(x)          # change 为元组，calc 内部会迭代
    cnt += 1
print("done", cnt, time.time() - start)   # 输出尝试的组合数和耗时

# ----------- 情况 2: 仅摧毁 5 个墙壁（无 Heart） -----------
# 对应游戏 nDestroyNum == 5，且未攻击 Heart
print("try 5 walls")
for x in itertools.combinations(walls, 5):
    calc(x)

# ----------- 情况 3: 摧毁 Heart + 3 个墙壁 -----------
# 虽然游戏条件中不包含这种组合（仅判断墙壁数量，未单独处理 Heart），但作为备选
print("try heart + 3 walls")
for x in itertools.combinations(walls, 3):
    # 将墙壁组合转为列表，再添加 heart 索引，形成攻击集合
    calc(list(x) + [heart])

# ----------- 情况 4: 摧毁 Heart + 4 个墙壁 -----------
# 同上，作为备选枚举
print("try heart + 4 walls")
for x in itertools.combinations(walls, 4):
    calc(list(x) + [heart])

# 如果所有组合均未匹配，输出未找到信息
print("[-] not found")

pasted_1787307604223_evkxm9.png