APC注入

最新推荐文章于 2023-12-15 20:06:33 发布
最新推荐文章于 2023-12-15 20:06:33 发布
阅读量613 收藏
点赞数
分类专栏： 驱动开发学习
/***********************************
desc : This code was written for inject a dll named text.dll to the target process based on APC.
time : 2013
coder: ejoywx
***********************************/
#include <ntddk.h>
#include <ntimage.h>
 
#ifndef SEC_IMAGE
#define SEC_IMAGE   0x1000000     // winnt
#endif
 
extern PUSHORT NtBuildNumber;
 
PVOID pfn_XxxDispatchAPC  = NULL;
PVOID pfn_LoadLibraryA    = NULL;
PVOID pszText_Kernel32    = NULL;
 
ULONG Offset_szText = 0;
ULONG Offset_LoadLibraryA = 0;
ULONG Offset_BaseDispatchAPC = 0;
ULONG Offset_RtlDispatchAPC = 0;
 
UNICODE_STRING gModuleName[] =
{
     RTL_CONSTANT_STRING(L "\\systemroot\\system32\\ntdll.dll" ),
     RTL_CONSTANT_STRING(L "\\systemroot\\system32\\kernel32.dll" ),
     RTL_CONSTANT_STRING(L "\\WINDOWS\\system32\\kernel32.dll" ),
     RTL_CONSTANT_STRING(L "\\systemroot\\system\\text.dll" ),
     RTL_CONSTANT_STRING(L "\\Device\\HarddiskVolume1\\WINDOWS\\system32\\notepad.exe" )
};                               
 
PIMAGE_NT_HEADERS
NTAPI
RtlImageNtHeader(
     PVOID Base
     );
 
NTSYSAPI
PVOID
NTAPI
RtlImageDirectoryEntryToData(
     PVOID BaseOfImage,
     BOOLEAN MappedAsImage,
     USHORT DirectoryEntry,
     PULONG Size
     );
 
NTSTATUS (NTAPI* pfn_NtQueueApcThread)(
     __in HANDLE     ThreadHandle,
     __in PVOID      ApcRoutine,
     __in_opt PVOID  ApcArgument1,
     __in_opt PVOID  ApcArgument2,
     __in_opt PVOID  ApcArgument3
     );
 
PVOID NTAPI 
TlLoadSysPEtoMem(
     IN PUNICODE_STRING FilePath
     )
{
     OBJECT_ATTRIBUTES   ObjectAttributes = {0};
     IO_STATUS_BLOCK     IoStatusBlock    = {0};
     HANDLE              FileHandle       = NULL;
     HANDLE              SectionHandle    = NULL;
     PVOID               ViewBase         = NULL;
     PVOID               MemBase          = NULL;
     SIZE_T              ViewSize         = 0;
     NTSTATUS            Status           = STATUS_INVALID_PARAMETER;
 
     InitializeObjectAttributes( &ObjectAttributes,
                                 FilePath,
                                 OBJ_KERNEL_HANDLE|OBJ_CASE_INSENSITIVE,
                                 NULL,
                                 NULL );
 
     Status = ZwOpenFile (  &FileHandle,
                             FILE_GENERIC_READ,
                             &ObjectAttributes,
                             &IoStatusBlock,
                             FILE_SHARE_READ|FILE_SHARE_WRITE,
                             FILE_NON_DIRECTORY_FILE );
     if ( NT_SUCCESS( Status ) )
     {
         InitializeObjectAttributes( &ObjectAttributes,
                                     NULL,
                                     OBJ_KERNEL_HANDLE,
                                     NULL,
                                     NULL );
         Status = ZwCreateSection(   &SectionHandle,
                                     SECTION_MAP_READ,
                                     &ObjectAttributes,
                                     (PLARGE_INTEGER)NULL,
                                     PAGE_READONLY,
                                     SEC_IMAGE,
                                     FileHandle);
         if ( NT_SUCCESS( Status ) )
         {
             Status = ZwMapViewOfSection(SectionHandle,
                                         ZwCurrentProcess(),
                                         &ViewBase,
                                         0L,
                                         PAGE_SIZE,
                                         NULL,
                                         &ViewSize,
                                         ViewUnmap,
                                         MEM_TOP_DOWN,
                                         PAGE_READWRITE);
                                         
             if ( NT_SUCCESS( Status ) )
             {
                 MemBase = ExAllocatePoolWithTag( NonPagedPool, ViewSize, ' dmC' );
                 if ( MemBase )
                 {
                     RtlMoveMemory( MemBase, ViewBase, ViewSize );
                 }
                 
                 ZwUnmapViewOfSection( ZwCurrentProcess(), ViewBase );
             }
 
             ZwClose( SectionHandle );
         }
         
         ZwClose( FileHandle );
     }
 
     return MemBase;
}
 
PVOID NTAPI 
TlMapKnownDlltoMem(
     IN PUNICODE_STRING FilePath
     )
{
     OBJECT_ATTRIBUTES   ObjectAttributes = {0};
     HANDLE              SectionHandle    = NULL;
     PVOID               ViewBase         = NULL;
     PVOID               MemBase          = NULL;
     SIZE_T              ViewSize         = 0;
     NTSTATUS            Status           = STATUS_INVALID_PARAMETER;
 
     InitializeObjectAttributes( &ObjectAttributes,
                                 FilePath,
                                 OBJ_KERNEL_HANDLE|OBJ_CASE_INSENSITIVE,
                                 NULL,
                                 NULL );
     Status = ZwOpenSection( &SectionHandle,
                     SECTION_MAP_READ,
                     &ObjectAttributes
                     );
     if ( NT_SUCCESS( Status ) )
     {
         Status = ZwMapViewOfSection(SectionHandle,
                             ZwCurrentProcess(),
                             &ViewBase,
                             0L,
                             PAGE_SIZE,
                             NULL,
                             &ViewSize,
                             ViewUnmap,
                             MEM_TOP_DOWN,
                             PAGE_READWRITE );
         
         if ( NT_SUCCESS( Status ) )
         {
             MemBase = ExAllocatePoolWithTag( NonPagedPool, ViewSize, ' dmC' );
             if ( MemBase )
             {
                 RtlMoveMemory( MemBase, ViewBase, ViewSize );
             }
             
             ZwUnmapViewOfSection( ZwCurrentProcess(), ViewBase );
         }
 
         ZwClose( SectionHandle );
     }
 
     return MemBase;
}
 
PVOID NTAPI 
TlGetProcAddress(
     IN PVOID ImageBase,
     IN PUCHAR ApiName
     )
{
     PIMAGE_EXPORT_DIRECTORY ExpDir  = NULL;
     PULONG          AddressOfNames  = NULL;
     PULONG      AddressOfFunctions  = NULL;
     PUSHORT  AddressOfNameOrdinals  = NULL;
     PVOID              FuncAddress  = NULL;
     ULONG               ExpDirSize  = 0;
     ULONG            NumberOfNames  = 0; 
 
     LONG                    Idx     = 0;
     LONG                    ret     = 0;
     LONG                    low     = 0;
     LONG                    mid     = 0;
     LONG                    high    = 0;
     PCHAR                   pName   = NULL;
     
     if ( !ImageBase ) return NULL;
     
     ExpDir = (PIMAGE_EXPORT_DIRECTORY)RtlImageDirectoryEntryToData(ImageBase,TRUE,IMAGE_DIRECTORY_ENTRY_EXPORT,&ExpDirSize );
     if ( ExpDir  )
     {
         AddressOfNames          = ( PULONG )( ( ULONG )ImageBase + ExpDir->AddressOfNames );
         AddressOfFunctions      = ( PULONG )( ( ULONG )ImageBase + ExpDir->AddressOfFunctions );
         AddressOfNameOrdinals   = ( PUSHORT )( ( ULONG )ImageBase + ExpDir->AddressOfNameOrdinals );
         NumberOfNames           = ExpDir->NumberOfNames;
         
         if ( ( ULONG )ApiName & 0xFFFF0000 )
         {
             high = NumberOfNames-1;
             while (low <= high) //二分查找，快速定位
             {
                 mid   = (high+low)>>1;
                 pName = ( PCHAR )ImageBase+AddressOfNames[mid] ;
 
                 Idx = 0;
                 while ( pName[Idx] && pName[Idx] == ApiName[Idx] )
                 {
                     ++Idx;
                 }
 
                 ret = pName[Idx] - ApiName[Idx];
                 if ( ret==0 )
                 {
                     ( PUCHAR )FuncAddress=( PUCHAR )ImageBase + AddressOfFunctions[ AddressOfNameOrdinals[ mid ] ];
 
                     break ;
                 }
                 else if ( ret > 0 )
                 {
                     high=mid-1;
                 }
                 else
                 {
                     low=mid+1;
                 }
             }
         }
         else
         {
             ( PUCHAR )FuncAddress=( PUCHAR )ImageBase + AddressOfFunctions[ ( ULONG )ApiName & 0x0FFFF ];
         }       
     }   
 
     return FuncAddress;
}
 
ULONG NTAPI //just for winxp/win2003
GetOffsetForXxxDispatchApc(
     IN PVOID pfn_QueueUserApc,
     IN PVOID ImageBase
     )
{
     ULONG   Offset = 0;
     PUCHAR  pMem   = ( PUCHAR )pfn_QueueUserApc;
     PUCHAR  pLim   = ( PUCHAR )pfn_QueueUserApc + 0x100;
     
     while ( pMem < pLim && *( PULONG )pMem != 0x90000CC2 ) pMem++;
     
     if ( *( PULONG )pMem == 0x90000CC2 )
     {
         pLim   = ( PUCHAR )pfn_QueueUserApc;
         while ( (--pMem) > pLim )
         {
             if ( *( PUSHORT )pMem == 0x75FF && *( PUSHORT )(pMem+3) == 0x15FF  && *(pMem-5) == 0x68 )
             {
                 Offset  = *( PULONG )(pMem-4) - ( ULONG )ImageBase;               
                 break ;
             }
         }
     }
     
     return Offset;
}
 
ULONG NTAPI
GetOffsetForSpecialText(
     IN PVOID ImageBase,
     IN PCSTR szText
     )
{
     ULONG   Offset = 0;
     PUCHAR  pMem   = ( PUCHAR )ImageBase;
     PUCHAR  pLim   = ( PUCHAR )ImageBase + 0x400;
     
     while ( pMem < pLim )
     {
         if ( _stricmp( szText, pMem) == 0 )
         {
             Offset = ( ULONG )(pMem-( PUCHAR )ImageBase);
             break ;
         }
         
         pMem++;
     }   
     
     return Offset;
}
 
PVOID NTAPI
TlBuildNtFunc(
     IN ULONG ServiceId
     )
{
     PVOID   NtFunc = NULL;
     PVOID   pfn_KiSystemService;
     PVOID   pfn_ZwQueryKey;       
     UNICODE_STRING RoutineName;
         
     RtlInitUnicodeString( &RoutineName, L "ZwQueryKey" );       
     pfn_ZwQueryKey = MmGetSystemRoutineAddress( &RoutineName );
     
     if ( pfn_ZwQueryKey )
     {
         NtFunc = ExAllocatePoolWithTag( NonPagedPool, 32, ' dmC' );        
         if ( NtFunc )
         {
             ( PUCHAR )pfn_KiSystemService = ( PUCHAR )pfn_ZwQueryKey + 12 + 5 + *( PULONG )(( PUCHAR )pfn_ZwQueryKey + 12 + 1);
             
             RtlFillMemory( NtFunc, 32, 0xCC );       
             RtlMoveMemory( NtFunc, pfn_ZwQueryKey, 20 );
 
             *( PULONG )(( PUCHAR )NtFunc + 12 + 1 ) = ( ULONG )(( PUCHAR )pfn_KiSystemService - (( PUCHAR )NtFunc + 12 + 5));
             *( PULONG )(( PUCHAR )NtFunc + 1 ) = ServiceId;
         }    
     }
     
     return NtFunc;
}
 
BOOLEAN NTAPI
TlCheckFileExist(
     IN PUNICODE_STRING FileName
)
{
     OBJECT_ATTRIBUTES   ObjectAttributes = {0};
     IO_STATUS_BLOCK     IoStatusBlock    = {0};
     HANDLE              FileHandle       = NULL;
     NTSTATUS            Status           = STATUS_INVALID_PARAMETER;
 
     InitializeObjectAttributes( &ObjectAttributes,
                                 FileName,
                                 OBJ_KERNEL_HANDLE|OBJ_CASE_INSENSITIVE,
                                 NULL,
                                 NULL );
 
     Status = ZwOpenFile (  &FileHandle,
                             FILE_GENERIC_READ,
                             &ObjectAttributes,
                             &IoStatusBlock,
                             FILE_SHARE_READ|FILE_SHARE_WRITE,
                             FILE_NON_DIRECTORY_FILE );
                     
     if ( NT_SUCCESS( Status ) )
     {     
         ZwClose( FileHandle );
     }
     
     return NT_SUCCESS( Status );
}
 
VOID
LoadImageNotifyRoutine(
     IN PUNICODE_STRING  FullImageName,
     IN HANDLE           ProcessId,
     IN PIMAGE_INFO      ImageInfo
     )
{      
     if ( !pfn_XxxDispatchAPC || !pfn_LoadLibraryA || !pszText_Kernel32 )
     {       
         if ( !pfn_LoadLibraryA || !pszText_Kernel32 )
         {
             if ( RtlCompareUnicodeString( FullImageName, &gModuleName[2], TRUE ) == 0 )
             {
                 ( PUCHAR )pfn_LoadLibraryA  = ( PUCHAR )ImageInfo->ImageBase + Offset_LoadLibraryA;
                 ( PUCHAR )pszText_Kernel32  = ( PUCHAR )ImageInfo->ImageBase + Offset_szText;
                 
                 if ( Offset_BaseDispatchAPC )
                 {
                     ( PUCHAR )pfn_XxxDispatchAPC= ( PUCHAR )ImageInfo->ImageBase + Offset_BaseDispatchAPC;
                 }
             }
         }
         
         if ( Offset_RtlDispatchAPC && !pfn_XxxDispatchAPC )
         {
             if ( RtlCompareUnicodeString( FullImageName, &gModuleName[0], TRUE ) == 0 )
             {
                 ( PUCHAR )pfn_XxxDispatchAPC= ( PUCHAR )ImageInfo->ImageBase + Offset_RtlDispatchAPC;
             }
         }
     }
     else if ( pfn_NtQueueApcThread )
     {
         if ( RtlCompareUnicodeString( FullImageName, &gModuleName[4], TRUE ) == 0 )
         {
             pfn_NtQueueApcThread(
                     ZwCurrentThread(),
                     pfn_XxxDispatchAPC,
                     pfn_LoadLibraryA,
                     pszText_Kernel32,
                     NULL );
         }
     }
}
 
VOID DriverUnload(IN PDRIVER_OBJECT DriverObject)
{
     PsRemoveLoadImageNotifyRoutine( LoadImageNotifyRoutine );
     
     ExFreePool( pfn_NtQueueApcThread );
}
 
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,IN PUNICODE_STRING RegistryPath)
{   
     NTSTATUS Status = 0; 
     ULONG ServiceId = -1;    
     PVOID ImageBase_Ntdll ;
     PVOID ImageBase_Kernel;   
     PVOID pfn;
     
     ImageBase_Ntdll = TlLoadSysPEtoMem( &gModuleName[0] );
     if ( ImageBase_Ntdll )
     {
         pfn = TlGetProcAddress( ImageBase_Ntdll, "NtQueueApcThread" );
         if ( pfn )
         {
             ServiceId = *( PULONG )(( PUCHAR )pfn + 1 );
         }
         
         if ( *NtBuildNumber == 7601 )
         {
             pfn = TlGetProcAddress( ImageBase_Ntdll, ( PUCHAR )7 );
             if ( pfn )
             {
                 Offset_RtlDispatchAPC = ( ULONG )pfn - ( ULONG )ImageBase_Ntdll;
             } 
         }     
         
         ExFreePool( ImageBase_Ntdll );
     }
     
     ImageBase_Kernel = TlLoadSysPEtoMem( &gModuleName[1] );
     if ( ImageBase_Kernel )
     {
         PIMAGE_NT_HEADERS NtHdrs = RtlImageNtHeader( ImageBase_Kernel );
         
         if ( *NtBuildNumber == 2600 )
         {
             pfn = TlGetProcAddress( ImageBase_Kernel, "QueueUserAPC" );
             if ( pfn )
             {
                 Offset_BaseDispatchAPC = GetOffsetForXxxDispatchApc( pfn, ( PVOID )NtHdrs->OptionalHeader.ImageBase);
             }
         }
         
         pfn = TlGetProcAddress( ImageBase_Kernel, "LoadLibraryA" );
         if ( pfn )
         {
             Offset_LoadLibraryA = ( ULONG )pfn - ( ULONG )ImageBase_Kernel;
         }       
         
         Offset_szText = GetOffsetForSpecialText( ( PUCHAR )ImageBase_Kernel, "text" );
          
         ExFreePool( ImageBase_Kernel );
     }
     
     Status = STATUS_NOT_SUPPORTED;
     if ( Offset_LoadLibraryA && Offset_szText && (Offset_BaseDispatchAPC || Offset_RtlDispatchAPC) && ServiceId != -1 )
     {
         Status = STATUS_NO_SUCH_FILE;
         //确保文件"systemroot\system\text.dll"存在
         if ( TlCheckFileExist( &gModuleName[3] ) )
         {
             pfn_NtQueueApcThread = TlBuildNtFunc( ServiceId ); 
         }     
     }
     
     if ( pfn_NtQueueApcThread )
     {
         Status = PsSetLoadImageNotifyRoutine( LoadImageNotifyRoutine );;
     }
     
     if ( !NT_SUCCESS(Status) && pfn_NtQueueApcThread )
     {
         ExFreePool( pfn_NtQueueApcThread );
     }
     
     DriverObject->DriverUnload = DriverUnload;
     return Status;
}
cosmoslife
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
APC注入以及几种实现方式
include_voidmain的博客
08-02 2017
APC注入以及几种实现方式
PE文件结构详解（三）PE导出表
Azure_Sky_2014
02-02 829
转自：http://blog.csdn.net/evileagle/article/details/12176797 上篇文章 PE文件结构详解（二）可执行文件头 的结尾出现了一个大数组，这个数组中的每一项都是一个特定的结构，通过函数获取数组中的项可以用RtlImageDirectoryEntryToData函数，DataDirectory中的每一项都可以用这个函数获取，函数原型如下：
重载内核(x86)
125096
11-17 2257
#include #include #include #include #include #include #include #ifndef MAX_PATH #define MAX_PATH 256 #endif typedef unsigned char *PBYTE; typedef unsigned char BYTE; typedef unsigned int UIN
驱动内存映射文件
liwen930723的专栏
09-25 1234
驱动内存映射文件，一切尽在代码中，各位老爷请看：       // 内存映射文件，返回基址 // 用完记得ZwUnmapViewOfSection(ZwCurrentProcess(), BaseAddress); PVOID CreateMapFileAndGetBaseAddr(PUNICODE_STRING FilePath, PSIZE_T Size) { #define SE...
APC(二)
Misaka10046的博客
11-26 404
BOOLEAN KeInsertQueueApc ( __inout PRKAPC Apc, //APC的结构 __in_opt PVOID SystemArgument1, __in_opt PVOID SystemArgument2,//参数 __in KPRIORITY Increment//优先级 ) ```
C++ APC注入.zip
08-06
C++ APC注入是一种高级的进程通信技术，常用于在Windows操作系统中实现远程线程注入。在本案例中，APC（Asynchronous Procedure Call）注入被用作替代方法，因为直接的DLL注入可能导致某些系统，如Win7，在特定情况...
易语言移植的APC注入源码
06-06
易语言移植的APC注入源码是一个涉及到Windows操作系统编程、进程通信和恶意代码技术的知识点。APC（Asynchronous Procedure Call）是Windows API提供的一种异步处理机制，常用于线程间的通信。在易语言中实现APC注入...
APC注入测试源码C++
12-19
一个对APC注入进行学习测试的例子，可以在用户态下执行。但是对系统进程仍无法进行注入，不清楚是权限问题还是其他的问题。 工程在vs2012下编译测试成功。 共有三个工程 1、ApcInject 实现Apc注入功能 2、InjectTest...
易语言移植的APC注入
07-22
在这个场景中，"易语言移植的APC注入"指的是将APC注入技术应用到易语言的环境中，使得开发者能够利用易语言编写相关的注入程序。 APC注入的基本原理是通过系统调用，将一个函数（通常是一个DLL中的函数）添加到另一...
APC注入实现代码
07-30
在IT领域，特别是系统编程和安全研究中，"APC注入实现代码"是一个涉及操作系统内核和用户模式之间交互的重要技术。"Ring0 + Ring3"标签进一步强调了这一技术在不同权限级别的运用。让我们深入探讨这个主题。 首先，...
Kernel_Inject：内核注入DLL
02-15
别问问就是F7 修仙交流（限定筑基期至渡劫期）：546110133
cvi 解析PE文件获取导出函数表和虚拟地址
09-01
用Labwindows/CVI写的用于解析dll库的导出函数和虚拟地址的小工具
ShellCode注入程序
最新发布
jmm18363027827的博客
12-15 318
程序功能是利用NtQueueApcThreadEx注入ShellCode到一个进程中，程序运行后会让你选择模式，按1为普通模式，所需的常规API接口都是使用Windows原本正常的API；在有游戏保护的进程中Windows原本正常的API无法使用，这时候需要选择内核模式，按2选择内核模式。内核模式下使用的一些关键API都是我自己在ring0从0实现的，本帖仅开源普通模式下的代码。shellCode的功能是给被注入进程设置一个键盘钩子，TAB键。项目包含三个源代码文件：1.源.cpp。
暴力注入Explorer的apc方法
07-17 1201
 向一个运行中的进程注入自己的代码，最自然莫过于使用CreateRemoteThread，如今远线程注入已经是泛滥成灾，同样的监测远线程注入、防止远线程注入的工具也举不胜举，一个木马或后门启动时向Explorer或IE的注入操作就像在自己脸上写上“我是贼”一样。用户态代码想要更隐蔽地藏身于别的进程，就应该在注入的环节隐蔽自己的行为。下面就介绍一种非常简单不过比较暴力的方法，给出的示例为在E
注入技术之APC注入
whs100505的博客
02-10 714
APC注入 原理：每个线程都有一个APC队列，当调用SleepEx，SignalObjectAndWait，WaitForSingleObjectEx，WaitForMultipleObjectsEx或MsgWaitForMultipleObjectsEx进入警报状态时，系统会遍历该线程的APC，按照先进先出的顺序执行APC。 #include <Windows.h> bool AP...
APC_dll注入
qq_36918532的博客
03-03 429
主要是以下五步 //注入器 //1.要注入到进程中首先要拿到进程ID //2.获取到LoadLibrary地址 //3.在目标程序的体内开辟一块内存,用来写入dll地址 //4.遍历线程-随便选一个目标进程的线程获取句柄 //5.插入APC,把LoadLibrary作为APC的回调参数,然后把目标进程的dll地址作为参数 #include<stdio.h> #include<stdlib.h> #include<Windows.h> #include<TlHelp3
ReactOS-Freeldr镜像加载2
cradiator的专栏
06-08 1322
 先来介绍几个重要的结构。Freeldr虽然是个引导程序，严格来讲不属于操作系统的一部分，但它也有一些类似Windows系统中的数据结构。LOADER_PARAMETER_BLOCK这个可以看作Freeldr的PEB，结构也和PEB非常相似。/include/reactos/arc/arc.htypedef struct _LOADER_PARAMETER_BLOCK{  
注入系列：APC注入（Ring3）
weixin_43742894的博客
03-22 884
APC注入的作用：APC注入可以让一个线程在它正常的执行路径运行之前执行一些其他的代码。 要了解APC注入，我们首先来了解Windows的APC机制。 APC机制详细可参考本文：https://blog.csdn.net/qq229596421/article/details/77828647 简单来说，APC 是一个简称,具体名字叫做异步过程调用。是软件中断的一种。 APC队列：每个线程都有...
windows apc注入原理
06-11
Windows APC（Asynchronous Procedure Call）注入是一种常见的注入技术，它利用了 Windows 操作系统中的异步过程调用机制来实现注入。具体原理如下： 1. 创建目标进程 首先，攻击者需要创建一个目标进程，该进程将作为注入目标。一般情况下，攻击者会选择一个易受攻击的进程，例如 Windows Explorer。 2. 分配内存空间 攻击者需要在目标进程中分配一块内存空间，用于存放要注入的代码。可以使用 VirtualAllocEx 等函数来实现。 3. 编写注入代码 接下来，攻击者需要编写注入代码，并将其写入到之前分配的内存空间中。注入代码通常是一个 DLL 文件，其中包含了攻击者想要执行的恶意代码。同时，在注入代码中还需要将恶意代码的入口点指向一个 APC 回调函数。 4. 调用 QueueUserAPC 函数 接下来，攻击者需要在目标进程中的某个线程上调用 QueueUserAPC 函数，并将之前分配的内存空间中的 APC 回调函数作为参数。这样，当目标进程的线程下一次进入 Alertable 状态时，它将执行注入代码中的 APC 回调函数。 5. 触发注入 最后，攻击者需要触发目标进程中的线程进入 Alertable 状态。可以使用 Sleep、WaitForSingleObject 等函数来实现。 总之，APC 注入技术是一种高级的注入技术，攻击者可以通过它将恶意代码注入到目标进程中，并在其中执行。然而，这种技术也有一定的局限性，例如无法注入到特权级较高的进程中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值