极客大挑战2024_re wp

原创已于 2024-11-22 13:19:48 修改 · 2.2k 阅读

51 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

于 2024-11-22 13:18:27 首次发布

1.先来一道签到题

类型：.s文件逆向

密文：

加密逻辑：L3中flag每位异或7再减去5

Exp:

a = 'TTDv^jrZu`Gg6tXfi+pZojpZSjXmbqbmt.&x'
flag =''
i = 0
for v in a:
    if i %2==0:
        flag+=chr((ord(v)^7))
        i+=1
    else:
        flag += chr((ord(v) + 5))
        i+=1
print(flag)
#SYC{You_re@l1y_kn0w_how_To_revers3!}

2.让我康康你的调试

类型：rc4加异或

观察rc4函数，发现没有魔改，动调将密文取出，用cyberchef解出：

3.Ezzzz

类型：安卓逆向，魔改xtea

魔改逻辑：将加密解密的数据类型都搞成int有符号类型，且每轮密文都异或上了轮数和delta的和，因此都要一一逆向：

密文：

Exp:

#include<stdio.h>
#include<stdint.h>
void decipher(int num_rounds, int v[2], int const key[4]) {
    //int i;
    int v0 = v[0], v1 = v[1], delta = 0x9E3779B9, sum = delta * num_rounds;
    
    for (int i = 31; i >= 0; i--) {
        /*printf("%d ",i);*/
        v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]) ^ (i + sum);
        sum -= delta;
        v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]) ^ (i + sum);
    }
    /*printf("0x%x ", v0);*/
    v[0] = v0; v[1] = v1;
}
void encipher(int num_rounds, int v[2], int const key[4]) {
    int i;
    int v0 = v[0], v1 = v[1], sum = 0, delta = 0x9E3779B9;
    for (i = 0; i < 32; i++) {
        v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]) ^ ( sum+i ) ;

        sum += 0x9E3779B9;
        v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]) ^ (sum +i ) ;

    }
    v[0] = v0; v[1] = v1;
}
int main() {
    int key_xtea[4] = { 0x47,0x45,0x45,0x4b };
    int enc_xtea[60] = { 4059137714, 1519830914, 3871750667, 1890982748, 3983276104, 2305822059, 154671964, 3408864506, 2982649465, 1837247900, 3703922550, 259526261, 224773295, 3096478889, 3917005698, 2056116240, 2448592371, 2823666378, 3034013557, 4053465317, 3104801020, 4228949443, 3523639803, 734475464, 3434290322, 449129171, 3891864247, 774166819, 4216121845, 893954533, 1911276122, 3745023534, 268800390, 846530886, 1037358412, 2421865526, 3261944594, 3536667328, 1999477221, 215270502, 1546746070, 981466737, 2913096128, 1884720474, 1469629074, 515962876, 988403777, 2220914217, 818571821, 3438236114, 2712143956, 2444294189, 1751950151, 1959079183, 254166175, 3264034348, 2264084763, 2329694129, 2756279860, 3773862237};
    for (int i = 0; i < 30; i++) {
        decipher(32, enc_xtea + 2*i, key_xtea);
    }

    for (int i = 0; i < 60; i++) {
        printf("%c", enc_xtea[i]);
    }
    return 0;
}
//SYC{g0od_j0b_wweLCoMeToooSSSyC_zz_1_et3start_yoUr_j0urney!!}

4.DH爱喝茶

类型：花指令，魔改tea

过程：花指令

莫名其妙的指针和多的数据，全部nop之后按p反编译

在做wp之前我是没有去花的，见没有爆红也不能反编译直接动调看了：

这里根据动调是密钥和密文：

这里是加密逻辑，根据动调发现，进行、四轮加密，每轮传两组密文和密钥，密钥每轮都进行了变化，没一轮都把相应下标的密钥循环移动六位

并且加密函数之内也做了魔改：

Delta值每轮都进行了会改变，而且有特别说明了转成了int8类型。

Exp:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdint.h>
void enc(unsigned int* a1, int* a2)
{
    unsigned int result; // eax
    unsigned int v3; // [esp+8h] [ebp-28h]
    unsigned int v4; // [esp+Ch] [ebp-24h]
    int v5; // [esp+10h] [ebp-20h]
    unsigned int i; // [esp+14h] [ebp-1Ch]
    int v7 =0; // [esp+1Ch] [ebp-14h]
    int v8= 0 ; // [esp+20h] [ebp-10h]

    v3 = *a1;
    v4 = a1[1];
    
    v7 = *a2;
    v8 = a2[1];
    v5 = (((v8 ^ v7)&0xff) + 0x98765432) * 32;
    for (i = 0; i <= 0x1F; ++i)
    {   
        v4 -= (v3 + v5) ^ (16 * v3 + a2[2]) ^ ((v3 >> 5) + a2[3]);
        v3 -= (v4 + v5) ^ (16 * v4 + v7) ^ ((v4 >> 5) + v8);
        v5 -= ((v8 ^ v7)&0xff) + 0x98765432;
    }
    *a1 = v3;
    a1[1] = v4;
 
}
int main() {
    unsigned int enc11[8] = { 0x1F85A965, 0xEEC063EC, 0x5BF1D0B6, 0xF2FDE7B0, 0xAA38809A, 0x670772E9, 0x360D24B9, 0xE98C688C };
    int key11[4] = { 0x56789ABC, 0x6789ABCD, 0x789ABCDE, 0x89ABCDEF };
    int key_re[4] = { 0x9E26AF15, 0xE26AF359, 0x26AF379E, 0x6AF37BE2 };
    for (int i = 0; i < 4; i++) {
        key11[i] = key_re[i];
        int v5;
        v5 = (((key11[0] ^ key11[1]) & 0xff)+0x98765432)*32;
        printf("0x%x\n", v5);
        for (int z = 0; z < 4; z++) {
            printf("0x%x,", key11[z]);
        }
        printf("\n");
        
        enc(enc11 +2 * i,key11);
        
        for (int i = 0; i < 8; i++) {
            printf("0x%x,", enc11[i]);
        }
        printf("\n");
    }
    for (int i = 0; i < 8; i++) {
    printf("%c%c%c%c", enc11[i], enc11[i] >> 8,enc11[i] >> 16 ,enc11[i] >> 24 );
    }
    return 0;
}

5.奇怪的RC4

类型：python逆向

使用经典pyinstxtractor和uncompyle6搞出源代码，发现导入了Rc4，于是一起反编译了：

题目提示什么两次？不是很懂，直接根据逻辑硬逆向了

Exp:

def KSA(key):
    j = 0
    S = list(range(256))
    key_length = len(key)
    for i in range(256):
        j = (j + S[i] + key[i % key_length]) % 256
        S[i], S[j] = S[j], S[i]
    else:
        return S

def PRGA(S):
    i = 0
    j = 0
    while True:
        i = (i + 1) % 256
        j = (j + S[i]) % 256
        S[i], S[j] = S[j], S[i]
        k = (S[i] + S[j]) % 256
        yield k
cipher = [158, 31, 205, 434, 354, 15, 383, 298, 304, 351, 465, 312, 261, 442,
 397, 474, 310, 397, 31, 21, 78, 67, 47, 133, 168, 48, 153, 99, 103,
 204, 137, 29, 22, 13, 228, 3, 136, 141, 248, 124, 26, 26, 65, 200,
 7]
key = 'SYCFOREVER'
key1 = [0]*len(key)
for i in range(len(key)):
    key1[i] = ord(key[i])
xor_list = [0]*45
for i in range(45):
    xor_list[i] = i
for i in range(44,0,-1):
    cipher[i] = cipher[i-1] ^ cipher[i]
for i in range(45):
    cipher[i] = cipher[i] ^xor_list[i]
S = KSA(key1)
xor_value = PRGA(S)
for i in range(len(cipher)):
    cipher[i] ^= (int(next(xor_value)) + 6)
for i in range(len(cipher)):
    cipher[i] -= i
    cipher[i] %= 128
    print(chr(cipher[i]),end ='')
#SYC{Bel1eve_thAt_you_a3e_Unique_@nd_tHe_beSt}

6.长颈鹿喜欢吃彩虹

类型：控制流平坦，逻辑简单，直接动调，用d810搞不动，可以用另外一个工具去搞，但是我懒

逻辑：主函数内经典加密和比对：

进入加密函数：

这里把我们的第一个输入与N异或，之后第二个再与o异或，可以猜到是循环异或了，直接写出脚本：

enc = [0x1D, 0x36, 0x73, 0x16, 0x49, 0x2D, 0x1A, 0x1D, 0x29, 0x06, 0x42, 0x2C, 0x76, 0x07, 0x10, 0x0E, 0x7E, 0x39, 0x55, 0x32, 0x75, 0x03, 0x1B, 0x1D, 0x19, 0x5F, 0x52, 0x23, 0x01, 0x03, 0x1D, 0x3F]
key = [0x42, 0x4F, 0x62, 0x30, 0x6D, 0x30, 0x6F, 0x4E]
print(''.join(chr(key2) for key2 in key))
key1 = key[::-1]
for i in range(len(enc)):
    enc[i]^=key1[i%8]
    print(chr(enc[i]),end ='')

7.blasting_master

类型：md5爆破

逻辑：

一眼加密函数，点进之后：

分析出逻辑，之后使用z3和md5爆破，发现每32位是0-3四位flag，之后下一个32个数字是1-4位flag，于是隔三组32个数爆破一次，可得到flag：

Exp：

Z3：

src1 = [0xB2, 0x50, 0xA0, 0xBC, 0x3A, 0x7F, 0x54, 0x6D, 0x96, 0x07, 0x0F, 0x71, 0x9A, 0x72, 0xEB, 0xA5, 0xA0, 0xB5, 0x71, 0xA4, 0x6A, 0xB8, 0xBA, 0xFA, 0xE4, 0x31, 0xC3, 0x71, 0x54, 0x29, 0xA7, 0x59, 0x20, 0x2B, 0x13, 0x21, 0xBD, 0x67, 0x5F, 0x8D, 0x65, 0x3A, 0x02, 0x27, 0x08, 0x4F, 0x92, 0x9C, 0xB5, 0x7C, 0xDF, 0x69, 0x34, 0xB8, 0x82, 0x2D, 0xF6, 0xCA, 0x7A, 0x65, 0x98, 0x63, 0xDC, 0x51, 0x2A, 0x34, 0x97, 0x4F, 0xF8, 0xBC, 0x23, 0x1F, 0x38, 0xA8, 0xA6, 0x2F, 0xA9, 0x0D, 0x64, 0x4C, 0xAC, 0x2F, 0xF9, 0xF5, 0x2D, 0xB1, 0x91, 0xA8, 0xD5, 0x76, 0xD9, 0x2D, 0xC6, 0xAC, 0x2E, 0x69, 0x32, 0xD5, 0x64, 0x1D, 0xC1, 0x3C, 0xEC, 0xF5, 0x2C, 0x90, 0xED, 0xF4, 0x17, 0x8B, 0x55, 0x4C, 0xE4, 0x6C, 0x3B, 0xB3, 0xDA, 0x29, 0xC0, 0x7B, 0x39, 0xDF, 0x92, 0x73, 0xFC, 0xC9, 0xC2, 0xA8, 0x68, 0x11, 0x22, 0x2B, 0x64, 0x3F, 0x12, 0x9B, 0x95, 0x73, 0x2A, 0x05, 0xD3, 0x3F, 0x2E, 0x33, 0xF1, 0x85, 0xED, 0x07, 0x7B, 0x86, 0x8F, 0x62, 0x2D, 0x79, 0x03, 0xAC, 0x80, 0xCE, 0xF5, 0xB2, 0xA0, 0x0C, 0xF7, 0xE1, 0xC5, 0x0E, 0x63, 0x27, 0xD1, 0x65, 0x23, 0xEA, 0x5A, 0x1C, 0x02, 0x0B, 0x32, 0xBA, 0x1F, 0xE5, 0xC7, 0x22, 0xA5, 0x66, 0x77, 0xEA, 0x5B, 0xE4, 0x64, 0xAB, 0x8B, 0x60, 0xB6, 0xDF, 0x00, 0xDC, 0xF7, 0x6D, 0x93, 0xEC, 0x2F, 0x2F, 0x68, 0x07, 0x50, 0xE0, 0xD1, 0x1A, 0x3F, 0xC6, 0x4E, 0x2E, 0xC6, 0xBB, 0xAE, 0x08, 0x40, 0xD8, 0x5B, 0x11, 0xB5, 0xDC, 0x15, 0x35, 0x7F, 0x63, 0x49, 0x3E, 0x5B, 0x9C, 0x0D, 0xFC, 0x0D, 0xB6, 0x80, 0xB7, 0x2B, 0x00, 0xEF, 0x3C, 0x0C, 0x2F, 0xEB, 0x86, 0x44, 0x57, 0x74, 0x9E, 0x5F, 0x1F, 0x8B, 0xA1, 0xC9, 0x01, 0xF1, 0xD8, 0xF4, 0x92, 0x82, 0x95, 0x6F, 0x85, 0xD2, 0x15, 0x22, 0x1F, 0xF0, 0x9F, 0xD1, 0xAB, 0x51, 0x39, 0x9A, 0xB6, 0xC4, 0xDA, 0xFB, 0x38, 0x8D, 0xE6, 0x8C, 0x57, 0x19, 0x5E, 0x94, 0xDA, 0x57, 0xCC, 0xF0, 0xB9, 0x0A, 0x4A, 0x17, 0x82, 0xFC, 0xC5, 0x4F, 0x4B, 0x5A, 0xA5, 0xF4, 0xE5, 0x3E, 0xFA, 0x3A, 0x0A, 0xF4, 0xB4, 0x8E, 0x7F, 0x25, 0x84, 0x75, 0x90, 0xCD, 0x35, 0x87, 0xEB, 0xC3, 0xCE, 0x81, 0x2B, 0x86, 0xC9, 0x16, 0x7E, 0x85, 0x68, 0x2D, 0xF1, 0xDB, 0x8E, 0x74, 0x15, 0xCF, 0x95, 0x51, 0x07, 0x88, 0x5E, 0x1B, 0xE9, 0x37, 0xC9, 0x5B, 0xBA, 0x61, 0xEB, 0x9F, 0x7B, 0xE4, 0x89, 0x10, 0xF0, 0x6E, 0xCD, 0x75, 0x71, 0xAD, 0x09, 0x74, 0x58, 0x49, 0xA3, 0xF5, 0x33, 0x83, 0x75, 0x22, 0x95, 0x1B, 0xE3, 0x3C, 0x48, 0x05, 0x5C, 0xAD, 0xA8, 0x6B, 0xFD, 0x41, 0xEB, 0xAF, 0xC6, 0x02, 0x28, 0xC6, 0x5E, 0xCF, 0x36, 0xAE, 0x50, 0xCE, 0x93, 0xF2, 0x70, 0x88, 0x9D, 0x3F, 0x4A, 0x9F, 0x86, 0xE7, 0x67, 0x64, 0xB0, 0x02, 0x96, 0x0C, 0xAB, 0x9F, 0xEB, 0x4B, 0x03, 0x44, 0x92, 0xDE, 0x6C, 0xF4, 0xCE, 0x32, 0x4F, 0x4F, 0x38, 0xE2, 0x52, 0x59, 0xCA, 0x95, 0x4A, 0x11, 0xD8, 0x30, 0xA2, 0x7B, 0xD5, 0x3A, 0xE6, 0x11, 0xDA, 0x3A, 0x4A, 0x33, 0x61, 0x39, 0x65, 0x26, 0xD2, 0x78, 0xBC, 0xED, 0xBD, 0xA5, 0x8B, 0x2B, 0x87, 0x4C, 0x95, 0x47, 0x25, 0x02, 0xBA, 0x83, 0x3D, 0xDC, 0xE4, 0x6A, 0xAD, 0x67, 0xDD, 0x22, 0xB1, 0xBD, 0x2B, 0x7C, 0x53, 0x11, 0x3C, 0xD9, 0x23, 0x06, 0x3D, 0x20, 0xBA, 0x28, 0xC8, 0x2D, 0x89, 0x51, 0x57, 0x63, 0x82, 0xA0, 0xC8, 0xA8, 0xDE, 0x29, 0x61, 0xC1, 0x53, 0x51, 0xB0, 0xBC, 0x37, 0x04, 0xEE, 0xC9, 0x35, 0x8A, 0xA8, 0xA2, 0x66, 0xBA, 0x6F, 0x24, 0xB6, 0x3F, 0x62, 0x41, 0x6D, 0x10, 0x46, 0xCB, 0x06, 0x12, 0x39, 0xD9, 0x0E, 0xF9, 0xDC, 0x19, 0xA7, 0x65, 0xB8, 0xC0, 0x40, 0xBE, 0xF6, 0x99, 0x9A, 0xAF, 0x02, 0x16, 0x37, 0x4D, 0xA5, 0x75, 0x4C, 0x42, 0x4B, 0x1A, 0xF0, 0x52, 0xDA, 0x38, 0xF3, 0x6B, 0xA9, 0x1A, 0xDC, 0xFA, 0x80, 0xB0, 0x60, 0xB1, 0xFD, 0x73, 0x7B, 0x78, 0xD9, 0x62, 0x83, 0x26, 0xBF, 0x16, 0x33, 0x71, 0x79, 0x6F, 0x11, 0x2F, 0xE9, 0xA7, 0xBB, 0x46, 0x46, 0xD6, 0x8F, 0xF6, 0x21, 0x7E, 0xFC, 0x68, 0x12, 0x86, 0x6B, 0xFC, 0x51, 0xC9, 0x70, 0x7A, 0x74, 0xBC, 0x8F, 0x6E, 0x0B, 0x86, 0x42, 0x6F, 0x5C, 0xFD, 0xF7, 0x4E, 0x27, 0x71, 0xFE, 0x37, 0xE6, 0xC8, 0x62, 0x47, 0xFC, 0xD5, 0x6C, 0xBA, 0x5C, 0xD9, 0x29, 0x5A, 0x73, 0xAE, 0xC3, 0x8F, 0xF0, 0x46, 0x95, 0x32, 0x42, 0x2D, 0xD0]
print(len(src1))
from z3 import*
s = Solver()
flag = [BitVec("flag[%d]"%i,8)for i in range(640)]
aa = flag[:]
for i in range(40):
    for j in range(16):
        flag[16 * i + j] = 7* ((j + 42) ^ flag[16 * i + j]) + 82 * (j % 15)
for i in range(640):
     s.add(src1[i] == flag[i])
if s.check() == sat:
    m = s.model()
    a =[0]*640
    for i in range(640):
        a[i] = m[aa[i]].as_long()
        print("%02x"%a[i],end = '')
    for i in range(40):
        for j in range(16):
            print("%02x" % a[16*i+j],end ='')
        print('')
#SYC{W0w!y0u_@re_th3_BeSt_blasting_Exp3rt!!}

Md5：

import hashlib
import string

md5_str = "5c50152daeee511f32db7bf8a5502c69"
r = len(md5_str)//32
for i in range(r):
    target = md5_str[i*32:(i+1)*32]
    flag = False
    for a in string.printable:
        if flag:
            break
        for b in string.printable:
            if flag:
                break
            for c in string.printable:
                if flag:
                    break
                for d in string.printable:
                    t = a + b + c + d
                    if hashlib.md5(t.encode()).hexdigest() == target:
                        flag = True
                        print(t)

8.致我的星星

类型：迷宫，js逆向（？），z3

开始有一组20x9地图，之后是序列估计是路，还有一个线性方程组，应该是终点和起点，上下左右是“STAR”，之后把上面这些路径和终点搞上去后，定位函数是对10x10的地图定位，还要重排一次,然后就是鸡汤啦，皓齿（笑）：

Exp:

from z3 import*
s = Solver()
a = [BitVec("a%i"%i,8)for i in range(8)]
s.add(43654*a[0] - 57003*a[1] -3158*a[2] + 30120*a[3] -58621*a[4] -41947*a[5] +122237*a[6] +129534*a[7] == 2594143)
s.add(-48022*a[0] + 18308*a[1] + 52478*a[2] + 69397*a[3]  +49696*a[4] + 12288*a[5] -40437*a[6] -23154*a[7] ==  651137)
s.add(124109*a[0]  +58952*a[1] + 16645*a[2] -17531*a[3] + 53139*a[4]  +49937*a[5]  + 3282*a[6]   +7656*a[7] == 2071815)
s.add(108286*a[0] + 118886*a[1] +116876*a[2]   +2281*a[3] -64590*a[4]  -3021*a[5] + 13386*a[6] -56070*a[7] ==  703)
s.add(105983*a[0] + 8794*a[1] + 31851*a[2] -35052*a[3]  -7880*a[4]  + 2183*a[5] + 47575*a[6] +107236*a[7] == 2511919)
s.add(-38005*a[0] -6833*a[1] +107897*a[2] +119771*a[3] +124322*a[4] + 13335*a[5]+ 121590*a[6] -17434*a[7] == 4816084)
s.add(60696*a[0] +95253*a[1] +101581*a[2] + 93822*a[3] +112989*a[4]  +65643*a[5]  +45639*a[6] + 26705*a[7] == 5330538)
s.add(49019*a[0] +72343*a[1] -21814*a[2]  +85020*a[3] -62332*a[4]  +99828*a[5]  +  587*a[6] -65119*a[7] ==  505173)
if s.check() == sat:
    m = s.model()
    print(m)
data = [
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#',
    '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'
'#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#', '#'

]

coordinates = [
    [1, 11], [1, 12], [1, 13], [1, 14],
    [2, 1], [2, 4], [2, 11], [2, 12], [2, 14],
    [3, 4], [3, 14],
    [5, 7], [5, 8], [5, 12], [5, 14], [5, 15], [5, 18],
    [6, 1], [6, 2], [6, 4], [6, 5], [6, 7], [6, 8], [6, 11], [6, 15],
    [7, 1], [7, 5], [7, 11], [7, 12], [7, 13], [7, 14], [7, 15], [7, 16],
    [8, 1], [8, 12], [8, 13], [8, 15], [8, 18],
    [9, 3], [9, 4], [9, 6], [9, 7], [9, 8]
]
ROW_LENGTH = 20
for coord in coordinates:
    row_index = coord[0]
    col_index = coord[1]
    data[row_index * 20 + col_index] = '.'
    data[(2 )*20+12]='S'
    data[(7 )*20+12] ='S'
    data[(3 )*20+14] ='Y'
    data[(5 )*20+14] ='Y'

for i in range(0, len(data), 10):
print(data[i:i + 10])
#STTAAARRRRAAATTTTS

9.ez_re

类型：花指令，aes，反调试

进来一看有一些花，都是跳转加1的话，直接和前面的跳转一起全部nop了，之后发现是没魔改的aes加密，而且提示了是cbc加密，花指令去掉之后的key和iv都很清楚地说明了：

Exp：

10.也许你也听jay

类型：异或，rc4

打开题目，是变量名称很奇怪的代码，移到vs上一一逆向出来是一个网站，进入是jay的六首歌诶，而真正的flag就在旁边的介绍里面：

11.CPP_flower

类型：花指令

这些东西全都是从jz到call得到e8全部nop，

不知道为什么下面全都有点乱了呢，但是不管他，写出exp

Exp：

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
void main() {
    srand(0x7DE9);
    for (int i = 0; i < 50; i++) {
        int a = rand() % 255;
    }
    char src[50] = { 0x6d,0xc1,0xa8,0x5d,0x7c,0xbe,0x50,0xba,0xe5,0x88,0x51,0xc7,0xfb,0xb0,0x18,0x2b,0xd9,0x94,0x52,0x42,0x59,0xf5,0xf8,0xa7,0xe7,0x22,0xad,0x1f,0x86,0xf5,0xf9,0x65,0x26,0x58,0x34,0x9b,0x45,0x7b,0x86,0xb4,0x65,0xfd,0x68,0x27,0x52,0x32,0x81,0x50,0xc4,0xb8 };   
    unsigned int enc[50] = { 0x0000003E, 0x00000098, 0x000000EB, 0x00000026, 0x00000025, 0x0000008E, 0x00000025, 0x000000E5, 0x00000086, 0x000000C8, 0x0000003F, 0x00000098, 0x000000C8, 0x000000DE, 0x00000052, 0x00000044, 0x000000A0, 0x000000CB, 0x0000002B, 0x0000002A, 0x0000003C, 0x000000AA, 0x000000BE, 0x000000CB, 0x00000088, 0x00000055, 0x0000009E, 0x0000006D, 0x000000D9, 0x00000094, 0x00000097, 0x0000001C, 0x00000052, 0x00000031, 0x00000059, 0x000000FE, 0x0000001A, 0x0000001A, 0x000000E8, 0x000000D0, 0x0000003A, 0x0000009C, 0x00000006, 0x0000005E, 0x00000025, 0x0000005A, 0x000000E4, 0x00000022, 0x000000A1, 0x000000C5 };
    for (int i = 0; i < 50; i++) {
        enc[i] ^= src[i];
        printf("%c", (char)enc[i]);
    }
}
//SYC{Y0u_c@n_3nJoy_yhe_Flow3r_anytime_and_anywhere}

12.玩就行了

类型，unity逆向

啊啊，是unity，使用il2cppdump和还原函数表大法，研究半天了，发现使用了txt文件中的代码，绷不住了，于是把exe搞出来，也是很简单的逻辑：

Exp：

a = '0A161230300C2D0A2B303D2428233005242C2D26182206233E097F133A'
key = 'GEEK'
enc1=[]
enc = [0]*29
enc4 = [10, 22, 18, 48, 48, 12, 45, 10, 43, 48, 61, 36, 40, 35, 48, 5, 36, 44, 45, 38, 24, 34, 6, 35, 62, 9, 127, 19, 58]
for i in range(len(enc4)):
    enc[i] = enc4[i]^ord(key[i%4])
enc5=[0]*29
for i in range(len(enc)):
    b = enc[i]
    if b > 47 and b <=57:
        enc5[i] =( (b-20-48)%10 )+ 48
    else:
        if  b >= 64 and b < 90 :
            enc5[i] = ((b-20-65)%26) + 65
        else:
            if b>=96 and b<122:
                 enc5[i] =( (b-20 - 97  ) % 26 )+ 97
flag = ''
for i in range(len(enc5)):
    if enc5[i] == 0:
        enc5[i] = enc[i]
    flag += chr(enc5[i])
print(flag)
#SYC{cOnGraduulaTions_mIneR:D}

13.ez_hook

类型：smc，反调试

经过动调，发现将flag反序后再进行了排序，还有反调试改一下就过了。之后再换序的函数末尾有smc，将下一个函数的内容给改了，每一个异或7。

懒得看代码了，直接根据动调前后变化排序：

Exp：

a = 'zoXpih^lhX6soX7lr~DTHtGpX|'
a2 = [19, 6, 18, 25, 17, 5, 16, 24, 15, 4, 14, 23, 13, 3, 12, 22, 11, 2, 10, 21, 9, 1, 8, 20, 7, 0]
rearranged_a = ''.join([chr((ord(a[i])^7) )for i in a2])
print(rearranged_a)
#SYC{you_kn0w_wh@t_1s_hoOk}

14.baby_vm

类型：vm

嘛，vm题没什么好说的呀，就硬看呗，另外一条路？我不知道呢

Exp：

opcode=[0x00000046, 0x0000003F, 0x00000000, 0x0000003C, 0x0000003F, 0x00000019, 0x0000003D, 
        0x0000003A, 0x0000003E, 0x0000003F, 0x00000053, 0x00000033, 0x00000038, 0x0000003F, 0x00000059, 0x0000003E, 0x00000039, 0x00000034, 0x0000003E, 0x0000003F, 0x00000043, 0x00000037, 0x00000038, 0x00000040, 0x00000042, 0x0000003C, 0x0000003F, 0x00000063, 0x0000003E, 0x0000003A, 0x00000037, 0x0000003E, 0x0000003F, 0x00000079, 0x00000033, 0x00000038, 0x0000003F, 0x00000073, 0x0000003E, 0x00000039, 0x00000034, 0x00000038, 0x00000040, 0x00000042, 0x0000003C, 0x00000043, 0x00000026, 0x0000003F, 0x00000031, 0x0000003C, 0x0000003F, 0x00000032, 0x0000003D, 0x00000041, 0x0000003E, 0x00000039, 0x00000044, 0x00000043, 0x00000004, 0x000000FF]
idx = 0
for i in range(len(opcode)):
    a1 = opcode[idx]
    match(a1):
        case 0x33:
            print("eax += edx")
            idx += 1
            continue
        case 0x34:
            print("eax -= edx")
            idx += 1
            continue
        case 0x35:
            print("eax *= edx")
            idx += 1
            continue
        case 0x36:
            print("eax /= edx")
            idx += 1
            continue
        case 0x37:
            print("eax = ~(eax & edx) & ~(~edx & ~eax)")
            idx += 1
            continue
        case 0x38:
            print("miwen[ezx] = eax ezx += 1")
            idx += 1
            continue
        case 0x39:
            print("eax = miwen[ezx--]")
            idx += 1
            continue
        case 0x3A:
            print("eax = flag[ebx]")
            idx += 1
            continue
        case 0x3B:
            print("eax = edx")
            idx += 1
            continue
        case 0x3C:
            print("ebx = eax")
            idx += 1
            continue
        case 0x3D:
            print("ecx = eax")
            idx += 1
            continue
        case 0x3E:
            print("edx = eax")
            idx += 1
            continue
        case 0x3F:
            print("eax = 0x%x" % opcode[idx+1])
            idx += 2
            continue
        case 0x40:
            print("eax = ebx")
            idx += 1
            continue
        case 0x41:
            print("eax = bytes[ebx]")
            idx += 1
            continue
        case 0x42:
            print("eax++")
            idx += 1
            continue
        case 0x43:
            print("if ecx-- : v4 = idx - %d"%opcode[idx+1])
            print("else: v4 += 2")

            idx += 2
            continue
        case 0x44:
            print("if eax != ecx :cf=1")
            print("ebx--")
            idx += 1
            continue
        case 0x45:
            print("eax = 0x%x" % opcode[idx + 1])
            idx += 2
            continue
        case 0x46:
            print("flag = input")
            idx += 1
            continue
        case 0xff:
            print("over")
            break

#~(eax & edx) & ~(~edx & ~eax)flag&0x63+0x79 ->miwen-0x73
miwen =[0x0E, 0x40, 0x7E, 0x1E, 0x13, 0x34, 0x1A, 0x17, 0x6E, 0x1B, 0x1C, 0x17, 0x2E, 0x0C, 0x1A, 0x30, 0x69, 0x32, 0x26, 0x16, 0x1A, 0x15, 0x25, 0x0E, 0x1C, 0x42, 0x30, 0x32, 0x0B, 0x42, 0x79, 0x17, 0x6E, 0x42, 0x29, 0x17, 0x6E, 0x5A, 0x2D, 0x20, 0x1A, 0x16, 0x26, 0x10, 0x05, 0x15, 0x6E, 0x0D, 0x58, 0x24]
for i in range(len(miwen)):
    for j in range(30,128,1):
        tmp1 = 0
        if i % 2 == 0:
            tmp = j + 0x53 - 0x59
            a12 = 0x43
            tmp1 = ~(tmp & a12) & ~(~tmp & ~a12)
        else:
            a12=0x63
            tmp =  ~(j & a12) & ~(~j & ~a12)
            tmp1 = tmp + 0x79-0x73
        if tmp1 == miwen[i]:
            print(chr(j),end = '')
            break
#SYC{VM_r3verse_I0Oks_llke_yON_@r3_pr37ty_skiLl3d!}

15.我勒个z3啊

类型：z3

Exp:

from z3 import*
a1 =[0x2A, 0x0E, 0x0E, 0x14, 0x3F, 0x3F, 0x3F, 0x26, 0x11, 0x0A, 0x15, 0x15, 0x0E, 0x17, 0x10, 0x0E]
b = ''
table="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ?_"
key = [0x47,0x65,0x65,0x6b,0x5f,0x5f,0x5f,0x43,0x68,0x61,0x6c,0x6c,0x65,0x6e,0x67,0x65]
c = [0x0000019B, 0x00000113, 0x00000189, 0x000001C9, 0x00000250, 0x00000536, 0x000004DE, 0x000001BC, 0x0000041B, 0x00000724, 0x000006D0, 0x000004A1, 0x00000645, 0x00000475, 0x000004CA, 0x0000068C, 0x000003E5, 0x000001C7, 0x0000033D, 0x000005B7, 0x0000028D, 0x00000244, 0x0000030E, 0x00000291, 0x00000271, 0x00000301, 0x0000045F, 0x0000046F, 0x00000517, 0x0000041E, 0x00000426, 0x000004B5]
print(len(c))
s = Solver()
a  =[BitVec('flag[%d]'%i,9) for i in range(32)]
a2=a[:]
for i in range(32):
    s.add(a[i]<=126)
    s.add(a[i]>=32)
for i in range(8):
    for j in range(i):
        temp = a[4*i]
        for k in range(3):
            a[4*i+k] = a[4*i+k+1]
        a[4*i+3] = temp
for i in range(32):
    a[i] = a[i] ^ a[(32 + i - 1) % 32]
    a[i] = a[i] ^ key[(47 - i) % 16] ^ i
for i in range(0,32,4):
    s.add(a[i]+     8 * a[i + 1] + 6 * a[i + 2] + a[i + 3] == c[i])
    s.add(a[i + 1]+ 8 * a[i + 2] + 6 * a[i + 3] + a[i]     == c[i+1])
    s.add(a[i + 2]+ 8 * a[i + 3] + 6 * a[i]     + a[i + 1] == c[i+2])
    s.add(a[i + 3]+ 8 * a[i]     + 6 * a[i + 1] + a[i + 2] == c[i+3])
if s.check() == sat:
    m = s.model()
    print(m)
    print(''.join(chr(m[a2[i]].as_long()) for i in range(32)))
#SYC{Wow!!_Y0u_4r3_9o0d_At_r3$!!}

16.AES!

类型：AES魔改

仔细观察主函数，是aes加密，先试一边是不是无魔改的，结果不是...点开加密函数，观察哪里有魔改，之后发现是最简单的sbox换掉了，就把逆sbox搞出来，之后从网上随便找一个脚本就可以逆向了

逆sbox:(忘了在哪里找的脚本喵，网上一大堆就省略了喵)

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

17.Hello_re

类型：upx，异或

简单加密，没什么好说的

Exp:

#include<stdio.h>
void main() {
    int v4[32] = { 0 };
    v4[0] = 0;
    v4[1] = 1;
    v4[2] = 2;
    v4[3] = 52;
    v4[4] = 3;
    v4[5] = 96;
    v4[6] = 47;
    v4[7] = 28;
    v4[8] = 107;
    v4[9] = 15;
    v4[10] = 9;
    v4[11] = 24;
    v4[12] = 45;
    v4[13] = 62;
    v4[14] = 60;
    v4[15] = 2;
    v4[16] = 17;
    v4[17] = 123;
    v4[18] = 39;
    v4[19] = 58;
    v4[20] = 41;
    v4[21] = 48;
    v4[22] = 96;
    v4[23] = 26;
    v4[24] = 8;
    v4[25] = 52;
    v4[26] = 63;
    v4[27] = 100;
    v4[28] = 33;
    v4[29] = 106;
    v4[30] = 122;
    v4[31] = 48;
    int v3[8] = { 0 };
    int v2[8] = {0x52,0x45,0x56,0x4F,0x4C,0x43,0x59,0x53};
    for (int i = 0; i < 8; i++) {
        v3[i] = v2[8 - i-1];
    }
    for (int i = 0; i < 32; i++) {
        v4[i] = i ^ v4[i] ^ v3[i % 8];
        printf("%c", v4[i]);
    }
}

18.你干嘛~~

类型：aes，花指令

一眼顶针花指令，小改一下

下面都出来了，下面的base64是假的。我动调的时候进seh了还想着会有什么东西呢。

进入加密函数一眼aes：

看看各种表，没魔改，是cbc模式，一把梭了：

转一遍程序，gif好了：（不动？不动算了

19.好像是python？

类型：python反汇编

密文：

逻辑：

记住是以栈的形式的，写出

exp：

num = [-1, -36, 26, -5, 14, 41, 6, -9, 60, 29, -28, 17, 21, 7, 35, 38, 26, 48]
a = 13
b = 14
c = (a + b) ^ a
d = b * 100
e = a ^ b
m = (d - (c * 4) + e - 1)
r = m % 26
key = 'SYC'
length = 18
cipher = [0]*18
for i in range(18):
    cipher[i] = (num[i] - ((~ord(key[i % len(key)])) + 1)^i)
    print(chr(cipher[i]), end='')
print(cipher)
result = ''
for i in cipher:
    if ord('A') <= i <= ord('Z'):
        result+=(chr((i - ord('A') - r) % 26 + ord('A')))
    elif ord('a') <= i <= ord('z'):
        result+=(chr((i - ord('a') - r) % 26 + ord('a')))
    elif ord('0') <= i <=ord( '9'):
        result+=(chr((i - ord('0') - r) % 10 + ord('0')))
    else:
        result+=(chr(i))
print(result)
#D0_You_Iik3_python

20.贝斯！贝斯！（未交）

类型，baseX

除了base64不会了，把base85手撕了，base58不会手撕了，到后面才知道是base58，不过没地方提示时间戳？九月九有点久了吧

Base85手撕：

table4 = [0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
    0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
    0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
    0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2B, 0x2F,
    0x00]
enc = 'RjB6Myu#,>Bgoq&u.H(nBgdIaOKJbgEYj1GR4S.w'
a111 = None
def check_match(a,n):
    for i in table4:
        for j in table4:
            for k in table4:
                for l in table4:
                    a11 = (i << 0) | (j << 8) | (k << 16) | (l << 24)
                    tmp_a11 = a11
                    div_remainders = []
                    for _ in range(5):
                        div_remainders.append(tmp_a11 % 85)
                        tmp_a11 //= 85
                    if table[div_remainders[0]] == ord(a[5*n+4]):
                        if table[div_remainders[1]] == ord(a[5*n+3]):
                            if table[div_remainders[2]] == ord(a[5*n+2]):
                                if table[div_remainders[3]] == ord(a[5*n+1]):
                                    if table[div_remainders[4]] == ord(a[5*n+0]):
                                            return a11
    return None
for x in range(8):
    a111 = check_match(enc,x)
    if a111 is not None:
        print('%c%c%c%c'%(chr((a111>>24)&0xff),chr((a111>>16)&0xff),chr((a111>>8)&0xff),chr((a111>>0)&0xff)),end = '')
print(hex(a111))

Base58就是用时间戳为种子，生成随机数，能满足不重复的序列，魔改base码表，再解码。

21.ez_raw(未交)

类型：内存取证，kdbx

太好了，是内存取证。用vol3打开，扫描特定文件，例如flag、secret什么的标志词，看见一个key.kdbx文件，在这个文件的上面还有一个elf文件，全部拿出来，开始进行分析：

关键函数如上，取了128位，也就是16个字符，这里加密了前半，后面再用key异或加密所有flag，关键在于key拿到的时候还是做了加密处理：

打开key文件，可以找到历史文件有两个，一个是错的flag，想必是只找到这一个文件时的提醒，另外一个密钥版本是18个字符，用这个解密的时候出不来，之后才知道是要经过凯撒加密..

exp:

miwen=[0x24, 0xA5, 0x58, 0x59, 0x0B, 0x45, 0xEC, 0x94, 0x7A, 0xA6, 0xCE, 0x11, 0x10, 0x65, 0x8E, 0xA6, 0x6C, 0x31, 0x23, 0x05, 0x3E, 0x64, 0x3A, 0x26, 0x6E, 0x26, 0x25, 0x2E, 0x76, 0x34, 0x2E, 0x26]
key = 'lsxqpoxqgsdrcr4n0g'
key1 = 'bingfengwithsh4d0w'
flag2 = ''
for i in range(32):
    miwen[i] = miwen[i] ^ ord(key1[i % len(key1)]) ^ 0x33
    flag2 += chr(miwen[i])
print(flag2[16:])
flag1 = ''
idx = -1
for i in range(32):
    idx += 1
    for x in range(0,128):
        if (x * 23) % 256 == miwen[idx]:
            print(idx)
            flag1 += chr(x)
            break
print(flag1[:16]+flag2[16:])

标签

#笔记