前言

这次不太好评价，感觉对我来说是降维打击，首先感谢队里的所有朋友们，是你们的陪伴和互助我才能坚持下去。

0x01红白机

看文件标题，猜测是6052汇编语言，作为上世纪的古老汇编，我自然是看不懂的，这里有个网址能运行6052汇编

如果感兴趣还有教学，该博客对6052汇编的介绍还是有理有据的。

ec51921f958fc86b6271cd70b5f3152

flag{6502_I_LOVE_u}

0x02xor

出题人说是简单的异或，我点进去一看一坨，不想看了，既然说是异或那就用异或试试看。

f67244fb95a69b6dbc8707cf453fb9d

找到这个极其可疑的字符串

image-20240201132103590

点进去打个断点调试，要你输入flag时，就把这串字符串输入进去，结果肯定是错的，但是由于异或的可逆性，这时候查看enc的值，就是正确的flag，手抄下来得到答案（偷懒取巧的做法，不可取:( ）

image-20240201132331372

flag{Virus_gonna_be_terminated!}

0x03real checkin xor

借这又一道异或题记录一下静态做法，这题的函数相比之下就人性化许多了，一眼能看出加密过程

记录一下源码

1
2
3
4
5
6
7
8
9
10
11
12
13
def verify_func(ciper,key):
    encrypted = []
    for i in range(len(ciper)):
        encrypted.append(ord(ciper[i])^ord(key[i%len(key)]))
    return encrypted

secret = [7, 31, 56, 25, 23, 15, 91, 21, 49, 15, 33, 88, 26, 48, 60, 58, 4, 86, 36, 64, 23, 54, 63, 0, 54, 22, 6, 55, 59, 38, 108, 39, 45, 23, 102, 27, 11, 56, 32, 0, 82, 24]
print("这是一个保险箱,你能输入相关的key来进行解密吗?")
input_line = input("请输入key > ")
if verify_func(input_line,"ez_python_xor_reverse") == secret:
    print("密码正确")
else:
    print("密码错误")

根据这个verify_func函数，复制过来改一下，就能得到解密脚本了捏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
secret = [7, 31, 56, 25, 23, 15, 91, 21, 49, 15, 33, 88,
          26, 48, 60, 58, 4, 86, 36, 64, 23, 54, 63, 0, 54, 22,
          6, 55, 59, 38, 108, 39, 45, 23, 102, 27, 11, 56, 32,
          0, 82, 24]
key = "ez_python_xor_reverse"
def decry(enc, key):
    ans = []
    for i in range(len(enc)):
        ans.append(enc[i] ^ ord(key[i%len(key)]))
    return ans
flag=""
for i in decry(secret ,key):
    flag += chr(i)
print(flag)

begin{3z_PY7hoN_r3V3rSE_For_TH3_Be9inNEr!}

0x04俄语学习

先找到主要的逻辑函数，观察后发现这个程序的主要逻辑是，先答对30道俄语题目然后输入flag并验证，为了便捷地动态调试这个程序，我先把前面三十道题目关于正误的判断全patch，变成答错能前进。

image-20240202002450710

if 判断里有个主要的函数，这个函数接收input（不是原本输入的），然后和encry后的enc比较，这里的enc能直接调试得到

1
2
3
enc = [ 0x38, 0x9A, 0xFA, 0xC3, 0x5B, 0x89, 0xA5, 0xE6, 0xD0, 0xAB,
        0x42, 0x58, 0x57, 0x09, 0x42, 0xAB, 0x33, 0x2F, 0x98, 0x42,
        0x2E, 0x59, 0x6D, 0x41]

然后按X查看input的引用

image-20240202002718359

发现这样一个函数，input是put和need_shuzu计算得到的（这些数组都被我改过名字），最后再encry。查找put 的引用不难发现是输入的用来验证的flag，encry函数的逻辑很简单，key可以直接调试得到

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
key = [ 0x35, 0xF1, 0xDA, 0x19, 0x7A, 0xF6, 0x31, 0x9C, 0xD9, 0x2C,
  0xC1, 0xFC, 0xE2, 0xD8, 0x1D, 0x8D, 0x4F, 0x97, 0x81, 0x26,
  0xC0, 0xB8, 0x96, 0x27, 0xD5, 0x5B, 0xAA, 0x18, 0x85, 0xFA,
  0x61, 0xE4, 0xA1, 0xBC, 0xF8, 0xA4, 0x56, 0x37, 0x43, 0x58,
  0x2B, 0xC9, 0x77, 0x64, 0xCC, 0x6B, 0x98, 0x65, 0x75, 0x38,
  0x80, 0x09, 0x11, 0x3D, 0xD0, 0xE6, 0x8F, 0xA9, 0x57, 0x99,
  0x06, 0x10, 0x5D, 0xC5, 0x69, 0xBD, 0x2D, 0x68, 0x7E, 0xE3,
  0x67, 0xD1, 0xFF, 0x5E, 0xF9, 0xF5, 0x41, 0x8C, 0xDD, 0x21,
  0x4B, 0xA7, 0x47, 0x86, 0x6D, 0xC3, 0x2A, 0x9A, 0x9F, 0x20,
  0x48, 0xBB, 0x94, 0xB9, 0xB4, 0x92, 0x02, 0x74, 0x7D, 0x1B,
  0x1E, 0x5F, 0xBA, 0x49, 0xD6, 0xE7, 0x53, 0x04, 0xCB, 0x28,
  0x3F, 0xE8, 0x33, 0x3E, 0x00, 0x9B, 0x6A, 0xFD, 0xBE, 0x1C,
  0x90, 0xED, 0xDF, 0x4D, 0x25, 0x6F, 0xB5, 0x13, 0x70, 0x3C,
  0x9E, 0x16, 0x0C, 0x05, 0x4A, 0x73, 0xDE, 0xB1, 0x8A, 0x51,
  0x3B, 0x54, 0x14, 0xE0, 0x5A, 0xDC, 0x91, 0x62, 0xA3, 0x95,
  0xD3, 0x3A, 0x17, 0xEE, 0x32, 0xF2, 0x7C, 0xAF, 0xB3, 0x88,
  0xEC, 0x0E, 0xAE, 0x9D, 0x5C, 0x0D, 0x55, 0x4E, 0xFB, 0x46,
  0x22, 0x44, 0x45, 0xBF, 0x52, 0x12, 0x66, 0x07, 0xD2, 0x36,
  0x93, 0x6E, 0x42, 0x1A, 0x0F, 0xE9, 0x60, 0xCA, 0xB2, 0x6C,
  0x83, 0xF0, 0x03, 0x76, 0xA8, 0x1F, 0x63, 0xEF, 0xA5, 0xCD,
  0x79, 0x7B, 0x0A, 0x0B, 0xAB, 0xDB, 0xD4, 0x7F, 0x01, 0x34,
  0x23, 0x59, 0xE1, 0x29, 0xC6, 0xAC, 0xA2, 0x40, 0xC8, 0xAD,
  0xC4, 0x89, 0xC2, 0xB6, 0x71, 0xA0, 0xEB, 0x2F, 0x78, 0xF3,
  0xB0, 0xFE, 0xCE, 0xF7, 0x84, 0x72, 0xF4, 0xCF, 0xC7, 0xD7,
  0xB7, 0x8E, 0x4C, 0x82, 0x30, 0x50, 0x2E, 0x24, 0x87, 0x08,
  0x39, 0xE5, 0xEA, 0xA6, 0x8B, 0x15]
1
2
3
4
5
6
7
8
9
def decry(key, enc):
        v7 = 0
        v6 = 0
        for i in range(0, len(enc)):
                v7 = (v7+1)%256
                v6 = (v6 + key[v7])%256
                key[v7], key[v6] = key[v6], key[v7]
                enc[i] ^= key[(key[v6]+key[v7]) % 256]
        return enc

这下只需知道need_shuzu，就能写出逆向脚本解了。

查找一下need_shuzu 的引用

image-20240202002957047

image-20240202003018010

不难发现，need_shuzu定义于这个sub_C4B4B4( )函数，且从未被修改，那么这就好办了，直接调试进去找到need_shuzu的值

1
2
3
4
need = [0x35, 0x6D, 0x35, 0x64, 0x35, 0x77, 0x35, 0x64, 0x35, 0x62,
        0x35, 0x6E, 0x35, 0x6D, 0x35, 0x64, 0x35, 0x77, 0x35, 0x64,
        0x35, 0x62, 0x35, 0x6E, 0x35, 0x6D, 0x35, 0x64, 0x35, 0x77,
        0x35, 0x64, 0x35, 0x62, 0x35, 0x6E, 0x8E]

最终脚本

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
43
44
45
46
47
48
49
50
51
key1 = [ 0x35, 0xF1, 0xDA, 0x19, 0x7A, 0xF6, 0x31, 0x9C, 0xD9, 0x2C,
  0xC1, 0xFC, 0xE2, 0xD8, 0x1D, 0x8D, 0x4F, 0x97, 0x81, 0x26,
  0xC0, 0xB8, 0x96, 0x27, 0xD5, 0x5B, 0xAA, 0x18, 0x85, 0xFA,
  0x61, 0xE4, 0xA1, 0xBC, 0xF8, 0xA4, 0x56, 0x37, 0x43, 0x58,
  0x2B, 0xC9, 0x77, 0x64, 0xCC, 0x6B, 0x98, 0x65, 0x75, 0x38,
  0x80, 0x09, 0x11, 0x3D, 0xD0, 0xE6, 0x8F, 0xA9, 0x57, 0x99,
  0x06, 0x10, 0x5D, 0xC5, 0x69, 0xBD, 0x2D, 0x68, 0x7E, 0xE3,
  0x67, 0xD1, 0xFF, 0x5E, 0xF9, 0xF5, 0x41, 0x8C, 0xDD, 0x21,
  0x4B, 0xA7, 0x47, 0x86, 0x6D, 0xC3, 0x2A, 0x9A, 0x9F, 0x20,
  0x48, 0xBB, 0x94, 0xB9, 0xB4, 0x92, 0x02, 0x74, 0x7D, 0x1B,
  0x1E, 0x5F, 0xBA, 0x49, 0xD6, 0xE7, 0x53, 0x04, 0xCB, 0x28,
  0x3F, 0xE8, 0x33, 0x3E, 0x00, 0x9B, 0x6A, 0xFD, 0xBE, 0x1C,
  0x90, 0xED, 0xDF, 0x4D, 0x25, 0x6F, 0xB5, 0x13, 0x70, 0x3C,
  0x9E, 0x16, 0x0C, 0x05, 0x4A, 0x73, 0xDE, 0xB1, 0x8A, 0x51,
  0x3B, 0x54, 0x14, 0xE0, 0x5A, 0xDC, 0x91, 0x62, 0xA3, 0x95,
  0xD3, 0x3A, 0x17, 0xEE, 0x32, 0xF2, 0x7C, 0xAF, 0xB3, 0x88,
  0xEC, 0x0E, 0xAE, 0x9D, 0x5C, 0x0D, 0x55, 0x4E, 0xFB, 0x46,
  0x22, 0x44, 0x45, 0xBF, 0x52, 0x12, 0x66, 0x07, 0xD2, 0x36,
  0x93, 0x6E, 0x42, 0x1A, 0x0F, 0xE9, 0x60, 0xCA, 0xB2, 0x6C,
  0x83, 0xF0, 0x03, 0x76, 0xA8, 0x1F, 0x63, 0xEF, 0xA5, 0xCD,
  0x79, 0x7B, 0x0A, 0x0B, 0xAB, 0xDB, 0xD4, 0x7F, 0x01, 0x34,
  0x23, 0x59, 0xE1, 0x29, 0xC6, 0xAC, 0xA2, 0x40, 0xC8, 0xAD,
  0xC4, 0x89, 0xC2, 0xB6, 0x71, 0xA0, 0xEB, 0x2F, 0x78, 0xF3,
  0xB0, 0xFE, 0xCE, 0xF7, 0x84, 0x72, 0xF4, 0xCF, 0xC7, 0xD7,
  0xB7, 0x8E, 0x4C, 0x82, 0x30, 0x50, 0x2E, 0x24, 0x87, 0x08,
  0x39, 0xE5, 0xEA, 0xA6, 0x8B, 0x15]

enc = [ 0x38, 0x9A, 0xFA, 0xC3, 0x5B, 0x89, 0xA5, 0xE6, 0xD0, 0xAB,
        0x42, 0x58, 0x57, 0x09, 0x42, 0xAB, 0x33, 0x2F, 0x98, 0x42,
        0x2E, 0x59, 0x6D, 0x41]
need = [0x35, 0x6D, 0x35, 0x64, 0x35, 0x77, 0x35, 0x64, 0x35, 0x62,
        0x35, 0x6E, 0x35, 0x6D, 0x35, 0x64, 0x35, 0x77, 0x35, 0x64,
        0x35, 0x62, 0x35, 0x6E, 0x35, 0x6D, 0x35, 0x64, 0x35, 0x77,
        0x35, 0x64, 0x35, 0x62, 0x35, 0x6E, 0x8E]

def decry(key, enc):
        v7 = 0
        v6 = 0
        for i in range(0, len(enc)):
                v7 = (v7+1)%256
                v6 = (v6 + key[v7])%256
                key[v7], key[v6] = key[v6], key[v7]
                enc[i] ^= key[(key[v6]+key[v7]) % 256]
        return enc
if __name__ == '__main__':
        flag = []
        input = decry(key1, enc)
        for i in range(24):
              flag.append(input[i] + 112 - need[i])
        for i in flag:
                print(chr(i), end = "")

主要逻辑就是，由enc，反推回去input，然后input再反推回去put，很好理解，其中的need_shuzu，和key通过调试能得到。这个做法看起来挺冗杂的，应该有更好的办法

flag{Russian_is_so_easy}

0x05 stick game

一个网页小游戏，根据之前搭载博客时对网页的一点点理解，觉得主要的逻辑函数应该在js文件里面。

先看看游戏，说达到1337427分就能获得flag，当然正常是不能去玩的，如果js文件没有加变量名字混淆的话，存储着分数的变量应该叫score，打开文件ctrl+F找一下score变量

d3ac6c2abfae882ecb8eed2305f1165

喜报，代码没有经过格式化，一坨。后面请教大佬朋友在vscode扩展下载了一个插件Prettier - Code formatter ，下载后选中格式化。

image-20240204182828372

继续查找score，发现有个疑似修改分数的代码，这里的_0x3c8400作为一个变量名暂存分数，然后这个0x3a2009是一个判断是否双倍得分的参数，若为True就加2分，false就加1分，那一坨0x10a5….计算出来是2，下面-0x257…算出来是1，手动给他们后面加上1337426，这样一来，如果加一分，就相当于加了1337427分。不过这些都是建立在这个代码就是控制得分的代码的基础上的假设。

image-20240204183632727

下面还有一个疑似修改分数的代码，不过这个算出来score = 0，应该不太可能是加分的代码，更像是重置分数的代码。修改完后打开游戏试试，果然成功一次就加了1337427分，这时候直接跳崖，让游戏在1337427分结束，网页弹窗显示出了flag。

完全不懂javascript，静态分析对我来说太难了，如果懂的话找下弹窗函数，和其他flag的加密函数或许能解出来，不过由于代码变量名混淆，我也看不出flag在js文件里到底长什么样。

begin{y0u_re4l1y_g07_1337427_66f1ebde263de1e039063aa402d22977}

0x06 ezpython

这题真的坑，题干一直在说key有问题，我也尝试过去找有没有函数修改了key，没想到竟然是gmssl库的sm4加密解密函数里，一个叫set_key的函数被修改了，key在填入前先做了和37的异或，确实搞到我了，flag也搞我，唉，采购。除了这个就是正常的py解包反编译，不过要用3.8python解包，不然会丢失文件（因为这题是3.8python写的）（py解包反编译梗概）。

反编译出他的ezpython文件，加以修改就能出flag了，早该如此，key 的错误一直卡死我了，唉。

ezpython.py

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#!/usr/bin/env python
# visit https://tool.lu/pyc/ for more information
# Version: Python 3.8
from secret import enc,key
from gmssl import sm4
import base64


def pad_pkcs7(data):
    '''PKCS#7填充'''
    padding_len = 16 - len(data) % 16
    padding = bytes([
        padding_len] * padding_len)
    return data + padding


def unpad_pkcs7(padded_data):
    '''PKCS#7去填充'''
    padding_len = padded_data[-1]
    return padded_data[:-padding_len]


class SM4:
    
    def __init__(self):
        self.gmsm4 = sm4.CryptSM4()

    
    def encryptSM4(self, encrypt_key, value):
        gmsm4 = self.gmsm4
        gmsm4.set_key(encrypt_key.encode(), sm4.SM4_ENCRYPT)
        padded_value = pad_pkcs7(value.encode())
        encrypt_value = gmsm4.crypt_ecb(padded_value)
        return base64.b64encode(encrypt_value)

    def decryptSM4(self, key, value):
        gmsm4 = self.gmsm4
        gmsm4.set_key(key.encode(), sm4.SM4_DECRYPT)
        padded_value = base64.b64decode(value)
        decrypted_data = gmsm4.crypt_ecb(padded_value)
        return unpad_pkcs7(decrypted_data).decode()

        # decrypted_data = unpad_pkcs7(value.decode())
        # decrypted_data = gmsm4.crypt_ecb(decrypted_data)
        # return base64.b64decode(decrypted_data)

if __name__ == '__main__':
    # print('请输入你的flag:')
    # flag = input()
    # sm4_instance = SM4()
    # flag_1 = sm4_instance.encryptSM4(key, flag)
    # if flag_1 != enc:
    #     print('flag错误!!')
    # else:
    #     print('恭喜你获得flag😊😀')
    key2 = ''
    for i in range(len(key)):
        key2 += chr(ord(key[i]) ^ 37)
    sm4_instance = SM4()
    flag_1 = sm4_instance.decryptSM4(key2, enc)
    print(flag_1)

secret.py

1
2
key = 'BeginCTFBeginCTF'
enc = b'JmjJEAJGMT6F9bmC+Vyxy8Z1lpfaJzdEX6BGG/qgqUjUpQaYSON1CnZyX9YXTEClSRYm7PFZtGxmJw6LPuw1ww=='

flag{Pay_M0re_@ttention_to_th3_key!!}

0x07 出题人的密码

一开始做的时候被一坨看不懂的东西卡住了，后面才发现那个是没用的，引以为戒。

程序点进去无法f5，一步一步看，后面才发现是有花指令，把那些call的脏字节和无意义的jnz和jn全部都nop掉，然后反编译就能看到main函数了。

image-20240207152800382

正常来说这里有很多sub函数，混淆我们找加密函数，我做的时候直接找了最后拿来比较的input和enc（input 是我自己命名的）中input 的引用，反解回去两个加密函数的

encry1

1
2
3
4
5
6
7
8
9
10
11
12
13
int sub_C98090()
{
  int result; // eax
  int i; // [esp+D0h] [ebp-8h]

  result = __CheckForDebuggerJustMyCode(&unk_D0D0F4);
  for ( i = 0; i < 48; ++i )
  {
    input[i] = (put[i] + 5) ^ 0x25;
    result = i + 1;
  }
  return result;
}

encry2

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
int sub_C97F10()
{
  int v0; // edx
  int result; // eax
  __int64 v2; // [esp+D0h] [ebp-58h]
  size_t v3; // [esp+ECh] [ebp-3Ch]
  int j; // [esp+F8h] [ebp-30h]
  int i; // [esp+104h] [ebp-24h]
  __int64 v6; // [esp+110h] [ebp-18h]
  char *v7; // [esp+120h] [ebp-8h]

  __CheckForDebuggerJustMyCode(&unk_D0D0F4);
  v3 = j__strlen(Buffer);                       // 612995005
  if ( v3 )
    j__srand(byte_D09FD7[v3]);
  else
    j__srand(0x123456u);
  v0 = j__rand() % 7;
  result = unk_D09000[2 * v0];
  LODWORD(v2) = result;
  HIDWORD(v2) = dword_D09004[2 * v0];           // 0x33077D
  for ( i = 0; i < 6; ++i )
  {
    v7 = &put[8 * i];
    v6 = *v7;
    for ( j = 0; j < 64; ++j )
    {
      if ( v6 < 0 )
        v6 = v2 ^ (2 * v6);
      else
        v6 *= 2i64;
    }
    *v7 = v6;
    result = i + 1;
  }
  return result;
}

其中encry1不多讲了，encry2是一个主要的加密函数，他的主要逻辑就是，将enc（48个字节），按小端序存储分为6个8字节大小的长整形，然后判断整形是否为负数（其实就是看最高位是否为1），若为负数，在左移一位的基础上再异或v2（v2是用魔法得到的），若不为负数，则就只是左移1位。

这个加密的难点在于根据加密后的数才判断加密前的数是正数还是负数，因为符号位在左移一位后已经丢失了。但是由此同时左移一位后的数的最低位变成了 0，恰v2的最低位也是0。因此，若加密后的数最低位是1，说明最低位经过0 ^ 0 =1 的异或，说明加密前的数是负数（因为经过异或），若加密后的数最低位是0，说明左移后没有和v2异或过，加密前是正数。

有了这个思路，逆向思路就很明了了。

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
43
44
45
46
47
48
49
50
51
52
53
54
#include<iostream>
#include<string.h>
unsigned char enc[] =
{
  0xB4, 0xBB, 0xD8, 0xEB, 0xD0, 0x6E, 0xAB, 0xCA, 0x65, 0x8E, 
  0x4B, 0xE9, 0x4D, 0xD4, 0x4A, 0xF3, 0x7D, 0x29, 0xC2, 0xF9, 
  0x95, 0x89, 0xA4, 0x85, 0x9D, 0xCD, 0xDF, 0x77, 0xFD, 0x45, 
  0xCB, 0x5D, 0x7D, 0xFD, 0x93, 0x4B, 0xBC, 0xF6, 0x7C, 0xF3, 
  0x24, 0x42, 0xF5, 0xD2, 0xDD, 0xE3, 0x56, 0xAE
};
unsigned char enc1[48];  
unsigned __int64 enc2[6];
__int64 v2 = 0x000000000033077D;
int main(){
    //encry1
    for(int i = 0;i < 48; i++){
        enc1[i] = (enc[i] ^ 0x25) - 5;
    }
    //encry2
    //小端序合并字节
    for(int i = 0; i < 6; i++){
        enc2[i] = 0;
        for(int j = 0; j < 8; j++){
            enc2[i] |= (__int64)enc1[8 * i + j] << (8 * j);
        }
        for(int k = 0; k < 64 ; k++){
            //如果enc2[i] & 1为1，说明最后一位是1，说明被异或过了，因为
            //移位后最后一位是0，而v2的最后一位也是0，若没有异或过，最后
            //一位应该是0，所以看最后一位判断之前有无异或过
            if(enc2[i] & 1){
                enc2[i] ^= v2;
                enc2[i] >>= 1;
                //由于题目里的判断是小于0，即第一位是1时异或v2，这时左移
                //会丢失数据1，应该右移后补上
                enc2[i] |= 0x8000000000000000;
            }
            else{
                enc2[i] >>= 1;
            }
        }
    }
    //小端序分离
    for(int i = 0; i < 6; i++){
        for(int j = 0; j < 8;j++){
            enc[8 * i + j] = (enc2[i] >> (8 * j)) & 0xFF;
        }
    }
    //输出flag
    for(int i = 0;i < 48; i++){
        printf("%c",enc[i]);
    }
    return 0;
}

由于涉及到数据的溢出和大小长度，建议还是用C写脚本

begin{Th1s_reverse_pr0blem_may_t@ke_some_time#!}

0x08 superguesser

其实这题我动调了半天都不知道意义何在，一来随便点点就看到了疑似加密的主函数

image-20240207161553428

这里的静态代码真的看不懂，不过大概率是while循环那里，给明文依次加密，最后再比较，把一大坨密文抄一下，（v0-48）就是输入input开始的地址，长度为（v0-24）=37；然后(v0-20)=0（类似于循环里的i），(v0-25)=0x33（调试出来的）。下面那个loc_46EEF4猜测就是cmp函数。

1
2
while ( *(v0 - 20) < *(v0 - 24) )
  *(*(v0 - 48) + (*(v0 - 20))++) ^= *(v0 - 20) + *(v0 - 25) + 17 * *(v0 - 26);

这里有个疑点，就是这个(v0-26)动调出来是1，但是实际计算根据这个1算不出来。

动调研究一下原本的汇编代码，看看哪里是有问题的。看完汇编代码发现计算时找不到这个17 *(v0-26)的操作，反而 +0x33 的操作变成了 +0x44，原因是(v0-26) = 1这一步经过位移操作后变成0x11与0x33相加，导致结果变成了0x44，感觉被反调试过了，动调出来的东西不太可信。

一位一位爆破试出来(v0-26) = 0，写出脚本就很简单了

1
2
3
4
5
6
7
8
enc = [81,81,82,95,89,67,93,95,89,73,
       90,89,86,46,38,29,42,55,26,39,
       41,23,40,36,42,56,37,33,61,15,
       50,58,60,61,54,51,42]
d = 1
for i in range(37):
    enc[i] ^= (i + 0x33)
    print(chr(enc[i]),end = "")

begin{debugging_is_an_anathor_choice}