SMC

SMC（Self-Modifying Code，自修改代码） 是一种程序在执行过程中修改自身指令的技术

原理

程序运行时，动态修改内存中代码段的机器码，然后跳转到修改后的地址执行。修改方式包括：

  • 异或（XOR） — 用密钥异或加密代码段，运行时解密

  • 加减常量 — 对指令字节增减固定值

  • 直接覆写 — 用预先准备好的原始字节替换

实战案例

jocker（SMC 逆向 + IDA 脚本）

pasted_1784276813864_xysy62.png

IDA 反编译发现对 Str 和 Destination 进行了操作

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
int __cdecl main(int argc, const char **argv, const char **envp)
{
  char Str[50];
  char Destination[80];
  DWORD flOldProtect;
  size_t v7;
  int i;

  __main();
  puts("please input you flag:");
  if ( !VirtualProtect(encrypt, 0xC8u, 4u, &flOldProtect) )  // 修改 encrypt 函数内存为可写（PAGE_READWRITE）
    exit(1);                                          // 失败则退出
  scanf("%40s", Str);                                 // 读取最多 40 字符的输入（防止溢出）
  v7 = strlen(Str);                                   // 获取输入长度
  if ( v7 != 24 )                                     // 长度必须为 24
  {
    puts("Wrong!");                                   // 长度不符则输出错误
    exit(0);                                          // 退出
  }
  strcpy(Destination, Str);                           // 备份原始输入到 Destination
  wrong(Str);                                         // 对输入执行某种变换/处理
  omg(Str);                                           // 对输入执行另一种变换/处理
  for ( i = 0; i <= 186; ++i )                        // 循环 187 次
    *(encrypt + i) ^= 0x41u;                          // 逐字节异或 0x41，解密 encrypt 函数代码
  if ( encrypt(Destination) )                         // 调用解密后的 encrypt 函数验证处理后的输入
    finally(Destination);                             // 验证成功则调用 finally 输出最终结果（flag）
  return 0;
}

最后输出 flag 的校验是由 encrypt 函数决定

反编译这个函数报错，这是 SMC 解密前的密文被 IDA 强行当作指令反汇编的结果

proc far、sp-analysis failed、异常的 retf 和大量无意义指令都是明显特征，不需要继续分析这些乱码

pasted_1784277660011_u982ch.png

回头看 main 函数的这段代码

1
2
for ( i = 0; i <= 186; ++i )
    *(encrypt + i) ^= 0x41u;

找到 encrypt 的具体地址

pasted_1784278544504_aqz0ha.png

因此需要处理

1
2
3
4
起始地址：0x401500
结束地址：0x4015BA，包含该字节
长度：0xBB
算法：每个字节 XOR 0x41
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
import ida_auto
import ida_bytes
import ida_funcs
import ida_ua

START = 0x401500
END = 0x4015BB       # 结束地址不包含，所以实际最后一个字节是 0x4015BA

# 删除 IDA 当前错误识别的函数
for address in (0x401500, 0x40159A):
    function = ida_funcs.get_func(address)
    if function is not None:
        ida_funcs.del_func(function.start_ea)

# 对数据库中的字节进行 XOR 解密
for address in range(START, END):
    old_byte = ida_bytes.get_byte(address)
    ida_bytes.patch_byte(address, old_byte ^ 0x41)

# 清除原来的错误反汇编结果
ida_bytes.del_items(
    START,
    ida_bytes.DELIT_EXPAND,
    END - START
)

# 重新创建指令
address = START

while address < END:
    instruction_size = ida_ua.create_insn(address)

    if instruction_size <= 0:
        address += 1
    else:
        address += instruction_size

# 重新设置两个函数的范围
ida_funcs.add_func(0x401500, 0x40159A)
ida_funcs.add_func(0x40159A, 0x401641)

ida_auto.auto_wait()

点击脚本文件导入进去

pasted_1784280172311_ohlu7w.png

解密出正确的指令

pasted_1784280623155_31j69u.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
26
27
28
29
30
// 验证输入前 19 字符：与 "hahahaha_do_you_find_me?" 异或后等于硬编码数组
int encrypt(char* input) {
    int array[19];
    memcpy(array, (void*)0x403040, 19 * sizeof(int)); // 从全局数据复制 19 个整数
    int flag = 1;

    for (int i = 0; i <= 18; i++) {
        char key_char = "hahahaha_do_you_find_me?"[i]; // 取密钥对应字符
        if ((key_char ^ input[i]) != array[i]) {       // 异或后与期望数组比较
            puts("wrong ~");
            exit(0);                                   // 不匹配则退出
        }
    }

    puts("come here");
    return flag;
}

// 以随机小概率输出成功，实际只比较输入的第一个字符
void finally(char* input) {
    char local[5] = "%tp&:";           // 比较字符串
    srand(time(0));
    int rand_val = rand() % 100;       // 0~99 的随机数
    int mismatch = (local[0] != input[0]); // 比较第 1 个字符，不等为 1，等为 0

    if (mismatch == rand_val)          // 只有 rand_val 等于该值时打印成功（极低概率）
        puts("Really??? Did you find it?OMG!!!");
    else
        puts("I hide the last part, you will not succ...");
}

查看 0x403040 处的数据，然后写脚本反推

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
buffer = b"hahahaha_do_you_find_me?"

array = [
    0x0E, 0x0D, 0x09, 0x06, 0x13,
    0x05, 0x58, 0x56, 0x3E, 0x06,
    0x0C, 0x3C, 0x1F, 0x57, 0x14,
    0x6B, 0x57, 0x59, 0x0D
]

first_part = bytes(
    buffer[i] ^ array[i]
    for i in range(19)
)

print(first_part)

得到 b'flag{d07abccf8a410c'

回到 main()，程序检查输入长度为 24 字节，还少了 5 字节

在 finally 函数中看到字符串 %tp&: 刚好是 5 字节

pasted_1784281226031_bhgz66.png

假设 ':' XOR key = '}'，则 key 为 0x47

1
2
3
4
5
6
cipher = b"%tp&:"
key = 0x47

tail = bytes(c ^ key for c in cipher)

print(tail)

得到 b'b37a}'

拼接得到 flag{d07abccf8a410cb37a}