攻防世界-first

题目下载：下载

IDA载入

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  __useconds_t *v3; // rbp
  unsigned int v4; // eax
  int *v5; // rcx
  int v6; // edx
  unsigned int v7; // eax
  signed __int64 v8; // rcx
  __int64 v9; // rax
  char v10; // bl
  char v11; // dl
  void (**v12)(void *); // rbp
  char *v13; // r12
  pthread_t *v14; // r13
  void (*v15)(void *); // rdi
  unsigned __int64 i; // rcx
  char v17; // al
  int *v18; // rdx
  int v19; // esi
  unsigned int v20; // eax
  unsigned __int64 v21; // rdx
  char *v22; // rax
  char *v23; // rdx
  char v24; // di

  v3 = useconds;
  v4 = time(0LL);
  srand(v4);
  do
    *v3++ = 100 * (rand() % 1000);
  while ( v3 != &unk_602208 );
  __isoc99_scanf("%63s", input);
  v5 = input;                                   // 输入的首地址给v5
  do
  {
    v6 = *v5++;
    v7 = ~v6 & (v6 - 16843009) & 0x80808080;
  }
  while ( !v7 );                                // v7等于0 就循环
  if ( (~v6 & (v6 - 16843009) & 32896) == 0 )
    v7 >>= 16;                                  // 右移16，相当于除以4
  if ( (~v6 & (v6 - 16843009) & 32896) == 0 )
    v5 = (v5 + 2);                              // v5应该是个地址
  v8 = v5 - (input + __CFADD__(v7, v7) + 3);    // __CFADD__函数的功能是返回两个参数相加后的CF标志位。
  v9 = 0LL;
  v10 = 0;
  while ( v8 != v9 )                            // 不相等就循环
  {
    v11 = *(input + v9) + v9;
    ++v9;                                       // 累加，知道等于v9
    v10 ^= v11;
  }
  v12 = &newthread;                             // v12是地址
  v13 = 0LL;
  v14 = &newthread;                             // v14也是地址
  do
  {
    if ( pthread_create(v14, 0LL, start_routine, v13) )// 创建线程的函数，它的功能是创建线程（实际上就是确定调用该线程函数的入口点），在线程创建以后，就开始运行相关的线程函数。
    {
      perror("pthread_create");
      exit(-1);
    }
    ++v13;
    ++v14;
  }
  while ( v13 != 6 );                           // v13==6，退出循环，所以pthread_create执行6次
  do
  {
    v15 = *v12++;
    pthread_join(v15, 0LL);                     // 主线程等待子线程的终止。
  }
  while ( &free != v12 );
  for ( i = 0LL; ; byte_60221F[i] = v10 ^ byte_6020DF[i] ^ v17 )
  {
    v18 = input;                                // v18是地址
    do
    {
      v19 = *v18++;                             // 把输入的值一个一个给v19
      v20 = ~v19 & (v19 - 16843009) & 0x80808080;
    }
    while ( !v20 );                             // v20不为0停止循环
    if ( (~v19 & (v19 - 16843009) & 32896) == 0 )
      v20 >>= 16;                               // v20右移
    if ( (~v19 & (v19 - 16843009) & 32896) == 0 )
      v18 = (v18 + 2);
    v21 = v18 - (input + __CFADD__(v20, v20) + 3);
    if ( v21 <= i )
      break;                                    // 终止for循环的唯一
    v17 = *(flag + i++);                        // v17遍历flag值
  }
  if ( v21 )                                    // v21不为0，进入条件1
  {
    if ( (LOBYTE(flag[0]) - 48) > 74u )         // 不走
    {
LABEL_32:
      puts("Badluck! There is no flag");
      return 0LL;
    }
    v22 = flag + 1;
    v23 = (v21 + 6300192);
    while ( v22 != v23 )                        // 不等 就循环
    {
      v24 = *v22++;                             // v24也是flag的值
      if ( (v24 - 48) > 74u )                   // 不走
        goto LABEL_32;
    }
  }
  __printf_chk(1LL, "Here is the flag:%s\n", flag);
  return 0LL;
}

代码很长，其实有用的挺少的，其他都是混淆代码。

开始代码：

首先进行输入一个input，然后有一个while循环涉及到input并且有个异或操作，所以可能挺重要的。

看下一段代码

 有一个pthread_create()函数：

pthread_create是类Unix操作系统（Unix、Linux、Mac OS X等）的创建线程的函数。它的功能是创建线程（实际上就是确定调用该线程函数的入口点），在线程创建以后，就开始运行相关的线程函数。若成功，返回0；若出错，返回出错编号。

参数

第一个参数为指向线程标识符的指针。

第二个参数用来设置线程属性。

第三个参数是线程运行函数的起始地址。

最后一个参数是运行函数的参数。

v13等于6时停止循环，所以这个循环创建了6个线程。跟进线程运行函数的起始地址start_routine

补充一下：pthread_mutex_lock 

pthread_mutex_lock： 是一个 POSIX 线程库中的函数，用于对互斥量进行加锁。该函数的作用是阻塞当前线程，直到该互斥量被解锁。一旦互斥量被加锁，其他线程将无法再次对其进行加锁。

互斥锁：对共享数据进行锁定，保证同一时刻只能有一个线程去操作。互斥锁是多个线程一起去抢，抢到锁的线程先执行，没有抢到锁的线程需要等待，等互斥锁使用完释放后，其它等待的线程再去抢这个锁，是无序的。

既然有6个线程，所以他们会一起去抢互斥锁并上锁对数据资源进行操作。那么哪个线程先抢到互斥锁呢，这里有个usleep函数，让不同线程挂起不同时间，所以这个对哪个线程抢到资源起决定性作用，抢到互斥锁之后上锁，因为有6个线程，所以用户输入分成6组，每组4个进行md5加密。然后和byte_602120比较，如果和对应的相等就执行 flag[v6] = input[v4]赋值给flag数组。

根据v8[0] == byte_602120[v1]条件可以求出input：

import hashlib
check="4746bbbd02bb590fbeac2821ece8fc5cad749265ca7503ef4386b38fc12c4227b03ecc45a7ec2da7be3c5ffe121734e8"
for i in range(6):
    for j in range(32,127):
        for m in range(32,127):
            for n in range(32,127):
                for k in range(32,127):
                    temp=chr(j)+chr(m)+chr(n)+chr(k)
                    crypto=hashlib.md5(temp.encode()).hexdigest()
                    if crypto[0:16]==check[i*16:i*16+16]:
                        print(i,temp)
#juhuhfenlapsiuerhjifdunu

但是由于usleep存在你不知道是哪个线程先抢到互斥锁，所以你不知道哪个input部分赋值给flag数组。这里应该可以动态调试出来flag数组，或者24种可能自己排列组合...结果是juhuhfenlapsdunuhjifiuer

然后再根据

 解出byte_60221F[i]数组就好(这个数组和要求flag一致，如下图)

input1='juhuhfenlapsiuerhjifdunu'
check=[0xfe,0xe9,0xf4,0xe2,0xf1,0xfa,0xf4,0xe4,0xf0,0xe7,0xe4,0xe5,0xe3,0xf2,0xf5,0xef,0xe8,0xff,0xf6,0xf4,0xfd,0xb4,0xa5,0xb2]
i=0
v10=0
while(i!=len(input1)):
	v11=ord(input1[i])+i
	v10=v10^v11
	i=i+1

input2='juhuhfenlapsdunuhjifiuer'
flag=''
for i in range(len(input2)):
	temp=ord(input2[i])^v10^check[i]
	flag+=chr(temp)
print(flag)

#goodjobyougetthisflag233

相关函数补充：

pthread_mutex_init()函数          功能：初始化一个互斥锁

pthread_mutex_destroy()函数   功能：销毁一个互斥锁

pthread_mutex_lock()函数        功能：加锁

pthread_mutex_trylock()函数    功能：尝试加锁

pthread_mutex_unlock()函数    功能：解锁