i春秋作家：W1ngs
原文来自：pwnable.kr详细通关秘籍（二）
0x00 input
首先看一下代码：
可以看到程序总共有五步，全部都满足了才可以得到flag，那我们就一步一步来看
这道题考到了很多linux下的基本操作，参数输入、管道符、进程间通信等知识，推荐大家可以先看看《深入理解计算机系统这本书》，补补基础
1、Step1（argv）
if(argc != 100) return 0;也就是说输入为一百个参数，其中索引为大写A(65)的值为\x00，索引为B的值为\x20\x0a\x0d，(记得这里是索引'A'的ascii值)
手动输入显然是不太现实的，这里我们用pwntools的process方法来实现：
但是在目标的机器上没有pwntools环境，在加上后面的几步的解题方法（进程间通信、socket编程），这边还是选择c来写exp
这里就使用execve函数来传入参数和环境变量，中间的参数是指向命令行参数的指针数组，后面的一个是指向环境变量的指针数组。作用是创建一个新的进程
int execve(const char * filename,char * const argv[ ],char * const envp[ ]);其中的一种写法是：
char *argv[101] = {"/home/input/input", [1 ... 99] = "A", NULL};
argv['A'] = "\x00";
argv['B'] = "\x20\x0a\x0d";
argv['C'] = "55555";
也就是定义一个参数数组argv，长度为101个数，最后一个以空字节结尾。argv['C'] = "55555"在后面step5时会用到。
在本地尝试一下执行该目录下的input文件，看看参数是否正确传入
ok，参数已经正确传入，通过了第一步
2、Step2（stdio）
step2代码的意思是向buf区输入两次的四字节，第一次从stdin输入流的得到字符，第二个从stderr输出流中得到字符（可以看我前面说过的文件描述符的用法），比较两次的字符串是否与'0xff000a00'和'0xff020a00'相同，相同则通过判断
memcmp函数：
https://baike.baidu.com/item/memcmp/5494788?fr=aladdin
这里的第一个read的输入流我们是可以控制的（fd=0），但是输出流是无法控制的，这里只能用管道来解决
这一步用到了管道（pipe）的基本知识：
管道，可以抽象的理解为一根管子，一端输入进去，另一端输出出来。一端write进去，另一端read出来。而且还可以把管道的read重定向到我们的某一个流中。两个进程之间就可以通过这种方式进行通信了。就像这一步中的输入流和错误输出流。那么这个题目的思路是通过子进程将内容写入管道，父进程把管道的read重定向到输入输出流中。其实关键在与如何向错误输出流中准确写入东西。用pipe管道可能是唯一的好办法。
具体可以看一下本地的测试代码：
在fork函数中fork出一个子进程，也就是执行if里的语句，把"hello"写到管道的一端，之后关闭管道并退出进程
然后父进程把刚刚子进程写入的数据进行读出到buf里，打印出的数据就为buf的内容"hello"，运行结果：
画个图会更直观一些，原理的实现和现实中的管道的原理很像：一端流入一端流出
（这里还应该表示出子进程是父进程fork出的）
测试成功以后我们的思路就是先建立起一个管道，建立之后使用dup方法对文件描述符进行重定向，重定向到stdin和stderr中。dup函数的使用方法：
https://blog.csdn.net/u010006102/article/details/39667875
代码如下：
int pipe2stdin[2] = {-1,-1};
int pipe2stderr[2] = {-1,-1};
pid_t childpid;
if ( pipe(pipe2stdin) < 0 || pipe(pipe2stderr) < 0){
perror("Cannot create the pipe");
exit(1);
}
if ( ( childpid = fork() ) < 0 ){
perror("Cannot fork");
exit(1);
}
if ( childpid == 0 ){
/* Child process */
close(pipe2stdin[0]); close(pipe2stderr[0]); // Close pipes for reading
write(pipe2stdin[1],"\x00\x0a\x00\xff",4); //写入管道的一端
write(pipe2stderr[1],"\x00\x0a\x02\xff",4);
}
else {
/* Parent process */
close(pipe2stdin[1]); close(pipe2stderr[1]); // Close pipes for writing
dup2(pipe2stdin[0],0); dup2(pipe2stderr[0],2); // 重定向到 stdin 和 stderr
close(pipe2stdin[0]); close(pipe2stderr[1]); // Close write end (the fd has been copied before)
execve("input",argv,NULL); // 执行新的进程
}把第一步和第二步的代码放在一起执行，成功绕过第一二步
3、Step3（env）
这步关键就一行代码：
if(strcmp("\xca\xfe\xba\xbe", getenv("\xde\xad\xbe\xef"))) return 0;getenv函数的解释：
https://baike.baidu.com/item/getenv/935515?fr=aladdin
环境变量是以键值对的形式存放的（name=value），getenv函数的参数为环境变量的键名，返回值是环境变量的值
例如我们在shell下面输入env，就会列出当前的所有环境变量：
再回过头来看看题目，代码中是getenv("\xde\xad\xbe\xef")，但是我们的环境变量中一般是不会有键名为\xde\xad\xbe\xef的键值对，所以这里就需要我们手动向里面写入环境变量
这里就利用到了execve函数的第三个参数，向里面传入我们自己建立的环境变量
char *env[2] = {"\xde\xad\xbe\xef=\xca\xfe\xba\xbe", NULL};
execve("input",argv,env); 这里要注意的一点就是env数组的指针都是以null结尾的，所以我们必须要这么写char *env[2] = {"\xde\xad\xbe\xef=\xca\xfe\xba\xbe", NULL};
把第一二三步的代码放在一起执行，成功通过前三步！
4、Step4（file）
这步考到了文件流的基本操作：打开一个名为\x0a的文件，如果读入的前四个字节为空字节（\x00\x00\x00\x00），就通过判断
这里的一个比较疑惑的地方是\x0a这个文件，目录下并不存在但是还是可以正常打开，而且是返回正常：
既然这样的话我们默认\x0a的这个文件存在，就向\x0a文件里写入\x00\x00\x00\x00，代码如下：
FILE* fp = fopen("\x0a","w");
fwrite("\x00\x00\x00\x00",4,1,fp);
fclose(fp);这里要把这几句代码写在execve函数的前面
运行发现成功通过前四步！
5、Step5（network）
这里考的是网络编程的知识，来看一下代码：
int sd, cd;
struct sockaddr_in saddr, caddr;
sd = socket(AF_INET, SOCK_STREAM, 0);
if(sd == -1){
printf("socket error, tell admin\n");
return 0;
}
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = INADDR_ANY;
saddr.sin_port = htons( atoi(argv['C']) );
if(bind(sd, (struct sockaddr*)&saddr, sizeof(saddr)) < 0){
printf("bind error, use another port\n");
return 1;
}
listen(sd, 1);
int c = sizeof(struct sockaddr_in);
cd = accept(sd, (struct sockaddr *)&caddr, (socklen_t*)&c);
if(cd < 0){
printf("accept error, tell admin\n");
return 0;
}
if( recv(cd, buf, 4, 0) != 4 ) return 0;
if(memcmp(buf, "\xde\xad\xbe\xef", 4)) return 0;
printf("Stage 5 clear!\n");
代码的大概意思就是以该文件（input）作为服务器，监听argv['C']端口，我们上面传入的argv['C']为55555，那么就是相当于监听0.0.0.0:55555
recv函数接收客户端的输入，若输入的字符串为\xde\xad\xbe\xef，就通过判断了。
那么这里我们就只需要建立一个socket客户端，用write函数向socket对象写入\xde\xad\xbe\xef就行了。
如果对套接字编程不太熟悉的可以看这里：
https://blog.csdn.net/lovekun1989/article/details/41042273
编写的代码如下：
int sockfd;
struct sockaddr_in server;
sockfd = socket(AF_INET,SOCK_STREAM,0);
if ( sockfd < 0){
perror("Cannot create the socket");
exit(1);
}
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr("127.0.0.1");
server.sin_port = htons(55555);
if ( connect(sockfd, (struct sockaddr*) &server, sizeof(server)) < 0 ){
perror("Problem connecting");
exit(1);
}
printf("Connected\n");
char buf[4] = "\xde\xad\xbe\xef";
write(sockfd,buf,4);
close(sockfd);也就是以这个可执行文件作为客户端，主动连接127.0.0.1:55555，并发送字符串"\xde\xad\xbe\xef"
将前五步的代码放在一起执行，结果如下：
在本地测试都通过了，现在把代码放在服务器上运行，回到根目录下，ls -al看看：
只有tmp目录有可写的权限，那我们就进入tmp目录下
把文件用scp命令在本地写好的exp复制到tmp目录下：
scp -P 2222 inputpwn.c input@pwnable.kr:/tmp把代码放上去编译执行以后会发现一个问题，代码在最后读取flag时是读取当前目录下的flag文件
// here's your flag
system("/bin/cat flag"); 但是tmp目录下没有flag，也没有办法把flag移动到该目录下
这时候我们就要使用ln命令创建一条硬连接，ln的详细的使用看这里：
http://www.cnblogs.com/peida/archive/2012/12/11/2812294.html
ln /home/input2/flag flag也就是相当于在该目录下"模拟"出一个目录"/home/input2/flag"下的flag
但是这里有点问题，创建硬连接时，会提示无法创建，用-s参数时，也无法正常得到flag，但是大概思路是不会错的
另外两个详细的题解：
https://werewblog.wordpress.com/2016/01/11/pwnable-kr-input/
https://blog.csdn.net/bluestar628/article/details/69132263
0x01 leg
题目中给了一个c源程序，一个汇编程序，汇编程序是由c编译来的，所以直接看汇编程序就行了。
main函数：
key1函数：
key2函数：
key3函数：
程序是用arm汇编语言编写的，如果只了解过intel汇编看起来会比较吃力，但是基本语法了解起来还是不难的。
基本的语法的使用可以看这里：
https://blog.csdn.net/smalosnail/article/details/53065048
题目分析
main函数中：先调用了printf函数，接着调用scanf函数，仔细看scanf的参数为r3 = r11-#16，r1 = r3，这里的r1为函数的参数值，也就是r11-#16
key1函数中：
0x00008cd4 <+0>: push {r11} ; (str r11, [sp, #-4]!)
0x00008cd8 <+4>: add r11, sp, #0
-> 0x00008cdc <+8>: mov r3, pc
-> 0x00008ce0 <+12>: mov r0, r3
0x00008ce4 <+16>: sub sp, r11, #0
0x00008ce8 <+20>: pop {r11} ; (ldr r11, [sp], #4)
0x00008cec <+24>: bx lr
前面的push {r11}，add r11,sp,#0，就相当于intel汇编集里的push ebp，mov esp,ebp，sub esp,xx
关键是中间的几句mov r3,pc，mov r0,r3，这里吧pc（程序计数器也就是eip）的值赋值给r0。在arm中r0就是返回值，相当于eax
程序计数器pc指向下两条指令的地址，也就是当前指令的地址+0x8
那么这里的r0 = pc = 0x8cdc + 0x8 = 0x8ce4
key2函数中
0x00008cf0 <+0>: push {r11} ; (str r11, [sp, #-4]!)
0x00008cf4 <+4>: add r11, sp, #0
0x00008cf8 <+8>: push {r6} ; (str r6, [sp, #-4]!)
0x00008cfc <+12>: add r6, pc, #1
0x00008d00 <+16>: bx r6
-> 0x00008d04 <+20>: mov r3, pc
* 0x00008d06 <+22>: adds r3, #4
0x00008d08 <+24>: push {r3}
0x00008d0a <+26>: pop {pc}
0x00008d0c <+28>: pop {r6} ; (ldr r6, [sp], #4)
-> 0x00008d10 <+32>: mov r0, r3
0x00008d14 <+36>: sub sp, r11, #0
0x00008d18 <+40>: pop {r11} ; (ldr r11, [sp], #4)
0x00008d1c <+44>: bx lr直接追溯r0的值，0x00008d10 处r0 = r3 ，再看看r3的值，adds r
3,#4，这条语句是把 r3 + 4h 的值存入当前状态寄存器CPSR中，并不是将r3加4存入r3，所以r3在此处的值是不变的
0x00008d04处，r3 = pc，pc = 0x00008d04 + 0x8 ，前面的pc值没有改变，所以r0 = 0x00008d04 + 0x8
key3函数中
0x00008d20 <+0>: push {r11} ; (str r11, [sp, #-4]!)
0x00008d24 <+4>: add r11, sp, #0
-> 0x00008d28 <+8>: mov r3, lr
-> 0x00008d2c <+12>: mov r0, r3
0x00008d30 <+16>: sub sp, r11, #0
0x00008d34 <+20>: pop {r11} ; (ldr r11, [sp], #4)
0x00008d38 <+24>: bx lr关键就两句的代码，mov r3, lr，mov r0, r3，lr是连接寄存器 (Link Register) ，也也就调用这个函数的时候的返回地址，相当于intel里调用函数时的push eip
可以在main函数中看到，返回值的地址值为0x00008d80
那么这里的lr = 0x00008d80，所以r0 = 0x00008d80
这样在主函数中，将三个值相加，与scanf中接收的值进行比较，相等就调用system函数
我们将三个值进行相加，得到的结果进行输入
计算输入得到flag
0x02 mistake
连上ssh服务器后，查看代码
重点是两个函数，一个xor函数，一个main函数，题目的意思是open一个password文件(但是password文件的内容是未知的)，再接收一个输入，将这个输入在xor函数中逐个与1异或，最后与password文件读出来的字符串进行比较
题目分析：
题目提示了operator priority，也就是运算符优先级，那么看到第一处的运算符处
这一句：if(fd=open("/home/mistake/password",O_RDONLY,0400)< 0)
代码中<运算符的优先级是大于=的，所以先进行后面的运算，open("/home/mistake/password",O_RDONLY,0400)< 0
因为open函数正常执行时的返回值是大于0的，这里的文件是可以正常打开的，所以这条逻辑语句的值是0
然后再执行前面的=号的赋值语句，fd=0，也就是标准输入，关于文件描述符可以看我前面的文章pwnable1
也就是说我们在执行下面这条语句的时候可以将接收的字符输入到pw_buf里len=read(fd,pw_buf,PW_LEN) > 0
在scanf语句里可以输入pw_buf2的值scanf("%10s", pw_buf2);
所以这里的两个地方都可以控制，那么先输入10个0，在input password再输入1111111111，经过异或以后全为0，最后就会相等了。
解题步骤：
先第一个输入点输入十个0，在提示input password时，输入十个1，就会提示password OK
于是拿到flag
0x03 shellshock
首先查看一下代码：
代码的逻辑很简单，调用了两个setresuid函数，也就是为shellshock可执行文件设置组用户对flag文件的读权限。
函数的具体用法可以看看这里：
https://blog.csdn.net/scutth/article/details/6980758
我们ls -al看看：
发现shellshock程序的组用户被设置了s标志位，s标志位的解释可以看这里：
https://blog.csdn.net/findstr/article/details/7330592
普通用户对flag文件没有读取权限，但是shellshock这个可执行文件与root用户是在同一个组中，对group是具有特殊权限读(w)的，这就意味着egid是属于shellshock_pwn的，这个权限很高，对flag文件是可读的
-r-xr-sr-x表示SGID和同组用户权限中可执行位被设置
再回头来看看题目的名字：shellshock，其实这是一个bash的一个本地提权安全漏洞（破壳漏洞）
这里先给出payload:
env x = '(){:;}; echo vulnerable' bash -c "echo test" 该漏洞影响的bash使用的环境变量是通过函数名称来调用的，以“(){”开头通过环境变量来定义的。而在处理这样的“函数环境变量”的时候，并没有以函数结尾“}”为结束，而是一直执行其后的shell命令
我们一段段来看：env x= ''表示向环境变量中注入x = ....的变量，bash在处理这样以"(){"开头的环境变量的值时并没有以函数结尾"}"为结束，而是一直执行其后的shell命令，最后就会执行"echo vulnerable"这个语句
bash -c 'ls'表示调用linux下的默认shell（GNU Bourne-Again Shell）
参考这里的漏洞分析贴
这里将echo vulnerable' 换成想执行的命令 bash -c "cat ./flag"'
而./ bash -c "echo this is a test" 换成./shellshock
最后的payload：env var='() { :;}; cat flag' ./shellshock
0x04 coin1
首先看一下题：
题目的意思是猜假硬币，在一堆硬币中有一枚假硬币，假硬币的重量是9，而正常的是10。现在有N枚硬币，你可以询问C次。每次询问返回的是你询问的硬币的质量之和。询问C次之后，就要告诉它假的硬币的编号。
题目中还有一个要求是要求30秒内完成100个用例，显然这个问题要靠脚本来解决，但是在本地运行脚本的话，速度肯定是不够快的，所以题目中还给了提示：
if your network response time is too slow, try nc 0 9007 inside pwnable.kr server
所以我们可以在远程服务器上写脚本，即nc 0 9007，登录到上一道的服务器，进入tmp目录，到脚本写到该目录下
脚本的思路就是二分法的求解，类似数据结构中设置l、mid、r三个变量
详细脚本如下：
# coding: utf-8
from socket import*
import random
import time
HOST='0.0.0.0'
PORT=9007
#建立socket对象
client=socket(AF_INET,SOCK_STREAM)
#AF_INET表示将使用标准的ipv4地址或主机名
#SOCK_STREAM说明这是一个TCP客户端
client.connect((HOST,PORT))#连接
data = client.recv(1024)
time.sleep(4)
for i in range(100):
data = client.recv(1024)#接收数据
int_cnt=data.find('N=')+2 #int_cnt用于找到N,C
N=0
C=0
while True:
N+=int(data[int_cnt])
int_cnt+=1
if data[int_cnt]==' ':
break
N*=10
int_cnt=data.find('C=')+2
while True:
C+=int(data[int_cnt])
int_cnt+=1
if data[int_cnt]<'0' :
break
if data[int_cnt]>'9' :
break
C*=10
print 'get N=%d'%N,'get C=%d'%C#打印N,C
left=0
right=N-1
mid=(left+right)/2#二分
for i in xrange(C):#C次询问
str_ask=[str(n) for n in xrange(left,mid+1)]
str_ask=" ".join(str_ask)#构造要询问的硬币
client.send(str_ask+"\n")#发送数据
str_weight=client.recv(1024)#接收数据
str_weight.split("\n")
int_weight=int(str_weight)
print "int_weight = ",int_weight,"l=%d mid=%d r=%d"%(left,mid,right)
if int_weight!=((mid-left+1)*10):
right=mid
mid=(right+left)/2
else:
left=mid+1
mid=(left+right)/2
client.send(str(mid)+"\n")
ans=client.recv(1024)
print "ans=",ans
ans=client.recv(1024)#flag
print "ans=%s"%ans
client.close()因为这道题和pwn的知识没什么多大关系，详细的脚本用法就不进行讲解了
运行脚本之后很快就跑完了，拿到flag
0x05 结束语
后面的这几道题也不是很难，都是考到了linux下的许多基础知识。尤其是第一题的知识点需要多去理解，推荐《深入理解计算机系统》、《程序员的自我修养》这两本书，打pwn的基础的话看这两本就行了！