文章目录
攻防世界re 新手区wp
这个几天没有之前忙了，现在有时间整理一下之前做的攻防世界新手区的题目，记录一下学习过程，也复习一下
https://adworld.xctf.org.cn/
re1
方法一：
下载附件，die查壳，无壳，
载入ida查看
简单的明文比较，将比较过后的结果赋给v5，v5就是flag
查看上面两个字符串
一串数字按r转换为字符串如上，然后写出脚本即可得到flag
DUTCTF{We1c0met0DUTCTF}
str1='0tem0c1eW{FTCTUD'[::-1]
str2='}FTCTUD'[::-1]
print(str1+str2)
这里要注意数据大小端的储存方式，这里形成的字符串时逆序。
方法二：载入od中文搜索查看字符串，发现flag就在字符串里面，简单粗暴
game
下载附件
die查壳，无壳
方法一：
载入od动态调试，
注意记住上面的072E940是判断正确函数的入口点，然后现在的思路就很清晰了，就是找到判断我们输入是否正确的函数，将其跳转到判断正确的函数入口点来，也就是072E940地址。
接下来就是找输入的地方了，慢慢调试，找到%d
设置个断点，单步运行，找到跳转的指令
将其改为jle long 0072e940，然后运行得到flag
方法二：
载入ida分析，shift+f12查看字符串，这样方便快速定位关键函数
这个函数就是关键函数，f5查看伪代码
函数有三部分构成
第一部分输出游戏的规则信息，第二部分就是游戏的运行部分，第三部分就是判断我们输入的n是否正确，
如果正确，然后跳到下面的sub_458054函数，猜测打印出flag，进入该函数看看
sub_45A7BE("done!!! the flag is ");
v59 = 18;
v60 = 64;
v61 = 98;
v62 = 5;
v63 = 2;
v64 = 4;
v65 = 6;
v66 = 3;
v67 = 6;
v68 = 48;
v69 = 49;
v70 = 65;
v71 = 32;
v72 = 12;
v73 = 48;
v74 = 65;
v75 = 31;
v76 = 78;
v77 = 62;
v78 = 32;
v79 = 49;
v80 = 32;
v81 = 1;
v82 = 57;
v83 = 96;
v84 = 3;
v85 = 21;
v86 = 9;
v87 = 4;
v88 = 62;
v89 = 3;
v90 = 5;
v91 = 4;
v92 = 1;
v93 = 2;
v94 = 3;
v95 = 44;
v96 = 65;
v97 = 78;
v98 = 32;
v99 = 16;
v100 = 97;
v101 = 54;
v102 = 16;
v103 = 44;
v104 = 52;
v105 = 32;
v106 = 64;
v107 = 89;
v108 = 45;
v109 = 32;
v110 = 65;
v111 = 15;
v112 = 34;
v113 = 18;
v114 = 16;
v115 = 0;
v2 = 123;
v3 = 32;
v4 = 18;
v5 = 98;
v6 = 119;
v7 = 108;
v8 = 65;
v9 = 41;
v10 = 124;
v11 = 80;
v12 = 125;
v13 = 38;
v14 = 124;
v15 = 111;
v16 = 74;
v17 = 49;
v18 = 83;
v19 = 108;
v20 = 94;
v21 = 108;
v22 = 84;
v23 = 6;
v24 = 96;
v25 = 83;
v26 = 44;
v27 = 121;
v28 = 104;
v29 = 110;
v30 = 32;
v31 = 95;
v32 = 117;
v33 = 101;
v34 = 99;
v35 = 123;
v36 = 127;
v37 = 119;
v38 = 96;
v39 = 48;
v40 = 107;
v41 = 71;
v42 = 92;
v43 = 29;
v44 = 81;
v45 = 107;
v46 = 90;
v47 = 85;
v48 = 64;
v49 = 12;
v50 = 43;
v51 = 76;
v52 = 86;
v53 = 13;
v54 = 114;
v55 = 1;
v56 = 117;
v57 = 126;
v58 = 0;
for ( i = 0; i < 56; ++i )
{
*(&v2 + i) ^= *(&v59 + i);
*(&v2 + i) ^= 0x13u;
}
return sub_45A7BE("%s\n");
}
果不其然，这就是打印flag的函数，py写出脚本，运行得到flag
zsctf{T9is_tOpic_1s_v5ry_int7resting_b6t_others_are_n0t}
a = [18, 64, 98, 5, 2, 4, 6, 3, 6, 48, 49, 65, 32, 12, 48, 65, 31, 78, 62, 32, 49, 32,
1, 57, 96, 3, 21, 9, 4, 62, 3, 5, 4, 1, 2, 3, 44, 65, 78, 32, 16, 97, 54, 16, 44,
52, 32, 64, 89, 45, 32, 65, 15, 34, 18, 16, 0]
b = [123, 32, 18, 98, 119, 108, 65, 41, 124, 80, 125, 38, 124, 111, 74, 49,
83, 108, 94, 108, 84, 6, 96, 83, 44, 121, 104, 110, 32, 95, 117, 101, 99,
123, 127, 119, 96, 48, 107, 71, 92, 29, 81, 107, 90, 85, 64, 12, 43, 76, 86,
13, 114, 1, 117, 126, 0]
str = ''
for i in range(0, 56):
b[0 + i] ^= a[0 + i]
b[0 + i] ^= 0x13
str = str + chr(b[i]);
print(str)
方法三，这是网上大佬的另外一种思路
if ( byte_532E28[0] == 1
&& byte_532E28[1] == 1
&& byte_532E28[2] == 1
&& byte_532E28[3] == 1
&& byte_532E28[4] == 1
&& byte_532E28[5] == 1
&& byte_532E28[6] == 1
&& byte_532E28[7] == 1 )
这里判断出我们需要将这八个数组的值都变为1，也就是8盏灯都闭合。
打开sub_4576D6函数
分析得到按键与电路闭合的关系：
按1--闭合1,2,8
按8--闭合1,7,8
按i(除1,8)--闭合i-1,i,i+1
附上大佬c+汇编爆破代码
#include <iostream>
#include <vector>
using namespace std;
#define for(a,b,c) for(int a = b; a < c; ++a)
#define N 8
vector<int> flag(8,-1);
void func(int *arr){
for(i,0,N){
int n = arr[i];
if(n == 0){
flag[0] *= -1;
flag[1] *= -1;
flag[7] *= -1;
}else{
if(n == 7){
flag[0] *= -1;
flag[6] *= -1;
flag[7] *= -1;
}else{
flag[n] *= -1;
flag[n-1] *= -1;
flag[n+1] *= -1;
}
}
}
}
bool Judge(){
for(i,0,8)
if(flag[i] == -1)
return false;
return true;
}
int main(void)
{
int array[N] = {0};
for(i,0,8)
for(j,0,8)
for(k,0,8)
for(m,0,8)
for(n,0,8)
for(p,0,8)
for(q,0,8)
for(t,0,8){
array[0] = i;
array[1] = j;
array[2] = k;
array[3] = m;
array[4] = n;
array[5] = p;
array[6] = q;
array[7] = t;
func(array);
if(Judge()){
cout << "success:" << i+1 << j+1 << k+1 << m+1 << n+1 << p+1 << q+1 << t+1 << endl;
system("PAUSE");
}else{
for(x,0,8)
fill(flag.begin(), flag.end(), -1);
}
}
cout << "over!";
system("PAUSE");
return 0;
}
hello，ctf
die查壳无壳，载入ida查看
函数很简单，就是将我们输入的值进行16进制转换过后与v13进行比较，也就是说将v13的十六进制数转换位字符串就是flag
a = [0x43,0x72,0x61,0x63,0x6b,0x4d,0x65,0x4a,0x75,0x73,0x74,0x46,0x6f,0x72,0x46,0x75,0x6e]
flag = ""
for i in a:
flag += chr(i)
print(flag)
后记：这道题学习了sprintf这个函数，这个函数处理字符串可谓强大。
头文件：stdio.h
声明：int sprintf(char *string, char *format [,argument,…]);
功能：把格式化的数据写入某个字符串缓冲区。
例子1：
int main( void )
{
char buffer[200], s[] = "computer", c = 'l';
int i = 35, j;
float fp = 1.7320534f;
// 格式化并打印各种数据到buffer
j = sprintf( buffer, " String: %s\n", s ); // C4996
j += sprintf( buffer + j, " Character: %c\n", c ); // C4996
j += sprintf( buffer + j, " Integer: %d\n", i ); // C4996
j += sprintf( buffer + j, " Real: %f\n", fp );// C4996
printf( "Output:\n%s\ncharacter count = %d\n", buffer, j );
return 0;
}
>>>输出结果
>Output:
String: computer
Character: l
Integer: 35
Real: 1.732053
character count = 79
格式化数字字符串sprintf 最常见的应用之一莫过于把整数打印到字符串中
//把整数123 打印成一个字符串保存在s 中。
sprintf(s, "%d", 123); //产生"123"
sprintf(s, "%4d%4d", 123, 4567); //产生：" 1234567"
sprintf(s, "%-4d%4d", 123, 4567); //产生："123 4567"
也可以按照16 进制打印：
sprintf(s, "%8x", 4567); //小写16 进制，宽度占8 个位置，右对齐
sprintf(s, "%-8X", 4568); //大写16 进制，宽度占8 个位置，左对齐
打印16 进制内容时，如果想要一种左边补0 的等宽格式，在表示宽度的数字前面加个0 就可以了。
sprintf(s, "%08X", 4567); //产生："000011D7"
控制浮点数打印格式，默认保留小数点后6 位数字
sprintf(s, "%f", 3.1415926); //产生"3.141593"
但有时我们希望自己控制打印的宽度和小数位数，这时就应该使用：”%m.nf”格式，其中m 表示打印的宽度，n 表示小数点后的位数。比如：
sprintf(s, "%10.3f", 3.1415626); //产生：" 3.142"
sprintf(s, "%-10.3f", 3.1415626); //产生："3.142 "
sprintf(s, "%.3f", 3.1415626); //不指定总宽度，产生："3.142"
连接字符串
char buf[60]={0};
char*who="I";
char*whom="CSDN";
sprintf(buf,"%slove%s.",who,whom);
printf("%s",buf);
//输出结果："IloveCSDN."
open-source
下载附件，附件是一份c语言源码，这就很简单了
1 #include <stdio.h>
2 #include <string.h>
3
4 int main(int argc, char *argv[]) {
5 if (argc != 4) {
6 printf("what?\n");
7 exit(1);
8 }
9
10 unsigned int first = atoi(argv[1]);
11 if (first != 0xcafe) {
12 printf("you are wrong, sorry.\n");
13 exit(2);
14 }
15
16 unsigned int second = atoi(argv[2]);
17 if (second % 5 == 3 || second % 17 != 8) {
18 printf("ha, you won't get it!\n");
19 exit(3);
20 }
21
22 if (strcmp("h4cky0u", argv[3])) {
23 printf("so close, dude!\n");
24 exit(4);
25 }
26
27 printf("Brr wrrr grr\n");
28
29 unsigned int hash = first * 31337 + (second % 17) * 11 + strlen(argv[3]) - 1615810207;
30
31 printf("Get your key: ");
32 printf("%x\n", hash);
33
34 return 0;
35 }
第29行计算flag，第32行代码输出十六进制形式
三部分组成，三个数组运算
第一部分：
if (first != 0xcafe) {
printf("you are wrong, sorry.\n");
exit(2);
}
first=0xcafe
第二部分：
if (second % 5 == 3 || second % 17 != 8) {
printf("ha, you won't get it!\n");
exit(3);
}
second=25
第三部分：
if (strcmp("h4cky0u", argv[3])) {
printf("so close, dude!\n");
exit(4);
}
相等strcmp返回0，退出if条件，那argv[3]=“h4cky0u”
综上，用C语言写出脚本
#include <stdio.h>
#include <string.h>
int main(int argc, char* argv[])
{
int first = 0xcafe;
int second = 25;
argv[3] = "h4cky0u";
unsigned int hash = first * 31337 + (second % 17) * 11 + strlen(argv[3]) - 1615810207;
printf("%x\n", hash);
return 0;
}
simple-unpack
下载附件elf文件，die查壳，64位，upx的壳，linux下upx -d 脱壳
如何脱壳：网上去下载upx-3.95-amd64_linux.tar.xz，解压缩到linux一个文件夹，然后将要脱壳的文件也扔进这个文件夹，然后就再该文件夹下打开终端，再./upx -d “要脱壳的文件名”（注意没有“”哈）！
载入ida64，找到main函数，就出现的这个flag就是真的flag
logmein
die查壳，无壳，载入ida
这里要注意大小端序的问题，接下来写出py脚本
v7 = 'ebmarah'[::-1]
v8 = ":\"AL_RT^L*.?+6/46"
for i in range(len(v8)):
print(chr(ord(v7[i % 7]) ^ ord(v8[i])),end='')
遗留问题：什么时候该大小端序转换？
insanity
查壳无壳32位，载入ida，shift+f12查找字符串，直接出来flag，当真如题目所说，来个简单的签到题。。。
no-strings-attached
查壳，无壳，32位
这是关键函数
处理部分在这个加密函数decrypt里面
idapy脚本将传入decrypt() 的两个参数打印出来，注意舍去最后的0
addr1=0x8048a90
addr2=0x8048aa8
a2=[]
dest=[]
for i in range(6):
a2.append(Dword(addr1+4*i))
for j in range(38):
dest.append(Dword(addr2+4*j))
print(a2)
print(dest)
然后py写出脚本
a2 = [5121, 5122, 5123, 5124, 5125]
dest = [5178, 5174, 5175, 5179, 5248, 5242, 5233, 5240, 5219, 5222, 5235, 5223, 5218, 5221, 5235, 5216, 5227, 5233, 5240, 5226, 5235, 5232, 5220, 5240, 5230, 5232, 5232, 5220, 5232, 5220, 5230, 5243, 5238, 5240, 5226, 5235, 5243, 5248]
i = j = 0
while i < 38:
j = 0
while j <5 and i < 38:
dest[i] -= a2[j]
i += 1
j += 1
flag = ''
for i in range(38):
flag+= (chr(dest[i]))
print(flag)
CSAW2013Reversing2
查壳无壳，载入ida
发现就两个函数，一个调用窗口的messageboxa函数一个判断是否被调试的函数，推断不乱码的函数是sub_401000函数，这里面有真正的flag
点进去看，一个加密函数，但是上面的流程图显示，这个函数应该没有被执行，
现在载入od看看，中文搜索字符串flag，找到关键地点，
果不其然，sub_401000函数被跳过去了，弹窗，然后显示乱码，我们需要执行sub_401000函数，所以将其跳转到该函数前一步，005E109B处，然后，还需要一个跳转调出messagebox，所以还要将下面的跳转跳转到第二个flag位置，因为flag是在lpMem + 1位置处弹出来的。
此时eax当中和栈中也如期出现了flag
gitit
查壳无壳，载入ida分析
上面部分是处理字符串得到flag，下面部分是处理文件，重点是上面部分，s和t是关键
查看s和t的值，py逆向写出脚本
s = 'c61b68366edeb7bdce3c6820314b7498'
flag=''
for i in range(len(s)):
a = -1
if i & 1:
a = 1
flag += (chr(ord(s[i]) + a))
print(flag)
然后将得到在字符串用SharifCTF{}包裹得到flag
python-trade
下载附件，pyc文件，在线反编译
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'
逆向写出脚本即可
import base64
correct = 'XlNkVmtUI1MgXWBZXCFeKY+AaXNt'
a = base64.b64decode(correct)
flag = ''
for i in range(len(a)):
x = a[i]
x -= 16
y = x ^ 32
flag += chr(y)
print(flag)
nctf{d3c0mpil1n9_PyC}
maze
这个题，提示是个迷宫题，查壳无壳，ida分析
结构很复杂，f5代码很多，查找字符串
******* * **** * **** * *** # *** *** *** *********
上面这个就是迷宫了，分析伪代码得知这是一个88的迷宫
我们将迷宫打印出来，为了方便，我们将空格代替为o
上下左右分别是.0Oo，走迷宫，用nctf{}包裹得到flag为nctf{o0oo00O000oooo…OO}
扫一扫
1746
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
