ACTF 新生赛 2020 SoulLike

https://buuoj.cn/challenges#[ACTF%E6%96%B0%E7%94%9F%E8%B5%9B2020]SoulLike

elf 64

太大了，反编译不了

试试动调 输入 actf{111111111111111111} 看出来是对输入和验证都进行了操作，这不好搞了

看看别人是怎么做的

1. 调整 ida 配置，然后逆向脚本：进入 cfg 文件夹，找到 hexrays.cfg 文件，打开，找到 MAX_FUNCSIZE

将原来的 64 改为 1024，重新启动 ida 即可

看别人的 WP 好像可以用 angr 符号求解

最近比较有空，学一下 angr 吧

angr

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  char flag; // [rsp+7h] [rbp-B9h]
  int i; // [rsp+8h] [rbp-B8h]
  int j; // [rsp+Ch] [rbp-B4h]
  int buffer[14]; // [rsp+10h] [rbp-B0h] BYREF
  char pre[6]; // [rsp+4Ah] [rbp-76h] BYREF
  char input[104]; // [rsp+50h] [rbp-70h] BYREF
  unsigned __int64 v11; // [rsp+B8h] [rbp-8h]
 
  v11 = __readfsqword(0x28u);
  printf("input flag:");
  scanf("%s", input);
  strcpy(pre, "actf{");
  flag = 1;
  for ( i = 0; i <= 4; ++i )
  {
    if ( pre[i] != input[i] )
    {
      flag = 0;
      goto LABEL_6;
    }
  }
  if ( !flag )
    goto avoid;
LABEL_6:
  for ( j = 0; j <= 11; ++j )
    buffer[j] = input[j + 5];
  if ( (unsigned __int8)sub_83A(buffer) && input[17] == '}' )
  {
    printf("That's true! flag is %s", input);
    return 0LL;
  }
  else
  {
avoid:
    printf("Try another time...");
    return 0LL;
  }
}

对每个字符都进行一个判断，一旦不对就退出

❯ checksec --file=SoulLike
RELRO           STACK CANARY      NX            PIE             RPATH      RUNPATH      Symbols         FORTIFY     Fortified       Fortifiable     FILE
Full RELRO      Canary found      NX enabled    PIE enabled     No RPATH   No RUNPATH   No Symbols        No0               1               SoulLike

用 checksec 查一下发现有 PIE 偏移，不知道 angr 跑不跑的了

查了资料：

angr automatically loads PIE binaries at 0x400000. angr has no trouble dealing with PIE binaries.

原来是这样，那就加上嘛

堆栈信息

-00000000000000B9 flag            db ?
-00000000000000B8 var_B8          dd ?
-00000000000000B4 j               dd ?
-00000000000000B0 buffer          dd 14 dup(?)
-0000000000000078                 db ? ; undefined
-0000000000000077                 db ? ; undefined
-0000000000000076 input           db 8 dup(?)
-000000000000006E                 db ? ; undefined
-000000000000006D                 db ? ; undefined
-000000000000006C                 db ? ; undefined
-000000000000006B                 db ? ; undefined
-000000000000006A                 db ? ; undefined
-0000000000000069                 db ? ; undefined
-0000000000000068                 db ? ; undefined
-0000000000000067                 db ? ; undefined
-0000000000000066                 db ? ; undefined
-0000000000000065                 db ? ; undefined
-0000000000000064                 db ? ; undefined
-0000000000000063                 db ? ; undefined
-0000000000000062                 db ? ; undefined
-0000000000000061                 db ? ; undefined
-0000000000000060                 db ? ; undefined
-000000000000005F var_5F          db ?

import angr  
proj = angr.Project('./SoulLike', auto_load_libs=False)  
state = proj.factory.entry_state()  
simgr = proj.factory.simgr(state, veritesting=True)  
simgr.explore(find=0x400000+ 0x00000000001117D, avoid=[0x400000+0x0000000000111A1, 0x400000 + 0x00000000001102D])  
print(simgr.found[0].posix.dumps(0))

我的电脑跑不出来，好像别人的可以，可能是我的电脑太菜了？🥲

试一下反编译软件 retdec 好慢……

file 命令查看文件信息

---

还是用 IDA 跑吧，就是反过来跑一次

注意加法操作要变成减法等等，这里打个脚本先

import re  
  
# 示例C代码  
c_code = """  
*a1 ^= 0x2Bu;  a1[8] ^= 8u;  
++a1[9];a1[10] += 1;  
a1[11] -= 2;  
a1[12] = 3;  
""" 
  
# 更新正则表达式以匹配前缀和后缀的递增/递减操作  
pattern = re.compile(r'\s*(\+\+|--)?(\*\w+|\w+\[\d+])(\+\+|--)?\s*([\^=+-]*)\s*(.*?);')  
  
# 找到所有匹配的操作  
matches = pattern.findall(c_code)  
  
# 逆向操作  
reversed_operations = []  
for pre_inc_dec, var, post_inc_dec, op, value in reversed(matches):  
    # 处理前缀递增/递减  
    if pre_inc_dec:  
        if pre_inc_dec == '++':  
            reversed_operations.append(f'--{var};')  
        elif pre_inc_dec == '--':  
            reversed_operations.append(f'++{var};')  
    # 处理后缀递增/递减  
    elif post_inc_dec:  
        if post_inc_dec == '++':  
            reversed_operations.append(f'{var}--;')  
        elif post_inc_dec == '--':  
            reversed_operations.append(f'{var}++;')  
    # 处理其他操作  
    elif op:  
        if op == '^=':  # 异或操作不变  
            reversed_operations.append(f'{var} ^= {value};')  
        elif op == '+=':  # 加等变减等  
            reversed_operations.append(f'{var} -= {value};')  
        elif op == '-=':  # 减等变加等  
            reversed_operations.append(f'{var} += {value};')  
        elif op == '=':  # 赋值操作，逆向时通常不变  
            reversed_operations.append(f'{var} = {value};')  
  
# 输出逆向后的C代码  
for operation in reversed_operations:  
    print(operation)  
      
# 输出：  
# a1[12] = 3;  
# a1[11] += 2;  
# a1[10] -= 1;  
# --a1[9];  
# a1[8] ^= 8u;  
# *a1 ^= 0x2Bu;

b0Nf|Re_LiT!