Trao đổi với tôi

www.hdphim.info OR www.chepphimhdtv.com

12/19/16

[System Info], [MASM] Processless Applications - Remotethreads on Microsoft* Windows 2000, XP and 2003

Processless Applications - Remotethreads on
Microsoft* Windows 2000, XP and 2003
Thomas Kruse
Universitas Virtualis
Tranz by Benina (7/2008)


Tôi (benina) có coding một chương trình theo dõi việc gắm đĩa USB vào máy tính dựa trên bài viết này: Source usb_dog

Abstract

The shown technique is able to run on all Windows operation systems. In order to avoid virus creation on it’s best, this technique is shown for W2K/XP/2K3 only. NT4 systems doesnt know several of the used API’s, also it is possible to rewrite them. Non NT-based systems need other techniques to detect the correct process to inject the code.
This essay was created while searching for new software protections to make ”crackers life” even harder. Based on ”WatchDog theory” - another way to protect applications - the idea is to create threads outside the main application which are able to continue workflow also if the main application terminates. This essay will show up a way to display a messagebox from process ”Explorer.Exe”, which is available on all OS.
The created application is ”processless” in that way that the main application becomes terminated after creating the external thread.
The shown source code is in Microsoft Assembler style (MASM [3]).

Keywords: Microsoft Operating Systems, Software Protection, Assembly Programming, System Internals
The author Thomas Kruse has his main research focus on operating-system independent code optimising and software-protection development. He is Associate
Editor of Assembly-Programming-Journal and CodeBreakers-Journal.

I. Introduction

Trước khi chúng ta bắt đầu cài đặt ứng dụng của chúng ta , chúng ta cần vài kiến thức căn bản về processes và threads. Và như thế nào chúng tương tác với nhau. Bất cứ khi nào một ứng dụng thưc thi, nó cài đặt một process và thread chính của nó. Ứng dụng này có thể run cho đến khi:

• process được kết thúc (terminated)
• Số các threads of process của nó là NULL

Trong 2 điều kiện trên, điều kiện sau cùng chỉ ra cho ta một điểm mới: chúng ta có thể cài đặt hơn một thread cho một ứng dụng. Và kỹ thuật này được sử dụng cho các ứng dụng “giám sát bảo vệ” WatchDog.
Cho ví dụ, các system processes có nhiều threads đang chạy bên trong một process. Cũng vậy nếu một thread kết thúc terminates, thì process vẫn đang chạy. Và thêm điều này nữa, các threads mới có thể được cài đặt khi process đang running.
Nhưng có một điểm khác mà chúng ta cần kiểm tra: Khi debugging[2] một ứng dụng mà nó cài đặt hơn một thread (e.g. WatchDog protected app), nó có thể trace thread assembler code! Lý do ở đây thật là đơn giản:

• mỗi created thread được cấp phát memory bên trong vùng nhớ calling process memory area
• calling process memory area có khả năng reading

Memory mới có thể được cho bởi sử dụng hàm VirtualAlloc[1] API từ KERNEL32.DLL, mà hàm này có trên tất cả các OS. Nếu chúng ta muốn làm cho việc crack của các crackers khó hơn, thì chúng ta phải “rời” calling process memory area của chúng ta và cài đặt các threads bên ngòai ứng dụng của chúng ta.
Điều này có thể được thực hiện bởi sử dụng VirtualAllocEx[1].

II. General Idea

Ý tưởng cài đặt một ứng dụng được ”better protected” dựa trên “lỗi hỏng” đã chỉ ra trước đó. Chúng ta cần vài name conventions để hiểu tiến trình công việc:

carrier application: ứng dụng được thực thi. Nó cài đặt remote thread, inject code và terminates chính nó.
target application: ứng dụng mà nó nhận một new thread. Nó tồn tại sẳn khi carrier starts.

Chúng ta phải có một cái nhìn tổng quát về tiến trình công việc :

 carrier application                      target application
-------------------                       ------------------
- đang running
- bắt đầu thực thi
- tìm ứng dụng target
- ban cấp truy xuất đến ứng dụng target   - return access rights
- cấp phát memory trong target area       - return memory address
- inject code trong target memory area
- create remote thread trong target app   - gia tăng threads
- resume remote thread                    - new thread executes*
- terminate kết thúc chính nó**

Khi thread thực thi, nó chứa code, nhưng ko biết chính xác addr của các hàm API function calls. Có 2 cách để tránh điều này:

• giải quyết function calls qua carrier application
• giải quyết function calls qua target application

** Carrier application và các threads của nó bị khử. Nhưng created thread dựa trên ứng dụng target. Trong cas đó, thread này ko bị ảnh hưởng khi kết thúc carrier (mang,vác,chở) application!

III. Resolving API calls

Chủ đề này nghe qua tưởng khó, nhưng ko phải vậy. Một lần nữa chúng ta cần biết một kỹ thuật mà nó dựa trên nền hệ điều hành NT sử dụng để ”sort” dynamic link librarys trong memory.
Khi một remote thread thực thi, nó có thể truy xuất Process Environment Block (PEB) of process chính của nó. Trong trường hợp của chúng ta, nó có thể truy xuất PEB of our target application. Và mỗi PEB chứa thành phần của nó :

• InLoadOrderModuleList
• InMemoryOrderModuleList
• InInitializationOrderModuleList

Hai thành phần đầu tiên chứa tên ứng dụng của nó như first module, theo sau bởi DLL mà nó cần (and accessable ones). Cuối cùng điều quan tâm hơn. NT-based operation systems cần  NTDLL.DLL. DLL này là thành phần đầu tiên trong InInitializationOrderModuleList. Và module kế tiếp là: KERNEL32.DLL! Một cách chính xác chúng ta cần cái gì, bởi vì  library này chứa các hàm API functions có 2 hàm calls quan trọng: GetProcAddress[1] và LoadLibraryA[1]. Bằng cách giải quyết hai hàm gọi này chúng ta có thể import những gì mà chúng ta muốn. Nhưng ở đâu chứa các addr cần giải quyết?.

IV. Preparing memory areas

Chúng ta ở đâu có thể giải quyết các API calls cần thiết, nhưng chúng ta cần tìm một cách để chứa chúng. Có một cách là chứa chúng trên stack, cách khác để cài đặt một vùng nhớ riêng biệt cho data of thread chúng ta. Nhưng bởi sử dụng kỹ thuật thứ hai, chúng ta cần nói cho remote thread của chúng ta ở đâu để tìm data. Trước tiên chúng ta hảy nhìn vào hàm API function CreateRemoteThread[1]:

HANDLE CreateRemoteThread(
HANDLE hProcess,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId
);

lpStartAddress: Trỏ đến app - defined function of type
LPTHREAD START ROUTINE được thực thi bởi thread và miêu tả starting address of thread trong remote process. Hàm phải hiện có trong remote process.
lpParameter: Chỉ định một giá trị 32-bit đơn truyền cho hàm thread function.

Nếu thread chúng ta thực thi, lpParameter là vẫn trên stack. Có thể qua phần code sau của injected threadcode của chúng ta:

; -- access the given parameter from Create(Remote)Thread
mov eax,dword ptr [ebp+0Ch]   ; get parameter
push eax                      ; store this value on stack

Chúng ta có thể cắt phần data và code ra trong hai vùng nhớ. Chúng ta đơn giản sử dụng cập API VirtualAllocEx :

• cài đặt vùng data trong target application
• lưu chứa memory address, chúng ta cần nó như lpParameter cho CreateRemoteThread
• inject data vào trong data area
• cài đặt code area trong target application
• lưu chứa memory address, chúng ta cần nó như là lpStartAddress
• inject code vào trong code area
• cài đặt remote thread trong trạng thái suspended mode

Bởi sử dụng hai vùng nhớ - cho code và data – chúng ta ở đâu cài đặt address independent code trong suốt quá trịnh phát triển!
Chúng ta rời carrier application process memory range và có – trong suốt quá trình khởi động của thread trong target – không có ý nghĩa về address ranges trong process app target của chúng ta. Và bằng cách sử dụng kỹ thuật này, code là target independent (độc lập), regardless (bất chấp) which application is affected.

V. Thread Data Part

Phần data được cài đặt qua VirtualAllocEx và WriteProcessMemory[1] trong process memory range of our target application. Bởi sử dụng VirtualAllocEx, chúng ta có thể ở đâu đặt tên cho target process trong first parameter of this API call.
Khi debugging carrier application, vùng nhớ này ko dễ trace, bởi vì nó dựa trên process khác và debugger ko biết vùng nhớ này. Cho ví dụ, chúng ta sử dụng phần data sau đây:

.data
_sizeofInject dd offset _inject_end - offset _inject
_sizeofData dd offset _ENDOFDATA - offset _dwThreadID
_dwThreadID dd 0
_dwThreadHandle dd 0
_lpCode dd 0
_lpData dd 0
_lpRsrc dd 0
_dwExitCode dd 0
_Kernel32 dd 0
_User32 dd 0
_GetProcAddress dd 0
_GetExitCodeThread dd 0
_ExitThread dd 0
_szMessageBoxA db "MessageBoxA",0
_szExitThread db "ExitThread",0
_szExitCodeThread db "GetExitCodeThread",0
_szText db "Hello from Thread!",0
_szCaption db "Thread:",0
_ENDOFDATA dd 0

Hai cái đầu tiên và thành phần sau cùng KHÔNG thực hiện. Chúng chỉ mô tả size để inject. Phần data để inject bắt đầu với dwThreadID và kết thúc với szCaption như là thành phần sau cùng. Phần data chứa nhiều placeholders (chổ chứa) cho các hàm API function calls cần giải quyết và strings (for MessageBox call and additional API functions to resolve). Có nhiều placeholders mà nó ko được sử dụng trong ví dụ của chúng ta, nhưng phần data này cũng được prepared cho các further projects.

VI. Thread Code Part

Chúng ta có thể tưởng tượng tiến trình làm việc của thread code bằng cách phân tích phần data đã cho:

• resolve GetProcAddress API from KERNEL32.DLL
• resolve GetExitCodeThread API from KERNEL32.DLL
• resolve ExitThread API from KERNEL32.DLL
• resolve MessageBoxA API from User32.DLL
• prepare MessageBoxA parameters on stack
• show the messagebox
• prepare GetExitCodeThread parameter on stack ( dwThreadHandle)
• get the exitcode
• exit the thread (thread terminates, process continue!)

VII. Carrier Application

Thread code được sửa chửa là vô dụng với carrier application. Chúng ta hảy xem nó làm gì:

• check the operating system (do not execute on 9X)
• resolve USER32.DLL base address for our thread (*)
• create a snapshot of running processes
• find the target application (explorer.exe)
• if not found, terminate with error message
• store target processID
• free snapshot
• grant access to target application via OpenProcess[1]
• store the target process handle
• create two memory areas via VirtualAllocEx
• create a remote thread in suspended mode
• inject the parts via WriteProcessMemory
• resume the remote thread to become executed via ResumeThread[1]
• close the target process handle
• terminate the carrier via ExitProcess[1]

* Người đọc nào mà hiểu được thread code được chỉ ra có thể thấy trong phần Section IX, mà base address of USER32.DLL ko được giải quyết bởi thread code của chúng ta! Bạn cần thay đổi nó để run được. Hiểu tiến trình công việc này chúng ta có thể create carrier application phần tổng quát. Chứa những dữ liệu cần thiết và các hàm được included và được chỉ ra trong phần Section X. Phần code được chỉ ra trong phần Section XI thực hiện chính xác những gì chúng ta muốn làm. Và code này có thể được sử dụng như một template tổng quát để cài đặt các ứng dụng như vậy. Nếu bạn muốn sử dụng resources later on, đơn giản là cài đặt memory region khác bằng cách sử dụng VirtualAllocEx và chứa memory address bên trong thread data ( lpRsrc).

VIII. Conclusions

Kỷ thuật chỉ ra sử dụng một target mà nó thực thi injected code. Nhưng nó cũng có thể :

• inject code trong KHÁC target app và truyền thông giữa các targets này sử dụng kỷ thuật từ carrier application để truy xuất một process
• DUYỆT qua từ một target application đến target khác, destroying itself sau khi inject các phần cần thiê1t cho new target bởi sử dụng polymorphic code
• WALK from one target application to another, leaving itself intact (nguyên vẹn) and create ”splitted” applications which communicate together
• INTERACT (tương tác) with still running carrier application as kind of ”external” WatchDog from target application(s)
• KẾT HỢP tất cả các ví dụ chỉ ra ở trên.

Với sự kết hợp các kỹ thuật bảo vệ software đang được sử dụng thì có thể tránh ”readable” thread data. Bằng cách sử dụng polymorphic code và crypto algorythms thì kỹ thuật reversing approach trở nên gần như ko thể.

References

[1] Microsoft Corporation, Microsoft Developer Network, http://msdm.microsoft.com
[2] Yuschuk, O., Olly Debugger, http://home.t-online.de/home/ollydbg
[3] Hutchenson, S., MASM V8, http://www.masmforum.com

IX. SourceCode Thread.inc

Chúng ta sử dụng nhìêu cấu trúc cho việc giải quyết export address table từ KERNEL32.DLL. Các cấu trúc này được thay đổi vào trong correct code trong suốt quá trình biên dịch và trong cas đó, chúng ta ko cần làm life harder than it is.

;-- thread.inc (data and code)
.data
_sizeofInject dd offset _inject_end - offset _inject
_sizeofData dd offset _ENDOFDATA - offset _dwThreadID
_dwThreadID dd 0
_dwThreadHandle dd 0
_lpCode dd 0
_lpData dd 0
_lpRsrc dd 0
_dwExitCode dd 0
_Kernel32 dd 0
_User32 dd 0
_GetProcAddress dd 0
_GetExitCodeThread dd 0
_ExitThread dd 0
_szMessageBoxA db "MessageBoxA",0
_szExitThread db "ExitThread",0
_szExitCodeThread db "GetExitCodeThread",0
_szText db "Hello from Thread!",0
_szCaption db "Thread:",0
_ENDOFDATA dd 0

.code
_inject: ; start offet of code to inject
; -- access the given parameter from Create(Remote)Thread
mov eax,dword ptr [ebp+0Ch] ; get parameter
push eax ; store this value on stack
; resolve the kernel32 base via PEB (NT-based!)
mov eax,7FFDF00Ch ; pointer to PEB_LDR
mov eax,[eax]
add eax,1Ch ; pointer to InInitOrder_First
mov eax,[eax] ; NTDLL.DLL InitOrder_Next
mov eax,[eax] ; K32.dll InitOrder_Next
add eax,8h ; pointer to base address
mov eax,[eax] ; get the base addess
mov ebx,[esp] ; get base data
add ebx,18h ; kernel32 address place
mov [ebx],eax ; store kernel32 base
mov ebx,eax ; to ebx
; -- GetProcAddress in another style
push edi ; store edi
push esi ; store esi
push ebp ; store ebp
push edx ; store edx
mov eax,ebx ; kernel32
mov ebp,eax ; ebp becomes base address
assume eax: ptr IMAGE_DOS_HEADER
add eax,[eax].e_lfanew
assume eax:ptr IMAGE_NT_HEADERS
mov edi,[eax].OptionalHeader.DataDirectory[0].VirtualAddress
add edi,ebp ; add the base value
assume edi:ptr IMAGE_EXPORT_DIRECTORY
mov esi,[edi].AddressOfNames
add esi,ebp ; add the base value
xor edx,edx ; clear edx
assume eax:nothing ; avoid errors
_loopstart:
mov eax,[esi]
add eax,ebp ; add the base value
cmp word ptr [eax+0Ch],"ss"
jne _nextloop
cmp dword ptr [eax+04h], "Acor"
jne _nextloop
cmp dword ptr [eax+00h], "PteG"
jne _nextloop
cmp dword ptr [eax+08h], "erdd"
jne _nextloop
mov eax,[edi].AddressOfNameOrdinals
add eax,ebp ; add the base value
movzx ebx,word ptr [edx*2+eax]; get ordinal
mov eax,[edi].AddressOfFunctions
add eax,ebp ; add the base value
mov ebx,[ebx*4+eax]
add ebx,ebp ; ebx holds value of function
jmp _found ; quit searching
_nextloop:
add esi,4
inc edx
cmp edx,[edi].NumberOfNames
jne _loopstart
_found:
assume edi:nothing ; avoiding errors
pop edx ; restore edx
pop ebp ; restore ebp
pop esi ; restore esi
pop edi ; restore edi
mov eax,[esp] ; get base data
add eax,20h ; GetProcAddress placeholder
mov [eax],ebx ; store API address
mov eax,[esp] ; init eax with base data
; -- resolve all needed API’s for this thread
mov ebx,[eax+18h] ; base address kernel32
mov edx,[eax+20h] ; function GetProcAddess
push eax ; store base data on stack
add dword ptr [esp],38h ; pointer to ExitThread String
push ebx ; the kernel32 base
call edx ; call GetProcAddress
xchg eax,ebx
pop eax ; restore data base
add eax,28h ; placeholder of ExitThread
mov dword ptr [eax],ebx ; store the resolved address
sub eax,28h ; restore the original data base
push eax ; store it on stack
mov ebx,[eax+18h] ; base address kernel32
mov edx,[eax+20h] ; function GetProcAddess
push eax ; store base data on stack
add dword ptr [esp],43h ; GetExitCodeThread String
push ebx ; the kernel32 base
call edx ; call GetProcAddress
xchg eax,ebx
pop eax ; restore data base
add eax,24h ; placeholder of ExitThread
mov dword ptr [eax],ebx ; store the resolved address
sub eax,24h ; restore the original data base
push eax ; store it on stack
mov ebx,[eax+1ch] ; base address user32
mov edx,[eax+20h] ; function GetProcAddess
push eax ; store base data on stack
add dword ptr [esp],2ch ; pointer to MessageBoxA String
push ebx ; the user32 base
call edx ; call GetProcAddress
xchg eax,ebx
pop eax ; restore data base
add eax,1ch ; placeholder MessageBoxA (User32)
mov dword ptr [eax],ebx ; store the resolved address
sub eax,1ch ; restore the original data base
; -- start visible "action" inside the created thread
push eax ; store data base
mov ebx,eax ; ebx becomes data base
mov edx,[eax+1Ch] ; function MessageBoxA
add ebx,68h ; pointer to caption
push 0 ; MB_OK
push ebx ; caption
sub ebx,13h ; pointer to text
push ebx ; text
push 0 ; handle
call edx ; MessageBoxA
pop eax ; restore data base/correct stack!
; -- final cleanup and destroying the created thread
push eax ; store data base
mov ebx,eax
add ebx,14h ; pointer to ExitCode
push ebx ; address to recieve the ExitCode
sub ebx,10h ; pointer to ThreadHandle
push dword ptr[ebx]
add ebx,20h ; pointer to GetExitCodeThread
call dword ptr[ebx] ; GetExitCodeThread
xchg eax,ebx
pop eax ; restore data base
mov ebx,eax
add ebx,14h ; pointer to ExitCode
push dword ptr[ebx] ; ExitCode for this thread
add ebx,14h ; pointer to ExitThread
call dword ptr[ebx] ; ExitThread

_inject_end: ; end offset of code to inject

X. SourceCode inject.inc

; -- inject.inc
.386 ; minimum required CPU
.model flat,stdcall ; win 32 app
option casemap:none ; case sensitive
include windows.inc ; stuff we need
incboth macro incl ; macro for less typing
include incl.inc
includelib incl.lib
endm
incboth kernel32 ; for kernel32 API’s
incboth user32 ; for user32 API’s
include thread.inc ; thread related data
.data
szErrorText db "Process EXPLORER.EXE not found",0
szErrorOS db "You need an NT-based OS!",0
szErrorCaption db "Error occured:",0
szExplorer db "explorer.EXE",0
szUser32 db "user32.dll",0
.data?
hInstance dd ? ; application instance handle
_myProcessID dd ? ; resolved process ID
_myProcessHandle dd ? ; resolved process handle
_BytesWritten dd ? ; for WriteProcessMemory
hSnapShot dd ? ; snapshot handle
myProcess PROCESSENTRY32 <>

XI. SourceCode inject.asm

; -- inject.asm
include inject.inc ; additional data and includes
.code
start: ; application entry point
; -- carrier application
invoke GetModuleHandle,NULL ; get application module handle
mov hInstance,eax ; and store it
assume fs:nothing ; needed for MASM
mov eax,fs:[18h] ; get TEB self pointer
mov ebx,fs:[30h] ; get PEB pointer
.if eax!=7FFDE000h || ebx!=7FFDF000h ; NT check
invoke MessageBox,NULL,addr szErrorOS,addr szErrorCaption,MB_OK
jmp _exitApp
.endif
invoke LoadLibrary,addr szUser32
mov _User32,eax
invoke FreeLibrary,_User32
invoke CreateToolhelp32Snapshot, TH32CS_SNAPALL, 0
mov hSnapShot, eax ; store the snapshot handle
mov myProcess.dwSize, sizeof myProcess
invoke Process32First,hSnapShot, ADDR myProcess
.while eax
lea eax,myProcess.szExeFile
lea esi,szExplorer ; the name to search
invoke lstrcmpi,eax,esi ; compare both strings
.if eax==0 ; if the same...
push myProcess.th32ProcessID
pop _myProcessID ; get the process ID and
jmp @F ; leave search routine
.else
invoke Process32Next,hSnapShot, ADDR myProcess
.endif
@@:
.endw
invoke CloseHandle,hSnapShot ; close snapshot handle
mov eax,_myProcessID ; get the process ID
test eax,eax ; is there an ID
jne _goOn ; if so, continue
invoke MessageBox,NULL,addr szErrorText,\
addr szErrorCaption, MB_OK
jmp _exitApp ; leave application
_goOn:
invoke OpenProcess,PROCESS_ALL_ACCESS,NULL,_myProcessID
mov _myProcessHandle,eax ; store the process handle
; -- create two mem parts: one for code, one for data
invoke VirtualAllocEx,_myProcessHandle,NULL,1000h,MEM_COMMIT,\
PAGE_EXECUTE_READWRITE
mov _lpCode,eax ; store code base in thread data
invoke VirtualAllocEx,_myProcessHandle,NULL,100h,MEM_COMMIT,\
PAGE_EXECUTE_READWRITE
mov _lpData,eax ; store data base in thread data
; -- create the thread in suspended mode!
; -> the 4th (here: _lpData) parameter is important; it
; guarantees an memory independent inject code...
invoke CreateRemoteThread,_myProcessHandle,NULL,NULL,_lpCode,\
_lpData, CREATE_SUSPENDED,\
addr _dwThreadID
mov _dwThreadHandle,eax ; store handle in thread data
; -- write code section
invoke WriteProcessMemory,_myProcessHandle,_lpCode,\
addr _inject, _sizeofInject,\
addr _BytesWritten
; -- write data section
invoke WriteProcessMemory,_myProcessHandle,_lpData,\
addr _dwThreadID, _sizeofData,\
addr _BytesWritten
invoke ResumeThread,_dwThreadHandle ; start the thread
invoke CloseHandle,_myProcessHandle ; close process handle
_exitApp:
invoke ExitProcess,NULL ; exit application

end start ; end of application code section




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;          The End                ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

XII. Phần của người dịch:

Phần code sau đây mà benina chỉnh sửa để app running

1.File inject.Asm

; -- inject.asm

include inject.inc                              ; additional data and includes

.code
start:                                          ; application entry point

; ---------------------------------- carrier application --------------------------------
invoke GetModuleHandle,NULL                     ; get application module handle
mov hInstance,eax                               ; and store it

assume fs:nothing                               ; needed for MASM
mov eax,fs:[18h]                          ; get TEB self pointer
mov ebx,fs:[30h]                          ; get PEB pointer

comment /* phan nay nen bo
.if eax!=7FFDE000h || ebx!=7FFDF000h                  ; NT check
invoke MessageBox,NULL,addr szErrorOS,addr szErrorCaption,MB_OK
jmp _exitApp
.endif
*/

invoke LoadLibrary,addr szUser32
mov _User32,eax
invoke FreeLibrary,_User32

invoke CreateToolhelp32Snapshot, TH32CS_SNAPALL, 0
mov hSnapShot, eax                              ; store the snapshot handle

mov myProcess.dwSize, sizeof myProcess
invoke Process32First,hSnapShot, ADDR myProcess

.while eax
      lea eax,myProcess.szExeFile
      lea esi,szExplorer                        ; the name to search
      invoke lstrcmpi,eax,esi                   ; compare both strings
      .if eax==0                          ; if the same...
      push myProcess.th32ProcessID
      pop _myProcessID                    ; get the process ID and
      jmp @F                                    ; leave search routine
      .else
      invoke Process32Next,hSnapShot, ADDR myProcess
      .endif
      @@:
.endw

invoke CloseHandle,hSnapShot                    ; close snapshot handle
mov eax,_myProcessID                            ; get the process ID

test eax,eax                                    ; is there an ID
jne _goOn                                 ; if so, continue

invoke MessageBox,NULL,addr szErrorText,\
              addr szErrorCaption, MB_OK
jmp _exitApp                                    ; leave application

_goOn:

invoke OpenProcess,PROCESS_ALL_ACCESS,NULL,_myProcessID
mov _myProcessHandle,eax                        ; store the process handle

; -------------------- create two mem parts: one for code, one for data ---------------

invoke VirtualAllocEx,_myProcessHandle,NULL,1000h,MEM_COMMIT,\
                  PAGE_EXECUTE_READWRITE
mov _lpCode,eax                           ; store code base in thread data
invoke VirtualAllocEx,_myProcessHandle,NULL,100h,MEM_COMMIT,\
                  PAGE_EXECUTE_READWRITE
mov _lpData,eax                           ; store data base in thread data

; ---------------------------- create the thread in suspended mode! -------------------
; -> the 4th (here: _lpData) parameter is important; it
; guarantees an memory independent inject code...
;--------------------------------------------------------------------------------------

invoke CreateRemoteThread,_myProcessHandle,NULL,NULL,_lpCode,\
                                    _lpData, CREATE_SUSPENDED,\
                                    addr _dwThreadID
mov _dwThreadHandle,eax ; store handle in thread data

; ------------------------- write code section ----------------------------------------
invoke WriteProcessMemory,_myProcessHandle,_lpCode,\
                                    addr _inject, _sizeofInject,\
                                    addr _BytesWritten
; -------------------------- write data section ---------------------------------------
invoke WriteProcessMemory,_myProcessHandle,_lpData,\
                                    addr _dwThreadID, _sizeofData,\
                                    addr _BytesWritten
invoke ResumeThread,_dwThreadHandle                   ; start the thread
invoke CloseHandle,_myProcessHandle                   ; close process handle

_exitApp:
invoke ExitProcess,NULL                         ; exit application

end start                                 ; end of application code section



2.File inject.inc

; -- inject.inc
.386                                ; minimum required CPU
.model flat,stdcall                       ; win 32 app
option casemap:none                       ; case sensitive
include \masm32\include\windows.inc             ; stuff we need

incboth macro incl                        ; macro for less typing
include \masm32\include\incl.inc
includelib \masm32\lib\incl.lib
endm

incboth kernel32                    ; for kernel32 API’s
incboth user32                            ; for user32 API’s
include thread.inc                        ; thread related data

.data
szErrorText db "Process EXPLORER.EXE not found",0
szErrorOS db "You need an NT-based OS!",0
szErrorCaption db "Error occured:",0
szExplorer db "explorer.EXE",0
szUser32 db "user32.dll",0

.data?
hInstance dd ? ; application instance handle
_myProcessID dd ? ; resolved process ID
_myProcessHandle dd ? ; resolved process handle
_BytesWritten dd ? ; for WriteProcessMemory
hSnapShot dd ? ; snapshot handle
myProcess PROCESSENTRY32 <>


3.File thread.inc

;-- thread.inc (data and code)
.data

_sizeofInject dd offset _inject_end - offset _inject
_sizeofData dd offset _ENDOFDATA - offset _dwThreadID
_dwThreadID dd 0                    ;00h
_dwThreadHandle dd 0                      ;04h
_lpCode dd 0                              ;08h
_lpData dd 0                              ;0ch
_lpRsrc dd 0                              ;10h
_dwExitCode dd 0                          ;14h
_Kernel32 dd 0                            ;18h
_User32 dd 0                              ;1ch
_GetProcAddress dd 0                      ;20h
_GetExitCodeThread dd 0                   ;24h
_ExitThread dd 0                          ;28h
_szMessageBoxA db "MessageBoxA",0         ;2ch
_szExitThread db "ExitThread",0                 ;38h
_szExitCodeThread db "GetExitCodeThread",0      ;43h
_szText db "Hello from Thread!",0               ;55h
_szCaption db "Thread:",0                       ;68h
_ENDOFDATA dd 0


.code

_inject:                            ; start offet of code to inject

; -- access the given parameter from Create(Remote)Thread
mov eax,dword ptr [ebp+0Ch]         ; get parameter
push eax                            ; store this value on stack

assume fs:nothing

      @@find_kernel32:
            push esi
            xor eax, eax
            mov eax, fs:[eax+030h]
            test eax, eax
            js @@find_kernel32_9x
           
      @@find_kernel32_nt:
            mov eax, [eax + 0Ch]
            mov esi, [eax + 01ch]
            lodsd
            mov eax, [eax + 08h]
            jmp @@find_kernel32_finished
           
      @@find_kernel32_9x:
            mov eax, [eax + 034h]
            lea eax, [eax + 7ch]
            mov eax, [eax + 03ch]
           
      @@find_kernel32_finished:
            pop esi
;--------return eax is base kernel32---------------------------        

mov ebx,[esp]                       ; get base data
add ebx,18h                         ; kernel32 address place
mov [ebx],eax                       ; store kernel32 base

mov ebx,eax                         ; to ebx

; -- GetProcAddress in another style
push edi                            ; store edi
push esi                            ; store esi
push ebp                            ; store ebp
push edx                            ; store edx

mov eax,ebx                         ; kernel32
mov ebp,eax                         ; ebp becomes base address

assume eax: ptr IMAGE_DOS_HEADER
add eax,[eax].e_lfanew
assume eax:ptr IMAGE_NT_HEADERS
mov edi,[eax].OptionalHeader.DataDirectory[0].VirtualAddress
add edi,ebp                         ; add the base value
assume edi:ptr IMAGE_EXPORT_DIRECTORY
mov esi,[edi].AddressOfNames
add esi,ebp                         ; add the base value
xor edx,edx                         ; clear edx
assume eax:nothing                  ; avoid errors

_loopstart:
mov eax,[esi]
add eax,ebp                         ; add the base value
cmp word ptr [eax+0Ch],"ss"
jne _nextloop
cmp dword ptr [eax+04h], "Acor"
jne _nextloop
cmp dword ptr [eax+00h], "PteG"
jne _nextloop
cmp dword ptr [eax+08h], "erdd"
jne _nextloop
mov eax,[edi].AddressOfNameOrdinals
add eax,ebp                         ; add the base value
movzx ebx,word ptr [edx*2+eax]      ; get ordinal
mov eax,[edi].AddressOfFunctions
add eax,ebp                         ; add the base value
mov ebx,[ebx*4+eax]
add ebx,ebp                         ; ebx holds value of function
jmp _found                          ; quit searching

_nextloop:
add esi,4
inc edx
cmp edx,[edi].NumberOfNames
jne _loopstart

_found:
assume edi:nothing                  ; avoiding errors
pop edx                             ; restore edx
pop ebp                             ; restore ebp
pop esi                             ; restore esi
pop edi                             ; restore edi
mov eax,[esp]                       ; get base data
add eax,20h                         ; GetProcAddress placeholder
mov [eax],ebx                       ; store API address
mov eax,[esp]                       ; init eax with base data

; -- resolve all needed API’s for this thread
mov ebx,[eax+18h]                   ; base address kernel32
mov edx,[eax+20h]                   ; function GetProcAddess
push eax                            ; store base data on stack
add dword ptr [esp],38h             ; pointer to ExitThread String
push ebx                            ; the kernel32 base
call edx                            ; call GetProcAddress
xchg eax,ebx
pop eax                             ; restore data base
add eax,28h                         ; placeholder of ExitThread
mov dword ptr [eax],ebx             ; store the resolved address
sub eax,28h                         ; restore the original data base
push eax                            ; store it on stack
mov ebx,[eax+18h]                   ; base address kernel32
mov edx,[eax+20h]                   ; function GetProcAddess
push eax                            ; store base data on stack
add dword ptr [esp],43h             ; GetExitCodeThread String
push ebx                            ; the kernel32 base
call edx                            ; call GetProcAddress
xchg eax,ebx
pop eax                             ; restore data base
add eax,24h                         ; placeholder of ExitThread
mov dword ptr [eax],ebx             ; store the resolved address
sub eax,24h                         ; restore the original data base
push eax                            ; store it on stack
mov ebx,[eax+1ch]                   ; base address user32
mov edx,[eax+20h]                   ; function GetProcAddess
push eax                            ; store base data on stack
add dword ptr [esp],2ch             ; pointer to MessageBoxA String
push ebx                            ; the user32 base
call edx                            ; call GetProcAddress
xchg eax,ebx
pop eax                             ; restore data base
add eax,1ch                         ; placeholder MessageBoxA (User32)
mov dword ptr [eax],ebx             ; store the resolved address
sub eax,1ch                         ; restore the original data base

; -- start visible "action" inside the created thread
push eax                            ; store data base
mov ebx,eax                         ; ebx becomes data base
mov edx,[eax+1Ch]                   ; function MessageBoxA
add ebx,68h                         ; pointer to caption
push 0                              ; MB_OK
push ebx                            ; caption
sub ebx,13h                         ; pointer to text
push ebx                            ; text
push 0                              ; handle
call edx                            ; MessageBoxA
pop eax                             ; restore data base/correct stack!

; -- final cleanup and destroying the created thread
push eax                            ; store data base
mov ebx,eax
add ebx,14h                         ; pointer to ExitCode
push ebx                            ; address to recieve the ExitCode
sub ebx,10h                         ; pointer to ThreadHandle
push dword ptr[ebx]
add ebx,20h                         ; pointer to GetExitCodeThread
call dword ptr[ebx]                 ; GetExitCodeThread
xchg eax,ebx
pop eax                             ; restore data base
mov ebx,eax
add ebx,14h                         ; pointer to ExitCode
push dword ptr[ebx]                 ; ExitCode for this thread
add ebx,14h                         ; pointer to ExitThread
call dword ptr[ebx]                 ; ExitThread

_inject_end:                        ; end offset of code to inject

XIII. Phần code tương tự:

1.File InjectProcess.Asm

.386
.model flat, stdcall
option casemap:none


include kernel32.inc
include user32.inc
include WINDOWS.INC

includelib kernel32.lib
includelib user32.lib

;############################################################################################

include InjectProcess.Inc

;############################################################################################

.data
hSnapShot         dd 0
PrEntry                 PROCESSENTRY32 <>
BufferExe         db "explorer.exe"
pMap              dd 0
nbwr              dd 0
ThID              dd 0
hProcess          dd 0

;############################################################################################

.code
start:
;scan tout les process lancés
      invoke CreateToolhelp32Snapshot,TH32CS_SNAPPROCESS,NULL
      mov hSnapShot,eax

      mov PrEntry.dwSize,SIZEOF PROCESSENTRY32
      invoke Process32First,eax,addr PrEntry

      .while eax!=FALSE
            invoke lstrcmpi,addr PrEntry.szExeFile,addr BufferExe ;regarde s'il s'agit d'explorer.exe
            test eax,eax
            je InjectIT
            invoke Process32Next,hSnapShot,addr PrEntry ;si ce n'est pas explorer.exe alors on continue de scanner
      .endw

      jmp ErrorCannotBeFounded

      dwSize                  equ (offset EndCode - offset CodeToBeInj) ;taille du code à injecter
     
      InjectIT:
            invoke OpenProcess,PROCESS_ALL_ACCESS,FALSE,PrEntry.th32ProcessID
            test eax,eax
            je ErrorPr
            mov hProcess,eax

            invoke VirtualAllocEx,hProcess,NULL,dwSize,MEM_COMMIT,PAGE_EXECUTE_READWRITE ;alloue de la mémoire avec tous les accès dans explorer.exe
            test eax,eax
            je ErrorMem
            mov pMap,eax

            invoke WriteProcessMemory,hProcess,pMap,addr CodeToBeInj,dwSize,addr nbwr ;recopie le code dans explorer.exe
            test eax,eax
            je ErrorWr

            invoke CreateRemoteThread,hProcess,NULL,NULL,pMap,NULL,NULL,addr ThID ; lance notre code :D
            test eax,eax
            je ErrorThread

            invoke ExitProcess,0

;############################################################################################
;traitement des erreurs
ErrorThread:
      push MB_OK
      pushstr "Error"
      pushstr "Unable to launch remote thread"
      jmp WarnAndStop

ErrorCannotBeFounded:
      push MB_OK
      pushstr "Error"
      pushstr "Cannot opening process"
      jmp WarnAndStop

ErrorPr:
      push MB_OK
      pushstr "Error"
      pushstr "Cannot opening process"
      jmp WarnAndStop

ErrorMem:
      push MB_OK
      pushstr "Error"
      pushstr "Memory allocation failed"
      jmp WarnAndStop

ErrorWr:
      push MB_OK
      pushstr "Error"
      pushstr "Writing malicious code into process failed"
      jmp WarnAndStop

WarnAndStop:
      push NULL
      call MessageBox
      invoke ExitProcess,NULL

;############################################################################################

end start

2. File InjectProcess.Inc


;############################################################################################
GetKernelAddr                 PROTO
FindExport                    PROTO :DWORD,:DWORD
AdjustIfIsForwarded           PROTO :DWORD, :DWORD
GetKernelAddr                 PROTO

;############################################################################################

_LoadLibraryA     equ   0EC0E4E8Eh
_GetProcAddress   equ   07C0DFCAAh

;Macros
;#######################################################################
;récupère dans eax l'adresse de la fonction de la dll
GetProcAddr macro DllName,FuncName
      call GetKernelAddr
      invoke FindExport,eax,_LoadLibraryA
      pushstr DllName
      call eax    ; call LoadLibrary
           
      push eax
      call GetKernelAddr
      invoke FindExport,eax,_GetProcAddress
      pop ebx
      pushstr FuncName
      push ebx ;dll module
      call eax ;call GetProcAdress 
endm
pushstr macro a
      call @F
      db a,0
@@:
endm


.code
;####################################################################################### 
;####################################################################################### 
;code injecté dans explorer.exe

CodeToBeInj:
      GetProcAddr "user32.dll","MessageBoxA"
     
      push MB_OK
      pushstr "yuhu"
      pushstr "Thanh cong roi:)"
      push 0
      call eax

      ret
;####################################################################################### 
assume fs:nothing
GetKernelAddr proc
LOCAL KernelAddr:DWORD
      pushad
      @@find_kernel32:
            push esi
            xor eax, eax
            mov eax, fs:[eax+030h]
            test eax, eax
            js @@find_kernel32_9x
           
      @@find_kernel32_nt:
            mov eax, [eax + 0Ch]
            mov esi, [eax + 01ch]
            lodsd
            mov eax, [eax + 08h]
            jmp @@find_kernel32_finished
           
      @@find_kernel32_9x:
            mov eax, [eax + 034h]
            lea eax, [eax + 7ch]
            mov eax, [eax + 03ch]
           
      @@find_kernel32_finished:
            pop esi
            mov KernelAddr,eax
       popad
       mov eax,KernelAddr
    ret
GetKernelAddr endp
FindExport PROC KernelAddr:DWORD, HashFromAPI:DWORD

      @@find_function:
            pushad
            mov ebp, KernelAddr
            mov eax, [ebp + 03ch]         ; signature PE
            mov edx, [ebp + eax + 078h]   ; RVA export table
            add edx, ebp                        ; Export table address
            mov ecx, [edx + 018h]         ; ecx = nombre d'export de la DLL
            mov ebx, [edx + 020h]         ; ebx = RVA pointeur de nom
            add ebx, ebp                        ; ebx = pointeur de nom
           
      @@find_function_loop:
            jecxz @@find_function_finished
            dec ecx                                   ; dec nombre d'export
            mov esi, dword ptr [ebx + ecx * 4]  ; RVA string de la fonction
            add esi, ebp                        ; pointe sur la string de la fonction
           
      @@compute_hash:
            xor edi, edi
            xor eax, eax
            cld
           
      @@compute_hash_again:
            lodsb
            test al, al
            jz @@compute_hash_finished
            ror edi, 0dh
            add edi, eax
            jmp @@compute_hash_again
           
      @@compute_hash_finished:
     
      @@find_function_compare:
            mov eax, [esp+02ch];*
            cmp edi, eax ;HashFromAPI;
            jnz @@find_function_loop
           
            mov ebx, [edx + 024h]         ; ordinal table RVA
            add ebx, ebp                        ; pointeur vers ordinal table
            mov cx, word ptr[ebx + 2 * ecx]           ; cx = ordinal de la fonction
            mov ebx, [edx + 01ch]         ; ebx = export table address RVA
            add ebx, ebp                        ; pointeur vers table d'export
            mov eax, [ebx + 4 * ecx]      ; RVA de la fonction
           
            invoke AdjustIfIsForwarded,ebp,eax
           
            mov [esp+01Ch],eax                  ; retour sur eax (overwrite le EAX du pushad)
      @@find_function_finished:
            popad
     
      ret

FindExport endp
AdjustIfIsForwarded     proc  DllModule:DWORD,FuncRva:DWORD
LOCAL ForwarderRef[50]:BYTE

      mov esi, DllModule
      mov eax, [esi + 3Ch]          ;pe signature
      mov ebx, [esi + eax + 78h]    ;ebx == exportable rva
      mov ecx, [esi + eax + 7Ch]    ;ecx == sizeof EAT
;---------------------- teste si on se trouve dans l'export table
      cmp FuncRva,ebx
      jb NotForwarded
      add ebx,ecx
      cmp FuncRva,ebx
      ja NotForwarded
;----------------------
ForwardedRefPresent:
;si on se retrouve ici alors il s'agit d'un forwarder ref et FuncRva pointe vers une string sous la forme "NomDll"."NomFonction"

;---------------------- lstrlen maison    (ecx == taille)
      mov al,0
      mov ecx,-1
      mov edi,FuncRva
      add edi,esi
      push edi
      repne scasb
      not ecx
;----------------------
;---------------------- lstrcpy maison (edi == ptr buffer)
      pop esi                 ;esi==ptr ds l'export table (source)
      lea edi, ForwarderRef   ;edi == buffer (dest)
      push edi
      rep movsb
;----------------------
;---------------------- scan la pos du "." " (ecx == position relative au ptr buffer du ".")
      mov al,"."
      pop edi
      mov ecx,-1
      repne scasb
      not ecx
;----------------------
      mov byte ptr [edi - 1],0
     
      sub edi,ecx ;edi == ptr vers le nom de la dll
     
      push ecx;save ecx parce que loadlibrary le modifie
     
;charge la dll correspondante
      invoke GetKernelAddr
      invoke FindExport,eax,_LoadLibraryA
      push edi
      call eax
      mov ebx, eax ;ebx == module de la dll
     
      pop ecx;restaure ecx
     
      add edi,ecx ;edi == ptr vers le nom de la fonction
     
;---------------------- hash le nom de la fonction
      mov esi, edi
      @@compute_hash:
            xor edi, edi
            xor eax, eax
            cld
           
      @@compute_hash_again:
            lodsb
            test al, al
            jz @@compute_hash_finished
            ror edi, 0dh
            add edi, eax
            jmp @@compute_hash_again
      @@compute_hash_finished:
;----------------------
;---------------------- obtien le ptr de cette fonction    
      invoke FindExport,ebx,edi
      ret
;---------------------- si c pas une forwarded ref alors on ajoute a cette rva le module de la dll :)  
NotForwarded:
      mov eax,FuncRva
      add eax,DllModule
      ret

AdjustIfIsForwarded endp
EndCode:
;####################################################################################### 
;####################################################################################### 
;fin du code injecté

No comments:

Post a Comment