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

最新推荐文章于 2021-02-18 00:27:23 发布
最新推荐文章于 2021-02-18 00:27:23 发布
阅读量1.4k 收藏
点赞数
分类专栏： c++

被加载的映像EXE，固定基址(/FIXED:NO)即必须有重定位表, 否则无法处理重定位.

在vs的linker->advanced 中设置 fixed base address。

从其他博主中摘取的

// WinMain001.cpp : Defines the entry point for the application.
//

#include "stdafx.h"
#include "WinMain001.h"
#include "stdio.h"

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( int 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()   
{   
    HMODULE hModule = GetModuleHandle(TEXT("Kernel32.dll"));

    MyVirtualAllocEx = (pfVirtualAllocEx)GetProcAddress(hModule, "VirtualAllocEx");
    return MyVirtualAllocEx!=NULL;   
}   

// 生成外壳程序命令行   
char *PrepareShellExe(char *CmdParam, unsigned long BaseAddr, unsigned long ImageSize)   
{   
    if(IsNT())   
    {   
        char *Buf = new char[256];   
        memset(Buf, 0, 256);   
        GetModuleFileNameA(0, Buf, 256);   
        strcat(Buf, CmdParam);
        //memset(Buf , 0,256);
        //strcpy(Buf,"C:\\WINDOWS\\system32\\notepad.exe");

        //svchost.exe
        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(L"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 = CreateProcessA(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;   
}   
int APIENTRY WinMain(HINSTANCE hInstance,   
                     HINSTANCE hPrevInstance,   
                     LPSTR     lpCmdLine,   
                     int       nCmdShow)   
{   
    HANDLE hFile = NULL;   
    hFile = ::CreateFile(L"C:\\test001.exe"  
        , FILE_ALL_ACCESS   
        , 0   
        , NULL   
        , OPEN_EXISTING   
        , FILE_ATTRIBUTE_NORMAL   
        , NULL   
        );   
    if( hFile == INVALID_HANDLE_VALUE )   
        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);

    unsigned long ulProcessId = 0;
    MemExecute( pBuf, dwFileSize, "", &ulProcessId);   
    delete[] pBuf;   


    getchar();
    return 0;   
}


cc___999
关注
专栏目录
[网络安全自学篇] 九十二.《Windows黑客编程技术详解》之病毒启动技术创建进程API、突破SESSION0隔离、内存加载详解（3）
杨秀璋的专栏
07-27 2万+
这是作者网络安全自学教程系列，主要是关于安全工具和实践操作的在线笔记，特分享出来与博友们学习，希望您喜欢，一起进步。这篇文章将带着大家来学习《Windows黑客编程技术详解》，其作者是甘迪文老师，推荐大家购买来学习。作者将采用实际编程和图文结合的方式进行分享，并且会进一步补充知识点。第三篇文章主要介绍木马病毒启动技术，包括创建进程API、突破SESSION0隔离、内存加载详解，希望对您有所帮助。
Python 调用系统DLL（2） 共享内存
weixin_43640369的博客
11-25 1127
Python 调用系统DLL（2） 共享内存 理论上来说调用系统DLL不区分语言，所以可以在不同语言中使用共享内存进行数据传输。 共享内存简介 所谓共享内存就是使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。其他进程能把同一段共享内存段“连接到”他们自己的地址空间里去。所有进程...
DLL内存加载
天使也掉毛
11-19 7055
动态加载dll 功能：      把一个处于内存里的dll直接加载并且使用。 用途：      免杀（静态文件查杀），外挂（防止游戏自己hook了loadlibrary等函数），以及其他。 原理：      假设目前处于内存里的dll是A，然后开辟一个新的内存空间B，根据A的文件头等相关信息，把B看做是加载内存。 然后把数据拷贝到B里，并且对齐相关节，然后修正iat等相关。然后在手动
直接运行内存中的程序
08-16 1138
  Windows的PE加载器在启动程序的时候，会将磁盘上的文件加载到内存，然后做很多操作，如函数导入表重定位，变量预处理之类的。这位仁兄等于是自己写了一个PE加载器。直接将内存中的程序启动。记得以前的“红色代码”病毒也有相同的特性。    直接启动内存中的程序相当于加了一个壳，可以把程序加密保存，运行时解密到内存，然后启动，不过对于增加破解难度还要稍微复杂点。否则人家把内存中的进程DUMP出来然
【转】直接运行内存中的 程序
天道酬勤
03-10 1212
转自：http://www.cnblogs.com/jecray/archive/2011/02/15/1955563.html #include "stdafx.h" #include typedef IMAGE_SECTION_HEADER (*PIMAGE_SECTION_HEADERS)[1]; // 计算对齐后的大小 unsigned long GetAli
内存DLL注入易语言模块源码
05-27
内存DLL注入是一种技术，常用于调试、自动化测试、性能优化以及恶意软件中，它允许一个程序在不修改或重新启动目标进程的情况下，将其功能插入到另一个正在运行的进程中。在这个场景中，标题提及的是“易语言模块...
动态加载dll，动态加载webservice
02-24
动态加载DLL意味着在程序运行时，而不是在编译时，才将DLL加载到内存中。这种方式有以下几个优势： 1. **节省资源**：多个进程可以共享同一份DLL的内存映像，减少了系统资源的消耗。 2. **模块化**：允许独立更新和...
python进程通信方式总结（三）：共享内存
热门推荐
submarineas的博客
02-18 2万+
引言 python使用共享内存进行通信
内存加载dll
12-28
AppWizard has created this CalcModule DLL for you. This file contains a summary of what you will find in each of the files that make up your CalcModule application. CalcModule.dsp This file (the project file) contains information at the project level and is used to build a single project or subproject. Other users can share the project (.dsp) file, but they should export the makefiles locally. CalcModule.cpp This is the main DLL source file. When created, this DLL does not export any symbols. As a result, it will not produce a .lib file when it is built. If you wish this project to be a project dependency of some other project, you will either need to add code to export some symbols from the DLL so that an export library will be produced, or you can check the "doesn't produce lib" checkbox in the Linker settings page for this project.
在内存中加载作为资源的DLL文件
10-09
二次封装动态库时，如果想把多个动态库包含在一起，需要以资源的方式添加封装，在使用的时候有两种方法：1.释放DLL到本地，然后load；2.直接load资源中的DLL；第一种方式有可能造成被封装的DLL泄露，此代码介绍第二种方式加载。
delphi 在内存中直接运行EXE类型的资源文件
09-09
运行一下你会看到 资源里的的exe 运行了 ，程序没有生成exe文件，而是直接从内存里加载并且执行的。 打开任务管理器看一下，比原来多了一个svchost.exe 的进程（进程路径：c:\windows\system32\svchost.exe 就是你在pe 单元里面设定的路径，当然你还任意修改）。
内存加载DLL运行
11-16
内存加载DLL运行内存加载DLL运行内存加载DLL运行内存加载DLL运行内存加载DLL运行
一种保护应用程序的方法 模拟Windows PE加载器，从内存资源中加载DLL
马大叔的工作日记
08-13 2956
1、前言 目前很多敏感和重要的DLL(Dynamic-link library) 都没有提供静态版本供编译器进行静态连接(.lib文件)，即使提供了静态版本也因为兼容性问题导致无法使用，而只提供DLL版本，并且很多专业软件的授权部分的API，都是单独提供一个DLL来完成，而
直接运行内存中的 程序
zqf_office的专栏
10-24 759
#include "stdafx.h"     #include         typedef IMAGE_SECTION_HEADER (*PIMAGE_SECTION_HEADERS)[1];           // 计算对齐后的大小      unsigned long GetAlignedSize(unsigned long Origin, unsigned long Al
直接运行内存中的程序[转]
mAKER's Blog
11-10 2460
001  /* 002  Windows的PE加载器在启动程序的时候，会将磁盘上的文件加载到内存，然后做很多操作，如函数导入表重定位，变量预处理之类的。这位仁兄等于是自己写了一个PE加载器。直接将内存中的程序启动。记得以前的“红色代码”病毒也有相同的特性。 003  直接启动内存中的程序相当于加了一个壳，可以把程序加密保存，运行时解密到内存，然后启动，不过对于增加破解难度还要稍微复杂点。否则人家把内存中的进程DUMP出来然后修复导入表就被拖出来了。 004  */ 005  #includ
Procexp进程管理工具：深入洞察CPU、内存与DLL分析
这款免费软件由Microsoft开发，提供了一种直观的方式来查看和管理计算机的后台活动，包括CPU、内存占用、加载的DLL文件、句柄、线程以及堆栈信息。 首先，工具的核心功能在于实时查看和控制进程。通过打开procexp主...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值