虽然Linux病毒屈指可数,但是基于缓冲区溢出(BufferOverflow)漏洞的攻击还是让众多Linux用户大吃一惊。所谓“世界上之一个Linux病毒”??reman,严格地说并不是真正的病毒,它实质上是一个古老的、在Linux/Unix(也包括Windows等系统)世界中早已存在的“缓冲区溢出”攻击程序。reman只是一个非常普通的、自动化了的缓冲区溢出程序,但即便如此,也已经在Linux界引起很大的恐慌。
缓冲区溢出漏洞是一个困扰了安全专家30多年的难题。简单来说,它是由于编程机制而导致的、在软件中出现的内存错误。这样的内存错误使得黑客可以运行一段恶意代码来破坏系统正常地运行,甚至获得整个系统的控制权。
Linux系统特性
利用缓冲区溢出改写相关内存的内容及函数的返回地址,从而改变代码的执行流程,仅能在一定权限范围内有效。因为进程的运行与当前用户的登录权限和身份有关,仅仅能够制造缓冲区溢出是无法突破系统对当前用户的权限设置的。因此尽管可以利用缓冲区溢出使某一程序去执行其它被指定的代码,但被执行的代码只具有特定的权限,还是无法完成超越权限的任务。
但是,Linux(包括Unix)系统本身的一些特性却可以被利用来冲破这种权限的局限性,使得能够利用缓冲区溢出获得更高的、甚至是完全的权限。主要体现在如下两方面:
1.Linux(包括Unix)系统通过设置某可执行文件的属性为SUID或SGID,允许其它用户以该可执行文件拥有者的用户ID或用户组ID来执行它。如果该可执行文件的属性是root,同时文件属性被设置为SUID,则该可执行文件就存在可利用的缓冲区溢出漏洞,可以利用它以root的身份执行特定的、被另外安排的代码。既然能够使得一个具有root权限的代码得以执行,就能够产生一个具有超级用户root权限的Shell,那么掌握整个系统的控制权的危险就产生了。
2.Linux(包括Unix)中的许多守护进程都是以root权限运行。如果这些程序存在可利用的缓冲区溢出,即可直接使它以root身份去执行另外安排的代码,而无须修改该程序的SUID或SGID属性。这样获得系统的控制权将更加容易。
随着现代 *** 技术的发展和 *** 应用的深入,计算机 *** 所提供的远程登录机制、远程调用及执行机制是必须的。这使得一个匿名的Internet用户有机会利用缓冲区溢出漏洞来获得某个系统的部分或全部控制权。实际上,以缓冲区溢出漏洞为攻击手段的攻击占了远程 *** 攻击中的绝大多数,这给Linux系统带来了极其严重的安全威胁。
途径分析
通常情况下攻击者会先攻击root程序,然后利用缓冲区溢出时发生的内存错误来执行类似“exec(sh)”的代码,从而获得root的一个Shell。为了获得root权限的Shell,攻击者需要完成如下的工作:
1.在程序的地址空间内安排适当的特定代码。一般使用如下两种 *** 在被攻击的程序地址空间内安排攻击代码。
2.通过适当地初始化寄存器和存储器,使程序在发生缓冲区溢出时不能回到原来的执行处,而是跳转到被安排的地址空间执行。
当攻击者找到一种途径可以变原程序的执行代码和流程时,攻击的危险就产生了。
共2页: 1 [2]
内容导航
第 1 页:Linux系统特性
防范措施
Linux下的缓冲区溢出攻击威胁既来自于软件的编写机制,也来自于Linux(和Unix)系统本身的特性。实际上,缓冲区溢出攻击及各种计算机病毒猖獗的根本原因在于现代计算机系统都是采用冯?诺依曼“存储程序”的工作原理。这一基本原理使得程序和数据都可以在内存中被繁殖、拷贝和执行。因此,要想有效地防范缓冲区溢出攻击就应该从这两个方面双管其下。
确保代码正确安全
缓冲区溢出攻击的根源在于编写程序的机制。因此,防范缓冲区溢出漏洞首先应该确保在Linux系统上运行的程序(包括系统软件和应用软件)代码的正确性,避免程序中有不检查变量、缓冲区大小及边界等情况存在。比如,使用grep工具搜索源代码中容易产生漏洞的库调用,检测变量的大小、数组的边界、对指针变量进行保护,以及使用具有边界、大小检测功能的C编译器等。
基于一定的安全策略设置系统
攻击者攻击某一个Linux系统,必须事先通过某些途径对要攻击的系统做必要的了解,如版本信息等,然后再利用系统的某些设置直接或间接地获取控制权。因此,防范缓冲区溢出攻击的第二个方面就是对系统设置实施有效的安全策略。这些策略种类很多,由于篇幅有限只列举几个典型措施:
(1)在装有Telnet服务的情况下,通过手工改写“/etc/inetd.conf”文件中的Telnet设置,使得远程登录的用户无法看到系统的提示信息。具体 *** 是将Telnet设置改写为:
telnet stream tcp nowait root /usr/ *** in/tcpd/in.telnetd -h
末尾加上“-h”参数可以让守护进程不显示任何系统信息,只显示登录提示。
(2)改写“rc.local”文件。默认情况下,当登录Linux系统时系统运行rc.local文件,显示该Linux发行版本的名字、版本号、内核版本和服务器名称等信息,这使得大量系统信息被泄露。将“rc.local”文件中显示这些信息的代码注释掉,可以使系统不显示这些信息。
一种 *** 是在显示这-些信息的代码行前加“#”:
……# echo “”/etc/issue# echo “$R”/etc/issue#echo”Kernel $ (uname -r)on $a $(uname -m)”/etc/issue##echo/etc/issue……
另一种 *** 是将保存有系统信息的文件/etc/issue.net和issue删除。这两个文件分别用于在远程登录和本地登录时向用户提供相关信息。删除这两个文件的同时,仍需要完成 *** 一中的注释工作,否则,系统在启动时将会自动重新生成这两个文件。
(3)禁止提供finger服务。在Linux系统中,使用finger命令可以显示本地或远程系统中目前已登录用户的详细信息。禁止提供finger服务的有效 *** 是,通过修改该文件属性、权限(改为600)使得只有root用户才可以执行该命令。
(4)处理“inetd.conf”文件。Linux系统通过inetd(超级服务器)程序根据 *** 请求装入 *** 程序。该程序通过“/etc/inetd.conf”文件获得inetd在监听哪些 *** 端口,为每个端口启动哪些特定服务等信息。因此,该文件同样会泄露大量的敏感信息。解决问题的 *** 是,通过将其权限改为600只允许root用户访问,并通过改写“/etc/inetd.conf”文件将不需要的服务程序禁止掉,最后修改该文件的属性使其不能被修改。
总结
缓冲区溢出攻击之所以能成为一种常见的攻击手段,其原因在于缓冲区溢出漏洞太普遍,且易于实现攻击,因此缓冲区溢出问题一直是个难题。
所幸的是,OpenBSD开发组为解决这一安全难题采用了三种新的有效策略。相信不久的将来,Linux用户可以不再为缓冲区溢出攻击而寝食难安了。
RAR文件在Linux下用起来
要在Linux下处理.rar文件,需要安装RARforLinux。该软件可以从网上下载,但要记住,它不是免费的。大家可从http://www.onlinedown.net/sort/125_1.htm下载RARforLinux 3.2.0,然后用下面的命令安装:
# tar -xzpvf rarlinux-3.2.0.tar.gz
# cd rar
# make
安装后就有了rar和unrar这两个程序,rar是压缩程序,unrar是解压程序。它们的参数选项很多,这里只做简单介绍,依旧举例说明一下其用法:
# rar a all *.mp3
这条命令是将所有.mp3的文件压缩成一个rar包,名为all.rar,该程序会将.rar 扩展名将自动附加到包名后。
# unrar e all.rar
这条命令是将all.rar中的所有文件解压出来。
因为它是在程序执行的时候在缓冲区执行的错误代码,所以叫缓冲区溢出漏洞。
它一般是由于编成人员的疏忽造成的。
具体的讲,溢出漏洞是由于程序中的某个或某些输入函数(使用者输入参数)对所接收数据的边界验证不严密而造成。
根据程序执行中堆栈调用原理,程序对超出边界的部分如果没有经过验证自动去掉,那么超出边界的部分就会覆盖后面的存放程序指针的数据,当执行完上面的代码,程序会自动调用指针所指向地址的命令。
根据这个原理,恶意使用者就可以构造出溢出程序。 其实溢出原理很简单(我以前以为很难理解,太菜了,o(∩_∩)o…)。当然,这里为了让大家容易理解,会引用一些程序实例(如果没有编程基础的,可以略过程序不看,影响不大,还是能理解的),而且说得会比较通俗和简单,不会太深入。
从书上找来找去,终于找到一个适合的程序(汗!要找符合的程序简单啊,但是要找特级菜鸟觉得特别简单的程序就不多了,55~~)。大家看看下面这段程序:
#include “stdafx.h”
#include “string.h”
#include “stdio.h”
char buf[255], pass[4]; /*声明变量,让计算机分配指定的内存*/
int main (int argc , char* argv[ ])
{
printf(“请输入您的密码:”); /*指定输出的字符*/
scanf(%s ,buf); /*输入一个字符串,保存在变量buf中*/
strcpy(pass , buf); /*把字符串buf中的字符串复制到变量pass中*/
if (strcmp(pass,”wlqs”)= =0) /*比较输入的字符串是否为密码*/
printf (“输入正确!”);
else printf(“输入错误!);
return 0;
}
(注:“/*”中的中文是对程序的注解)
这是一段密码验证程序,与我们平时输入密码一样,先让用户输入密码,然后在取得真正的密码,与之对比,如果差异为0,则输出密码正确,否则输出密码错误。很多帐号登录的程序都是这样做的,看起来没有非常合理,其实不然,它有一个致命缺陷!这个漏洞很容易就看出来了。那就是它给数据申请了4个字节的储存空间,但是万一用户输入的数据不只4个字节,那么剩余的字节存放在哪里?
先举个例子,有一条一米长的木头,有一张红色纸条从尾巴往头贴,上面写有字,然后又有一张蓝色纸条,上面也写有字,要从木头的头往它的尾巴贴,但是贴了红色纸条过后只剩4cm的长度,贴完后会有人读出后面96cm的字,并且执行字条的命令,但是蓝色纸条却有10cm的长度,怎么办呢?只有把蓝色纸条剩下的部分贴在红色纸条上了。那么红色纸条的一些字就被覆盖了。但是那个人还是会去读那后面96cm的字,所以他就只有读错,前面读的都是蓝色字条的字。先前去执行的是蓝色字条后面6cm的命令。
当然大家看了这个例子也不是很懂,下面来注解一下:
人——CPU
红色字条上的字——CPU要执行的命令
4cm的长度——计算机为数据申请的内存空间
蓝色字条上的字——要储存的数据
可以看见蓝色字条已经覆盖了红色字条上的字,然而那个人还是必须读出后面96cm的字并执行。后面已经不是规定的命令了!他根本就不能执行,根本读不懂!那么他就不能执行了,并且报错。
如图系统只为我的密码分配4个字节的内存,那么我输入的密码是“714718366”循环了6次的,不只4个字节吧,其他剩下的字符将溢出!剩下的数字将占用内存空间,那么系统执行命令的时候将会执行占用内存的数据,而不是执行原先写好的命令了!这些数字系统根本就读不懂,如何执行?那么它只好报错了!说此程序遇到问题需要关闭。那么计算机上的程序将出错而无法执行或关闭。
二、本地溢出
/B上面所说的本地计算机因数据溢出而关闭程序或无法执行就叫做本地溢出。输入超长的数据已经把计算机要执行的代码覆盖掉了,可是,计算机不会管指令有没有被更改,依旧取原先存放指令的空间里的数据来运行,取到“shujucuole!shujucuole!shujucuole!”这些不合法的溢出数据,它依旧会执行,可是在计算机里这样的指令是非法指令,也就是不符合计算机逻辑的指令,用户执行它的时候就会出错,于是程序就被强行关闭了。
题外话:(想来想去,还是说一说o(∩_∩)o…我的爱好……损人利己的爱好)利用这样的溢出漏洞可以关闭很多程序,比如各学校机房里安装的那些远程教育系统,学生的计算机被教师的计算机所控制是因为学生机上安装有一个学生端程序,教师机可以通过教师端来对学生端进行远程控制,学生端没有推出功能,学生所在的用户组也没有强行结束进程的权限,档学生不想被老师控制的时候,可以打开学生端自带的远程消息功能,在消息里输入很长的数据,比如几百上千句“敢控制我!看我不宰了你!”,然后发送,就可以令学生端程序出错而被系统强行关闭。这招对某些网吧的收费系统也有用的!^_^
三、远程溢出
再举个列子(哎,这英文字母也太难打了,程序更难找,还翻了好几本书呢!55~~):
#include “stdafx.h”
#include winsock.h
#pragma comment(lib ,”ws2_32”)
int main(int argc,char* argv[ ])
{
char buf[255]=” ”,pass[4]=” ”; //声明变量,让计算机分配内存
//================================================================
//这节的代码功能是出示化 *** 连接
//并侦听1234端口等待连接
//没有编程基础的特级菜鸟可以略过不看
SOCKET sock1,sock2;
struct sockaddr_in addr1;
struct sockaddr_in addr2;
addr1 .sin_addr.s_addr=INADDR_ANY;
addr1 .sin_family=AF_INET;
addr1 .sin_port=htons(1234);
WSADATA * wsadatal=new WSADATA( );
WSAStartup(MAKEWORD(2,2),wsadatal1);
sock1=socket(AF_INET,SOCK_STREAM,0);
bind(sock1,(sockaddr *)addr1,sizeof(struct sockaddr) );
listen(sock1,10);
int iSin=sizeof(struct sockaddr_in);
//=================================================================
if(sock2=accept(sock1,(sockaddr *)addr2,iSin)
{//有用户连接进来
send(sock2,“请输入密码,密码正确,则告诉你我的qq:”,36,0);
//发送提示用户输入密码
if (recv(sock2,buf,255,0))
{//接受用户发送过来的数据并保存在缓冲buf变量里
strcpy (pass,buf);//把缓冲buf变量里的数据复制到pass变量中
if(strcmp(pass,”wlqs”= =0)
//比较pass变量里的数据跟“wlqs”字符串之间的差异是否为0
{//差异为0,则说明两者相等,密码正确
send(sock2,”714718366”,9,0);//发送 *** 号给用户
}
else
{//否则就说明密码错误
send (sock2,”密码错误!”,10,0);
}
}
}
//=================[/ft]关闭 *** 连接并退出=======================
closesocket(sock2);
closesocket(sock1);
return 0;
}
(可把我打死了!这么长的字母啊!我最讨厌打英文了!和写简直是两回事*_*)
这是一个服务器程序,当有用户连接的时候,它会先发送一句话,提示用户输入登录密码。其实它和前面说的本地溢出例子形似,问题也就处在把数据从缓存复制刀内存的那句代码里,如果远程用户输入的密码太长,那么同样出现溢出的现象。那么程序就会出错,服务端将被强行关闭。
举个例子,比如腾讯公司的即时通讯软件服务端程序就曾被黑客不停地攻击导致服务端崩溃,不能正常提供服务,只是很多用户都不能登陆,及时登陆成功也会在几分钟之内再次掉线,就是因为他们的服务端有这样的漏洞存在,被别人利用了,这给他们以及他们的客户造成了不可估计的损失。
缓冲区溢出漏洞入门介绍
文/hokersome
一、引言
不管你是否相信,几十年来,缓冲区溢出一直引起许多严重的安全性问题。甚至毫不夸张的说,当前 *** 种种安全问题至少有50%源自缓冲区溢出的问题。远的不说,一个冲击波病毒已经令人谈溢出色变了。而作为一名黑客,了解缓冲区溢出漏洞则是一门必修课。网上关于溢出的漏洞的文章有很多,但是大多太深或者集中在一个主题,不适合初学者做一般性了解。为此,我写了这篇文章,主要是针对初学者,对缓冲区溢出漏洞进行一般性的介绍。
缓冲区溢出漏洞是之所以这么多,是在于它的产生是如此的简单。只要C/C++程序员稍微放松警惕,他的代码里面可能就出现了一个缓冲区溢出漏洞,甚至即使经过仔细检查的代码,也会存在缓冲区溢出漏洞。
二、溢出
听我说了这些废话,你一定很想知道究竟什么缓冲区溢出漏洞,溢出究竟是怎么发生的。好,现在我们来先弄清楚什么是溢出。以下的我将假设你对C语言编程有一点了解,一点点就够了,当然,越多越好。
尽管缓冲区溢出也会发生在非C/C++语言上,但考虑到各种语言的运用程度,我们可以在某种程度上说,缓冲区溢出是C/C++的专利。相信我,如果你在一个用VB写的程序里面找溢出漏洞,你将会很出名。回到说C/C++,在这两种使用非常广泛的语言里面,并没有边界来检查数组和指针的引用,这样做的目的是为了提高效率,而不幸的是,这也留下了严重的安全问题。先看下面一段简单的代码:
#includestdio.h
void main()
{
char buf[8];
gets(buf);
}
程序运行的时候,如果你输入“Hello”,或者“Kitty”,那么一切正常,但是如果输入“Today is a good day”,那么我得通知你,程序发生溢出了。很显然,buf这个数组只申请到8个字节的内存空间,而输入的字符却超过了这个数目,于是,多余的字符将会占领程序中不属于自己的内存。因为C/C++语言并不检查边界,于是,程序将看似正常继续运行。如果被溢出部分占领的内存并不重要,或者是一块没有使用的内存,那么,程序将会继续看似正常的运行到结束。但是,如果溢出部分占领的正好的是存放了程序重要数据的内存,那么一切将会不堪设想。
实际上,缓冲区溢出通常有两种,堆溢出和堆栈溢出。尽管两者实质都是一样,但由于利用的方式不同,我将在下面分开介绍。不过在介绍之前,还是来做一些必要的知识预备。
三、知识预备
要理解大多数缓冲区溢出的本质,首先需要理解当程序运行时机器中的内存是如何分配的。在许多系统上,每个进程都有其自己的虚拟地址空间,它们以某种方式映射到实际内存。我们不必关心描述用来将虚拟地址空间映射成基本体系结构的确切机制,而只关心理论上允许寻址大块连续内存的进程。
程序运行时,其内存里面一般都包含这些部分:1)程序参数和程序环境;2)程序堆栈,它通常在程序执行时增长,一般情况下,它向下朝堆增长。3)堆,它也在程序执行时增长,相反,它向上朝堆栈增长;4)BSS 段,它包含未初始化的全局可用的数据(例如,全局变量); 5)数据段,它包含初始化的全局可用的数据(通常是全局变量);6)文本段,它包含只读程序代码。BSS、数据和文本段组成静态内存:在程序运行之前这些段的大小已经固定。程序运行时虽然可以更改个别变量,但不能将数据分配到这些段中。下面以一个简单的例子来说明以上的看起来让人头晕的东西:
#includestdio.h
char buf[3]="abc";
int i;
void main()
{
i=1
return;
}
其中,i属于BBS段,而buf属于数据段。两者都属于静态内存,因为他们在程序中虽然可以改变值,但是其分配的内存大小是固定的,如buf的数据大于三个字符,将会覆盖其他数据。
与静态内存形成对比,堆和堆栈是动态的,可以在程序运行的时候改变大小。堆的程序员接口因语言而异。在C语言中,堆是经由 malloc() 和其它相关函数来访问的,而C++中的new运算符则是堆的程序员接口。堆栈则比较特殊,主要是在调用函数时来保存现场,以便函数返回之后能继续运行。
四、堆溢出
堆溢出的思路很简单,覆盖重要的变量以达到自己的目的。而在实际操作的时候,这显得比较困难,尤其是源代码不可见的时候。之一,你必须确定哪个变量是重要的变量;第二,你必须找到一个内存地址比目标变量低的溢出点;第三,在特定目的下,你还必须让在为了覆盖目标变量而在中途覆盖了其他变量之后,程序依然能运行下去。下面以一个源代码看见的程序来举例演示一次简单的堆溢出是如何发生的:
#include "malloc.h"
#include "string.h"
#include "stdio.h"
void main()
{
char *large_str = (char *)malloc(sizeof(char)*1024);
char *important = (char *)malloc(sizeof(char)*6);
char *str = (char *)malloc(sizeof(char)*4);
strcpy(important,"abcdef");//给important赋初值
//下面两行代码是为了看str和important的地址
printf("%d/n",str);
printf("%d/n",important);
gets(large_str);//输入一个字符串
strcpy(str, large_str);//代码本意是将输入的字符串拷贝到str
printf("%s/n",important);
}
在实际应用中,这样的代码当然是不存在的,这只是一个最简单的实验程序。现在我们的目标是important这个字符串变成"hacker"。str和important的地址在不同的环境中并不是一定的,我这里是7868032和7868080。很好,important的地址比str大,这就为溢出创造了可能。计算一下可以知道,两者中间隔了48个字节,因此在输入溢出字符串时候,可以先输入48个任意字符,然后再输入hakcer回车,哈哈,出来了,important成了"hacker"。
五、堆栈溢出
堆溢出的一个关键问题是很难找到所谓的重要变量,而堆栈溢出则不存在这个问题,因为它将覆盖一个非常重要的东西----函数的返回地址。在进行函数调用的时候,断点或者说返回地址将保存到堆栈里面,以便函数结束之后继续运行。而堆栈溢出的思路就是在函数里面找到一个溢出点,把堆栈里面的返回地址覆盖,替换成一个自己指定的地方,而在那个地方,我们将把一些精心设计了的攻击代码。由于攻击代码的编写需要一些汇编知识,这里我将不打算涉及。我们这里的目标是写出一个通过覆盖堆栈返回地址而让程序执行到另一个函数的堆栈溢出演示程序。
因为堆栈是往下增加的,因此,先进入堆栈的地址反而要大,这为在函数中找到溢出点提供了可能。试想,而堆栈是往上增加的,我们将永远无法在函数里面找到一个溢出点去覆盖返回地址。还是先从一个最简单的例子开始:
void test(int i)
{
char buf[12];
}
void main()
{
test(1);
}
test 函数具有一个局部参数和一个静态分配的缓冲区。为了查看这两个变量所在的内存地址(彼此相对的地址),我们将对代码略作修改:
void test(int i)
{
char buf[12];
printf("i = %d/n", i);
printf("buf[0] = %d/n", buf);
}
void main()
{
test(1);
}
需要说明的是,由于个人习惯的原因,我把地址结果输出成10进制形式,但愿这并不影响文章的叙述。在我这里,产生下列输出:i = 6684072 buf[0] = 6684052。这里我补充一下,当调用一个函数的时候,首先是参数入栈,然后是返回地址。并且,这些数据都是倒着表示的,因为返回地址是4个字节,所以可以知道,返回地址应该是保存在从6684068到6684071。因为数据是倒着表示的,所以实际上返回地址就是:buf[19]*256*256*256+buf[18]*256*256+buf[17]*256+buf[16]。
我们的目标还没有达到,下面我们继续。在上面程序的基础,修改成:
#include stdio.h
void main()
{
void test(int i);
test(1);
}
void test(int i)
{
void come();
char buf[12];//用于发生溢出的数组
int addr[4];
int k=(int)i-(int)buf;//计算参数到溢出数组之间的距离
int go=(int)come;
//由于EIP地址是倒着表示的,所以首先把come()函数的地址分离成字节
addr[0]=(go 24)24;
addr[1]=(go 16)24;
addr[2]=(go 8)24;
addr[3]=go24;
//用come()函数的地址覆盖EIP
for(int j=0;j4;j++)
{
buf[k-j-1]=addr[3-j];
}
}
void come()
{
printf("Success!");
}
一切搞定!运行之后,"Success!"成功打印出来!不过,由于这个程序破坏了堆栈,所以系统会提示程序遇到问题需要关闭。但这并不要紧,因为至少我们已经迈出了万里长征的之一步。
防止缓冲区举出 ,可以参考 如下几点建议:
1、避免使用编译器中自带的库文件
编程语言通常都要带有库文件。如果一个库文件具有某些漏洞,任何包括该库文件的应用程序就都会有这些漏洞。因此,黑客往往会先试图利用常用的库文件中已知的漏洞来达到攻击本地应用程序的目的。
库文件本身也不可靠。虽然最新的编译器都开始加入大量可靠的库文件,但长期以来库文件为了提供了快速、简单的方式来完成任务,几乎没有考虑到安全编码的问题。C + +编程语言就是这种形式的最典型代表。而用C + +编写的程序中依赖的标准库就很容易在运行时产生错误,这也为希望利用缓冲区溢出进行攻击的黑客们提供了实现他们想法的机会。
2、验证所有的用户输入
要在本地应用程序上验证所有的用户输入,首先要确保输入字符串的长度是有效长度。举个例子,假设你的程序设计的是接受50个文本字符的输入,并将它们添加到数据库里。如果用户输入75个字符,那么他们就输入了超出数据库可以容纳的字符,这样以来谁都不能预测程序接下来的运行状况。因此,用户的输入应该这样设计:在用户输入文本字符串时,先将该字符串的长度同更大允许长度进行比较,在字符串超过更大允许长度时能对其进行必要的拦截。
3、过滤掉潜在的恶意输入
过滤是另一个很好的防御措施。先看下面例子中的ASP代码:
这是从用户的输入中过滤掉HTML代码,撇号和引号的代码。
?
strNewString = Request.Form("Review")
strNewString = Replace(strNewString, "", " amp;")
strNewString = Replace(strNewString, "", " lt;")
strNewString = Replace(strNewString, "", " gt;")
strNewString = Replace(strNewString, "'", "`")
strNewString = Replace(strNewString, chr(34), "``")
上面的代码用于目前我正在开发的电子商务网站中。这样做的目的是为了过滤掉可能会导致数据库出现问题的HTML代码和符号。在HTML代码中,使用""和""的符号来命名一个HTML标签。为了防止用户可能会在他们的输入里嵌入HTML代码,因此程序过滤掉了""和""符号。
什么是缓冲区溢出
单的说就是程序对接受的输入数据没有进行有效的检测导致错误,后果可能造成程序崩溃或者执行攻击者的命令,详细的资料可以看unsecret.org的漏洞利用栏目 。
缓冲区溢出的概念
堆栈溢出(又称缓冲区溢出)攻击是最常用的黑客技术之一。我们知道,UNIX本身以及其上的许多应用程序都是用C语言编写的,C语言不检查缓冲区的边界。在某些情况下,如果用户输入的数据长度超过应用程序给定的缓冲区,就会覆盖其他数据区。这称作“堆栈溢出或缓冲溢出”。
一般情况下,覆盖其他数据区的数据是没有意义的,最多造成应用程序错误。但是,如果输入的数据是经过“黑客”精心设计的,覆盖堆栈的数据恰恰是黑客的入侵程序代码,黑客就获取了程序的控制权。如果该程序恰好是以root运行的,黑客就获得了root权限,然后他就可以编译黑客程序、留下入侵后门等,实施进一步地攻击。按照这种原理进行的黑客入侵就叫做“堆栈溢出攻击”。
为了便于理解,我们不妨打个比方。缓冲区溢出好比是将十磅的糖放进一个只能装五磅的容器里。一旦该容器放满了,余下的部分就溢出在柜台和地板上,弄得一团糟。由于计算机程序的编写者写了一些编码,但是这些编码没有对目的区域或缓冲区——五磅的容器——做适当的检查,看它们是否够大,能否完全装入新的内容——十磅的糖,结果可能造成缓冲区溢出的产生。如果打算被放进新地方的数据不适合,溢得到处都是,该数据也会制造很多麻烦。但是,如果缓冲区仅仅溢出,这只是一个问题。到此时为止,它还没有破坏性。当糖溢出时,柜台被盖住。可以把糖擦掉或用吸尘器吸走,还柜台本来面貌。与之相对的是,当缓冲区溢出时,过剩的信息覆盖的是计算机内存中以前的内容。除非这些被覆盖的内容被保存或能够恢复,否则就会永远丢失。
在丢失的信息里有能够被程序调用的子程序的列表信息,直到缓冲区溢出发生。另外,给那些子程序的信息——参数——也丢失了。这意味着程序不能得到足够的信息从子程序返回,以完成它的任务。就像一个人步行穿过沙漠。如果他依赖于他的足迹走回头路,当沙暴来袭抹去了这些痕迹时,他将迷失在沙漠中。这个问题比程序仅仅迷失方向严重多了。入侵者用精心编写的入侵代码(一种恶意程序)使缓冲区溢出,然后告诉程序依据预设的 *** 处理缓冲区,并且执行。此时的程序已经完全被入侵者操纵了。
入侵者经常改编现有的应用程序运行不同的程序。例如,一个入侵者能启动一个新的程序,发送秘密文件(支票本记录,口令文件,或财产清单)给入侵者的电子邮件。这就好像不仅仅是沙暴吹了脚印,而且后来者也会踩出新的脚印,将我们的迷路者领向不同的地方,他自己一无所知的地方。
缓冲区溢出的处理
你屋子里的门和窗户越少,入侵者进入的方式就越少……
由于缓冲区溢出是一个编程问题,所以只能通过修复被破坏的程序的代码而解决问题。如果你没有源代码,从上面“堆栈溢出攻击”的原理可以看出,要防止此类攻击,我们可以:
1、开放程序时仔细检查溢出情况,不允许数据溢出缓冲区。由于编程和编程语言的原因,这非常困难,而且不适合大量已经在使用的程序;
2、使用检查堆栈溢出的编译器或者在程序中加入某些记号,以便程序运行时确认禁止黑客有意造成的溢出。问题是无法针对已有程序,对新程序来讲,需要修改编译器;
3、经常检查你的操作系统和应用程序提供商的站点,一旦发现他们提供的补丁程序,就马上下载并且应用在系统上,这是更好的 *** 。但是系统管理员总要比攻击者慢一步,如果这个有问题的软件是可选的,甚至是临时的,把它从你的系统中删除。举另外一个例子,你屋子里的门和窗户越少,入侵者进入的方式就越少。
黑客主要先从微软漏洞公布表上或者0days上找到漏洞,再根据漏洞编写溢出程序(好多都自带扫描功能)包括本地提权溢出,远程提权溢出.编好后,先用那个扫描一下有漏洞的主机,然后再用它溢出获得权限,控制目标主机.
更简单的说法是,杯子(内存区域)满了,可茶壶(程序)还在往里倒水(垃圾数据通常为NULL数值),结果水就流出来了,流到外面(其他程序的内存区域)弄湿了桌子还有可能流到电器中造成危险(溢出攻击),就是这样
缓冲区溢出攻击
http://baike.baidu.com/view/700134.htm
溢出漏洞
http://baike.baidu.com/view/164019.htm
如果把一加仑的水注入容量为一品脱的容量中,水会四处冒出,这时你就会充分理解溢出的含义。同样的道理,在计算机内部,如果你向一个容量有限的内存空间里存储过量数据,这时数据也会溢出存储空间。输入数据通常被存放在一个临时空间内,这个临时存放空间被称为缓冲区,缓冲区的长度事先已经被程序或者*作系统定义好了。
何为缓冲区溢出
缓冲区溢出是指当计算机程序向缓冲区内填充的数据位数超过了缓冲区本身的容量。溢出的数据覆盖在合法数据上。理想情况是,程序检查数据长度并且不允许输入超过缓冲区长度的字符串。但是绝大多数程序都会假设数据长度总是与所分配的存储空间相匹配,这就为缓冲区溢出埋下隐患。*作系统所使用的缓冲区又被称为堆栈,在各个*作进程之间,指令被临时存储在堆栈当中,堆栈也会出现缓冲区溢出。
当一个超长的数据进入到缓冲区时,超出部分就会被写入其他缓冲区,其他缓冲区存放的可能是数据、下一条指令的指针,或者是其他程序的输出内容,这些内容都被覆盖或者破坏掉。可见一小部分数据或者一套指令的溢出就可能导致一个程序或者*作系统崩溃。
溢出根源在于编程
缓冲区溢出是由编程错误引起的。如果缓冲区被写满,而程序没有去检查缓冲区边界,也没有停止接收数据,这时缓冲区溢出就会发生。缓冲区边界检查被认为是不会有收益的管理支出,计算机资源不够或者内存不足是编程者不编写缓冲区边界检查语句的理由,然而摩尔定律已经使这一理由失去了存在的基础,但是多数用户仍然在主要应用中运行十年甚至二十年前的程序代码。
缓冲区溢出之所以泛滥,是由于开放源代码程序的本质决定的。一些编程语言对于缓冲区溢出是具有免疫力的,例如Perl能够自动调节字节排列的大小,Ada95能够检查和阻止缓冲区溢出。但是被广泛使用的C语言却没有建立检测机制。标准C语言具有许多复制和添加字符串的函数,这使得标准C语言很难进行边界检查。C++略微好一些,但是仍然存在缓冲区溢出。一般情况下,覆盖其他数据区的数据是没有意义的,最多造成应用程序错误,但是,如果输入的数据是经过“黑客”或者病毒精心设计的,覆盖缓冲区的数据恰恰是“黑客”或者病毒的入侵程序代码,一旦多余字节被编译执行,“黑客”或者病毒就有可能为所欲为,获取系统的控制权。
溢出导致“黑客”病毒横行
缓冲区溢出是病毒编写者和特洛伊木马编写者偏爱使用的一种攻击 *** 。攻击者或者病毒善于在系统当中发现容易产生缓冲区溢出之处,运行特别程序,获得优先级,指示计算机破坏文件,改变数据,泄露敏感信息,产生后门访问点,感染或者攻击其他计算机。
2000年7月,微软Outlook以及Outlook Express被发现存在漏洞能够使攻击者仅通过发送邮件就能危及目标主机安全,只要邮件头部程序被运行,就会产生缓冲区溢出,并且触发恶意代码。2001年8月,“红色代码”利用微软IIS漏洞产生缓冲区存溢出,成为攻击企业 *** 的“罪魁祸首”。2003年1月,Slammer蠕虫利用微软SQL漏洞产生缓冲区溢出对全球互联网产生冲击。而在近几天,一种名为“冲击波”的蠕虫病毒利用微软RPC远程调用存在的缓冲区漏洞对Windows 2000/XP、Windows Server 2003进行攻击,波及全球 *** 系统。据CERT安全小组称,*作系统中超过50%的安全漏洞都是由内存溢出引起的,其中大多数与微软技术有关,这些与内存溢出相关的安全漏洞正在被越来越多的蠕虫病毒所利用。
缓冲区溢出是目前导致“黑客”型病毒横行的主要原因。从红色代码到Slammer,再到日前爆发的“冲击波”,都是利用缓冲区溢出漏洞的典型。缓冲区溢出是一个编程问题,防止利用缓冲区溢出发起的攻击,关键在于程序开发者在开发程序时仔细检查溢出情况,不允许数据溢出缓冲区。此外,用户需要经常登录*作系统和应用程序提供商的网站,跟踪公布的系统漏洞,及时下载补丁程序,弥补系统漏洞。
要成为顶级黑客要看什么书(如何成为顶级黑客)(tiechemo.com)一直致力于黑客(HACK)技术、黑客QQ群、信息安全、web安全、渗透运维、黑客工具、找黑客、黑客联系方式、24小时在线网络黑客...
长泽雅美再曝父女恋...
需求指出的是,以上趋势仅依据监控数据,实践许多用户是黑客经过服务器进犯浸透侵略内网后投进的勒索病毒,亦或用户终端不联网经过内网其他机器感染的勒索病毒,这些景象下是无法监控到数据的。 本文就让我议论Ar...
永陵位于辽宁新宾县永陵镇,建于明万历二十六年(1598)。陵区占地约12000平方米,依山面水。陵内葬有清太祖努尔哈赤的远祖盖特穆、曾祖福满、祖父昌安。 永陵没什么太好的宾馆福满楼要是能住那价格比较高...
宝宝别哭,那麼爱你的我如何狠心放弃你,我讲过如果你回首我一直在你身边,我也在附近一直看你,见到你哭,我心好痛,小宝宝给油,妈妈爱你针对断奶后实际上感叹数最多的并不是小宝宝只是妈妈,下边的我为大伙儿共享...
每日要闻微信聊天记录怎么恢复?现在,微 信已经成为了我们生 活和工作中的小帮手,不论是日常的聊天, 语音/视频通话,还是资料的传输,图片的发送,我们都可以依靠它完成。但在使用的过程中,难免会出现一些意...