强行卸载DLL模块（转载）

最新推荐文章于 2022-08-19 16:13:40 发布
最新推荐文章于 2022-08-19 16:13:40 发布
阅读量8.4k 收藏 2
点赞数 1
文章标签： dll microsoft windows null winapi server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lanhai96/article/details/1765055
版权

卸载dll模块可以用于杀毒程序中


// 程序功能：结束进程中的一个模块。
// 程序日期：2006.10.8
// 程序说明：这个程序写于2003年，主要针对一些木马注入程序。以往结束远程注入木马(dll)时需要
// 结束进程，这个程序不用结束进程而直接结束单个DLL。结束后会出现一些问题，某些情况
//           下会导致整个进程异常，这是很正常的，例如结束了一个进程需要调用的DLL；或者结束后DLL
//           又被主进程加载，例如mfc42.dll。
// 程序原理：根据DLL地址范围找到进程用的DLL线程，结束这个线程即DLL。
// 调试参数：explorer.exe secur32.dll

#include <windows.h>
#include <stdio.h>
#include <TlHelp32.h>

#pragma warning(disable:4996)

#define OS_SDK 0

#define BUFSIZE 80

typedef enum _THREAD_INFORMATION_CLASS {

 ThreadBasicInformation,
 ThreadTimes,
 ThreadPriority,
 ThreadBasePriority,
 ThreadAffinityMask,
 ThreadImpersonationToken,
 ThreadDescriptorTableEntry,
 ThreadEnableAlignmentFaultFixup,
 ThreadEventPair,
 ThreadQuerySetWin32StartAddress,
 ThreadZeroTlsCell,
 ThreadPerformanceCount,
 ThreadAmILastThread,
 ThreadIdealProcessor,
 ThreadPriorityBoost,
 ThreadSetTlsArrayAddress,
 ThreadIsIoPending,
 ThreadHideFromDebugger

} THREAD_INFORMATION_CLASS, *PTHREAD_INFORMATION_CLASS;
typedef DWORD (CALLBACK* NTQUERYINFORMATIONTHREAD)(HANDLE,DWORD,PVOID,DWORD,PDWORD);

int GetVersionInfo()
{
 OSVERSIONINFOEX osvi;
 BOOL bOsVersionInfoEx;

 // Try calling GetVersionEx using the OSVERSIONINFOEX structure.
 // If that fails, try using the OSVERSIONINFO structure.

 ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);

 if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
 {
  osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
  if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) )
   return FALSE;
 }

 switch (osvi.dwPlatformId)
 {
  // Test for the Windows NT product family.
 case VER_PLATFORM_WIN32_NT:

  // Test for the specific product family.
  if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
   printf ("Microsoft Windows&nbsp;.NET Server&nbsp;2003 family, ");

  if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
   printf ("Microsoft Windows XP ");

  if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
   printf ("Microsoft Windows 2000 ");

  if ( osvi.dwMajorVersion <= 4 )
   printf("Microsoft Windows NT ");

  // Test for specific product on Windows NT 4.0 SP6 and later.
  if( bOsVersionInfoEx )
  {
#if OS_SDK
   // Test for the workstation type.
   if ( osvi.wProductType == VER_NT_WORKSTATION )
   {
    if( osvi.dwMajorVersion == 4 )
     printf ( "Workstation 4.0 " );
    else if( osvi.wSuiteMask & VER_SUITE_PERSONAL )
     printf ( "Home Edition " );
    else
     printf ( "Professional " );
   }

   // Test for the server type.
   else if ( osvi.wProductType == VER_NT_SERVER )
   {
    if( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
    {
     if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
      printf ( "Datacenter Edition " );
     else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
      printf ( "Enterprise Edition " );
     else if ( osvi.wSuiteMask == VER_SUITE_BLADE )
      printf ( "Web Edition " );
     else
      printf ( "Standard Edition " );
    }

    else if( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
    {
     if( osvi.wSuiteMask & VER_SUITE_DATACENTER )
      printf ( "Datacenter Server " );
     else if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
      printf ( "Advanced Server " );
     else
      printf ( "Server " );
    }

    else  // Windows NT 4.0
    {
     if( osvi.wSuiteMask & VER_SUITE_ENTERPRISE )
      printf ("Server 4.0, Enterprise Edition " );
     else
      printf ( "Server 4.0 " );
    }
   }
#endif
  }
  else  // Test for specific product on Windows NT 4.0 SP5 and earlier
  {
   HKEY hKey;
   char szProductType[BUFSIZE];
   DWORD dwBufLen=BUFSIZE;
   LONG lRet;

   lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
    "SYSTEM//CurrentControlSet//Control//ProductOptions",
    0, KEY_QUERY_VALUE, &hKey );
   if( lRet != ERROR_SUCCESS )
    return FALSE;

   lRet = RegQueryValueEx( hKey, "ProductType", NULL, NULL,
    (LPBYTE) szProductType, &dwBufLen);
   if( (lRet != ERROR_SUCCESS) || (dwBufLen > BUFSIZE) )
    return FALSE;

   RegCloseKey( hKey );

   if ( lstrcmpi( "WINNT", szProductType) == 0 )
    printf( "Workstation " );
   if ( lstrcmpi( "LANMANNT", szProductType) == 0 )
    printf( "Server " );
   if ( lstrcmpi( "SERVERNT", szProductType) == 0 )
    printf( "Advanced Server " );

   printf( "%d.%d ", osvi.dwMajorVersion, osvi.dwMinorVersion );
  }

  // Display service pack (if any) and build number.

  if( osvi.dwMajorVersion == 4 &&
   lstrcmpi( osvi.szCSDVersion, "Service Pack 6" ) == 0 )
  {
   HKEY hKey;
   LONG lRet;

   // Test for SP6 versus SP6a.
   lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
    "SOFTWARE//Microsoft//Windows NT//CurrentVersion//Hotfix//Q246009",
    0, KEY_QUERY_VALUE, &hKey );
   if( lRet == ERROR_SUCCESS )
    printf( "Service Pack 6a (Build %d)/n", osvi.dwBuildNumber & 0xFFFF );        
   else // Windows NT 4.0 prior to SP6a
   {
    printf( "%s (Build %d)/n",
     osvi.szCSDVersion,
     osvi.dwBuildNumber & 0xFFFF);
   }

   RegCloseKey( hKey );
  }
  else // Windows NT 3.51 and earlier or Windows 2000 and later
  {
   printf( "%s (Build %d)/n",
    osvi.szCSDVersion,
    osvi.dwBuildNumber & 0xFFFF);
  }


  break;

  // Test for the Windows 95 product family.
 case VER_PLATFORM_WIN32_WINDOWS:

  if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
  {
   printf ("Microsoft Windows 95 ");
   if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
    printf("OSR2 " );
   return 0;
  }

  if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
  {
   printf ("Microsoft Windows 98 ");
   if ( osvi.szCSDVersion[1] == 'A' )
    printf("SE " );
   return 0;
  }

  if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
  {
   printf ("Microsoft Windows Millennium Edition/n");
   return 0;
  }
  break;

 case VER_PLATFORM_WIN32s:

  printf ("Microsoft Win32s/n");
  return 0;
  break;
 }
 return TRUE;
}

// 函数功能：设置权限
BOOL SetPrivilege(LPCTSTR Privilege, BOOL bEnablePrivilege)
{
 HANDLE hToken, h;
 TOKEN_PRIVILEGES tkp;

 // 获得令牌
 typedef VOID (WINAPI *MYPROC1)(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
 MYPROC1 ProcAdd1 = (MYPROC1)GetProcAddress(GetModuleHandle(TEXT("Advapi32")), "OpenProcessToken");
 if (ProcAdd1 == NULL)
  return FALSE;
 h = GetCurrentProcess();
 if (h == NULL)
  return FALSE;
 ProcAdd1(h, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);

 // 开机关机权限
 typedef VOID (WINAPI *MYPROC2)( LPCTSTR lpSystemName, LPCTSTR lpName,  PLUID lpLuid);
 MYPROC2 ProcAdd2 = (MYPROC2)GetProcAddress(GetModuleHandle(TEXT("Advapi32")), "LookupPrivilegeValueA");
 if (ProcAdd2 == NULL)
  return FALSE;
 (ProcAdd2)(NULL, Privilege, &tkp.Privileges[0].Luid);

 // 第一次
 tkp.PrivilegeCount = 1;  // one privilege to set   
 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

 typedef VOID (WINAPI *MYPROC3)( HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState,  PDWORD ReturnLength);
 MYPROC3 ProcAdd3 = (MYPROC3)GetProcAddress(GetModuleHandle(TEXT("Advapi32")), "AdjustTokenPrivileges");
 if (ProcAdd3 == NULL)
  return FALSE;
 (ProcAdd3)(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);

 // 第二次
 tkp.PrivilegeCount = 1;  // one privilege to set   
 tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

 if(bEnablePrivilege)
  tkp.Privileges[0].Attributes |= (SE_PRIVILEGE_ENABLED);
 else
  tkp.Privileges[0].Attributes ^= (SE_PRIVILEGE_ENABLED & tkp.Privileges[0].Attributes);
 (ProcAdd3)(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);


 return TRUE;
}

// 函数功能：获取关机/重启权限
BOOL SetPrivilege_ShutDown()
{
 return SetPrivilege(SE_SHUTDOWN_NAME,true);
}

// 函数功能：获取关闭其它进程权限
int SetPrivilege_Debug()      
{
 return SetPrivilege(SE_DEBUG_NAME,true);
}

// 函数功能：获取文件的大小
// 函数返回：文件大小
DWORD GetFileSize(char *pFileName)
{
 FILE *pFile;
 DWORD dwPos;
 DWORD dwFileSize;

 if( (pFile  = fopen(pFileName, "rb" )) == NULL )
 {
  printf( "The file 'data' was not opened/n" );
  return 0;
 }

 dwPos = ftell(pFile);
 fseek(pFile, 0, SEEK_END);
 dwFileSize = ftell(pFile);
 fseek(pFile, dwPos, SEEK_SET);
 fclose(pFile);

 return dwFileSize;
}

// 函数功能：杀进程中的模块
typedef HANDLE (WINAPI *MYPROC1)(DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwThreadId);
int KillModule(char *strPName, char *strMName)
{
 char strDllName[MAX_PATH];
 HANDLE hProcess, hThread;
 DWORD dwStartAddr = 0;
 DWORD dwRetLen = 0;
 DWORD dwDllSize = 0;
 PWSTR pszLibFileRemote = NULL;
 int  nKilled = 0;
 BOOL fOk, fOK1;
 HANDLE hmeSnapshot;
 BOOL fME;
 char *pdest;
 HMODULE hNtdll;
 int  cch;
 int  cb;
 int  nDllKillNum;

 MYPROC1 ProcAdd1;

 PTHREAD_START_ROUTINE  pfnThreadRtn;
 NTQUERYINFORMATIONTHREAD NtQueryInformationThread;
 
 HANDLE hthSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
 PROCESSENTRY32 pe = { sizeof(pe) };
 MODULEENTRY32 me = { sizeof(me) };

 // 遍历所有进程
 fOk = Process32First(hthSnapshot, &pe);
 for (; fOk; fOk = Process32Next(hthSnapshot, &pe))
 {
  // 找到远程进程
  if (stricmp(pe.szExeFile, strPName) == 0)
  {
   // 遍历模块
   hmeSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, pe.th32ProcessID);
   fME = Module32First(hmeSnapshot, &me);
   for (; fME; fME = Module32Next(hmeSnapshot, &me))
   {
    strcpy(strDllName, me.szExePath);
    pdest = strrchr(strDllName, '//');
    strcpy(strDllName, ++pdest);

    // 找到远程进程中的模块， 杀之，3个步骤
    if (stricmp(strDllName, strMName) == 0)
    {
     __try
     {
      // 1.遍历模块中的线程，如果有结束
      dwDllSize = GetFileSize(me.szExePath);
      hthSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, me.th32ProcessID);
      if (hthSnapshot == NULL) __leave;
      THREADENTRY32 te = { sizeof(te) };
      fOK1 = Thread32First(hthSnapshot, &te);

      // 遍历线程
      for (; fOK1; fOK1 = Thread32Next(hthSnapshot, &te))
      {
       if (te.th32OwnerProcessID == pe.th32ProcessID)
       {
        __try
        {
         // 得到线程句柄
         ProcAdd1 = (MYPROC1)GetProcAddress(GetModuleHandle(TEXT("Kernel32")), "OpenThread");
         if (ProcAdd1 == NULL)
          return FALSE;
         hThread = (ProcAdd1(THREAD_ALL_ACCESS, FALSE, te.th32ThreadID));
         if (hThread == NULL) __leave;

         // 找到ntdll.dll中函数NtQueryInformationThread地址
         hNtdll = LoadLibrary( "ntdll.dll" );
         if (!hNtdll) return 0;
         NtQueryInformationThread = (NTQUERYINFORMATIONTHREAD)GetProcAddress(hNtdll, "NtQueryInformationThread");

         // 获取线程入口地址
         NtQueryInformationThread(hThread, ThreadQuerySetWin32StartAddress, &dwStartAddr, 0x4, &dwRetLen);
         if (dwStartAddr != NULL)
         {
          // 判断线程入口地址是否在模块中
          if ((dwStartAddr - (DWORD)me.hModule) <=  dwDllSize)
          {
           // 结束线程
           TerminateThread(hThread, 0);
           CloseHandle(hThread);
          }
         }
        }

        // 释放资源
        __except(EXCEPTION_EXECUTE_HANDLER)
        {
         return 0;
        }
       }
      } // for

      // 2.释放DLL
      // 获取远程进程中的DLL句柄
      hProcess = OpenProcess(
       PROCESS_QUERY_INFORMATION |   // Required by Alpha
       PROCESS_CREATE_THREAD     |   // For CreateRemoteThread
       PROCESS_VM_OPERATION      |   // For VirtualAllocEx/VirtualFreeEx
       PROCESS_VM_WRITE,             // For WriteProcessMemory
       FALSE, me.th32ProcessID);
      if (hProcess == NULL) __leave;

      // 计算DLL名称需要的字节数
      cch = 1 + strlen(me.szExePath);
      cb  = cch * sizeof(CHAR);

      // 分配远程进程路径名空间
      pszLibFileRemote = (PWSTR)VirtualAllocEx(hProcess, NULL, cb, MEM_COMMIT, PAGE_READWRITE);
      if (pszLibFileRemote == NULL) __leave;

      // 考贝DLL路径名到远程进程空间
      if (!WriteProcessMemory(hProcess, pszLibFileRemote, (PVOID)me.szExePath, cb, NULL)) __leave;

      // 得到GetModuleHandle在Kernel32.dll中的地址
      pfnThreadRtn = (PTHREAD_START_ROUTINE)GetProcAddress(GetModuleHandle(TEXT("Kernel32")), "FreeLibrary");
      if (pfnThreadRtn == NULL) __leave;

      // 创建远程进程，调用GetModuleHandle(DLLPathname)
      nDllKillNum = (me.GlblcntUsage > me.ProccntUsage) ? me.GlblcntUsage : me.ProccntUsage;
      if (nDllKillNum == 65535)
       nDllKillNum = 3;
      for (int i = 0; i < nDllKillNum; i++)
      {
       hThread = CreateRemoteThread(hProcess, NULL, 0, pfnThreadRtn, me.hModule, 0, NULL);
       if (hThread == NULL) __leave;
      }

      // 3.删除DLL
      //DeleteFile(me.szExePath);
      CloseHandle(hProcess);
      CloseHandle(hThread);
      printf("Killed !!!/n");
      nKilled = 1;
     }
     __finally
     {
      if (hthSnapshot != NULL)
       CloseHandle(hthSnapshot);
     }
    }// if
   } // for
  }
 }// for

 if (nKilled == 0)
  printf("Sorry, No found!/n");
  
 return 0;
}

int main(int argc, char **argv)
{
 printf("KillModule V1.0(2006). Welcome to myblog: www.blog.163.com/lanhai96");

 if (argc < 3)
 {
  printf("Parameter error./n");
  return 0;
 }

 // 看版本号
 if (!GetVersionInfo())
 {
  printf("Don't run at this OS./n");
  return 0;
 }

 // 获得权限
 SetPrivilege_Debug();

 // 结束模块
 KillModule(argv[1], argv[2]);

 return 0;
}

 
lanhai96
关注
如何安全的将远程DLL卸载，不会让程序崩溃
Qensq的博客
07-19 1454
卸载DLL 很多人是从外部卸载的，但是可能会造成程序的崩溃和异常，需要卸载的方式最好是放在内部操作。 通过执行DLL内部方法去卸载DLL本身，代码如下： VOID unDll() { HMODULE hmodel = NULL; GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,(LPCSTR) &unDll, &a...
python hook dll_Python——dll注入
weixin_39678493的博客
12-16 1276
dll攻击原理分析什么是dll动态链接库，是在微软Windows操作系统中实现共享函数库概念的一种方式。这些库函数的扩展名是 ”.dll"、".ocx"(包含ActiveX控制的库)或者 ".drv"(旧式的系统驱动程序)。为何有dll由于进程的地址空间是独立的(保护模式)，当多个进程共享相同的库时，每个库都在硬盘和进程彼此的内存存放一份的话，对于早期的计算机来说，无疑是一种极大的浪费，于是win...
易语言DLL自卸载
07-21
易语言DLL自卸载源码,DLL自卸载,Hello,Dll入口函数,zsxz,取自身模块句柄,卸载自身_
卸载Dll
qiuxue110的专栏
04-02 615
BOOL EjectDll(DWORD dwPID, LPCTSTR szDllName) { BOOL bMore = FALSE, bFound = FALSE; HANDLE hSnapshot, hProcess, hThread; HMODULE hModule = NULL; MODULEENTRY32 me = { sizeof(me) }; LPTHREAD_START_ROUTINE pThreadProc; // dwPID = 传入的进程id // 使用 TH32CS.
显式卸载DLL模块
ll2323001的专栏
04-15 1847
当进程中的线程不再需要DLL中的引用符号时，可以从进程的地址空间中显式卸载DLL，方法是调用下面的函数：     BOOL FreeLibrary(HINSTANCE hinstDll); 必须传递HINSTANCE值，以便标识要卸载的DLL。该值是较早的时候调用LoadLibrary(Ex)而返回的值。 也可以通过调用下面的函数从进程的地址空间中卸载DLL：     VO
`DLL`文件永久删除方法【只需两行代码】
aristo
08-19 1957
DLL文件删除方法[简单有效]
DLL卸载
qq_39249347的博客
08-24 1593
DLL卸载是将强制插入进程的DLL弹出的一种技术，其基本工作原理与使用CreateRemoteThread API进行DLL注入的原理类似。 DLL卸载工作的原理：将FreeLibrary() API的地址传递给CreateRemoteThread()的lpStartAddress参数，并把要卸载的DLL的句柄传递给lpParameter参数。 每个Windows内核对象都拥有一个引用计数，代表对象被被使用的次数，调用10次LoadLibrary(“a.dll”),a.dll的引用技术就变为10，卸载a..
用自删除dll实现应用程序的安装卸载代码
10-03
为了获取DLL的路径，可以使用`GetModuleFileName`函数，传入NULL参数以获取调用进程（即自删除DLL）的模块名。 在卸载阶段，自删除DLL同样可以发挥作用。例如，可以创建一个卸载程序入口点，该入口点在控制面板的...
Rundll32.exe在批处理里的应用
Steven的博客
10-11 867
Rundll32.exe的功能就是以命令列的方式呼叫Windows的动态链结库，Rundll32.exe与Rundll.exe的区别就在於前者是呼叫32位的链结库，而後者是运用於16位的链结库，它们的命令格式是∶ RUNDLL32.EXE ，， 这里要注意三点：1.Dll文件名中不能含有空格，比如该文件位于c:\Program Files\目录，你要把这个路径改成c:\Progra～1\；2
dll编程深入浅出（含源代码）
05-01
资料中提供的源代码实例可能包括创建DLL项目、导出函数、调用DLL函数、处理DLL初始化和卸载等场景。通过对这些代码的阅读和实践，读者可以更好地理解DLL的工作机制。 此外，DLL还涉及到一些高级话题，如API钩子...
DLL注入与卸载
05-22
实现window系统下的DLL注入与卸载
实现DLL的注入与卸载
05-07
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/wzxq123/article/details/514
DLL自卸载.rar
04-04
DLL自卸载.rar
教你如何卸载被注入到进程中的dll
04-04
RemoteDLL dllinject教你如何卸载被注入到进程中的dll
dll加载卸载工具（开源）
guoyi987的专栏
02-18 576
原本在VB梦工厂发过，也整理到这里来吧。 VC6开发，XP，2003测试正常运行。     远程注入方式实现LoadLibrary，FreeLibrary 附带遍历进程和模块dll功能。svchost等的系统进程不能遍历，没做处理。 用了破解的皮肤组件，可能360之类的软件会唧唧歪歪，不喜欢的可以去到代码里面去掉相关代码和调用的文件。   CSDN下载地址：http:/
第三课 DLL卸载
xuenixiang.com
08-02 358
先来看一下dll卸载的定义 先介绍引用计数的概念 #include "windows.h" #include "tlhelp32.h" #include "tchar.h" #define DEF_PROC_NAME (L"notepad.exe") #define DEF_DLL_NAME (L"myhack.dll") DWORD FindProcessID(LPCT...
用自删除dll实现应用程序的安装/卸载代码
weixin_33935505的博客
07-05 1219
译者按 本文译自 Alex Tilles 在Windows Developer Network（2003 第12期）发表的一篇文章：“Writing Your Own Install and Uninstall Code”。这是一篇具有一定技术含量的文章，相信许多开发人员都需要本文介绍的技术，其中包括几个重要的技术点： Rundll32.exe 实用程序的使用方法； DLL 或 EX...
NX/UG二次开发-其他-NX中MFC界面的dll卸载方案
门前大桥下，游过一群鸭，快来看一看，原来是C++
01-20 1780
NX二次开发工具有三种卸载方式，1、运行完毕自动卸载，2、用卸载镜像方式卸载，3关闭NX时卸载。在用MFC界面开发的dll，需要卸载镜像方式卸载。有时候发现无法卸载或卸载报错，原因是new非模态对话框时，并没有完全清除。清除方法也很简单，只需要在对话框类的OnDestroy中delete就可以了。 但对于调试的时候，每次都需要手动点击卸载镜像，然后才能重新编译，这样调试很麻烦，下面给出两个方案： 1、录制一个宏，功能是卸载全部镜像，然后添加到菜单，这样每次只需要点击一下就可以了； 2、单独写一个卸载镜
《逆向工程核心原理》----第24章DLL卸载
qq_55785697的博客
04-24 285
同DLL注入使用LoadLibrary一样，DLL卸载需要使用FreeLibrary。 1.使用CreateToolhelp32Snapeshoot（）API获取加载到进程中的dll信息 2.提权，LookupPrivilegeValue（）可以查看权限，AdjustTookenPrivilege（）可以禁用/启用函数 提权相关函数_爱沧海的博客-CSDN博客 提权函数的相关链接 3.之后同DLL注入过程类似，获取进程句柄，获取FreeLibrary（）地址，创建远程线程 <注>这种方
dotnet 6.0如何动态卸载dll文件
最新发布
05-18
在 .NET 6.0 中，可以使用 `AssemblyLoadContext` 类来实现动态卸载 DLL 文件。 以下是一个示例代码，演示如何加载和卸载一个 DLL 文件： ```csharp using System.IO; using System.Reflection; // 创建一个新的 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lanhai96

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值