程序破解之 API HOOK技术 z

API
HOOK,就是截获API调用的技术，在程序对一个API调用之前先执行你的函数,然后根据你的需要可以执行缺省的API调用或者进行其他处理，假设如果想截获一个进程对网络的访问，一般是几个socket
API : recv,recvfrom, send, sendto等等,当然你可以用网络抓包工具，这里只介绍通过API HOOK的方式来实现,
主要原理是在程序运行中动态修改目标函数地址的内存数据，使用jmp语句跳转到你的函数地址，执行完后再恢复内存数据, 汇编代码是:

mov eax, pNewAddr[/size][size=3] jmp eax

读写进程内存方法:
1.读进程内存:


VirtualProtect(lpAddress, nSize, PAGE_READONLY, &dwOldProtect);

ReadProcessMemory(hProcess, lpAddress, lpBuffer, nSize, &dwRead);

VirtualProtect(lpAddress, nSize, dwOldProtect, &dwOldProtect);

2.写进程内存:


VirtualProtect(lpAddress, nSize, PAGE_READWRITE, &dwOldProtect);

WriteProcessMemory(hProcess, lpAddress, lpBuffer, nSize, &dwWrite);

VirtualProtect(lpAddress, nSize, dwOldProtect, &dwOldProtect);

在很多年前这种技术非常的流行，有各种各样的工具和SDK,我自己也实现了一个C++ class,名为 CAdHookApi, 主要几个函数是:


class CAdHookApi

{

public:

    // 指定DLL的某个函数进行HOOK

    HANDLE Add(LPCTSTR lpszModule, LPCSTR lpcFuncName, void *pNewAddr, DWORD dwData = 0);

    // 给定一个函数地址进行HOOK

    HANDLE Add(void *pOldAddr, void *pNewAddr, const BYTE *verifyData = NULL, DWORD verifySize = 0, DWORD dwData = 0);

    BOOL   Remove(HANDLE hHook);

    BOOL   Begin(HANDLE hHook);

    BOOL   End(HANDLE hHook);

    BOOL   Begin2(void *pNewAddr);

    BOOL   End2(void *pNewAddr);

    int    BeginAll();

    int    EndAll();

};

举例说明使用方法:
    假设一个软件是试用软件，试用7天，最笨的办法就是改本机时间，但如果用API
HOOK技术就可以很容易做到，可以先用CFF
Explorer或者Dependency查看一下该软件是调用哪个函数来获取系统当前时间的，假如是GetLocalTime函数(当然获取时间的函数还有很多API)，那么我就可以截获GetLocalTime,返回一个永不过期的时间.

1.首先,声明一个全局变量:


static CAdHookApi     gHooks;

2.确定要截获API的参数,API GetLocalTime对应的DLL是KERNEL32.DLL, API定义为:


void WINAPI GetLocalTime(LPSYSTEMTIME lpSystemTime);

写一个新的函数，定义和原函数保持一致:


void WINAPI my_GetLocalTime(LPSYSTEMTIME lpSystemTime)

{

#if 1

// 执行缺省调用

    CAdAutoHookApi autoHook(&gHooks, my_GetLocalTime);

    GetLocalTime(lpSystemTime);

#else

// 改变函数的行为,返回固定的时间

    // 2012-12-28 10:00:00

    lpSystemTime->wYear         = 2012;

    lpSystemTime->wMonth        = 12;

    lpSystemTime->wDayOfWeek    = 0;

    lpSystemTime->wDay          = 28;

    lpSystemTime->wHour         = 10;

    lpSystemTime->wMinute       = 0;

    lpSystemTime->wSecond       = 0;

    lpSystemTime->wMilliseconds = 0;

#endif

}

3.直接HOOK已知的函数地址:
   
如果已知函数地址和函数定义，可以直接对地址进行HOOK,在HOOK之前还可以先对内存数据进行检验，只有数据一致才HOOK.


// 004026B0 ;

static int my_sub_4026B0(BYTE *pbData)

{

CAdAutoHookApi autoHook(&gHooks, my_sub_4026B0);

sub_4026B0_func sub_4026B0 = (sub_4026B0_func)(0x004026B0);

string hexData1 = toHexString((const char *)pbData, strlen((const char *)pbData));

int ret = sub_4026B0(pbData);

string hexData2 = toHexString((const char *)pbData, strlen((const char *)pbData));


logOutput(formatString("ApiDebugger - sub_4026B0(%s=>%s)",

hexData1.c_str(), hexData2.c_str()));


return ret;

}


const BYTE verifyData[] = { 0x55, 0x8B, 0xEC, 0x81, 0xEC, 0x2C, 0x01, 0x00, 0x00 };

void *addr = (void *)0x004026B0;

if(gHooks.Add(addr, my_sub_4026B0, verifyData, sizeof(verifyData), 0) != NULL)

{

logOutput(formatString("ApiDebugger - hook sub_4026B0 ok.\r\n"));

}

else

{

logOutput(formatString("ApiDebugger - hook sub_4026B0 failed.\r\n"));

}

4.函数首次HOOK是在DLL加载时完成的,DLL入口增加代码:


BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)

{

    switch (ul_reason_for_call)

    {

    case DLL_PROCESS_ATTACH:

        {

            // 截获KERNEL32.DLL的API GetLocalTime到你的函数地址my_GetLocalTime

            gHooks.Add(_T("KERNEL32.DLL"), "GetLocalTime", my_GetLocalTime);

            // 开始HOOK所有的

            gHooks.BeginAll();

        }

        break ;

    case DLL_THREAD_ATTACH:

    case DLL_THREAD_DETACH:

        break ;

    case DLL_PROCESS_DETACH:

        {

            gHooks.EndAll();

        }

        break;

    }

    return TRUE;

}

这样就完成了，只要你的DLL加载到一个进程中，相应的函数就被你截获了.

下面谈一下如何让一个程序加载你的DLL,一般有两种方式:
1.修改原程序的Import
Table,增加导入你的DLL(静态加载):    使用工具:CFF Explorer，是Explorer
Suite(http://www.ntcore.com/)中的一个工具
用于PE文件的修改,下面这个操作就是让notepad.exe加载rand.dll的操作:


    只要Rebuild Import Table,然后再Save/Save
As就可以保存新的文件,这样你的dll就自动的被加载了，DLL加载的时候也就实现了API HOOK。

 
 
这种方式因为对原程序进行了修改，如果程序有CRC校验，运行肯定就不正确了，就需要通过破解去除CRC校验部分的判断.

2.动态DLL加载:

    在原程序运行之后，通过API CreateRemoteThread
把自己的DLL注入到另一个进程.使用DLL注入工具，这个工具是我多年前写的:


   
这种方式最大的好处是不需要对原程序进行修改，可以躲避程序CRC校验.

最后例举一些应用场景:

1.加密狗的通用破解方法,仅针对固定数据读取的有效(有算法的加密狗无效):

    1)HOOK几个API,加密狗一般最终都是使用CreateFile打开设备，调用API
DeviceIoControl与加密狗进行数据交互:


gHooks.Add(_T("KERNEL32.DLL"),  "CreateFileA",                      my_CreateFileA);

gHooks.Add(_T("KERNEL32.DLL"),  "CreateFileW",                      my_CreateFileW);

gHooks.Add(_T("KERNEL32.DLL"),  "DeviceIoControl",                  my_DeviceIoControl);


static int gCallCounter = 0;

BOOL WINAPI my_DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize,

                               LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped

                               )

{

    BOOL ret = TRUE;

    CAdAutoHookApi autoHook(&gHooks, my_DeviceIoControl);

#if 1

    ret = DeviceIoControl(hDevice, dwIoControlCode, lpInBuffer, nInBufferSize,

        lpOutBuffer, nOutBufferSize, lpBytesReturned, lpOverlapped);

    if(ret)

    {

        // 带狗时记录数据

        WriteDataToFile(formatstring(L"1\\%d.in",   gCallCounter).c_str(), lpInBuffer, nInBufferSize);

        gCallCounter ++;

    }

#else

    {

        // 拔掉后狗直接从已保存的文件中返回数据，实现狗数据的模拟

        int nRet = 0;

        *lpBytesReturned = ReadDataFromFile(formatstring(L"1\\%d.in",  gCallCounter).c_str(), lpOutBuffer, nOutBufferSize);

        gCallCounter ++;

    }

#endif

    return ret;

}

2)使用刚才提到的方法进行DLL导入
    3)带狗保存数据，数据记录完成后，用保存的数据进行狗的模拟

2.
360 CrackMe加密API的截获，这部分在我的一个帖子中有提到
    http://www.52pojie.cn/thread-257062-1-1.html

    1)HOOK以个API:


// HOOK IsDebuggerPresent可以让函数直接返回FALSE

gHooks.Add(_T("KERNEL32.DLL"),      "IsDebuggerPresent",        my_IsDebuggerPresent);


gHooks.Add(_T("ADVAPI32.DLL"),      "CryptAcquireContextW",     my_CryptAcquireContextW);

gHooks.Add(_T("ADVAPI32.DLL"),      "CryptImportKey",           my_CryptImportKey);

gHooks.Add(_T("ADVAPI32.DLL"),      "CryptCreateHash",          my_CryptCreateHash);

gHooks.Add(_T("ADVAPI32.DLL"),      "CryptHashData",            my_CryptHashData);

gHooks.Add(_T("ADVAPI32.DLL"),      "CryptDeriveKey",           my_CryptDeriveKey);

gHooks.Add(_T("ADVAPI32.DLL"),      "CryptDecrypt",             my_CryptDecrypt);


BOOL WINAPI my_IsDebuggerPresent(VOID)

{

    return FALSE;

}


int WINAPI my_CompareStringW(LCID Locale, DWORD dwCmpFlags, PCNZWCH lpString1, int cchCount1,

                          PCNZWCH lpString2,int cchCount2)

{

    CAdAutoHookApi autoHook(&gHooks, my_CompareStringW);

    logOutput(formatString("ApiDebugger - CompareStringW.\r\n"));

    int ret = CompareStringW(Locale, dwCmpFlags, lpString1, cchCount1, lpString2, cchCount2);

    logOutput(formatString("ApiDebugger - CompareStringW(%S, %S).\r\n", lpString1, lpString2));

    return ret;

}


BOOL WINAPI my_CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR szContainer, LPCWSTR szProvider,

                                 DWORD dwProvType, DWORD dwFlags)

{

    CAdAutoHookApi autoHook(&gHooks, my_CryptAcquireContextW);

    BOOL ret = CryptAcquireContextW(phProv, szContainer, szProvider, dwProvType, dwFlags);

    logOutput(formatString("ApiDebugger - CryptAcquireContextW(0x%08X, %S, %S, 0x%08X, 0x%08X) : %S.\r\n",

        (int)(*phProv),

        (szContainer != NULL) ? szContainer : L"NULL",

        (szProvider != NULL) ? szProvider : L"NULL",

        dwProvType, dwFlags,

        ret ? L"TRUE" : L"FALSE"

        ));


return ret;

}


BOOL WINAPI my_CryptImportKey(HCRYPTPROV hProv, CONST BYTE *pbData, DWORD dwDataLen, HCRYPTKEY hPubKey,

                           DWORD dwFlags, HCRYPTKEY *phKey)

{

    CAdAutoHookApi autoHook(&gHooks, my_CryptImportKey);


BOOL ret = CryptImportKey(hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);


string hexData = toHexString((const char *)pbData, dwDataLen);

    logOutput(formatString("ApiDebugger - CryptImportKey(0x%08X, %s, 0x%08X, 0x%08X, 0x%08X) : %S.\r\n",

        (int)hProv, hexData.c_str(), (int)hPubKey, dwFlags, (int)(*phKey),

        ret ? L"TRUE" : L"FALSE"

        ));


return ret;

}


BOOL WINAPI my_CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)

{

    CAdAutoHookApi autoHook(&gHooks, my_CryptCreateHash);

    BOOL ret = CryptCreateHash(hProv, Algid, hKey, dwFlags, phHash);

    logOutput(formatString("ApiDebugger - CryptCreateHash(0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X) : %S.\r\n",

        (int)hProv, (int)Algid, (int)hKey, dwFlags, (int)phHash,

        ret ? L"TRUE" : L"FALSE"

        ));

    return ret;

}


BOOL WINAPI my_CryptHashData(HCRYPTHASH hHash, CONST BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)

{

    CAdAutoHookApi autoHook(&gHooks, my_CryptHashData);

    BOOL ret = CryptHashData(hHash, pbData, dwDataLen, dwFlags);

    string hexData = toHexString((const char *)pbData, dwDataLen);

    logOutput(formatString("ApiDebugger - CryptHashData(0x%08X, %s, 0x%08X) : %S.\r\n",

        (int)hHash, hexData.c_str(), dwFlags,

        ret ? L"TRUE" : L"FALSE"

        ));

    return ret;

}


BOOL WINAPI my_CryptDeriveKey(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData, DWORD dwFlags, HCRYPTKEY *phKey)

{

    CAdAutoHookApi autoHook(&gHooks, my_CryptDeriveKey);

    BOOL ret = CryptDeriveKey(hProv, Algid, hBaseData, dwFlags, phKey);

    logOutput(formatString("ApiDebugger - CryptDeriveKey(0x%08X, 0x%08X, 0x%08X, 0x%08X, 0x%08X) : %S.\r\n",

        (int)hProv, (int)Algid, (int)hBaseData, dwFlags, (int)phKey,

        ret ? L"TRUE" : L"FALSE"

        ));

    return ret;

}


BOOL WINAPI my_CryptDecrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags,

                            BYTE *pbData, DWORD *pdwDataLen)

{

    CAdAutoHookApi autoHook(&gHooks, my_CryptDecrypt);


string hexData1 = toHexString((const char *)pbData, *pdwDataLen);

    writeDataToFile("CryptDec_IN.bin", pbData, *pdwDataLen);

    BOOL ret = CryptDecrypt(hKey, hHash, Final, dwFlags, pbData, pdwDataLen);

    string hexData2 = toHexString((const char *)pbData, *pdwDataLen);

    writeDataToFile("CryptDec_OUT.bin", pbData, *pdwDataLen);


logOutput(formatString("ApiDebugger - CryptDecrypt(0x%08X, 0x%08X, %S, 0x%08X, %s=>%s) : %S.\r\n",

        (int)hKey, (int)hHash, Final ? L"TRUE" : L"FALSE",

        dwFlags, hexData1.c_str(), hexData2.c_str(),

        ret ? L"TRUE" : L"FALSE"

        ));

    return ret;

}

3. 程序网络访问抓包,前面提到的几个api : recv,recvfrom,
send, sendto, ...

当然API
HOOK的功能还远不止这些，可以分析目标程序的特点做更多的处理，有时间我再写一个用这种方法破解HASP SRM
AES-128加密狗的经验吧。

总结：虽然API
HOOK是相对比较老的一门技术，但很多时候如果能结合这种方法就不需要花很大的精力去脱五花八门的壳和分析反汇编代码，直接锁定核心的API的调用，能够快速的进行数据分析，而且也不用对原有程序进行Patch,
简单有效.另外，本人很少发帖，难免有错字和问题，欢迎批评指正。


更多细节和代码请下载附件源程序(VS2012的工程).

时间： 2024-08-05 04:02:07

程序破解之 API HOOK技术 z的相关文章

API HOOK技术

API HOOK技术是一种用于改变API执行结果的技术,Microsoft 自身也在Windows操作系统里面使用了这个技术,如Windows兼容模式等. API HOOK 技术并不是计算机病毒专有技术,但是计算机病毒经常使用这个技术来达到隐藏自己的目的. 外文名 API HOOK      用于 改变API执行结果的技术 应用 如Windows兼容模式等  目的 计算机病毒隐藏自己的技术                                                      

VB程序破解之API断点[bp __vbaVarTstEq]

软件名称:风云足彩1.7软件大小:2.1M下载地址:http://free.ys168.com/?zhinengxuanhao软件保护:注册码编写软件:Microsoft Visual Basic 5.0 / 6.0 [Debug]破解工具:PEiD,OD破解作者:WildCatIII[D.4s] 引用: 软件介绍:足彩智能选号全能版足彩智能选号全能版 提供了足彩独特选号的方法.不论是足彩高手还是初玩者,足彩智能选号全能版都为他们提供了整套工具,以方便稳中一等奖. 但是,工具不是一个万能.能不能

API HOOK及其注入技术详解

大家有没有想过,一些系统监控软件是如何得知我们所进行的操作的?杀软启发式分析是如何对病毒行为进行拦截和监控的?外挂又是如何读取到游戏的内部数据的?这些功能的实现,基本都有API HOOK存在.API HOOK分为ring0和ring3层,这里我们以ring3层API HOOK 进行讲解分析. API HOOK 在ring 3的实现,分为inline 和修改导入表2种方法,所谓inline,是指直接写入并覆盖函数开头字节汇编码的方法,这种方法有一个问题,便是他被杀软重点监控,成功率极低,而修改导入

API HOOK

API HOOK技术是一种用于改变API执行结果的技术,Microsoft 自身也在Windows操作系统里面使用了这个技术,如Windows兼容模式等. API HOOK 技术并不是计算机病毒专有技术,但是计算机病毒经常使用这个技术来达到隐藏自己的目的. API HOOK解释 在windows系统下编程,应该会接触到api函数的使用,常用的api函数大概有2000个左右.今天随着控件,stl等高效编程技术的出现,api的使用概率在普通的用户程序上 就变得越来越小了.当诸如控件这些现成的手段不能

API Hook完全手册

文章来源: http://blog.csdn.net/atfield 原文作者: ATField 整理日期: 2008-07-16 发表评论 字体大小: 小 中 大 注:本文是根据我两年前写的一个系统行为监测程序写成(参考了一些书籍和文章).最近在论坛上看到有不少人在问关于API Hook的问题,便写成此文,希望能对朋友们在写API Hook代码的时候能够有所帮助. 1 基本原理 API Hook是什么我就不多说了,直接进入正题.API Hook技术主要有下面的技术难点: 如何将自己的的代码In

API Hook基本原理和实现

2009-03-14 20:09 windows系统下的编程,消息message的传递是贯穿其始终的.这个消息我们可以简单理解为一个有特定意义的整数,正如我们看过的老故事片中的“ 长江长江,我是黄河”一个含义.windows中定义的消息给初学者的印象似乎是“不计其数”的,常见的一部分消息在winuser.h头文件中定义. hook与消息有着非常密切的联系,它的中文含义是“钩子”,这样理解起来我们不难得出“hook是消息处理中的一个环节,用于监控消息在系统中的传递,并在这些消息到达最终的消息处理过

Windows API Hook

原文地址:http://blog.sina.com.cn/s/blog_628821950100xmuc.html 原文对我的帮助极大,正是因为看了原文,我才学会了HOOK,鉴于原文的排版不是很好, 又没有原工程例子源码下载,因此我决定对其重新整理,文章后面附有我测试时的工程源码下载地址. 注:我测试的环境为Win7+VS2008+MFC 原文出处,好像是这篇:http://blog.csdn.net/glliuxueke/article/details/2702608      //后来才看到

HOOK技术2_Detour+API拦截技术

最近公司做一个远程桌面控制的软件,其中用到了API hook的技术,由于之前没有接触过此类技术,刚刚开始的时候就想按照<Windows核心编程>中介绍的修改IAT表的方法实现API hook,但是项目中的一个工程中需要创建第三方的工具的进程,此种方法可以注入现有的工程,但是第三方工具我没有源代码,由于时间仓促对此种方法的hook理解不深,发现此种方法不能够实现注入CreateProccess启动的进程,有天下班和同事吃饭,给他说起这方面的问题,他正好以前做过此类的项目,他给我推荐了微软的det

逆向实用干货分享,Hook技术第一讲,之Hook Windows API

逆向实用干货分享,Hook技术第一讲,之Hook Windows API 作者:IBinary出处:http://www.cnblogs.com/iBinary/版权所有,欢迎保留原文链接进行转载:) 一丶什么是Hook,以及Hook能干啥 首先这一个小标题主要介绍神马是Hook,如果知道的,则不用看了. 这里我偷袭啊懒,贴出Hook的意思  https://baike.baidu.com/item/%E9%92%A9%E5%AD%90%E7%A8%8B%E5%BA%8F Hook,英文单词中成