标签: buffer-overflow

1167      ptr = (void*)getcwd(cwd, MAX_PATH_LENGTH-1);
(gdb) n
1168      if (!ptr) {
(gdb) print ptr
$1 = 0xbff2d96c "/media/MMC-SD/partition1/aaaaaaaaaaa"
(gdb) print &cwd
$2 = (char (*)[3500]) 0xbff2d96c
(gdb) print strlen(cwd)
$3 = 36
(gdb) print "%s",cwd
$4 = "/media/MMC-SD/partition1/aaaaaaaaaaa", '\0' <repeats 912 times>, "??O?001\000\000\000\000??027\000\000\000?3????EL?3?000??027\000\000\000\000\000\000\000\027\000\000\000\000??/?027\000\000\000?3????N????\230????3?000??027\000\000\000\000\000\000\000??000\000\000\000\001\000\000\000??M?3????\000\000\000\000.\231?027??w\005\b\001\000"...
(gdb) print "%s", ptr
$5 = 0xbff2d96c "/media/MMC-SD/partition1/aaaaaaaaaaa"
(gdb) Quit

为什么ptr正确打印字符串但不是cwd; 如果我尝试使用cwd,这也会影响程序并崩溃...

[编辑:事实证明崩溃是由于此变量上的一个愚蠢的缓冲区溢出... grr ...而不是gdb,但打印问题仍然有效]

我正在处理一个简单的缓冲区溢出(是的,利用;但与问题无关)我试图找出内存映射中的字段,当GCC的堆栈保护器启用时.作为说明:

$ ./overflow
*** stack smashing detected ***: ./overflow terminated
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x48)[0xb7f67da8]
/lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x0)[0xb7f67d60]
./overflow[0x804845c]
[0x41414141]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:06 3704767    /home/hatred/w0rk/bugz
08049000-0804a000 r--p 00000000 08:06 3704767    /home/hatred/w0rk/bugz
0804a000-0804b000 rw-p 00001000 08:06 3704767    /home/hatred/w0rk/bugz
0804b000-0806c000 rw-p 0804b000 00:00 0          [heap]
b7e5a000-b7e67000 r-xp 00000000 08:06 368705     /lib/libgcc_s.so.1
b7e67000-b7e68000 r--p 0000c000 08:06 368705     /lib/libgcc_s.so.1
b7e68000-b7e69000 rw-p 0000d000 08:06 368705     /lib/libgcc_s.so.1
b7e69000-b7e6a000 rw-p b7e69000 00:00 0 
b7e6a000-b7fc6000 r-xp 00000000 08:06 386037     /lib/tls/i686/cmov/libc-2.9.so
b7fc6000-b7fc7000 ---p 0015c000 08:06 386037     /lib/tls/i686/cmov/libc-2.9.so …

我正在开发一个发布到网站的应用程序,我正在尝试将实体响应存储为字符串.但是,字符串似乎只包含一小部分响应,大约35行左右.我想知道它是否与缓冲区溢出有关但我真的不确定.我的代码如下:

static String getResponseBody(HttpResponse response) throws IllegalStateException, IOException{

    String content = null;
    HttpEntity entity = response.getEntity();

    if (entity != null) 
    {
        InputStream is = entity.getContent();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        StringBuilder sb = new StringBuilder();
        String line = null;

        while ((line = br.readLine()) != null) 
        {
            if(isBlankString(line) == false)
            {
            sb.append(line + "\n");
            }
        }
        br.close();
        content = sb.toString();
    }
    return content; 

isBlankString只是注意一条线是否包含任何字符,因为响应中有很多空白行让我烦恼.我有一个问题,即无论有没有得到整个回应.任何人都知道发生了什么或如何解决这个问题？

谢谢

我试图了解wcsncpy_s函数如何工作以及它如何防止缓冲区溢出.首先,根据MSDN,此函数的参数意味着以下内容:

strDest =目标字符串.

numberOfElements =目标字符串的大小.

strSource =源字符串.

count =要复制的字符数,或_TRUNCATE.

现在考虑这段代码:

wchar_t a[5];
wcsncpy_s(a, 10, L"ABCDEFGHIJKLMNOPQRSTUVWXYZ", 9);

printf("%d\r\n", sizeof(a));//10
printf("%d\r\n", wcslen(a));//9
wprintf(L"%s", a);//ABCDEFGHI

如果我理解这一切,"a",它应该最多包含4个宽字符和一个空终止符,现在可以容纳9个宽字符.

现在,以下代码将导致我的应用程序因调试断言失败而突然终止(VS 2005编译器):

wchar_t a[5];
wcsncpy_s(a, 10, L"ABCDEFGHIJKLMNOPQRSTUVWXYZ", 10);

printf("%d\r\n", sizeof(a));
printf("%d\r\n", wcslen(a));
wprintf(L"%s", a);

有人可以解释上面的代码,以及wcsncpy_s应该如何防止缓冲区溢出？

通过cat /proc/*some PID*/maps对机器上的多个进程执行一些操作,我注意到它们在内存地址方面都有相同的起点0x8048000.这是否意味着每个进程都有"它自己的内存空间,包括堆栈,堆等".在运行时？

如果是这样,攻击者如何区分一个进程的内存地址到另一个进程？

因此,如果一台机器有2GB的RAM,并且有几个进程同时运行 - 我们如何知道我们所针对的内存地址？或者我把这一切都弄错了,攻击开始于查看过程本身然后从那里前进？

请原谅初学者的问题,我刚刚进入大会并且正在同时阅读5个教程,并且有点难以理解这一切.

请注意这个问题是放在这里,而不是IT安全,因为我确实提到了大会方面.

我想使用Raspberry PI和Raspbian OS为ARMv6指令集架构编写一个简单的缓冲区溢出示例.我首先看一下堆栈框架的布局.很遗憾,我无法找到回邮地址.请考虑以下示例:

void foo
(int b)
{
    int c = 3;
}

int main
(int argc, char **argv)
{
    int a = 1;
    foo(2);
    a = 4;
}

我编译它:

gcc exploit_me.c -g -O0 -o exploit_me

使用gdb调试代码可以获得以下信息:

gdb exploit_me 
GNU gdb (GDB) 7.4.1-debian
Copyright (C) 2012 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by …

我编写了以下程序,用于将文件中的字符串读入变量"title":

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int m, b;
    char *title;
    FILE *fp;

    fp = fopen("input2.txt", "r");
    if (fp == NULL)
    {
         printf ("Error: file cannot be found\n");
         return 1;
    }

    fscanf(fp, "<%d>\n<%d>", &m, &b);
    printf("%d\n%d", m, b);
    fscanf(fp, "<%s>", title);

    fclose(fp);
    return 0;
}

上面的程序在第二次调用时崩溃了fscanf.为什么会这样？

给定一个语法,在C中计算FIRST和FOLLOW时,如何避免堆栈溢出问题.当我不得不通过长时间的生产时,问题出现在我的代码中.

例:

S->ABCD
A->aBc | epsilon
B->Bc
C->a | epsilon
D->B

这只是一个语法.递归是这样的:

S->A
C->A
A->B
B->D
D->aBc | epsilon

FIRST(S)=FIRST(A)=FIRST(B)=FIRST(D)={a,epsilon}.  

Run Code Online (Sandbox Code Playgroud)

提供一个C(而不是C++)代码来计算和打印上面的语法的FIRST和FOLLOW集合,记住你可能会遇到一个更长的语法,它具有特定非终端的多个隐含的第一/后续集合.

例如:

FIRST(A)=FIRST(B)=FIRST(B)=FIRST(C)=FIRST(D)=FIRST(E)=FIRST(F)=FIRST(G)=FIRST(H)=FIRST(I)=FIRST(J)=FIRST(K)={k,l,epsilon}.

那就是:让你得到FIRST(A)你算算FIRST(B),并依此类推,直至到达FIRST(K)具有其FIRST(K)具有终端'k','l'和epsilon.暗示越长,越有可能因多次递归而遇到堆栈溢出.
如何在C语言中避免这种情况并仍能获得正确的输出？
用C(不是C++)代码解释.

char*first(int i)
{
    int j,k=0,x;
    char temp[500], *str;
    for(j=0;grammar[i][j]!=NULL;j++)
    {
        if(islower(grammar[i][j][0]) || grammar[i][j][0]=='#' || grammar[i][j][0]==' ')
        {
           temp[k]=grammar[i][j][0];
           temp[k+1]='\0';
        }
        else
        {
            if(grammar[i][j][0]==terminals[i])
            {
                temp[k]=' ';
                temp[k+1]='\0';
            }
            else
            {
                x=hashValue(grammar[i][j][0]);
                str=first(x);
                strncat(temp,str,strlen(str));
            }
        }
        k++;
    }
    return temp;
} …

我试图创建一个简单的程序只是为了好玩,但我得到一个BufferOverflowException:

ByteBuffer byteBuffer = ByteBuffer.allocateDirect(10);
FloatBuffer floatBuffer = byteBuffer.asFloatBuffer();
floatBuffer.put(new float[] {1, 0, 0});

可能有什么不对？

我是汇编新手，并试图编写一个内置的“echo”版本，但一次只能对 1 个字节进行操作。

我有以下按我想要的方式工作的方法，除了它在读取和写入时溢出超过 1 个字节，即使我在两个系统调用中都明确表示 x2 中的 1 个字节。我究竟做错了什么？

示例运行：

sh-4.2$ ./echo1b
f
f
o
o
b
b
bar
bar
bazbazbaz
bazbazbaz
q
sh-4.2$

这是代码：

.data
temp:   .byte 1  

.text
.globl _start
_start:
    /* read one byte from stdin, store to temp */
    mov x0, #0x0
    adr x1, temp
    mov x2, #0x1
    mov x8, #0x3F
    svc #0x0

    /* write newline to stdout */
    mov x0, #0x1
    mov x1, #0xA
    mov x2, #0x1
    mov x8, #0x40
    svc #0x0
    
    /* if …