在内存中运行可执行程序

最新推荐文章于 2021-09-24 08:10:21 发布
最新推荐文章于 2021-09-24 08:10:21 发布
阅读量4.3k 收藏 8
点赞数
分类专栏： VC＋＋ 文章标签： alignment image null dos header file

 在内存中运行可执行程序

        在内存中运行可执行程序，好处是可以给程序加壳，加密源程序，静态反汇编无法获得PE输入节，但是因为运行后仍然是独立的进程，所以没办法防止远程线程注入，挂接API钩子。

  
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) )    
         return  FALSE;   
       
     if ( SrcMz -> e_magic  !=  IMAGE_DOS_SIGNATURE )   
         return  FALSE;   
       
     if ( 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 )   
         return  FALSE;   
  
     if ( (SrcPeH -> FileHeader.Characteristics  &  IMAGE_FILE_DLL)  ||    
        (SrcPeH -> FileHeader.Characteristics  &  IMAGE_FILE_EXECUTABLE_IMAGE  ==   0 )  ||    
        (SrcPeH -> FileHeader.SizeOfOptionalHeader  !=   sizeof (IMAGE_OPTIONAL_HEADER)) )   
     {   
         return  FALSE;   
    }    
  
  
    SrcPeSecH  =  (PIMAGE_SECTION_HEADERS)(( int )SrcPeH  +   sizeof (IMAGE_NT_HEADERS));   
    ImageSize  =  CalcTotalImageSize( SrcMz, Len, SrcPeH, SrcPeSecH);   
  
     if ( 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));   
            }    
        }    
    }    
     return  TRUE;   
}    
  
  
  
typedef  void   * (__stdcall  * pfVirtualAllocEx)(unsigned  long ,  void   * , unsigned  long , unsigned  long , unsigned  long );   
pfVirtualAllocEx MyVirtualAllocEx  =  NULL;   
  
BOOL IsNT()   
 {   
     return  MyVirtualAllocEx != NULL;   
}    
  
 //  生成外壳程序命令行   
char   * PrepareShellExe( char   * CmdParam, unsigned  long  BaseAddr, unsigned  long  ImageSize)   
 {   
     if (IsNT())   
     {   
         char   * Buf  =   new   char [ 256 ];   
        memset(Buf,  0 ,  256 );   
        GetModuleFileName( 0 , Buf,  256 );   
        strcat(Buf, CmdParam);   
         return  Buf;  //  请记得释放内存;-)   
    }    
     else   
     {   
         //  Win98下的处理请参考原文;-)   
         //   http://community.youkuaiyun.com/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);   
       
    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;   
}    
  
 //  创建外壳进程并用目标进程替换它然后执行   
HANDLE AttachPE( char   * CmdParam, PIMAGE_NT_HEADERS peH, PIMAGE_SECTION_HEADERS peSecH,    
                 void   * Ptr, unsigned  long  ImageSize, unsigned  long   & ProcId)   
 {   
    HANDLE res  =  INVALID_HANDLE_VALUE;   
    CONTEXT Ctx;   
    HANDLE Thrd;   
    unsigned  long  Addr, Size;   
     char   * s  =  PrepareShellExe(CmdParam, peH -> OptionalHeader.ImageBase, ImageSize);   
     if (s == NULL)  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()) {   
             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;   
            }    
        }    
         else { //  加载失败,杀掉外壳进程   
            TerminateProcess(res,  0 );   
            CloseHandle(Thrd);   
            CloseHandle(res);   
            res  =  INVALID_HANDLE_VALUE;   
        }    
    }    
    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);   
    }    
     return  res;   
}    
  
 //  初始化   
class  CInit   
 {   
 public :   
    CInit()   
     {   
        MyVirtualAllocEx  =  (pfVirtualAllocEx)GetProcAddress(GetModuleHandle( " Kernel32.dll " ),  " VirtualAllocEx " );   
    }    
} Init;   
  
  
  
  



 int  main( int  argc,  char *  argv[])
 {
    FILE *  fp;
    fp  =  fopen( " E://CProject//DBGVIEW.EXE " , " rb " );

     if  ( fp )
     {

        fseek(fp, 0l ,SEEK_END);
         int  file_size = ftell(fp); /* 获取文件长度 */
        fseek(fp, 0l ,SEEK_SET); /* 回到文件头部 */    
        
        
        LPBYTE pBuf  =   new  BYTE[file_size];   
        memset( pBuf,  0 , file_size);   

        fread(pBuf,file_size, 1 ,fp);

        DWORD id  =  GetCurrentProcessId();
        unsigned  long  ulProcessId  =   0 ;   
        MemExecute( pBuf, file_size,  "" ,  & ulProcessId);   
        delete[] pBuf;   
        
    }   
    
     return   0 ;
}
【C++内存泄漏】引发C++程序内存泄漏的原因分析与排查内存泄漏的方法总结
dvlinker的技术专栏
12-30 3万+
本文根据多年的项目实践以及遇到的多个内存泄漏的问题案例及场景，详细介绍引发内存泄漏的原因以及排查方法。
windows下在内存中运行程序
zhang_ruiqiang的博客
08-20 6658
将程序加载到资源中，从资源加载到内存，并运行程序
直接运行内存中的程序
08-16 1170
  Windows的PE加载器在启动程序的时候，会将磁盘上的文件加载到内存，然后做很多操作，如函数导入表重定位，变量预处理之类的。这位仁兄等于是自己写了一个PE加载器。直接将内存中的程序启动。记得以前的“红色代码”病毒也有相同的特性。    直接启动内存中的程序相当于加了一个壳，可以把程序加密保存，运行时解密到内存，然后启动，不过对于增加破解难度还要稍微复杂点。否则人家把内存中的进程DUMP出来然
转载（程序在内存中运行的奥秘)
06-23 445
程序在内存中运行的奥秘 来源: 译言发布时间: 2010-06-20 14:10 　　内存管理是操作系统的核心功能，无论对于开发者还是系统管理员内存管理的重要性都是不言而喻的。我会在接下来的几篇文章通过计算机的实际运行过程谈谈内存管理，当然在必要的时候我也会从底层原理去阐释这个问题。我们提到的概念是不局限于平台特性的通用概念，不过为了阐述这些概念我们选取的实例大多...
程序在内存中的运行原理
sinat_31608641的博客
09-24 3182
一、背景介绍 当进程被加载到内存时，会被分成很多段 bss段： 　　bss段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。 　　bss是英文Block Started by Symbol的简称。 　　bss段属于静态内存分配。 data段： 　　数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。 　　数据段属于静态内存分配。 text段： 　　代码段（code segment/text segment）通常.
易语言 - 内存中加载运行EXE源码
11-18
在计算机系统中，当一个可执行文件（如EXE）被启动时，操作系统会将其加载到内存中，然后执行其中的指令。在易语言中，我们可以通过编写特定的代码来模拟这个过程，不通过传统的文件系统调用直接运行程序，而是将EXE...
在内存中运行EXE可执行文件（Delphi7源代码）
02-18
在编程领域，有时候为了安全或者效率的考虑，我们可能需要在内存中运行可执行文件，而不是将其保存到硬盘上再执行。"在内存中运行EXE可执行文件（Delphi7源代码）"这个主题恰好涉及到这样的技术。下面将详细解释相关...
实现exe从资源中加载到内存中运行
08-20
在Windows操作系统中，将EXE文件从资源中加载到内存并执行是一种常见的技术，它主要用于减少磁盘I/O操作，提高程序的启动速度，以及在某些特殊场景下保护程序不被篡改。以下是对这个主题的详细解释： 一、资源管理...
从内存中运行exe程序
03-05
1. 把你的程序读要内存 2. 以 CREATE_SUSPENDED模式CreateProcess打开svchost.exe 3. 修改svchost.exe页面的属性，然后把要运行的那个程序的内容拷贝到svchost.exe页面 4. 然后再运行 实质想当于是 披着/svchost.exe进程的相关信息/这张皮，而皮里面的肉都被改了
在内存中运行EXE模块.ec
05-19
易模块，.版本 2 .子程序 在内存中运行EXE, 逻辑型, 公开, 可以直接运行资源中的程序，不必释放。成功返回真，失败返回假。 .参数 欲执行的程序, 字节集, , 欲执行的程序，不支持某些加了壳的程序，请自行测试。 .参数 命令行, 文本型, 可空, 为程序提供的命令行参数，不需要请留空。 .参数 外壳程序路径, 文本型, 可空, 外壳程序的路径(如果用系统程序做外壳，如cmd.exe、svchost.exe，可以实现穿防火墙，呵呵)，不支持某些程序，请自行测试；不在当前目录下要提供绝对路径；留空默认为cmd.exe，如果无法运行，请换用不同的程序尝试。 .参数 等待程序运行完毕, 逻辑型, 可空, 默认为假，即不等待。 .参数 窗口显示方式, 整数型, 可空, 1#隐藏窗口； 2#普通激活； 3#最小化激活； 4#最大化激活； 5#普通不激活； 6#最小化不激活。如果省略本参数，默认为“普通激活”方式。 .参数 运行信息, 运行信息, 参考 可空, 用来接收在内存中执行的exe的运行信息(进程、主线程的句柄和ID)。不需要可留空。
EXE直接在内存中运行(Win PE原理)
12-27
通过这段代码可以实现,以加壳的方式让EXE直接在内存中运行, 防止被挂勾和破解释.
简述一个程序在内存中运行过程
weixin_42983452的博客
03-08 2093
以QQ为例进行说明 1.QQ原本是保存在硬盘中的，当要点击QQ图标运行它时，它就被加载到内存中，进行操作。 2.QQ登录界面要输入QQ号码和密码并读取到用户输入的QQ号码和密码，将它发送给腾讯服务器，等待服务器确认账户信息。 3.QQ将密码信息发给服务器后，也得将账户信息自己存在内存中，这时在内存中就会有一块单独的空间是QQ的，QQ账号和QQ密码就像在这个空间中挖了两个坑，这个坑就相当于开辟的变量...
activity window对象创建过程及其作用
ange_li的博客
12-23 917
activity里持有成员变量mWidow， 在attach里初始化，并设置windowManager activity的attach方法在ActivityThread 的 performLaunchActivity方法里被调用 activity被创建后，activity的attach方法被调用 Window.java 里面有几个重要的成员变量，mAppTo...
从内存中加载并运行exe（两种方法）
11-27 1657
windows似乎只提供了一种启动进程的方法：即必须从一个可执行文件中加载并启动。 而下面这段代码就是提供一种可以直接从内存中启动一个exe的变通办法。 用途嘛, 也许可以用来保护你的exe，你可以对要保护的 exe 进行任意切分、加密、存储， 只要运行时能将exe的内容正确拼接到一块内存中，就可以直接从内存中启动，...
内存的执行过程
weixin_30633949的博客
06-25 79
转载于:https://www.cnblogs.com/abelblog/p/7077169.html
从内存中加载并启动一个EXE
不得闲.闲忆居
03-18 4462
windows似乎只提供了一种启动进程的方法：即必须从一个可执行文件中加载并启动。 而下面这段代码就是提供一种可以直接从内存中启动一个exe的变通办法。 用途嘛, 也许可以用来保护你的exe，你可以对要保护的 exe 进行任意切分、加密、存储，只要运行时能将exe的内容正确拼接到一块内存中，就可以直接从内存中启动，而不必不安全地去生成一个临时文件再从临时文件启 动进程。另外这段代码也提供了一种自己
内存执行流程
sunburstm的博客
11-05 275
一、内存区域划分是什么？ 所谓的内存区域划分也只是程序界给出的一种虚拟的概念 栈 程序运行的区域，效率最高，方法的调用执行，基本数据类型定义(局部变量) 堆 用于存储引用数据类型的区域 方法区 所有类的方法都在方法区。 二、试例程序 1.代码 代码如下（示例）： pack
C# 内存中运行程序集技术解析
在.NET中，程序集（Assembly）是代码的部署单元，它可以包含可执行代码（例如.exe文件）或库代码（例如.dll文件）。程序集是编译后的代码单元，其中包含中间语言(IL)指令、元数据和资源。 动态加载程序集意味着你的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值