← 返回列表

Windows 反调试检测实验:观察隐藏插件留下的痕迹

单站 bbs.kanxue.com 作者 XiunoBBS 4.0 入库 2026-11-18T09:17:31

这是我写的一个 Windows x86/x64 反调试检测测试项目。文中记录检测思路、伪代码和两组实测,重点是观察隐藏插件是否改动了进程状态或查询结果。

最初我用 IsDebuggerPresent、CheckRemoteDebuggerPresent 和 NtQueryInformationProcess 查询调试状态。启用隐藏插件后,这些常规检查在我的测试中都返回了正常结果。

我随后把观察重点放到插件的改动上:预先写入的标志是否被清除,函数入口是否改变,查询结果之间是否出现矛盾。下文的伪代码摘自工程,省去了界面和日志部分。

先讲最基础的一个。IsDebuggerPresent 这个 API 其实特别简单,它读的是 PEB(进程环境块)里的一个字节,叫 BeingDebugged。x86 下 PEB 的地址从 fs 段的 0x30 处取,x64 下从 gs 段的 0x60 处取,BeingDebugged 就在 PEB 开头往里 2 字节的位置。进程被调试时内核把这个字节设成 1,函数看到非零就返回真。

常规检测就是"读到 1 说明有调试器"。陷阱的思路反过来:

我在程序启动的时候,自己把这个字节写成 1,当成诱饵埋在那儿。没有调试器的时候,没人会碰它,过一阵读回来还是 1,说明环境干净。如果进程真的被调试,插件为了过掉 IsDebuggerPresent,通常第一件事就是把这个字节清成 0,于是我再读就变成 0 了。

在写入诱饵后,读到 1 表示这个字段仍保留预设值,读到 0 表示这个字段发生了变化。

这里有个特别容易翻车的点,叫"先查后植"。每一轮必须先读当前值做判断,判断完了再把诱饵重新写成 1,为下一轮埋好。顺序反了——先写 1 再读——那你永远读到自己刚写进去的 1,什么也抓不到。

伪代码:

BYTE* BdAddress() {
    #ifdef _WIN64
        return (BYTE*)__readgsqword(0x60) + 2; 
    #else
        return (BYTE*)__readfsdword(0x30) + 2;
    #endif
}
g_bdOriginal = *BdAddress();
if (g_bdOriginal == 0) {
    *BdAddress() = 1; 
    g_bdPlanted = true;
}
BYTE* bd = BdAddress();
BYTE before = *bd; 
BOOL api = IsDebuggerPresent();
BYTE after = *bd;
bool cleared = (before == 0); 
bool hooked = (before == 1 && api == 0); 
bool hit = cleared || hooked;
*bd = 1; 

注意这里除了"诱饵被清",还顺手抓了另一种情况:PEB 字节明明还是 1,API 却返回 0。这说明插件没动 PEB,而是把 IsDebuggerPresent 本身 hook 成了固定返回 0。两个信号对不上,同样暴露问题。

这个检查依赖字段被清除,或字段与 API 返回值出现矛盾。如果插件同时避开了这两个条件,这一项就可能漏报。第七节还会说明函数入口检查如何参与最终判定。

NtGlobalFlag 是 PEB 里另一个字段,x86 偏移 0x68,x64 偏移 0xBC。它里面有三个跟堆检查有关的位:0x10、0x20、0x40,合起来是 0x70。进程如果是在调试器下启动的,内核会把这几个位置起来。常规检测就是看 (flag & 0x70) 是不是非零。

既然这个字段也在 PEB 里、用户态能直接写,那金丝雀那一套照搬就行:启动时不管原来是多少,先或上 0x70 把诱饵埋进去,后面读回来看这三位还在不在。被清成 0 就说明有插件在抹痕迹。

伪代码:

DWORD* GfAddress() {
    #ifdef _WIN64
        return (DWORD*)((BYTE*)__readgsqword(0x60) + 0xBC);
    #else
        return (DWORD*)((BYTE*)__readfsdword(0x30) + 0x68);
    #endif
}
g_gfOriginal = *GfAddress();
*GfAddress() = g_gfOriginal | 0x70;
DWORD* gf = GfAddress();
DWORD before = *gf & 0x70; 
bool hit = (before == 0); 
*gf |= 0x70; 

这个比 BeingDebugged 那个麻烦一点:这三个位会真的打开堆的额外检查,程序会变慢,理论上还可能影响逻辑。所以诱饵的植入窗口要尽量短,不用的时候该恢复就恢复。另外它和前面那个共享同一个软肋——只对"会清这个字段的插件"有效,对方只 hook 函数不碰内存,一样漏报。还有个老毛病:用 gflags 或者应用程序验证器开了堆检查的机器,这三个位本来就是亮的,会误报。

前面两招都是"埋诱饵等人来清"。但如果插件不改数据,只是把函数 hook 掉呢?这一节就是对付这个的。

inline hook 的手法说白了就是改函数开头几个字节,改成一条跳转指令,让调用流拐到插件自己的函数里去。常见的跳转指令特征就那么几种:E9、EB 这种相对跳转,FF 25 这种间接跳转,68 xx xx xx xx C3 这种压栈再返回,x64 下还有 48 B8 或 48 A1 打头后接 FF E0/FF 20 的形式。

那我的思路是:启动时先从磁盘上的 ntdll.dll、kernel32.dll 里把目标函数的前 16 字节读出来存一份"原版基线",运行时拿内存里函数头跟这些跳转特征比对。

这里有个坑,我踩得很结实:千万不能用"内存字节和磁盘字节逐个比"。函数开头的 16 字节里可能含重定位过的地址,磁盘上的值和加载进内存后的值本来就不一样,全字节比较会把一堆正常函数误判成被改。

后来改成只看"指令特征"——判断函数头是不是以某种跳转指令开头。而且要两边都看:内存里出现了跳转特征,磁盘原版却没有,这才算真的被 inline hook。要是磁盘原版本身就是跳转(比如某些转发函数),那不算。

伪代码:

bool LooksHooked(BYTE* p) {
    if (p[0] == 0xE9 || p[0] == 0xEB || p[0] == 0x68) return true;
    if (p[0] == 0xFF && p[1] == 0x25) return true; 
    #ifdef _WIN64
    if (p[0] == 0x48 && (p[1] == 0xB8 || p[1] == 0xA1)) return true;
    #endif
    return false;
}
int CheckPrologue(基线 ref) {
    HMODULE mod = GetModuleHandle(ref.module);
    if (!mod || !ref.ok) return 2; 
    BYTE* mem = (BYTE*)GetProcAddress(mod, ref.func);
    if (!mem) return 2;
    bool memHook = LooksHooked(mem); 
    bool diskHook = LooksHooked(ref.bytes); 
    return (memHook && !diskHook) ? 1 : 0; 
}

基线是启动时从磁盘文件里读的:先用 GetSystemDirectory 拼出系统 DLL 的完整路径,把整个文件读进内存,再顺着 PE 的导出表找到目标函数名,算出它在文件里的偏移,把前 16 字节抠出来。这一段是纯粹的 PE 解析,RVA 转文件偏移、导出表三张表(名字、序号、地址)对号入座,没什么玄机,就不展开了。

前面两招能抓"改数据"和"改函数头"。但内核里的那些查询结果——调试端口、调试对象、调试标志——用户态根本改不了,诱饵没法埋在数据本身上。怎么办?

换个思路:既然没法埋在数据上,就埋在调用路径上。我自己造一个"答案确定"的场景,拿被怀疑的函数去查它,看它会不会答错。

具体做法是:用 DEBUG_PROCESS 标志启动一个子进程。这时候本进程就是它的调试器,这个子进程百分之百处于被调试状态,是个标准答案。然后我用本进程里的 NtQueryInformationProcess 去查这个子进程——调试端口应该非零,调试对象句柄应该非空。如果连这个确定的答案都报成"干净",那说明本进程里的这个函数已经被 hook 成固定返回安全值了。

这一招妙在它利用了钩子自身的逻辑:插件要骗本进程,就得改本进程的函数;函数一改,连这个已知答案的探针也一起被骗,矛盾立刻冒出来。

伪代码:

CreateProcess(自身路径 + " --callee",
              DEBUG_PROCESS | CREATE_NO_WINDOW, ...);
ULONG_PTR port = 0;
st = NtQueryInformationProcess(pi.hProcess, ProcessDebugPort, &port, ...);
g_calPort = (成功 && port != 0) ? 1 : 2; 
HANDLE hObj = NULL;
st = NtQueryInformationProcess(pi.hProcess, ProcessDebugObjectHandle, &hObj, ...);
g_calObj = (成功 && hObj != NULL) ? 1 : 2;
DebugActiveProcessStop(pi.dwProcessId); 
TerminateProcess(pi.hProcess, 0);

两个细节。一是被启动的子进程要走"--callee"分支保持存活(就是 Sleep 几秒再退出),不然父进程还没查完它就自己没了。二是查完必须 DebugActiveProcessStop 再结束它,否则调试关系没收干净。

局限也很实在:有些插件只对"查当前进程"做假,查别的进程时就放行——这种"按目标区分"的 hook,校准探针查不出来。而且创建子进程、建立调试会话有开销,不适合高频调用,所以我的工具只在手动点刷新时才校准,自动刷新时直接用上次的校准结果。

每轮检查先记录 PEB 诱饵是否被清除,后续判定会用到这个结果。

任一 PEB 诱饵被完全清零时,本轮把 wiped 记为真。

如果诱饵被清除,而查询仍报告非调试态,程序会记录这组矛盾。具体原因要结合实测环境判断。

伪代码:

DWORD gfNow = *GfAddress() & 0x70;
BYTE bdNow = *BdAddress();
bool wiped = (gfNow == 0 || bdNow == 0); 

注意这个 wiped 要在每一轮检测开始时先算,而且要在陷阱项重建诱饵之前算——不然诱饵刚被自己写回 1,就看不到被清的状态了。

陷阱一,IsDebuggerPresent。综合三个信号:PEB 字节被清(cleared)、PEB 是 1 但 API 报 0(hooked)、函数前导字节被改(pro==1)。三个任一成立就算命中。判完记得重建诱饵。如果前导字节基线本身取不到(pro==2)且没别的命中信号,这项标"不可用",不硬下结论。

陷阱二,CheckRemoteDebuggerPresent。先看 kernel32 里 CheckRemote 的函数头和 ntdll 里 NtQueryInformationProcess 的函数头有没有被改;再看校准结果 g_calPort 是不是 2(已知被调试的子进程却报无端口);最后看 wiped 这个前提:诱饵都被清了,端口查询还报"没调试器",那就是查询被伪造。三条任一命中。

伪代码(陷阱二的核心判定):

BOOL present = FALSE;
CheckRemoteDebuggerPresent(GetCurrentProcess(), &present);
int proK = CheckPrologue(CheckRemote 的基线);
int proN = CheckPrologue(NtQIP 的基线);
int hit = 0;
if (proK == 1 || proN == 1) hit = 1; 
else if (g_calPort == 2) hit = 1; 
else if (wiped && !present) hit = 1; 

陷阱三,ProcessDebugObjectHandle。看函数头有没有被改、校准 g_calObj 是不是 2、以及 wiped 前提下句柄是不是空。这里状态有三种:命中、正常、不可用(基线取不到且没校准成功)。拿到的调试对象句柄是内核给的,用完要 CloseHandle,不然每轮泄漏一个。

陷阱四,ProcessDebugFlags。看函数头有没有被改,以及 wiped 前提下标志位是不是报成了非调试态(flags != 0)。这个类别没正式文档,不同 Windows 版本细节可能有出入,所以我在目标系统上都实测过才定的判断条件。

陷阱五,NtGlobalFlag 金丝雀。最简单,读回 0x70 三位,被清就是命中,然后重建诱饵。

陷阱六,一致性交叉,单独放下一节讲。

这项检查比较两组观测:PEB 诱饵的读回状态,以及调试端口、调试对象和调试标志的查询结果。

当 wiped 为真时,如果三路查询中任意一路仍报告非调试态,程序就记录一次不一致。

伪代码:

bool canarySayDebug = wiped; 
bool portClean = !g_results[1].debugged; 
bool objectClean = !g_results[2].debugged; 
bool flagsClean = !g_results[3].debugged; 
bool inconsistent = canarySayDebug &&
                   (portClean || objectClean || flagsClean);

这一招的好处是:不需要猜插件具体 hook 了哪个函数。只要它的伪造不完整,矛盾会自己冒出来。当然,如果对方把所有信号统一改干净了,那就得回到前导字节校验和校准探针上,多路一起压。

这里顺便解释一个可能让人困惑的设计:我程序里其实还留着"常规五项"的计算——IsDebuggerPresent、CheckRemote、三个 NtQueryInformationProcess 查询,结果都存在 g_results 里,但界面上不显示、日志里不记录。原因是它们虽然单独用会被绕过(早就被插件抹成"正常"了),但一致性交叉需要拿它们当"查询报正常"这一路的证据。换句话说,常规项不是拿来直接下结论的,是拿来当矛盾比对的材料。

项目记录了开启隐藏插件后的两组测试。

下面是命中日志的格式示意,包含时间、检测项和命中依据。

21:03:17 [陷阱方案] IsDebuggerPresent 命中 查前0 API0 查后0 前导正常 -> 命中
21:03:17 [陷阱方案] NtGlobalFlag 命中 查前0x00 -> 诱饵被清
21:03:17 [陷阱方案] 一致性交叉信号 命中 擦除1 端口正常1 对象正常0 标志正常1 -> 信号矛盾

日志只在某个陷阱项状态从"未命中"变成"命中"时写一行,避免刷屏。x86 存 hit_x86.log,x64 存 hit_x64.log。

这两组结果只对应本次测试使用的环境和插件配置。

把这几个印象最深的坑记一下,省得后来人重复踩:

一,常规五项必须从界面和日志里删掉。它们被插件抹得太干净,显示出来全是"正常",反而误导。但内部计算要保留,一致性交叉要用。删显示、留计算,这是两个动作。

二,诱饵一定"先查后植"。前面说过,顺序反了就永远读自己写的值。

三,前导字节不能全字节比。磁盘和内存的函数头本来就可能因重定位不同,只认跳转指令特征,且要"内存有、磁盘无"才算。

四,句柄要关。调试对象句柄是内核资源,每轮不 CloseHandle 就泄漏。

五,校准子进程要活到查完。"--callee"分支里 Sleep 几秒,别让它自己先退了。

六,wiped 要在重建诱饵之前算。算晚了诱饵已经写回,看不到被清的状态。

七,"不可用"和"正常"要分开。基线取不到、函数地址拿不到的时候,标成"不可用"(状态 2),不要当成"没命中"——那是两回事,硬下结论会冤枉好人。

八,NtGlobalFlag 诱饵会开堆检查,程序变慢,植入窗口要短。

九,gflags 开的机器会误报,别把这一路当唯一证据。

说几句实话。这套东西提高的是攻击成本,不是绝对安全。金丝雀只对"改数据"的插件有效,前导字节校验只对 inline hook 有效,校准探针对"按目标区分"的 hook 没辙,一致性交叉怕对方把所有信号统一改干净。任何单一手段都有对应绕过,叠起来才有意义。

更关键的是,只要检查点会被找到,绕过就会尝试,本质还是"检测加拦截"的框架。我在设计文档里还推演过更进一步的方向,但当前这个程序没有实现,这里只提一句、不展开,免得误会成工具已经具备:影子模式(发现调试不退出,改喂假数据,让逆向者拿到错误结论)、门限投票(每个检查点只投票不做反应,敏感操作前才开箱计票,切断反馈回路)、运行时多态(检查代码运行时才生成、用完就擦,没有固定字节可 NOP)、外部信任根(把判定权交给独立进程,主进程内怎么 hook 都不影响外部裁判)。

回到这套已经落地的东西,它最值得说的其实不是某一招多强,而是那个思路的转变:不去读那个被人精心维护的"假答案",而是去观察对方为了制造假答案所必须产生的副作用。标志被清、函数头被改、信号自相矛盾——这些副作用不像单个值那样说清就清。把"问状态"和"抓动作"混着用,再用校准和交叉兜底,才是它比传统单点检测耐打的原因。

就写到这里,欢迎拍砖交流

[招生]科锐逆向工程师培训(2026年11月13日实地,远程教学同时开班, 第57期)

最后于 11小时前
被StarTrace编辑

    ,原因: 上传测试附件
原文链接:https://bbs.kanxue.com/thread-293582.htm