码迷，mamicode.com
首页 > 其他好文 > 详细

adworld-re新手练习区

时间：2020-01-24 09:31:34      阅读：103      评论：0      收藏：0      [点我收藏+]

标签：encode   缓冲   函数实现   变量   bit   hid   create   import   源码   

RE

re1

下载得到exe文件，运行：

 技术图片

使用exeinfo分析，发现是32位无壳的exe，拖入IDA，f5反编译：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // eax
  __int128 v5; // [esp+0h] [ebp-44h]
  __int64 v6; // [esp+10h] [ebp-34h]
  int v7; // [esp+18h] [ebp-2Ch]
  __int16 v8; // [esp+1Ch] [ebp-28h]
  char v9; // [esp+20h] [ebp-24h]
?
  _mm_storeu_si128((__m128i *)&v5, _mm_loadu_si128((const __m128i *)&xmmword_413E34));
  v7 = 0;
  v6 = qword_413E44;
  v8 = 0;
  printf(&byte_413E4C);
  printf(&byte_413E60);
  printf(&byte_413E80);
  scanf("%s", &v9);
  v3 = strcmp((const char *)&v5, &v9);
  if ( v3 )
    v3 = -(v3 < 0) | 1;
  if ( v3 )
    printf(aFlag);
  else
    printf((const char *)&unk_413E90);
  system("pause");
  return 0;
}

追踪查看了unk_413E90中存放的内容是：flagget 所以v3运行结果应该是0，也即v5和v9中存放的东西相同；所以去找v5中的内容，发现：

  _mm_storeu_si128((__m128i *)&v5, _mm_loadu_si128((const __m128i *)&xmmword_413E34));

猜测意思是将xmmword_413E34的内容赋值给v5，所以继续看xmmword_413E34的内容，得到flag：DUTCTF{We1c0met0DUTCTF}

注：

void  _mm_storeu_si128(_m128i *p,_m128i a)

SSE指令，将_m128i变量a的值存储到p所指定的变量中

_m128i _mm_loadu_si128(_m128i *p)

SSE指令，返回寄存器中的值

game

打开题目，玩一会2333，好吧，玩是玩不出flag的，放入exeinfo，发现32位，拖入IDA，找到main主函数，f5反编译，发现全部变成1后，会执行sub_457AB4( )函数：

 技术图片

跟进它：技术图片

来到sub_45E940（ ）函数，发现关键部分：

技术图片

写脚本跑一下：

list1=[]
list2=[]
file1 = open("1.txt",‘r‘)
file2 = open("2.txt",‘r‘)
file3 = open("3.txt",‘w‘)
for line in file1:
    line=line.strip(‘\n‘)
    list11=line.split(‘=‘)
    list1.append(list11[1])
for line in file2:
    line=line.strip(‘\n‘)
    list12=line.split(‘=‘)
    list2.append(list12[1])
?
list3=[]
for i in range(57):
    list3.append(int(list1[i])^int(list2[i]))
    file3.write(str(list3[i]))
    file3.write(‘\n‘)
file1.close()
file2.close()
file3.close()
list4=[]
file4=open("3.txt",‘r‘)
for line in file4:
    line=line.strip(‘\n‘)
    list4.append(line)
for i in range(57):
    list4[i]=chr(int(list4[i])^0x13)
    
print ‘‘.join(list4)

注：如果IDA不能正确的获得自定义函数的名字，那么IDA会用sub__加上自定义函数的起始地址来定义函数的名字

Hello,CTF

打开题目，IDA->f5，发现关键代码：

技术图片

要求输入的字符串与v13相同且长度不超过17，题目提示不一定是明文比较，所以将v13十六进制转换成字符串：CrackMeJustForFun，也即flag

注:

int sprintf(char *string, char *format [,argument,...]);

说明：把格式化（format与其后数量不定的参数）的数据写入某个字符串缓冲区（string），有缓冲区溢出的可能，不安全

open-source

下载得到一个C源码，

技术图片

将上面的参数值代入计算，得到flag.

Simple-unpack

exeinfo分析下载的文件：

技术图片

Linux upx -d 脱壳，载入IDA发现flag.

logmein

exeinfo显示下载文件为64位ELF文件，拖入IDA，f5反编译：

技术图片

要求flag长度应与v8相同，且每一位都是由v7和v8的对应字符异或得到，所以编写EXP:

v7="harambe"  #重点！
str=":\"AL_RT^L*.?+6/46"
flag=‘‘
for i in range(len(str)):
    flag += chr(ord(str[i])^ord(v7[i%7]))
    
print flag

或者C++脚本：

#include <iostream>
#include <cstring>
typedef unsigned char BYTE;
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
?
int main(int argc, char** argv) {
    long long int v7=28537194573619560;
    char v8[18] =":\"AL_RT^L*.?+6/46";
    char s[18];//定义字符数组变量，char a[字符串长度+1]；
    int i;
    for(i=0;i<strlen(v8);i++)
    {
        s[i]=(char)(*((BYTE *)&v7+i%7)^v8[i]);
    }
    s[i]=‘\0‘;
    cout<<s;
    return 0;
}

跑出flag.

注：

1.在计算机中数据全部以二进制形式储存，所以v7是int型还是字符串型本质上是相同的，但是在该程序中，计算机以小端字节序储存数据，所以v7变成字符串时应该从后向前读取。

2.v8是":\"AL_RT^L*.?+6/46"，该字符串长度应为17，其中包含转移字符\"

3.IDA宏定义：

typedef unsigned char uint8;  
?
#define _BYTE  uint8   //所以说_BYTE代表了四个字节
insanity

ida->f5查看伪码：

技术图片

大概意思应该是不断地随机（以程序运行时间为种子，取随机数）取strs这个字符串中的字符，跟进strs，得到flag:9447{This_is_a_flag}

no-strings-attached

拿到下载文件放进exeinfo分析一下：

为32位ELF文件，拖进IDA分析，找啊找，找到decrypt函数！

wchar_t *__cdecl decrypt(wchar_t *s, wchar_t *a2)
{
  size_t v2; // eax
  signed int v4; // [esp+1Ch] [ebp-1Ch]
  signed int i; // [esp+20h] [ebp-18h]
  signed int v6; // [esp+24h] [ebp-14h]
  signed int v7; // [esp+28h] [ebp-10h]
  wchar_t *dest; // [esp+2Ch] [ebp-Ch]
?
  v6 = wcslen(s);
  v7 = wcslen(a2);
  v2 = wcslen(s);
  dest = (wchar_t *)malloc(v2 + 1);
  wcscpy(dest, s);
  while ( v4 < v6 )
  {
    for ( i = 0; i < v7 && v4 < v6; ++i )                    // v6是s的长度  v7是a2的长度  dest是s
      dest[v4++] -= a2[i];
  }
  return dest;
}

意思是s的每一位循环减去a2的每一位，最后存入dest。

找到调用位置----

void authenticate()
{
  int ws[8192]; // [esp+1Ch] [ebp-800Ch]
  wchar_t *s2; // [esp+801Ch] [ebp-Ch]
?
  s2 = decrypt(&s, &dword_8048A90);
  if ( fgetws(ws, 0x2000, stdin) )
  {
    ws[wcslen(ws) - 1] = 0;
    if ( !wcscmp(ws, s2) )
      wprintf((int)&unk_8048B44);
    else
      wprintf((int)&unk_8048BA4);
  }
  free(s2);
}

可以看出flag应该就是加密后的密文，下面有两种方法解决——

方法一：静态分析，编写exp

#include <iostream>
using namespace std;
?
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
?
int main(int argc, char** argv) {
    int i=1,j=0;
    int a[]={0x3A,0x36,0x37,0x3B,0x80,0x7A,0x71,0x78,0x63,0x66,0x73,0x67,0x62,0x65,0x73,0x60,0x6B,0x71,0x78,0x6A,0x73,0x70,0x64,0x78,0x6E,0x70,0x70,0x64,0x70,0x64,0x6E,0x7B,0x76,0x78,0x6A,0x73,0x7B,0x80,0};
    char t;
    while(a[j]!=0)
    {
        t=a[j++]-(i++);
        cout<<t;
        if(i==6)
        {
            i=1;
        }
    }   return 0;
}

跑出flag: 9447{you_are_an_international_mystery}

方法二：linux下gdb动态分析（来自平台wp）

gdb 文件路径

先在dectypt函数处下断点---- b decrypt

然后运行程序至断点处---- r

单步执行---- n

在IDA中可以看到

技术图片

加密后的结果存入了寄存器eax中，

所以最后查看运行结果---- x/50wx $eax【注：wx为以word即两个字节32bit形式查看】

技术图片

16进制转ASCII同样得到flag。

csaw2013reversing2

exeinfo发现32bit PE文件，运行得到乱码，在IDA中反编译分析——

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  int v3; // ecx
  CHAR *lpMem; // [esp+8h] [ebp-Ch]
  HANDLE hHeap; // [esp+10h] [ebp-4h]
?
  hHeap = HeapCreate(0x40000u, 0, 0);
  lpMem = (CHAR *)HeapAlloc(hHeap, 8u, MaxCount + 1);
  memcpy_s(lpMem, MaxCount, &unk_409B10, MaxCount);
  if ( sub_40102A() || IsDebuggerPresent() )
  {
    __debugbreak();
    sub_401000(v3 + 4, lpMem);
    ExitProcess(0xFFFFFFFF);
  }
  MessageBoxA(0, lpMem + 1, "Flag", 2u);
  HeapFree(hHeap, 0, lpMem);
  HeapDestroy(hHeap);
  ExitProcess(0);
}

关键是if( )函数，其中sub_401000应该为得到flag的函数，

unsigned int __fastcall sub_401000(int a1, int a2)
{
  int v2; // esi
  unsigned int v3; // eax
  unsigned int v4; // ecx
  unsigned int result; // eax
?
  v2 = dword_409B38;
  v3 = a2 + 1 + strlen((const char *)(a2 + 1)) + 1;
  v4 = 0;
  result = ((v3 - (a2 + 2)) >> 2) + 1;
  if ( result )
  {
    do
      *(_DWORD *)(a2 + 4 * v4++) ^= v2;
    while ( v4 < result );
  }
  return result;
}

但是跟进sub_40102A发现永远return 0;而另一个条件则在调试状态下成立，因此暂时有三种思路可以解决这个问题：

（一）IDA静态分析

分析sub_401000( )函数，自己编写函数实现的脚本跑出flag:

#include <iostream>
using namespace std;
typedef unsigned char BYTE;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
?
int main(int argc, char** argv) {
    int v2[] ={0xBB,0xAA,0xCC,0xDD};
    char result[]={0xBB,0xCC,0xA0,0xBC,0xDC,0xD1,0xBE,0xB8,0xCD,0xCF,0xBE,0xAE,0xD2,0xC4,0xAB,0x82,0xD2,0xD9,0x93,0xB3,0xD4,0xDE,0x93,0xA9,0xD3,0xCB,0xB8,0x82,0xD3,0xCB,0xBE,0xB9,0x9A,0xD7,0xCC,0xDD};
    int i;
    for(i=0;i<0x24;i++)
    {
        result[i]^=v2[i%4];
        cout<<result[i];
    }
    return 0;
}

注：

1.在main()中可以看到由memcpy_s( )函数对lpmem空间初始化，也即result[]初值

2.分析memcpy_s( )函数可以看到每个单元为8bit，也即两个十六进制位，所以实现异或时，v2也应8bit为一个单元进行异或，即v2[]初值

（二）OllyDBG动态调试

在调试状态下，执行if( )函数：

首先int 3为断点指令——

技术图片

所以调试到int 3停止，在OD中f8单步执行，

技术图片

随后edx寄存器中存储函数执行结果的地址，查看得到flag:

技术图片

（三）IDA改变函数执行逻辑

技术图片

修改汇编语言指令，再次运行，得到flag:

技术图片

getit

exeinfo分析知为64bit ELF文件，IDA反汇编分析：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char v3; // al
  __int64 v5; // [rsp+0h] [rbp-40h]
  int i; // [rsp+4h] [rbp-3Ch]
  FILE *stream; // [rsp+8h] [rbp-38h]
  char filename[8]; // [rsp+10h] [rbp-30h]
  unsigned __int64 v9; // [rsp+28h] [rbp-18h]
?
  v9 = __readfsqword(0x28u);
  LODWORD(v5) = 0;
  while ( (signed int)v5 < strlen(s) )
  {
    if ( v5 & 1 )
      v3 = 1;
    else
      v3 = -1;
    *(&t + (signed int)v5 + 10) = s[(signed int)v5] + v3;
    LODWORD(v5) = v5 + 1;
  }             // flag实现过程
  strcpy(filename, "/tmp/flag.txt");
  stream = fopen(filename, "w");
  fprintf(stream, "%s\n", u, v5);
  for ( i = 0; i < strlen(&t); ++i )
  {
    fseek(stream, p[i], 0);
    fputc(*(&t + p[i]), stream);
    fseek(stream, 0LL, 0);
    fprintf(stream, "%s\n", u);
  }            // p[]中为0x01-0x47，即将刚刚得到的flag写入文件
  fclose(stream);
  remove(filename);
  return 0;
}

大致是运行程序，会在当前目录下创建文件并写入内容，最后将文件删除的过程，所以写脚本实现flag输出：

#include <iostream>
#include <string>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
?
int main(int argc, char** argv) {
    string t="SharifCTF{";
    string s="c61b68366edeb7bdce3c6820314b7498";
    int v5=0,v3,i;
    for(v5=0;v5<s.length();v5++)
    {
        if(v5&1)
        {
            v3=1;
        }
        else 
        {
            v3=-1;
        }
        t+=(s[v5]+v3);
    }
    t+="}"; 
    cout<<t;
    return 0;
}
python-trade

得到pyc文件，利用在线网站python反汇编：

import base64
?
def encode(message):
    s = ‘‘
    for i in message:
        x = ord(i) ^ 32
        x = x + 16
        s += chr(x)
?
    return base64.b64encode(s)
?
?
correct = ‘XlNkVmtUI1MgXWBZXCFeKY+AaXNt‘
flag = ‘‘
print ‘Input flag:‘
flag = raw_input()
if encode(flag) == correct:
    print ‘correct‘
else:
    print ‘wrong‘

因此，写脚本得到flag:

import base64
?
def decode(message):
    s = base64.b64decode(message)
    result=‘‘
    for i in s:
        i=ord(i)-16
        i=i^32
        result+=chr(i)
    return result
?
?
correct = ‘XlNkVmtUI1MgXWBZXCFeKY+AaXNt‘
flag = decode(correct)
print flag
maze

迷宫问题：

技术图片

IDA反汇编得到的伪码如下：

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  signed __int64 v3; // rbx
  signed int v4; // eax
  bool v5; // bp
  bool v6; // al
  const char *v7; // rdi
  __int64 v9; // [rsp+0h] [rbp-28h]
?
  v9 = 0LL;
  puts("Input flag:");
  scanf("%s", &s1, 0LL);
  if ( strlen(&s1) != 24 || strncmp(&s1, "nctf{", 5uLL) || *(&byte_6010BF + 24) != 125 )
  {
LABEL_22:
    puts("Wrong flag!");
    exit(-1);
  }
  v3 = 5LL;
  if ( strlen(&s1) - 1 > 5 )
  {
    while ( 1 )
    {
      v4 = *(&s1 + v3);
      v5 = 0;
      if ( v4 > ‘N‘ )
      {
        v4 = (unsigned __int8)v4;
        if ( (unsigned __int8)v4 == ‘O‘ )       // 向左走
        {
          v6 = sub_400650((_DWORD *)&v9 + 1);
          goto LABEL_14;
        }
        if ( v4 == ‘o‘ )                        // 向右走
        {
          v6 = sub_400660((int *)&v9 + 1);
          goto LABEL_14;
        }
      }
      else
      {
        v4 = (unsigned __int8)v4;
        if ( (unsigned __int8)v4 == ‘.‘ )       // 向上走
        {
          v6 = sub_400670(&v9);
          goto LABEL_14;
        }
        if ( v4 == ‘0‘ )                        // 向下走
        {
          v6 = sub_400680((int *)&v9);
LABEL_14:
          v5 = v6;
          goto LABEL_15;
        }
      }
LABEL_15:
      if ( !(unsigned __int8)sub_400690((__int64)asc_601060, SHIDWORD(v9), v9) )
        goto LABEL_22;
      if ( ++v3 >= strlen(&s1) - 1 )
      {
        if ( v5 )
          break;
LABEL_20:
        v7 = "Wrong flag!";
        goto LABEL_21;
      }
    }
  }
  if ( asc_601060[8 * (signed int)v9 + SHIDWORD(v9)] != 35 )
    goto LABEL_20;
  v7 = "Congratulations!";
LABEL_21:
  puts(v7);
  return 0LL;
}

其中的LABEL只是吓人的，其实代码本身逻辑还是很清楚的，其中限制我一开始没看懂的关键有几点：

(1)

v6 = sub_400650((_DWORD *)&v9 + 1);

typedef unsigned long DWORD;

DWORD是指两个word、四个字节、32bit。因此，这里的函数参数是变量v9的后一个32bit存储单元的指针。

(2)

(unsigned __int8)sub_400690((__int64)asc_601060, SHIDWORD(v9), v9)

其中，

#define SHIDWORD(x)  (*((int32*)&(x)+1))

也就是指：变量v9的下一个指向32bit内存单元的指针所指的内容，也就是上面那个函数的参数

(3)

__int64 __fastcall sub_400690(__int64 a1, int a2, int a3)
{
  __int64 result; // rax
?
  result = *(unsigned __int8 *)(a1 + a2 + 8LL * a3);
  LOBYTE(result) = (_DWORD)result == 32 || (_DWORD)result == 35;
  return result;
}

最关键的是result那一行，分析后可以转变成：a2为列数、a3为行数，也就是第二个参数是列数，于是可以倒推出上面四个函数中符号代表的方向。

=>于是，条件是：

flag为24位字符串，格式为nctf{xxxxxxx}

‘O‘，‘o‘，‘.‘，‘0‘分别代表向左、向右、向上、向下

迷宫为：

00******
*000*00*
***0*0**
**00*0**
*00*#00*
**0***0*
**00000*
********

因此，手动得到flag:nctf{o0oo00O000oooo..OO}

adworld-re新手练习区

标签：encode   缓冲   函数实现   变量   bit   hid   create   import   源码   

原文地址：https://www.cnblogs.com/Theffth-blog/p/12231751.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！