西湖论剑2021

最新推荐文章于 2022-11-08 21:39:53 发布
最新推荐文章于 2022-11-08 21:39:53 发布
阅读量319 收藏
点赞数
分类专栏： CTF-RE练习 文章标签： 信息安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52974719/article/details/121739800
版权

感悟: 收获挺大的，同时意识到自己的做题思路和方法还有所欠缺，还是要做好应对体力活的准备。

1、ROR

  __CheckForDebuggerJustMyCode(&unk_406029);
  v6[0] = 128;
  v6[1] = 64;
  v6[2] = 32;
  v6[3] = 16;
  v6[4] = 8;
  v6[5] = 4;
  v6[6] = 2;
  v6[7] = 1;
  memset(input, 0, sizeof(input));
  memset(Buf2, 0, sizeof(Buf2));
  printf("Input:", v4);
  scanf("%40s", (char)input);
  if ( strlen(input) != 40 )
    exit(0);
  for ( i = 0; i < 40; i += 8 )
  {
    for ( j = 0; j < 8; ++j )
    {
      v5 = ((v6[j] & input[i + 3]) << (8 - (3 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 3]) >> ((3 - j) % 8u)) | ((v6[j] & input[i + 2]) << (8 - (2 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 2]) >> ((2 - j) % 8u)) | ((v6[j] & input[i + 1]) << (8 - (1 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 1]) >> ((1 - j) % 8u)) | ((v6[j] & (unsigned __int8)input[i]) << (8 - -j % 8u)) | ((v6[j] & (unsigned int)input[i]) >> (-j % 8u));
      Buf2[j + i] = byte_405000[(unsigned __int8)(((v6[j] & (unsigned __int8)input[i + 7]) << (8 - (7 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 7]) >> ((7 - j) % 8u)) | ((v6[j] & input[i + 6]) << (8 - (6 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 6]) >> ((6 - j) % 8u)) | ((v6[j] & input[i + 5]) << (8 - (5 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 5]) >> ((5 - j) % 8u)) | ((v6[j] & input[i + 4]) << (8 - (4 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 4]) >> ((4 - j) % 8u)) | v5)];
    }
  }
  if ( memcmp(&unk_405100, Buf2, 0x28u) )
  {
    puts("Wrong");
    exit(0);
  }
  puts("Congratulations");
  puts("flag is DASCTF{your input}");
  return 0;
}

主要就是对输入8个一组进行位运算，之后再进行表byte_405000的索引，看到立马想到z3，修改代码z3解密。

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

赛后整理的时候copy一遍就过了，比赛的时候出了点问题，卡了段时间。

另一种解法就是了解程序的位运算在干什么，v6数组对应的8位二进制每一位,单拿一小段分析。

i=0
j=0~8
v6[0]=128->0x10000000
((v6[j] & input[i + 3]) << (8 - (3 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 3]) >> ((3 - j) % 8u)) | ((v6[j] & input[i + 2]) << (8 - (2 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 2]) >> ((2 - j) % 8u)) | ((v6[j] & input[i + 1]) << (8 - (1 - j) % 8u)) | ((v6[j] & (unsigned int)input[i + 1]) >> ((1 - j) % 8u)) | ((v6[j] & (unsigned __int8)input[i]) << (8 - -j % 8u)) | ((v6[j] & (unsigned int)input[i]) >> (-j % 8u))
    
/*上为char input[0~3]  分别与上v6[j]取出最高位，因为第二步限定(unsigned __int8)类型，所以只看右移，左移都舍去了
input 0   intput 1  input2  input3
高位  a0000000  b0000000  c0000000  d0000000
input3 右移3  input2 右移2  input 1 右移1 ..
变成 abcd0000
后半段也类似 加上input4~7 假设7为x0000000则 最后变为abcd...x
也就是8个一组 对应位的二进制重新组合按照顺序做到右放0-7的对应位
逆过程，通过enc在table中的索引转换为8个二进制，之后8个一组，重组即可。
*/

exp:

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

上述两种方法都可以求逆，不过擅长使用z3来解这道题是非常迅速的，减少了代码分析量。

2、TacticalArmed

赛后复现，学到很多东西，基础还是⑧顶，尤其是对执行流程有修改的代码。

win逆向，有Tlscallback函数，开了一个进程，跟进进程处理函数。

.text:004010D6 ;   __try { // __except at loc_4010F1
.text:004010D6                 mov     [ebp+ms_exc.registration.TryLevel], 0
.text:004010DD                 int     2Dh             ; Windows NT - debugging services: eax = type
.text:004010DF                 nop
.text:004010E0                 jmp     short loc_401142
.text:004010E0 ;   } // starts at 4010D6

存在Int 2d反调试，即正常运行会引发异常而检测到调试器则继续执行，所以真正代码逻辑在异常处理中。

分析代码知是对dword_405000这个内存中赋值了4个int，一般是修改key或某个解密需要的参数。

dword_405000 ->7CE45630h  58334908h  66398867h  0C35195B1h
//retn 指令
retn 4 -> pop eip  add esp,4

之后主函数内用到了一个函数指针v21,来表示lpadress的函数。

  lpAdress = malloc(0x10u);
  VirtualProtect(lpAdress, 0x10u, 0x40u, &flOldProtect);
  v21 = (__int64 (__fastcall *)(int, _DWORD))lpAdress;

//函数指针
    int Func(int x);   /*声明一个函数*/
    int (*p) (int);  /*定义一个函数指针*/
    p = Func;          /*将Func函数的首地址赋给指针变量p*/
	p(1) 等价 Func(1)

整体main函数如下

  lpAdress = malloc(0x10u);
  VirtualProtect(lpAdress, 0x10u, 0x40u, &flOldProtect);
  v21 = (__int64 (__fastcall *)(int, _DWORD))lpAdress;
  Src = (char *)&loc_405010;                    // 指向一个神秘的数串 类似opcode
  Size = 0;
  v18 = 0;
  printf("Input flag here:", v13);
  scanf("%255s", (char)Str);
  v17 = strlen(Str) >> 3;                       // size_t是unsigned int 的一个宏定义 主要用来计数
  a3 = 0;
  v15 = 0;
  a2 = 0;
  v12 = v4;
  HIDWORD(v11) = v3;
  v5 = __readeflags();
  v10 = v5;
  while ( 1 )                                   // v15循环33次 分清
  {
    while ( 1 )                                 
    {
      while ( Size )
      {
        memset(lpAdress, 0, 0x10u);             // 清0
        memcpy(lpAdress, Src, Size);            // 把src处指向的代码 赋值过去
        dispatch((int)lpAdress, a2, a3);
        *((_BYTE *)lpAdress + Size) = 0xC3;     // ret的机器码是0xc3
        __writeeflags(v10);
        v6 = v21(v12, HIDWORD(v11));
        v12 = v7;
        v11 = v6;
        v8 = __readeflags();
        v10 = v8;
        ++a2;
        Src += 16;
        Size = unk_405220[v18++];               // 读取opcode的大小 控制里面的代码执行
      }
      if ( v15 == 33 )
        break;
      ++v15;
      a2 = 0;
      Src = (char *)&loc_405010;
      Size = unk_405220[0];                     // 6
      v18 = 1;
    }
    if ( ++a3 == v17 )                          // v17是输入长度//8  输入8个一组
      break;
    v15 = 0;
    Size = 0;
  }
  if ( memcmp(Str, dword_40532C, 40u) )
  {
    puts("Wrong");
    exit(0);
  }
  puts("Congratulations");
  puts("flag is DASCTF{your input}");
  return 0;

主要步骤是是while(size)里的循环，主要是代码的执行。

*((_BYTE *)lpAdress + Size) = 0xC3;
是对每个语句末写上ret语句，用于返回。
之后通过v21来调用，在调用前还有一个针对opcode的smc

用switch case语句来进行不同变量的分发，比较新颖。

void __cdecl dispatch(int a1, int a2, int a3)
{
  unsigned int v3; // [esp+Ch] [ebp-50h]
  unsigned int v4; // [esp+50h] [ebp-Ch]
  int i; // [esp+58h] [ebp-4h]

  __CheckForDebuggerJustMyCode(&unk_406015);
  for ( i = 0; *(_BYTE *)(i + a1); ++i )        // 一直找opcode为0的地方停
    ;
  v4 = dword_4052A8[a2] % 0x10u;
  v3 = (unsigned int)dword_4052A8[a2] >> 4;     // 16进制数的高位和低位 16进制模式
  switch ( v3 )
  {
    case 1u:
      *(_DWORD *)(i + a1) = 4 * (v4 + 2 * a3) + 0x405648;// input a3是8个一组 依次越过8个字节
      break;
    case 2u:
      *(_DWORD *)(i + a1) = 4 * v4 + 0x405000;  // key
      break;
    case 3u:
      *(_DWORD *)(i + a1) = &unk_405748;        // sum 看汇编得出 
      break;
  }
}

case语句的左侧是一个int的指针，所以右侧是一个地址，可以跳转到0x405648和0x405000，发现一个是输入的首地址，一个这是在Tlscallback中被修改过的int数据组的地址，还有一个&unk_405748，没有其他的交叉引用所以初始默认为0，(全局变量)。

而switch 和 case中用到的索引在dword_4052A8这个数组中，16进制高位为case索引，低位为寻址的下标。

综上，流程就是把src处的代码依次cpy到lpadress中，通过dispatch来修改操作数的值(操作数也是写入机器码中的)，之后依次执行。这片代码通过v15控制一共执行33次，同时根据输入进行8个一组分组再循环上述操作。

Src = (char *)&loc_405010; src每次+16执行

mov操作后面都是00，所以需要dispatch来赋值。

8B 0D 00 00 00 00                 mov     ecx, large ds:0
81 E9 D2 96 5A 7E                 sub     ecx, 7E5A96D2h  
89 0D 00 00 00 00                 mov     large ds:0, ecx
8B 15 00 00 00 00                 mov     edx, large ds:0
C1 EA 05                          shr     edx, 5
A1 00 00 00 00                    mov     eax, large ds:0
03 C2                             add     eax, edx
8B 0D 00 00 00 00                 mov     ecx, large ds:0
03 0D 00 00 00 00                 add     ecx, large ds:0
33 C1                             xor     eax, ecx
8B 15 00 00 00 00                 mov     edx, large ds:0
C1 E2 04                          shl     edx, 4
8B 0D 00 00 00 00                 mov     ecx, large ds:0
03 CA                             add     ecx, edx
33 C1                             xor     eax, ecx
8B 15 00 00 00 00                 mov     edx, large ds:0
03 D0                             add     edx, eax
89 15 00 00 00 00                 mov     large ds:0, edx
A1 00 00 00 00                    mov     eax, large ds:0
C1 E8 05                          shr     eax, 5    
8B 0D 00 00 00 00                 mov     ecx, large ds:0  
03 C8                             add     ecx, eax
8B 15 00 00 00 00                 mov     edx, large ds:0
03 15 00 00 00 00                 add     edx, large ds:0   33 CA                             xor     ecx, edx
A1 00 00 00 00                    mov     eax, large ds:0
C1 E0 04                          shl     eax, 4
8B 15 00 00 00 00                 mov     edx, large ds:0
03 D0                             add     edx, eax
33 CA                             xor     ecx, edx
A1 00 00 00 00                    mov     eax, large ds:0
03 C1                             add     eax, ecx
A3 00 00 00 00                    mov     large ds:0, eax

脚本对4025A8数组处理，拿到修改操作数的流程。

for ( i = 0; *(_BYTE *)(i + a1); ++i )；        // 一直找opcode为0的地方停

3 0 3 1 0 2 0 3 1 0 1 0 2 0 0 1 0 1 1 0 2 0 3 1 0 1 0 2 0 0 1 0 
0 0 0 1 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0 2 0 0 1 0 
//举例
 3 0 -> switch(3) 也就是 把8D 0D 00 00 00 00 后4个改成unk_405748的地址并取内容赋值给ecx
 0 0 无操做
 1 1 是取出input[1] 右边是v4=1   4 * (v4 + 2 * a3) + 0x405648
 2 1 是取出key[1] //大致分析后确定  
 ...依次补全汇编并翻译

如下:

mov ecx,&unk_405748

sum=0;

sub     ecx, 7E5A96D2h
mov &unk_405748,ecx

sum-=0x7E5A96D2

mov  edx,input[1]
shr edx,5

mov eax,key[1]

add eax,edx //2 1  0 0

mov ecx,sum
add ecx,input[1]

xor eax,ecx   //(input[1]+sum)^(input[1]>>5 + key[1])

mov edx, input[1]
shl edx,4
mov ecx,key[0]
add ecx,edx
xor eax,ecx
// (input[1]<<4 + key[0])^(input[1]+sum)^(input[1]>>5 + key[1])

mov edx ,input[0]
add edx,eax

mov edx,input[0] 

//以上实现的就是 v0+=(v1<<4 + k0)^(v1 + sum)(v1 >>5 + k1)
.....

//不过汇编中没有 mov  xxx,0 并且 对 sum 那边地址内容unk_405748 也没有别的交叉引用  也就是每组

分析到一半就能推出是Tea加密，轮数为33 ，default为0x7E5A96D2，既然分析出&unk_405748为sum，并且对他没有别的引用，所以再对密文多次加密时sum是在上一轮基础上使用的。

解密脚本:

#include<iostream>
void tea_decode(unsigned int* s, unsigned int* key,int count);
int main() {
	int a = 0xE98651DC67185A11;
	unsigned int enc[] = { 0x422F1DED,0x1485E472,0x35578D5,0x0BF6B80A2,0x97D77245,0x2DAE75D1,0x665FA963,0x292E6D74,0x9795FCC1,0x0BB5C8E9};
	unsigned int key[4] = { 0x7CE45630,0x58334908,0x66398867,0x0C35195B1 };
	for(int i=0;i<10;i+=2)
	tea_decode(enc+i, key,i/2);
	return 0;
}
void tea_decode(unsigned int* s, unsigned int* key,int count) {
	unsigned int v0 = s[0];
	unsigned int v1 = s[1];
	uint32_t sum = 0;
    unsigned int defalt = 0x7E5A96D2;
	unsigned int k0 = key[0], k1 = key[1], k2 = key[2], k3 = key[3];
	for (int i = 0; i < (33*count+33); i++)// sum状态保存到下一组
		sum -= defalt;
	for (int i = 0; i < 33; i++) {  
		v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
		v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
		sum += defalt;
	}
	s[0] = v0;
	s[1] = v1;
	printf("%d,%d,", v0,v1);
}
/*
a=[826566507,843212655,845236089,1097428850,1198086245,1902206776,1132088430,1181900618,1917866824,1261778286]
for i in a:
    print(int.to_bytes(i,4,'little').decode(),end='')
*/

3、虚假的粉丝

dos界面的代码动画，有点震撼，不过题目没设计到什么算法，主要还是读流程。

首先就是找到3个key，查看strings窗口，发现第一字符串很可疑,对其交叉引用发现了一个未被调用的函数，需要重新定义一下。

//#j#M_OEE!jmhih,=555"xtx
int sub_401379()
{
  char Buffer[100]; // [esp+16h] [ebp-92h] BYREF
  char FileName[30]; // [esp+7Ah] [ebp-2Eh] BYREF
  FILE *Stream; // [esp+98h] [ebp-10h]
  int i; // [esp+9Ch] [ebp-Ch]

  for ( i = 0; i <= 23; ++i )
    FileName[i] = aJMOeeJmhih555X[i] ^ 0xC;
  Stream = fopen(FileName, "r");
  fread(Buffer, 0x57u, 1u, Stream);
  return printf("%s\n", Buffer);
}

拉出去异或一下，是在读P./f/ASCII-faded 1999P.txt这个文件，打开查看，发现key。

K3y1: (hex(ord('A')) + hex(ord('W'))).replace("0x", "")
K3y2: ord('F') + ord('a') + ord('d') + ord('e') + ord('d') + ord('i') + ord('s') + ord('b') + ord('e') + ord('s') + ord('t')
#key3是文件读取的字节大小，根据if判断知是40
if ( Buffer[0] != 'U' || Buffer[39] != 'S' )

之后它通过上述的key计算了一个新的文件，之后从中读取内容。

"UzNDcmU3X0szeSUyMCUzRCUyMEFsNE5fd0FsSzNS"
base64 -> url解码 -> S3Cre7_K3y = Al4N_wAlK3R

之后观察一个用到key的check结果的处理。

 if ( v24 == 1 )
  {
    v25 = 5317;
    Stream = fopen("./f/ASCII-faded 5315.txt", "rb");
    if ( !Stream )
    {
      printf("ERROR!\n");
      return 0;
    }
    fread(v6, 0x4EDEu, 1u, Stream);
    fclose(Stream);
    v22 = 0;
    for ( i = 0; i <= 0x84E; ++i )
    {
      if ( v22 > 10 )
        v22 = 0;
      v6[i] ^= key[v22++];
    }
    Stream = fopen("./f/ASCII-faded 5315.txt", "w");
    fwrite(v6, 0x84Fu, 1u, Stream);
    fclose(Stream);
  }

对5317进行异或之后再写入，再异或一次观察内容,后面就没什么内容了，就是接着奏乐接着舞了。

key='Al4N_wAlK3R'
f=open('ASCII-faded 5315.txt','r+')
s=f.read()
for i in range(len(s)):
    print(chr(ord(s[i])^ord(key[i%len(key)])),end='')

输入key跑起来还是挺不错的，摘掉眼镜.jpg。

A_TrUe_AW_f4ns

不过这题，静态的话就最后一个key有用，还是在文件中，并且U和S已知，直接文件搜索，也能拿到key，然后直接异或就可以了。

for i in range(1,5317):
    f=open('ASCII-faded %s.txt'%str(i).zfill(4),'r+')
    s=f.read()
    if 'U'in s and 'S' in s:
        print(i)
    else:
        f.close()
        continue
"""
4157 ->key的文件
5315
"""

比赛时候挺麻的，比赛快要截止才有点感觉，还有一个硬件描述语言有待复现，计组实验课用的verilog神似，关键是不会啊! 人不行别怪路不平，还得补！。

Lu1u~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
漏洞分析丨HEVD-0x2.StackOverflowGS[win7x86]
m0_64973256的博客
07-07 236
视频制作不易，求三联支持，拜谢~添加公众账号“极安御信安全研究院”，报暗号：“资料” 即可领取视频相关工具、源码、学习资料，和其他逆向工程免费课。进交流群报暗号“交流群” 网络安全交流群QQ：434238324...
SEH 进阶（1）
商少
04-23 1490
SHE进阶 了解了上一篇的文章之后，我们写一个简单的例子来验证我们的想法，并学习新的知识。 不同的编译器提供的增强版本SHE 可能不同，但是它们都是基于windows 底层SHE 的。我们使用Win10 1703 + VS2010 生成X86 Rlease 程序来验证已经学过的知识，后面使用XP x86 7600 来学习编译器版本的SHE。 编译如下程序 #define WIN32_LEA
[Windows] CVE-2011-2005 Afd.sys 本地提权漏洞复现
fa1c4的blog
01-26 3185
前言 这是一个微软在2011.10发布的补丁中提到的系统辅助驱动程序Afd.sys存在的本地提权漏洞, 影响到Windows XP, 和Windows Server 2003系统. 漏洞成因是Microsoft Windows Ancillary Function Driver(afd.sys)驱动程序没有完善检测用户提交的数据, 攻击者可以利用该漏洞执行任意代码. 漏洞分析 漏洞利用 总结 ...
VirtualAllocAPi逆向笔记
qq_43147121的博客
11-08 1106
Windows API逆向
2022DASCTF easyre
weixin_49764009的博客
03-27 524
基本面 32位 ASPack壳 既然是签到题应该不会太难把 手动脱壳 直接ESP定律就可以了 可以参考之前写过的帖子 基本一样 https://blog.csdn.net/weixin_49764009/article/details/122059947 注意入口的位置 这个位置才是正确的入口位置 一开始找错了 真是给我整不会了 静态分析 int __cdecl main(int argc, const char **argv, const char **envp) { unsigned __i
西湖论剑2021中国杭州网络安全技能大赛.zip
12-07
CTF 西湖论剑 决赛 2021
2021西湖论剑网络安全大会PPT汇总.zip
10-27
2021西湖论剑网络安全大会PPT汇总。 1、赋能数据开放、激活数据价值 2、防范电信网络诈骗科普分论坛-数字时代下的电信网络诈骗及防范 3、防范电信网络诈骗科普分论坛-网络空间生存法则 4、工业互联网安全分论坛-...
2021西湖论剑演讲ppt合集.zip
11-18
2021西湖论剑演讲ppt合集 数据开放和工业互联网
2024西湖论剑数据安全PHPEMS源码包
02-14
2024西湖论剑数据安全PHPEMS源码包
2021西湖论剑网络安全大赛部分WP
七堇年的博客
12-23 4534
2021西湖论剑网络安全大赛WP
山西省第二届网络安全技能大赛（企业组）部分赛题WP（九）
qq_32499435的博客
07-29 175
逆向题 intertwine.exe
西湖论剑reverse第三题
XFox_的博客
11-20 461
memset(Str, 0, sizeof(Str)); memset(Buf2, 0, sizeof(Buf2)); sub_401650("Input:", v4); sub_4016A0("%40s", (char)Str); if ( strlen(Str) != 40 ) exit(0); for ( i = 0; i < 0x28; i += 8 ) //循环5次 { for ( j = 0; j < 8; ++j )//每8个为一组做一..
2022DASCTF Apr X FATE 防疫挑战赛 Writeup
末初的CSDN博客
04-25 2474
文章目录SimpleFlow熟悉的猫冰墩墩 废物选手的misc做题记录 SimpleFlow 首先tcp.stream eq 50中分析传入的执行命令的变量是$s，也就是参数substr($_POST["g479cf6f058cf8"],2) 找到对应的参数，然后去掉前面两位字符解码即可 cd "/Users/chang/Sites/test";zip -P PaSsZiPWorD flag.zip ../flag.txt;echo [S];pwd;echo [E] 得到压缩包密码：PaSsZi
参加西湖论剑2021
暮冬拾叁的博客
04-24 420
参加西湖论剑2021一组照片总结 一组照片 今天在美丽的人杭州参加了西湖论剑，直接上一组照片吧。 总结 杭州今天有雨，但人在论坛现场感觉不到，哈哈哈
CFreeMarshaler::MarshalInterface逆向结果唯一可以触发CFreeMarshaler::InitSecret的地方
如鹿渴慕泉水的专栏
03-16 354
HRESULT __stdcall CFreeMarshaler::MarshalInterface(CFreeMarshaler *this, IStream *pStm, _GUID *riid, void *pv, unsigned int dwDestContext, void *pvDestContext, unsigned int mshlflags) { int v7; // e...
南邮 逆向 部分题解
木槿华年的博客
08-24 3196
转自： https://blog.csdn.net/xiangshangbashaonian/article/details/78878876 Hello,RE! 首先可以看到提示如下     我还是查了一下 无壳 提示用IDA 那我们就载入 shift+f12查找字符串 在ida浏览A界面选定要查看的函数，按f5看到了伪代码， 于是点击字符串按R转化为其实际值 ...
2021西湖论剑web部分wp
fmyyy1的博客
11-21 1797
前言 快期末了 忙里偷闲打了西湖论剑，队伍第七，又被队友带飞了，web题目质量还可以 OA?RCE? 环境没有写的权限，本地有打通环境打不通的情况很多 之后在webmain/index/indexAction.php处 有个包含任意php文件 有个查看phpinfo的 看了之后开着register_argc_argv，尝试包含pearcmd payload 第一步 ?m=index&a=getshtml&surl=Li4vLi4vLi4vLi4vLi4vdXNyL2xvY2FsL2x
C++反汇编与逆向之识别main函数学习笔记
AvinLi的专栏
03-16 1106
int main(int argc, char* argv[]) { // main(int 1, char * * 0x00380d70) line 7 // mainCRTStartup() line 206 + 25 bytes // KERNEL32! 7c817067() // 根据堆栈的先进后出原则可知 // 程序在调用main函数之前，先调用了Kernel32 ->
node-v4.2.2-headers.tar.xz
最新发布
05-21
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
2021西湖论剑 zip
09-26
2021西湖论剑是一场面向全球的技术大赛，旨在选拔和展示在信息技术领域有创新能力和实践经验的优秀人才。zip是这次比赛的主题之一，它代表着压缩和解压缩文件的技术。 zip技术是一种常用的文件压缩算法，它能将多个文件或文件夹压缩成一个单独的zip文件，从而减少存储空间和传输时间。在2021西湖论剑中，参赛选手会面临一系列与zip相关的挑战，包括压缩算法的优化、解压缩效率的提升以及安全性的加强等。 比赛过程中，参赛选手需要展示对zip技术的深入理解和实践经验。他们需要通过优化算法、改进压缩和解压缩过程中的细节，以及运用先进的数据结构和算法来提高zip的性能。此外，参赛选手还需要关注zip技术的安全性，抵御可能存在的恶意攻击，确保压缩和解压缩过程的完整性和可信度。 在比赛结束后，评审团将根据参赛选手的成绩和方案来评选出优胜者，并颁发相应的奖励。除了竞赛成绩外，参赛选手还可以通过交流和分享经验，扩展专业网络和知识储备。 总的来说，2021西湖论剑的zip主题是一个挑战性的技术赛题，需要参赛选手在zip压缩和解压缩领域展示创新能力和实践经验。这将进一步推动zip技术的发展和创新，为信息技术的进步做出贡献。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值