视频也可以含恶意代码吗 - Watermelonabc的Blog

Note

本题为“中国高校智能机器人创意大赛产教融合赛道-软件系统安全赛”的 re1，可惜的是我在比赛期间没有解出。只能说恐怕离了 AI 我就啥也不是了哎 😔

1. 题目背景#

本题的参考项目应该是这个：Malicious-PixelCode。GitHub 提交记录显示是 25 年 11 月上传的，算是一个 Real World 题目了。

首先，计算机中的视频本质上仍是一串字节序列，只要是字节序列就会有程序可以读取。

你可以观看不依赖三方库和框架，直接操纵像素在 CPU 上跑 Shader | Tsoding，看看纯代码是如何生成简单图像和视频的。

像素代码 (Pixel Code) 是以可视化像素的形式表示二进制数据的技术。每个像素通过将可执行字节转换为结构化的彩色矩阵来编码原始文件的一小部分，数据可以存储、传输或嵌入图像或视频中而不暴露原始形式。

该技术常被用于研究数据混淆、隐蔽存储和非常规编码通道。通过将恶意软件转化为基于像素的表示形式，攻击者可能试图将其负载伪装成无害的多媒体内容。这些编码文件随后可以上传到合法平台，绕过传统的安全过滤器，向外界传达一种可信赖的假象。攻击者控制的加载器或解码器随后可以检索视频并重建原始恶意文件。

整体流程是这样的：

编写攻击负载并构建为可执行文件
生成的可执行文件会通过专门设计用于将二进制数据转换为像素代码的基于 Python 的工具进行处理。该工具将可执行文件转换为可视化的 MP4 视频，二进制字节以像素值的形式嵌入帧中。
生成 Pixel Code MP4 文件后，会作为标准视频上传到视频平台。
编写 Python Stager 脚本以从视频中重建代码
将 Stager 脚本转换为编码序列（这里是先转成 EXE 再 Base64 一次），嵌入加载器代码
构建加载器

当目标机器下载并运行加载器后，加载器会自动从视频网站下载视频。然后加载器重建 Stager 脚本，Stager 脚本再从视频里重建攻击负载，最后攻击负载执行，实现攻击目的。

2. 题目分析#

本题给了两个文件：ELF 格式的 Loader 和 video.mp4。打开 video.mp4 的话会看到一系列条码在“滚动”。

加载 Loader 会发现附带调试信息，因此总体是比较清晰的：

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  __int64 v3; // rax
4
  __int64 v4; // rax
5
  __int64 v5; // rax
6
  int v6; // ebx
7
  __int64 v7; // rax
8
  const char *file; // rax
9
  _BYTE v10[9]; // [rsp+7h] [rbp-99h] BYREF
10
  _BYTE *v11; // [rsp+10h] [rbp-90h]
11
  _BYTE *v12; // [rsp+18h] [rbp-88h]
12
  __int64 videoFile[4]; // [rsp+20h] [rbp-80h] BYREF
13
  __int64 src[4]; // [rsp+40h] [rbp-60h] BYREF
14
  __int64 File[7]; // [rsp+60h] [rbp-40h] BYREF
15

16
  File[5] = __readfsqword(0x28u);
17
  *(_QWORD *)&v10[1] = v10;
18
  std::string::basic_string(videoFile, "video.mp4", v10);
19
  std::__new_allocator<char>::~__new_allocator(v10);
20
  if ( file_exists(videoFile) )
21
  {
22
    v11 = v10;
23
    std::string::basic_string(
24
      File,
25
      stager_pyc_base64,                        // "delete"
26
      v10);                                     // "delete"
27
    base64_decode(src, File);
28
    std::string::~string();
29
    std::__new_allocator<char>::~__new_allocator(v10);
30
    v12 = v10;
31
    std::string::basic_string(File, "stager.pyc", v10);
32
    std::__new_allocator<char>::~__new_allocator(v10);
33
    if ( (unsigned __int8)write_string_to_file((__int64)File, src) == 1 )
34
    {
35
      file = (const char *)std::string::c_str(File);
36
      chmod(file, 493u);
37
      run_python_script(File);
38
      v6 = 0;
39
    }
40
    else
41
    {
42
      v7 = std::operator<<<std::char_traits<char>>(&std::cerr, "创建 stager.pyc 失败");
43
      std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
44
      v6 = 1;
45
    }
46
    std::string::~string();
47
    std::string::~string();
48
  }
49
  else
50
  {
51
    v3 = std::operator<<<std::char_traits<char>>(&std::cerr, "错误：未找到视频文件 ");
52
    v4 = std::operator<<<char>(v3, videoFile);
53
    std::ostream::operator<<(v4, &std::endl<char,std::char_traits<char>>);
54
    v5 = std::operator<<<std::char_traits<char>>(&std::cerr, "请确保 video.mp4 位于当前目录");
55
    std::ostream::operator<<(v5, &std::endl<char,std::char_traits<char>>);
56
    v6 = 1;
57
  }
58
  std::string::~string();
59
  return v6;
60
}

Loader 的逻辑是：

这里出题者将 Stager.pyc 的字节序列删除了，只留下 "delete"，但是查看 .data 段会发现攻击用的负载编码器的编码序列没有删除。将其 dump 下来并保存为 .pyc 文件，反编译得到：

1
from PIL import Image
2
import math
3
import os
4
import sys
5
import numpy as np
6
import imageio
7
from tqdm import tqdm
8

9
def file_to_video(input_file, width, height, pixel_size, fps, output_file = (640, 480, 8, 10, 'video.mp4')):
10
    if not os.path.isfile(input_file):
11
        return None
12
    file_size = None.path.getsize(input_file)
13
    binary_string = ''
14
    with None:
15
        f = open(input_file, 'rb')
16
        for chunk in None(None((lambda : f.read(1024)), b''), math.ceil(file_size / 1024), 'KB', '读取文件', **('iterable', 'total', 'unit', 'desc')):
17
            binary_string += ''.join((lambda .0: pass)(chunk))
18
    xor_key = '10101010'
19
    xor_binary_string = ''
20
    for i in range(0, len(binary_string), 8):
21
        chunk = binary_string[i:i + 8]
22
        if len(chunk) == 8:
23
            chunk_int = int(chunk, 2)
24
            key_int = int(xor_key, 2)
25
            xor_result = chunk_int ^ key_int
26
            xor_binary_string += f'''{xor_result:08b}'''
27
            continue
28
        xor_binary_string += chunk
29

30
    binary_string = xor_binary_string
31
    pixels_per_image = (width // pixel_size) * (height // pixel_size)
32
    num_images = math.ceil(len(binary_string) / pixels_per_image)
33
    frames = []
34
    for i in tqdm(range(num_images), '生成视频帧', **('desc',)):
35
        start = i * pixels_per_image
36
        bits = binary_string[start:start + pixels_per_image]
37
        if len(bits) < pixels_per_image:
38
            bits = bits + '0' * (pixels_per_image - len(bits))
39
        img = Image.new('RGB', (width, height), 'white', **('color',))
40
        for r in range(height // pixel_size):
41
            row_start = r * (width // pixel_size)
42
            row_end = (r + 1) * (width // pixel_size)
43
            row = bits[row_start:row_end]
44
            for c, bit in enumerate(row):
45
                color = (0, 0, 0) if bit == '1' else (255, 255, 255)
46
                x1 = c * pixel_size
47
                y1 = r * pixel_size
48
                img.paste(color, (x1, y1, x1 + pixel_size, y1 + pixel_size))
49

50

51
        frames.append(np.array(img))
52

53
    with imageio.get_writer(output_file, fps, 'libx264', **('fps', 'codec')) as writer:
54
        for frame in tqdm(frames, '写入视频帧', **('desc',)):
55
            writer.append_data(frame)
56

57
if __name__ == '__main__':
58
    input_path = 'payload'
59
    if os.path.exists(input_path):
60
        file_to_video(input_path)
61
    else:
62
        sys.exit(1)

对照原始项目脚本，将原始项目脚本修改为：

1
from PIL import Image
2
import math, os
3
import numpy as np
4
from moviepy import ImageSequenceClip
5
from tqdm import tqdm
6

7
# tqdm 是进度条的库
8

9
def file_to_video(input_file, width=640, height=480, pixel_size=8, fps=10):
10
    if not os.path.isfile(input_file):
11
        print(f"Error: File '{input_file}' does not exist.")
12
        return
13

14
    file_size = os.path.getsize(input_file)
15
    binary_string = ""
16
    with open(input_file, "rb") as f:
17
        for chunk in tqdm(iterable=iter(lambda: f.read(1024), b""),
18
                         total=math.ceil(file_size/1024), unit="KB"):
19
            binary_string += "".join(f"{byte:08b}" for byte in chunk)
20

21
    xor_key = '10101010'
22
    xor_binary_string = ''
23
    for i in range(0, len(binary_string), 8):
24
        chunk = binary_string[i:i + 8]
25
        if len(chunk) == 8:
26
            chunk_int = int(chunk, 2)
27
            key_int = int(xor_key, 2)
28
            xor_result = chunk_int ^ key_int
29
            xor_binary_string += f'''{xor_result:08b}'''
30
            continue
31
        xor_binary_string += chunk
32
    binary_string = xor_binary_string
33

34
    pixels_per_image = (width // pixel_size) * (height // pixel_size)
35
    num_images = math.ceil(len(binary_string) / pixels_per_image)
36
    frames = []
37

38
    for i in tqdm(range(num_images), desc="Generating frames"):
39
        start = i * pixels_per_image
40
        bits = binary_string[start:start + pixels_per_image]
41
        img = Image.new('RGB', (width, height), color='white')
42

43
        if len(bits) < pixels_per_image:
44
            bits = bits + '0' * (pixels_per_image - len(bits))
45

46
        for r in range(height // pixel_size):
47
            row = bits[r * (width // pixel_size):(r + 1) * (width // pixel_size)]
48
            for c, bit in enumerate(row):
49
                color = (0, 0, 0) if bit == '1' else (255, 255, 255)
50
                x1, y1 = c * pixel_size, r * pixel_size
51
                img.paste(color, (x1, y1, x1 + pixel_size, y1 + pixel_size))
52

53
        frames.append(np.array(img))
54
        # print(frames)
55

56
    clip = ImageSequenceClip(frames, fps=fps)
57
    clip.write_videofile('video.mp4', fps=fps, codec='libx264')
58
    print("Video generated successfully: video.mp4")
59

60

61

62
if __name__ == "__main__":
63
    print("Convert file → video")
64
    path = input("Enter file path: ")
65
    file_to_video(path)

脚本主要分成两部分：将程序转化成二进制流并作按位异或处理；将二进制流以 8bits 为一个单位，设定位置和颜色，最终生成一个 640 × 480 @ 10FPS 的 mp4 视频文件。

Info

我怎么发现这个 GitHub 项目的呢？我在解码 pyc 文件后，发现解码结果中间有一些合法的文件名，比如 Payload_To_PixelCode_video.py，于是我就拿到 Bing 上搜，一下就搜到了这个项目（

现在正向转换我们知道是怎么回事了，但逆过来呢？

背景项目提供了一个解码器：

1
import imageio
2
import numpy as np
3
import os
4

5
def frames_to_bits_auto(frames):
6
    bits_list = []
7
    for frame in frames:
8
        gray = np.mean(frame, axis=2)
9
        h, w = gray.shape
10
        pixel_size_h = max(1, h // 256)
11
        pixel_size_w = max(1, w // 256)
12
        pixel_size = min(pixel_size_h, pixel_size_w)
13
        h_blocks = h // pixel_size
14
        w_blocks = w // pixel_size
15
        cropped = gray[:h_blocks * pixel_size, :w_blocks * pixel_size]
16
        reshaped = cropped.reshape(h_blocks, pixel_size, w_blocks, pixel_size)
17
        block_means = reshaped.mean(axis=(1, 3))
18
        block_bits = (block_means < 128).astype(np.uint8)
19
        bits_list.append(block_bits.ravel())
20
    if not bits_list:
21
        return np.array([], dtype=np.uint8)
22
    return np.concatenate(bits_list)
23

24
def bits_to_file(bits, output_file):
25
    remainder = bits.size % 8
26
    if remainder:
27
        bits = bits[: bits.size - remainder]
28
    if bits.size == 0:
29
        return False
30
    packed = np.packbits(bits, bitorder='big')
31
    try:
32
        with open(output_file, 'wb') as f:
33
            f.write(packed.tobytes())
34
        return True
35
    except:
36
        return False
37

38
def video_to_exe(video_path, output_name="Final_Result"):
39
    if not os.path.exists(video_path):
40
        return False
41
    try:
42
        reader = imageio.get_reader(video_path, 'ffmpeg')
43
    except:
44
        return False
45

46
    frames = []
47
    try:
48
        for frame in reader:
49
            frames.append(frame)
50
    except:
51
        reader.close()
52
        return False
53
    reader.close()
54

55
    bits = frames_to_bits_auto(frames)
56
    return bits_to_file(bits, output_name)
57

58
if __name__ == "__main__":
59
    video_file = "Pixel_Code_Video.mp4"
60
    out_exe = "Final_Result"
61
    success = video_to_exe(video_file, out_exe)
62
    if success and os.path.exists(out_exe):
63
        try:
64
            print("Reconstruction Success.\n")
65
            # os.startfile(out_exe)
66
        except:
67
            print("Reconstruction Failed.\n")

对比原项目提供的编码器，我们发现题目中编码器只修改了两点：一是程序字节转二进制流时的按位异或，二是二进制流数据不够时补 0。第二点在逆向时不需要关注，因此我们只需要确定这个异或操作应该出现在解码器的哪个位置。

从编码器来看，异或操作位于程序字节转成二进制流之后，那么编码器生成二进制流之后需要经过一次异或才是原始程序字节。逆异或操作位于 numpy 打包完成二进制流之后：

1
# ...
2

3
def undo_xor(data):
4
    return bytes([b ^ 0xAA for b in data]) # 0xAAh = 10101010b
5

6
def bits_to_file(bits, output_file):
7
    remainder = bits.size % 8
8
    if remainder:
9
        bits = bits[: bits.size - remainder]
10
    if bits.size == 0:
11
        return False
12
    packed = np.packbits(bits, bitorder='big')
13
    decoded = undo_xor(packed.tobytes())
14
    try:
15
        with open(output_file, 'wb') as f:
16
            f.write(decoded)
17
        return True
18
    except:
19
        return False
20

21
# ...

执行修改后的脚本，得到 Final_Result。使用 IDA 反编译，查看 .rodata 段，得到“提示：每个 MD5 哈希对应一个 ASCII 字符，按顺序组合这些字符即可得到 flag。”以及 20 个 MD5 值。解密这些 MD5 值，得到 flag：

dart{2b1f8-3045e76c}

音乐

1. 题目背景#

2. 题目分析#

文章分享

评论区