动态加载EXE文件到内存执行

转载 2007年10月14日 22:32:00
//*******************************************************************************************************
// loadEXE.cpp : Defines the entry point for the console application.
//
// Proof-Of-Concept Code
// Copyright (c) 2004
// All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so, provided that the above
// copyright notice(s) and this permission notice appear in all copies of
// the Software and that both the above copyright notice(s) and this
// permission notice appear in supporting documentation.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
// OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
// HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
// INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
// FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
// NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
// WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
//
// Usage:
// loadEXE <EXE filename>
//
// This will execute calc.exe in suspended mode and replace its image with
// the new EXE's image.  The thread is then resumed, thus causing the new EXE to
// execute within the process space of svchost.exe.
//
//*******************************************************************************************************

#include 
<stdio.h>
#include 
<windows.h>
#include 
<tlhelp32.h>
#include 
<psapi.h>

struct PE_Header 
{
    unsigned 
long signature;
    unsigned 
short machine;
    unsigned 
short numSections;
    unsigned 
long timeDateStamp;
    unsigned 
long pointerToSymbolTable;
    unsigned 
long numOfSymbols;
    unsigned 
short sizeOfOptionHeader;
    unsigned 
short characteristics;
}
;

struct PE_ExtHeader
{
    unsigned 
short magic;
    unsigned 
char majorLinkerVersion;
    unsigned 
char minorLinkerVersion;
    unsigned 
long sizeOfCode;
    unsigned 
long sizeOfInitializedData;
    unsigned 
long sizeOfUninitializedData;
    unsigned 
long addressOfEntryPoint;
    unsigned 
long baseOfCode;
    unsigned 
long baseOfData;
    unsigned 
long imageBase;
    unsigned 
long sectionAlignment;
    unsigned 
long fileAlignment;
    unsigned 
short majorOSVersion;
    unsigned 
short minorOSVersion;
    unsigned 
short majorImageVersion;
    unsigned 
short minorImageVersion;
    unsigned 
short majorSubsystemVersion;
    unsigned 
short minorSubsystemVersion;
    unsigned 
long reserved1;
    unsigned 
long sizeOfImage;
    unsigned 
long sizeOfHeaders;
    unsigned 
long checksum;
    unsigned 
short subsystem;
    unsigned 
short DLLCharacteristics;
    unsigned 
long sizeOfStackReserve;
    unsigned 
long sizeOfStackCommit;
    unsigned 
long sizeOfHeapReserve;
    unsigned 
long sizeOfHeapCommit;
    unsigned 
long loaderFlags;
    unsigned 
long numberOfRVAAndSizes;
    unsigned 
long exportTableAddress;
    unsigned 
long exportTableSize;
    unsigned 
long importTableAddress;
    unsigned 
long importTableSize;
    unsigned 
long resourceTableAddress;
    unsigned 
long resourceTableSize;
    unsigned 
long exceptionTableAddress;
    unsigned 
long exceptionTableSize;
    unsigned 
long certFilePointer;
    unsigned 
long certTableSize;
    unsigned 
long relocationTableAddress;
    unsigned 
long relocationTableSize;
    unsigned 
long debugDataAddress;
    unsigned 
long debugDataSize;
    unsigned 
long archDataAddress;
    unsigned 
long archDataSize;
    unsigned 
long globalPtrAddress;
    unsigned 
long globalPtrSize;
    unsigned 
long TLSTableAddress;
    unsigned 
long TLSTableSize;
    unsigned 
long loadConfigTableAddress;
    unsigned 
long loadConfigTableSize;
    unsigned 
long boundImportTableAddress;
    unsigned 
long boundImportTableSize;
    unsigned 
long importAddressTableAddress;
    unsigned 
long importAddressTableSize;
    unsigned 
long delayImportDescAddress;
    unsigned 
long delayImportDescSize;
    unsigned 
long COMHeaderAddress;
    unsigned 
long COMHeaderSize;
    unsigned 
long reserved2;
    unsigned 
long reserved3;
}
;


struct SectionHeader
{
    unsigned 
char sectionName[8];
    unsigned 
long virtualSize;
    unsigned 
long virtualAddress;
    unsigned 
long sizeOfRawData;
    unsigned 
long pointerToRawData;
    unsigned 
long pointerToRelocations;
    unsigned 
long pointerToLineNumbers;
    unsigned 
short numberOfRelocations;
    unsigned 
short numberOfLineNumbers;
    unsigned 
long characteristics;
}
;

struct MZHeader
{
    unsigned 
short signature;
    unsigned 
short partPag;
    unsigned 
short pageCnt;
    unsigned 
short reloCnt;
    unsigned 
short hdrSize;
    unsigned 
short minMem;
    unsigned 
short maxMem;
    unsigned 
short reloSS;
    unsigned 
short exeSP;
    unsigned 
short chksum;
    unsigned 
short exeIP;
    unsigned 
short reloCS;
    unsigned 
short tablOff;
    unsigned 
short overlay;
    unsigned 
char reserved[32];
    unsigned 
long offsetToPE;
}
;


struct ImportDirEntry
{
    DWORD importLookupTable;
    DWORD timeDateStamp;
    DWORD fowarderChain;
    DWORD nameRVA;
    DWORD importAddressTable;
}
;


//**********************************************************************************************************
//
// This function reads the MZ, PE, PE extended and Section Headers from an EXE file.
//
//**********************************************************************************************************

bool readPEInfo(FILE *fp, MZHeader *outMZ, PE_Header *outPE, PE_ExtHeader *outpeXH,
                SectionHeader 
**outSecHdr)
{
    fseek(fp, 
0, SEEK_END);
    
long fileSize = ftell(fp);
    fseek(fp, 
0, SEEK_SET);

    
if(fileSize < sizeof(MZHeader))
    
{
        printf(
"File size too small ");        
        
return false;
    }


    
// read MZ Header
    MZHeader mzH;
    fread(
&mzH, sizeof(MZHeader), 1, fp);

    
if(mzH.signature != 0x5a4d)        // MZ
    {
        printf(
"File does not have MZ header ");
        
return false;
    }


    
//printf("Offset to PE Header = %X ", mzH.offsetToPE);

    
if((unsigned long)fileSize < mzH.offsetToPE + sizeof(PE_Header))
    
{
        printf(
"File size too small ");        
        
return false;
    }


    
// read PE Header
    fseek(fp, mzH.offsetToPE, SEEK_SET);
    PE_Header peH;
    fread(
&peH, sizeof(PE_Header), 1, fp);

    
//printf("Size of option header = %d ", peH.sizeOfOptionHeader);
    
//printf("Number of sections = %d ", peH.numSections);

    
if(peH.sizeOfOptionHeader != sizeof(PE_ExtHeader))
    
{
        printf(
"Unexpected option header size. ");

        
return false;
    }


    
// read PE Ext Header
    PE_ExtHeader peXH;

    fread(
&peXH, sizeof(PE_ExtHeader), 1, fp);

    
//printf("Import table address = %X ", peXH.importTableAddress);
    
//printf("Import table size = %X ", peXH.importTableSize);
    
//printf("Import address table address = %X ", peXH.importAddressTableAddress);
    
//printf("Import address table size = %X ", peXH.importAddressTableSize);


    
// read the sections
    SectionHeader *secHdr = new SectionHeader[peH.numSections];

    fread(secHdr, 
sizeof(SectionHeader) * peH.numSections, 1, fp);

    
*outMZ = mzH;
    
*outPE = peH;
    
*outpeXH = peXH;
    
*outSecHdr = secHdr;

    
return true;
}



//**********************************************************************************************************
//
// This function calculates the size required to load an EXE into memory with proper alignment.
//
//**********************************************************************************************************

int calcTotalImageSize(MZHeader *inMZ, PE_Header *inPE, PE_ExtHeader *inpeXH,
                       SectionHeader 
*inSecHdr)
{
    
int result = 0;
    
int alignment = inpeXH->sectionAlignment;

    
if(inpeXH->sizeOfHeaders % alignment == 0)
        result 
+= inpeXH->sizeOfHeaders;
    
else
    
{
        
int val = inpeXH->sizeOfHeaders / alignment;
        val
++;
        result 
+= (val * alignment);
    }



    
for(int i = 0; i < inPE->numSections; i++)
    
{
        
if(inSecHdr[i].virtualSize)
        
{
            
if(inSecHdr[i].virtualSize % alignment == 0)
                result 
+= inSecHdr[i].virtualSize;
            
else
            
{
                
int val = inSecHdr[i].virtualSize / alignment;
                val
++;
                result 
+= (val * alignment);
            }

        }

    }


    
return result;
}



//**********************************************************************************************************
//
// This function calculates the aligned size of a section
//
//**********************************************************************************************************

unsigned 
long getAlignedSize(unsigned long curSize, unsigned long alignment)
{    
    
if(curSize % alignment == 0)
        
return curSize;
    
else
    
{
        
int val = curSize / alignment;
        val
++;
        
return (val * alignment);
    }

}



//**********************************************************************************************************
//
// This function loads a PE file into memory with proper alignment.
// Enough memory must be allocated at ptrLoc.
//
//**********************************************************************************************************

bool loadPE(FILE *fp, MZHeader *inMZ, PE_Header *inPE, PE_ExtHeader *inpeXH,
            SectionHeader 
*inSecHdr, LPVOID ptrLoc)
{
    
char *outPtr = (char *)ptrLoc;

    fseek(fp, 
0, SEEK_SET);
    unsigned 
long headerSize = inpeXH->sizeOfHeaders;

    
// certain PE files have sectionHeaderSize value > size of PE file itself.  
    
// this loop handles this situation by find the section that is nearest to the
    
// PE header.

    
for(int i = 0; i < inPE->numSections; i++)
    
{
        
if(inSecHdr[i].pointerToRawData < headerSize)
            headerSize 
= inSecHdr[i].pointerToRawData;
    }


    
// read the PE header
    unsigned long readSize = fread(outPtr, 1, headerSize, fp);
    
//printf("HeaderSize = %d ", headerSize);
    if(readSize != headerSize)
    
{
        printf(
"Error reading headers (%d %d) ", readSize, headerSize);
        
return false;        
    }


    outPtr 
+= getAlignedSize(inpeXH->sizeOfHeaders, inpeXH->sectionAlignment);

    
// read the sections
    for(i = 0; i < inPE->numSections; i++)
    
{
        
if(inSecHdr[i].sizeOfRawData > 0)
        
{
            unsigned 
long toRead = inSecHdr[i].sizeOfRawData;
            
if(toRead > inSecHdr[i].virtualSize)
                toRead 
= inSecHdr[i].virtualSize;

            fseek(fp, inSecHdr[i].pointerToRawData, SEEK_SET);
            readSize 
= fread(outPtr, 1, toRead, fp);

            
if(readSize != toRead)
            
{
                printf(
"Error reading section %d ", i);
                
return false;
            }

            outPtr 
+= getAlignedSize(inSecHdr[i].virtualSize, inpeXH->sectionAlignment);
        }

        
else
        
{
            
// this handles the case where the PE file has an empty section. E.g. UPX0 section
            
// in UPXed files.

            
if(inSecHdr[i].virtualSize)
                outPtr 
+= getAlignedSize(inSecHdr[i].virtualSize, inpeXH->sectionAlignment);
        }

    }


    
return true;
}



struct FixupBlock
{
    unsigned 
long pageRVA;
    unsigned 
long blockSize;
}
;


//**********************************************************************************************************
//
// This function loads a PE file into memory with proper alignment.
// Enough memory must be allocated at ptrLoc.
//
//**********************************************************************************************************

void doRelocation(MZHeader *inMZ, PE_Header *inPE, PE_ExtHeader *inpeXH,
                  SectionHeader 
*inSecHdr, LPVOID ptrLoc, DWORD newBase)
{
    
if(inpeXH->relocationTableAddress && inpeXH->relocationTableSize)
    
{
        FixupBlock 
*fixBlk = (FixupBlock *)((char *)ptrLoc + inpeXH->relocationTableAddress);
        
long delta = newBase - inpeXH->imageBase;

        
while(fixBlk->blockSize)
        
{
            
//printf("Addr = %X ", fixBlk->pageRVA);
            
//printf("Size = %X ", fixBlk->blockSize);

            
int numEntries = (fixBlk->blockSize - sizeof(FixupBlock)) >> 1;
            
//printf("Num Entries = %d ", numEntries);

            unsigned 
short *offsetPtr = (unsigned short *)(fixBlk + 1);

            
for(int i = 0; i < numEntries; i++)
            
{
                DWORD 
*codeLoc = (DWORD *)((char *)ptrLoc + fixBlk->pageRVA + (*offsetPtr & 0x0FFF));

                
int relocType = (*offsetPtr & 0xF000>> 12;

                
//printf("Val = %X ", *offsetPtr);
                
//printf("Type = %X ", relocType);

                
if(relocType == 3)
                    
*codeLoc = ((DWORD)*codeLoc) + delta;
                
else
                
{
                    printf(
"Unknown relocation type = %d ", relocType);
                }

                offsetPtr
++;
            }


            fixBlk 
= (FixupBlock *)offsetPtr;
        }

    }
    
}



#define TARGETPROC "calc.exe"
CHAR    szDefDir[] 
= "I:/MyProject/tools/Xptools";
//CHAR    szDeft[] = "E:/WINDOWS/system32/notepad.exe";
//CHAR    szDeft[] = "I:/MyProject/tools/Xptools/XPtools.exe";
//CHAR    szDeft[] = "I:/MyProject/Test/Calcu/debug/Calcu.exe";
CHAR    szDeft[] = "I:/MyProject/PCBTest/Bin/PCBTest.exe";

typedef 
struct _PROCINFO
{
    DWORD baseAddr;
    DWORD imageSize;
}
 PROCINFO;



//**********************************************************************************************************
//
// Creates the original EXE in suspended mode and returns its info in the PROCINFO structure.
//
//**********************************************************************************************************


BOOL createChild(PPROCESS_INFORMATION pi, PCONTEXT ctx, PROCINFO 
*outChildProcInfo)
{
    STARTUPINFO si 
= {0};

    
if(CreateProcess(NULL, TARGETPROC,
        NULL, NULL, 
0, CREATE_SUSPENDED, NULL, szDefDir, &si, pi))        
    
{
        ctx
->ContextFlags=CONTEXT_FULL;
        GetThreadContext(pi
->hThread, ctx);

        DWORD 
*pebInfo = (DWORD *)ctx->Ebx;
        DWORD read;
        ReadProcessMemory(pi
->hProcess, &pebInfo[2], (LPVOID)&(outChildProcInfo->baseAddr), sizeof(DWORD), &read);

        DWORD curAddr 
= outChildProcInfo->baseAddr;
        MEMORY_BASIC_INFORMATION memInfo;
        
while(VirtualQueryEx(pi->hProcess, (LPVOID)curAddr, &memInfo, sizeof(memInfo)))
        
{
            
if(memInfo.State == MEM_FREE)
                
break;
            curAddr 
+= memInfo.RegionSize;
        }

        outChildProcInfo
->imageSize = (DWORD)curAddr - (DWORD)outChildProcInfo->baseAddr;

        
return TRUE;
    }

    
return FALSE;
}



//**********************************************************************************************************
//
// Returns true if the PE file has a relocation table
//
//**********************************************************************************************************

BOOL hasRelocationTable(PE_ExtHeader 
*inpeXH)
{
    
if(inpeXH->relocationTableAddress && inpeXH->relocationTableSize)
    
{
        
return TRUE;
    }

    
return FALSE;
}



typedef DWORD (WINAPI 
*PTRZwUnmapViewOfSection)(IN HANDLE ProcessHandle, IN PVOID BaseAddress);


//**********************************************************************************************************
//
// To replace the original EXE with another one we do the following.
// 1) Create the original EXE process in suspended mode.
// 2) Unmap the image of the original EXE.
// 3) Allocate memory at the baseaddress of the new EXE.
// 4) Load the new EXE image into the allocated memory.  
// 5) Windows will do the necessary imports and load the required DLLs for us when we resume the suspended 
//    thread.
//
// When the original EXE process is created in suspend mode, GetThreadContext returns these useful
// register values.
// EAX - process entry point
// EBX - points to PEB
//
// So before resuming the suspended thread, we need to set EAX of the context to the entry point of the
// new EXE.
//
//**********************************************************************************************************

void doFork(MZHeader *inMZ, PE_Header *inPE, PE_ExtHeader *inpeXH,
            SectionHeader 
*inSecHdr, LPVOID ptrLoc, DWORD imageSize)
{
    STARTUPINFO si 
= {0};
    PROCESS_INFORMATION pi;
    CONTEXT ctx;
    PROCINFO childInfo;

    
if(createChild(&pi, &ctx, &childInfo)) 
    
{        
        printf(
"Original EXE loaded (PID = %d). ", pi.dwProcessId);
        printf(
"Original Base Addr = %X, Size = %X ", childInfo.baseAddr, childInfo.imageSize);

        LPVOID v 
= (LPVOID)NULL;

        
if(inpeXH->imageBase == childInfo.baseAddr && imageSize <= childInfo.imageSize)
        
{
            
// if new EXE has same baseaddr and is its size is <= to the original EXE, just
            
// overwrite it in memory
            v = (LPVOID)childInfo.baseAddr;
            DWORD oldProtect;
            VirtualProtectEx(pi.hProcess, (LPVOID)childInfo.baseAddr, childInfo.imageSize, PAGE_EXECUTE_READWRITE, 
&oldProtect);            

            printf(
"Using Existing Mem for New EXE at %X ", (unsigned long)v);
        }

        
else
        
{
            
// get address of ZwUnmapViewOfSection
            PTRZwUnmapViewOfSection pZwUnmapViewOfSection = (PTRZwUnmapViewOfSection)GetProcAddress(GetModuleHandle("ntdll.dll"), "ZwUnmapViewOfSection");

            
// try to unmap the original EXE image
            if(pZwUnmapViewOfSection(pi.hProcess, (LPVOID)childInfo.baseAddr) == 0)
            
{
                
// allocate memory for the new EXE image at the prefered imagebase.
                v = VirtualAllocEx(pi.hProcess, (LPVOID)inpeXH->imageBase, imageSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
                
if(v)
                    printf(
"Unmapped and Allocated Mem for New EXE at %X ", (unsigned long)v);
            }

        }


        
if(!&& hasRelocationTable(inpeXH))
        
{
            
// if unmap failed but EXE is relocatable, then we try to load the EXE at another
            
// location
            v = VirtualAllocEx(pi.hProcess, (void *)NULL, imageSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
            
if(v)
            
{
                printf(
"Allocated Mem for New EXE at %X. EXE will be relocated. ", (unsigned long)v);

                
// we've got to do the relocation ourself if we load the image at another
                
// memory location                
                doRelocation(inMZ, inPE, inpeXH, inSecHdr, ptrLoc, (DWORD)v);
            }

        }


        printf(
"EIP = %X ", ctx.Eip);
        printf(
"EAX = %X ", ctx.Eax);
        printf(
"EBX = %X ", ctx.Ebx);        // EBX points to PEB
        printf("ECX = %X ", ctx.Ecx);
        printf(
"EDX = %X ", ctx.Edx);

        
if(v)
        
{            
            printf(
"New EXE Image Size = %X ", imageSize);

            
// patch the EXE base addr in PEB (PEB + 8 holds process base addr)
            DWORD *pebInfo = (DWORD *)ctx.Ebx;
            DWORD wrote;                        
            WriteProcessMemory(pi.hProcess, 
&pebInfo[2], &v, sizeof(DWORD), &wrote);

            
// patch the base addr in the PE header of the EXE that we load ourselves
            PE_ExtHeader *peXH = (PE_ExtHeader *)((DWORD)inMZ->offsetToPE + sizeof(PE_Header) + (DWORD)ptrLoc);
            peXH
->imageBase = (DWORD)v;

            
if(WriteProcessMemory(pi.hProcess, v, ptrLoc, imageSize, NULL))
            
{    
                printf(
"New EXE image injected into process. ");

                ctx.ContextFlags
=CONTEXT_FULL;                
                
//ctx.Eip = (DWORD)v + ((DWORD)dllLoaderWritePtr - (DWORD)ptrLoc);
                //ctx.Eip = 0x007B9640;

                
if((DWORD)v == childInfo.baseAddr)
                
{
                    ctx.Eax 
= (DWORD)inpeXH->imageBase + inpeXH->addressOfEntryPoint;        // eax holds new entry point
                }

                
else
                
{
                    
// in this case, the DLL was not loaded at the baseaddr, i.e. manual relocation was
                    
// performed.
                    ctx.Eax = (DWORD)v + inpeXH->addressOfEntryPoint;        // eax holds new entry point
                }


                printf(
"********> EIP = %X ", ctx.Eip);
                printf(
"********> EAX = %X ", ctx.Eax);

                SetThreadContext(pi.hThread,
&ctx);

                ResumeThread(pi.hThread);
                printf(
"Process resumed (PID = %d). ", pi.dwProcessId);
            }

            
else
            
{
                printf(
"WriteProcessMemory failed ");
                TerminateProcess(pi.hProcess, 
0);
            }

        }

        
else
        
{
            printf(
"Load failed.  Consider making this EXE relocatable. ");
            TerminateProcess(pi.hProcess, 
0);
        }

    }

    
else
    
{
        printf(
"Cannot load %s ", TARGETPROC);
    }

}





int main(int argc, char* argv[])
{
    POINT        pt;
    GetCursorPos(
&pt);

    FILE 
*fp;
    
if(argc != 2)
    
{
        printf(
" Usage: %s <EXE filename> ", argv[0]);
        printf(
"No Input EXE, use: %s ", szDeft);
        fp 
= fopen(szDeft, "rb");
    }

    
else
        fp 
= fopen(argv[1], "rb");
    
if(fp)
    
{
        MZHeader mzH;
        PE_Header peH;
        PE_ExtHeader peXH;
        SectionHeader 
*secHdr;

        
if(readPEInfo(fp, &mzH, &peH, &peXH, &secHdr))
        
{
            
int imageSize = calcTotalImageSize(&mzH, &peH, &peXH, secHdr);
            
//printf("Image Size = %X ", imageSize);

            LPVOID ptrLoc 
= VirtualAlloc(NULL, imageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
            
if(ptrLoc)
            
{
                
//printf("Memory allocated at %X ", ptrLoc);
                loadPE(fp, &mzH, &peH, &peXH, secHdr, ptrLoc);                                                

                doFork(
&mzH, &peH, &peXH, secHdr, ptrLoc, imageSize);                                
            }

            
else
                printf(
"Allocation failed ");
        }


        fclose(fp);
    }

    
else
        printf(
" Cannot open the EXE file! ");

    
return 0;
}
 

EXE内存加载的两种方式(支持win7)

EXE内存加载的两种方式(支持win7)
  • u013761036
  • u013761036
  • 2016年11月24日 19:48
  • 3013

从内存中加载并启动一个exe

windows似乎只提供了一种启动进程的方法:即必须从一个可执行文件中加载并启动。 而下面这段代码就是提供一种可以直接从内存中启动一个exe的变通办法。 用途嘛, 也许可以用来保护你的ex...
  • fjclc2008
  • fjclc2008
  • 2014年02月20日 22:50
  • 2314

实现exe从资源中加载到内存中运行

  • 2016年08月20日 15:18
  • 108KB
  • 下载

载入内存,让程序运行起来

转载于:C语言中文网高级部分。 如果你的电脑上安装了QQ,你希望和好友聊天,会双击QQ图标,打开QQ软件,输入账号和密码,然后登录就可以了。 那么,QQ是怎么运行起来的呢? 首先,有一点你要明确,...
  • czg13548930186
  • czg13548930186
  • 2016年09月22日 23:42
  • 1281

内存加载exe的两种方式(支持win7)

  • 2016年11月24日 19:11
  • 139KB
  • 下载

从内存中加载映像(EXE/DLL)到本地或者远程进程执行

被加载的映像EXE,固定基址(/FIXED:NO)即必须有重定位表, 否则无法处理重定位. 在vs的linker->advanced 中设置 fixed base address。 从其他博主中摘...
  • ooyyee
  • ooyyee
  • 2016年07月06日 20:28
  • 1020

加载exe至内存运行

有时候需要将exe加载至内存运行,例如保护exe程序版权。 先上代码: #ifdef WIN32     #include #else     #error Process Forking...
  • wanm9
  • wanm9
  • 2016年08月25日 21:36
  • 521

内存中加载并运行EXE程序

  • 2011年02月21日 10:27
  • 544KB
  • 下载

从内存中加载并启动一个EXE

windows似乎只提供了一种启动进程的方法:即必须从一个可执行文件中加载并启动。 而下面这段代码就是提供一种可以直接从内存中启动一个exe的变通办法。 用途嘛, 也许可以用来保护你的exe,你可以对...
  • suiyunonghen
  • suiyunonghen
  • 2008年03月18日 01:54
  • 2377

在内存中运行可执行程序

 在内存中运行可执行程序         在内存中运行可执行程序,好处是可以给程序加壳,加密源程序,静态反汇编无法获得PE输入节,但是因为运行后仍然是独立的进程,所以没办法防止远程线程注入,挂接API...
  • xylary
  • xylary
  • 2007年01月08日 19:28
  • 2972
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:动态加载EXE文件到内存执行
举报原因:
原因补充:

(最多只允许输入30个字)