CTF实战：立方体加密原理与Python逆向破解详解

1. 项目概述：从一道CTF密码题看立方体加密的实战应用

最近在整理历年CTF比赛的密码学题目时，又翻到了UTCTF 2020里那道名为“Cube Crypto”的题。这道题当时给不少选手留下了深刻印象，它没有用那些花里胡哨的现代密码协议，而是回归到了一个非常古典且有趣的加密思想——基于立方体的坐标变换。题目本身不长，但解题过程却像在玩一个立体的华容道，需要你理解数据是如何在一个三维空间里被“打乱”和“还原”的。这种题目在CTF中属于典型的“古典密码与现代编码结合”的类型，考察的不仅是密码分析能力，更是对数据结构和空间思维的把握。

对于刚接触CTF密码学方向的朋友来说，这类题目是个很好的起点。它不像RSA那样需要深厚的数论背景，也不像AES那样涉及复杂的轮函数。它的核心是逻辑和坐标映射。你完全可以把加密过程想象成：把一段明文（比如一串字符）写在一个立方体的每一个小格子里，然后按照某种特定的规则旋转、翻转这个立方体，最后再按新的顺序把格子里的字符读出来，就成了密文。解密，就是把这个过程逆向执行一遍。听起来是不是有点像小时候玩的魔方？没错，其内核思想是相通的。

这道“Cube Crypto”题，正是基于这个思想的一次典型实现。它通常会给你加密后的密文（一段看起来乱码的字符串），以及加密时使用的立方体边长（或者叫阶数），你的任务就是写一个脚本，逆向这个“填充-变换-读取”的过程，恢复出原始的明文。在这个过程中，你会接触到Python中对多维列表（模拟立方体）的熟练操作、对坐标系的深刻理解，以及如何将抽象的加密规则转化为确切的代码逻辑。接下来，我就结合这道题，把立方体加密的原理、常见的变换模式、解题的详细思路以及我踩过的坑，完整地梳理一遍。

2. 核心原理拆解：立方体加密是如何工作的？

要攻克这道题，首先得在脑子里把“立方体加密”这个模型搭建起来。我们别把它想得太复杂，它本质上是一种换位密码。换位密码不改变字符本身，只改变字符出现的位置。立方体，就是为这种位置变换提供了一个三维的、结构化的“舞台”。

2.1 基础模型：三维数组与坐标映射

在编程中，我们最自然的就是用一个三维列表（或数组）来模拟一个立方体。假设立方体的边长是n，那么这个数据结构就是cube = [[[None for _ in range(n)] for _ in range(n)] for _ in range(n)]。这里，cube[x][y][z]就代表了在三维坐标系中，位于(x, y, z)位置的那个小格子。通常，我们会定义：

• x轴：代表层（layer），从外到内，或者从上到下。
• y轴：代表行（row），从上到下。
• z轴：代表列（column），从左到右。

加密的第一步，是填充。将明文字符串按顺序填入这个立方体的每一个格子。填充顺序是关键，通常有两种主流方式：

1. 逐层填充：先填满x=0这一层的所有y和z，再填x=1层，以此类推。这类似于按书本页码顺序写字。
2. 蛇形填充：在每一层内部，按“之”字形顺序填充，有时层与层之间也会采用蛇形连接，目的是为了增加混乱度。

在UTCTF2020的这道题中，根据当时的writeup和常见模式，它采用的更可能是逐层、逐行、逐列的标准光栅扫描顺序。也就是固定x，然后遍历所有y，对于每个y再遍历所有z。用代码表示就是：

index = 0 for x in range(n): for y in range(n): for z in range(n): if index < len(plaintext): cube[x][y][z] = plaintext[index] index += 1 else: cube[x][y][z] = ‘#’ # 或用其他字符填充不足部分

2.2 核心变换：旋转与切片

填充之后，一个规规矩矩的立方体就形成了。加密的魔法在于接下来的变换。变换的目的是打乱格子内容的位置。最常见的变换是旋转。

三维空间的旋转比二维复杂。你可以绕X轴、Y轴、Z轴旋转。绕某个轴旋转90度，意味着这个轴对应的坐标值不变，而另外两个坐标构成的平面在进行一个二维的90度旋转。举个例子，绕Z轴逆时针旋转90度：

• 变换前坐标：(x, y, z)
• 变换后坐标：(-y, x, z)这里z不变，x和y的变换符合二维平面点(x, y)绕原点逆时针旋转90度到(-y, x)的规则。

一道题目可能只进行一次旋转，也可能进行一系列旋转的组合。除了旋转，还有可能进行切片重排。例如，将立方体沿着某个轴切成若干片，然后把这些片的顺序打乱，或者将某一片整体翻转。UTCTF2020的题目，根据回忆和常见模式，其加密过程很可能包含了多次不同轴向的旋转组合。

变换完成后，就进入了最后一步：读取。按照一个新的、固定的顺序，遍历立方体的所有格子，将格子里的字符依次取出，连接成字符串，就得到了密文。读取顺序同样至关重要，它可能与填充顺序相同，也可能完全不同。例如，加密时按(x,y,z)顺序填充，但读取时却按(z,y,x)顺序。这相当于又多了一层置换。

所以，完整的加密流程可以概括为：明文 -> (按顺序A填充到立方体) -> (进行一系列旋转/切片变换) -> (按顺序B从立方体读取) -> 密文。解密，就是逆序执行：密文 -> (按顺序B填充到立方体) -> (逆向进行之前的旋转/切片变换) -> (按顺序A从立方体读取) -> 明文。

注意：这里最容易出错的地方是“逆向变换”。旋转的逆操作就是反向旋转相同的角度。如果加密时是绕Z轴逆时针90度，那么解密时就需要绕Z轴顺时针90度（或等价地，逆时针270度）。在代码实现时，一定要想清楚变换矩阵，或者直接用一个临时立方体来存储变换后的结果，避免在原数组上操作导致坐标覆盖错误。

3. 实战解题步骤与代码实现

理论清晰了，我们开始动手。假设我们从题目中得到的信息是：密文ciphertext，立方体边长n=3（这是常见尺寸，因为3x3x3=27，足以容纳一个短句或flag格式），并且我们通过分析或题目描述，知道了加密的具体步骤。这里我基于常见模式，还原一个典型的解题过程。

3.1 第一步：密文填充与立方体重建

我们拿到的是密文，所以第一步是按照加密时最终的读取顺序，将密文填回立方体。这是解密流程的起点。如果我们推测加密的读取顺序是“逐层(x)、逐行(y)、逐列(z)”，那么重建代码如下：

def build_cube_from_cipher(n, ciphertext): """ 根据密文和立方体边长，按照假定的读取顺序重建立方体。 假设读取顺序为：for x in range(n): for y in range(n): for z in range(n): """ cube = [[[None for _ in range(n)] for _ in range(n)] for _ in range(n)] idx = 0 for x in range(n): for y in range(n): for z in range(n): if idx < len(ciphertext): cube[x][y][z] = ciphertext[idx] idx += 1 else: # 密文长度应该正好是n^3，否则题目会填充。这里假设长度匹配。 cube[x][y][z] = ‘#’ # 或直接报错 return cube

但这里有个关键问题：我们假定的读取顺序对吗？如果不对，填回去的立方体结构就是错的，后续的逆向变换也就无从谈起。如何确定顺序？有几种方法：

1. 题目描述：有些题目会直接说明“按某种顺序读取”。
2. 已知明文攻击：如果flag格式已知（如utflag{...}），我们可以尝试将密文开头部分按不同顺序填充，然后尝试逆向变换，看哪种顺序能得到有意义的开头。
3. 暴力枚举：对于小的n（如2或3），可能的遍历顺序有限（6种主要方向：xyz, xzy, yxz, yzx, zxy, zyx），可以结合逆向变换进行尝试。

在实际操作中，我通常会先按照最常见的(x,y,z)顺序尝试。如果不行，再根据情况调整。

3.2 第二步：逆向变换的实现

假设我们通过分析或测试，确定加密过程是：先绕Y轴旋转90度，再绕X轴旋转90度。那么解密时，就需要先逆向绕X轴旋转（即绕X轴旋转-90度或270度），再逆向绕Y轴旋转（绕Y轴旋转-90度）。

在代码中实现旋转，最清晰的方法是创建一个新的、同尺寸的空立方体，然后根据旋转规则，将原立方体每个位置的值，放到新立方体的对应位置。下面是绕Z轴旋转90度（逆时针）的函数：

def rotate_cube_z(cube, n, degrees=90): """ 绕Z轴旋转立方体。默认逆时针90度。 degrees应为90的倍数：90， 180， 270。 """ new_cube = [[[None for _ in range(n)] for _ in range(n)] for _ in range(n)] # 简化处理：只实现90度的情况，多次调用即可实现180和270 # 绕Z轴逆时针90度： (x, y, z) -> (-y, x, z) for x in range(n): for y in range(n): for z in range(n): new_x = (n - 1) - y # 注意：因为索引从0开始，-y的映射是 (n-1)-y new_y = x new_z = z new_cube[new_x][new_y][new_z] = cube[x][y][z] return new_cube

注意坐标映射中的(n-1)-y。这是因为我们的数组索引是0到n-1，而数学坐标系中的变换-y在索引世界里需要这样转换。这是实现时最容易出错的点之一，务必画一个2x2的小立方体在纸上推导一下。

同理，可以实现绕X轴和绕Y轴的旋转。对于逆向旋转，我们可以直接调用正向旋转函数3次（实现270度），或者更高效地，实现一个degrees=-90的参数处理。但在解题脚本中，为了清晰，我更喜欢写独立的逆向函数，或者用参数控制方向。

def rotate_cube_x(cube, n, clockwise=False): """绕X轴旋转。clockwise=True为顺时针，否则为逆时针。""" new_cube = [[[None for _ in range(n)] for _ in range(n)] for _ in range(n)] for x in range(n): for y in range(n): for z in range(n): if not clockwise: # 逆时针90度： (x, y, z) -> (x, -z, y) new_y = (n - 1) - z new_z = y else: # 顺时针90度： (x, y, z) -> (x, z, -y) new_y = z new_z = (n - 1) - y new_cube[x][new_y][new_z] = cube[x][y][z] return new_cube

实操心得：在编写旋转函数时，一定要先在小规模（如2x2x2）上测试。你可以用数字或字母预先填充一个立方体，打印出旋转前后的状态，手动核对是否正确。一个错误的映射会导致全盘皆输。另外，注意Python中列表是可变对象，函数内对new_cube的修改不会影响外部的cube，所以需要return new_cube并重新赋值，如cube = rotate_cube_x(cube, n)。

3.3 第三步：按原始顺序读取明文

完成所有的逆向变换后，我们得到了一个“还原”的立方体。最后一步，就是按照加密时最初的填充顺序，遍历这个立方体，读出所有字符，连接成字符串，就应该是明文（也就是我们想要的flag）。

如果最初的填充顺序是(x,y,z)，那么读取代码和之前的构建代码几乎一样：

def read_cube_in_order(cube, n, order=‘xyz‘): """按照指定顺序读取立方体中的字符。""" result = [] # 这里简化，假设order就是‘xyz‘，即x最外层，y中间，z最内层。 for x in range(n): for y in range(n): for z in range(n): result.append(cube[x][y][z]) return ‘’.join(result)

将这三步串联起来，一个完整的解密脚本框架就出来了。但CTF题目之所以有趣，就在于它不会把步骤直接告诉你。你需要去猜测、推断、测试这个变换序列。

4. 题目分析与破解思路推演

对于UTCTF2020的“Cube Crypto”，我们手头没有原始的题目文件，只有记忆和公开的Writeup。结合常见的出题套路，我们可以模拟一个合理的破解过程。

4.1 信息收集与假设建立

首先，我们假设拿到的密文是类似“Xp9D#kF2lA&sQmZ*”这样的乱码字符串（此为示例）。题目可能还会给一个提示，比如n=3。我们的目标是得到形如utflag{...}的字符串。

第一步，验证数据量：n=3的立方体有27个格子。检查密文长度。如果密文长度正好是27，那完美匹配。如果少于27，可能用了填充字符（如#或_）补足；如果多于27，那可能不是简单的单次立方体加密，或者n值不对。

第二步，分析字符集：密文是否只包含可打印字符？这有助于判断是否经过了其他编码（如Base64）。在“Cube Crypto”这类题中，通常变换后直接输出字符。

4.2 逆向工程与试错策略

最核心的问题是：加密的具体变换序列是什么？在没有明确说明的情况下，我们需要进行逆向工程。

策略一：利用Flag格式进行锚定。我们知道Flag通常以utflag{开头。这7个字符在解密后的明文中应该是连续出现的。我们可以尝试以下方法：

1. 枚举所有可能的填充顺序和读取顺序组合（对于n=3，数量有限）。
2. 对于每一种组合，假设加密变换是“无变换”（即只有填充和读取顺序不同），尝试解密。如果某一种组合解密出的字符串开头几个字符看起来有规律（比如部分匹配utflag），那么这可能就是正确的顺序，而剩下的乱码部分可能就是因为我们还没做逆向旋转。
3. 一旦确定了填充和读取顺序，我们就可以专注于破解旋转序列。这时，我们可以把已知的明文片段（如utflag{）在立方体中的大概位置标出来，然后观察在当前的密文立方体中，这些位置上的字符是什么。通过对比，可以反推出需要怎样的旋转才能把它们“送”回正确的位置。这需要一些空间想象力。

策略二：暴力枚举旋转序列。对于n=3，旋转操作是离散的。每次旋转可以是绕X、Y、Z轴顺时针或逆时针90度（共6种基本操作）。如果加密只进行了少数几次（比如2-4次）旋转，那么总的可能性是6^k（k是旋转次数）。当k=3时，6^3=216种可能性，完全可以用计算机暴力枚举。 我们可以写一个脚本，遍历所有可能的短旋转序列（例如长度1到4），对重建的密文立方体施加逆向序列（注意顺序要反过来且方向取反），然后按假设的原始顺序读取，检查输出是否包含utflag子串，或者是否全部由可打印字母、数字、括号和花括号组成（即合理的Flag字符）。

import itertools def brute_force_rotations(cipher_cube, n, original_order=‘xyz‘): """ 暴力尝试所有可能的旋转序列。 rotations_list 是基本旋转操作的函数列表，如 [rot_x_cw, rot_x_ccw, rot_y_cw, ...] """ basic_rots = [‘x_cw‘, ‘x_ccw‘, ‘y_cw‘, ‘y_ccw‘, ‘z_cw‘, ‘z_ccw‘] for k in range(1, 5): # 尝试旋转1到4次 for seq in itertools.product(basic_rots, repeat=k): test_cube = [row[:] for layer in cipher_cube for row in layer] # 深拷贝，这里需要根据三维列表调整 # 注意：解密时旋转顺序应与加密相反，且方向相反。 # 例如加密是 x_cw -> y_ccw，解密就应该是 y_cw -> x_ccw for op in reversed(seq): # 顺序反转 inverse_op = op.replace(‘cw‘, ‘temp‘).replace(‘ccw‘, ‘cw‘).replace(‘temp‘, ‘ccw‘) test_cube = apply_rotation(test_cube, n, inverse_op) plain_candidate = read_cube_in_order(test_cube, n, original_order) if ‘utflag{‘ in plain_candidate: print(f“Found potential sequence: {seq}“) print(f“Plaintext: {plain_candidate}“) return plain_candidate return None

注意事项：这个暴力方法计算量会随着k增大而指数增长，但对于k<=4且n较小的情况，在现代计算机上瞬间即可完成。关键在于编写正确且高效的apply_rotation函数，并能对三维列表进行深拷贝。

4.3 整合解题脚本与输出

将信息收集、立方体重建、暴力破解等模块整合，就是一个完整的解题脚本。在UTCTF2020的实际场景中，选手很可能就是通过类似的分析，确定了加密是“绕Y轴逆时针90度后，再绕X轴顺时针90度”，然后写出解密脚本，成功拿到Flag。

下面是一个整合后的示例脚本框架，它体现了完整的解密逻辑：

def solve_cube_crypto(ciphertext, n=3): # 1. 假设读取顺序为‘xyz‘，重建密文立方体 cube = build_cube_from_cipher(n, ciphertext, read_order=‘xyz‘) # 2. 假设加密变换序列（这里是推测的，实际需要分析或暴力得出） # 假设加密时进行了：绕Y轴逆时针90度 (y_ccw)，再绕X轴顺时针90度 (x_cw) # 那么解密时需进行逆向：先绕X轴逆时针90度 (x_ccw)，再绕Y轴顺时针90度 (y_cw) cube = rotate_cube_x(cube, n, clockwise=False) # x_ccw cube = rotate_cube_y(cube, n, clockwise=True) # y_cw # 3. 假设原始填充顺序也是‘xyz‘，读取明文 plaintext = read_cube_in_order(cube, n, order=‘xyz‘) # 4. 清理可能的填充字符（如‘#‘） flag = plaintext.rstrip(‘#‘) return flag # 假设的密文，实际应从题目获取 cipher = “Xp9D#kF2lA&sQmZ*VbYtLc8@1“ # 示例，长度27 n = 3 flag = solve_cube_crypto(cipher, n) print(“Potential Flag:“, flag)

5. 常见陷阱与调试技巧

即使思路正确，在实现过程中也极易踩坑。下面是我在解这类题目和编写相关工具时总结的几个常见陷阱及应对技巧。

5.1 坐标系统与索引混淆

这是最大的坑。数学上的三维坐标系(x,y,z)和程序中的数组索引cube[i][j][k]没有标准对应关系。你必须自己定义并始终保持一致。我的习惯是：

• 定义cube[layer][row][col]，其中layer对应x轴（层），row对应y轴（行），col对应z轴（列）。
• 在纸上画一个2x2x2的立方体，标出每个格子的坐标(l, r, c)和索引[l][r][c]。
• 实现旋转函数时，先用这个小立方体测试。填充字母‘A‘到‘H‘，打印旋转前后的立方体，肉眼核对。

# 测试用的小立方体 test_n = 2 test_cube = [[[chr(65 + i*4 + j*2 + k) for k in range(test_n)] for j in range(test_n)] for i in range(test_n)] print(“Original:“) print_cube(test_cube, test_n) # 需要实现一个打印立方体的函数 rotated = rotate_cube_z(test_cube, test_n) print(“After Z-rotation:“) print_cube(rotated, test_n)

5.2 旋转方向与顺序错误

旋转方向（顺时针/逆时针）和旋转顺序（先绕哪个轴，再绕哪个轴）一旦搞反，结果就会南辕北辙。

• 方向：牢记“逆向变换需方向相反”。如果加密是绕Z轴逆时针90度，解密就是绕Z轴顺时针90度。在代码中，可以用一个布尔参数clockwise或ccw来明确控制。
• 顺序：变换序列的顺序至关重要。加密时的变换是T1 -> T2 -> T3，那么解密时必须是T3^-1 -> T2^-1 -> T1^-1。写解密代码时，最好把加密步骤注释在旁边，然后显式地写出其逆步骤。

5.3 填充与读取顺序不匹配

如果加密的填充顺序是A，读取顺序是B，那么解密时：

1. 用顺序B把密文填回立方体。
2. 进行逆向变换。
3. 用顺序A从立方体读取明文。 这两个顺序A和B可能是不同的，也可能是相同的。在不确定的情况下，就需要像前面说的，利用Flag格式进行推测或暴力枚举。一个有用的技巧是：如果n很小，可以尝试所有可能的顺序组合（6种），并检查解密后的文本的熵或字符分布，有意义的文本通常看起来与随机乱码不同。

5.4 边界处理与填充字符

明文长度可能不是正好n^3。加密时通常会用特定字符（如空格、‘#‘、‘@‘或‘X‘）填充到满。解密后，这些填充字符会出现在明文末尾。你需要用rstrip()或类似方法去除它们。但要注意，有时Flag本身也可能包含这些字符（概率极低），或者填充字符出现在中间（如果填充规则不是简单的末尾追加）。最稳妥的方法是，解密后，在结果中搜索flag{或utflag{这类已知的模式。

5.5 调试与可视化

对于三维操作，调试不能只靠看日志。一定要写一个可视化函数，以清晰的方式打印出立方体每一层。

def print_cube(cube, n): for layer in range(n): print(f“Layer {layer}:“) for row in range(n): print(‘ ‘.join(str(cube[layer][row][col]) for col in range(n))) print() # 层之间空一行

在关键步骤前后（如重建后、每次旋转后）打印立方体状态，能帮你快速定位是填充错了，还是旋转错了。

6. 从解题到理解：立方体加密的变体与拓展

解完一道题，我们不妨跳出来看看。立方体加密作为一种教学模型和CTF题目，其实可以衍生出很多变体，理解这些有助于你未来应对更复杂的挑战。

6.1 非对称边长与长方体加密

立方体是特例（长宽高相等）。更一般化的是长方体加密，即三个维度(a, b, c)可以不相等。这时总格子数是a*b*c。填充和读取顺序的选择更多，变换也可以包括非90度的旋转（但那样坐标映射就不是整数了，更复杂），或者沿着某一维度进行镜像翻转。解题思路不变，但参数空间变大了。

6.2 多层嵌套与高阶立方体

有的题目会玩“套娃”。比如，先将明文按某种规则填充进一个小立方体，加密（旋转）后输出一串字符；再把这串字符作为输入，填充进一个更大的立方体，再进行加密。这相当于复合加密。破解时需要分层解密，从外到内或从内到外，一步步剥离。

6.3 与其它编码方式结合

这是CTF的常见套路。例如：

1. 明文先经过Base64编码，再进行立方体加密。
2. 立方体加密后的输出，每个字符再根据其ASCII值进行简单的移位或替换（如凯撒密码）。
3. 使用多个立方体，每个立方体使用不同的密钥（旋转序列）进行加密，然后交错输出。

应对方法就是分离关注点。先尝试把密文当成普通字符串，看看是否有Base64的特征（结尾可能有‘=‘，字符集受限）。或者分析字符频率，看是否像经过替换加密。把明显的编码层剥掉后，剩下的很可能就是纯粹的立方体加密问题。

6.4 自动化工具与思维提升

虽然这次我们手动编写了解密脚本，但对于这类结构固定的古典密码，完全可以编写一个更通用的“立方体密码分析工具”。这个工具可以接受密文、维度、猜测的填充/读取顺序、旋转序列等参数，自动进行尝试和输出。这不仅能提高解题效率，更能加深你对算法本身的理解。

最后，这道“Cube Crypto”题带给我的最大收获，不是某个具体的旋转函数怎么写，而是一种结构化思考的能力。面对一堆杂乱的数据，如何为它建立一个清晰的空间模型（立方体），如何定义操作（旋转），又如何逆向这个操作。这种能力在逆向工程、密码分析甚至软件架构中都非常有用。下次当你遇到一堆看似无序的数据时，不妨想想：它会不会是被放进了某个维度的“空间”里，然后被“转动”了一下呢？