精华内容
下载资源
问答
  • 源码介绍 《DLL劫持》技术当一个可执行文件运行时,Windows加载器将可执行模块映射到进程的地址空间中,加载器分析可执行模块的输入表,并设法...本插件是用易语言编写的DLL劫持补丁(Version.dll)插件大家可以测试下。
  • Navicat Premium v12.0.18(v12.0.x) x86/64 劫持 补丁
  • 补丁说明:补丁版本 v4,可通过 payload.bin 文件支持其它语系。 支持 x86/64 Win7+,需要安装 VS 2017 运行时。 支持简繁英三语版导航猫 v12.0.11~18 x86/64。
  • 1. 和谐补丁仅支持官方原版,若使用其他破解版请先卸载后安装VAX官方原版。 2. 运行Visual Assist X 通用破解补丁程序,点击安装,重新启动VS输入注册信息完成破解。 3. 当安装或卸载VA_X时,会提示注册信息对当前...
  • DLL补丁劫持制作

    2019-09-25 20:53:02
    PYG-优雅DLL劫持补丁制作工具   0x02 这个软件是比较低的版本,跟现在升级之后的网络验证有很多不同,本篇是讲的DLL补丁劫持   0x03 PEID查壳 无壳,C++编写的,不用在意字符串找不到的问题   0x...

    DLL:

    由于输入表中只包含 DLL 名而没有它的路径名,因此加载程序必须在磁盘上搜索 DLL 文件。首先会尝试从当前程序所在的目录加载 DLL,如果没找到,则在Windows 系统目录中查找,最后是在环境变量中列出的各个目录下查找。利用这个特点,先伪造一个系统同名的 DLL,提供同样的输出表,每个输出函数转向真正的系统 DLL。程序调用系统 DLL 时会先调用当前目录下伪造的 DLL,完成相关功能后,再跳到系统DLL同名函数里执行。这个过程用个形象的词来描述就是系统 DLL 被劫持(hijack)了。

    利用这种方法取得控制权后,可以对主程序进行补丁。此种方法只对除kernel32.dll、ntdll.dll等核心系统库以外的DLL有效,如网络应用程序的ws2_32.dll、游戏程序中的d3d8.dll,还有大部分应用程序都调用的lpk.dll、sxs.dll,这些DLL都可被劫持。


    伪造的 dll 制作好后,放到程序当前目录下,这样当原程序调用原函数时就调用了伪造的dll的同名函数,进入劫持DLL的代码,处理完毕后,再调用原DLL此函数。

     

    案例软件也是从某个破解论坛上找的,算是拿着做课后练习,边学边记录.

     

    0x01

    OD

    PYG-优雅DLL劫持补丁制作工具

     

    0x02

    这个软件是比较低的版本,跟现在升级之后的网络验证有很多不同,本篇是讲的DLL补丁劫持

     

    0x03

    PEID查壳

    无壳,C++编写的,不用在意字符串找不到的问题

     

    0x04

    载入OD,CTRL+G,到401000

    因为之前没有加壳,80%的可能是可以查找到字符串的

    来到最上边,找到到期时间双击到代码处,我们就干掉试用时间,达到长久试用的效果

    00401291  |. /0F85 2B010000jnz 2.004013C2
    
    00401297  |. |68 40726A00   push 2.006A7240
    
    0040129C  |. |8B0424        mov eax, dword ptr ss:[esp]
    
    0040129F  |. |8B00          mov eax, dword ptr ds:[eax]
    
    004012A1  |. |8B00          mov eax, dword ptr ds:[eax]
    
    004012A3  |. |FF90 88000000call dword ptr ds:[eax+0x88]
    
    004012A9  |. |8945 F8       mov [local.2], eax
    
    004012AC  |. |837D F8 01    cmp [local.2], 0x1
    
    004012B0  |. |0F85 D7000000jnz 2.0040138D
    
    004012B6  |. |68 40726A00   push 2.006A7240
    
    004012BB  |. |8B0424        mov eax, dword ptr ss:[esp]
    
    004012BE  |. |8B00          mov eax, dword ptr ds:[eax]
    
    004012C0  |. |8B00          mov eax, dword ptr ds:[eax]
    
    004012C2  |. |FF50 28       call dword ptr ds:[eax+0x28]
    
    004012C5  |. |8945 FC       mov [local.1], eax
    
    004012C8  |. |FF75 FC       push [local.1]
    
    004012CB  |. |68 7E844700   push 2.0047847E                          ;  到期时间:
    
    004012D0  |. |B9 02000000   mov ecx, 0x2
    
    004012D5  |. |E8 AAFEFFFF   call 2.00401184
    
    004012DA  |. |83C4 08       add esp, 0x8
    
    004012DD  |. |8945 F8       mov [local.2], eax
    
    004012E0  |. |8B5D FC       mov ebx, [local.1]
    
    004012E3  |. |85DB          test ebx, ebx
    
    004012E5  |. |74 09         je short 2.004012F0
    
    004012E7  |. |53            push ebx
    
    004012E8  |. |E8 156F0000   call 2.00408202
    
    004012ED  |. |83C4 04       add esp, 0x4
    
    004012F0  |> |6A 00         push 0x0
    
    004012F2  |. |6A 00         push 0x0
    
    004012F4  |. |6A 00         push 0x0
    
    004012F6  |. |68 01030080   push 0x80000301
    
    004012FB  |. |6A 00         push 0x0
    
    004012FD  |. |68 00000000   push 0x0
    
    00401302  |. |68 04000080   push 0x80000004
    
    00401307  |. |6A 00         push 0x0
    
    00401309  |. |8B45 F8       mov eax, [local.2]
    
    0040130C  |. |85C0          test eax, eax
    
    0040130E  |. |75 05         jnz short 2.00401315
    
    00401310  |. |B8 79844700   mov eax, 2.00478479
    
    00401315  |> |50            push eax
    
    00401316  |. |68 03000000   push 0x3
    
    0040131B  |. |BB 608D4000   mov ebx, 2.00408D60
    
    00401320  |. |E8 E36E0000   call 2.00408208
    
    00401325  |. |83C4 28       add esp, 0x28
    
    00401328  |. |8B5D F8       mov ebx, [local.2]
    
    0040132B  |. |85DB          test ebx, ebx
    
    0040132D  |. |74 09         je short 2.00401338
    
    0040132F  |. |53            push ebx
    
    00401330  |. |E8 CD6E0000   call 2.00408202
    
    00401335  |. |83C4 04       add esp, 0x4
    
    00401338  |> |6A 00         push 0x0
    
    0040133A  |. |68 00000000   push 0x0
    
    0040133F  |. |6A FF         push -0x1
    
    00401341  |. |6A 05         push 0x5
    
    00401343  |. |68 00000106   push 0x6010000
    
    00401348  |. |68 01000152   push 0x52010001
    
    0040134D  |. |E8 DA6E0000   call 2.0040822C
    
    00401352  |. |83C4 18       add esp, 0x18
    
    00401355  |. |68 02000080   push 0x80000002
    
    0040135A  |. |6A 00         push 0x0
    
    0040135C  |. |68 

    转载于:https://www.cnblogs.com/ichunqiu/p/6742465.html

    展开全文
  • 这个过程用个形象的词来描述就是系统DLL被劫持 (hijack)了。 示例DELPHI源码: Library   USP10;  uses Windows,  SysUtils,  Classes;  {$R *.res} ModHandle: Cardinal ;  ...

    当一个可执行文件运行时,Windows加载器将可执行模块映射到进程的地址空间中,加载器分析可执行模块的输入表,并设法找出任何需要的DLL,并将它们映射到进程的地址空间中。由于输入表中只包含DLL名而没有它的路径名,因此加载程序必须在磁盘上搜索DLL文件。首先会尝试从当前程序所在的目录加载DLL,如果没找到,则在Windows系统目录查找,最后是在环境变量中列出的各个目录下查找。利用这个特点,先伪造一个系统同名的DLL,提供同样的输出表,每个输出函数转向真正的系统DLL。程序调用系统DLL时会先调用当前目录下伪造的DLL,完成相关功能后,再跳到系统DLL同名函数里执行。这个过程用个形象的词来描述就是系统DLL被劫持
    (hijack)了。
    示例DELPHI源码:

    Library USP10; 

    uses
    Windows, 
    SysUtils, 
    Classes; 
    {$R *.res}
    ModHandle: Cardinal
    POldLpkPresent: Pointer
    POldScriptApplyDigitSubstitution: Pointer
    POldScriptApplyLogicalWidth: Pointer
    POldScriptBreak: Pointer
    POldScriptCPtoX: Pointer
    POldScriptCacheGetHeight: Pointer
    POldScriptFreeCache: Pointer
    POldScriptGetCMap: Pointer
    POldScriptGetFontProperties: Pointer
    POldScriptGetGlyphABCWidth: Pointer
    POldScriptGetLogicalWidths: Pointer
    POldScriptGetProperties: Pointer
    POldScriptIsComplex: Pointer
    POldScriptItemize: Pointer
    POldScriptJustify: Pointer
    POldScriptLayout: Pointer
    POldScriptPlace: Pointer
    POldScriptRecordDigitSubstitution: Pointer
    POldScriptShape: Pointer
    POldScriptStringAnalyse: Pointer
    POldScriptStringCPtoX: Pointer
    POldScriptStringFree: Pointer
    POldScriptStringGetLogicalWidths: Pointer
    POldScriptStringGetOrder: Pointer
    POldScriptStringOut: Pointer
    POldScriptStringValidate: Pointer
    POldScriptStringXtoCP: Pointer
    POldScriptString_pLogAttr: Pointer
    POldScriptString_pSize: Pointer
    POldScriptString_pcOutChars: Pointer
    POldScriptTextOut: Pointer
    POldScriptXtoCP: Pointer
    POldUspAllocCache: Pointer
    POldUspAllocTemp: Pointer
    POldUspFreeMem: Pointer
    procedure LpkPresent; asm jmp POldLpkPresent end
    procedure ScriptApplyDigitSubstitution; asm jmp POldScriptApplyDigitSubstitution end
    procedure ScriptApplyLogicalWidth; asm jmp POldScriptApplyLogicalWidth end
    procedure ScriptBreak; asm jmp POldScriptBreak end
    procedure ScriptCPtoX; asm jmp POldScriptCPtoX end
    procedure ScriptCacheGetHeight; asm jmp POldScriptCacheGetHeight end
    procedure ScriptFreeCache; asm jmp POldScriptFreeCache end
    procedure ScriptGetCMap; asm jmp POldScriptGetCMap end
    procedure ScriptGetFontProperties; asm jmp POldScriptGetFontProperties end
    procedure ScriptGetGlyphABCWidth; asm jmp POldScriptGetGlyphABCWidth end
    procedure ScriptGetLogicalWidths; asm jmp POldScriptGetLogicalWidths end
    procedure ScriptGetProperties; asm jmp POldScriptGetProperties end
    procedure ScriptIsComplex; asm jmp POldScriptIsComplex end
    procedure ScriptItemize; asm jmp POldScriptItemize end
    procedure ScriptJustify; asm jmp POldScriptJustify end
    procedure ScriptLayout; asm jmp POldScriptLayout end
    procedure ScriptPlace; asm jmp POldScriptPlace end
    procedure ScriptRecordDigitSubstitution; asm jmp POldScriptRecordDigitSubstitution end
    procedure ScriptShape; asm jmp POldScriptShape end
    procedure ScriptStringAnalyse; asm jmp POldScriptStringAnalyse end
    procedure ScriptStringCPtoX; asm jmp POldScriptStringCPtoX end
    procedure ScriptStringFree; asm jmp POldScriptStringFree end
    procedure ScriptStringGetLogicalWidths; asm jmp POldScriptStringGetLogicalWidths end
    procedure ScriptStringGetOrder; asm jmp POldScriptStringGetOrder end
    procedure ScriptStringOut; asm jmp POldScriptStringOut end
    procedure ScriptStringValidate; asm jmp POldScriptStringValidate end
    procedure ScriptStringXtoCP; asm jmp POldScriptStringXtoCP end
    procedure ScriptString_pLogAttr; asm jmp POldScriptString_pLogAttr end
    procedure ScriptString_pSize; asm jmp POldScriptString_pSize end
    procedure ScriptString_pcOutChars; asm jmp POldScriptString_pcOutChars end
    procedure ScriptTextOut; asm jmp POldScriptTextOut end
    procedure ScriptXtoCP; asm jmp POldScriptXtoCP end
    procedure UspAllocCache; asm jmp POldUspAllocCache end
    procedure UspAllocTemp; asm jmp POldUspAllocTemp end
    procedure UspFreeMem; asm jmp POldUspFreeMem end
     
    exports
    LpkPresent, 
    ScriptApplyDigitSubstitution, 
    ScriptApplyLogicalWidth, 
    ScriptBreak, 
    ScriptCPtoX, 
    ScriptCacheGetHeight, 
    ScriptFreeCache, 
    ScriptGetCMap, 
    ScriptGetFontProperties, 
    ScriptGetGlyphABCWidth, 
    ScriptGetLogicalWidths, 
    ScriptGetProperties, 
    ScriptIsComplex, 
    ScriptItemize, 
    ScriptJustify, 
    ScriptLayout, 
    ScriptPlace, 
    ScriptRecordDigitSubstitution, 
    ScriptShape, 
    ScriptStringAnalyse, 
    ScriptStringCPtoX, 
    ScriptStringFree, 
    ScriptStringGetLogicalWidths, 
    ScriptStringGetOrder, 
    ScriptStringOut, 
    ScriptStringValidate, 
    ScriptStringXtoCP, 
    ScriptString_pLogAttr, 
    ScriptString_pSize, 
    ScriptString_pcOutChars, 
    ScriptTextOut, 
    ScriptXtoCP, 
    UspAllocCache, 
    UspAllocTemp, 
    UspFreeMem; 
    begin
    ModHandle:= LoadLibrary('C:\WINDOWS\system32\usp10.dll'); 
    if ModHandle > 0 then
    begin
       POldLpkPresent:= GetProcAddress(ModHandle, 'LpkPresent'); 
       POldScriptApplyDigitSubstitution:= GetProcAddress(ModHandle,'ScriptApplyDigitSubstitution'); 
       POldScriptApplyLogicalWidth:= GetProcAddress(ModHandle,'ScriptApplyLogicalWidth'); 
       POldScriptBreak:= GetProcAddress(ModHandle, 'ScriptBreak'); 
       POldScriptCPtoX:= GetProcAddress(ModHandle, 'ScriptCPtoX'); 
       POldScriptCacheGetHeight:= GetProcAddress(ModHandle, 'ScriptCacheGetHeight'); 
       POldScriptFreeCache:= GetProcAddress(ModHandle, 'ScriptFreeCache'); 
       POldScriptGetCMap:= GetProcAddress(ModHandle, 'ScriptGetCMap'); 
       POldScriptGetFontProperties:= GetProcAddress(ModHandle,'ScriptGetFontProperties'); 
       POldScriptGetGlyphABCWidth:= GetProcAddress(ModHandle, 'ScriptGetGlyphABCWidth'); 
       POldScriptGetLogicalWidths:= GetProcAddress(ModHandle, 'ScriptGetLogicalWidths'); 
       POldScriptGetProperties:= GetProcAddress(ModHandle, 'ScriptGetProperties'); 
       POldScriptIsComplex:= GetProcAddress(ModHandle, 'ScriptIsComplex'); 
       POldScriptItemize:= GetProcAddress(ModHandle, 'ScriptItemize'); 
       POldScriptJustify:= GetProcAddress(ModHandle, 'ScriptJustify'); 
       POldScriptLayout:= GetProcAddress(ModHandle, 'ScriptLayout'); 
       POldScriptPlace:= GetProcAddress(ModHandle, 'ScriptPlace'); 
       POldScriptRecordDigitSubstitution:= GetProcAddress(ModHandle,'ScriptRecordDigitSubstitution'); 
       POldScriptShape:= GetProcAddress(ModHandle, 'ScriptShape'); 
       POldScriptStringAnalyse:= GetProcAddress(ModHandle, 'ScriptStringAnalyse'); 
       POldScriptStringCPtoX:= GetProcAddress(ModHandle, 'ScriptStringCPtoX'); 
       POldScriptStringFree:= GetProcAddress(ModHandle, 'ScriptStringFree'); 
       POldScriptStringGetLogicalWidths:= GetProcAddress(ModHandle,'ScriptStringGetLogicalWidths'); 
       POldScriptStringGetOrder:= GetProcAddress(ModHandle, 'ScriptStringGetOrder'); 
       POldScriptStringOut:= GetProcAddress(ModHandle, 'ScriptStringOut'); 
       POldScriptStringValidate:= GetProcAddress(ModHandle, 'ScriptStringValidate'); 
       POldScriptStringXtoCP:= GetProcAddress(ModHandle, 'ScriptStringXtoCP'); 
       POldScriptString_pLogAttr:= GetProcAddress(ModHandle, 'ScriptString_pLogAttr'); 
       POldScriptString_pSize:= GetProcAddress(ModHandle, 'ScriptString_pSize'); 
       POldScriptString_pcOutChars:= GetProcAddress(ModHandle,'ScriptString_pcOutChars'); 
       POldScriptTextOut:= GetProcAddress(ModHandle, 'ScriptTextOut'); 
       POldScriptXtoCP:= GetProcAddress(ModHandle, 'ScriptXtoCP'); 
       POldUspAllocCache:= GetProcAddress(ModHandle, 'UspAllocCache'); 
       POldUspAllocTemp:= GetProcAddress(ModHandle, 'UspAllocTemp'); 
       POldUspFreeMem:= GetProcAddress(ModHandle, 'UspFreeMem'); 
    end
    begin
    //添加自己的补丁内容!
    end
    end.

    转载于:https://www.cnblogs.com/plug/p/8665616.html

    展开全文
  • Visual Assist X插件VAX2231 for vs2017(附劫持破解补丁+破解教程)
  • 在逆向工程中,经常需要改变程序原有的执行流程,使其增加或者减少一些功能代码,这就需要对原文件进行补丁补丁分文件补丁和内存补丁两种。文件补丁就是修改文件本身某个数据,达到一劳永逸的效果。顾名思义,内存...
  • 软件安全系列图书——《加密与解密》(第三版)   ...第18章 补丁技术20 ...18.1 文件补丁 ...18.2.4 DLL劫持技术 18.3 SMC补丁技术 18.3.1 单层SMC补丁技术 18.3.2 多层SMC补丁技术 18

    软件安全系列图书——《加密与解密》(第三版)

     

    引用:

    第18章 补丁技术20

    18.1 文件补丁

    18.2 内存补丁

    18.2.1 跨进程内存存取机制

    18.2.2 Debug API机制

    18.2.3 利用调试寄存器机制

    18.2.4 DLL劫持技术

    18.3 SMC补丁技术

    18.3.1 单层SMC补丁技术

    18.3.2 多层SMC补丁技术

    18.4 补丁工具

     

     

    【转】DLL劫持技术(内存补丁技术) - 心雪*冰狐 - 心雪*冰狐 

    18.2.4 DLL劫持技术

     

    说明

    我是从CoDe_Inject帮助下才了解这个DLL劫持技术(或称HOOK),利用这个制作内存补丁非常的好用。

    Yonsm在几年前,写了个工具AheadLib,可以很方便地生成各类DLL头文件,见本帖2楼。

    这种补丁方法,适合制作被ASProtect,Armadillo,Themida等各类强壳保护软件的补丁。

     

    当一个可执行文件运行时,Windows加载器将可执行模块映射到进程的地址空间中,加载器分析可执行模块的输入表,并设法找出任何需要的DLL,并将它们映射到进程的地址空间中。

     

    由于输入表中只包含DLL名而没有它的路径名,因此加载程序必须在磁盘上搜索DLL文件。首先会尝试从当前程序所在的目录加载DLL,如果没找到,则在Windows系统目录查找,最后是在环境变量中列出的各个目录下查找。利用这个特点,先伪造一个系统同名的DLL,提供同样的输出表,每个输出函数转向真正的系统DLL。程序调用系统DLL时会先调用当前目录下伪造的DLL,完成相关功能后,再跳到系统DLL同名函数里执行,如图18.4。这个过程用个形象的词来描述就是系统DLL被劫持(hijack)了。

     

    【转】DLL劫持技术(内存补丁技术) - 心雪*冰狐 - 心雪*冰狐 

    利用这种方法取得控制权后,可以对主程序进行补丁。此种方法只对除kernel32.dll, ntdll.dll等核心系统库以外的DLL有效,如网络应用程序的ws2_32.dll,游戏程序中的d3d8.dll,还有大部分应用程序都调用的lpk.dll,这些DLL都可被劫持。

    利用5.6.2章提供的CrackMeNet.exe来演示一下如何利用劫持技术制作补丁,目标文件用Themida v1.9.2.0加壳保护。

     

    1.补丁地址

    去除这个CrackMe网络验证方法参考第5章,将相关补丁代码存放到函数PatchProcess( )里。例如将401496h改成:

    代码:

    00401496 EB 29 jmp short 004014C1

    补丁编程实现就是:

    代码:

     unsigned char p401496[2] = {0xEB, 0x29};
            WriteProcessMemory(hProcess,(LPVOID)0x401496, p401496, 2, NULL);

    p401496这个数组的数据格式,可以用OllyDBG插件获得,或十六进制工具转换。例如Hex Workshop打开文件,执行菜单Edit/Copy As/Source即可得到相应的代码格式。

     

    2.构建输出函数

    查看实例CrackMeNet.exe输入表,会发现名称为ws2_32.dll的DLL,因此构造一个同名的DLL来完成补丁任务。伪造的ws2_32.dll有着真实ws2_32.dll一样的输出函数,完整源码见光盘。实现时,可以利用DLL模块中的函数转发器来实现这个目标,其会将对一个函数的调用转至另一个DLL中的另一个函数。可以这样使用一个pragma指令:

    代码:

    #pragma comment(linker, "/EXPORT:SomeFunc=DllWork.someOtherFunc")

    这个pragma告诉链接程序,被编译的DLL应该输出一个名叫SomeFunc的函数。但是SomeFunc函数的实现实际上位于另一个名叫SomeOtherFunc的函数中,该函数包含在称为DllWork. dll的模块中。

    如要达到劫持DLL的目的,生成的DLl输出函数必须与目标DLL输出函数名一样,本例可以这样构造pragma指令:

    代码:

    #pragma comment(linker, "/EXPORT:WSAStartup=_MemCode_WSAStartup,@115")

    编译后的DLL,会有与ws2_32.dll同名的一个输出函数WSAStartup,实际操作时,必须为想要转发的每个函数创建一个单独的pragma代码行,读者可以写一个工具或用其他办法,将ws2_32.dll输出函数转换成相应的pragma指令。

     

    当应用程序调用伪装ws2_32.dll的输出函数时,必须将其转到系统ws2_32.dl中去,这部分的代码自己实现。例如WSAStartup输出函数如下构造:

    代码:

     ALCDECL MemCode_WSAStartup(void){GetAddress("WSAStartup");__asm JMP EAX;//转到系统ws2_32.dll的WSAStartup输出函数}

    其中GetAddress()函数的代码如下:

    代码:

     // MemCode 命名空间namespace MemCode{HMODULE m_hModule = NULL;
     //原始模块句柄DWORD m_dwReturn[500] = {0}; 
    //原始函数返回地址
    // 加载原始模块inline BOOL WINAPI Load(){TCHAR tzPath[MAX_PATH]={0};TCHAR tzTemp[MAX_PATH]={0};GetSystemDirectory(tzPath, sizeof(tzPath));strcat(tzPath,"<A href="file://ws2_32.dll/" target=_blank>\\ws2_32.dll</A>");m_hModule = LoadLibrary(tzPath);
    //加载系统系统目录下ws2_32.dllif (m_hModule == NULL){wsprintf(tzTemp, TEXT("无法加载 %s,程序无法正常运行。"), tzPath);MessageBox(NULL, tzTemp, TEXT("MemCode"), MB_ICONSTOP);}return (m_hModule != NULL); } // 释放原始模块inline VOID WINAPI Free(){if (m_hModule)FreeLibrary(m_hModule);}// 获取原始函数地址FARPROC WINAPI GetAddress(PCSTR pszProcName){FARPROC fpAddress;TCHAR szProcName[16]={0};TCHAR tzTemp[MAX_PATH]={0}; if (m_hModule == NULL){if (Load() == FALSE)ExitProcess(-1);} fpAddress = GetProcAddress(m_hModule, pszProcName);if (fpAddress == NULL){if (HIWORD(pszProcName) == 0){wsprintf(szProcName, "%d", pszProcName);pszProcName = szProcName;}wsprintf(tzTemp, TEXT("无法找到函数 %hs,程序无法正常运行。"), pszProcName);MessageBox(NULL, tzTemp, TEXT("MemCode"), MB_ICONSTOP);ExitProcess(-2);}return fpAddress;}}using namespace MemCode;

    编译后,用LordPE查看伪造的ws2_32.dll输出函数,和真实ws2_32.dll完全一样,如图18.5所示。

     

    【转】DLL劫持技术(内存补丁技术) - 心雪*冰狐 - 心雪*冰狐

    查看伪造的ws2_32.dll中任意一个输出函数,例如WSACleanup:

    代码:

     .text:10001CC0 ; int __stdcall WSACleanup().text:10001CC0 WSACleanup proc near.text:10001CC0 push offset aWsacleanup ;"WSACleanup".text:10001CC5 call sub_10001000 ;GetAddress(WSACleanup).text:10001CCA jmp eax.text:10001CCA WSACleanup endp

    会发现输出函数WSACleanup()首先调用GetAddress(WSACleanup),获得真实ws2_32.dll中WSACleanup的地址,然后跳过去执行,也就是说ws2_32.dll各输出函数被HOOK了。

     

    3.劫持输出函数

    ws2_32.dll有许多输出函数,经分析,程序发包或接包时,WSAStartup输出函数调用的比较早,因此在这个输出函数放上补丁的代码。代码如下:

    代码:

     ALCDECL MemCode_WSAStartup(void){hijack();GetAddress("WSAStartup");__asm JMP EAX; }hijack()函数主要是判断是不是目标程序,如是就调用PatchProcess()进行补丁。void hijack(){if (isTarget(GetCurrentProcess())) //判断主程序是不是目标程序,是则补丁之{PatchProcess(GetCurrentProcess());}}

    伪造的ws2_32.dll制作好后,放到程序当前目录下,这样当原程序调用WSASTartup函数时就调用了伪造的ws2_32.dll的WSASTartup函数,此时hijack()函数负责核对目标程序校验,并将相关数据补丁好,处理完毕后,转到系统目录下的ws2_32.dll执行。

    这种补丁技术,对加壳保护的软件很有效,选择挂接的函数最好是在壳中没有被调用,当挂接函数被执行时,相关的代码己被解压,可以直接补丁了。有些情况下,必须用计数器统计挂接的函数的调用次数来接近OEP。此方法巧妙地绕过了壳的复杂检测,很适合加壳程序的补丁制作。

    一些木马或病毒也会利用DLL劫持技术搞破坏,因此当在应用程序目录下发现系统一些DLL文件存在时,应引起注意。

     

    看雪软件安全

    http://www.pediy.com

    2008.3.8

     

    展开全文
  •  ...由于输入表是根据DLL名来进行查找,首先是查找当前目录下有没这文件,没有话在去查找系统目录C:\\Windows\\system32有没这文件,所以我们可以完全趁这个机会去劫持DLL,把他劫持下来后就可以
    

    在windows下当一个可执行文件运行时,Windows加载器将可执行模块映射到进程的地址空间中,加载器分析可执行模块的输入表,并设法找出任何需要的DLL,并将它们映射到进程的地址空间中。由于输入表是根据DLL名来进行查找,首先是查找当前目录下有没这文件,没有话在去查找系统目录C:\\Windows\\system32有没这文件,所以我们可以完全趁这个机会去劫持DLL,把他劫持下来后就可以在里面进行我们要做的事情。


    为了让我们自己开发的补丁DLL有导出函数,我们可以用 #parma comment(..),如:


    #pragma comment(linker, "/EXPORT:testadd=_TESTDLLLIB_testadd,@1")
    



    1.补丁前DLL。

    //tstDll.dll 补丁前
    //By symanli
    #include "stdafx.h"
    #include "dll.h"
    BOOL APIENTRY DllMain( HANDLE hModule, 
                           DWORD  ul_reason_for_call, 
                           LPVOID lpReserved
                                             )
    {
        return TRUE;
    }
    //原始函数
    int testadd(int a,int b)
    {
            ::MessageBox(NULL,"这是补丁前的DLL","TODO",MB_OK);
            return a+b;
    }
    
    
    
    


    2.补丁后DLL

    //这是补丁代码。by symanli
    
    // 头文件
    #include <Windows.h>
    
    // 宏定义
    #define EXTERNC extern "C"
    #define NAKED __declspec(naked)
    #define EXPORT __declspec(dllexport)
    
    #define ALCPP EXPORT NAKED
    #define ALSTD EXTERNC EXPORT NAKED void __stdcall
    #define ALCFAST EXTERNC EXPORT NAKED void __fastcall
    #define ALCDECL EXTERNC NAKED void __cdecl
    
    // TESTDLLLIB 命名空间
    namespace TESTDLLLIB
    {
            HMODULE m_hModule = NULL;        // 原始模块句柄
            DWORD m_dwReturn[1] = {0};        // 原始函数返回地址
            
            
            // 加载原始模块
            inline BOOL WINAPI Load()
            {
                    TCHAR tzPath[MAX_PATH];
                    TCHAR tzTemp[MAX_PATH * 2];
                    
                    //将原始DLL名改成其他的名字,我们用LoadLibrary去加载他。
                    lstrcpy(tzPath, TEXT("tstDllold.dll"));
                    m_hModule = LoadLibrary(tzPath);
                    if (m_hModule == NULL)
                    {
                            wsprintf(tzTemp, TEXT("无法加载 %s,程序无法正常运行。"), tzPath);
                            MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
                    }
                    
                    return (m_hModule != NULL);        
            }
            
            // 释放原始模块
            inline VOID WINAPI Free()
            {
                    if (m_hModule)
                    {
                            FreeLibrary(m_hModule);
                    }
            }
            
            // 获取原始函数地址
            FARPROC WINAPI GetAddress(PCSTR pszProcName)
            {
                    FARPROC fpAddress;
                    CHAR szProcName[16];
                    TCHAR tzTemp[MAX_PATH];
                    
                    fpAddress = GetProcAddress(m_hModule, pszProcName);
                    if (fpAddress == NULL)
                    {
                            if (HIWORD(pszProcName) == 0)
                            {
                                    wsprintf(szProcName, "%d", pszProcName);
                                    pszProcName = szProcName;
                            }
                            
                            wsprintf(tzTemp, TEXT("无法找到函数 %hs,程序无法正常运行。"), pszProcName);
                            MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
                            ExitProcess(-2);
                    }
                    
                    return fpAddress;
            }
    }
    using namespace TESTDLLLIB;
    
    // 入口函数
    BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
    {
            if (dwReason == DLL_PROCESS_ATTACH)
            {
                    DisableThreadLibraryCalls(hModule);
                    
                    for (INT i = 0; i < sizeof(m_dwReturn) / sizeof(DWORD); i++)
                    {
                            m_dwReturn[i] = TlsAlloc();
                    }
                    
                    return Load();
            }
            else if (dwReason == DLL_PROCESS_DETACH)
            {
                    for (INT i = 0; i < sizeof(m_dwReturn) / sizeof(DWORD); i++)
                    {
                            TlsFree(m_dwReturn[i]);
                    }
                    
                    Free();
            }
            
            return TRUE;
    }
    // 导出函数
    ALCDECL TESTDLLLIB_testadd(void)
    {
            ::MessageBox(NULL,"这是补丁后的DLL","TODO",MB_OK);
            // 保存返回地址到 TLS
            //__asm PUSH m_dwReturn[0 * TYPE long];
            //__asm CALL DWORD PTR [TlsSetValue];
            
            // 调用原始函数
            GetAddress("testadd");
            __asm JMP EAX;
            // 获取返回地址并返回
    
    //         __asm PUSH EAX;
    //         __asm PUSH m_dwReturn[0 * TYPE long];
    //         __asm CALL DWORD PTR [TlsGetValue];
    //         __asm XCHG EAX, [ESP];
    //         __asm RET;
    
    }
    #pragma comment(linker, "/EXPORT:testadd=_TESTDLLLIB_testadd,@1")
    
    

    exe调用

    //exe调用代码
    #pragma  comment(lib,"tstDll.lib")//导入先前DLL的lib,就是最原始的LIB
    void CTstExeDlg::OnButton1() 
    {
            // TODO: Add your control notification handler code here
            int _sum =testadd(10,20);
            CString szSum;
            szSum.Format("结果是:[%d]",_sum);
            AfxMessageBox(szSum);
    }
    





    展开全文
  • DLL劫持技术(内存补丁技术)

    千次阅读 2009-12-22 10:14:00
    《加密与解密(第三版)》这种补丁方法,适合制作被ASProtect,Armadillo,Themida等各类强壳保护软件的补丁。当一个可执行文件运行时,Windows加载器将可执行模块映射到进程的地址空间中,加载器分析可执行模块的输入表...
  • 与DLL函数查看器3.5配套使用 DLL函数查看器3.5的ViewApi_增强补丁 下载后解压到 DLL函数查看器3.5程序目录 可以增加一些很方便的功能
  • 支持简体中文、繁体中文、英文三个版本的劫持补丁,补丁来源https://www.52pojie.cn/thread-618718-1-1.html
  • VEH硬件断点劫持

    2013-07-17 15:56:25
    VEH-硬件断点+dll劫持内存补丁vs2008源码
  • dll劫持技术

    千次阅读 2015-07-15 17:00:41
    说起DLL劫持技术,相信大家都不会陌生,因为这种技术的应用比较广泛,比如木马后门的 启动、破解程序的内存补丁、外挂插件的注入以及加密狗的模拟等。之所以DLL劫持技术深受黑客们的喜爱,主要是因为该技术可以有效...
  • dll劫持破坏360

    2019-04-14 22:05:00
    说起DLL劫持技术,相信大家都不会陌生,因为这种技术的应用比较广泛,比如木马后门的启动、破解程序的内存补丁、外挂插件的注入以及加密狗的模拟等。之所以DLL劫持技术深受黑客们的喜爱,主要是因为该技术可以有效的...
  • DLL劫持技术

    千次阅读 2008-11-26 14:17:00
    DLL劫持技术2008-09-14 21:02说明我是从CoDe_Inject帮助下才了解这个DLL劫持技术(或称HOOK),利用这个制作内存补丁非常的好用。Yonsm在几年前,写了个工具AheadLib,可以很方便地生成各类DLL头文件,见本帖2楼。...
  • LD_PRELOAD实现API劫持

    2021-04-17 17:46:36
    API劫持主要是利用动态链接技术,通过预先加载SO,隐藏符号。达到动态替换API的功能。 API劫持技术可用于热补丁等领域。
  • 网站遇到被黑,被恶意镜像怎么办?这是同学们最头疼的问题,...下面讲几个点,针对于网站被黑被劫持了的解决办法。 第一,网站程序的安全,我们使用开源程序。一定要做好程序版本的更新和勤打补丁。使用越多的程序使用
  • IAT-Hook 劫持进程Api调用

    千次阅读 2018-05-28 16:40:45
    鹅厂面试的时候回答劫持API的各种Hook方式的时候,IAT-Hook应该算是最简单的一个。比IAT-Hook更难的是R3的5字节Hook,然后是热补丁Hook,SSDT-Hook….. 5字节Hook在前两篇进程隐藏中用过了,7字节主要是对API的要求...
  • 黑客登录到sshd服务系统之后会用木马补丁文件将原来的sshd服务替换掉,并且留下后门密码,此后门密码还可以直接登录系统。 过程2:网络管理员登录到系统之后,所登录的路径已经不是原来真实安全的路...
  • DLL劫持技术详解(lpk.dll)

    千次阅读 2016-09-08 10:09:21
    说起DLL劫持技术,相信大家都不会陌生,因为这种技术的应用比较广泛,比如木马后门的启动、破解程序的内存补丁、外挂插件的注入以及加密狗的模拟等。之所以DLL劫持技术深受黑客们的喜爱,主要是因为该技术可以有效的...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 167
精华内容 66
关键字:

劫持补丁