某些情況下需要exe執行結束刪除自身，而自刪除程式有好幾種方法，如下面的兩方法：
a.先使自己快速退出，然後再在命令列中刪除自己；或是先使自己快速退出，然後再在bat檔案或指令碼檔案中刪除自己

b. 非常經典的，關閉硬編碼為4的控制代碼，撤銷自己在記憶體的對映，再刪除自己，再結束自己，也就是程序在未真正退出的時候就已經被刪除了（只能在win2k或98使用）
                    int main(int argc, char *argv[])
                 {
                 HMODULE module = GetModuleHandle(0);
                 CHAR buf[MAX_PATH];
                 GetModuleFileName(module, buf, sizeof buf);
                 CloseHandle(HANDLE(4));
                 __asm {
                 lea    eax, buf
                 push    0
                 push    0
                 push    eax
                 push    ExitProcess
                 push    module
                 push    DeleteFile
                 push    UnmapViewOfFile//FreeLibrary;98
                 ret
                 }
                 return 0;
                 }

本文所使用的是另外一種方法：使用注入其他程序的shellcode來實現自刪除，其基本原理就是：讓shellcode先終止自己，然後再讓shellcode刪除自己。執行shellcode完畢之後，僅在記憶體保留一段地址，而不會產生磁碟檔案，利用這個特點可以用來做'乾淨的'自刪除程式，但會讓被注入的程序造成記憶體洩漏，理由是注入的程式碼不能被釋放，否則會造成呼叫方的訪問違規。

要點： 1.本地修改API函式在遠端程序的實際地址，有效的減少shellcode的程式碼長度，利用預定義的巨集作為可能被呼叫的API函式的值，巨集  的一個特點是，在編譯的時候，只會編譯成巨集定義的值，而不是像變數一樣被優化成地址（因為本地變數的地址在其他程序是無效的）
            2.在執行時修改暫存器指向的地址，在程序virtualallocex分配一塊記憶體，然後把得到的地址由esi指向它，
            然後writeprocessmemory，esi持有的地址就會發生變化，這樣就可以修改預先編碼的資料，就像使用函式引數一樣來傳遞。

 基本實現： 程式自殺的原理，注入遠執行緒到其他程序，讓執行緒的shellcode終止掉自己，然後再呼叫deletefile刪除自己（有點笨挫，也許可以有更好的方法），（當然也可以用來幹掉其他程序，但前提是可以被結束和刪除的。。）

限制：可能被殺軟報警，至少讀寫其他程序的資料是違規的吧？

下面是程式碼：
//h檔案//////////////////////////

//查詢指標內的一個無符號的32位整數值，這個可以是個標籤
void* __cdecl find_ptrvalue(__in  void* pfun,__in unsigned  int findvalue,__out unsigned int *ioffset );
//更完善的
void* __cdecl FindCodeValue(__in void* pcode,__in size_t codelen,__in unsigned int findvalue,__out unsigned int *ioffset );
//查詢全部匹配的，並替換為指定的,並返回最後一個找到的偏移量
unsigned int __cdecl FindCodeReplaceAll(__in void* pcode,__in size_t codelen,
                                        __in unsigned int findvalue,__in unsigned int replacevalue);

/*獲得指定模組路徑的在某個程序中的基地址*/
DWORD __stdcall GetModulebaseProcessW(__in DWORD dwPid,__in  LPWSTR lpszDllFile);
DWORD __stdcall GetModulebaseProcessA(__in DWORD dwPid,__in   LPSTR    lpszDllFile);


#ifdef UNICODE
#define  GetModulebaseProcess GetModulebaseProcessW
#else
#define  GetModulebaseProcess GetModulebaseProcessA
#endif

/*計算遠端程序呼叫載入模組匯出函式的地址，原理:利用DLL匯出函式的RVA+模組基地址*/
DWORD __stdcall GetRemoteProcAddress(
                                     __in   DWORD dwRemoteModule,
                                     __in   DWORD  dwLocalModule,
                                     __in   LPCSTR   lpszProcName);


/*自刪除的簡單實現*/
BOOL __stdcall SeltKill(__in  DWORD dwInjectPid/*被注入的程序PID*/);

//下面是cpp檔案///////////////////////////////////////////////////////////////////////////////////

//查詢指標內的一個無符號的32位整數值，這個可以是個標籤
void* __cdecl find_ptrvalue(__in  void* pfun,__in unsigned  int findvalue,__out unsigned int *ioffset ){
    void *pret;
    int   i=0;
    __asm{
        mov eax,pfun
            mov ecx,0
            jmp __loop
__goon:
        inc   eax
            inc   ecx
__loop:
        mov ebx,[eax]
        cmp ebx,findvalue
            jnz __goon
            mov pret,eax
            mov i,ecx
        }
    if(ioffset) *ioffset = i;
    return pret;/*這個函式沒有使用，而是使用FindCodeReplaceAll*/
    }

//更完善的
void* __cdecl FindCodeValue(__in void* pcode,__in size_t codelen,__in unsigned int findvalue,__out unsigned int *ioffset ){
    if(!pcode || !codelen ) return NULL;
    LPDWORD dwfind =NULL;
    void* presult=NULL;
    PBYTE pb=(PBYTE)pcode;
    for(int i =0;i<codelen-3;i++,pb++){
        dwfind=(LPDWORD)pb;
        if(*dwfind==findvalue){
            presult=pb;
            if(ioffset) *ioffset=i;
            return presult;
            }
        }
    return NULL;/*這個函式沒有使用，而使用FindCodeReplaceAll*/
    }

//查詢全部匹配的，並替換為指定的,並返回最後一個找到的偏移量
unsigned int __cdecl FindCodeReplaceAll(__in void* pcode,__in size_t codelen,    __in unsigned int findvalue,__in unsigned int replacevalue){

    if(!pcode || !codelen) return 0;
unsigned int iret=0;
unsigned int *pui=0;
unsigned char *puc=(unsigned char *)pcode;
for(int i =0;i<codelen-3;i++,puc++){
pui=(unsigned int*)puc;
if(*pui==findvalue){
*pui=replacevalue;
iret=i;
}
    }
return iret;
}

//獲得指定程序的模組的控制代碼並轉換為DWORD，引數lpszDllFile指定的是完全路徑
DWORD __stdcall GetModulebaseProcessW(__in DWORD dwPid,__in  LPWSTR lpszDllFile){
    if(!dwPid || !lpszDllFile) return 0;
    HANDLE  hSnap=NULL;
    MODULEENTRY32W me32={sizeof(me32)};
    __try{
        hSnap=CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,dwPid);
        if(hSnap==INVALID_HANDLE_VALUE) __leave;
        if(!Module32FirstW(hSnap,&me32)) __leave;
        do{
            if(lstrcmpiW(me32.szExePath,lpszDllFile)==0)
                return (DWORD)me32.modBaseAddr;

            }while(Module32NextW(hSnap,&me32));

        }__finally{
            if(hSnap!=INVALID_HANDLE_VALUE &&hSnap!=NULL) CloseHandle(hSnap);


        }
    return 0;
    }
DWORD __stdcall GetModulebaseProcessA(__in DWORD dwPid,__in   LPSTR    lpszDllFile){
    WCHAR szFile[MAX_PATH];
    wsprintfW(szFile,L"%S/0",lpszDllFile);
    return GetModulebaseProcessW(dwPid,szFile);
    }

/*計算遠端程序呼叫載入模組匯出函式的地址，原理:利用DLL匯出函式的RVA+模組基地址*/
DWORD __stdcall GetRemoteProcAddress(
                                     __in   DWORD dwRemoteModule,
                                     __in   DWORD  dwLocalModule,
                                     __in   LPCSTR   lpszProcName){
DWORD dwfun=(DWORD)GetProcAddress((HMODULE)dwLocalModule,lpszProcName);
dwfun-=dwLocalModule;/*從當前程序載入模組獲取的函式（即便匯入表中不存在的，只要模組被對映到程序的記憶體地址空間，整個模組的匯出函式都可以使用GetProcAddress來獲取），得到函式的地址後，減去模組基地址得到函式在模組的RVA，利用這個RVA+其他程序模組的基地址=該函式在其他程序的真實地址*/
return dwfun+dwRemoteModule;
    }

/*預定義隨機值的巨集，每個巨集代表一個函式的地址,這些僅作為“佔位”的方式存在於shellcode，是無法呼叫，只有替換為真實的API地址後才能呼叫，否則呼叫異常*/
#define   _PRE_PID                                   0x88aa77cc //隨機數..
#define   _PRE_OpenProcess                      0x99bb1234
#define   _PRE_GetExitCodeProcess            0x99aa4321
#define   _PRE_TerminateProcess               0xFaFaFaFa
#define   _PRE_MessageBoxA                    0xFA971215
#define   _PRE_szFile                               0xAF792151
#define   _PRE_CloseHandle                      0x88aa77bc
#define   _PRE_DeleteFileA                       0xAF782161
#define   _PRE_Sleep                               0xBf782115
#define   _PRE_GetCurrentThreadId           0xFb564646
#define   _PRE_OpenThread                      0xFb564791

//////////////////////////////自刪除程式//////////////////////////////////////////


BOOL __stdcall SeltKill(__in  DWORD dwInjectPid){
goto _l2;
_l1:
__asm{
pushad
mov ebp,esp
sub  esp,4

mov   eax,_PRE_PID
push  eax
push  FALSE
push  PROCESS_QUERY_INFORMATION|PROCESS_TERMINATE
mov   edx,_PRE_OpenProcess
call    edx
test   eax,eax
jz      _end
mov   ebx,eax

lea     ecx,[ebp-4]
mov    edx,_PRE_GetExitCodeProcess
push   ecx
push   ebx
call     edx

push  ecx
push  ebx
mov   edx,_PRE_TerminateProcess
call    edx

push   ebx
mov    edx,_PRE_CloseHandle
call     edx

push   500 ;等待0.5秒再刪除,或許可以更短
mov    edx,_PRE_Sleep
call     edx

_end:
mov   edx,_PRE_DeleteFileA
mov   ecx,_PRE_szFile
lea     esi,[ecx]
push   esi
call     edx
add   esp,4
popad
ret
    }
_l2:
PSTR   pPageCode=NULL;
ULONG ulPageCodeLen=0;
__asm{
    mov  eax,_l1
    mov  ebx,_l2
    mov  pPageCode,eax
    sub   ebx,eax
    mov  ulPageCodeLen,ebx
    }
DWORD  dwCurPid=GetCurrentProcessId();
if(dwCurPid==dwInjectPid) return FALSE;
HANDLE hprocess=OpenProcess(PROCESS_ALL_ACCESS,FALSE,dwInjectPid);
if(!hprocess) return FALSE;
LPVOID  lpRmCode=NULL;
LPVOID  lpRmSzFile=NULL;
HANDLE  hRmthd=NULL;
PSTR pMemCode=(PSTR)GlobalAlloc(GPTR,ulPageCodeLen);
if(!pMemCode) return FALSE;
CopyMemory(pMemCode,pPageCode,ulPageCodeLen);
WCHAR  szkerneldir[MAX_PATH];
WCHAR   sysdir[MAX_PATH];
GetSystemDirectoryW(sysdir,(ULONG)(MAX_PATH)*sizeof(WCHAR));
lstrcpynW(szkerneldir,sysdir,(lstrlenW(sysdir)+1)*sizeof(WCHAR));
StrCatW(szkerneldir,L"//kernel32.dll/0");
char szThisFile[260];
GetModuleFileNameA(NULL,szThisFile,260);

DWORD  dwRemoteKernel=GetModulebaseProcessW(dwInjectPid,szkerneldir);/* kernel32在任何程序的地址都是一樣的*/
DWORD     dwLocalKernel=(DWORD)GetModuleHandleW(L"kernel32");
DWORD  dwExportFunc=0;

__try{
dwExportFunc=GetRemoteProcAddress(dwRemoteKernel,dwLocalKernel,"OpenProcess");
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_OpenProcess,dwExportFunc))
__leave;
dwExportFunc=GetRemoteProcAddress(dwRemoteKernel,dwLocalKernel,"GetExitCodeProcess");
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_GetExitCodeProcess,dwExportFunc))
__leave;
dwExportFunc=GetRemoteProcAddress(dwRemoteKernel,dwLocalKernel,"TerminateProcess");
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_TerminateProcess,dwExportFunc))
__leave;
dwExportFunc=GetRemoteProcAddress(dwRemoteKernel,dwLocalKernel,"CloseHandle");
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_CloseHandle,dwExportFunc))
__leave;
dwExportFunc=GetRemoteProcAddress(dwRemoteKernel,dwLocalKernel,"DeleteFileA");
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_DeleteFileA,dwExportFunc))
__leave;
dwExportFunc=GetRemoteProcAddress(dwRemoteKernel,dwLocalKernel,"Sleep");
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_Sleep,dwExportFunc))
__leave;
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_PID,dwCurPid))
__leave;
DWORD dwszlen=lstrlenA(szThisFile)+1;
lpRmSzFile=VirtualAllocEx(hprocess,NULL,dwszlen,MEM_COMMIT,PAGE_READWRITE);
if(!lpRmSzFile) __leave;//不能釋放，否則遠端崩潰
if(!WriteProcessMemory(hprocess,lpRmSzFile,szThisFile,dwszlen,NULL)){
    VirtualFreeEx(hprocess,lpRmSzFile,0,MEM_RELEASE);
    __leave;
    }
if(!FindCodeReplaceAll(pMemCode,ulPageCodeLen,_PRE_szFile,(DWORD)lpRmSzFile)){
  VirtualFreeEx(hprocess,lpRmSzFile,0,MEM_RELEASE);
  __leave;
    }
//寫程式碼
lpRmCode=VirtualAllocEx(hprocess,0,ulPageCodeLen,MEM_COMMIT,PAGE_EXECUTE_READWRITE);
if(!lpRmCode){
    VirtualFreeEx(hprocess,lpRmSzFile,0,MEM_RELEASE);
    __leave;
    }
if(!WriteProcessMemory(hprocess,lpRmCode,pMemCode,ulPageCodeLen,NULL)){
VirtualFreeEx(hprocess,lpRmCode,0,MEM_RELEASE);
VirtualFreeEx(hprocess,lpRmSzFile,0,MEM_RELEASE);
__leave;
    }
hRmthd=CreateRemoteThread(hprocess,NULL,0,
                          (LPTHREAD_START_ROUTINE)lpRmCode,NULL,NULL,NULL);
if(!hRmthd){
    VirtualFreeEx(hprocess,lpRmCode,0,MEM_RELEASE);
    VirtualFreeEx(hprocess,lpRmSzFile,0,MEM_RELEASE);
    __leave;
    }
return TRUE;
    }__finally{
        if(pMemCode) GlobalFree(pMemCode);
        if(hprocess) CloseHandle(hprocess);
    }
return FALSE;
    }

//程式碼完畢

上面的程式碼可以實現程式的自刪除，其基本原理就是終止程序，等待，再刪除。或許可以有更好的演算法。。。

補1：

  上述程式碼是通過遠執行緒強制終止呼叫方的程序的，可能出現不確定性，例如呼叫方程序並未做好退出程序的準備就退出。某些情況下需要呼叫方程序處理完畢之後方可退出並刪除，因此遠執行緒需要執行等待，直到呼叫方程序自身退出程序後再刪除它，利用WaitForSingleObject函式即可等待呼叫方程序的結束，而作為等待狀態的核心物件可以是呼叫方的的程序控制代碼，因為一旦程序退出後，該控制代碼就會無狀態，那麼WaitForSingleObject就不再等待，繼而執行之後的刪除函式。

即把上面的程式碼改這個，注意查詢WaitForSingleObject的地址！

__asm{
pushad
mov   eax,_PRE_PID
push  eax
push  FALSE
push  SYNCHRONIZE
mov   edx,_PRE_OpenProcess
call    edx
test   eax,eax
jz      _end
mov   ebx,eax
mov   edx,_PRE_WaitForSingleObject
push  INFINITE  ;無限等待，也可另設時間
push   ebx
call    edx
;waiting...process exit

mov   edx,_PRE_CloseHandle
push  ebx
call    edx

_end: ;假設程序控制代碼打不開就刪除
mov  ecx,_PRE_szFile
lea  esi,[ecx]
mov  edx,_PRE_DeleteFileA
push esi
call   edx

popad
ret
    }

也就是呼叫WaitForSingleObject等待程序，如果程序退出了，WaitForSingleObject就沒狀態了，就不會掛起執行緒了，那麼之後的語句就會執行。

這樣做有個前提，就是被注入的程序必須長時間駐機執行，如果先退出，就沒有作用了。