逆向数据处理

不知道你有没有像我一样，被加密的数据找到了，加密算法也找到了，却发现写不出逆向代码，特别是ai也写不来的时候，只得无奈跳过

我还是首推使用工具，一个工具不行就换一个，除非魔改的很厉害。

1.位与字节

一个字节=8位 ，范围是0x00~0xff (0~255)

用二进制表示就是 0000 0000 ~ 1111 1111

我们常见的算法，比如TEA，他就是要两个32位数据，也就是两个4字节的数据，而密钥是则需要4个32位数据，也就是4个4字节数据。

而这也就构成了我们常见的数据

1.0xfffffffffffffffff

0xff的二进制码是1111 1111

根据这个可以实现取低位无符号整数的作用

如何实现呢？

将一个他如其他的东西同或就行，同或是将两个数二进制进行比较，相同取1，不同取0，根据这个特性可以只取低8位，如果和0xffff，则取第16位。

如果是负数，python会自动取反

2.先正向来看一看

一个字符是一个字节，我也就拿TEA加解密来举例子

例如，我的明文是： "flag{kuai_lai_guan_zhu_man_su_jiao_sheng!!!!!!!}"为了凑够48个字节

密钥是"mansujiaosheng"这个有14个字节，不够16个字节，

我们先来把字符串转换为字节，并分成4字节一组：：

def str_to_u32(s):
    #将字符串转换为字节
    data = s.encode('utf-8')
    temps =[]
    #将字节按4个一组切分
    for i in range(0,len(data),4):
        temp = data[i:i+4]
        # 如果字节不足4个，则填充\x00
        if len(temp)<4:
            temp = temp +b'\x00'*(4-len(temp))
        temps.append(temp)
    return temps
#我的数据：
flag ='flag{kuai_lai_guan_zhu_man_su_jiao_sheng!!!!!!!}'
key = 'mansujiaosheng'
flag_byte = str_to_u32(flag)
key_byte = str_to_u32(key)
print(flag_byte)
print(key_byte)
#输出：[b'flag', b'{kua', b'i_la', b'i_gu', b'an_z', b'hu_m', b'an_s', b'u_ji', b'ao_s', b'heng', b'!!!!', b'!!!}']
#[b'mans', b'ujia', b'oshe', b'ng\x00\x00']

然后再转化为整数:

def byte_to_u32(data):
    return [int.from_bytes(i,'big') for i in data]
flag_u32 = byte_to_u32(flag_byte)
key_u32 = byte_to_u32(key_byte)
#[1718378855, 2070639969, 1767861345, 1767860085, 1634623354, 1752522605, 1634623347, 1969187433, 1634688883, 1751477863, 555819297, 555819389]
#[1835101811, 1969908065, 1869834341, 1852243968

然后就进行tea加密：

def entea(v0,v1,k0,k1,k2,k3,):
    delta = 0x9e3779b9
    _sum =0
    u32 = 0xffffffff
    for i in range(32):
        
        v0= (v0+(((v1<<4) + k0) ^ (v1 + _sum) ^ ((v1>>5) + k1)))& u32
        _sum = (_sum+delta) & u32
        v1 = (v1+(((v0<<4)+ k2) ^ (v0 + _sum)^ ((v0>>5) + k3)))& u32
    return v0,v1
for i in range(0,len(flag_u32),2):
    v0,v1 = entea(flag_u32[i],flag_u32[i+1],key_u32[0],key_u32[1],key_u32[2],key_u32[3])
    enflag.append(v0)
    enflag.append(v1)
print(enflag)
#[1858221103, 1768634730, 848273956, 1276141334, 3983983412, 3022382808, 841921832, 988514907, 644402040, 1095669320, 2804150858, 1625053465]

[1858221103, 1768634730, 848273956, 1276141334, 3983983412, 3022382808, 841921832, 988514907, 644402040, 1095669320, 2804150858, 1625053465]就是我们正向加密得到的数据

现在我们来处理这些数据

2.正向处理数据：

1.拼凑成更大的16进制数作为结果：

1.拼成一个：

def num_to_hex(num):
    byte_stream= b''.join([i.to_bytes(4,'big') for i in num])
    return byte_stream.hex()
b=num_to_hex(enflag)
print(b)
#6ec2342f696b396a328fa2244c105f16ed76c334b425e6d8322eb5283aeb8a5b2668cb78414e9648a723f24a60dc5919

6ec2342f696b396a328fa2244c105f16ed76c334b425e6d8322eb5283aeb8a5b2668cb78414e9648a723f24a60dc5919（一个384位数据）

这是事先知道这个数字是几个32位数字拼成成的，如果不知道，那就麻烦了。

2.拼凑成n个：

def num_to_more(num,bits):
    byte_stream= b''.join([i.to_bytes(4,'big') for i in num])
    bytes_per_group = bits//8
    hex_group=[]
    for i in range(0,len(byte_stream),bytes_per_group):
        temp = byte_stream[i:i+bytes_per_group]
        if len(temp)<bytes_per_group:
            temp = temp +b'\x00'*(bytes_per_group-len(temp))
        hex_group.append(temp.hex())
    return hex_group
c=num_to_more(enflag,192)
print(c)

拼成成两个192位的16进制数：6ec2342f696b396a328fa2244c105f16ed76c334b

425e6d8', '322eb5283aeb8a5b2668cb78414e9648a723f24a60dc5919

多少位都可以，只要是8的整数

3.逆向来看

我们拿到的数据可能是这样：

['6e', 'c2', '34', '2f', '69', '6b', '39', '6a', '32', '8f', 'a2', '24', '4c', '10', '5f', '16', 'ed', '76', 'c3', '34', 'b4', '25', 'e6', 'd8', '32', '2e', 'b5', '28', '3a', 'eb', '8a', '5b', '26', '68', 'cb', '78', '41', '4e', '96', '48', 'a7', '23', 'f2', '4a', '60', 'dc', '59', '19']

或者这样：

['6ec2342f696b396a328fa2244c105f16', 'ed76c334b425e6d8322eb5283aeb8a5b', '2668cb78414e9648a723f24a60dc5919']

这些根据算法手动拼接一下，

也可以像我这样，对输出后的结果手动加上0x：

aflag =''
for i in range(0,len(c)):
    aflag +=''.join(c[i]) 
print(aflag)

然后通过这个

注意，一定要输入一个数组，如果是一个数就用[]包起来

还有那个bytes要根据实际情况修改，这个是输入数据的字节数，

比如输入是64位数据，那就填8，，如果不知道，那就先把0x去除，然后使用print(len()/2)来输入

def num_to_more(num,bits,bytes):
    byte_stream= b''.join([i.to_bytes(bytes,'big') for i in num])
    bytes_per_group = bits//8
    
    hex_group=[]
    for i in range(0,len(byte_stream),bytes_per_group):
        temp = byte_stream[i:i+bytes_per_group]
        if len(temp)<bytes_per_group:
            temp = temp +b'\x00'*(bytes_per_group-len(temp))
        hex_group.append(temp.hex())
    return hex_group

似乎也就这些了

我之前是为什么被卡住的啊

实战

出给看的人了，这组数据怎么用？https://tkazer.github.io/2025/03/06/GHCTF2025WP/

  uint8_t EncFlag[24]{};
    memcpy(EncFlag, "!V", 2);
    EncFlag[2] = -105;
    EncFlag[3] = -90;
    EncFlag[4] = 26;
    EncFlag[5] = -43;
    EncFlag[6] = -60;
    EncFlag[7] = -34;
    EncFlag[8] = -92;
    EncFlag[9] = -100;
    EncFlag[10] = -126;
    EncFlag[11] = 77;
    EncFlag[12] = -47;
    EncFlag[13] = 69;
    EncFlag[14] = -56;
    EncFlag[15] = 86;
    EncFlag[16] = -89;
    EncFlag[17] = -76;
    EncFlag[18] = -106;
    EncFlag[19] = 92;
    EncFlag[20] = 77;
    EncFlag[21] = 73;
    EncFlag[22] = -121;
    EncFlag[23] = 32;