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}
来源：https://www.cnblogs.com/Theffth-blog/p/12231751.html