通用Inline Hook代码收藏

大浪淘沙1 大浪淘沙1 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1k累计阅读 1.1k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄19年
关注
原创 最新推荐文章于 2026-03-16 01:13:15 发布 1k 阅读 AI 写同款· GEO 优化 ›
inline hook的原理及实现 网上没有找到多少关于inline hook的文章，感觉这方面资料不是很完整，所以决定自己写一份存档，重点讲述inline hook的实现。 inline hook的核心思想是：通过替换目标函数头部指令实现在函数执行之前跳转到其他的指令区域，执行完毕跳转回到原来的函数，跳转到的指令区域通常是我们自己编写的函数。inline hook技术对于编写外挂和外挂式补丁意义重大。 步骤： 1.使用Vir 阅读详情 
#include "inlinehook.h"



typedef struct _INLINE_HOOK_ITEM

{

    PBYTE    HookAddress;        //inlinehook 的位置

    DWORD    OrgBytesSize;        //

    //PBYTE    OrgBytes;            //原始函数字节

    PBYTE    HookBytes;            //HOOK代码 = OrgBytesSize + 14字节

}INLINE_HOOK_ITEM, *PINLINE_HOOK_ITEM;



////////////////////////////////

// DisassembleMem32

////////////////////////////////

DWORD DisassembleMem32(PBYTE pbCode)

{

BYTE      bmodrm;



//----------------

bmodrm = *pbCode;



if (bmodrm >= 0xC0)

  return 1;



if (bmodrm >= 0x80)

  return ((bmodrm & 0x07) == 0x04 ? 6 : 5);



if (bmodrm >= 0x40)

  return ((bmodrm & 0x07) == 0x04 ? 3 : 2);



if ((bmodrm & 0x07) == 0x05)

  return 5;



if ((bmodrm & 0x07) == 0x04)

  return ((pbCode[1] & 0x07) == 0x05 ? 6 : 2);



return 1;

} //DisassembleMem32()





////////////////////////////////

// DisassembleProlog

////////////////////////////////

DWORD DisassembleProlog(

PBYTE      pbCode,

DWORD      cbMinimumRequired)

{

PBYTE      pb;

DWORD      cboperand;



//----------------

cboperand = 4;



for (pb = pbCode; (DWORD)(pb - pbCode) < cbMinimumRequired; )

{

  // Potemkin's Hackers Group rocks heavy metal-style (OPCODE.LST)



  switch (*pb++)

  {

  case 0x00:      // 00h: ADD mem8, reg8

  case 0x01:      // 01h: ADD mem, reg

  case 0x02:      // 02h: ADD reg8, mem8

  case 0x03:      // 03h: ADD reg, mem

  case 0x08:      // 08h: OR mem8, reg8

  case 0x09:      // 09h: OR mem, reg

  case 0x0A:      // 0Ah: OR reg8, mem8

  case 0x0B:      // 0Bh: OR reg, mem

  case 0x10:      // 10h: ADC mem8, reg8

  case 0x11:      // 11h: ADC mem, reg

  case 0x12:      // 12h: ADC reg8, mem8

  case 0x13:      // 13h: ADC reg, mem

  case 0x18:      // 18h: SBB mem8, reg8

  case 0x19:      // 19h: SBB mem, reg

  case 0x1A:      // 1Ah: SBB reg8, mem8

  case 0x1B:      // 1Bh: SBB reg, mem

  case 0x20:      // 20h: AND mem8, reg8

  case 0x21:      // 21h: AND mem, reg

  case 0x22:      // 22h: AND reg8, mem8

  case 0x23:      // 23h: AND reg, mem

  case 0x28:      // 28h: SUB mem8, reg8

  case 0x29:      // 29h: SUB mem, reg

  case 0x2A:      // 2Ah: SUB reg8, mem8

  case 0x2B:      // 2Bh: SUB reg, mem

  case 0x30:      // 30h: XOR mem8, reg8

  case 0x31:      // 31h: XOR mem, reg

  case 0x32:      // 32h: XOR reg8, mem8

  case 0x33:      // 33h: XOR reg, mem

  case 0x38:      // 38h: CMP mem8, reg8

  case 0x39:      // 39h: CMP mem, reg

  case 0x3A:      // 3Ah: CMP reg8, mem8

  case 0x3B:      // 3Bh: CMP reg, mem

  case 0x84:      // 84h: TEST mem8, reg8

  case 0x85:      // 85h: TEST mem, reg

  case 0x86:      // 86h: XCHG mem8, reg8

  case 0x87:      // 87h: XCHG mem, reg

  case 0x88:      // 88h: MOV mem8, reg8

  case 0x89:      // 89h: MOV mem, reg

  case 0x8A:      // 8Ah: MOV reg8, mem8

  case 0x8B:      // 8Bh: MOV reg, mem

  case 0x8C:      // 8Ch: mem, sreg

  case 0x8D:      // 8Dh: LEA reg, mem

  case 0x8E:      // 8Eh: sreg, mem

  case 0x8F:      // 8Fh: POP mem

  case 0xC4:      // C4h: LES reg, mem

  case 0xC5:      // C5h: LDS reg, mem

  case 0xD0:      // D0h: mem8, 1

  case 0xD1:      // D1h: mem, 1

  case 0xD2:      // D2h: mem8, CL

  case 0xD3:      // D3h: mem, CL

  case 0xFE:      // FEh: mem8

  case 0xFF:      // FFh: mem

    pb += DisassembleMem32(pb);

    break;



  case 0x04:      // 04h: ADD AL, imm8

  case 0x0C:      // 0Ch: OR AL, imm8

  case 0x14:      // 14h: ADC AL, imm8

  case 0x1C:      // 1Ch: SBB AL, imm8

  case 0x24:      // 24h: AND AL, imm8

  case 0x2C:      // 2Ch: SUB AL, imm8

  case 0x34:      // 34h: XOR AL, imm8

  case 0x3C:      // 3Ch: CMP AL, imm8

  case 0x6A:      // 6Ah: PUSH simm8

  case 0xA8:      // A8h: TEST AL, imm8

  case 0xB0:      // B0h: MOV AL, imm8

  case 0xB1:      // B1h: MOV CL, imm8

  case 0xB2:      // B2h: MOV DL, imm8

  case 0xB3:      // B3h: MOV BL, imm8

  case 0xB4:      // B4h: MOV AH, imm8

  case 0xB5:      // B5h: MOV CH, imm8

  case 0xB6:      // B6h: MOV DH, imm8

  case 0xB7:      // B7h: MOV BH, imm8

  case 0xD4:      // D4h: AAM imm8

  case 0xD5:      // D5h: AAD imm8

    pb++;

    break;



  case 0x05:      // 05h: ADD EAX, imm

  case 0x0D:      // 0Dh: OR EAX, imm

  case 0x15:      // 15h: ADC EAX, imm

  case 0x1D:      // 1Dh: SBB EAX, imm

  case 0x25:      // 25h: AND EAX, imm

  case 0x2D:      // 2Dh: SUB EAX, imm

  case 0x35:      // 35h: XOR EAX, imm

  case 0x3D:      // 3Dh: CMP EAX, imm

  case 0x68:      // 68h: PUSH imm

  case 0xA9:      // A9h: TEST EAX, imm

  case 0xB8:      // B8h: MOV EAX, imm

  case 0xB9:      // B9h: MOV ECX, imm

  case 0xBA:      // BAh: MOV EDX, imm

  case 0xBB:      // BBh: MOV EBX, imm

  case 0xBC:      // BCh: MOV ESP, imm

  case 0xBD:      // BDh: MOV EBP, imm

  case 0xBE:      // BEh: MOV ESI, imm

  case 0xBF:      // BFh: MOV EDI, imm

    pb += cboperand;

    break;



  case 0x06:      // 06h: PUSH ES

  case 0x07:      // 07h: POP ES

  case 0x0E:      // 0Eh: PUSH CS

  case 0x16:      // 16h: PUSH SS

  case 0x17:      // 17h: POP SS

  case 0x1E:      // 1Eh: PUSH DS

  case 0x1F:      // 1Fh: POP DS

  case 0x26:      // 26h: ES:

  case 0x27:      // 27h: DAA

  case 0x2E:      // 2Eh: CS:

  case 0x2F:      // 2Fh: DAS

  case 0x36:      // 36h: SS:

  case 0x37:      // 37h: AAA

  case 0x3E:      // 3Eh: DS:

  case 0x3F:      // 3Fh: AAS

  case 0x40:      // 40h: INC EAX

  case 0x41:      // 41h: INC ECX

  case 0x42:      // 42h: INC EDX

  case 0x43:      // 43h: INC EBX

  case 0x44:      // 44h: INC ESP

  case 0x45:      // 45h: INC EBP

  case 0x46:      // 46h: INC ESI

  case 0x47:      // 47h: INC EDI

  case 0x48:      // 48h: DEC EAX

  case 0x49:      // 49h: DEC ECX

  case 0x4A:      // 4Ah: DEC EDX

  case 0x4B:      // 4Bh: DEC EBX

  case 0x4C:      // 4Ch: DEC ESP

  case 0x4D:      // 4Dh: DEC EBP

  case 0x4E:      // 4Eh: DEC ESI

  case 0x4F:      // 4Fh: DEC EDI

  case 0x50:      // 50h: PUSH EAX

  case 0x51:      // 51h: PUSH ECX

  case 0x52:      // 52h: PUSH EDX

  case 0x53:      // 53h: PUSH EBX

  case 0x54:      // 54h: PUSH ESP

  case 0x55:      // 55h: PUSH EBP

  case 0x56:      // 56h: PUSH ESI

  case 0x57:      // 57h: PUSH EDI

  case 0x58:      // 58h: POP EAX

  case 0x59:      // 59h: POP ECX

  case 0x5A:      // 5Ah: POP EDX

  case 0x5B:      // 5Bh: POP EBX

  case 0x5C:      // 5Ch: POP ESP

  case 0x5D:      // 5Dh: POP EBP

  case 0x5E:      // 5Eh: POP ESI

  case 0x5F:      // 5Fh: POP EDI

  case 0x60:      // 60h: PUSHAD

  case 0x61:      // 61h: POPAD

  case 0x64:      // 64h: FS:

  case 0x90:      // 90h: NOP

  case 0x91:      // 91h: XCHG EAX, ECX

  case 0x92:      // 92h: XCHG EAX, EDX

  case 0x93:      // 93h: XCHG EAX, EBX

  case 0x94:      // 94h: XCHG EAX, ESP

  case 0x95:      // 95h: XCHG EAX, EBP

  case 0x96:      // 96h: XCHG EAX, ESI

  case 0x97:      // 97h: XCHG EAX, EDI

  case 0x98:      // 98h: CWDE

  case 0x99:      // 99h: CDQ

  case 0x9C:      // 9Ch: PUSHFD

  case 0x9D:      // 9Dh: POPFD

  case 0x9E:      // 9Eh: SAHF

  case 0x9F:      // 9Fh: LAHF

  case 0xA4:      // A4h: MOVSB

  case 0xA5:      // A5h: MOVSD

  case 0xA6:      // A6h: CMPSB

  case 0xA7:      // A7h: CMPSD

  case 0xAA:      // AAh: STOSB

  case 0xAB:      // ABh: STOSD

  case 0xAC:      // ACh: LODSB

  case 0xAD:      // ADh: LODSD

  case 0xAE:      // AEh: SCASB

  case 0xAF:      // AFh: SCASD

  case 0xC9:      // C9h: LEAVE

  case 0xD6:      // D6h: SETALC

  case 0xD7:      // D7h: XLAT

  case 0xF0:      // F0h: LOCK

  case 0xF2:      // F2h: REPNZ

  case 0xF3:      // F3h: REP

  case 0xF5:      // F5h: CMC

  case 0xF8:      // F8h: CLC

  case 0xF9:      // F9h: STC

  case 0xFC:      // FCh: CLD

  case 0xFD:      // FDh: STD

    break;



  case 0x66:      // 66h: memory access size prefix

    cboperand = 2;

    continue;



  case 0x69:      // 69h: IMUL reg, imm, mem

  case 0x81:      // 81h: mem, imm

  case 0xC7:      // C7h: MOV mem, imm

    pb += DisassembleMem32(pb) + cboperand;

    break;



  case 0x6B:      // 6Bh: IMUL reg8, imm8, mem8

  case 0x80:      // 80h: mem8, imm8

  case 0x82:      // 82h: mem8, simm8

  case 0x83:      // 83h: mem, simm8

  case 0xC0:      // C0h: mem8, imm8

  case 0xC1:      // C1h: mem, imm8

  case 0xC6:      // C6h: MOV mem8, imm8

    pb += DisassembleMem32(pb) + 1;

    break;



  case 0xA0:      // A0h: MOV AL, [ofs]

  case 0xA1:      // A1h: MOV EAX, [ofs]

  case 0xA2:      // A2h: MOV [ofs], AL

  case 0xA3:      // A3h: MOV [ofs], EAX

    pb += 4;

    break;



  case 0xC8:      // C8h: ENTER imm16, imm8

    pb += 3;

    break;



  case 0xF6:      // F6h/0: TEST mem8, imm8; F6h/{1..7}: mem8

    pb += DisassembleMem32(pb) + ((*pb & 0x38) == 0x00 ? 1 : 0);

    break;



  case 0xF7:      // F7h/0: TEST mem, imm; F7h/{1..7}: mem

    pb += DisassembleMem32(pb) + ((*pb & 0x38) == 0x00 ? cboperand : 0);

    break;



  case 0x0F:

    switch (*pb++)

    {

    case 0x0D:    // 0Fh/0Dh: mem

    case 0x18:    // 0Fh/18h: mem

    case 0x90:    // 0Fh/90h: SETO mem8

    case 0x91:    // 0Fh/91h: SETNO mem8

    case 0x92:    // 0Fh/92h: SETC mem8

    case 0x93:    // 0Fh/93h: SETNC mem8

    case 0x94:    // 0Fh/94h: SETZ mem8

    case 0x95:    // 0Fh/95h: SETNZ mem8

    case 0x96:    // 0Fh/96h: SETNA mem8

    case 0x97:    // 0Fh/97h: SETA mem8

    case 0x98:    // 0Fh/98h: SETS mem8

    case 0x99:    // 0Fh/99h: SETNS mem8

    case 0x9A:    // 0Fh/9Ah: SETP mem8

    case 0x9B:    // 0Fh/9Bh: SETNP mem8

    case 0x9C:    // 0Fh/9Ch: SETL mem8

    case 0x9D:    // 0Fh/9Dh: SETNL mem8

    case 0x9E:    // 0Fh/9Eh: SETNG mem8

    case 0x9F:    // 0Fh/9Fh: SETG mem8

    case 0xA3:    // 0Fh/A3h: BT mem, reg

    case 0xA5:    // 0Fh/A5h: SHLD mem, reg, CL

    case 0xAB:    // 0Fh/ABh: BTS mem, reg

    case 0xAD:    // 0Fh/ADh: SHRD mem, reg, CL

    case 0xAF:    // 0Fh/AFh: IMUL reg, mem

    case 0xB3:    // 0Fh/B3h: BTR mem, reg

    case 0xB4:    // 0Fh/B4h: LFS reg, mem

    case 0xB5:    // 0Fh/B5h: LGS reg, mem

    case 0xB6:    // 0Fh/B6h: MOVZX reg, mem8

    case 0xB7:    // 0Fh/B7h: MOVZX reg, mem16

    case 0xBB:    // 0Fh/BBh: BTC mem, reg

    case 0xBC:    // 0Fh/BCh: BSF mem, reg

    case 0xBD:    // 0Fh/BDh: BSR mem, reg

    case 0xBE:    // 0Fh/BEh: MOVSX reg, mem8

    case 0xBF:    // 0Fh/BFh: MOVSX reg, mem16

    case 0xC0:    // 0Fh/C0h: XADD mem8, reg8

    case 0xC1:    // 0Fh/C1h: XADD mem, reg

    case 0xC7:    // 0Fh/C7h/0: CMPXCHG8B mem

      pb += DisassembleMem32(pb);

      break;



    case 0xA0:    // 0Fh/A0h: PUSH FS

    case 0xA1:    // 0Fh/A1h: POP FS

    case 0xA8:    // 0Fh/A8h: PUSH GS

    case 0xA9:    // 0Fh/A9h: POP GS

    case 0xC8:    // 0Fh/C8h: BSWAP EAX

    case 0xC9:    // 0Fh/C9h: BSWAP ECX

    case 0xCA:    // 0Fh/CAh: BSWAP EDX

    case 0xCB:    // 0Fh/CBh: BSWAP EBX

    case 0xCC:    // 0Fh/CCh: BSWAP ESP

    case 0xCD:    // 0Fh/CDh: BSWAP EBP

    case 0xCE:    // 0Fh/CEh: BSWAP ESI

    case 0xCF:    // 0Fh/CFh: BSWAP EDI

      break;



    case 0xA4:    // 0Fh/A4h: SHLD mem, reg, imm8

    case 0xAC:    // 0Fh/ACh: SHRD mem, reg, imm8

    case 0xBA:    // 0Fh/BAh: mem, imm8

      pb += DisassembleMem32(pb) + 1;

      break;



    default:

      return 0;

    }

    break; //case 0x0F



  default:

    return 0;

  } //switch(*pb)



  cboperand = 4;

} //for(pb)



return (DWORD)(pb - pbCode);

} //DisassembleProlog()



__declspec(naked) void InLineHookHead()

{

    __asm

    {

        POP EAX;

        PUSH 0xAAAAAAAA;            //OrgFunction

        PUSH EAX;

        _emit 0xea;

        _emit 0xbb;

        _emit 0xbb;

        _emit 0xbb;

        _emit 0xbb;

        _emit 0x08;

        _emit 0x00;

        //POP EAX;                   

        //MOV EAX, 0xBBBBBBBB;        //MyHookFunction - 注意调用方式

        //CALL EAX;

        //INT 3;

        //ADD ESP, 8;

        //PUSH dword ptr [ESP - 8];

    }

}

void InLineHookHeadEnd(){}



DWORD

SetupInlineHook(

                IN OUT PBYTE FunctionAddress,

                IN PBYTE NewAddress

    )

{

    PINLINE_HOOK_ITEM hook_item = NULL;

    PBYTE jmp_back = NULL;



    UINT i, call_head_len;

   

    if (!FunctionAddress || !NewAddress)

        return 0;



    hook_item = ExAllocatePool(NonPagedPool, sizeof(INLINE_HOOK_ITEM));

    hook_item->HookAddress = FunctionAddress;

    hook_item->OrgBytesSize = DisassembleProlog(FunctionAddress, 7);    //JMP FAR 0008:0xffffffff

    call_head_len = (ULONG)InLineHookHeadEnd - (ULONG)InLineHookHead;//头字节数



    hook_item->HookBytes = ExAllocatePool(NonPagedPool, hook_item->OrgBytesSize + call_head_len + 7);

    //------------------------------------------------------------

    //填写HookHeader Bytes

    memcpy(hook_item->HookBytes, (PBYTE)InLineHookHead, call_head_len);

    for (i=0; i<call_head_len; i++)

    {

        if (*(PULONG)&hook_item->HookBytes == 0xAAAAAAAA)

        {

            *(PULONG)&hook_item->HookBytes = (ULONG)hook_item->HookBytes + call_head_len;

            i += 4;

        }

        if (*(PULONG)&hook_item->HookBytes == 0xBBBBBBBB)

        {

            *(PULONG)&hook_item->HookBytes = (ULONG)NewAddress;

            i += 4;

        }

    }

    //here is old bytes

    memcpy(hook_item->HookBytes + call_head_len, FunctionAddress, hook_item->OrgBytesSize);

    //7 bytes jmp back

    jmp_back = hook_item->HookBytes + call_head_len + hook_item->OrgBytesSize;

    jmp_back[0] = 0xEA;

    *(PULONG)&jmp_back[1] = (ULONG)(FunctionAddress + hook_item->OrgBytesSize);

    jmp_back[5] = 0x08;

    jmp_back[6] = 0x00;

    //------------------------------------------------------------

    //setup inline hook

    //------------------------------------------------------------

    _asm

    {

        MOV EAX, CR0;            //move CR0 register into EAX

        AND EAX, NOT 10000H;    //disable WP bit

        MOV CR0, EAX;            //write register back

    }

    hook_item->HookAddress[0] = 0xEA;//JMP FAR 0008:0xffffffff

    *(PULONG)&hook_item->HookAddress[1] = (ULONG)hook_item->HookBytes;

    hook_item->HookAddress[5] = 0x08;

    hook_item->HookAddress[6] = 0x00;

    for (i=7; i<hook_item->OrgBytesSize; i++)//fill nop

        hook_item->HookAddress = 0x90;

    _asm

    {

        MOV EAX, CR0;

        OR  EAX, 10000H;

        MOV CR0, EAX;

    }

    //------------------------------------------------------------

    KdPrint(("Hook At %08x/n", FunctionAddress));

   

    return (DWORD)hook_item;

}



//下面是简单的测试--win2000以及win2003SP1测试通过



SetupInlineHook((PBYTE)PacketSend, (PBYTE)InLineHookPacketSend);



NDIS_STATUS

InLineHookPacketSend(

                     SEND_HANDLER                OrgPacketSend,

                     IN    NDIS_HANDLE                MacBindingHandle,

                     IN    PNDIS_PACKET            Packet

                     )

{



    KdPrint(("InLineHookPacketSend %08x, %08x, %08x!!!/n", OrgPacketSend, MacBindingHandle, Packet));

    return OrgPacketSend(MacBindingHandle, Packet);   

}
标签
#hook #c #include #null #测试
#struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
Inline Hook Inline Hooking的实现 阅读详情

相关推荐

Android PLT hook 与 Inline hook

Android Native 函数 Hook 技术是一种在应用运行时拦截或替换系统或自身函数行为的手段，常见实现包括 PLT Hook、Inline Hook。PLT Hook 和 Inline Hook 是两种不同层次和机制的函数 Hook 技术，常用于逆向工程、安全分析、壳保护或热修复等场景。

1407

Inline Hook 之（监视任意函数）

前面已经写过两次inline hook的博文了，第一篇为：《C/C++ HOOK API（原理深入剖析之-LoadLibraryA）》，这篇博文的方法是通过修改任意函数的前面N个字节，实现跳转并进入到我们自定义的hook函数里，执行完毕我们的hook函数之后，再直接调用被hook的函数。第一篇的方法没有考虑多线程的情况，所以在多线程环境下会有问题。第二篇为：《Inline HOOK API 改进版（hot-patching）》，这篇的初衷是为了解决多线程的问题，因为这种方式是一直hook的，直到程序结束。

技术思行 4万+

内存注入之IAT Hook和Inline Hook综合程序

内存注入综合程序 1) 进程列表获取 2) IAT表项获取 3) IAT Hook 4) Inline Hook

enjoy5512的博客 8615

Hook攻防之InlineHook

Inline Hook，又称为超级Hook，是一种强大而又灵活的Hook技术。Inline Hook的主要思想就是直接修改目标函数的代码，通常是在目标函数的开头插入一个跳转指令（jmp）。这个跳转指令会将程序的执行流跳转到我们自定义的函数中。在我们的自定义函数中，我们可以执行任意的代码，然后再跳回目标函数的剩余部分。这样，我们就可以在不改变目标函数原有逻辑的基础上，添加自己的功能。

xf555er的博客 3029

普及X64 ssdtshadow inline HOOK

序： 我只想说~~再不发帖老大就 不搭理我了~~~ 原因：玩保护玩到了 XINGCODE3 就他的各种检测就让我不得不重视这个问题了:o: 各种窗口 各种X 我的工具 让我忍无可忍，就决定先HOOK了在说其他 最开始我用TA 的代码里面的 HOOK 方法 在 挂钩 NT 内核中的函数算是无往不利 在SHADOWSSDT中就蛋疼菊花紧了~~ 于是 开始自己搞:mad::mad:

落笔飞花笑百生的博客 3241

API hook原理和实例快速入门（inline hook），以dll线程注入方式使用（win7-64bit）

一个完整的hook，如果hook程序是以dll形式生成的，是分两步：1.完成dll本身的设计和生成，2.完成dll注入程序的设计和生成 本文完成第一步。 第二步在http://blog.youkuaiyun.com/arvon2012/article/details/7767437有详细讲解。   最近在64位win7上hook文件复制，拖拽和剪切的hook（这个要通过hook IFileOperat

扣的CODE 1万+

通用Inline Hook代码

#include "inlinehook.h"typedef struct _INLINE_HOOK_ITEM{    PBYTE    HookAddress;        //inlinehook 的位置    DWORD    OrgBytesSize;        //    //PBYTE    OrgBytes;            //原始函数字节    PBYTE    Ho

1908

C# inline-hook / api-hook

我查阅了一下相关C#方面的资料，却没有发现有提供过关于api-hook方面的资 料包括应用库由此本人编写一套inline-hook的库用于支持x64、x86上的基于在 clr的公共语言，如: c#、c+/clr、vb.net 全部都可以使用该类库改变底层api执 行结果，如我们需要制作抓包工具，或者拦截某个ActiveX对象内部调用的函数  用处广泛 有些人在制作“截包”工具时是通过使用S

5792

InlineHook 通用

NTSTATUS InlineHookFuncXP (   IN PVOID FuncAddress,   IN PVOID NewFuncAddress   ) /*++ Author : MJ0011 User   : sudami [xiao_rui_119@163.com] Time   : 08/01/24           参数 :   FuncAddress -

收集学习过程中对自己有帮助的牛人文章 860

WIN32 Inline HOOK

Inline hook 和CE里面的代码注入很像（应该是一个东西），这个技术的原理是，修改汇编指令，让某个指令跳转到我们定义的函数，然后在函数内完成被替换的指令，然后再跳转回去。在我们定义的函数内，我们可以实时获取寄存器的值，从而可以完成对函数行为的监视和修改。 在我们定义的函数内，需要注意，寄存器的值和堆栈状态，执行前后必须完全一致，否则程序会出错。为了实现这个目的，我们需要用到裸函数。 下面是代码，要注意代码中使用的地址仅在我的机器上有效，如果你要编译这个程序，第一次运行会失败，请根据生成的汇编代码，找

hambaga的博客 635

深入解析Inline HOOK技术源代码实现

Inline HOOK技术是一种程序代码拦截技术，它允许开发者在不改变原有程序运行流程的前提下，对程序的关键函数或API调用进行拦截和修改。这种技术自诞生以来，就在软件开发、调试、安全防护等多个领域发挥着重要的作用。开源社区是学习和交流inline HOOK技术的重要平台。在GitHub、GitLab等代码托管平台上，可以找到许多涉及inline HOOK技术的开源项目。这些项目不仅提供源代码，还提供使用文档、问题跟踪和社区讨论等功能。

weixin_42298254的博客 965

如何写一个Android inline hook框架

Android_Inline_Hook https://github.com/GToad/Android_Inline_Hook_ARM64 有32和64的实现，但是是分离的，要用的话还要自己把两份代码合并在一起。 缺点： 1、不支持函数替换（即hook后不执行原函数），现在只能修改参数寄存器，无法修改返回值。 2、不支持定义同类型的hook函数来接受处理参数，只能通过修改寄存器的方式修改参数。 ...

DaoDivDiFang的博客 2165

分析TP的InlineHook.txt

分析TP的InlineHook.分析TP的Inline分析TP的InlineHook.txtHook.txttxt

Android Natvie Hook讲解、 got表hook、inline hook 原理

Android Natvie Hook 讲解什么是Hook，以及Android Native层 hook名词解释以及知识储备处理器架构欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 什么是

spinchao的博客 8294

HOOK技术之InLineHOOK源代码

InLineHOOK技术，通过读写进程内存的技术实现在指令层面上的HOOK技术，比较常用的HOOK技术。

golang 线上事故

golang 线上事故 最近公司要做大促的一些活动。并且单量，qps持续上涨。之前使用的是django python 语言做的一个服务端。目前已经部署的国家里面最多的国家会有300+个实例。大促期间还可能会增加一个实例数。这么多的实例部署，回滚的时间都会特变长，除了问题也不好定位。并且如此多的一个机器，连接数* 实例数也会导致DB等其他服务扛不住这么大的并发。所以决定上go服务解决性能问题。 ...

lcf枫的博客 1538

稳定多线程中的inline hook

优化inline hook 实验平台：WIN10 实验工具：VS2017，OD 我所说的是windows下的inline hook，总所周知inline hook是windows平台下很灵活好用的一种hook方式， 但inline hook是非线程稳定的，也就是说在多线程的程序中，频繁的进行inline hook有可能会导致程序崩溃，不稳定。 之前在为了解决这个问题，只找到了Hook七个字节的...

qq_31507523的博客 1487

MQTT与物联网平台（一）：基础知识和设备接入物联网平台的实现（以华为云为例）

本文简单介绍了MQTT的基础知识和使用方法，以蓝牙WIFI双模芯片W801作为硬件设备，接入到华为云。

weixin_50622833的博客 1万+

软件安全之Hook 技术 Inline Hook技术应用 TraceMe.exe

Hook 技术 实验须知 1实验说明 Hook 是在指令的关键位置插入特定代码，以干预程序原有的执行流程，实现拦截目标进程运行过程的关键信息改变目标进程原本执行流程等目的。 2实验目的 本实验使用 Inline Hook 技术，挂钩 [raceMe.exe百度网盘地址(提取码1111)中计算序列号的代码，获取正确的序列号，加深对 Hook 技术的理解。 3实验原理 Hook Hook∶中文译作"挂钩"或"钩子"，在指令执行的关键位置插入特定代码，以干预程序原有的执行流程，实现拦截目标进程运行过程的关键信

SKPrimin的博客 3584

Oracle19c SYSAUX表空间爆满？手把手教你清理SM/ADVISOR和AUDSYS占用（附完整SQL）

本文详细解析了Oracle19c中SYSAUX表空间爆满的常见原因及解决方案，重点针对SM/ADVISOR和AUDSYS组件的空间占用问题提供了完整的SQL清理脚本。通过诊断查询、空间清理和预防性维护策略，帮助DBA有效管理SYSAUX表空间，确保数据库稳定运行。

weixin_28338005的博客 243

银行业数据科学家的 6 条经验教训

原本希望在计算机科学、统计学和机器学习领域工作。运用新方法获得独特见解，实现一切自动化。简而言之，最终成了这个职业炒作的牺牲品。我想和你们分享一下。希望我们能够摆脱炒作，提高你对数据科学家工作的理解。

茶桁专栏 247
上一篇： 最通用的自删除代码收藏
下一篇： My Root Kit Note
点赞 0
评论 0
书签 书签 1
大浪淘沙1
大浪淘沙1
博客等级 码龄19年 42粉丝 38原创
+ 关注
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值