精华内容
下载资源
问答
  • DLL注入技术之远线程注入

    千次阅读 2013-10-21 09:59:22
    刚好看到一个论坛上一系列简明的说dll注入的文章 特此转载 正规主题 作者: DLL注入技术之远线程注入 日期: 2013-05-31 来源: 黑客反病毒 (http://bbs.hackav.com) ...

    玩了这么久的hack,竟然到最近玩一个QQ显IP小软件的时候才知道注入是干什么用的,惭愧惭愧。刚好看到一个论坛上有一系列简明的说dll注入的文章 特此转载

    正规主题
    作者: DLL注入技术之远线程注入
    日期: 2013-05-31
    来源: 黑客反病毒 (http://bbs.hackav.com)
    出处: 黑客反病毒 (http://bbs.hackav.com)
    注意: 转载请务必附带本组信息,否则侵权必究!
    DLL注入技术之远线程注入

        DLL注入技术指的是将一个DLL文件强行加载到EXE文件中,并成为EXE文件中的一部分,这样做的目的在于方便我们通过这个DLL读写EXE文件内存数据,(例如 HOOK EXE文件中的API),或以被注入EXE的身份去执行一些操作等等。
        远线程注入原理是利用Windows 系统中CreateRemoteThread()这个API,其中第4个参数是准备运行的线程,我们可以将LoadLibrary()填入其中,这样就可以执行远程进程中的LoadLibrary()函数,进而将我们自己准备的DLL加载到远程进程空间中执行。
        当然除了CreateRemoteThread()和LoadLibrary()这个两个主要的API还是远远不够的,我们还需要以下表格所示的API:
    OpenProcess 打开远程进程
    VirtualAllocEx 在远程进程中申请空间
    WriteProcessMemory 在远程进程中写入数据
    WaitForSingleObject 等待信号量
    VirtualFreeEx 释放远程进程中申请空间
    CloseHandle 关闭句柄

    主要代码如下:
    1. int CRemoteThreadInjectDLL::InjectDll(DWORD dwProcessId, PTCHAR szDllName)  
    2. {  
    3.     if (szDllName[0] == NULL)  
    4.         return -1;  
    5.     //提高权限相关操作  
    6.     EnablePrivilege(TRUE);  
    7.     //1. 打开进程  
    8.     HANDLE hProcess = ::OpenProcess(  PROCESS_ALL_ACCESS,   //打开进程权限  
    9.         FALSE,                                              //是否可继承   
    10.         dwProcessId);                                       //进程ID  
    11.   
    12.     if (hProcess == INVALID_HANDLE_VALUE)  
    13.         return -1;  
    14.   
    15.     //2. 在远程进程中申请空间  
    16.     LPVOID pszDllName = ::VirtualAllocEx(hProcess, //远程进程句柄  
    17.         NULL,                                  //建议开始地址  
    18.         4096,                                  //分配空间大小  
    19.         MEM_COMMIT,                            //空间初始化全0  
    20.         PAGE_EXECUTE_READWRITE);               //空间权限  
    21.   
    22.     if (NULL == pszDllName)  
    23.     {  
    24.         return -1;  
    25.     }  
    26.   
    27.     //3. 向远程进程中写入数据  
    28.     BOOL bRet = ::WriteProcessMemory( hProcess, pszDllName,   
    29.         szDllName, MAX_PATH, NULL);  
    30.   
    31.     if (NULL == bRet)  
    32.     {  
    33.         return -1;  
    34.     }  
    35.   
    36.     //4. 在远程进程中创建远程线程  
    37.     m_hInjecthread = ::CreateRemoteThread(hProcess,      //远程进程句柄  
    38.         NULL,                                            //安全属性  
    39.         0,                                               //栈大小  
    40.         (LPTHREAD_START_ROUTINE)LoadLibrary,             //进程处理函数      
    41.         pszDllName,                                      //传入参数  
    42.         NULL,                                            //默认创建后的状态  
    43.         NULL);                                           //线程ID  
    44.   
    45.     if (NULL == m_hInjecthread)  
    46.     {  
    47.         DWORD dwErr = GetLastError();  
    48.         return -1;  
    49.     }  
    50.   
    51.     //5. 等待线程结束返回  
    52.     DWORD dw = WaitForSingleObject(m_hInjecthread, -1);  
    53.     //6. 获取线程退出码,即LoadLibrary的返回值,即dll的首地址  
    54.     DWORD dwExitCode;  
    55.     GetExitCodeThread(m_hInjecthread, &dwExitCode);  
    56.     m_hMod = (HMODULE)dwExitCode;  
    57.   
    58.     //7. 释放空间  
    59.     BOOL bReturn = VirtualFreeEx(hProcess, pszDllName,   
    60.         4096, MEM_DECOMMIT);  
    61.   
    62.     if (NULL == bReturn)  
    63.     {  
    64.         return -1;  
    65.     }  
    66.   
    67.     CloseHandle(hProcess);  
    68.     hProcess = NULL;  
    69.     //恢复权限相关操作  
    70.     EnablePrivilege(FALSE);  
    71.   
    72.     return 0;  
    73. }  

    此外,我们还需要提升进程权限以便于提高注入成功率,所需API如下表所示:
    OpenProcessToken 得到令牌句柄
    LookupPrivilegeValue 得到权限值
    AdjustTokenPrivileges 提升令牌句柄权限

    主要代码如下:
    1. int CRemoteThreadInjectDLL::EnablePrivilege(bool isStart)  
    2. {          
    3.     //1. 得到令牌句柄  
    4.     HANDLE  hToken = NULL;      //令牌句柄    
    5.     if (!OpenProcessToken( GetCurrentProcess(),   
    6.         TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY | TOKEN_READ,   
    7.         &hToken))  
    8.     {     
    9.         return FALSE;  
    10.     }  
    11.   
    12.     //2. 得到特权值  
    13.     LUID    luid = {0};         //特权值  
    14.     if (!LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid))  
    15.     {  
    16.         return FALSE;  
    17.     }  
    18.     //3. 提升令牌句柄权限  
    19.     TOKEN_PRIVILEGES tp = {0};  //令牌新权限  
    20.     tp.PrivilegeCount = 1;   
    21.     tp.Privileges[0].Luid = luid;  
    22.     tp.Privileges[0].Attributes = isStart ? SE_PRIVILEGE_ENABLED : 0;  
    23.     if (!AdjustTokenPrivileges(hToken, FALSE, &tp, 0, NULL, NULL))  
    24.     {  
    25.         return FALSE;  
    26.     }  
    27.     //4. 关闭令牌句柄  
    28.     CloseHandle(hToken);  
    29.     return 0;  
    30. }  

    当要在指定的进程中加载DLL时,我们就需要过滤指定名称的进程,这时遍历进程ID并进行对比,得到所指定的进程,所需API如表所示:
    CreateToolhelp32Snapshot   创建进程快照  
    Process32First   第一个进程快照
    Process32Next   循环下一个进程快照  

    主要代码如下:
    1. DWORD CRemoteThreadInjectDLL::GetProcessId(PTCHAR pszProcessName)  
    2. {  
    3.     HANDLE hProcess = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);  
    4.   
    5.     if (INVALID_HANDLE_VALUE == hProcess)  
    6.     {  
    7.         return 0;  
    8.     }  
    9.   
    10.     DWORD dwProcessId = 0;  
    11.   
    12.     PROCESSENTRY32 process32 = {0};  
    13.     process32.dwSize = sizeof(PROCESSENTRY32);  
    14.   
    15.     BOOL bRetProcess = FALSE;  
    16.     bRetProcess = ::Process32First(hProcess, &process32);  
    17.   
    18.     do  
    19.     {  
    20.         if (_tcscmp(pszProcessName, process32.szExeFile) == 0)  
    21.         {  
    22.             dwProcessId = process32.th32ProcessID;  
    23.             break;  
    24.         }  
    25.   
    26.         bRetProcess = ::Process32Next(hProcess, &process32);  
    27.     }while (bRetProcess);  
    28.     ::CloseHandle(hProcess);  
    29.   
    30.     return dwProcessId;  
    31. }  

    远线程注入API使用较多,不易实现。但是可以批量注入和卸载,这样对于需要反复调试的注入就非常的方便。
    测试代码下载地址请到原帖地址下载,http://bbs.hackav.com/thread-8895-1-1.html
    展开全文
  • 利用输入法注入DLL

    2013-05-19 22:45:22
    全软件屏蔽的DLL注入方法,后来发现,输入法程序就是能完成这一任务的理想人选。输入 法程序程序到底是什么?它没有自己的进程,并且在系统还没有登录时就已被加载(在欢迎 界面你也可以调出输入法),它可以在...
  • DLL注入,除了线程注入,消息钩子注入,输入法注入外,还有一种就是内存注入 那么什么是内存注入呢? 内存注入就是指内存中加载并且执行DLL文件,这样的注入方式好处以下几点: 1.不需要把DLL文件暴露在出来(防止...

    DLL注入,除了线程注入,消息钩子注入,输入法注入外,还有一种就是内存注入

    那么什么是内存注入呢?
    内存注入就是指内存中加载并且执行DLL文件,这样的注入方式好处有以下几点:
    1.不需要把DLL文件暴露在出来(防止别人拿着你的DLL文件改装成自己的程序或者破解)
    内存DLL不需要写出到硬盘上即可使用.只要用易语言编译出来DLL后,加入到图片资源中,即可直接在内存用运行使用.

    2.安全性高,注入到对方进程后,对方进程如果有检测非法DLL文件加载,一般是检测不到的,
    因为枚举进程模块文件找不到DLL文件,因为DLL不再是模块文件,也没有DLL名称,而是一段内存机器码了.
    除非搜整个进程空间内存来查找DLL代码数据特征

    来看下Game-EC 最新版本模块里的这个命令 内存安装DLL 的参数信息
    子程序名:内存安装DLL
    失败返回0,成功返回内存DLL在目标进程里的地址,可以用 内存释放DLL () 进行释放
    返回值类型:整数型
    参数<1>的名称为“进程句柄”,类型为“整数型”。注明: 。
    参数<2>的名称为“DLL_数据”,类型为“字节集”。注明:把DLL文件放在易语言的资源在这里#DLL文件.
    参数<3>的名称为“绑定线程”,类型为“整数型”,允许接收空参数数据。注明:尽量使用绑定线程的方式加载,
    不然可能会产生窗口无法载入呼出等一些不确定的问题.

    其实这个 内存安装DLL() 的用法很简单与 安装线程DLL() 基本差不多,
    唯一不同的是 参数二是DLL文件字节集数据,提供图片资源名即可.不用把dll文件写出,内存加载即可
    下面代码是 EXE 的(注入器的代码)
    如图:
    在这里插入图片描述下面代码是内存注入DLL的DLL文件代码
    在这里插入图片描述
    win7 测试
    在这里插入图片描述在这里插入图片描述
    需要注意的是 只有内存安装DLL()
    是用来注Game-EC模块所编译的DLL,如果你拿其他语言写的DLL文件,使用内存安装DLL
    来进行内存方式注入的话可能会失败的。

    DLL 得使用 编译 来编译,并且提示是否写出所需支持库,选择否即可!

    本功能目前只测试过:xp,2003,win7 32位 64位 ,win8 32位系统
    特别提醒:
    如果注入个别游戏出现奔溃,
    可能是DLL 窗口里 使用了 “标签”、“透明标签”、“易语言自带时钟这几样组件” 。
    如果要使用标签请用编辑框代替,时钟请用模块自带的 时间_创建时钟() 再试。
    本文章转载来自:http://bbs.dult.cn/thread-10510-1-1.html 源码下载进入此原创地址

    展开全文
  • 远程注入DLL

    2011-09-25 23:08:00
    至于为什么要使用远程DLL注入我就不了多说了,既然大家要,肯定各种各样的目的。 简单来说,就是利用API在宿主程序里运行我们的程序(代码等),以达到我们自己想要的效果和目的。 在阅读本文之前,想必以下...
     
     
    至于为什么要使用远程DLL注入我就不了多说了,既然大家要用,肯定有各种各样的目的。
    简单来说,就是利用API在宿主程序里运行我们的程序(代码等),以达到我们自己想要的效果和目的。
     
    在阅读本文之前,想必以下几个API函数大家应该都有所了解我就不一一介绍了,关于函数的详细功能和介绍请参阅MSDN吧!

    OpenProcess-用于打开宿主的目标进程。
    VirtualAllocEx/VirtualFreeEx-用于在宿主进程中分配/释放内存空间。
    WriteProcessMemory-用于在宿主进程中写入要加载的DLL名称。
    CreateRemoteThread-远程加载DLL的核心内容,用于控制目标进程调用API函数。
    LoadLibrary-目标进程通过调用此函数来加载我们的DLL或者我们要执行的代码
     
    下面是远程注入DLL的具体代码,慢慢看看吧!
    #include "stdafx.h"

    #include
    <windows.h>
    #include
    <string>
    #include
    "stdio.h"
    #include
    <iostream>
    using namespace std;

    #define DEF_BUF_SIZE 1024

    // 用于存储注入模块DLL的路径全名
    char szDllPath[DEF_BUF_SIZE] = {0} ;

    // 使用远程线程向指定ID的进程注入模块
    BOOL InjectModuleToProcessById ( DWORD dwProcessId )
    {
    if ( dwProcessId == 0 )
    return FALSE ;

    // 打开进程
    HANDLE hProcess = OpenProcess ( PROCESS_ALL_ACCESS, FALSE, dwProcessId ) ;
    if ( hProcess == NULL )
    return FALSE ;

    //申请存放文件名的空间
    UINT nLen = (UINT)strlen ( szDllPath ) + 1;
    LPVOID lpRemoteDllName
    = VirtualAllocEx ( hProcess, NULL, nLen, MEM_COMMIT, PAGE_READWRITE ) ;
    if ( lpRemoteDllName == NULL )
    {
    printf (
    "[ERROR]VirtualAllocEx(%d)\n", GetLastError() );
    return FALSE ;
    }

    //把dll文件名写入申请的空间
    if ( WriteProcessMemory ( hProcess, lpRemoteDllName, szDllPath, nLen, NULL) == FALSE )
    {
    printf (
    "[ERROR]WriteProcessMemory(%d)\n", GetLastError() );
    return FALSE ;
    }

    //获取动态链接库函数地址
    HMODULE hModule = GetModuleHandle ( L"kernel32.dll" ) ;
    LPTHREAD_START_ROUTINE fnStartAddr
    = ( LPTHREAD_START_ROUTINE )GetProcAddress(hModule,"LoadLibraryA") ;
    if ( (DWORD)fnStartAddr == 0 )
    {
    printf (
    "[ERROR]GetProcAddress(%d)\n", GetLastError() );
    return FALSE ;
    }

    //创建远程线程
    HANDLE hRemoteThread = CreateRemoteThread ( hProcess, NULL, 0,fnStartAddr, lpRemoteDllName, 0, NULL ) ;
    if ( hRemoteThread == NULL )
    {
    printf (
    "[ERROR]CreateRemoteThread(%d)\n", GetLastError() );
    return FALSE ;
    }

    // 等待远程线程结束
    if ( WaitForSingleObject ( hRemoteThread, INFINITE ) != WAIT_OBJECT_0 )
    {
    printf (
    "[ERROR]WaitForSingleObject(%d)\n", GetLastError() );
    return FALSE ;
    }

    CloseHandle ( hRemoteThread ) ;
    CloseHandle ( hModule ) ;
    CloseHandle ( hProcess ) ;
    return TRUE ;
    }


    看过上面的代码,思路应该就很清晰了,大家快去试试吧!

    下次,我将写一个C#或者JAVA版的远程注入DLL的DEMO,有兴趣的朋友就关注一下啦,嘿嘿!

    本文章来自【龙歌网络】博客园(http://www.cnblogs.com/longle/archive/2011/06/04/2072934.html),转载就注明出处哦!

     

    转载于:https://www.cnblogs.com/longle/archive/2011/09/25/2072934.html

    展开全文
  • IAT HOOK 代码注入DLL

    2011-12-07 21:27:51
    没有什么高级技术 纯体力活 原理就不说了 只是没有通过DLL注入 来实现HOOK API 纯粹注入代码 邪恶二进制上 也个代码注入的 只是了一个未公开的函数,我还看不懂 = =本来想汇编写的 发现汇编注入...
     
    使用代码注入来实现进程隐藏  而不是使用DLL注入来实现进程隐藏
    没有什么高级技术  纯体力活  原理就不说了  只是没有通过DLL注入  来实现HOOK API
    纯粹注入代码   邪恶二进制上 也有个代码注入的 只是用了一个未公开的函数,我还看不懂
    = =本来想用汇编写的  发现汇编注入代码远比C注入代码来的繁  所以用C实现了
    主要功能就是 隐藏进程   不过RING3的似乎没多大用  练习而已
    代码如下:
    //需要编译成release版本  DEBUG版本 对函数生成的跳转地址表
    //jmp xxxxx  写入远程进程的时候xxxxx等于写入了一个全局变量
    // 程序必然崩溃
    #include "Iat_Hook.h"


    char cPath[] = "taskmgr.exe";

    void main(void)
    {
      //定义变量
      DWORD dwPid;
      HANDLE hProcess;
      DWORD dwSize = 2048;
      PVOID pRemoteAddress, pRemoteStructAddress,MyAddress;
      REMOTESTRUCT stRemoteStruct;

      //遍历进程 寻找taskmgr.exe进程ID
        dwPid = GetProcessPid(cPath);

      // open process 得到进程句柄
      hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwPid);
      if(hProcess == NULL)
      {
        printf("open error code %d\n",GetLastError());
        return;
      }
      
      //写入 替代函数
      MyAddress = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
      WriteProcessMemory(hProcess, MyAddress, myNtQuerySystemInformation, dwSize, NULL);

      //初始化结构
      InitializeStruct(&stRemoteStruct, (DWORD)MyAddress, dwPid);

      //写入结构
      pRemoteStructAddress = VirtualAllocEx(hProcess, NULL, sizeof(REMOTESTRUCT), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
      WriteProcessMemory(hProcess, pRemoteStructAddress, &stRemoteStruct, sizeof(REMOTESTRUCT), NULL);

      //写入远程线程函数
      pRemoteAddress = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
      WriteProcessMemory(hProcess, pRemoteAddress, RemoteThread, dwSize, NULL);

      //创建远程线程
      CreateRemoteThread(hProcess, NULL, 0, pRemoteAddress,pRemoteStructAddress, 0, 0);
      CloseHandle(hProcess);
    }

    DWORD __stdcall RemoteThread(PREMOTESTRUCT pRemoteStruct)
    {
      FARPROC fpVirtualQuery;
      FARPROC fpVirtualProtect;
      FARPROC fpOpenProcess;
      FARPROC fpEnum;
      FARPROC fpGetProcAddress;
      FARPROC fpLoadLibrary;
      FARPROC fpFreeLibrary;
      FARPROC fpWriteMemory;
      FARPROC fplstrcmp;

      HANDLE hProcess = NULL;
      HMODULE hMods[256];
      DWORD dwNeed;
      HANDLE hPsapi;
      MEMORY_BASIC_INFORMATION stMem;
      HMODULE hKernel, hModule;
      PIMAGE_NT_HEADERS pImageNtHeaders;
      PIMAGE_OPTIONAL_HEADER pImageOptionalHeader;
      IMAGE_DATA_DIRECTORY ImageImport;
      PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor;
      PIMAGE_THUNK_DATA pImageThunkData;
      DWORD oldProtect;
      wchar_t *p = pRemoteStruct->cProcessName;

      //初始化函数指针
      fpVirtualQuery = (FARPROC)pRemoteStruct->dwVirtualQuery;
      fpVirtualProtect = (FARPROC)pRemoteStruct->dwVirtualProtect;
      fpOpenProcess = (FARPROC)pRemoteStruct->dwOpenProcess;
      fpLoadLibrary = (FARPROC)pRemoteStruct->dwLoadLibrary;
      fpFreeLibrary = (FARPROC)pRemoteStruct->dwFreeLibrary;
      fpGetProcAddress = (FARPROC)pRemoteStruct->dwGetProcAddress;
      fpWriteMemory = (FARPROC)pRemoteStruct->dwWriteProcessMemory;
      fplstrcmp = (FARPROC)pRemoteStruct->dwlstrcmp;

      //得到进程句柄
      hProcess =(HANDLE)fpOpenProcess(PROCESS_ALL_ACCESS, FALSE, pRemoteStruct->dwPid);
      if(!hProcess)
        return 0;

      //得到模块基址 模块基址存放于hMods[0]
      hPsapi = (HANDLE)fpLoadLibrary(pRemoteStruct->cDllName);
      fpEnum = (FARPROC)fpGetProcAddress(hPsapi, pRemoteStruct->cFunName);
      fpEnum(hProcess, hMods, sizeof(hMods), &dwNeed);
      fpFreeLibrary(hPsapi);
      hModule = hMods[0];

      //改变内存属性  因为采用的不是DLL插入 NtQuerySystemInformation的原始地址无法通过
      //全局变量传递给 替代函数 这里通过把函数地址写入kernel的PE头 来实现 这样只需要在替代函数中读出地址就可以了
      hKernel = (HANDLE)fpLoadLibrary(pRemoteStruct->cKernel);
      fpVirtualQuery(hKernel,&stMem, sizeof (MEMORY_BASIC_INFORMATION));
      fpVirtualProtect(stMem.BaseAddress, stMem.RegionSize, PAGE_READWRITE, &stMem.Protect);
      fpWriteMemory(hProcess, (PBYTE)(hKernel)+4, &pRemoteStruct->dwNtQuerySystem, sizeof(DWORD), NULL);
      fpWriteMemory(hProcess, (PBYTE)(hKernel)+8, &pRemoteStruct->dwlstrcmpW, sizeof(DWORD), NULL);
      fpWriteMemory(hProcess, (PBYTE)(hKernel)+0x14, &p, sizeof(DWORD), NULL);
      fpVirtualProtect(stMem.BaseAddress, stMem.RegionSize, stMem.Protect, &oldProtect);

      //查找导入表 找到存放NtQuerySystemInformation
      pImageNtHeaders = (PIMAGE_NT_HEADERS)((DWORD)*((PBYTE)hModule+0x3c) + (DWORD)hModule);
      pImageOptionalHeader = &pImageNtHeaders->OptionalHeader;
        ImageImport = pImageOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
      pImageImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)(ImageImport.VirtualAddress + (DWORD)hModule);

      while(pImageImportDescriptor->Name)
      {
        if(0 == fplstrcmp(pRemoteStruct->cNtdll, (PSTR)(pImageImportDescriptor->Name + (DWORD)hModule)))
        {      
          break;
        }
        pImageImportDescriptor++;
      }
      //替换 NtQuerySystemInformation的地址
      pImageThunkData = (PIMAGE_THUNK_DATA)(pImageImportDescriptor->FirstThunk + (DWORD)hModule);
      while(pImageThunkData->u1.Function)
      {
        if(pImageThunkData->u1.Function == pRemoteStruct->dwNtQuerySystem)
        {
          fpVirtualQuery(&pImageThunkData->u1.Function, &stMem, sizeof (MEMORY_BASIC_INFORMATION));
          fpVirtualProtect(stMem.BaseAddress, stMem.RegionSize, PAGE_READWRITE, &stMem.Protect);
          pImageThunkData->u1.Function =  pRemoteStruct->dwMyAddress;
          break;
        }
        pImageThunkData++;
      }
      fpVirtualProtect(stMem.BaseAddress, stMem.RegionSize, stMem.Protect, &oldProtect);
      return 0;
    }

    NTSTATUS WINAPI myNtQuerySystemInformation  (
                  SYSTEM_INFORMATION_CLASS SystemInformationClass,
            PVOID SystemInformation,
              ULONG SystemInformationLength,
                    PULONG ReturnLength)
    {
      HANDLE hKernel;
      NTSTATUS ntStatus;
      wchar_t *pName;
      PSYSTEM_PROCESS_INFORMATION pCurrent, pForward;

      FARPROC fpNtQuerySystem;
      FARPROC fplstrcmpW;

      //寻找kernel32的基址  准备读取需要用到的函数地址
      _asm 
      {
        mov eax,fs:[0x30]
        mov eax,[eax+0xc]
        mov ecx,[eax+0x1c]
        mov ecx, [ecx]
        mov eax, [ecx+8]
        mov hKernel,eax
      }
      //取得函数地址
      fpNtQuerySystem = *(FARPROC *)((DWORD)hKernel + 4);
      fplstrcmpW = *(FARPROC *)((DWORD)hKernel + 8);
      //取得 需隐藏的进程名
      pName = *(wchar_t **)((DWORD)hKernel + 0x14);

      ntStatus = (NTQUERYSYSTEMINFORMATION)fpNtQuerySystem(SystemInformationClass, SystemInformation, SystemInformationLength, ReturnLength);
      if (SystemProcessesAndThreadsInformation == SystemInformationClass)
      {
        pForward = NULL;
        pCurrent = (PSYSTEM_PROCESS_INFORMATION)SystemInformation;
        while(pCurrent->NextEntryDelta)//检验是否到 最后一个进程结构
        {
          if(pCurrent->ProcessName.Buffer)
          {
            //_asm int 3
            if(0 == fplstrcmpW(pCurrent->ProcessName.Buffer, pName))
            {
              if(pForward)
              {
                if(pCurrent->NextEntryDelta)//隐藏的进程在链表中间              
                {
                  pForward->NextEntryDelta += pCurrent->NextEntryDelta;
                }
                else//隐藏的进程在链表末端
                  pForward->NextEntryDelta = 0;
              }
              else //要隐藏的进程在链表头时
              {
                if(pCurrent->NextEntryDelta)
                {
                  SystemInformation = (PBYTE)pCurrent + pCurrent->NextEntryDelta;
                }
                else
                  SystemInformation = NULL;
              }
            }
          }
            pForward = pCurrent;
            pCurrent = (PSYSTEM_PROCESS_INFORMATION)(pCurrent->NextEntryDelta + (PBYTE)pForward);
        }
        //_asm int 3
      }
      return ntStatus;
    }


    //得到进程PID
    DWORD GetProcessPid(char *cPath)
    {
      PROCESSENTRY32 stProcess;
      HANDLE hSnap;
      BOOL bRet;
      hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
      if(hSnap == INVALID_HANDLE_VALUE)
      {
        printf("error\n");
        return 0;
      }
      stProcess.dwSize = sizeof (PROCESSENTRY32);
      bRet = Process32First(hSnap, &stProcess);
      if(!bRet)
      {
        printf("first error\n");
        return 0;
      }
      do
      {
        if(0 == strcmp(stProcess.szExeFile, cPath)) //find  process of target
        {
          break;
        }
      }while(Process32Next(hSnap, &stProcess));

      //确认 是否找到 目标进程
      if(0 != strcmp(stProcess.szExeFile, "taskmgr.exe"))
      {
        printf("can not find process\n");
        return 0;
      }
      CloseHandle(hSnap);
      return stProcess.th32ProcessID;
    }

    VOID InitializeStruct(PREMOTESTRUCT pRemoteStruct, DWORD MyAddress, DWORD dwPid)
    {
      HANDLE hNtdll;
      HANDLE hKernel;

      hNtdll = LoadLibrary("ntdll.dll");
      pRemoteStruct->dwNtQuerySystem = (DWORD)GetProcAddress(hNtdll, "NtQuerySystemInformation");
      FreeLibrary(hNtdll);

      hKernel = LoadLibrary("kernel32.dll");
      pRemoteStruct->dwVirtualProtect = (DWORD)GetProcAddress(hKernel, "VirtualProtect");
      pRemoteStruct->dwVirtualQuery = (DWORD)GetProcAddress(hKernel, "VirtualQuery");
      pRemoteStruct->dwOpenProcess = (DWORD)GetProcAddress(hKernel, "OpenProcess");
      pRemoteStruct->dwGetProcAddress = (DWORD)GetProcAddress(hKernel, "GetProcAddress");
      pRemoteStruct->dwFreeLibrary = (DWORD)GetProcAddress(hKernel, "FreeLibrary");
      pRemoteStruct->dwLoadLibrary = (DWORD)GetProcAddress(hKernel, "LoadLibraryA");
      pRemoteStruct->dwWriteProcessMemory = (DWORD)GetProcAddress(hKernel, "WriteProcessMemory");
      pRemoteStruct->dwlstrcmp = (DWORD)GetProcAddress(hKernel, "lstrcmpA");
      pRemoteStruct->dwlstrcmpW = (DWORD)GetProcAddress(hKernel, "lstrcmpW");
      FreeLibrary(hKernel);
      
      pRemoteStruct->dwMyAddress = MyAddress;
      pRemoteStruct->dwPid = dwPid;
      strcpy(pRemoteStruct->cDllName, "Psapi.dll");
      strcpy(pRemoteStruct->cFunName, "EnumProcessModules");
      strcpy(pRemoteStruct->cKernel,"Kernel32.dll");
      strcpy(pRemoteStruct->cNtdll, "ntdll.dll");
            //要隐藏的进程名
      wcscpy(pRemoteStruct->cProcessName, L"explorer.exe");
    }

    Iat_Hook.h

    //头文件
    #include <windows.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <tlhelp32.h>
    #include <imagehlp.h>
    #include "Winternl.h"

    #pragma comment(lib, "imagehlp")
    //类型声明

    typedef int NTSTATUS;
    typedef BOOL (__stdcall *ENUMPROCESSMODULES)(
                HANDLE hProcess,
                HMODULE* lphModule,
                DWORD cb,
                LPDWORD lpcbNeeded
    );

    typedef NTSTATUS (WINAPI *NTQUERYSYSTEMINFORMATION)(
                SYSTEM_INFORMATION_CLASS SystemInformationClass,
                PVOID SystemInformation,
                ULONG SystemInformationLength,
                PULONG ReturnLength
    );

    typedef struct _REMOTE_STRUCT
    {
      DWORD dwNtQuerySystem;
      DWORD dwVirtualQuery;
      DWORD dwVirtualProtect;
      DWORD dwOpenProcess;
      DWORD dwMessageBox;
      DWORD dwLoadLibrary;
      DWORD dwGetProcAddress;
      DWORD dwFreeLibrary;
      DWORD dwWriteProcessMemory;
      DWORD dwlstrcmp;
      DWORD dwlstrcmpW;
      DWORD dwEnum;
      DWORD dwMyAddress;
      DWORD dwPid;
      char cDllName[50];
      char cFunName[50];
      char cKernel[50];
      char cNtdll[50];
      wchar_t cProcessName[50];//要隐藏的进程名
    }REMOTESTRUCT, *PREMOTESTRUCT;

    //函数声明
    DWORD GetProcessPid(char *cPath);
    DWORD __stdcall RemoteThread(PREMOTESTRUCT pRemoteStruct);
    VOID InitializeStruct(PREMOTESTRUCT pRemoteStruct, DWORD MyAddress, DWORD dwPid);
    NTSTATUS WINAPI myNtQuerySystemInformation  (
                  SYSTEM_INFORMATION_CLASS SystemInformationClass,
            PVOID SystemInformation,
              ULONG SystemInformationLength,
                    PULONG ReturnLength);

    Winternl.h

    typedef struct _UNICODE_STRING { 
      USHORT Length; 
      USHORT MaximumLength; 
      PWSTR  Buffer;                 //注意,这里为Unicode类型
    } UNICODE_STRING, *PUNICODE_STRING;

    typedef enum _SYSTEM_INFORMATION_CLASS {
    SystemBasicInformation,
    SystemProcessorInformation,
    SystemPerformanceInformation,
    SystemTimeOfDayInformation,
    SystemNotImplemented1,
    SystemProcessesAndThreadsInformation,
    SystemCallCounts,
    SystemConfigurationInformation,
    SystemProcessorTimes,
    SystemGlobalFlag,
    SystemNotImplemented2,
    SystemModuleInformation,
    SystemLockInformation,
    SystemNotImplemented3,
    SystemNotImplemented4,
    SystemNotImplemented5,
    SystemHandleInformation,
    SystemObjectInformation,
    SystemPagefileInformation,
    SystemInstructionEmulationCounts,
    SystemInvalidInfoClass1,
    SystemCacheInformation,
    SystemPoolTagInformation,
    SystemProcessorStatistics,
    SystemDpcInformation,
    SystemNotImplemented6,
    SystemLoadImage,
    SystemUnloadImage,
    SystemTimeAdjustment,
    SystemNotImplemented7,
    SystemNotImplemented8,
    SystemNotImplemented9,
    SystemCrashDumpInformation,
    SystemExceptionInformation,
    SystemCrashDumpStateInformation,
    SystemKernelDebuggerInformation,
    SystemContextSwitchInformation,
    SystemRegistryQuotaInformation,
    SystemLoadAndCallImage,
    SystemPrioritySeparation,
    SystemNotImplemented10,
    SystemNotImplemented11,
    SystemInvalidInfoClass2,
    SystemInvalidInfoClass3,
    SystemTimeZoneInformation,
    SystemLookasideInformation,
    SystemSetTimeSlipEvent,
    SystemCreateSession,
    SystemDeleteSession,
    SystemInvalidInfoClass4,
    SystemRangeStartInformation,
    SystemVerifierInformation,
    SystemAddVerifier,
    SystemSessionProcessesInformation
    } SYSTEM_INFORMATION_CLASS;

    typedef struct _SYSTEM_PROCESS_INFORMATION  
    {  
        DWORD NextEntryDelta;  
        DWORD dThreadCount;  
        DWORD dReserved01;  
        DWORD dReserved02;  
        DWORD dReserved03;  
        DWORD dReserved04;  
        DWORD dReserved05;  
        DWORD dReserved06;  
        FILETIME ftCreateTime; /* relative to 01-01-1601 */  
        FILETIME ftUserTime; /* 100 nsec units */  
        FILETIME ftKernelTime; /* 100 nsec units */  
        UNICODE_STRING ProcessName;      //这就是进程名
        DWORD BasePriority;  
        DWORD dUniqueProcessId;            //进程ID
        DWORD dParentProcessID;  
        DWORD dHandleCount;  
        DWORD dReserved07;  
        DWORD dReserved08;  
        DWORD VmCounters;  
        DWORD dCommitCharge;  
        PVOID ThreadInfos[1]; 
    } SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
    展开全文
  • 代码注入 API HOOK(非DLL)

    千次阅读 2008-10-14 08:53:00
    使用代码注入来实现进程隐藏 而不是使用DLL注入来实现进程隐藏 没有什么高级技术 纯体力活 原理就不说了 只是没有通过DLL注入 来实现HOOK API从核心编程 以来 似乎 一提到C注入 就是DLL注入 很奇怪 为什么没人...
  • 事情的起因是这样的最近在研究x64下的inline Hook不会调试,一直MessageBox加Cheat Engine,很郁闷想着简单的办法没有,于是百度了下,原作者连接然后我知道了远程调试的话要Detours库,好吧那就整这个库翻墙...
  • 比如某多很像梦幻的游戏~ 解除只能开几个的限制 而且还能组队~(记得把虚拟网卡全删了 虚拟机的也不行) 其他游戏我没测试 但你们玩某些游戏给封硬盘序号的 可以找注入器把True.dll注入进去 最好是自己加个壳 修改...
  • 远程注入执行函数

    千次阅读 2013-01-29 23:13:46
    下午正好人问怎么注入线程,在公司《windows核心编程》的注入DLL程序修改了一下,实现了远程注入DLL调用函数。刚才回来,觉得照着别人的程序改,总还是学不到家,自己花了两个小时写了一个。能注入到其他进程中...
  • 另外说一下,其实我是要向受保护的进程中注入DLL,我想KeAttackStackProcess附加到目标进程之后,调用LoadLibrary加载自己想要加载的DLL,不知道这样可不可行,没有什么比较简单的方法。。。 本人是新手,不要...
  • 人问学完了C可以做什么,似乎好像什么也做不了,其实你学完了,你就可以你学的这些知识做到Windows系统下的一切,因为WIndows的基层本身也是C写的你只要熟悉这些函数就行了,甚至你超越现在的Windows系统,...
  • 中控台利用收到的数据做一些处理后再将关键信息传递给dll,告诉dll接下来该做什么操作。 那么就可以管道的方式做数据传输,支持双向读写通信。 当然跨进程通讯的方式很多种,服务器,客户,数据包,文件独写,...
  • 逆向分析-扫雷

    2020-10-22 11:29:31
    1.分别以两种方式写辅助工具,MFC的辅助工具,DLL注入补丁模式的辅助工具。 2.功能:暂停时间、无限插旗数量、根据鼠标坐标得知是否雷、一键获胜、一键镖旗、更改初级难度、中级难度、高级难度。 2.具体分析过程 ...
  • C/C++日志的日常使用

    2020-05-12 16:41:34
    作为一名学习程序的学生,在学习中编写过的代码、程序,没有日志功能,刚开始的时候,完全不知道日志的使用有什么意义,感觉特别鸡肋,出现问题,我自己调试一下完全都可以解决的事情,为什么要通过日志来输出。...
  • 蝙蝠与飞蛾的启示

    千次阅读 2006-08-17 16:02:00
    但现在都流行dll注入的了。在进程列表里找不到。只好查找进程调用的模块。但是模块实在太多了。tasklist /M 命令一看,密密麻麻的几页呢。但我发现注入的module大多都是临时写写,很少还会提供一个版本信息资料。
  • 远程线程插入代码

    千次阅读 2007-02-11 00:11:00
    远程线程插入代码玩过远程控制的朋友...有什么用呢?怎么实现呢?如果想边听边跟着我的代码调试需要NT系统,如果谁是9X/Me说一声你的某些代码需要稍微改下只是听就不要紧了首先要明白什么是线程说到线程就不得不提到
  • 第22章 DLL注入和API拦截 22.1 DLL注入的一个例子 22.2 使用注册表来注入DLL 22.3 使用Windows挂钩来注入DLL 22.4 使用远程线程来注入DLL 22.4.1 Inject Library示例程序 22.4.2 Image Walk DLL 22.5 使用木马DLL来...
  • 游戏对战平台,在没有了解的情况下,总是给人一种很神秘的感觉,然而,当你对socket的理解到达一定程度之后,你就不会再觉得神秘。... 替换Windows socket DLL,然后,你想做什么就做什么吧。 2. 进程注入,HOO...
  • 游戏对战平台

    2009-09-05 21:09:00
    游戏对战平台,在没有了解的情况下,总是给人一种很神秘的感觉,然而,当你对socket的理解到达一定程度之后,你就不会再觉得神秘。... 替换Windows socket DLL,然后,你想做什么就做什么吧。 2. 进程注入...
  • 对战平台原理分析

    2010-01-11 14:44:00
    游戏对战平台,在没有了解的情况下,总是给人一种很神秘的感觉,然而,当你对socket的理解到达一定程度之后,你就不会再觉得神秘。... 替换Windows socket DLL,然后,你想做什么就做什么吧。 2. 进程注入,HOOK...
  • 游戏对战平台原理

    千次阅读 2010-05-30 09:12:00
    游戏对战平台,在没有了解的情况下,总是给人一种很神秘的感觉,然而,当你对socket的理解到达一定程度之后,你就... 替换Windows socket DLL,然后,你想做什么就做什么吧。 2. 进程注入,HOOK WinSock函数调用。
  • 使用原子操作进行hook

    2018-11-14 21:00:49
    最近在写一个程序的时候,需要hook其他进程代码(64位进程),对稳定性要求很高,另外为了提高隐蔽性,打算WriteProcessMemory写入shellcode,这样不用注入dll。 hook方式的选择 inline hook和IAT hook都...
  • 至于WonderWall插件为什么没附带因为都是自己想要什么功能就加上,用法什么也没记录,时间我整理一下。 6.把生成的Winmm.dll 和FakeVer.ini放入易语言安装目录,每个版本自己对应修改配置版本号。这样同时打开多个...
  • <div><p>老项目的dll注入了3万5千多个函数,生成IDMAP在ios的il2cpp阶段出错了。 Unity 5.6.7f1的il2cpp对...有什么特殊考虑吗?</p><p>该提问来源于开源项目:Tencent/InjectFix</p></div>

空空如也

空空如也

1 2 3 4
收藏数 70
精华内容 28
关键字:

dll注入有什么用