标签: buffer-overflow

哪些GCC选项可以最好地防止内存损坏漏洞,如缓冲区溢出和悬空指针？GCC是否提供任何类型的ROP链缓解？是否存在性能问题或其他问题会妨碍此GCC选项在生产中使用关键任务应用程序？

我正在查看Debian强化指南以及GCC Mudflap.以下是我正在考虑的以下配置:

-D_FORTIFY_SOURCE=2
-fstack-protector --param ssp-buffer-size=4
-fPIE -pie
-Wl,-z,relro,-z,now (ld -z relro and ld -z now)

是否可以对这组选项进行任何改进？假设最新版本的GCC,如果你知道任何很酷的即将推出的功能,请告诉我!

所以我只是注意到了这一点,经过一些实验,我设法让它变得可重复.我没有看到这张贴在任何地方.在某些情况下,Python似乎正在读取文件的末尾.

我正在使用Python 2.7.12

f = open('test', 'wb')
f.write('this is a test')
f.close()

现在,"test"是一个14字节的文件,文本"这是一个测试".

f = open('test', 'rb+')
f.write('abcd')
x = f.read(1024*1024)
f.close()

现在"test"是一个4110字节的文件,有这种内容http://i.imgur.com/rWgNWXy.png

这是一个错误吗？这是安全隐患吗？

就我对语言的理解而言,缓冲区是内存的任何部分,其中数据存储就像int,float变量,字符数组等.但是,我正在阅读缓冲区溢出并在阅读堆栈http时遇到此链接://www.tenouk.com/Bufferoverflowc/Bufferoverflow2a.html 此链接中的图表将缓冲区与函数的局部变量分开.它是否正确？什么是缓冲呢？

作为大学计算机安全课程的一部分,我很快就要学习缓冲区溢出以及如何将它们用作漏洞.我正在尝试使用以下代码执行一些简单的缓冲区溢出:

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

int main(int argc, char *argv[])
{
    char buffer_one[4], buffer_two[16];

    strcpy(buffer_one, "one");
    strcpy(buffer_two, "two");

    strcpy(buffer_one, argv[1]);

    printf("buffer_two is at %p and contains \'%s\'\n", buffer_two, buffer_two);
    printf("buffer_one is at %p and contains \'%s\'\n", buffer_one, buffer_one);
}

如果我运行,我可以使用null终止符覆盖buffer_one的内容

$./overflow 1234567890123456
 buffer_two is at 0x7fff5fbff8d0 and contains '1234567890123456'
 buffer_one is at 0x7fff5fbff8e0 and contains ''

但是如果我发送超过16个字符作为参数,程序将发送Abort陷阱.我认为这是Snow Leopard上的某种缓冲保护(可能是ASLR？).如果if的大小为buffer_two <16,那么adresse仍然是16位

我正在运行gcc -o overflow overflow.c -fno-stack-protector以删除堆栈保护

除了安装运行linux dist的VM之外,有没有解决这个问题的方法？

我有一个缓冲区,我正在做很多strncat.我想确保我永远不会溢出缓冲区大小.

char buff[64];

strcpy(buff, "String 1");

strncat(buff, "String 2", sizeof(buff));

strncat(buff, "String 3", sizeof(buff));

而不是sizeof(buff),我想说一些buff - xxx.我想确保我永远不会覆盖缓冲区

我正在学习缓冲区溢出,并试图制作一个.我有这个代码:

#include <stdio.h>

char *secret = "password";

void go_shell() {
    char *shell =  "/bin/sh";
    char *cmd[] = { "/bin/sh", 0 };
    setreuid(0);
    execve(shell,cmd,0);
}

int authorize() {
    char password[64];
    printf("Enter Password: ");
    gets(password);
    if (!strcmp(password,secret)) {
        return 1;
    }
    else {
        return 0;
    }
}

int main() {
    if (authorize()) {
        printf("login successful\n");
        go_shell();
    } else {
        printf("Incorrect password\n");
    }
    return 0;
}

我用gcc编译它,然后在gdb中运行它

我输入大约100"A"作为密码,程序崩溃.

问题是没有寄存器被覆盖 0x4141414141414141

我用谷歌搜索并添加了-fno-stack-protector标志gcc,这允许RBP被覆盖0x4141414141414141但没有别的.

我想知道是否有一种编译代码的方法,以便可以覆盖RIP.

我试图使用缓冲区溢出更改函数的结果,以使用以下代码更改堆栈上的结果:

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


int check_auth1(char *password) 
{
    char password_buffer[8];
    int auth_flag = 0;
    strcpy(password_buffer, password);
    if (strcmp(password_buffer, "cup") == 0) {
        auth_flag = 1;
    }
    return auth_flag;
}
int main(int argc, char **argv)
{
    if (argc < 2) {
        printf("Usage: %s <password>\n", argv[0]);
        exit(0);
    }
    int authenticated = check_auth1(argv[1]);
    if (authenticated != 1) {
        printf("NOT Allowed.\n");
    } else {
        printf("Allowed.\n");
    }
    return 0;
}

我正在使用gdb来分析堆栈,这就是我所拥有的:

0xbffff6d0: 0xbffff8e4  0x0000002f  0xbffff72c  0xb7fd0ff4
0xbffff6e0: 0x08048540  0x08049ff4  0x00000002  0x0804833d
0xbffff6f0: …

我有一个问题,使用Android的MediaRecorder记录从麦克风到.m4a文件(AAC-LC,MPEG-4容器)的声音.从API级别18开始,默认采样率从44.1或48 kHz(取决于设备)降至仅8 Hz.如果我使用MediaRecorder.setAudioSamplingRate指定采样率,它会使用指定的速率,但录制中会有很多奇怪的噪音.

在LogCat中,以下警告会不时发生:

(1)标签:AudioSource文本:AudioRecord报告超限

(2)标签:AudioFlinger文本:RecordThread:缓冲区溢出

这是代码:

MediaRecorder recorder = new MediaRecorder();
recorder.setAudioChannels(2);
recorder.setAudioSource(MediaRecorder.AudioSource.MIC);
recorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
recorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
recorder.setAudioSamplingRate(48000);   // if not specified, defaults to 8kHz, if specified 44.1 or 48 kHz, lots of noise
recorder.setOutputFile("test.m4a");

try {
    recorder.prepare();
    recorder.start();

} catch (IOException ioe) {
    Log.e(TAG, "IOException", ioe);
} catch (IllegalStateException ise) {
    Log.e(TAG, "IllegalStateException", ise);
} catch (Exception e) {
    Log.e(TAG, "Exception", e);
}

任何帮助是极大的赞赏.

Visual Studio 2013 C++项目有一个 /GS切换到在运行时启用缓冲区安全检查验证.自升级到VS 2013以来,我们遇到了更多STATUS_STACK_BUFFER_OVERRUN错误,并怀疑它与改进的新编译器中缓冲区溢出检查有关.我一直在尝试验证这一点,并更好地了解如何检测缓冲区溢出.即使由语句更新的内存仅更改同一范围内堆栈上另一个局部变量的内容,也会报告缓冲区溢出这一事实让我感到困惑!因此,它必须不仅检查更改不会破坏本地变量"不拥有"的内存,而且还要检查更改不会影响除分配给单个更新语句引用的那个之外的任何本地变量.这是如何运作的？自VS 2010以来它有变化吗？

编辑: 这是一个例子,说明了Mysticial的解释未涉及的案例:

void TestFunc1();

int _tmain(int argc, _TCHAR* argv[])
{
   TestFunc1();
   return 0;
}

void TestFunc1()
{
   char buffer1[4] = ("123");
   char buffer2[4] = ("456");
   int diff = buffer1 - buffer2;
   printf("%d\n", diff);
   getchar();
   buffer2[4] = '\0';
}

输出4指示要覆盖的内存在buffer1(紧接着之后buffer2)的范围内,但随后程序以缓冲区溢出终止.从技术上讲,它应该被认为是缓冲区溢出,但我不知道它是如何被检测到的,因为它仍然在局部变量的存储内,并没有真正破坏局部变量之外的任何东西.

带有内存布局的屏幕截图证明了这一点.步进一行后,程序因缓冲区溢出错误而中止.

我只是想相同的代码在VS 2010中,虽然调试模式陷入缓冲区溢出(带缓冲12的偏移量),在发布模式下它并没有抓住它(带缓冲的8偏移).所以我认为VS 2013收紧了/GS交换机的行为.

编辑2: 我设法用这段代码偷偷溜过VS 2013范围检查.它仍然没有检测到更新一个局部变量的尝试实际更新了另一个:

void TestFunc()
{
   char buffer1[4] = "123";
   char buffer2[4] = "456";
   int diff;
   if (buffer1 < …

我做了什么.

测试1

  1 #include <stdio.h>                                                              
  2                                                                                 
  3 int test[16];                                                                   
  4                                                                                 
  5 int main()                                                                      
  6 {                                                                               
  7     test[17] = -1;                                                              
  8 } 

/tmp $ gcc ./main.c -o main -fsanitize=address
/tmp $ ./main 
/tmp $

TEST2

  1 #include <stdio.h>                                                              
  2                                                                                 
  3 int test[16] = {1};                                                             
  4                                                                                 
  5 int main()                                                                      
  6 {                                                                               
  7     test[17] = -1;                                                              
  8 }

 /tmp $ gcc ./main.c -o main -fsanitize=address
 /tmp $ ./main 

=================================================================
==19776==ERROR: AddressSanitizer: global-buffer-overflow on address 
...

看起来全局缓冲区溢出检测不适用于放在bss中的全局变量(是这样吗？).这背后的原因是什么？

更新:

存储的代码没有优化.系统信息:

$ gcc --version
gcc (Ubuntu …