目录
1.easyre
将exe文件放入ida，在主函数main中找到flag，此题结束
2.reverse1
打开主函数main，发现有一个跳转函数，双击打开
这句命令是将str1和str2的内容比较，当两者相同时候输出 “this is the right flag ”
双击str2打开，可以看见str2的内容
提交flag后发现flag错误，重新审计代码
发现上面藏有这样一条语句，由ascii码得知111为‘o’，48为‘0’
于是正确flag为
flag{hell0_w0rld}
此题结束
3.reverse2
这道题与reverse1类似，还是先查看主函数
在下面发现条件与reverse1一致，即都是当输入的值与flag相同时输出‘this is the right flag’
使用shift+F12查找字符串，发现一个疑似flag的字符串
同样的，我们直接查看flag也能得到这串字符
需要注意的是，上面的代码也有字符处理
这里会将‘i’和‘r’替换为‘1’，所以整理后的flag为
flag{hack1ng_fo1_fun}
此题结束
4.内涵的软件
打开main函数，发现有一个mian0，进去之后就可以找到flag
包上flag，此题结束
（我还以为是base加密过的。。）
5.新年快乐
首先打开exeinfo打开exe文件，查看详细信息，发现文件带壳
（什么是壳）
具体壳是什么可以看这个大佬的文章
然后，我们需要使用工具upx来进行脱壳
脱壳完成后，用ida打开文件，查找flag字符串
转到 _main函数，审计代码后发现，当输入内容与str2相同时，输出"this is true flag!"
于是我们得到flag
flag{HappyNewYear!}
此题结束
6.xor
用exeinfo检查发现无壳
使用ida打开，查找字符串并审计代码
这里看到输入的值进行异或计算后再与变量global进行了比较，于是我们反推global的值就能得到flag
（异或计算）
因为我们可以知道flag的开头一定是‘f’，于是我们将其与已经被异或计算后的第2位进行异或计算就能得到原来的值
y[异或计算后的第二位] = x[原有的第一位] ^ z[原有的第二位]
所以：
z[原有的第二位] = x[原有的第一位] ^ y[异或计算后的第二位]
以此类推便能还原原字符串
这里字符后面的h是16进制数的标志，于是我们对其进行整理，得到global的值
global['f','0xA','k',0xC,'w','&','O','.',@',0x11,'x',0xD,'Z',';','U',0x11,'p',0x19,'F',0x1F,'v','"','M','#','D',0xE,'g',6,'h',0xF,'G','2','O',0]
我们写一个脚本对global进行反异或处理
key = [ 'f',0xA,'k',0xC,'w','&','O','.','@',0x11,'x',0xD,'Z',';','U',0x11,'p',0x19,'F',0x1F,'v','"','M','#','D',0xE,'g',6,'h',0xF,'G','2','O' ]
flag = "f"
x = 0
for i in range(0,len(key)-1):
if isinstance(key[i],str):
if isinstance(key[i+1],str): x = ord(key[i]) ^ ord(key[i+1]) # key[i]，key[i+1]同时为字符串
else: x = ord(key[i]) ^ key[i+1] # key[i]为字符串，key[i+1]为整数
else:
if isinstance(key[i+1],str): x = key[i] ^ ord(key[i+1]) # key[i]为整数，key[i+1]为字符串
else: x = key[i] ^ key[i+1] # key[i]，key[i+1]同时为整数
flag = flag + chr(x)
print(flag)
得到结果
此题结束
7.helloword
这是一个安卓的反编译题目，我们需要使用到工具apkide
使用apkide打开文件后，找到主函数
即可得到flag
此题结束
8.reverse3
使用exeinfo查看，32位无壳
使用32位ida打开，shift+F12查看字符串，查找flag字符
进入主函数，审计代码，可以得到对输入的字符串进行sub_4110BE处理后进行了移位处理，与str2进行比较
打开str2得到加密后的flag
打开sub函数查看加密过程
int v4; // [esp+D4h] [ebp-38h]
int v5; // [esp+D4h] [ebp-38h]
int v6; // [esp+D4h] [ebp-38h]
int v7; // [esp+D4h] [ebp-38h]
int i; // [esp+E0h] [ebp-2Ch]
unsigned int v9; // [esp+ECh] [ebp-20h]
int v10; // [esp+ECh] [ebp-20h]
int v11; // [esp+ECh] [ebp-20h]
void *v12; // [esp+F8h] [ebp-14h]
char *v13; // [esp+104h] [ebp-8h]
if ( !a1 || !a2 )
return 0;
v9 = a2 / 3;
if ( (int)(a2 / 3) % 3 )
++v9;
v10 = 4 * v9;
*a3 = v10;
v12 = malloc(v10 + 1);
if ( !v12 )
return 0;
j_memset(v12, 0, v10 + 1);
v13 = a1;
v11 = a2;
v4 = 0;
while ( v11 > 0 )
{
byte_41A144[2] = 0;
byte_41A144[1] = 0;
byte_41A144[0] = 0;
for ( i = 0; i < 3 && v11 >= 1; ++i )
{
byte_41A144[i] = *v13;
--v11;
++v13;
}
if ( !i )
break;
switch ( i )
{
case 1:
*((_BYTE *)v12 + v4) = aAbcdefghijklmn[(int)(unsigned __int8)byte_41A144[0] >> 2];
v5 = v4 + 1;
*((_BYTE *)v12 + v5) = aAbcdefghijklmn[((byte_41A144[1] & 0xF0) >> 4) | (16 * (byte_41A144[0] & 3))];
*((_BYTE *)v12 + ++v5) = aAbcdefghijklmn[64];
*((_BYTE *)v12 + ++v5) = aAbcdefghijklmn[64];
v4 = v5 + 1;
break;
case 2:
*((_BYTE *)v12 + v4) = aAbcdefghijklmn[(int)(unsigned __int8)byte_41A144[0] >> 2];
v6 = v4 + 1;
*((_BYTE *)v12 + v6) = aAbcdefghijklmn[((byte_41A144[1] & 0xF0) >> 4) | (16 * (byte_41A144[0] & 3))];
*((_BYTE *)v12 + ++v6) = aAbcdefghijklmn[((byte_41A144[2] & 0xC0) >> 6) | (4 * (byte_41A144[1] & 0xF))];
*((_BYTE *)v12 + ++v6) = aAbcdefghijklmn[64];
v4 = v6 + 1;
break;
case 3:
*((_BYTE *)v12 + v4) = aAbcdefghijklmn[(int)(unsigned __int8)byte_41A144[0] >> 2];
v7 = v4 + 1;
*((_BYTE *)v12 + v7) = aAbcdefghijklmn[((byte_41A144[1] & 0xF0) >> 4) | (16 * (byte_41A144[0] & 3))];
*((_BYTE *)v12 + ++v7) = aAbcdefghijklmn[((byte_41A144[2] & 0xC0) >> 6) | (4 * (byte_41A144[1] & 0xF))];
*((_BYTE *)v12 + ++v7) = aAbcdefghijklmn[byte_41A144[2] & 0x3F];
v4 = v7 + 1;
break;
}
}
*((_BYTE *)v12 + v4) = 0;
return v12;分析后发现这是一个base加密
写一个脚本对其进行解密
import base64
key='e3nifIH9b_C@n@dH'
key=list(key)
for i in range(len(key)):
key[i]=chr(ord(key[i])-i)
flag=''.join(key)
print(base64.b64decode(flag))最后得到flag
此题结束
9.不一样的flag
exeinfo查看，32位无壳
32位ida打开，shift+F12查看字符串
有一个与flag相关，打开字符串位置并反编译
_BYTE v3[29]; // [esp+17h] [ebp-35h] BYREF
int v4; // [esp+34h] [ebp-18h]
int v5; // [esp+38h] [ebp-14h] BYREF
int i; // [esp+3Ch] [ebp-10h]
_BYTE v7[12]; // [esp+40h] [ebp-Ch] BYREF
__main();
v3[26] = 0;
*(_WORD *)&v3[27] = 0;
v4 = 0;
strcpy(v3, "*11110100001010000101111#");
while ( 1 )
{
puts("you can choose one action to execute");
puts("1 up");
puts("2 down");
puts("3 left");
printf("4 right\n:");
scanf("%d", &v5);
if ( v5 == 2 )
{
++*(_DWORD *)&v3[25];
}
else if ( v5 > 2 )
{
if ( v5 == 3 )
{
--v4;
}
else
{
if ( v5 != 4 )
LABEL_13:
exit(1);
++v4;
}
}
else
{
if ( v5 != 1 )
goto LABEL_13;
--*(_DWORD *)&v3[25];
}
for ( i = 0; i <= 1; ++i )
{
if ( *(_DWORD *)&v3[4 * i + 25] >= 5u )
exit(1);
}
if ( v7[5 * *(_DWORD *)&v3[25] - 41 + v4] == 49 )
exit(1);
if ( v7[5 * *(_DWORD *)&v3[25] - 41 + v4] == 35 )
{
puts("\nok, the order you enter is the flag!");
exit(0);
}
}发现有一串字符串‘*11110100001010000101111#’，还有下面的语句
当v7中的某个元素等于49时，程序停止；当这个元素等于35时，输出‘你输入的顺序就是flag’
结合ascii码，49为1，35为#，刚好与字符串相对应
再根据程序的输出内容，合理猜测这是一个迷宫
因为是25个字符，猜测是5x5迷宫，作出迷宫图
简单处理得到顺序，即得到flag
flag{222441144222}
此题结束
10.SimpleRev
用exeinfo查壳，使用64位ida打开文件，找到main函数
在主函数中有一个叫decry的函数，双击打开
unsigned __int64 Decry()
{
char v1; // [rsp+Fh] [rbp-51h]
int v2; // [rsp+10h] [rbp-50h]
int v3; // [rsp+14h] [rbp-4Ch]
int i; // [rsp+18h] [rbp-48h]
int v5; // [rsp+1Ch] [rbp-44h]
char src[8]; // [rsp+20h] [rbp-40h] BYREF
__int64 v7; // [rsp+28h] [rbp-38h]
int v8; // [rsp+30h] [rbp-30h]
__int64 v9[2]; // [rsp+40h] [rbp-20h] BYREF
int v10; // [rsp+50h] [rbp-10h]
unsigned __int64 v11; // [rsp+58h] [rbp-8h]
v11 = __readfsqword(0x28u);
*(_QWORD *)src = 0x534C43444ELL;
v7 = 0LL;
v8 = 0;
v9[0] = 0x776F646168LL;
v9[1] = 0LL;
v10 = 0;
text = (char *)join(key3, v9);
strcpy(key, key1);
strcat(key, src);
v2 = 0;
v3 = 0;
getchar();
v5 = strlen(key);
for ( i = 0; i < v5; ++i )
{
if ( key[v3 % v5] > 64 && key[v3 % v5] <= 90 )
key[i] = key[v3 % v5] + 32;
++v3;
}
printf("Please input your flag:");
while ( 1 )
{
v1 = getchar();
if ( v1 == 10 )
break;
if ( v1 == 32 )
{
++v2;
}
else
{
if ( v1 <= 96 || v1 > 122 )
{
if ( v1 > 64 && v1 <= 90 )
{
str2[v2] = (v1 - 39 - key[v3 % v5] + 97) % 26 + 97;
++v3;
}
}
else
{
str2[v2] = (v1 - 39 - key[v3 % v5] + 97) % 26 + 97;
++v3;
}
if ( !(v3 % v5) )
putchar(32);
++v2;
}
}
if ( !strcmp(text, str2) )
puts("Congratulation!\n");
else
puts("Try again!\n");
return __readfsqword(0x28u) ^ v11;
}对代码进行分析
注意有一个大小端储存的问题，要把src和v9两个变量进行倒转处理
因为得知密文和加密方式，所以我们写一个脚本对密文进行还原
key='adsfkndcls'
text='killshadow'
d = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
for i in range(0,10):
for j in d:
if (ord(j)-39-ord(key[i % 10])+97)%26+97 == ord(text[i]):
print(j,end='')最后得到flag，此题结束
1689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
