看雪CTF第八题

IDA查看Exports有3个TlsCallback

只有TlsCallback_2有用

其中创建6个线程用于代码动态解码smc

只有前三个线程有用 分别对check_part1,check_part2,check_part3代码解码

HANDLE sub_402C70()
{
  hMutex = CreateMutexW(0, 0, "Mutex");
  CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_smc1, 0, 0, 0);
  CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_smc2, 0, 0, 0);
  CreateThread(0, 0, (LPTHREAD_START_ROUTINE)thread_smc3, 0, 0, 0);
  CreateThread(0, 0, (LPTHREAD_START_ROUTINE)sub_402BB0, 0, 0, 0);
  CreateThread(0, 0, (LPTHREAD_START_ROUTINE)sub_402BF0, 0, 0, 0);
  return CreateThread(0, 0, (LPTHREAD_START_ROUTINE)sub_402C30, 0, 0, 0);
}

 

thread_smc1

void __stdcall __noreturn thread_smc1(LPVOID lpThreadParameter)
{
  signed int v1; // eax@2
  signed int v2; // ecx@4
  signed int v3; // esi@4
  char v4; // bl@5
  char *v5; // eax@5
  char v6; // dl@5
  DWORD flOldProtect; // [sp+Ch] [bp-10h]@2
  char v8[6]; // [sp+10h] [bp-Ch]@1

  while ( 1 )
  {
    v8[0] = -117;
    v8[1] = -64;
    v8[2] = -117;
    v8[3] = -1;
    v8[4] = -117;
    v8[5] = -37;
    WaitForSingleObject(hMutex, 0xFFFFFFFF);
    if ( thread_flag == 1 )
    {
      flOldProtect = 0;
      VirtualProtect(check_part1, 0x2Eu, 0x40u, &flOldProtect);
      v1 = 1;
      do
      {
        *((_BYTE *)check_part1 + v1 - 1) ^= byte_4064F0[v1 - 1];
        *((_BYTE *)check_part1 + v1) ^= byte_4064F0[v1];
        v1 += 2;
      }
      while ( v1 - 1 < 46 );
      VirtualProtect(check_part1, 0x2Eu, flOldProtect, &flOldProtect);
      VirtualProtect(smc_code1, 6u, 0x40u, &flOldProtect);
      v2 = 0;
      v3 = (_BYTE *)smc_code1 - v8;
      do
      {
        v4 = v8[v2];
        v5 = &v8[v2];
        v6 = *(&v8[v2++] + v3);
        v5[v3] = v4;
        *v5 = v6;
      }
      while ( v2 < 6 );
      VirtualProtect(smc_code1, 6u, flOldProtect, &flOldProtect);
      thread_flag = 0;
    }
    ReleaseMutex(hMutex);
    Sleep(0x32u);
  }
}

thread_smc2

void __stdcall __noreturn thread_smc2(LPVOID lpThreadParameter)
{
  signed int v1; // eax@3
  signed int v2; // ecx@5
  signed int v3; // esi@5
  char v4; // bl@6
  char *v5; // eax@6
  char v6; // dl@6
  DWORD flOldProtect; // [sp+10h] [bp-10h]@3
  char v8[6]; // [sp+14h] [bp-Ch]@1

  v8[0] = -117;
  v8[1] = -64;
  v8[2] = -117;
  v8[3] = -37;
  v8[4] = -117;
  v8[5] = -1;
  while ( 1 )
  {
    WaitForSingleObject(hMutex, 0xFFFFFFFF);
    if ( thread_flag == 2 )
    {
      flOldProtect = 0;
      VirtualProtect(check_part2, 0x2Eu, 0x40u, &flOldProtect);
      v1 = 1;
      do
      {
        *((_BYTE *)check_part2 + v1 - 1) ^= byte_406520[v1 - 1];
        *((_BYTE *)check_part2 + v1) ^= byte_406520[v1];
        v1 += 2;
      }
      while ( v1 - 1 < 46 );
      VirtualProtect(check_part2, 0x2Eu, flOldProtect, &flOldProtect);
      VirtualProtect(smc_code2, 6u, 0x40u, &flOldProtect);
      v2 = 0;
      v3 = (_BYTE *)smc_code2 - v8;
      do
      {
        v4 = v8[v2];
        v5 = &v8[v2];
        v6 = *(&v8[v2++] + v3);
        v5[v3] = v4;
        *v5 = v6;
      }
      while ( v2 < 6 );
      VirtualProtect(smc_code2, 6u, flOldProtect, &flOldProtect);
      thread_flag = 0;
    }
    ReleaseMutex(hMutex);
    Sleep(0x32u);
  }
}

 

thread_smc3

void __stdcall __noreturn thread_smc3(LPVOID lpThreadParameter)
{
  signed int v1; // eax@3
  char *v2; // ecx@5
  signed int v3; // eax@5
  char v4; // bl@6
  DWORD flOldProtect; // [sp+10h] [bp-10h]@3
  char v6[6]; // [sp+14h] [bp-Ch]@1

  v6[0] = -117;
  v6[1] = -1;
  v6[2] = -117;
  v6[3] = -64;
  v6[4] = -117;
  v6[5] = -37;
  while ( 1 )
  {
    WaitForSingleObject(hMutex, 0xFFFFFFFF);
    if ( thread_flag == 3 )
    {
      flOldProtect = 0;
      VirtualProtect(check_part3, 0x2Eu, 0x40u, &flOldProtect);
      v1 = 1;
      do
      {
        *((_BYTE *)check_part3 + v1 - 1) ^= byte_406550[v1 - 1];
        *((_BYTE *)check_part3 + v1) ^= byte_406550[v1];
        v1 += 2;
      }
      while ( v1 - 1 < 46 );
      VirtualProtect(check_part3, 0x2Eu, flOldProtect, &flOldProtect);
      VirtualProtect(smc_code3, 6u, 0x40u, &flOldProtect);
      v2 = (char *)smc_code3;
      v3 = 0;
      do
      {
        v4 = v6[v3];
        v6[v3] = *v2;
        *v2 = v4;
        ++v3;
        ++v2;
      }
      while ( v3 < 6 );
      VirtualProtect(smc_code3, 6u, flOldProtect, &flOldProtect);
      thread_flag = 0;
    }
    ReleaseMutex(hMutex);
    Sleep(0x32u);
  }
}

 

调用check_part1前，会置thread_flag=1, 这个时候thread_smc1开始解密

调用check_part1后，会置thread_flag=1, 这个时候thread_smc1开始加密

 

调用check_part2前，会置thread_flag=2, 这个时候thread_smc2开始解密

调用check_part2后，会置thread_flag=2, 这个时候thread_smc2开始加密

 

调用check_part3前，会置thread_flag=3, 这个时候thread_smc3开始解密

调用check_part3后，会置thread_flag=3, 这个时候thread_smc3开始加密

 

 

smc需要还原代码

import idaapi
tmp_point = {0x4068E4:0x4025DC, 0x4068E0:0x40263C, 0x4068EC:0x40269C}
def dec_func(func_addr, key_addr, tmp_addr, tmp):
    func = bytearray(idaapi.get_many_bytes(func_addr, 0x2E))
    key = bytearray(idaapi.get_many_bytes(key_addr, 0x2E))
    for i in xrange(len(func)):
        func[i] ^= key[i]
    idaapi.patch_many_bytes(func_addr, str(func))
    idaapi.patch_many_bytes(tmp_point[tmp_addr], str(bytearray(tmp)))
dec_func(0x401EC0, 0x4064F0, 0x4068E4, [0x8B, 0xC0, 0x8B, 0xFF, 0x8B, 0xDB])
dec_func(0x402090, 0x406520, 0x4068E0, [0x8B, 0xC0, 0x8B, 0xDB, 0x8B, 0xFF])
dec_func(0x4021D0, 0x406550, 0x4068EC, [0x8B, 0xFF, 0x8B, 0xC0, 0x8B, 0xDB])

 

fn_check

int __cdecl fn_check(const char *src)
{
  int result; // eax@14
  char v2; // [sp+20h] [bp-110h]@3
  char Dst; // [sp+21h] [bp-10Fh]@3
  char v4; // [sp+34h] [bp-FCh]@4
  char v5; // [sp+35h] [bp-FBh]@5
  char v6; // [sp+5Dh] [bp-D3h]@6
  char v7; // [sp+5Eh] [bp-D2h]@7
  int len; // [sp+128h] [bp-8h]@2
  int v9; // [sp+12Ch] [bp-4h]@3

  lpAddress = &loc_4025DC;
  dword_4068E0 = &loc_40263C;
  dword_4068EC = &loc_40269C;
  if ( (unsigned __int8)crc_check()
    && (len = strlen(src), len <= 0x100)
    && (v2 = 0, memset(&Dst, 0, 0xFFu), v9 = base64_decode(&v2), strlen(&v2) == 0x5A)
    && v4 == '-'
    && v5 == '-'
    && v6 == '-'
    && v7 == '-' )
  {
    if ( !(unsigned __int8)crc_check() )
      ExitProcess(1u);
    thread_flag = 1;
    while ( thread_flag )
      ;
    if ( ((int (__cdecl *)(char *))check_part1)(&v2) )
    {
      thread_flag = 1;
      while ( thread_flag )
        ;
      if ( !(unsigned __int8)crc_check() )
        ExitProcess(1u);
      thread_flag = 2;
      while ( thread_flag )
        ;
      if ( ((int (__cdecl *)(char *))check_part2)(&v2) )
      {
        thread_flag = 2;
        while ( thread_flag )
          ;
        if ( !(unsigned __int8)crc_check() )
          ExitProcess(1u);
        thread_flag = 3;
        while ( thread_flag )
          ;
        if ( (*(int (__cdecl **)(char *))check_part3)(&v2) )
        {
          thread_flag = 3;
          while ( thread_flag )
            ;
          if ( !(unsigned __int8)crc_check() )
            ExitProcess(1u);
          result = 1;
        }
        else
        {
          result = 0;
        }
      }
      else
      {
        result = 0;
      }
    }
    else
    {
      result = 0;
    }
  }
  else
  {
    result = 0;
  }
  return result;
}

 

check_part1

signed int __cdecl fn_check_part1(_BYTE *a1)
{
  unsigned __int64 v1; // rax@1
  _BYTE *v2; // eax@1
  signed int v3; // edx@1
  char v4; // bl@3
  bool v5; // zf@3
  const char *v6; // esi@4
  signed int result; // eax@6
  unsigned __int64 v8; // [sp+10h] [bp-28h]@4
  signed int v9; // [sp+14h] [bp-24h]@1
  unsigned __int64 v10; // [sp+30h] [bp-8h]@1

  __asm { fcmovnbe st, st(2) }
  v1 = __rdtsc();
  v10 = (unsigned int)v1 + ((unsigned __int64)HIDWORD(v1) << 32);
  v2 = a1;
  v3 = &unk_99B6F1 - (_UNKNOWN *)a1;
  v9 = 4;
  while ( 1 )
  {
    v4 = *v2 ^ v2["abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" - a1];
    v2 += 5;
    v2[&unk_99B6F0 - (_UNKNOWN *)a1 - 5] = v4;
    v2[v3 - 5] = *(v2 - 4) ^ v2[4215109 - (_DWORD)a1 - 5];
    v2[&unk_99B6F2 - (_UNKNOWN *)a1 - 5] = *(v2 - 3) ^ v2[4215110 - (_DWORD)a1 - 5];
    v2[&unk_99B6F3 - (_UNKNOWN *)a1 - 5] = *(v2 - 2) ^ v2[4215111 - (_DWORD)a1 - 5];
    v5 = v9-- == 1;
    v2[byte_99B6F4 - a1 - 5] = *(v2 - 1) ^ v2[4215112 - (_DWORD)a1 - 5];
    if ( v5 )
      break;
    v3 = &unk_99B6F1 - (_UNKNOWN *)a1;
  }
  v6 = (const char *)sub_403EA0(&unk_99B6F0, aXztrprtzxzrt_0);
  v8 = __rdtsc();
  if ( !strcmp(v6, aPwwRWX_Zhejg_0)
    && (unsigned int)v8 + ((unsigned __int64)HIDWORD(v8) << 32) - v10 < (unsigned int)&unk_87A238 )
  {
    operator delete(v6);
    result = 1;
  }
  else
  {
    operator delete(v6);
    result = 0;
  }
  return result;
}

 

check_part2

signed int __cdecl check_part2(int a1)
{
  unsigned __int64 v1; // rax@1
  unsigned __int64 v2; // kr00_8@1
  signed int v3; // eax@1
  char v4; // dl@2
  const char *v5; // esi@3
  unsigned __int64 v7; // ST20_8@6

  __asm { fcmovnbe st, st(2) }
  v1 = __rdtsc();
  v2 = ((unsigned __int64)HIDWORD(v1) << 32) + (unsigned int)v1;
  v3 = 0;
  do
  {
    v4 = aAbcdefghijklmn[v3] ^ *(_BYTE *)(a1 + v3 + 22);
    v3 += 3;
    *(_BYTE *)(v3 + 10073861) = v4;
    *(_BYTE *)(v3 + 10073862) = *(_BYTE *)(v3 + 4215106) ^ *(_BYTE *)(a1 + v3 + 20);
    *(_BYTE *)(v3 + 10073863) = *(_BYTE *)(v3 + 4215107) ^ *(_BYTE *)(a1 + v3 + 21);
  }
  while ( v3 < 39 );
  v5 = (const char *)sub_403EA0(10073864, 10073864);
  sub_403DC0(v5, aXuvwttsQzrXB_0);
  if ( strcmp(v5, a13095069099216) )
  {
    operator delete(v5);
    return 0;
  }
  operator delete(v5);
  v7 = __rdtsc();
  if ( (unsigned int)v7 + ((unsigned __int64)HIDWORD(v7) << 32) - v2 >= 0x14B230CE38i64 )
    return 0;
  return 1;
}

 

 

check_part3

int __cdecl check_part3(int a1)
{
  unsigned __int64 v1; // rax@1
  char *v2; // edi@1
  char *v3; // ecx@1
  signed int v4; // ebx@1
  signed int v5; // esi@2
  signed int v6; // ecx@3
  char v7; // al@4
  char v8; // al@6
  char v9; // al@8
  char v10; // al@10
  char v11; // al@12
  char v12; // al@14
  char v13; // al@16
  char v14; // al@18
  char v15; // al@20
  char v16; // al@22
  char v17; // al@24
  char v18; // al@26
  int result; // eax@29
  unsigned __int64 v20; // rax@32
  unsigned __int64 v21; // [sp+18h] [bp-2E8h]@1
  char v22; // [sp+20h] [bp-2E0h]@29
  int v23; // [sp+24h] [bp-2DCh]@29
  int v24[40]; // [sp+28h] [bp-2D8h]@30
  char v25; // [sp+170h] [bp-190h]@29
  char v26; // [sp+2C4h] [bp-3Ch]@1
  char Dst; // [sp+2C5h] [bp-3Bh]@1
  char v28; // [sp+2C6h] [bp-3Ah]@12
  char v29; // [sp+2C7h] [bp-39h]@16
  char v30; // [sp+2C8h] [bp-38h]@20
  char v31[51]; // [sp+2C9h] [bp-37h]@24

  v1 = __rdtsc();
  v21 = (unsigned int)v1 + ((unsigned __int64)HIDWORD(v1) << 32);
  sub_4010C0();
  v26 = 0;
  memset(&Dst, 0, 0x37u);
  v2 = (char *)(a1 + 63);
  v3 = &Dst;
  v4 = 27;
  do
  {
    v5 = *v2;
    *(v3 - 1) = *v2 / 16;
    *v3 = v5 % 16;
    ++v2;
    v3 += 2;
    --v4;
  }
  while ( v4 );
  v6 = 0;
  do
  {
    v7 = *(&v26 + v6);
    if ( v7 < 0 || v7 > 9 )
      v8 = v7 + 55;
    else
      v8 = v7 + 48;
    *(&v26 + v6) = v8;
    v9 = *(&Dst + v6);
    if ( v9 < 0 || v9 > 9 )
      v10 = v9 + 55;
    else
      v10 = v9 + 48;
    *(&Dst + v6) = v10;
    v11 = *(&v28 + v6);
    if ( v11 < 0 || v11 > 9 )
      v12 = v11 + 55;
    else
      v12 = v11 + 48;
    *(&v28 + v6) = v12;
    v13 = *(&v29 + v6);
    if ( v13 < 0 || v13 > 9 )
      v14 = v13 + 55;
    else
      v14 = v13 + 48;
    *(&v29 + v6) = v14;
    v15 = *(&v30 + v6);
    if ( v15 < 0 || v15 > 9 )
      v16 = v15 + 55;
    else
      v16 = v15 + 48;
    *(&v30 + v6) = v16;
    v17 = v31[v6];
    if ( v17 < 0 || v17 > 9 )
      v18 = v17 + 55;
    else
      v18 = v17 + 48;
    v31[v6] = v18;
    v6 += 6;
  }
  while ( v6 < 54 );
  sub_401C50(&v26, 16);
  sub_4010C0();
  sub_401C50(&unk_99B6F0, 10);
  sub_4010C0();
  sub_401C50(10073864, 10);
  sub_401A90(&v22, &v25);
  result = 0;
  if ( v23 == 4 )
  {
    while ( v24[result] == dword_4064E0[result] )
    {
      ++result;
      if ( result >= 4 )
      {
        v20 = __rdtsc();
        if ( (unsigned int)v20 + ((unsigned __int64)HIDWORD(v20) << 32) - v21 < 0x54C5638 )
          return 1;
        break;
      }
    }
    result = 0;
  }
  return result * 4;
}

 

 

 

 

vm_context

00000000 vm_context      struc ; (sizeof=0x70, mappedto_32)
00000000 r0              dd ?
00000004 r1              dd ?
00000008 r2              dd ?
0000000C r3              dd ?
00000010 r4              dd ?
00000014 opcode          dd ?
00000018 cmdA0           dd ?
0000001C fn_set_imm      dd ?
00000020 cmdA1           dd ?
00000024 fn_xor_r0_r1    dd ?
00000028 cmdA2           dd ?
0000002C fn_cmp          dd ?
00000030 cmdA4           dd ?
00000034 fn_prompt       dd ?
00000038 cmdA5           dd ?
0000003C fn_exit         dd ?
00000040 cmdA3           dd ?
00000044 fn_null         dd ?
00000048 cmdA6           dd ?
0000004C fn_jnz          dd ?
00000050 cmdA7           dd ?
00000054 fn_input        dd ?
00000058 cmdA8           dd ?
0000005C fn_output       dd ?
00000060 cmdA9           dd ?
00000064 fn_check        dd ?
00000068 cmdAA           dd ?
0000006C fn_decrypt_string dd ?
00000070 vm_context      ends

vm_init()

void *__usercall vm_init@<eax>(vm_context *vm_ctx@<eax>, void *data_start)
{
  char *v2; // ecx@1
  signed int v3; // edx@1

  vm_ctx->r0 = 0;
  vm_ctx->r1 = 0;
  vm_ctx->r2 = 0;
  vm_ctx->r3 = 0;
  vm_ctx->r4 = 0;
  v2 = (char *)&vm_ctx->cmdA0;
  v3 = 32;
  do
  {
    *v2 = 0;
    v2 += 8;
    --v3;
  }
  while ( v3 );

  LOBYTE(vm_ctx->cmdA0) = 0xA0u;
  vm_ctx->fn_set_imm = (int)fn_set_imm;
  LOBYTE(vm_ctx->cmdA1) = 0xA1u;
  vm_ctx->fn_xor_r0_r1 = (int)fn_xor_r0_r1;
  LOBYTE(vm_ctx->cmdA2) = 0xA2u;
  vm_ctx->fn_cmp = (int)fn_cmp;
  LOBYTE(vm_ctx->cmdA4) = 0xA4u;
  vm_ctx->fn_prompt = (int)fn_prompt;
  LOBYTE(vm_ctx->cmdA5) = 0xA5u;
  vm_ctx->fn_exit = (int)fn_exit;
  LOBYTE(vm_ctx->cmdA3) = 0xA3u;
  vm_ctx->fn_null = (int)fn_null;
  LOBYTE(vm_ctx->cmdA6) = 0xA6u;
  vm_ctx->fn_jnz = (int)fn_jnz;
  LOBYTE(vm_ctx->cmdA7) = 0xA7u;
  vm_ctx->fn_input = (int)fn_input;
  LOBYTE(vm_ctx->cmdA8) = 0xA8u;
  vm_ctx->fn_output = (int)fn_output;
  LOBYTE(vm_ctx->cmdA9) = 0xA9u;
  vm_ctx->fn_check = (int)fn_check;
  LOBYTE(vm_ctx->cmdAa) = 0xAAu;
  vm_ctx->fn_decrypt_string = (int)fn_decrypt_string;
  return memset(data_start, 0, 0x1000u);
}

vm_dispatcher()

int __usercall vm_dispatcher@<eax>(int opcode_start@<eax>, vm_context *vm_ctx@<esi>, int data_start)
{
  char *vm_handler_type; // ecx@2

  vm_ctx->opcode = opcode_start;
  while ( *(_BYTE *)vm_ctx->opcode != 0xA3u )
  {
    opcode_start = 0;
    vm_handler_type = (char *)&vm_ctx->cmdA0;
    while ( opcode_start < 0x20 )
    {
      if ( *(_BYTE *)vm_ctx->opcode == *vm_handler_type )
      {
        opcode_start = (*((int (__cdecl **)(_DWORD, _DWORD))&vm_ctx->fn_set_imm + 2 * opcode_start))(vm_ctx, data_start);
        break;
      }
      ++opcode_start;
      vm_handler_type += 8;
    }
  }
  return opcode_start;
}

自定义vm虚拟机

 

python指令解析器

 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 代码段
text = [0xAA, 0x15, 0x20, 0x01, 0x00, 0x00, 0xAA, 0x15, 0x40, 0x01, 0x00, 0x00, 0xA0, 0x10, 0x00, 0x00,
        0x00, 0x00, 0xA8, 0xA0, 0x10, 0xF0, 0x00, 0x00, 0x00, 0xA8, 0xA0, 0x10, 0x60, 0x01, 0x00, 0x00,
        0xA7, 0xAA, 0x11, 0x80, 0x00, 0x00, 0x00, 0xAA, 0x10, 0x60, 0x00, 0x00, 0x00, 0xAA, 0x12, 0xB0,
        0x00, 0x00, 0x00, 0xA9, 0xA2, 0xEA, 0xA6, 0x0E, 0xA0, 0x10, 0x20, 0x01, 0x00, 0x00, 0xA0, 0x11,
        0x10, 0x01, 0x00, 0x00, 0xA4, 0xA5, 0xA0, 0x10, 0x40, 0x01, 0x00, 0x00, 0xA0, 0x11, 0x10, 0x01,
        0x00, 0x00, 0xA4, 0xA5]

def toUint(arr):
        return arr[0] | (arr[1]<<8 | arr[2]<<16 | arr[3]<<24)

class Context:
        def __init__(self):
                self.ip = 0
        def cmdA0(self):
                c = text[self.ip + 1]
                p = toUint(text[self.ip+2:self.ip+6])
                self.ip += 6
                if 0x10 <= c <= 0x13:
                        print "mov r{0}, {1}".format(c-0x10, hex(p))
                elif c == 0x14:
                        print "movb r0, [{0}]".format(hex(p))
                elif c == 0x15:
                        print "movb [{0}], r0".format(hex(p))
                else:
                        assert False
        def cmdA1(self):
                self.ip += 1
                print "xor r0, r1"
        def cmdA2(self):
                p = text[self.ip+1]
                self.ip += 2
                print "equb r0, [{0}]".format(hex(p))
        def cmdA3(self):
                assert False
        def cmdA4(self):
                self.ip += 1
                print "msg [r0], [r1]"
        def cmdA5(self):
                self.ip += 1
                print "exit"
        def cmdA6(self):
                p = text[self.ip + 1]
                self.ip += 2
                print "jne +{0}".format(hex(p))
        def cmdA7(self):
                self.ip += 1
                print "in [r0]"
        def cmdA8(self):
                self.ip += 1
                print "out [r0]"
        def cmdA9(self):
                self.ip += 1
                print "check [r0]"
        def cmdAA(self):
                c = text[self.ip + 1]
                p = toUint(text[self.ip+2:self.ip+6])
                self.ip += 6
                if 0x10 <= c <= 0x12:
                        print "xorstr key{0}, [{1}], [32]".format(c - 0x10, hex(p))
                else:
                        print "xorstr [{0}], [32]".format(hex(p))
        def run(self):
                ops = [self.cmdA0, self.cmdA1, self.cmdA2, self.cmdA3, self.cmdA4, self.cmdA5,
                        self.cmdA6, self.cmdA7, self.cmdA8, self.cmdA9, self.cmdAA]
                while self.ip < len(text):
                        c = text[self.ip]
                        ops[c - 0xA0]()

ctx = Context()
ctx.run()

运行结果

xorstr [0x120], [32]
xorstr [0x140], [32]
mov r0, 0x0
out [r0]
mov r0, 0xf0
out [r0]
mov r0, 0x160
in [r0]
xorstr key1, [0x80], [32]
xorstr key0, [0x60], [32]
xorstr key2, [0xb0], [32]
check [r0]
equb r0, [0xea]
jne +0xe
mov r0, 0x120
mov r1, 0x110
msg [r0], [r1]
exit
mov r0, 0x140
mov r1, 0x110
msg [r0], [r1]
exit