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*) 0){                 printf("bind error, use another port\n");                 return 1;         }         listen(sd, 1);         int c = sizeof(struct sockaddr_in);         cd = accept(sd, (struct sockaddr *)         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*)  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的基础的话看这两本就行了！

大家有任何问题可以提问，更多文章可到i春秋论坛阅读哟~

转载请注明来自网盾网络安全培训，本文标题：《pwnable.kr详细通关秘籍（二）》

标签：pwnable.tw通关秘籍