《命令与征服:红色警戒2》是由Westwood制作、EA发行的一款RTS游戏,发行于2000年9月28日。作为一款拥有极大玩家群体和极高可自定义度的童年神作,不少基于游戏本体的隐写方法和基于某些元素扩展命名的隐写方法也时常被使用。
下面对一些出现过或可能会出现的基于RA2的隐写方式进行解析

1. 基于相关元素扩展命名的隐写方法

1.1 幻影坦克隐写

作为较早出现且较为常见的图片隐写方法,幻影坦克隐写得名于游戏中能够伪装成树木的单位幻影坦克,他是一种通过图像混合实现信息隐藏的技术。其根本原理是把两张图片“表图”和“里图“通过特定的像素混合算法合成为一张图片,使得在不同的显示条件下可以呈现不同的图像内容。

原理

早期的幻影坦克隐写主要用来处理黑白图像,或经过处理后彩色图像变成黑白图像,利用黑白两种颜色分别处理两张图片并将其混合,使一张图片在不同背景或处理方式下呈现不同的图片。具体在操作中就会表现为点开前和点开后是两种不同的图片,尽管大多数时候两张图片叠加会导致有明显的水痕而被轻易看出。比如这张

幻影坦克隐写从数学角度分析基本原理可以描述如下:对于一个PNG图像中的单个像素,假设其RGB值为(R, G, B),透明度值为α(0表示完全透明,255表示完全不透明),背景色为(X_R, X_G, X_B)。那么该像素在显示时的实际颜色值可以通过以下公式计算:

  • R_final = (α/255) * R + (1 - α/255) * X_R
  • G_final = (α/255) * G + (1 - α/255) * X_G
  • B_final = (α/255) * B + (1 - α/255) * X_B

基于这一原理,幻影坦克隐写需要解决的问题是如何计算出一组合适的(R, G, B, α)值,使得在纯白背景(255, 255, 255)下显示图像A,在纯黑背景(0, 0, 0)下显示图像B。
对于灰度图像的情况,问题可以简化为:已知在白色背景下期望显示的灰度值为A,黑色背景下期望显示的灰度值为B,需要求解对应的像素值P和透明度α。这可以通过建立并求解以下方程组得到:

  • 白色背景: (α/255) * P + (1 - α/255) * 255 = A
  • 黑色背景: (α/255) * P + (1 - α/255) * 0 = B

求解上述方程组可得:

  • α = 255 - (A - B)
  • P = 255B/α 或 P = A - (255 - α) * 255/α

即按照像素坐标和值的特定模运算关系来分配两张不同图像的像素信息。每个像素都可以用RGB三个数值的组合表示,通过提取图片的像素特征并进行混合计算,就可以还原出隐藏的图像内容。

进阶

随着思路的开阔和技术的发展,又出现了基于棋盘格幻影坦克的类lsb隐写术,与传统依赖连续灰度的幻影坦克不同,此方法将表图像素的灰度强制设为接近255,将里图像素的灰度强制设为接近0,通过透明度的微小变化来携带1或0。此类隐写依赖灰度阈值而不是二进制的硬编码,其对抗常规图像处理的鲁棒性通常优于传统的LSB隐写。此外,在实现基础的双图隐藏功能之上,它还能额外嵌入文件,更适用于CTF竞赛等场景。此部分实现可参考大佬的github项目:
GitHub - TankFactory/Mirage_Cloak: 幻影/无影及其杂交坦克编解码工具

隐写方法

传统灰度:
基于原理直接使用脚本进行制作

import cv2
import sys
import numpy as np

def mixImg(A, B, alpha=-1):
    """混合两张图片"""
    if alpha == -1:
        alphaA = A[:, :, -1].T
        alphaA = np.array(alphaA, dtype=np.float16) / 255
    else:
        alphaA = np.ones(A.shape[:2], dtype=np.float16).T * alpha
    alphaA = np.array([alphaA, alphaA, alphaA]).T
    colorA = A[:, :, 0:3]
    colorB = B[:, :, 0:3]
    color = colorA * (alphaA) + colorB * (1 - alphaA)
    
    return np.array(color, dtype=np.uint8)

def createSpecialImg(A, B):
    A = A / 2
    B = B / 2 + 128
    delta = np.array(A - B, dtype=np.float16)
    alpha = np.array(delta / 255 + 1, dtype=np.float16)
    color = A / alpha
    img = np.zeros([A.shape[0], A.shape[1], 4], dtype=np.uint8)
    img[:, :, 0] = color
    img[:, :, 1] = color
    img[:, :, 2] = color
    img[:, :, 3] = np.array(alpha * 255, dtype=np.uint8)

    return img

if __name__ == "__main__":
    SHOW = 0
    print(sys.argv[1:])
    path1 = sys.argv[1] # 改成两张图片的地址
    path2 = sys.argv[2]
    src1 = cv2.imread(path1, cv2.IMREAD_GRAYSCALE)
    src2 = cv2.imread(path2, cv2.IMREAD_GRAYSCALE)
    h = min(src1.shape[0], src2.shape[0])
    w = min(src1.shape[1], src2.shape[1])
    src1 = src1[:h, :w]
    src2 = src2[:h, :w]
    img = createSpecialImg(src1, src2)
    bkgpw = np.ones([h, w, 3], dtype=np.uint8) * 255
    bkgpb = np.ones([h, w, 3], dtype=np.uint8) * 0
    imgB = mixImg(img, bkgpb)
    imgW = mixImg(img, bkgpw)

    if SHOW:
        cv2.imshow("Output", img)
        cv2.imshow("Black", imgB)
        cv2.imshow("White", imgW)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

    cv2.imwrite("mix.png", img)

基于棋盘格:
使用在线网站:幻影坦克Ultra
或者采用PS手搓棋盘法,步骤如下

  1. 创建大小为2x2的图案,分别在两个对角填充黑色和白色


并分别保存为图案

  1. 创建两个空图层,分别使用刚刚创建的图案填充

  1. 之后给每个空白图层创建剪贴蒙版,然后将表里图复制到蒙版上
  2. 隐藏原图图层,导出为png

解题

对于灰度版本,可以使用简单的脚本进行解码

import cv2
import numpy as np
import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='提取幻影坦克')
    parser.add_argument('input', help='输入图')
    parser.add_argument('output1', help='输出隐藏的图')
    parser.add_argument('output2', help='输出直接展示的图')
    arg = parser.parse_args()

    img_in = cv2.imread(arg.input, cv2.IMREAD_UNCHANGED) 

    if len(img_in.shape) < 3 or img_in.shape[2] != 4:
        parser.error('图片不含alpha通道') 

    b = img_in[:, :, 0].astype(np.float)
    g = img_in[:, :, 1].astype(np.float)
    r = img_in[:, :, 2].astype(np.float)
    a = img_in[:, :, 3].astype(np.float) 

    out1 = np.zeros([img_in.shape[0], img_in.shape[1], 3])
    out2 = np.zeros([img_in.shape[0], img_in.shape[1], 3])

    out1[:, :, 0] = b * a / 255
    out1[:, :, 1] = g * a / 255
    out1[:, :, 2] = r * a / 255
    out2[:, :, 0] = 255 - (255 - b) * a / 255
    out2[:, :, 1] = 255 - (255 - g) * a / 255
    out2[:, :, 2] = 255 - (255 - r) * a / 255

    out1 = np.clip(np.floor(out1), 0, 255).astype(np.uint8)
    out2 = np.clip(np.floor(out2), 0, 255).astype(np.uint8) 

    cv2.imwrite(arg.output1, out1)
    cv2.imwrite(arg.output2, out2)

棋盘格法变体则需要利用其像素排布规律, (x+y) mod 2 == 0 的像素点属于里图,编写脚本,提取里图像素并增强其对比度,再利用插值算法补全图像。

import sys
import argparse
from pathlib import Path
import numpy as np
from PIL import Image

def detect_checkerboard_pattern(img_gray, max_modulus=6):
    height, width = img_gray.shape
    best_score = 0
    best_mod = 2
    best_offset = 0
    
    for modulus in range(2, max_modulus + 1):
        for offset in range(modulus):
            score = 0
            total = 0
            
            for y in range(0, height, 3):
                for x in range(0, width, 3, 3):
                    if (x + y) % modulus == offset:
                        if img_gray[y, x] < 128:
                            score += 1
                        total += 1
            
            if total > 0:
                match_ratio = score / total
                if match_ratio > best_score:
                    best_score = match_ratio
                    best_mod = modulus
                    best_offset = offset
    
    return best_mod, best_offset, best_score

def decode_checkerboard_mirage(input_path, output_path=None, modulus=None, offset=0):

    img = Image.open(input_path)
    
    if img.mode == 'RGBA':
        gray_img = np.array(img.split()[3]) 
    else:
        gray_img = np.array(img.convert('L'))
    
    height, width = gray_img.shape
    
    if modulus is None:
        modulus, offset, confidence = detect_checkerboard_pattern(gray_img)
        print(f"检测到模式: modulus={modulus}, offset={offset}, 置信度={confidence:.2%}")
        if confidence < 0.6:
            print("警告: 可能不是标准棋盘格幻影坦克")
    
    decode_mask = np.zeros((height, width), dtype=bool)
    for y in range(height):
        for x in range(width):
            if (x + y) % modulus == offset:
                decode_mask[y, x] = True
    
    result = np.zeros((height, width, 3), dtype=np.uint8)
    
    print("正在提取里图像素...")
    extracted_pixels = np.where(decode_mask)
    if len(extracted_pixels[0]) == 0:
        print("错误: 未找到符合模式的像素")
        return None
    
    max_val = gray_img[extracted_pixels].max()
    if max_val > 0:
        scale_factor = 255.0 / max_val
    else:
        scale_factor = 1.0
    
    print(f"对比度增强系数: {scale_factor:.2f}")
    
    for y, x in zip(*extracted_pixels):
        enhanced = min(255, int(gray_img[y, x] * scale_factor))
        result[y, x] = (enhanced, enhanced, enhanced)
    
    print("插值填充缺失像素...")
    kernel_radius = 1
    for y in range(height):
        for x in range(width):
            if not decode_mask[y, x]:
                neighbors = []
                for dy in range(-kernel_radius, kernel_radius + 1):
                    for dx in range(-kernel_radius, kernel_radius + 1):
                        ny, nx = y + dy, x + dx
                        if 0 <= ny < height and 0 <= nx < width:
                            if decode_mask[ny, nx]:
                                neighbors.append(result[ny, nx])
                
                if neighbors:
                    avg_r = sum(p[0] for p in neighbors) // len(neighbors)
                    avg_g = sum(p[1] for p in neighbors) // len(neighbors)
                    avg_b = sum(p[2] for p in neighbors) // len(neighbors)
                    result[y, x] = (avg_r, avg_g, avg_b)
                else:
                    result[y, x] = (0, 0, 0)
    output_img = Image.fromarray(result_median)
    
    if output_path:
        output_img.save(output_path)
        print(f"解密完成!结果已保存至: {output_path}")
    else:
        input_stem = Path(input_path).stem
        output_path = f"{input_stem}_decoded.png"
        output_img.save(output_path)
        print(f"解密完成!结果已保存至: {output_path}")
    return output_img

def main():
    parser = argparse.ArgumentParser(description='棋盘格幻影坦克解密')
    parser.add_argument('input', help='输入图片路径(PNG格式)')
    parser.add_argument('-o', '--output', help='输出图片路径(可选)')
    parser.add_argument('-m', '--modulus', type=int, help='棋盘格模数(如未指定则自动检测)')
    parser.add_argument('--offset', type=int, default=0, help='棋盘格偏移量(默认0)')
    
    args = parser.parse_args()
    
    if not Path(args.input).exists():
        print(f"文件 '{args.input}' 不存在")
        return 1   
    try:
        decode_checkerboard_mirage(
            args.input, 
            args.output, 
            args.modulus, 
            args.offset
        )
    except Exception as e:
        print(f"出错: {e}")
        return 1   
    return 0

if __name__ == "__main__":
    sys.exit(main())

1.2 光棱坦克隐写

原理

此方法名字源于游戏中盟军单位光棱坦克,因在手动解密时需要拉高曝光度故而得名。与棋盘格法幻影坦克一样,光棱坦克也是基于基于灰度色阶或亮度的像素分离,交错放置表图和里图的像素。但光棱坦克支持多图合一和保留彩色。一张图中混合了两种像素,一种特别“暗”,一种特别“亮”,既然存在区别就很容易将其区分开,因此可以通过调整色阶输出分离出表图和里图。同时灰度值的范围是0-255,整数有256个取值,存在多设几个区间a1-b1, a2-b2,...,的操作空间,假设有n个区间,那么就按照灰度值将所有像素归为n类,再稍加处理,就是n张独立的图。

隐写方法

使用脚本:

import numpy as np
from PIL import Image, ImageOps

def create_diagonal_pattern(size):
    pattern = np.zeros((size, size), dtype=bool)
    for i in range(size):
        for j in range(size):
            if (i + j) % 2 == 0:
                pattern[i, j] = True
    return pattern

def calculate_optimal_levels(img1_array, img2_array):
    mean1, std1 = np.mean(img1_array), np.std(img1_array)
    mean2, std2 = np.mean(img2_array), np.std(img2_array)
    level_max = int(min(mean1 + std1 * 0.5, 200))
    level_min = int(max(mean2 - std2 * 0.5, 55))
    if level_max >= level_min:
        level_max = min(100, level_min - 20)
        level_min = max(155, level_max + 20)
    return max(20, min(level_max, 120)), min(235, max(level_min, 130))

def apply_diagonal_mixing(img1, img2, pattern_size=2):
    target_size = (max(img1.size[0], img2.size[0]), max(img1.size[1], img2.size[1]))
    img1 = ImageOps.fit(img1, target_size)
    img2 = ImageOps.fit(img2, target_size)
    img1_grey = img1.convert('L')
    img2_grey = img2.convert('L')
    img1_array = np.array(img1_grey, dtype=np.float32)
    img2_array = np.array(img2_grey, dtype=np.float32)
    level_max, level_min = calculate_optimal_levels(img1_array, img2_array)
    pattern = create_diagonal_pattern(pattern_size)
    h, w = img1_array.shape
    result_array = np.zeros((h, w), dtype=np.float32)
    for i in range(h):
        for j in range(w):
            if pattern[i % pattern_size, j % pattern_size]:
                pixel = img1_array[i, j]
                result_array[i, j] = pixel * (level_max / 255.0)
            else:
                pixel = img2_array[i, j]
                result_array[i, j] = level_min + pixel * ((255 - level_min) / 255.0)
    result_array = np.clip(result_array, 0, 255).astype(np.uint8)
    return Image.fromarray(result_array, mode='L')

def create_color_prism_tank(img1, img2):
    target_size = (max(img1.size[0], img2.size[0]), max(img1.size[1], img2.size[1]))
    img1 = ImageOps.fit(img1, target_size)
    img2 = ImageOps.fit(img2, target_size)
    img1_hsv = img1.convert('HSV')
    img2_hsv = img2.convert('HSV')
    h1, s1, v1 = img1_hsv.split()
    h2, s2, v2 = img2_hsv.split()
    v1_array = np.array(v1, dtype=np.float32)
    v2_array = np.array(v2, dtype=np.float32)
    level_max, level_min = calculate_optimal_levels(v1_array, v2_array)
    pattern = create_diagonal_pattern(2)
    h, w = v1_array.shape
    result_v = np.zeros((h, w), dtype=np.float32)
    for i in range(h):
        for j in range(w):
            if pattern[i % 2, j % 2]:
                pixel = v1_array[i, j]
                result_v[i, j] = pixel * (level_max / 255.0)
            else:
                pixel = v2_array[i, j]
                result_v[i, j] = level_min + pixel * ((255 - level_min) / 255.0)
    result_v = np.clip(result_v, 0, 255).astype(np.uint8)
    result_v_img = Image.fromarray(result_v, mode='L')
    result_hsv = Image.merge('HSV', (h1, s1, result_v_img))
    return result_hsv.convert('RGB')

def main():
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument('visible_image')
    parser.add_argument('hidden_image')
    parser.add_argument('-o', '--output', default='prism_tank.png')
    parser.add_argument('-c', '--color', action='store_true')
    args = parser.parse_args()
    visible_img = Image.open(args.visible_image)
    hidden_img = Image.open(args.hidden_image)
    if args.color:
        result = create_color_prism_tank(visible_img, hidden_img)
    else:
        visible_grey = visible_img.convert('L')
        hidden_grey = hidden_img.convert('L')
        result = apply_diagonal_mixing(visible_grey, hidden_grey)
    if args.output.lower().endswith(('.jpg', '.jpeg')):
        result.save(args.output, 'JPEG', quality=95)
    else:
        result.save(args.output, 'PNG', optimize=True)

if __name__ == "__main__":
    main()

PS手搓:
在确定表图和里图后,我们需要分别对两张图进行处理,使其像素分布于色阶上不同的区域。这一点可以通过色阶以及曲线两种工具实现。
以下是操作过程:
打开ps,导入表图,转为灰度,打开色阶窗口将输出限定为色阶右侧的一定区间,可以观察到图片整体变得“白”了一些,确定后再次打开色阶可以看到左侧的一小段区间完全空了出来,这就是可以隐写里图的部分。

接下来对里图打开色阶窗口,将色阶输出限定到空出来的左侧的区间
接下来使用前面幻影坦克时做的黑色像素对角线填充的图案对里图新建一个剪贴蒙版
光棱坦克就做好了

解题

识别
不打开ps快速识别一张图片的色阶有没有被人工调整过,我们可以使用直方图来完成这个工作,它的横轴代表像素的亮度或颜色值,范围取决于图像的位深度。比如常见的8位深度图像,横轴就是从0到255,总共256个等级;如果是16位深度,范围就是0到65535,纵轴则是一个简单的计数,告诉我们整个图像里,有多少个像素的数值恰好等于横轴上对应的那个值。在图表上,每个像素值都会对应一根柱子,柱子越高,就说明图像中拥有这个特定像素值的像素数量越多。可以通过python脚本来生成一张图片的直方图

import numpy as np
from PIL import Image

def get_histogram_advanced(image_data, is_2d=False):

    pixels = []
    if isinstance(image_data, Image.Image):
        if image_data.mode != 'L':
            image_data = image_data.convert('L')
        pixels = list(image_data.getdata())
        
    elif isinstance(image_data, np.ndarray):
        if is_2d:
            h, w = image_data.shape[:2]
            pixels = image_data.flatten().tolist()
        else:
            pixels = image_data.flatten().tolist()
            
    elif isinstance(image_data, list):
        if is_2d:
            pixels = []
            for row in image_data:
                if isinstance(row, list):
                    pixels.extend(row)
                else:
                    raise ValueError("格式不正确")
        else:
            pixels = image_data
            
    else:
        raise TypeError(f"不支持的数据类型: {type(image_data)}")
    
    hist = [0] * 256
    for value in pixels:
        if isinstance(value, (list, tuple, np.ndarray)):
            if len(value) >= 3:
                grey = int(0.299 * value[0] + 0.587 * value[1] + 0.114 * value[2])
            else:
                grey = int(np.mean(value))
        else:
            grey = int(value)
        
        if 0 <= grey <= 255:
            hist[grey] += 1
    
    return hist

提取
基于里图格子坐标均符合(x+y) mod 2 == 0这一特点,我们可以通过写脚本提取这些里图格子并增加其曝光度,最后取临近像素平均值来补全图片

from PIL import Image
import itertools
from pathlib import Path
import posixpath
import sys

def detect_stripe_modulus(img: Image.Image, max_modulus=6, threshold=0.4):
    img = img.convert("L")
    pixels = img.load()
    height, width = img.size

    best_score = 0
    best_mod = 2
    best_xoff = 1

    for xoff in range(1, max_modulus + 1):
        for x_mod in range(2, max_modulus + 1):
            score = 0
            total = 0
            for y in range(0, height, 6):
                for x in range(0, width, 9):
                    if (x + y * xoff) % (x_mod) == 0:
                        if pixels[y, x] / 255 < threshold:
                            score += 1
                        total += 1
                    else:
                        if pixels[y, x] / 255 >= threshold:
                            score += 1
                        total += 1

            match_ratio = score / total
            print(xoff, x_mod, "match_ratio", score, match_ratio)
            if match_ratio > best_score:
                best_score = match_ratio
                best_mod = x_mod
                best_xoff = xoff
            if match_ratio == 1:
                break

    return best_mod, best_xoff

def get_circle_pixels(center_x, center_y, r, max_x, max_y):
    points = set()
    x = 0
    y = int(r + 0.5)
    p = 1 - y

    def add_symmetric_points(cx, cy, x, y):
        points.add((cx + x, cy + y))
        points.add((cx - x, cy + y))
        points.add((cx + x, cy - y))
        points.add((cx - x, cy - y))
        points.add((cx + y, cy + x))
        points.add((cx - y, cy + x))
        points.add((cx + y, cy - x))
        points.add((cx - y, cy - x))

    add_symmetric_points(center_x, center_y, x, y)

    while x < y:
        x += 1
        if p < 0:
            p += 2 * x + 1
        else:
            y -= 1
            p += 2 * (x - y) + 1
        add_symmetric_points(center_x, center_y, x, y)

    return set([p for p in points if 0 <= p[0] < max_x and 0 <= p[1] < max_y])

def decode(p, xoff=None, xmod=None):
    path = Path(p)
    lmax = 0
    ori = Image.open(path)
    new = Image.new(ori.mode, ori.size)
    pixels = new.load()
    print(xoff, xmod)
    
    if xmod is None or xoff is None:
        xmod, xoff = detect_stripe_modulus(ori)
    
    print("choice", xoff, xmod, ori.size)
    
    for y, x in itertools.product(*[range(r) for r in ori.size[::-1]]):
        if not (x + y * xoff) % (xmod) == 0:
            continue
        r, g, b = ori.getpixel((x, y))
        lmax = max(r, g, b, lmax)
    
    amp = 255 / lmax
    print(lmax, amp)

    for y, x in itertools.product(*[range(r) for r in ori.size[::-1]]):
        if not (x + y * xoff) % (xmod) == 0:
            continue
        r, g, b = ori.getpixel((x, y))
        r *= amp
        g *= amp
        b *= amp
        if r > 255 or g > 255 or b > 255:
            print(r, g, b)
        pixel = (int(min(r, 255)), int(min(g, 255)), int(min(b, 255)))
        pixels[x, y] = pixel

    for y, x in itertools.product(*[range(r) for r in ori.size[::-1]]):
        if (x + y * xoff) % (xmod) == 0:
            continue
        n = 0
        r, g, b = (0, 0, 0)
        radius = 1
        while n == 0:
            for rx, ry in get_circle_pixels(x, y, radius, ori.size[0], ori.size[1]):
                if not (rx + ry * xoff) % (xmod) == 0:
                    continue
                rr, gg, bb = new.getpixel((rx, ry))
                r += rr
                g += gg
                b += bb
                n += 1
            radius += 1
        pixels[x, y] = (r // n, g // n, b // n)

    new.save(
        path.parent / (posixpath.splitext(path.name)[0] + "_decoded.png"),
    )

if __name__ == "__main__":
    decode(
        sys.argv[1],
        int(sys.argv[2]) if len(sys.argv) == 4 else None,
        int(sys.argv[3]) if len(sys.argv) == 4 else None,
    )

如果选择手搓法:
打开ps,导入这张图片,接着以此选择图像,调整,色阶
然后就会看到这样的窗口:

色阶直方图的左侧有异常的高峰,那正是隐藏的里图。下一步将色阶的输入指针调整至左侧,对齐便可以得到里图
或者可以利用曲线
依然是打开ps,导入图片,但这次我们不选择色阶,而选择它下方的曲线
然后就打开了这样的窗口:

和色阶窗口类似,曲线窗口显示的图中背景为像素在色阶上的分布直方图,而我们需要调整的是图中前景的曲线。曲线的横坐标为输入,纵坐标为输出,因此和之前的操作类似,只需要将输入限制到色阶的左侧即可实现目的,曲线整体呈现先增后平的图像

2. 基于游戏本体的隐写方法

2.0 前置知识

SHP文件格式

SHP是红警中使用的图像文件,所有的 UI,地形,建筑,步兵,都使用 SHP 格式
使用XCC Mixer工具可以从ra2.mix或ra2md.mix中提取出相应的shp文件
SHP文件数据的组成
文件头、若干个帧头、若干个数据行组成
以盟军兵营的建造动画为例


文件数据结构
00-01字节,无意义
02-03字节,图片宽度,0xFA表示图片宽度250像素
04-05字节,图片高度,0x94表示图片高度148像素
06-07字节,动画总帧数,0x32表示共有50帧

恰好与XCC Mixer的预览相符合

接下来是动画帧

每个动画帧由24字节构成
00-01字节,有效区域最小X坐标 (相对于画布左上角为0,0),值为0x64表示100,坐标是从0开始的,所有坐标的范围是0到237
02-03字节,有效区域最小Y坐标,值为0x56表示86,同样是从0开始的,范围是0到201
04-05字节,有效区域的宽度 (像素数),值为0x38表示56
06-07字节,有效区域的高度 (像素数),值为0x22表示34
08-11字节,表示此帧的帧类型,目前已发现的有00,01和03两种值,数据区解析时会用到这个值
12-15字节,可能是校验值
16-19字节,分隔符
20-23字节,指向本帧像素数据在SHP文件中的绝对偏移量

同时可以发现实际渲染出的动画中,实际能看到的动画只占了一半(因为游戏中存在破损动画,需要存在额外的一套破损时的动画帧)

VXL文件格式

相对于建筑的SHP文件,战车单位方面就使用了VXL格式
VXL文件是一种3D图形结构文件,类似魔方,大部分载具(例如基洛夫空艇、磁力棒、爱国者基座以上部分、巨炮基座以上部分、坦克车身),都是以VXL文件为基础
使用XCC Mixer工具可以从ra2.mix或ra2md.mix中提取出相应的vxl文件

文件头数据结构
00-0F字节 固定的16个字符串(不包括引号),"Voxel Animation ",无意义
10-13字节 未知
14-17字节 区块数量,一般都是1
18-1B字节 未知
1C-1F字节 表示数据区的字节数
20和21字节 未知

文件头可以用来打明文

调色盘

上面两种文件的正确渲染都离不开外置的调色盘文件,正确匹配的调色盘是渲染的根基

2.1 广告牌图像隐写

在RA2的游戏地图中,常常可以见到广告牌
这个隐写方法的原理就是修改广告牌的显示内容,把原有的内容换成我们自己的hint或者是flag
因为广告牌在地图中并不起眼,所以这个隐写方法的隐蔽性还是比较高的

隐写步骤:

  1. 首先需要一张GIF,修改画布尺寸与图片相同,并记住图片的帧数。把它转换成AVI。
  2. 打开3Dmax,载入广告牌模板,把AVI拖到材质编辑球里,并指定给选定对象。如果不要边框,则直接指定给选定对象。如果需要边框,则需要在修改-面层级,点击模板中间,再指定给选定对象。
  3. 修改动画播放帧数,把帧数修改至原有帧数的两倍,之后导出
  4. 打开ImageShaper(简称IS),载入单位色盘unitdes.pal,将渲染出来的图片导入IS转换成shp文件
  5. 套用原有的广告牌的代码,在rules.ini(rulesmd.ini)和art.ini(artmd.ini)中注册自己的新广告牌
  6. 使用地图编辑器放置隐写广告牌

解题方法:

使用地图编辑器打开附件中的地图文件,直接找到广告牌,如SUSCTF 2022出现的题目ra2

另一种思路是进游戏后再一点点跑图找到地图中的广告牌,也可以风灵月影宗使用修改器开全图

2.2 单位模型隐写

广告牌隐写基于SHP文件,这个隐写方式就基于VXL文件,VXL文件是也算是一个3D建模文件,所以可以把flag文本写在载具的底部来实现隐写的效果

隐写步骤:

  1. 使用XCC Mixer提取出目标vxl文件
  2. 导入vxlse中使用画笔绘制隐写内容
  3. 导出后打包回原来的mix文件

解题方法:

进入游戏后使用爆炸气浪等掀翻载具,看到底部材质
或使用vxl编辑器看底部,如第二届黄河流域公安院校网络空间安全技能邀请赛的playing RA2
flag藏在显示名为flag注册名为CTCV的单位模型底部

2.3 地图隐写

最简单的隐写,出题人只需要使用地图编辑器在地图某片空地上绘制flag即可
对于解题人则需要探明区域视野,直接肉眼读取即可

2.4 地图触发隐写

基于游戏本身的地图机制,在编辑地图时可以设置若干触发条件(if),若满足则会执行某某操作或显示某某信息,例如

这样就通过触发来完成了一个当某个建筑物被摧毁时弹出flag的逻辑,这个隐写方式既可以进入游戏通过完成触发条件来解决,也可以通过地图编辑器编辑触发来解决