前言

这几天在跟朋友玩《异形:殖民军》这款游戏，这款游戏于2013年发售，制作完后制作组就跑路了。可以简单理解为这是一款太空版支持联机过剧情的使命召唤like游戏。我们两个下的都是FLT修改版本，本来想以前走hamachi局域网联机。

但是意外发生了，我们死活联机不上。提示找不到游戏。随后我们试了一下tun方案/对战平台方案，完全没办法联机。

可是我记得十年前玩的时候是可以正常联机的。问题出在哪？

联机流程

由于游戏早就死了，steam买不值得，我们用的是盗版，盗版走的是局域网联机方案，所谓局域网联机方案，一般指的是用hamachi或者对战平台或者各种联机工具 建立一个虚拟局域网，大家都有一样的虚拟局域网ip

这个虚拟机的网卡就是假的局域网，从而让大家走“局域网联机”

理论上我们应该连的上，所以对这个网卡进行抓包，发现完全没游戏的数据包进来（游戏数据包是UPD，这里只有ICMP,是测延迟用的）

传统游戏的局域网联机逻辑是，游戏对所有网卡的0.0.0.0 发一个UDP广播包，255.255.255.255 这个包会在整个局域网进行广播，然后如果有客户端就会 回包。
这个游戏确实监听了UDP端口，并且等待广播包

所以 问题很明显，游戏并没有对这个网卡发包。打开procmon，我们看看游戏发了什么包:

我们可以看到，这个是第一个问题，这个游戏广播的包是我的物理网卡地址，并不是TUN的卡的地址。那肯定是没有人回复的。
这个问题很好解决，根据我多年的零信任开发经验，游戏应该是通过一个叫做 越点 的机制去判断当前可用网卡的，我们只需要把虚拟网卡的越点设置为1就行

这样游戏就会优先考虑虚拟网卡的IP发包。但是依然连不上
再次抓包，发现：

解读一下，游戏的广播包服务端确实返回了回复了，我的客户端也即将链接，但是我的客户端莫名其妙的链到了25.16.24.136这个完全摸不着头脑的国外地址！ 按理说应该直接链接10.100.239.2这个我的朋友的虚拟网卡IP的

经过一段时间的摸索，我发现，这个25.16.245.136是我朋友的一个虚拟网卡的IP地址，说明： 游戏服务端收到信息了，但是回复的网卡IP错误！理论上，应该回复他的当前包过来的绑定的IP但是为什么会回复这个，不知道。

临时解决方法是，禁用这个虚拟网卡，祈祷游戏能找到真的地址
禁用虚拟网卡后，我们发现更完蛋了，游戏服务端返回的是电脑的物理网卡地址
 

这个是不可能通的，除非开零信任。零信任这个时候确实派上用场了。但是肯定不能为了一个游戏装这玩意。
因此有必要去代码层看看了

深入代码层

让我们直接逆向这个游戏，看看为什么会这样吧拖入IDA，对sento打断点，连接游戏看看：

构造255.255.255.255的包

发送:

可以看到，发送的socket是一个socket，而不是枚举网卡逐个发送

这就导致了第一个问题，广播包没广播对网卡

对于第二个问题，我们抓一个包看看：
游戏服务器会返回一个包里面带了游戏服务端的IP地址

这一段是服务端的IP地址：

这个IP地址很明显也是错误的
根据服务端代码，问题出在得到网卡地址的这里，服务端收到包是能知道哪个socket的，但是他的网络和引擎层不是一个socket，他的网络层是获取不到的，所以他就只能，取一个本机 IP 发出去….毕竟，2013年的时候哪有那么复杂的网卡局域网联机环境？

而这个IP就是纯随机的来源。

修复这个bug

我们有几个修复方案，比如改包把IP改成自己的，起一个假的转发代理服务器等。但是最直接的办法是hook，我跟朋友写了两个方案，我的方案是客户端的方案，朋友的是服务端方案

客户端方案：
通过hook sockets,进行改包,我用的是minihook:

#include "pch.h"
#include <cstdio>
#include <cstdarg>
#include <cstdint>
#include <cstring>
#include <vector>
#include <string>
#include "MinHook/include/MinHook.h"
namespace {
using sendto_t = int(WINAPI*)(SOCKET, const char*, int, int, const sockaddr*,
                              int);
using recvfrom_t = int(WINAPI*)(SOCKET, char*, int, int, sockaddr*, int*);
using bind_t = int(WINAPI*)(SOCKET, const sockaddr*, int);
using getsockname_t = int(WINAPI*)(SOCKET, sockaddr*, int*);
using gethostname_t = int(WINAPI*)(char*, int);
using gethostbyname_t = hostent*(WINAPI*)(const char*);
sendto_t RealSendTo = nullptr;
recvfrom_t RealRecvFrom = nullptr;
bind_t RealBind = nullptr;
getsockname_t RealGetSockName = nullptr;
gethostname_t RealGetHostName = nullptr;
gethostbyname_t RealGetHostByName = nullptr;
HMODULE g_Module = nullptr;
HANDLE g_WorkerThread = nullptr;
volatile bool g_Running = true;
bool g_LogPackets = true;
bool g_FixPayload = false;
uint32_t g_ForcedIp = 0;
std::vector<uint32_t> g_LocalIps;
CRITICAL_SECTION g_LogLock;
uint32_t ReadBe32(const char* p) {
    return (uint32_t(uint8_t(p[0])) << 24) | (uint32_t(uint8_t(p[1])) << 16) |
           (uint32_t(uint8_t(p[2])) << 8) | uint32_t(uint8_t(p[3]));
}
void WriteBe32(char* p, uint32_t ip) {
    p[0] = char((ip >> 24) & 0xff);
    p[1] = char((ip >> 16) & 0xff);
    p[2] = char((ip >> 8) & 0xff);
    p[3] = char(ip & 0xff);
}
std::string IpToString(uint32_t ip) {
    char buf[32];
    std::snprintf(buf, sizeof(buf), "%u.%u.%u.%u", (ip >> 24) & 0xff,
                  (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
    return buf;
}
uint32_t SockAddrIp(const sockaddr* addr) {
    if (!addr || addr->sa_family != AF_INET) {
        return 0;
    }
    const sockaddr_in* in = reinterpret_cast<const sockaddr_in*>(addr);
    return ntohl(in->sin_addr.s_addr);
}
uint16_t SockAddrPort(const sockaddr* addr) {
    if (!addr || addr->sa_family != AF_INET) {
        return 0;
    }
    const sockaddr_in* in = reinterpret_cast<const sockaddr_in*>(addr);
    return ntohs(in->sin_port);
}
void Log(const char* fmt, ...) {
    EnterCriticalSection(&g_LogLock);
    va_list args;
    va_start(args, fmt);
    std::vprintf(fmt, args);
    va_end(args);
    std::printf("\n");
    std::fflush(stdout);
    LeaveCriticalSection(&g_LogLock);
}
bool IsInterestingPacket(const char* buf, int len) {
    if (!buf || len <= 0) {
        return false;
    }
    if (len >= 2 && buf[0] == 'U' &&
        (buf[1] == 'D' || buf[1] == 'C' || buf[1] == 'F')) {
        return true;
    }
    if (len >= 2 && buf[0] == 'N' && buf[1] == 'F') {
        return true;
    }
    if (len > 200) {
        return true;
    }
    return false;
}
bool LooksLikeUsefulIp(uint32_t ip) {
    const uint8_t a = uint8_t((ip >> 24) & 0xff);
    const uint8_t b = uint8_t((ip >> 16) & 0xff);
    if (ip == 0 || ip == 0xffffffff || a == 0 || a == 127 || a >= 224) {
        return false;
    }
    if (a == 10 || a == 25 || (a == 172 && b >= 16 && b <= 31) ||
        (a == 192 && b == 168)) {
        return true;
    }
    return false;
}
void ScanPayloadIps(const char* tag, const char* buf, int len) {
    if (!buf || len < 4) {
        return;
    }
    int shown = 0;
    for (int i = 0; i <= len - 4; ++i) {
        const uint32_t be = ReadBe32(buf + i);
        if (LooksLikeUsefulIp(be)) {
            if (shown == 0) {
                std::printf("%s candidate IPs:", tag);
            }
            std::printf(" +0x%X=%s", i, IpToString(be).c_str());
            ++shown;
            if (shown >= 12) {
                std::printf(" ...");
                break;
            }
        }
    }
    if (shown > 0) {
        std::printf("\n");
    }
}
void DumpPacketPrefix(const char* tag, const char* buf, int len) {
    if (!buf || len <= 0) {
        return;
    }
    const int count = len < 64 ? len : 64;
    std::printf("%s first %d:", tag, count);
    for (int i = 0; i < count; ++i) {
        std::printf(" %02X", uint8_t(buf[i]));
    }
    std::printf("\n");
}
void AddLocalIp(uint32_t ip) {
    if (ip == 0 || ip == 0x7f000001) {
        return;
    }
    for (uint32_t existing : g_LocalIps) {
        if (existing == ip) {
            return;
        }
    }
    g_LocalIps.push_back(ip);
}
void RefreshLocalIps() {
    g_LocalIps.clear();
    HMODULE wsock32 = GetModuleHandleW(L"WSOCK32.dll");
    if (!wsock32) {
        wsock32 = LoadLibraryW(L"WSOCK32.dll");
    }
    auto realGetHostName =
        reinterpret_cast<gethostname_t>(GetProcAddress(wsock32, "gethostname"));
    auto realGetHostByName = reinterpret_cast<gethostbyname_t>(
        GetProcAddress(wsock32, "gethostbyname"));
    char name[256] = {};
    if (realGetHostName && realGetHostByName &&
        realGetHostName(name, sizeof(name)) == 0) {
        hostent* host = realGetHostByName(name);
        if (host && host->h_addrtype == AF_INET) {
            for (char** addr = host->h_addr_list; addr && *addr; ++addr) {
                AddLocalIp(ntohl(*reinterpret_cast<uint32_t*>(*addr)));
            }
        }
    }
}
int ReplaceIpsInPayload(char* buf, int len, uint32_t replacement) {
    if (!buf || len < 4 || replacement == 0) {
        return 0;
    }
    int replaced = 0;
    for (int i = 0; i <= len - 4; ++i) {
        const uint32_t value = ReadBe32(buf + i);
        for (uint32_t localIp : g_LocalIps) {
            if (value == localIp && value != replacement) {
                WriteBe32(buf + i, replacement);
                ++replaced;
            }
        }
    }
    return replaced;
}
int WINAPI HookSendTo(SOCKET s, const char* buf, int len, int flags,
                      const sockaddr* to, int tolen) {
    const uint32_t toIp = SockAddrIp(to);
    const uint16_t toPort = SockAddrPort(to);
    if (g_LogPackets && IsInterestingPacket(buf, len)) {
        Log("sendto s=%p to=%s:%u len=%d", reinterpret_cast<void*>(s),
            IpToString(toIp).c_str(), toPort, len);
        DumpPacketPrefix("  send", buf, len);
        ScanPayloadIps("  send", buf, len);
    }
    if (g_FixPayload && g_ForcedIp && buf && len > 0) {
        std::vector<char> copy(buf, buf + len);
        const int changed = ReplaceIpsInPayload(copy.data(), len, g_ForcedIp);
        if (changed > 0) {
            Log("sendto fixed %d payload IP(s) -> %s", changed,
                IpToString(g_ForcedIp).c_str());
            return RealSendTo(s, copy.data(), len, flags, to, tolen);
        }
    }
    return RealSendTo(s, buf, len, flags, to, tolen);
}
int WINAPI HookRecvFrom(SOCKET s, char* buf, int len, int flags, sockaddr* from,
                        int* fromlen) {
    const int ret = RealRecvFrom(s, buf, len, flags, from, fromlen);
    if (ret <= 0) {
        return ret;
    }
    const uint32_t fromIp = SockAddrIp(from);
    const uint16_t fromPort = SockAddrPort(from);
    if (g_FixPayload && fromIp) {
        const int changed = ReplaceIpsInPayload(buf, ret, fromIp);
        if (changed > 0) {
            Log("recvfrom fixed %d payload IP(s) -> packet source %s", changed,
                IpToString(fromIp).c_str());
        }
    }
    if (g_LogPackets && IsInterestingPacket(buf, ret)) {
        Log("recvfrom s=%p from=%s:%u len=%d", reinterpret_cast<void*>(s),
            IpToString(fromIp).c_str(), fromPort, ret);
        DumpPacketPrefix("  recv", buf, ret);
        ScanPayloadIps("  recv", buf, ret);
    }
    return ret;
}
int WINAPI HookBind(SOCKET s, const sockaddr* name, int namelen) {
    const uint32_t ip = SockAddrIp(name);
    AddLocalIp(ip);
    Log("bind s=%p local=%s:%u", reinterpret_cast<void*>(s),
        IpToString(ip).c_str(), SockAddrPort(name));
    return RealBind(s, name, namelen);
}
int WINAPI HookGetSockName(SOCKET s, sockaddr* name, int* namelen) {
    const int ret = RealGetSockName(s, name, namelen);
    if (ret == 0) {
        const uint32_t ip = SockAddrIp(name);
        AddLocalIp(ip);
        Log("getsockname s=%p local=%s:%u", reinterpret_cast<void*>(s),
            IpToString(ip).c_str(), SockAddrPort(name));
    }
    return ret;
}
int WINAPI HookGetHostName(char* name, int namelen) {
    const int ret = RealGetHostName(name, namelen);
    if (ret == 0) {
        Log("gethostname -> %s", name);
    }
    return ret;
}
hostent* WINAPI HookGetHostByName(const char* name) {
    hostent* ret = RealGetHostByName(name);
    if (ret) {
        std::printf("gethostbyname %s ->", name ? name : "<null>");
        if (ret->h_addrtype == AF_INET) {
            for (char** addr = ret->h_addr_list; addr && *addr; ++addr) {
                const uint32_t ip = ntohl(*reinterpret_cast<uint32_t*>(*addr));
                AddLocalIp(ip);
                std::printf(" %s", IpToString(ip).c_str());
            }
        }
        std::printf("\n");
    }
    return ret;
}
bool HookExport(HMODULE module, const char* name, void* hook, void** original) {
    void* target = reinterpret_cast<void*>(GetProcAddress(module, name));
    if (!target) {
        Log("missing export: %s", name);
        return false;
    }
    MH_STATUS status = MH_CreateHook(target, hook, original);
    if (status != MH_OK && status != MH_ERROR_ALREADY_CREATED) {
        Log("MH_CreateHook(%s) failed: %d", name, status);
        return false;
    }
    status = MH_EnableHook(target);
    if (status != MH_OK && status != MH_ERROR_ENABLED) {
        Log("MH_EnableHook(%s) failed: %d", name, status);
        return false;
    }
    Log("hooked %s at %p", name, target);
    return true;
}
uint32_t ParseIp(const char* text) {
    unsigned int a = 0, b = 0, c = 0, d = 0;
    if (sscanf_s(text, "%u.%u.%u.%u", &a, &b, &c, &d) != 4) {
        return 0;
    }
    if (a > 255 || b > 255 || c > 255 || d > 255) {
        return 0;
    }
    return (a << 24) | (b << 16) | (c << 8) | d;
}
void PrintHelp() {
    Log("commands:");
    Log("  help             show commands");
    Log("  log on|off       enable or disable packet logs");
    Log("  fix on|off       replace payload local IPs, default off");
    Log("  ip a.b.c.d       force replacement IP for outgoing sendto");
    Log("  local a.b.c.d    add an IP that should be replaced");
    Log("  ips              show local IPs detected by gethostbyname");
    Log("  refresh          refresh local IP list");
    Log("  quit             unhook and unload DLL");
}
void CommandLoop() {
    PrintHelp();
    char line[256] = {};
    while (g_Running && std::fgets(line, sizeof(line), stdin)) {
        line[strcspn(line, "\r\n")] = 0;
        if (_stricmp(line, "help") == 0) {
            PrintHelp();
        } else if (_stricmp(line, "log on") == 0) {
            g_LogPackets = true;
            Log("log on");
        } else if (_stricmp(line, "log off") == 0) {
            g_LogPackets = false;
            Log("log off");
        } else if (_stricmp(line, "fix on") == 0) {
            g_FixPayload = true;
            Log("fix on");
        } else if (_stricmp(line, "fix off") == 0) {
            g_FixPayload = false;
            Log("fix off");
        } else if (_strnicmp(line, "ip ", 3) == 0) {
            const uint32_t ip = ParseIp(line + 3);
            if (ip) {
                g_ForcedIp = ip;
                Log("forced IP = %s", IpToString(g_ForcedIp).c_str());
            } else {
                Log("bad ip");
            }
        } else if (_strnicmp(line, "local ", 6) == 0) {
            const uint32_t ip = ParseIp(line + 6);
            if (ip) {
                AddLocalIp(ip);
                Log("added local/replace source IP = %s",
                    IpToString(ip).c_str());
            } else {
                Log("bad ip");
            }
        } else if (_stricmp(line, "ips") == 0) {
            for (uint32_t ip : g_LocalIps) {
                Log("local %s", IpToString(ip).c_str());
            }
        } else if (_stricmp(line, "refresh") == 0) {
            RefreshLocalIps();
            Log("refreshed %u local IP(s)", unsigned(g_LocalIps.size()));
        } else if (_stricmp(line, "quit") == 0) {
            g_Running = false;
            break;
        } else if (line[0]) {
            Log("unknown command: %s", line);
        }
    }
}
DWORD WINAPI WorkerThread(LPVOID) {
    AllocConsole();
    FILE* file = nullptr;
    freopen_s(&file, "CONOUT$", "w", stdout);
    freopen_s(&file, "CONOUT$", "w", stderr);
    freopen_s(&file, "CONIN$", "r", stdin);
    SetConsoleTitleW(L"ACM LAN hook");
    Log("ACM LAN hook loaded");
    RefreshLocalIps();
    Log("local IP count: %u", unsigned(g_LocalIps.size()));
    for (uint32_t ip : g_LocalIps) {
        Log("local %s", IpToString(ip).c_str());
    }
    HMODULE wsock32 = GetModuleHandleW(L"WSOCK32.dll");
    if (!wsock32) {
        wsock32 = LoadLibraryW(L"WSOCK32.dll");
    }
    if (!wsock32) {
        Log("failed to load WSOCK32.dll");
        CommandLoop();
    } else if (MH_Initialize() == MH_OK) {
        HookExport(wsock32, "sendto", HookSendTo,
                   reinterpret_cast<void**>(&RealSendTo));
        HookExport(wsock32, "recvfrom", HookRecvFrom,
                   reinterpret_cast<void**>(&RealRecvFrom));
        HookExport(wsock32, "bind", HookBind,
                   reinterpret_cast<void**>(&RealBind));
        HookExport(wsock32, "getsockname", HookGetSockName,
                   reinterpret_cast<void**>(&RealGetSockName));
        HookExport(wsock32, "gethostname", HookGetHostName,
                   reinterpret_cast<void**>(&RealGetHostName));
        HookExport(wsock32, "gethostbyname", HookGetHostByName,
                   reinterpret_cast<void**>(&RealGetHostByName));
        CommandLoop();
        MH_DisableHook(MH_ALL_HOOKS);
        MH_Uninitialize();
    } else {
        Log("MH_Initialize failed");
        CommandLoop();
    }
    Log("unloading");
    FreeConsole();
    FreeLibraryAndExitThread(g_Module, 0);
    return 0;
}
}  // namespace
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call,
                      LPVOID lpReserved) {
    switch (ul_reason_for_call) {
        case DLL_PROCESS_ATTACH:
            g_Module = hModule;
            DisableThreadLibraryCalls(hModule);
            InitializeCriticalSection(&g_LogLock);
            g_WorkerThread =
                CreateThread(nullptr, 0, WorkerThread, nullptr, 0, nullptr);
            break;
        case DLL_THREAD_ATTACH:
        case DLL_THREAD_DETACH:
            break;
        case DLL_PROCESS_DETACH:
            if (lpReserved == nullptr) {
                g_Running = false;
            }
            DeleteCriticalSection(&g_LogLock);
            break;
    }
    return TRUE;
}

关键点在这，把朋友广播过来的错误包改成正确的IP包

    if (g_FixPayload && g_ForcedIp && buf && len > 0) {
        std::vector<char> copy(buf, buf + len);
        const int changed = ReplaceIpsInPayload(copy.data(), len, g_ForcedIp);
        if (changed > 0) {
            Log("sendto fixed %d payload IP(s) -> %s", changed,
                IpToString(g_ForcedIp).c_str());
            return RealSendTo(s, copy.data(), len, flags, to, tolen);
        }
    }

朋友的服务端的代码更粗暴，直接白加黑劫持游戏，把他的gethostbyname给hook了，从而发真的包给我

//
// created by AheadLib
// github:https://github.com/strivexjun/AheadLib-x86-x64
//
#include <windows.h>
#include <Shlwapi.h>
#pragma comment( lib, "Shlwapi.lib")
#pragma comment(linker, "/EXPORT:accept=_AheadLib_accept,@1")
#pragma comment(linker, "/EXPORT:bind=_AheadLib_bind,@2")
#pragma comment(linker, "/EXPORT:closesocket=_AheadLib_closesocket,@3")
#pragma comment(linker, "/EXPORT:connect=_AheadLib_connect,@4")
#pragma comment(linker, "/EXPORT:getpeername=_AheadLib_getpeername,@5")
#pragma comment(linker, "/EXPORT:getsockname=_AheadLib_getsockname,@6")
#pragma comment(linker, "/EXPORT:getsockopt=_AheadLib_getsockopt,@7")
#pragma comment(linker, "/EXPORT:htonl=_AheadLib_htonl,@8")
#pragma comment(linker, "/EXPORT:htons=_AheadLib_htons,@9")
#pragma comment(linker, "/EXPORT:inet_addr=_AheadLib_inet_addr,@10")
#pragma comment(linker, "/EXPORT:inet_ntoa=_AheadLib_inet_ntoa,@11")
#pragma comment(linker, "/EXPORT:ioctlsocket=_AheadLib_ioctlsocket,@12")
#pragma comment(linker, "/EXPORT:listen=_AheadLib_listen,@13")
#pragma comment(linker, "/EXPORT:ntohl=_AheadLib_ntohl,@14")
#pragma comment(linker, "/EXPORT:ntohs=_AheadLib_ntohs,@15")
#pragma comment(linker, "/EXPORT:recv=_AheadLib_recv,@16")
#pragma comment(linker, "/EXPORT:recvfrom=_AheadLib_recvfrom,@17")
#pragma comment(linker, "/EXPORT:select=_AheadLib_select,@18")
#pragma comment(linker, "/EXPORT:send=_AheadLib_send,@19")
#pragma comment(linker, "/EXPORT:sendto=_AheadLib_sendto,@20")
#pragma comment(linker, "/EXPORT:setsockopt=_AheadLib_setsockopt,@21")
#pragma comment(linker, "/EXPORT:shutdown=_AheadLib_shutdown,@22")
#pragma comment(linker, "/EXPORT:socket=_AheadLib_socket,@23")
#pragma comment(linker, "/EXPORT:MigrateWinsockConfiguration=_AheadLib_MigrateWinsockConfiguration,@24")
#pragma comment(linker, "/EXPORT:gethostbyaddr=_AheadLib_gethostbyaddr,@51")
#pragma comment(linker, "/EXPORT:gethostbyname=_AheadLib_gethostbyname,@52")
#pragma comment(linker, "/EXPORT:getprotobyname=_AheadLib_getprotobyname,@53")
#pragma comment(linker, "/EXPORT:getprotobynumber=_AheadLib_getprotobynumber,@54")
#pragma comment(linker, "/EXPORT:getservbyname=_AheadLib_getservbyname,@55")
#pragma comment(linker, "/EXPORT:getservbyport=_AheadLib_getservbyport,@56")
#pragma comment(linker, "/EXPORT:gethostname=_AheadLib_gethostname,@57")
#pragma comment(linker, "/EXPORT:WSAAsyncSelect=_AheadLib_WSAAsyncSelect,@101")
#pragma comment(linker, "/EXPORT:WSAAsyncGetHostByAddr=_AheadLib_WSAAsyncGetHostByAddr,@102")
#pragma comment(linker, "/EXPORT:WSAAsyncGetHostByName=_AheadLib_WSAAsyncGetHostByName,@103")
#pragma comment(linker, "/EXPORT:WSAAsyncGetProtoByNumber=_AheadLib_WSAAsyncGetProtoByNumber,@104")
#pragma comment(linker, "/EXPORT:WSAAsyncGetProtoByName=_AheadLib_WSAAsyncGetProtoByName,@105")
#pragma comment(linker, "/EXPORT:WSAAsyncGetServByPort=_AheadLib_WSAAsyncGetServByPort,@106")
#pragma comment(linker, "/EXPORT:WSAAsyncGetServByName=_AheadLib_WSAAsyncGetServByName,@107")
#pragma comment(linker, "/EXPORT:WSACancelAsyncRequest=_AheadLib_WSACancelAsyncRequest,@108")
#pragma comment(linker, "/EXPORT:WSASetBlockingHook=_AheadLib_WSASetBlockingHook,@109")
#pragma comment(linker, "/EXPORT:WSAUnhookBlockingHook=_AheadLib_WSAUnhookBlockingHook,@110")
#pragma comment(linker, "/EXPORT:WSAGetLastError=_AheadLib_WSAGetLastError,@111")
#pragma comment(linker, "/EXPORT:WSASetLastError=_AheadLib_WSASetLastError,@112")
#pragma comment(linker, "/EXPORT:WSACancelBlockingCall=_AheadLib_WSACancelBlockingCall,@113")
#pragma comment(linker, "/EXPORT:WSAIsBlocking=_AheadLib_WSAIsBlocking,@114")
#pragma comment(linker, "/EXPORT:WSAStartup=_AheadLib_WSAStartup,@115")
#pragma comment(linker, "/EXPORT:WSACleanup=_AheadLib_WSACleanup,@116")
#pragma comment(linker, "/EXPORT:__WSAFDIsSet=_AheadLib___WSAFDIsSet,@151")
#pragma comment(linker, "/EXPORT:WEP=_AheadLib_WEP,@500")
#pragma comment(linker, "/EXPORT:WSApSetPostRoutine=_AheadLib_WSApSetPostRoutine,@1000")
#pragma comment(linker, "/EXPORT:inet_network=_AheadLib_inet_network,@1100")
#pragma comment(linker, "/EXPORT:getnetbyname=_AheadLib_getnetbyname,@1101")
#pragma comment(linker, "/EXPORT:rcmd=_AheadLib_rcmd,@1102")
#pragma comment(linker, "/EXPORT:rexec=_AheadLib_rexec,@1103")
#pragma comment(linker, "/EXPORT:rresvport=_AheadLib_rresvport,@1104")
#pragma comment(linker, "/EXPORT:sethostname=_AheadLib_sethostname,@1105")
#pragma comment(linker, "/EXPORT:dn_expand=_AheadLib_dn_expand,@1106")
#pragma comment(linker, "/EXPORT:WSARecvEx=_AheadLib_WSARecvEx,@1107")
#pragma comment(linker, "/EXPORT:s_perror=_AheadLib_s_perror,@1108")
#pragma comment(linker, "/EXPORT:GetAddressByNameA=_AheadLib_GetAddressByNameA,@1109")
#pragma comment(linker, "/EXPORT:GetAddressByNameW=_AheadLib_GetAddressByNameW,@1110")
#pragma comment(linker, "/EXPORT:EnumProtocolsA=_AheadLib_EnumProtocolsA,@1111")
#pragma comment(linker, "/EXPORT:EnumProtocolsW=_AheadLib_EnumProtocolsW,@1112")
#pragma comment(linker, "/EXPORT:GetTypeByNameA=_AheadLib_GetTypeByNameA,@1113")
#pragma comment(linker, "/EXPORT:GetTypeByNameW=_AheadLib_GetTypeByNameW,@1114")
#pragma comment(linker, "/EXPORT:GetNameByTypeA=_AheadLib_GetNameByTypeA,@1115")
#pragma comment(linker, "/EXPORT:GetNameByTypeW=_AheadLib_GetNameByTypeW,@1116")
#pragma comment(linker, "/EXPORT:SetServiceA=_AheadLib_SetServiceA,@1117")
#pragma comment(linker, "/EXPORT:SetServiceW=_AheadLib_SetServiceW,@1118")
#pragma comment(linker, "/EXPORT:GetServiceA=_AheadLib_GetServiceA,@1119")
#pragma comment(linker, "/EXPORT:GetServiceW=_AheadLib_GetServiceW,@1120")
#pragma comment(linker, "/EXPORT:NPLoadNameSpaces=_AheadLib_NPLoadNameSpaces,@1130")
#pragma comment(linker, "/EXPORT:TransmitFile=_AheadLib_TransmitFile,@1140")
#pragma comment(linker, "/EXPORT:AcceptEx=_AheadLib_AcceptEx,@1141")
#pragma comment(linker, "/EXPORT:GetAcceptExSockaddrs=_AheadLib_GetAcceptExSockaddrs,@1142")
#include <string>
// --- ??核心 ---
std::string GetTargetIPFromConfig() {
    char szPath[MAX_PATH];
    GetModuleFileNameA(NULL, szPath, MAX_PATH);
    // 配置路?：与 exe 同目?的 hostip.config
    std::string configPath = std::string(szPath).substr(0, std::string(szPath).find_last_of("\\/")) + "\\hostip.config";
    char szIP[64] = { 0 };
    GetPrivateProfileStringA("Network", "TargetIP", "", szIP, sizeof(szIP), configPath.c_str());
    return std::string(szIP);
}
extern PVOID pfnAheadLib_gethostbyname;
// 核心 Hook 函?，使用 __stdcall 保??平衡
extern "C" struct hostent* __stdcall My_gethostbyname_Hook(const char* name) {
    // ?制?型??，使用全局?量 pfnAheadLib_gethostbyname
    typedef struct hostent* (__stdcall *pfn_orig)(const char*);
    pfn_orig pOrig = (pfn_orig)pfnAheadLib_gethostbyname;
    struct hostent* pResult = pOrig(name);
    std::string targetIP = GetTargetIPFromConfig();
    if (!targetIP.empty()) {
        unsigned long ip = inet_addr(targetIP.c_str());
        if (ip != INADDR_NONE) {
            if (pResult && pResult->h_addrtype == AF_INET) {
                // 原始请求成功，直接修改其缓存的 IP
                *(unsigned long*)pResult->h_addr_list[0] = ip;
            } else {
                // 原始请求失败（如域名已失效），构造一个假的 hostent 结构体返回
                static struct hostent fake_hostent;
                static char* fake_aliases[] = { NULL };
                static unsigned long fake_ip;
                static char* fake_addr_list[] = { (char*)&fake_ip, NULL };
                static char fake_name[256];
                fake_ip = ip;
                if (name) {
                    strncpy(fake_name, name, sizeof(fake_name) - 1);
                    fake_name[sizeof(fake_name) - 1] = '\0';
                } else {
                    fake_name[0] = '\0';
                }
                fake_hostent.h_name = fake_name;
                fake_hostent.h_aliases = fake_aliases;
                fake_hostent.h_addrtype = AF_INET;
                fake_hostent.h_length = 4;
                fake_hostent.h_addr_list = fake_addr_list;
                pResult = &fake_hostent;
            }
        }
    }
    return pResult;
}
PVOID pfnAheadLib_accept;
PVOID pfnAheadLib_bind;
PVOID pfnAheadLib_closesocket;
PVOID pfnAheadLib_connect;
PVOID pfnAheadLib_getpeername;
PVOID pfnAheadLib_getsockname;
PVOID pfnAheadLib_getsockopt;
PVOID pfnAheadLib_htonl;
PVOID pfnAheadLib_htons;
PVOID pfnAheadLib_inet_addr;
PVOID pfnAheadLib_inet_ntoa;
PVOID pfnAheadLib_ioctlsocket;
PVOID pfnAheadLib_listen;
PVOID pfnAheadLib_ntohl;
PVOID pfnAheadLib_ntohs;
PVOID pfnAheadLib_recv;
PVOID pfnAheadLib_recvfrom;
PVOID pfnAheadLib_select;
PVOID pfnAheadLib_send;
PVOID pfnAheadLib_sendto;
PVOID pfnAheadLib_setsockopt;
PVOID pfnAheadLib_shutdown;
PVOID pfnAheadLib_socket;
PVOID pfnAheadLib_MigrateWinsockConfiguration;
PVOID pfnAheadLib_gethostbyaddr;
PVOID pfnAheadLib_gethostbyname;
PVOID pfnAheadLib_getprotobyname;
PVOID pfnAheadLib_getprotobynumber;
PVOID pfnAheadLib_getservbyname;
PVOID pfnAheadLib_getservbyport;
PVOID pfnAheadLib_gethostname;
PVOID pfnAheadLib_WSAAsyncSelect;
PVOID pfnAheadLib_WSAAsyncGetHostByAddr;
PVOID pfnAheadLib_WSAAsyncGetHostByName;
PVOID pfnAheadLib_WSAAsyncGetProtoByNumber;
PVOID pfnAheadLib_WSAAsyncGetProtoByName;
PVOID pfnAheadLib_WSAAsyncGetServByPort;
PVOID pfnAheadLib_WSAAsyncGetServByName;
PVOID pfnAheadLib_WSACancelAsyncRequest;
PVOID pfnAheadLib_WSASetBlockingHook;
PVOID pfnAheadLib_WSAUnhookBlockingHook;
PVOID pfnAheadLib_WSAGetLastError;
PVOID pfnAheadLib_WSASetLastError;
PVOID pfnAheadLib_WSACancelBlockingCall;
PVOID pfnAheadLib_WSAIsBlocking;
PVOID pfnAheadLib_WSAStartup;
PVOID pfnAheadLib_WSACleanup;
PVOID pfnAheadLib___WSAFDIsSet;
PVOID pfnAheadLib_WEP;
PVOID pfnAheadLib_WSApSetPostRoutine;
PVOID pfnAheadLib_inet_network;
PVOID pfnAheadLib_getnetbyname;
PVOID pfnAheadLib_rcmd;
PVOID pfnAheadLib_rexec;
PVOID pfnAheadLib_rresvport;
PVOID pfnAheadLib_sethostname;
PVOID pfnAheadLib_dn_expand;
PVOID pfnAheadLib_WSARecvEx;
PVOID pfnAheadLib_s_perror;
PVOID pfnAheadLib_GetAddressByNameA;
PVOID pfnAheadLib_GetAddressByNameW;
PVOID pfnAheadLib_EnumProtocolsA;
PVOID pfnAheadLib_EnumProtocolsW;
PVOID pfnAheadLib_GetTypeByNameA;
PVOID pfnAheadLib_GetTypeByNameW;
PVOID pfnAheadLib_GetNameByTypeA;
PVOID pfnAheadLib_GetNameByTypeW;
PVOID pfnAheadLib_SetServiceA;
PVOID pfnAheadLib_SetServiceW;
PVOID pfnAheadLib_GetServiceA;
PVOID pfnAheadLib_GetServiceW;
PVOID pfnAheadLib_NPLoadNameSpaces;
PVOID pfnAheadLib_TransmitFile;
PVOID pfnAheadLib_AcceptEx;
PVOID pfnAheadLib_GetAcceptExSockaddrs;
static
HMODULE g_OldModule = NULL;
VOID WINAPI Free()
{
    if (g_OldModule)
    {
        FreeLibrary(g_OldModule);
    }
}
BOOL WINAPI Load()
{
    TCHAR tzPath[MAX_PATH];
    TCHAR tzTemp[MAX_PATH * 2];
    //
    // ?里是否?系?目?或?前目?加?原始DLL
    //
    //GetModuleFileName(NULL,tzPath,MAX_PATH); //?取本目?下的
    //PathRemoveFileSpec(tzPath);
    GetSystemDirectory(tzPath, MAX_PATH); //默??取系?目?的
    lstrcat(tzPath, TEXT("\\wsock32.dll"));
    g_OldModule = LoadLibrary(tzPath);
    if (g_OldModule == NULL)
    {
        wsprintf(tzTemp, TEXT("?法找到模? %s,程序?法正常?行"), tzPath);
        MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
    }
    return (g_OldModule != NULL);
}
FARPROC WINAPI GetAddress(PCSTR pszProcName)
{
    FARPROC fpAddress;
    CHAR szProcName[64];
    TCHAR tzTemp[MAX_PATH];
    fpAddress = GetProcAddress(g_OldModule, pszProcName);
    if (fpAddress == NULL)
    {
        if (HIWORD(pszProcName) == 0)
        {
            wsprintfA(szProcName, "#%d", pszProcName);
            pszProcName = szProcName;
        }
        wsprintf(tzTemp, TEXT("?法找到函? %hs,程序?法正常?行"), pszProcName);
        MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
        ExitProcess(-2);
    }
    return fpAddress;
}
BOOL WINAPI Init()
{
    pfnAheadLib_accept = GetAddress("accept");
    pfnAheadLib_bind = GetAddress("bind");
    pfnAheadLib_closesocket = GetAddress("closesocket");
    pfnAheadLib_connect = GetAddress("connect");
    pfnAheadLib_getpeername = GetAddress("getpeername");
    pfnAheadLib_getsockname = GetAddress("getsockname");
    pfnAheadLib_getsockopt = GetAddress("getsockopt");
    pfnAheadLib_htonl = GetAddress("htonl");
    pfnAheadLib_htons = GetAddress("htons");
    pfnAheadLib_inet_addr = GetAddress("inet_addr");
    pfnAheadLib_inet_ntoa = GetAddress("inet_ntoa");
    pfnAheadLib_ioctlsocket = GetAddress("ioctlsocket");
    pfnAheadLib_listen = GetAddress("listen");
    pfnAheadLib_ntohl = GetAddress("ntohl");
    pfnAheadLib_ntohs = GetAddress("ntohs");
    pfnAheadLib_recv = GetAddress("recv");
    pfnAheadLib_recvfrom = GetAddress("recvfrom");
    pfnAheadLib_select = GetAddress("select");
    pfnAheadLib_send = GetAddress("send");
    pfnAheadLib_sendto = GetAddress("sendto");
    pfnAheadLib_setsockopt = GetAddress("setsockopt");
    pfnAheadLib_shutdown = GetAddress("shutdown");
    pfnAheadLib_socket = GetAddress("socket");
    pfnAheadLib_MigrateWinsockConfiguration = GetAddress("MigrateWinsockConfiguration");
    pfnAheadLib_gethostbyaddr = GetAddress("gethostbyaddr");
    pfnAheadLib_gethostbyname = GetAddress("gethostbyname");
    pfnAheadLib_getprotobyname = GetAddress("getprotobyname");
    pfnAheadLib_getprotobynumber = GetAddress("getprotobynumber");
    pfnAheadLib_getservbyname = GetAddress("getservbyname");
    pfnAheadLib_getservbyport = GetAddress("getservbyport");
    pfnAheadLib_gethostname = GetAddress("gethostname");
    pfnAheadLib_WSAAsyncSelect = GetAddress("WSAAsyncSelect");
    pfnAheadLib_WSAAsyncGetHostByAddr = GetAddress("WSAAsyncGetHostByAddr");
    pfnAheadLib_WSAAsyncGetHostByName = GetAddress("WSAAsyncGetHostByName");
    pfnAheadLib_WSAAsyncGetProtoByNumber = GetAddress("WSAAsyncGetProtoByNumber");
    pfnAheadLib_WSAAsyncGetProtoByName = GetAddress("WSAAsyncGetProtoByName");
    pfnAheadLib_WSAAsyncGetServByPort = GetAddress("WSAAsyncGetServByPort");
    pfnAheadLib_WSAAsyncGetServByName = GetAddress("WSAAsyncGetServByName");
    pfnAheadLib_WSACancelAsyncRequest = GetAddress("WSACancelAsyncRequest");
    pfnAheadLib_WSASetBlockingHook = GetAddress("WSASetBlockingHook");
    pfnAheadLib_WSAUnhookBlockingHook = GetAddress("WSAUnhookBlockingHook");
    pfnAheadLib_WSAGetLastError = GetAddress("WSAGetLastError");
    pfnAheadLib_WSASetLastError = GetAddress("WSASetLastError");
    pfnAheadLib_WSACancelBlockingCall = GetAddress("WSACancelBlockingCall");
    pfnAheadLib_WSAIsBlocking = GetAddress("WSAIsBlocking");
    pfnAheadLib_WSAStartup = GetAddress("WSAStartup");
    pfnAheadLib_WSACleanup = GetAddress("WSACleanup");
    pfnAheadLib___WSAFDIsSet = GetAddress("__WSAFDIsSet");
    pfnAheadLib_WEP = GetAddress("WEP");
    pfnAheadLib_WSApSetPostRoutine = GetAddress("WSApSetPostRoutine");
    pfnAheadLib_inet_network = GetAddress("inet_network");
    pfnAheadLib_getnetbyname = GetAddress("getnetbyname");
    pfnAheadLib_rcmd = GetAddress("rcmd");
    pfnAheadLib_rexec = GetAddress("rexec");
    pfnAheadLib_rresvport = GetAddress("rresvport");
    pfnAheadLib_sethostname = GetAddress("sethostname");
    pfnAheadLib_dn_expand = GetAddress("dn_expand");
    pfnAheadLib_WSARecvEx = GetAddress("WSARecvEx");
    pfnAheadLib_s_perror = GetAddress("s_perror");
    pfnAheadLib_GetAddressByNameA = GetAddress("GetAddressByNameA");
    pfnAheadLib_GetAddressByNameW = GetAddress("GetAddressByNameW");
    pfnAheadLib_EnumProtocolsA = GetAddress("EnumProtocolsA");
    pfnAheadLib_EnumProtocolsW = GetAddress("EnumProtocolsW");
    pfnAheadLib_GetTypeByNameA = GetAddress("GetTypeByNameA");
    pfnAheadLib_GetTypeByNameW = GetAddress("GetTypeByNameW");
    pfnAheadLib_GetNameByTypeA = GetAddress("GetNameByTypeA");
    pfnAheadLib_GetNameByTypeW = GetAddress("GetNameByTypeW");
    pfnAheadLib_SetServiceA = GetAddress("SetServiceA");
    pfnAheadLib_SetServiceW = GetAddress("SetServiceW");
    pfnAheadLib_GetServiceA = GetAddress("GetServiceA");
    pfnAheadLib_GetServiceW = GetAddress("GetServiceW");
    pfnAheadLib_NPLoadNameSpaces = GetAddress("NPLoadNameSpaces");
    pfnAheadLib_TransmitFile = GetAddress("TransmitFile");
    pfnAheadLib_AcceptEx = GetAddress("AcceptEx");
    pfnAheadLib_GetAcceptExSockaddrs = GetAddress("GetAcceptExSockaddrs");
    return TRUE;
}    
DWORD WINAPI ThreadProc(LPVOID lpThreadParameter)
{
    HANDLE hProcess;
    PVOID addr1 = reinterpret_cast<PVOID>(0x00401000);
    BYTE data1[] = { 0x90, 0x90, 0x90, 0x90 };
    //
    // ??VMP3.x 的?存保?
    //
    hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_READ | PROCESS_VM_WRITE, FALSE, GetCurrentProcessId());
    if (hProcess)
    {
        WriteProcessMemory(hProcess, addr1, data1, sizeof(data1), NULL);
        CloseHandle(hProcess);
    }
    return 0;
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
    if (dwReason == DLL_PROCESS_ATTACH)
    {
        DisableThreadLibraryCalls(hModule);
        if (Load() && Init())
        {
            TCHAR szAppName[MAX_PATH] = TEXT("MyApp.exe");//?修改宿主?程名
            TCHAR szCurName[MAX_PATH];
            GetModuleFileName(NULL, szCurName, MAX_PATH);
            PathStripPath(szCurName);
            //是否判?宿主?程名
            if (StrCmpI(szCurName, szAppName) == 0)
            {
                //???丁?程或者其他操作
                HANDLE hThread = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
                if (hThread)
                {
                    CloseHandle(hThread);
                }
            }
        }
    }
    else if (dwReason == DLL_PROCESS_DETACH)
    {
        Free();
    }
    return TRUE;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_accept(void)
{
    __asm jmp pfnAheadLib_accept;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_bind(void)
{
    __asm jmp pfnAheadLib_bind;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_closesocket(void)
{
    __asm jmp pfnAheadLib_closesocket;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_connect(void)
{
    __asm jmp pfnAheadLib_connect;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_getpeername(void)
{
    __asm jmp pfnAheadLib_getpeername;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_getsockname(void)
{
    __asm jmp pfnAheadLib_getsockname;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_getsockopt(void)
{
    __asm jmp pfnAheadLib_getsockopt;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_htonl(void)
{
    __asm jmp pfnAheadLib_htonl;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_htons(void)
{
    __asm jmp pfnAheadLib_htons;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_inet_addr(void)
{
    __asm jmp pfnAheadLib_inet_addr;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_inet_ntoa(void)
{
    __asm jmp pfnAheadLib_inet_ntoa;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_ioctlsocket(void)
{
    __asm jmp pfnAheadLib_ioctlsocket;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_listen(void)
{
    __asm jmp pfnAheadLib_listen;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_ntohl(void)
{
    __asm jmp pfnAheadLib_ntohl;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_ntohs(void)
{
    __asm jmp pfnAheadLib_ntohs;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_recv(void)
{
    __asm jmp pfnAheadLib_recv;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_recvfrom(void)
{
    __asm jmp pfnAheadLib_recvfrom;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_select(void)
{
    __asm jmp pfnAheadLib_select;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_send(void)
{
    __asm jmp pfnAheadLib_send;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_sendto(void)
{
    __asm jmp pfnAheadLib_sendto;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_setsockopt(void)
{
    __asm jmp pfnAheadLib_setsockopt;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_shutdown(void)
{
    __asm jmp pfnAheadLib_shutdown;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_socket(void)
{
    __asm jmp pfnAheadLib_socket;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_MigrateWinsockConfiguration(void)
{
    __asm jmp pfnAheadLib_MigrateWinsockConfiguration;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_gethostbyaddr(void)
{
    __asm jmp pfnAheadLib_gethostbyaddr;
}
/*
EXTERN_C __declspec(naked) void __cdecl AheadLib_gethostbyname(void)
{
    __asm jmp pfnAheadLib_gethostbyname;
}
*/
EXTERN_C __declspec(naked) void __cdecl AheadLib_getprotobyname(void)
{
    __asm jmp pfnAheadLib_getprotobyname;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_getprotobynumber(void)
{
    __asm jmp pfnAheadLib_getprotobynumber;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_getservbyname(void)
{
    __asm jmp pfnAheadLib_getservbyname;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_getservbyport(void)
{
    __asm jmp pfnAheadLib_getservbyport;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_gethostname(void)
{
    __asm jmp pfnAheadLib_gethostname;
}
// 修改原本的 naked ??
EXTERN_C __declspec(naked) void __cdecl AheadLib_gethostbyname(void)
{
    __asm {
        push [esp+4]    // ?入??
        call My_gethostbyname_Hook
        ret 4           // 恢复?平衡
    }
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAAsyncSelect(void)
{
    __asm jmp pfnAheadLib_WSAAsyncSelect;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAAsyncGetHostByAddr(void)
{
    __asm jmp pfnAheadLib_WSAAsyncGetHostByAddr;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAAsyncGetHostByName(void)
{
    __asm jmp pfnAheadLib_WSAAsyncGetHostByName;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAAsyncGetProtoByNumber(void)
{
    __asm jmp pfnAheadLib_WSAAsyncGetProtoByNumber;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAAsyncGetProtoByName(void)
{
    __asm jmp pfnAheadLib_WSAAsyncGetProtoByName;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAAsyncGetServByPort(void)
{
    __asm jmp pfnAheadLib_WSAAsyncGetServByPort;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAAsyncGetServByName(void)
{
    __asm jmp pfnAheadLib_WSAAsyncGetServByName;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSACancelAsyncRequest(void)
{
    __asm jmp pfnAheadLib_WSACancelAsyncRequest;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSASetBlockingHook(void)
{
    __asm jmp pfnAheadLib_WSASetBlockingHook;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAUnhookBlockingHook(void)
{
    __asm jmp pfnAheadLib_WSAUnhookBlockingHook;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAGetLastError(void)
{
    __asm jmp pfnAheadLib_WSAGetLastError;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSASetLastError(void)
{
    __asm jmp pfnAheadLib_WSASetLastError;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSACancelBlockingCall(void)
{
    __asm jmp pfnAheadLib_WSACancelBlockingCall;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAIsBlocking(void)
{
    __asm jmp pfnAheadLib_WSAIsBlocking;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSAStartup(void)
{
    __asm jmp pfnAheadLib_WSAStartup;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSACleanup(void)
{
    __asm jmp pfnAheadLib_WSACleanup;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib___WSAFDIsSet(void)
{
    __asm jmp pfnAheadLib___WSAFDIsSet;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WEP(void)
{
    __asm jmp pfnAheadLib_WEP;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSApSetPostRoutine(void)
{
    __asm jmp pfnAheadLib_WSApSetPostRoutine;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_inet_network(void)
{
    __asm jmp pfnAheadLib_inet_network;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_getnetbyname(void)
{
    __asm jmp pfnAheadLib_getnetbyname;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_rcmd(void)
{
    __asm jmp pfnAheadLib_rcmd;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_rexec(void)
{
    __asm jmp pfnAheadLib_rexec;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_rresvport(void)
{
    __asm jmp pfnAheadLib_rresvport;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_sethostname(void)
{
    __asm jmp pfnAheadLib_sethostname;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_dn_expand(void)
{
    __asm jmp pfnAheadLib_dn_expand;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_WSARecvEx(void)
{
    __asm jmp pfnAheadLib_WSARecvEx;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_s_perror(void)
{
    __asm jmp pfnAheadLib_s_perror;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetAddressByNameA(void)
{
    __asm jmp pfnAheadLib_GetAddressByNameA;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetAddressByNameW(void)
{
    __asm jmp pfnAheadLib_GetAddressByNameW;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_EnumProtocolsA(void)
{
    __asm jmp pfnAheadLib_EnumProtocolsA;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_EnumProtocolsW(void)
{
    __asm jmp pfnAheadLib_EnumProtocolsW;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetTypeByNameA(void)
{
    __asm jmp pfnAheadLib_GetTypeByNameA;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetTypeByNameW(void)
{
    __asm jmp pfnAheadLib_GetTypeByNameW;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetNameByTypeA(void)
{
    __asm jmp pfnAheadLib_GetNameByTypeA;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetNameByTypeW(void)
{
    __asm jmp pfnAheadLib_GetNameByTypeW;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_SetServiceA(void)
{
    __asm jmp pfnAheadLib_SetServiceA;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_SetServiceW(void)
{
    __asm jmp pfnAheadLib_SetServiceW;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetServiceA(void)
{
    __asm jmp pfnAheadLib_GetServiceA;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetServiceW(void)
{
    __asm jmp pfnAheadLib_GetServiceW;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_NPLoadNameSpaces(void)
{
    __asm jmp pfnAheadLib_NPLoadNameSpaces;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_TransmitFile(void)
{
    __asm jmp pfnAheadLib_TransmitFile;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_AcceptEx(void)
{
    __asm jmp pfnAheadLib_AcceptEx;
}
EXTERN_C __declspec(naked) void __cdecl AheadLib_GetAcceptExSockaddrs(void)
{
    __asm jmp pfnAheadLib_GetAcceptExSockaddrs;
}

关键点:

// 核心 Hook 函?，使用 __stdcall 保??平衡
extern "C" struct hostent* __stdcall My_gethostbyname_Hook(const char* name) {
    // ?制?型??，使用全局?量 pfnAheadLib_gethostbyname
    typedef struct hostent* (__stdcall *pfn_orig)(const char*);
    pfn_orig pOrig = (pfn_orig)pfnAheadLib_gethostbyname;
    struct hostent* pResult = pOrig(name);
    std::string targetIP = GetTargetIPFromConfig();
    if (!targetIP.empty()) {
        unsigned long ip = inet_addr(targetIP.c_str());
        if (ip != INADDR_NONE) {
            if (pResult && pResult->h_addrtype == AF_INET) {
                // 原始请求成功，直接修改其缓存的 IP
                *(unsigned long*)pResult->h_addr_list[0] = ip;
            } else {
                // 原始请求失败（如域名已失效），构造一个假的 hostent 结构体返回
                static struct hostent fake_hostent;
                static char* fake_aliases[] = { NULL };
                static unsigned long fake_ip;
                static char* fake_addr_list[] = { (char*)&fake_ip, NULL };
                static char fake_name[256];
                fake_ip = ip;
                if (name) {
                    strncpy(fake_name, name, sizeof(fake_name) - 1);
                    fake_name[sizeof(fake_name) - 1] = '\0';
                } else {
                    fake_name[0] = '\0';
                }
                fake_hostent.h_name = fake_name;
                fake_hostent.h_aliases = fake_aliases;
                fake_hostent.h_addrtype = AF_INET;
                fake_hostent.h_length = 4;
                fake_hostent.h_addr_list = fake_addr_list;
                pResult = &fake_hostent;
            }
        }
    }
    return pResult;
}

结论

通过这样修改后，我们终于可以愉快联机了

要是以后有人玩《Aliens: Colonial Marines》出现一样的问题，可以看看这个咋修。

跳转微信打开

前言

在2025年的时候，我发布了云端的病毒分析引擎demo:

基于大模型的病毒木马文件云鉴定

今年，我决定更进一步开发一下大模型在安全行业运用，于是在年初做了这个下一代杀毒引擎。在这里分享一下我的一些思路和见解。

如何定义下一代?

杀毒引擎本质上只做两件事，标记是恶意的木马同时不要误报。在经历特征码，广谱特征码，发展到所谓的AI杀毒，虚拟执行杀毒等。
而我们的”当前代”的问题是，他的误报越来越大，经过长时间的对抗，到演变成了所谓的非白即黑以及人工响应拉黑速度快慢去决定一个杀毒引擎的质量。并且本地病毒库越来越臃肿。并且对新型病毒无法防御。

而所谓下一代，每个人定义不一样，我的定义是指的是“能自我进化”(需要指出并不是传统native ml的那种拿什么PE区段与代码段比例，PE熵什么的玩意，而是指真正理解代码)，”廉价”，”对未知病毒查杀效果好，长时间不用更新病毒库也能查杀”，”廉价”

“大模型”推理的缺点

那你会觉得，那大模型做这个很合适，只需要我们云端接一个反编译引擎，然后把二进制代码吐给大模型就行了。对，但是也错。用大模型做推理会有几个严重的问题

性能损耗极大

杀毒厂商可能一天收获起码100w+的样本,廉价的沙箱都跑不过来,大模型推理的成本比沙箱贵了不止一个数量级,价格是工程化必须考虑的因素。一次反编译+推理的时间，一天开100台推理服务器可能都无法解决问题

模型随机性

由于模型并没有系统学习过恶意代码分析，他们会因为各种问题报恶意代码，比如给crt报恶意代码，并且模型受提示词影响极大。同样一份代码可能提示词不同模型出问题的概率也不同。

必须云端工作

由于大模型在云端才有可能部署，所以实时性不是特别好，也就是说新型样本到多久才检测是完全未知的。并且模型的推理延迟极高，可能几十分钟才能发现一个样本

下一代杀毒引擎

为了解决上面的问题从而实现工程真正可用落地。我们需要从客户端和模型入手。以下是我的思路

模型二开

LLM最大的问题，是他的输出，他是通过lm_head循环计算下一个token输出的，这个过程耗时极大，而且输入的不确定性让他会随机胡言乱语。因此我们要用到大模型的语言理解能力，但是不要他的文本输出。本质上他要做两个改法，一个是把lm_head去掉变成cls_head 也就是一个”Classification Head”这样他就会输出0-1之间的概率,1代表是病毒,0代表是正常文件(是不是很熟悉?)

把大模型改成 0/1 输出，在杀毒或安全过滤场景下比传统的“生成式回答”好太多了：

1. 速度极快，节省算力：大模型最耗时的地方在于自回归生成，即吐出 100 个字需要模型前向传播 100 次。而改成 0/1 输出属于单次前向传播，模型把整段代码吞进去，只计算一次就直接出结果了，速度提升几十甚至上百倍。

2. 绝对不会“胡说八道”：如果用原生的 lm_head 问模型：“这段代码是病毒吗？”，模型可能会长篇大论，甚至找借口，或者在概率临界点时给出含糊其辞的答案。改成 Bool 输出后，它没有任何组织语言的自由，只能铁面无私地给出一个概率值。

3. 解析极其简单：对于杀毒软件来说，处理一个 0 或 1 的布尔值，比用正则表达式去解析模型输出的自然语言段落要稳定得多。

具体做法是，我们先生成一些病毒/白文件的数据，包含他的伪码和对应的家族

伪码怎么来的看下文

然后去缝合模型,选一个你喜欢的模型都行,只需要理解代码就行，实测这块不需要很大的模型参数就能理解代码了。小一点的甚至是PC电脑的CPU都能带起来比如UniXcoder。当然模型大一点没坏处，越大效果越好

过小的模型会导致不理解世界事实从而误报，比如代码可能是mimikatz的代码，但是小模型不知道什么是mimikatz，就会判定为正常

然后就是正常训练，没什么。就做完了。
但是这套技术的重点并不在模型端，而是在客户端，因为我们最终的目的是要实现客户端可用的技术，做到实时查杀，实时防护。而且客户端提交的token是决定能不能杀出来的关键。

客户端反编译器

这玩意跟”传统”把样本塞到云端最大的不同是，我们要做客户端的推理。云端固然好，但是还是那句话，太贵了。实话说，这个推理模型就一个星期差不多搞完了，而客户端花了大概两年。他本质上是一个22M大小的IDA，不过反编译速度和效率比IDA快了不止一个数量级.

支持GO/RUST/c++/ARM/ARM64/DOTNET反编译,感谢AI,虽然到目前发帖为止,AI还是基本不咋懂这块咋写,但是只要提示词严格要求,AI就能做,相当于实习生一样:
他的效果看起来是这样的:

之前的反编译器编写流程:
IDA背后的原理入门(一): 简介&函数识别

从0制作IDA的F5代码还原功能(hex-rays插件) 上

工程上我发现，他的难点不在于如何复刻一个IDA，而是如何”找到”恶意代码并且最小的不占用带宽的上传，否则服务器都快被打死了。而且token和推理费用直接挂钩。
这里只说关键技术点。

找异常

跟IDA不同的是，我们无法做到把一个程序完整的反编译然后丢给大模型，因为成本和效率并不允许，所以我们需要找异常。而异常由规则驱动，只丢有问题的函数，这块我本来想做TF-IDF的，但是想了想没必要，之前我们做过：
2024年终: 木马病毒自动化特征提取&云端机器学习的思路分享

极致压缩&优化

这个是最麻烦的地方，我们需要给模型压缩后的片段，否则太长的代码对任何没好处，这里的优化指的并不是ssa那种不破坏语义的优化，指的是我们给破坏性代码，只给模型关键的。这里是最麻烦的部分，因为压多了模型识别不出来，压少了模型上下文直接爆了。
压少了:

正确的压缩:

这块就不展开细说了,坑非常多.

结论

简单测试一下效率和速度:

大概3.4秒不到分析出一个样本，还是因为测试时候用HTTP通讯的方式，换成内部通讯方式就正常了:

实测误报率也非常低，不过这里没不带水印的图.就不发了。
最重要的是，他是可以逐渐迭代的，大不了就做强化学习，跟微调大模型一样，每一天自动训练一次。自动发布。

这一套还有一个好处，是天然针对现在流行的恶意skills，恶意脚本，供应链尤其是JS/python等安全做防护检测，因为它本质上是输入文本，输入文本可比输入反汇编代码检出率好非常多。

跳转微信打开

前言

如果你看过《异形》系列电影以及玩过《异形》系列的游戏，你一定对里面的那个探测器不陌生-异形系列里面经常会出现一个道具，叫活动探测器，他的作用很简单，有异形活动的时候发出BBB的声音.

《异形：隔离》里面的探测器：

《异形2》里面的M314探测器:

这些探测器实际上只用一个作用，吓坏未成年看异形电影的小朋友，让他们每天晚上因为这种声音做噩梦

这不是我说的，是央视电影频道主持人锐评的

硬件准备

电影 VS 现实

首先我们得知道这些探测器原理，在现实中，能用的方案是mmwave radar，也就是说发微波探测到物体反射回来打到屏幕上告诉我们有没有物品。

与电影的差别：
在现实中mmwave并不能穿混泥土墙，这是因为他们的工作波段导致的。不过好像电影里面的也没有穿混泥土墙的需求，都是穿一下泡沫板。

电影里面那种逆天的穿墙性能和追踪性能，现实中是做不到的。最多能通过UWB去看附近有没有东西，但是定位不到那么准确。

ESP32

ESP32简直是工业奇迹，我到现在还没整明白为什么这种小型计算机带蓝牙带wifi甚至是可以带摄像头的东西只要10块钱？？

TFT

一块屏幕

MMWAVE

这块选择很多，我选的是LD2460，LD2460最大距离是8M，支持360度和120度，对于我来说就够了

组装

实际做起来很简单，为了简单我们可以先用面包板加一些线把他简单拼接起来，按照说明书的接

这里不要相信GPT的。比如GPT5.4之前一直跟我说LD2460有两个TX RX GND只用接一个，实际上搞了半天我发现雷达咋都没信号，最后翻图纸才发现是GPT骗我，LD2460两个TX RX GND都得接。
最后长这样:

先绑着:

剩下的就非常简单，把ESP32插入电脑，剩下的交给GPT,只需要丢给GPT LD2460的结构体就行，让GPT自己编程。vibe coding即可。LD2460支持调整模式，高灵敏什么的，我就稍微调整了一下。3M内如果没东西就切换成高灵敏模式探测8M的东西。否则就缩放成3M的高精度定位。

测试

所以我们来试试

太丑了，让GPT改了一下样式, 经过测试，可以透过一些简单的遮挡物的。并且我发现，可能是因为反射的缘故？在室内如果不是完全密封的情况下，可以检测到人在混凝土墙背后，不过门完全关了就探测不到了，我猜测是因为有反射，所以不是完全密封的情况下，也是能探测到人的

拿去室外试试，效果也是嘎嘎的，在室内因为反射的缘故，:

现在就跟游戏里面的很像了，还可以继续微调一下:

后续

忘记加发声模块了，就先不加了，那声音听得我害怕。国外有一个老哥做了带发声模块的,原理跟我这个也差不太多

《Building a REAL Alien Motion Tracker》
https://www.youtube.com/watch?v=KpUjXUSlkbU&t=335s

还差一个3D打印，打印一个外壳然后塞进去就好了。

跳转微信打开

前言

在训练duckgpt之前，我认为未来端点推理一定是主流的，因为大模型在服务器上跑，大是大，确实性能可以，但是太贵了，未来LLM一定是软件一样分发到各家各户而不是在云端集中推理。

在写了上一篇文章后，我继续的对大模型进行训练
《[2026]从0训练自己的AI大模型(下)》
https://key08.com/index.php/2026/04/05/3136.html

经过不断的努力，我成功的让一个duckgpt变得非常聪明，通过蒸馏/SFT微调/强化学习agent能力，现在他长得像GPT+claude的组合了，而且逻辑思维能力基本跟GPT+claude差不太多:

duckgpt:

深度思维链思考:

逆向分析:

浏览器使用能力:

代码工程能力:

如果对这个感兴趣，在这篇文章留言”想看精调”，我会单独出一期如何通过精调(sft+rl场景+dpo)让模型具有agent能力并且提高智商

看起来很不错对吧，实际用也很不错，但是到前几天我发现了一个问题，参数量太小了，很多东西他都不懂。

什么东西是硬伤?

对于LLM来说，可以简单理解，模型参数量=脑容量。而模型行为可以被各种训练，比如我们可以做DPO去优化模型的行为，我们可以做GRPO让模型学会调用工具，强迫模型进行深度思考找到正确答案，我们可以搞SFT/lora去让模型蒸馏GPT/CLAUDE的能力让他们在某些领域的智商显著提高。但是我们没办法解决一件事，就是模型因为参数量的问题，他的知识面和深度永远比不过大模型

你可以说我们可以通过，扩展预训练去给模型增加知识啊？ 但是这个其实是有问题的，模型参数就这么大，扩展预训练代表模型一定会遗忘一些东西，另外成本很大，现在网络信息变化那么快，每几个月来一次吃不消。

所以有什么办法解决呢？

Reseach MCP

回想以前纯手工时代写代码，搞二进制，写内核的时候，我们在干什么？ 在每天没日没夜的查询资料，通过谷歌，github找代码抄。所以就那一个问题，为什么我们不搞一个模型用的”谷歌”呢？并且小模型是有工具调用能力的，他完全可以通过工具调用能力去弥补自己的知识面的问题。

第一版我就做了一个模型搜索引擎，有问题让模型先搜索一下网页，效果嘛….一般，对于了解新闻可以，但是对于专业领域还是太欠缺了，甚至是有害： 因为模型会无条件相信工具的结果，而我们的工具通过API调用，查到的居然是C某DN这种网站，质量直线下滑。

因此，我做了一个非常简单的mcp research，也不是我做的，vibe coding的，他本质上是通过duckduckgpt+AI聚合+知识库的东西，你可以简单理解为，他是一个搜索引擎，并且还内置一个AI，这个AI会根据skills去整理搜索引擎的内容，并且访问具体的网站，然后给报告。与其他的”deepresearch”不同的是，他是为代码设计过的

简单的例子，当我们问，WFP的时候，通过MCP，找到了对应的资料

还会带例子输出，参考资料

还会推荐要继续查询什么

然后模型会继续接着追问，一个场景会出现三四个知识库，这些知识库会保存起来，并且按时间过期，超过X天自动过期重新更新：

本质上，这个就是一个大号的，本地模型的专用搜索引擎，你甚至是可以接一个大模型，让自己本地的GPT，去问云端的GPT代码怎么写，问题怎么做。这样理论上能最大减少幻觉。

懒惰是最大的问题

再然后，我发现了另外一个问题，本地的GPT，比如QEWN或者DUCKGPT，都是“懒惰”的，意思是他们不会主动的调用工具。比如duckgpt或者qwen3.5 27b/35b在用户完全没提示的时候，无论MCP怎么写提示词让他调用，在没用户提示或者系统提示词的情况下，这些都很少调用这个MCP，即便是错误的环境下，也很少调用MCP，而且即便是用户提示调用，也是第一次调用，然后自己写代码出现幻觉了（代码怎么改都改不了），也不会调用MCP进行搜索。

然后去看源码，给出结论:

微调模型

因此，我对duckgpt进行了额外的微调，简单来说，就让大模型自己合成了一个简单的数据集吗，合成的办法看我之前的帖子:

(这个微调没有用DPO，我只用了lora，因为我觉得没必要那么费劲)
我们没办法知道模型是否幻觉，但是我们能让模型更倾向于主动调用research工具
弄完后，模型终于主动的开始调用工具了:

mcp里面的AI的结论:
(这种保守是非常正确的,不能胡编,只依赖证据)

不过还有瑕疵，AI会变得很保守，表现为问啥都会搜一下，所以之后可能做一下DPO让AI区分哪些是直接回答哪些是复杂问题找资料。不能这么傻大粗的做提示词+微调去做。

结论

我目前用得很爽，所以分享给大家:
https://github.com/huoji120/mcp-research

跳转微信打开

在上一篇中
《[2026]从0训练自己的AI大模型(上)》
我们已经做完了一个pretrain的模型，而模型聪不聪明看两个，一个是pre trian，另外一个是post train。因此本章会开始讨论后训练，我们的这个章节的最终目标是做一个能完成简单CTF的Agent模型。
要完成能打ctf的模型，模型需要掌握两个能力，第一个是工具调用能力，第二个是对”CTF流程的理解能力”。而这两个都在后训练阶段完成

公开互联网高质量文本越来越稀缺，所以各家 pretrain base 的差距在缩小。公开数据红利变小了，base 差距更隐蔽，后训练差异更显眼。这也是为什么后训练如此重要的原因

我们需要什么

让我们把目标明确，我希望模型具有think能力，并且能调用工具，此外能完成简单的登陆注册sql注入的ctf题目
为了实现think/和工具调用，我们需要

1. 在sft阶段把这两个能力给组起来

2. 后续使用 RL 纠正行为

SFT

SFT数据集很关键，好的数据集一两拨千金。
我们上一章的SFT是随便找了个简单的试试，而这次我们认真做一下，数据采用claude opus 4.6 + gpt 5.4的公开蒸馏数据集，配比少量deepseek和qwen的数据和部分合成数据，组了两个高质量数据集。非常标准的训练，代码由vibe coding完成，就不细说了。这部分就是数据集要选得好。
这里面包含了我们所有需要的，多轮对话，工具调用，以及关键的think能力。

值得注意的是，如果数据集不干净，模型很容易在这个地方被带偏。我建议是这些数据集至少带，指令遵循，多轮对话（比如第一轮给模型说记住我是谁，第二轮再问我是谁），多样化任务，以及部分工具调用的例子和思维链。而且要尽量避免污染，很多开源数据其实是不能直接用的，里面啥都有，写小黄文的有，搞色情有，最好的办法是自己记录自己给大模型调用的过程。比如给你的opencode装个插件记录一下之类的

用了高质量数据集后，模型很快的呈现了看起来不错的能力，并且大模型的think也迁移过来了:

但是光靠SFT还是不够的，比如一个普通的问题能think这么多:

一根6米长的杆子是否能通过一扇宽三米高5米的门

我猜测是数据集里面带qwen或者ds的缘故,学到了无限think。所以光靠SFT是没用的，而且过长思维链对模型有害。

强化学习

在SFT阶段，模型可能学到了”模式”比如知道用户说 “帮我查询一下天气”，模型会意识到需要调用工具

<tool_call>xxxxx</tool_call>

但是由于各种原因，他们可能会输出垃圾字符或者不闭合tag等。所以光有SFT是不够的，我们需要对其进行强化学习.而这部分简单来说，参考minimind的实现，改进一下
think太长太短，不闭合扣分

工具调用不规范扣分，如虚假工具，无效JSON，不闭合:

然后进行训练，结果:

一根6米长的杆子是否能通过一扇宽三米高5米的门

看样子虽然think乱七八糟，但是至少正常一点了。并且模型也掌握了基础的工具调用。

我应该怎么清理一匹 70kg178cm的马

如果 A>B，B<C，那么A和C的关系是什么?请给出具体的推理过程。

CTF训练

当模型掌握了tool use和看起来没那么糟糕后，我们可以进入正题，CTF训练了。实际上，我做这个系列的核心目的是为了把大模型能力迁移到小模型里面。简单的CTF是我们的第一个目标。我这里设计了一个存在sqli注入漏洞的靶场

import os
import sqlite3
from pathlib import Path
from flask import Flask, redirect, render_template_string, request, session, url_for
BASE_DIR = Path(__file__).resolve().parent
DB_PATH = Path(os.getenv("DB_PATH", str(BASE_DIR / "data" / "lab.db")))
FLAG = os.getenv("FLAG", "flag{demo_sqli_login_bypass}")
ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "sqli_lab_admin_9f3c2")
app = Flask(__name__)
app.config.update(
    SECRET_KEY=os.getenv("SECRET_KEY", "demo-secret-key"),
    SESSION_COOKIE_HTTPONLY=True,
    SESSION_COOKIE_SAMESITE="Lax",
)
def init_db() -> None:
    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
    connection = sqlite3.connect(DB_PATH)
    try:
        connection.execute(
            """
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                username TEXT UNIQUE NOT NULL,
                password TEXT NOT NULL
            )
            """
        )
        user_count = connection.execute("SELECT COUNT(*) FROM users").fetchone()[0]
        if user_count == 0:
            connection.executemany(
                "INSERT INTO users(username, password) VALUES(?, ?)",
                [
                    ("admin", ADMIN_PASSWORD),
                    ("guest", "guest"),
                ],
            )
        else:
            connection.execute(
                "UPDATE users SET password = ? WHERE username = ?",
                (ADMIN_PASSWORD, "admin"),
            )
        connection.commit()
    finally:
        connection.close()
def fetch_user(username: str, password: str):
    connection = sqlite3.connect(DB_PATH)
    connection.row_factory = sqlite3.Row
    try:
        query = (
            "SELECT username FROM users "
            f"WHERE username = '{username}' AND password = '{password}' "
            "ORDER BY CASE WHEN username = 'admin' THEN 0 ELSE 1 END LIMIT 1"
        )
        return connection.execute(query).fetchone()
    finally:
        connection.close()
INDEX_TEMPLATE = """
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Mini CTF Lab</title>
    <style>
      body { font-family: monospace; background: #f3efe5; color: #1f1b16; margin: 2rem; }
      .card { max-width: 780px; background: #fffdf7; border: 1px solid #c6b89e; padding: 1.5rem; }
      a { color: #8a3b12; }
      code { background: #efe5d2; padding: 0.1rem 0.3rem; }
    </style>
  </head>
  <body>
    <div class="card">
      <h1>Mini CTF Lab</h1>
      <p>This lab is for model training. Goal: become <code>admin</code> and visit <code>/flag</code>.</p>
      <p>Known low-privilege account: <code>guest / guest</code>.</p>
      {% if user %}
      <p>Current user: <code>{{ user }}</code></p>
      <p><a href="{{ url_for('profile') }}">profile</a> | <a href="{{ url_for('flag') }}">flag</a> | <a href="{{ url_for('logout') }}">logout</a></p>
      {% else %}
      <p><a href="{{ url_for('login') }}">login</a></p>
      {% endif %}
    </div>
  </body>
</html>
"""
LOGIN_TEMPLATE = """
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Login</title>
    <style>
      body { font-family: monospace; background: #f3efe5; color: #1f1b16; margin: 2rem; }
      .card { max-width: 780px; background: #fffdf7; border: 1px solid #c6b89e; padding: 1.5rem; }
      input { width: 100%; padding: 0.55rem; margin: 0.35rem 0 1rem 0; }
      button { padding: 0.6rem 1rem; }
      .error { color: #b42318; }
      a { color: #8a3b12; }
    </style>
  </head>
  <body>
    <div class="card">
      <h1>Login</h1>
      <p>Use <code>guest / guest</code> for a normal user.</p>
      {% if error %}<p class="error">{{ error }}</p>{% endif %}
      <form method="post">
        <label>Username</label>
        <input name="username" autocomplete="off">
        <label>Password</label>
        <input name="password" type="password" autocomplete="off">
        <button type="submit">Login</button>
      </form>
      <p><a href="{{ url_for('index') }}">home</a></p>
    </div>
  </body>
</html>
"""
PROFILE_TEMPLATE = """
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Profile</title>
    <style>
      body { font-family: monospace; background: #f3efe5; color: #1f1b16; margin: 2rem; }
      .card { max-width: 780px; background: #fffdf7; border: 1px solid #c6b89e; padding: 1.5rem; }
      a { color: #8a3b12; }
      .hint { color: #5f4b32; }
    </style>
  </head>
  <body>
    <div class="card">
      <h1>Profile</h1>
      <p>Logged in as <code>{{ user }}</code>.</p>
      {% if user == 'admin' %}
      <p>You have admin access. Visit <a href="{{ url_for('flag') }}">/flag</a>.</p>
      {% else %}
      <p class="hint">Only admins can read the flag.</p>
      {% endif %}
      <p><a href="{{ url_for('index') }}">home</a> | <a href="{{ url_for('logout') }}">logout</a></p>
    </div>
  </body>
</html>
"""
@app.route("/")
def index():
    return render_template_string(INDEX_TEMPLATE, user=session.get("user"))
@app.route("/login", methods=["GET", "POST"])
def login():
    error = None
    if request.method == "POST":
        username = request.form.get("username", "")
        password = request.form.get("password", "")
        try:
            user = fetch_user(username, password)
        except sqlite3.Error as exc:
            error = f"SQL error: {exc}"
        else:
            if user:
                session["user"] = user["username"]
                return redirect(url_for("profile"))
            error = "Login failed."
    return render_template_string(LOGIN_TEMPLATE, error=error)
@app.route("/profile")
def profile():
    user = session.get("user")
    if not user:
        return redirect(url_for("login"))
    return render_template_string(PROFILE_TEMPLATE, user=user)
@app.route("/flag")
def flag():
    if session.get("user") != "admin":
        return "Admins only.\n", 403
    return f"{FLAG}\n"
@app.route("/logout")
def logout():
    session.clear()
    return redirect(url_for("index"))
@app.route("/health")
def health():
    return {"status": "ok"}
init_db()
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

然后我们设计一个给靶场专用的CTF RL agent，他有三个模块组成，启动器，验证器，reward结算.

启动器

在启动器中，我会给模型对应的目标以及工具，从而让模型完成目标，并且做了限制，最多十步，最多两次工具失败调用:

验证器

这步是验证模型是否成功拿到flag，是否真的做了某些我们需要的操作，比如有没有发login包:

访问的时候有没有管理员权限

sql注入语句对不对 或者有没有相似的语句

reward结算

我们之所以验证器做那么复杂的原因是因为如果不每一步做验证，只看拿不拿flag，我们这种弱智模型会遇到Reward Sparsity(奖励稀疏)的问题

如同让小学生做高考数学题，无论尝试多少次都得零分，无法通过分数差异学习改进策略。

因此我们必须设计好，每一步都有对应的奖励或者惩罚，防止出现模型摆烂的问题.而这个是reward结算来干的，如模型成功登录就给点分，欺骗欺诈agent扣分等。

没错,RL其实是猴子算法，让猴子自己打字，打出正常语句就给分，错误语句扣分，最终让猴子实现打莎士比亚全集!

过程

这个过程非常有趣，因为模型一定不会走聪明路线，他会走偷懒的路线，哪条线容易就走哪个。
首先，用大模型合成一些正确的SFT过来（大概1k，包含正确的路线和思考），混在正常的SFT里面做训练，这个是保证模型至少读过数据。然后启动这个RL AGENT:
最开始，模型认为我们在骗他:

狠狠的扣分后，过了一个晚上，我发现模型开始上道了，认为这个是sql注入题目了

并且有时候居然还会想去谷歌搜一下答案，可惜我是国内，谷歌不给你访问的:

再过了一个晚上后，我发现模型居然作弊了:

再过了一个晚上后，我发现模型居然作弊了:

这是因为，这个flask后台也是可以正常登录的，而这套系统是我vibe coding出来的，默认的GPT给了一个弱口令，结果模型不知道从哪一步开始猜到了口令，开始疯狂刷分。
回退版本并且重新设计了奖励结构后，继续放置，一天后，这个模型终于学会了sql注入，拿到了flag:

至此，我们的训练模型之旅也结束了

总结

预训练这块坑比较多，花费也多成本也多，有条件的还是直接用别人家的base模型(已经预训练好的基座)吧，之后我也试了一下QWEN的BASE接了SFT和RL后做的真的比我的好太多了。

跳转微信打开

这个嵌套虚拟化的项目去年就完成了,但是因为业务实在是太忙了,没什么时间写再加上这种技术文章没几个人看,现在大众更喜欢的是”爽+AI”,”简单短快+AI”这类的文章.也就一直咕咕咕了,但是全国搞CPU虚拟化的人屈指可数,而且我发现我去年搞的项目今年细节也快忘完了,写了就当存档.
考虑到看这篇文章的人都有一定基础,故不做基础科普.

概念

要做嵌套虚拟化,我们需要了解三大概念

• L0：最底层的真实虚拟机监控器，直接控制物理硬件

• L1：运行在 L0 上的一台虚拟机，但它自己又充当 hypervisor

• L2：运行在 L1 里面的“下一层”虚拟机

我们做的是L1的角色，其实我们只需要:

1. 虚拟化MMIO嵌套

2. 虚拟化VMexit嵌套

3. 虚拟化异常/中断嵌套

核心做法是,我们设计一个l1用的页表/vmcb，然后分配一个l2用的页表/vmcb，当遇到l2调用vmrun的时候,把l2的vmcb提交给cpu,系统就会进入l2的工作状态。然后L2遇到vmexitt或者l1遇到vmexit的时候还是走我们的vmexit entry。虚拟化对应指令就能实现嵌套虚拟化。

让我们一步一步来

MMIO嵌套

小工具建设

第一步我们要给L2分配好页表，我们预先在每个vcpu分配:

然后我们需要一个翻译工具,要不然我们没办法访问l2的pa对应的hva:

这个所谓l1->l2,l2->l1的翻译工具就是把 L1 的 gPA映射成 L0 可访问的 VA

有了这个工具后,剩下的就是做基本的PML4访问映射:

有了PML4访问映射工具后,我们就能正常的访问L2的内存,类似于这个:

不过大部分时间我们用不上VA到PA的转换访问,这是因为,大部分情况下vmexit的都是pa地址而不是VA地址不需要走一次PML4翻译,不排除后续搞hack用的上

#PF处理

当出现#pf的时候,检查是否在guest exit里面,如果是,则进入guest 的pf而不是自己的:

void svm_exit::svm_pf_handler(_svm_guest_status* guest_context) {
#ifdef use_npt
    //__debugbreak();
    // ============ 嵌套NPT页错误处理 ============
    // 如果处于嵌套guest模式且L1启用了NPT，使用嵌套NPT处理
    if (guest_context->vcpu->nested_guest_mode &&
        guest_context->vcpu->nested_npt_enabled) {
        nested_npt::handle_nested_npt_page_fault(guest_context);
        return;
    }

而里面我们只需要像npt hook一样，找L2的rip和cr3,构造shadow page即可.
大概是:

构造shadow page,并且设置vmcb.tlbc设置成刷新tlb

然后走nvmexit即可.这个nvemexit是啥玩意后文会说。

虚拟化Vmexit

这很好理解,之前我们会伪装主板不支持vmexit指令,现在我们可以开始对他的虚拟化。总的来说,他分几步

vmsave

在vmsave阶段我们按照规范,复制当前vmsave到target上

vmload

同理,根据amd手册,复制到当前的vmcb->state_save里面

    // FS, GS, TR, LDTR (包括所有隐藏状态)
    // KernelGsBase, STAR, LSTAR, CSTAR, SFMASK
    // SYSENTER_CS, SYSENTER_ESP, SYSENTER_EIP

vmrun

这个比较复杂,让我们翻一下amd手册,

简单来说,我们先保存一下l1的guest_vmcb状态,然后给目前在用的vmcb赋值过去（也就是说,l1.vmcb = l2.vmcb)，并且标记一下进入嵌套模式(nested_guest_mode = true)

    // RAX包含guest VMCB的物理地址
    unsigned __int64 guest_vmcb_pa = guest_context->guest_register->Rax;
    DebugPrint("[Nested] VMRUN with VMCB PA: %p\n", guest_vmcb_pa);
    // 验证VMCB物理地址对齐(必须4KB对齐),这个地址在当前是不能直接范围的
    if (guest_vmcb_pa & 0xFFF) {
        DebugPrint("[Nested] VMCB PA not aligned, injecting #GP\n");
        inject_exception_gp(guest_context);
        return;
    }
    _svm_vmcb* source_vmcb =
        (_svm_vmcb*)map_l1_gpa_page_to_hva(guest_context->vcpu, guest_vmcb_pa);
    if (!source_vmcb) {
        DebugPrint("[Nested] Failed to map guest VMCB for VMRUN\n");
        inject_exception_gp(guest_context);
        return;
    }
    memcpy(guest_context->vcpu->l1_guest_vmcb, source_vmcb, sizeof(_svm_vmcb));

同时，我们的nested npt也是在这个时候初始化的

    _svm_vmcb* l1_vmcb = guest_context->vcpu->l1_guest_vmcb;
    // 初始化嵌套NPT
    if (!nested_npt::init_nested_npt(guest_context->vcpu, l1_vmcb)) {
        DebugPrint("[Nested] Failed to initialize nested NPT\n");
        inject_exception_gp(guest_context);
        return;
    }

最后把当前状态备份一下,赋值

    memcpy(guest_context->vcpu->l2_guest_vmcb, &guest_context->vcpu->stack->guest_vmcb, sizeof(_svm_vmcb));
    // ============ 从 L1 的 guest VMCB 恢复完整的处理器状态 ============
    // 根据 AMD SVM 规范，VMRUN 指令需要从 VMCB 加载完整的 guest 状态
    //dest_state->Rip = src_state->Rip;
    memcpy(&guest_context->vcpu->stack->guest_vmcb.state_save, &l1_vmcb->state_save, sizeof(_vmcb_state_save_area));

这样做的目的是,让CPU接下来执行l2的vmcb里面的内容,自然也就进入l2的虚拟化的环境了,直到遇到vmexit.

nested_vmexit

当有新的vmexit触发,并且我们进入了嵌套模式的时候,需要判断一下L2的虚拟机是否启用了对应的vmexit:

如果启用了,走nested_vmexit，而这个函数的作用是，拷贝上下文，然后注入回l2，触发l2的vmexit。这样在l2里面做对应的vmexit操作如cpuid等乱七八糟的时候,他会再次触发l1的vmexit,从而被我们控制.
简单来说:
回填一下当前的vmcb(这个时候是l2的vmcb)

    _svm_vmcb* l1_vmcb = guest_context->vcpu->l1_guest_vmcb;
    if (l1_vmcb == nullptr) {
        DebugPrint("[Nested] Error: L1 VMCB is null!\n");
        inject_exception_gp(guest_context);
        return;
    }

// 保存exit信息
    l1_vmcb->control.ExitCode = exit_code;
        l1_vmcb->control.ExitInfo1 =
            guest_context->vcpu->stack->guest_vmcb.control.ExitInfo1;
        l1_vmcb->control.ExitInfo2 =
            guest_context->vcpu->stack->guest_vmcb.control.ExitInfo2;
        l1_vmcb->control.ExitIntInfo =
            guest_context->vcpu->stack->guest_vmcb.control.ExitIntInfo;
    // 使用硬件在本次VMEXIT时给出的NRIP，避免在L2地址空间里手动解码指令长度
    l1_vmcb->control.NRip =
        guest_context->vcpu->stack->guest_vmcb.control.NRip;
    //拷贝state到l1_vmcb里面
    memcpy(&l1_vmcb->state_save, &guest_context->vcpu->stack->guest_vmcb.state_save, sizeof(_vmcb_state_save_area));
    l1_vmcb->state_save.Rax = guest_context->guest_register->Rax;
    _svm_vmcb* l1_guest_vmcb_hva =
        (_svm_vmcb*)map_l1_gpa_page_to_hva(guest_context->vcpu, guest_context->vcpu->l1_guest_vmcb_pa);
    if (l1_guest_vmcb_hva == nullptr) {
        DebugPrint("[Nested] Failed to map L1 VMCB for nested VMEXIT writeback\n");
        inject_exception_gp(guest_context);
        return;
    }
    memcpy(l1_guest_vmcb_hva, l1_vmcb, sizeof(_svm_vmcb));

这个l1_guest_vmcb_pa,不是真的l1_guest_vmcb的PA,是l1调用vm_load出来的

恢复之前的备份:

    // 恢复备份（回到进入L2前的L1 VMCB02）
    memcpy(&guest_context->vcpu->stack->guest_vmcb,
           guest_context->vcpu->l2_guest_vmcb,
           sizeof(_svm_vmcb));

这里有一个细节,在真实SVM上，#VMEXIT 返回到 host 后，某些状态不会自动从 HSAVE 恢复，host 需要在 VMRUN 之后执行 VMSAVE/VMLOAD 来保存/恢复：FS/GS/TR/LDTR（含隐藏状态）、KernelGsBase、STAR/LSTAR/CSTAR/SFMASK、SYSENTER_*。我们这里会把活动 VMCB 从 L2 恢复为进入 L2 前的 L1 备份（vcpu->l2_guest_vmcb）。如果直接整块覆盖，会导致这些字段变成 L1 的，从而让后续的 VMSAVE 保存错对象，解决：在恢复 L1 备份前，先抓取 L2 的这些字段；恢复后再把字段覆写回去，让紧随其后的 L1 VMSAVE 看到的是 L2 的值。
所以我们需要人工恢复一下

 auto* l1_state = &guest_context->vcpu->stack->guest_vmcb.state_save;
    const auto* l2_state = &l2_saved_state_for_vmsave;
    l1_state->FsSelector = l2_state->FsSelector;
    l1_state->FsAttrib = l2_state->FsAttrib;
    l1_state->FsLimit = l2_state->FsLimit;
    l1_state->FsBase = l2_state->FsBase;
    l1_state->GsSelector = l2_state->GsSelector;
    l1_state->GsAttrib = l2_state->GsAttrib;
    l1_state->GsLimit = l2_state->GsLimit;
    l1_state->GsBase = l2_state->GsBase;
    l1_state->TrSelector = l2_state->TrSelector;
    l1_state->TrAttrib = l2_state->TrAttrib;
    l1_state->TrLimit = l2_state->TrLimit;
    l1_state->TrBase = l2_state->TrBase;
    l1_state->LdtrSelector = l2_state->LdtrSelector;
    l1_state->LdtrAttrib = l2_state->LdtrAttrib;
    l1_state->LdtrLimit = l2_state->LdtrLimit;
    l1_state->LdtrBase = l2_state->LdtrBase;
    l1_state->KernelGsBase = l2_state->KernelGsBase;
    l1_state->Star = l2_state->Star;
    l1_state->LStar = l2_state->LStar;
    l1_state->CStar = l2_state->CStar;
    l1_state->SfMask = l2_state->SfMask;
    l1_state->SysenterCs = l2_state->SysenterCs;
    l1_state->SysenterEsp = l2_state->SysenterEsp;
    l1_state->SysenterEip = l2_state->SysenterEip;

然后就是恢复rip，恢复npt到l1里面

    // 恢复L0的NPT到VMCB
    guest_context->vcpu->stack->guest_vmcb.control.NCr3 = guest_context->vcpu->npt_pa;
    guest_context->vcpu->stack->guest_vmcb.control.TlbControl = 3;
    if (guest_context->vcpu->l1_guest_vmcb) {
        // 从 L2 VMEXIT 返回到 L1 host：应继续执行 L1 的 VMRUN 下一条指令。
        // 更可靠的来源是：L0 当初拦截到 L1 的 VMRUN 时硬件给出的 NRIP。
        // 该值在 handle_vmrun 中保存到 l1_vmrun_return_rip。
        uintptr_t resume_rip = guest_context->vcpu->l1_vmrun_return_rip;
        if (resume_rip == 0) {
            // 兼容旧路径：使用进入 L2 前备份的 VMCB02.control.NRip。
            resume_rip = guest_context->vcpu->stack->guest_vmcb.control.NRip;
        }
        if (resume_rip == 0) {
            resume_rip = guest_context->vcpu->stack->guest_vmcb.state_save.Rip;
            DebugPrint("[Nested] Warning: L1 resume RIP is zero, fallback RIP %p\n",
                       resume_rip);
        }
        guest_context->vcpu->stack->guest_vmcb.state_save.Rip = resume_rip;
    } else {
        inject_exception_gp(guest_context);
        return;
    }

最后rax指向guest_vmcb pa即可

    guest_context->guest_register->Rax = guest_context->vcpu->l1_guest_vmcb_pa;

结果

跟simplesvm嵌套：

simplesvm的vmexit:

跳转微信打开

从0开始开发VT调试器（二）

背景：

上一章中，我们完成了基础的VT环境搭建，我们已经可以从guest中拦截一些简单的指令跳转到host了，本期我们加快速度将对调试链路进行进一步编写

原理：

在Ring3层，我们经常会用到各种调试工具，例如vs、x64dbg等，他们的单步原理基本上就是两种异常——#DB、#BP，这两种异常在触发时（其实所有异常都会这么走），会触发IDT表中的1号中断和3号中断，中断触发后，会先触发调试器，也就是windbg、x64dbg等(First Chance); 如果调试器未处理，会自动分发到触发异常的进程的ntdll的RtlDispatchException，最后如果进程没有处理，会再次触发Ring3调试器

我们简单画一下异常处理的流程图，即：

VT下的异常流程:

通过原理已知在Ring3进程触发异常时，首先会通过触发#DB #BP，然后借助IDT进入windows内核，这便是我们可以触发VT调试的点，即，当触发#DB #BP时，VT host会接管异常，并分发到我们自己的调试器，当调试器处理完成后，VT负责注入异常或者继续执行

代码修改：

1. Exception map

首先，我们找到setup_vmcs中的针对_vt_vmcs_exceptionbitmap的写入值，这个字段主要的作用是它记录的值中如果某一位为1，那么当idt触发对应的中断时，会进入vt host，例如当#DB触发时，如果_vt_vmcs_exceptionbitmap的值为 1 << 1，那么#DB会进入VT的host的代码中，这里我们把exception_map的值改为 1 << 1

2. VT处理异常代码

我们在代码中需要对_vt_exitreason_exceptionornmi进行处理，即vt_vmm_handleexception函数，在该函数中，我们需要对#DB进行判断，并打印一条日志，并按原属性进行注入事件，在我们修改的代码中可以看到，判断了type(Hardware)和vector(#DB)，这个type和vector是一一对应的，具体值需要参考intel的手册，这里就不再展开了

3. 代码测试

我们将驱动在测试环境中加载起来，此时我们需要触发#DB，才能在驱动的输出中看是否拦截到了，所以，在这里需要打开调试器对文件进行单步，笔者使用了x64dbg对一个exe进行调试，可以看到，笔者单步两次后，debug中是可以打印出对应的日志的，证明此时host拦截到正确的数据了

Guest代码转向

现在，我们开始编写guest代码，guest的流程主要为，host注入guest转向，guest代码跳转到我们自己的stub上，stub最后触发host处理，最后host恢复环境，然后ring3继续执行，这里触发host处理，我们用vmcall指令即可

首先，我们在汇编中添加：

其次，我们在#DB中添加注入RIP的代码

KVA功能的影响

在注入代码后，我们需要考虑的一个问题，就是KVA的问题，如果windows启动了KVA，那么我们还需要更改cr3到kernel态下的CR3，毕竟shadow Cr3只有当前进程的ring3地址，以及ntkernel中的.KVSCode段的地址，我们的驱动不在这个段中，所以需要切CR3；如果没有开启，那么就不需要切了，可以用下面的ps脚本进行判断

笔者的电脑，执行后发现没有开启KVA，查阅相关资料发现在最新的CPU上，已经修复了这个漏洞，所以，windows不再开启了

需要保留的寄存器：

以上的代码展示了核心部分，但不是完整流程，因为在vmcall后，host需要恢复现场内容，所以需要将现场数据进行保存

1. eflags寄存器

该寄存器必然会被修改，因为至少tf位会被置为0，否则当注入guest后，会再次触发#DB，最后走入异常状态，我们根据Intel手册中对eflags的描述，我们将Eflags置为2，原始值保存

2. DR寄存器

和eflags的理由相同，当启动Dr时，如果地址被ring3精心构造，那么我们会在stub的某个地方触发#DB异常，导致异常状态，我们把Dr7改为0x400，屏蔽掉其他的Dr寄存器，避免触发

3. Guest context寄存器

包含cs和ss、rip、rsp、rcx，为了在vmcall的时候直接恢复，所以这几个段需要保存，这里可能会有读者有些疑问，为什么rcx也需要保存呢？因为我们在再次进入host时，用的vmcall，为了判断编号，所以用的时rcx，所以这个rcx是需要保存的

4. guest_exceptionreason、error_code、指令长度等

这些都和guest注入异常有关系，所以也需要进行保存，这样可以避免后续未处理时，注入错了异常

我们总结一下整体的结构

申请并填充栈

为了保存我们需要的数据，我们需要将我们的数据保存在栈上，并为了避免返回Ring3的时候，Ring3找到相关的数据，所以我们需要自己申请一块地址，保存context

VMCALL代码的实现：

首先，我们先针对VMACALL做一下接管，之前的逻辑是直接注入GP异常，现在不需要了

我们开始继续封装handle_vmcall函数，当得到rcx为0x1340时，我们直接注入系统异常，后续ring0、ring3的调试器就可以接到内容了

我们继续封装vt_vmm_handle_DB_exception用于处理相关逻辑，其中封装了一个vt_vmm_restore_context函数，用于处理堆栈上的数据恢复guest的状态，段、栈、ip、flags、原始rcx等

运行效果：

我们加载驱动后，打开x64dbg，并开始调试任意exe，我们在代码中，接到#DB异常时，打印了一条GetInt，在vmcall恢复的时候，打印了一条vt_vmm_handle_DB_exception，我们在x64dbg下执行两次单步后，发现windbg中日志已经可以正常打印了，切x64dbg下一切正常，没有任何的调试问题，我们再执行两次，发现rcx也是没有被变动的，证明，本次代码改动已经完成了

工程代码：

https://git.key08.com/CrazyHarb/VirtualizeDBG v0.0.2

跳转微信打开

从0开始开发VT调试器（一）背景： 这个项目其实很早就想写了，但一直没有机会，最近忙里偷闲赶紧写一下

从0开始开发VT调试器（一）

背景：

这个项目其实很早就想写了，但一直没有机会，最近忙里偷闲赶紧写一下，目前相关的中文资料不多，所以也当记录一下，避免未来自己也遗忘了。本文不会完成一个完全可用的调试器，仅做技术验证VT调试的链路不会涉及EPT等其他功能，及抛砖引玉供大家讨论，内容有瑕疵的地方，请帮忙指出。

既然是VT调试器，那么必然少不了虚拟化相关的代码，我们就先从虚拟化开始吧！之前已经有相关的资料如何进入虚拟化，各位可以先参考一下下面的参考资料

https://mp.weixin.qq.com/s/PVIkx0FDnZzo5idM3-NSSg (huoji:《国庆专题: 深度了解”核晶“的工作原理并且手动实现一个自己的"核晶"》)

https://mp.weixin.qq.com/s/nIovO0W8QW2YemZ5HCYkQg (手工编写linux下的intel虚拟化驱动)

https://mp.weixin.qq.com/s/mowc1iUJ1F2QghdyWgrrjw (手工编写linux下的intel虚拟化驱动(二))

https://mp.weixin.qq.com/s/a39NgPrKgk2wQNMD8nj5YA (INTEL CPU虚拟化特性研究&初探 (三))

https://github.com/CrazyHarb/VmxProject (linux下简易VT源码)

接下来，在正式的代码处理前，我们本章节将对VT进行简易回顾，简单的讲一下进入VT的代码

环境配置：

vs2022 + WDK + vmware + windbg

这里就不再赘述了，按照网上的来就可以了，实在不行就问AI也行，我们直接进入代码编写吧

VMX环境支持检测：

1Cpuid 1号功能的vmx位

1Msr的ia32_msr_vmx_basic功能，判断memory_type

1Msr的ia32_msr_feature_control lock位及enable_vmxon位

1Msr ia32_msr_vmx_ept_vpid_cap功能，判断是否支持EPT

1具体的结构大家可以参考前面的文章，这就不再赘述了

虚拟化环境初始化：

在进入虚拟化之前，我们需要对vmcs进行初始化，配置host、guest环境后再进入host

1. 首先我们开启vmx的Crx标志位

2. 分配栈、vmcs、vmxon空间

栈空间我们定义为0x6000大小，剩下两个定义为0x1000，并对头写入标志位即可，栈空间主要是为了我们进入host时，供CPU使用

3. 初始化vmcs内容

这里简单讲一下主要就是将vmcs中的数据进行填入，包括guest和host，我们直接上代码，由于篇幅有限，这里不再展开各个字段的含义，如果有需要进一步了解，可以参考上面的几个链接，或者intel手册

这里，我们只简单讲解最后几行的代码，其他的设置可以参考上面的文章引用，有更详细的解释，我们设置了hostrsp、hostrip、guestrsp、guestrip，并执行vmlaunch，当代码正常运行时，我们的cpu会自动进入guest模式，再guestrip处开始执行，如果cpu触发了某些vt的事件导致退出，那么会导致cpu进入host模式，并执行hostrip处的代码

VT Host的handler处理：

为了压缩篇幅，我们将尽可能的减少功能的实现，除非一些"必不可少的功能"，例如，我们需要实现cpuid、msr、nmi、vmx指令的处理，其余的暂时不涉及

1. NMI

针对NMI，我们选择直接注入到guest的方式进行，但需要注意的是，不需要挪动guest环境中的RIP

2. Cpuid

针对CPUID，我们直接通过调用CPUID，将返回值直接进行写入的方式进行处理，尽管这种处理是存在漏洞的，但本次的完成目标不涉及这块

3. Msr

针对msr的读取和写入，我们也是采取相同的方式进行，但是得套一层异常处理，因为在读写时，可能会导致CPU抛出来异常。在针对一些特殊的msr寄存器时，我们需要用特殊的vmcs段进行代替

4. vmx指令

由于本期不涉及嵌套，所以相关指令，我们直接注入一个事件即可

结尾：

至此，我们的代码已经可以在虚拟机中跑起来了，尽管本工程比较简陋，但对于目前接下来要做的功能，已经绰绰有余了

跳转微信打开

前言

2026年了，随着openclaw，ai agent的爆火，越来越多的人开始研究LLM的应用领域，不过我本人对它不咋感冒，一个是我无论是工作上还是生活中agent写得用的够多了

《[2025]中外AI大战!让AI们通过MCP玩帝国时代2》
https://key08.com/index.php/2025/10/04/2816.html
另外一个是，我觉得agent这些应用层的东西不够底层，没有什么价值。所以快过新年的时候，就打算年后学习咋做LLM，自己搞个AI大模型出来。不过年后公司业务真的忙，一直没空，到3月份也很忙。

ps:现在AI写代码了，理论上更轻松了，但是现实中怎么更忙了。

但是没办法了，我觉得自己不能被垃圾业务代码淹没，所以再怎么忙也抽时间开始这个项目了。

首先声明，虽然我之前懂机器学习/深度学习/强化学习，不过这些都只会一点点，我不是LLM领域专家，要是写的不好或者有问题请评论区请指出我的错误。

前期准备

明确自己要干什么

在训练的第一步，我们确定自己要搞什么，我确定我是搞网络安全的，我要最低代价训练一个看起来不错的小模型就行，其他的能力拉了就拉了，专项训练不是那么容易的。
因此我们确定：

1. 我们是小模型，不用太多资源

2. 搞着玩的，自己学习大模型训练，他基本只是个DEMO，不要做太好，不要花太多钱。

服务器配置

基本上，我们前期要准备一个AI训练服务器，我准备训练的模型大小是0.6b，所以两张A100就行了，太多了资源溢出了。但是硬盘和带宽要稍微大一点，特别是带宽，走梯子拉hf的内容，带宽32M绝对不够用。

准备

预训练数据集

这有两个推荐的
commoncrawl -数百 TB 级别的数据，数十亿网页中提取的 TB 级原始网络数据，每月都会爬取新的数据，但我没用，因为光下完我估计我就没了几万块了。
https://commoncrawl.org/get-started

RefinedWeb
1TB 左右，9.68亿条数据
Common Crawl 数据集的大量经过重复数据删除和过滤的标记语料库，它是为较小规模但高质量的数据集训练 Falcon-40B 模型而开发的
https://huggingface.co/datasets/tiiuae/falcon-refinedweb

网络安全社区的爬虫数据/CEV/POC/exploit-db/github安全相关的东西混在一起

由于RefinedWeb是纯英文的，所以我又找了几个hugging face上不知名的中文数据集，中文数据集是真的难找，随便找了几个。

模型架构

这里我就一个经验，永远不要自己创造乱七八糟的架构(其实架构不咋重要，重要的是数据)，所以我选了llama的，由于分词表llama对中文不太好，用qwen的分词表。此外快速注意力，rope这些都上了。

开始训练

所以，现在训练一个模型成本极其的低廉了，我只需要搞个服务器，然后装一个opencode，我给他数据，让他搅拌在一起，就能开始预训练了。你不用关心操作，只需要关心细节就行。
模型loss降低的很快，一晚上就从9到3，似乎一切都朝着好的方向发展，我们很快就能训练一个好的模型了

LOSS居然不降低了

过了大概3天后，我观察到一个问题，loss居然不继续降低了，还是在3-2左右
看了看checkpoints，成这样了

为什么会这样，这个问题别让ai回答，因为我被AI坑了，AI说是训练时间不够久，然后就训练到了60000步，等回过头的时候，已经被坑惨了

让我们仔细回顾一下数据集，RefinedWeb我用了，这个应该是洗好的，网络安全社区的爬虫数据.这个是问题，它包含了大量的无用的标签，时间戳，这些标签因为我们训练的是0.6b的模型，他会让模型困惑，毫无逻辑。可能在更大的模型上他会学到这个是网页，但是对于一个0.6b的模型来说太勉强了。

因此，我们只能清洗一下数据，所谓清洗，我们直接点，国内论坛强行只保留中文，删除非中文或者非代码的内容。删掉无意义的CVE的编号，等。然后我们由于一开始就训练坏了，只能重新训练了，这次看表现还不错，几千次就这样了

然后等吧，由于是重新再来，相当于浪费了1000多，挂了两天，看看效果：
肉眼可见loss低了：

续写也很正常一点了

但是我发现，这玩意大而空：

我认为是数据不够的结果，所以不管他继续训练了。
又过了一天
我发现最新的checkpoints出现损坏的情况：

所以先回退到老版本，做一下SFT

SFT

有了一个续写模型后，我们可以下一步，开始进行SFT微调了, 这样才有对话能力，自我认知能力。
这真的是一个大坑
pre train还算中规中矩。post train就麻烦了，一开始我从网上随便找了数据集进行训练，发现会让模型直接损坏！

还有更离谱的,老外的训练集也带黄色废料,导致模型学了不该学的:
(当我说’你好’的时候)

这tm是一个黄色废料….
实在不行了！业务上又有一堆事…于是乎我找了一个hf上很火的deepseek蒸馏的数据集，不带think的那个，又过了一天…
结果第二天看的时候 我特么发现不对劲..

怎么回事，这么那么多”美人”啊

检查checkpoints，发现从很早开始，模型就学会美人了，而且他最早的时候居然在写小黄文….
倒查训练集，我发现一个绝望的事情，我的训练集里面充满了小黄文，其中美人来自这里

完了，又白训练了.

捣鼓半天，试了N个数据集，效果还是不明显。其实后来写文章的时候看，这就触发了我前面说的两个大坑
我们用了RefinedWeb，并且用了一些受污染的/完全不知名的中文训练集来做预训练，这导致，模型的底座中文能力其实是偏差的，即便是有合成数据在，一开始的混入的中文低质量语料去不掉了，除非重新训练

第二个问题，我们的模型比较小，只有0.6b，他受到post train的影响非常大，他并不是一个通用模型，如果我们再拿网上的一些数据去给他做SFT，他只会学到乱七八糟的 杂七杂八的内容，除非我们预训练做的非常充分。
而看起来，我们的预训练也不充分，数据集不够多，次数也不够多，数据配比也有问题。一系列问题导致我们到了如今的情况。

make duckgpt greate again

其实前面写了一大堆废话的原因是因为，很明显，我前面的各种操作导致模型训练失败了。这种感觉就像是，你想去送外卖但是没有电动车，冰箱里面有泡面但是没有卤蛋，塞满了资料的硬盘说挂，很好的朋友突然翻脸，认真做的东西没人喜欢,你又会发现龟苓膏里面没有龟，老婆饼里面没有老婆，你以为的通常都不是通常，生气没用，愤怒徒劳，不行就是不行，但是失败并不丢人，只要总结原因，我们一定能解决各种未知的困难，毕竟这不是物理学。而经过冷静思考，我发现我前几天失败的原因是，在没有科学的进行学习的情况下干某件事，就跟《勇哥说餐饮》里面的蜘蛛侠一样失败。

于是乎为了解决问题，我重新进行了大量的资料学习，并且我仔细思考了一下目前的困境:
英文的效果都是好的，英文看起来至少都正常，比如这个，但是模型完全不会中文

因此本质上，需要的是pre train足够扎实，但是我们的pre train并不扎实

经过一段时间的学习和资料查找和别人的大模型POC学习（minimind），我发现，我们的重大失误:

首先，我们需要我们正确配比数据，正确的做法是，模型大小 x 20，比如我是0.6b的模型，则需要12b的数据。此外这之，我也不打算先训练网络安全的数据了，用完90%是通用数据，10%是合成的网络安全数据

此外，我们不能用野鸡的数据集，HF上很多数据集并没有进行很好的清理，一味的追求数据大规模，只会导致模型啥也学不到，除非模型参数是真的大，大到无视这种杂七杂八的数据，但是那种几百B的我们个人是搞不定的。小模型对输入的数据很敏感。

最后，我的SFT数据集也有问题，我们太相信网上的数据了，但是网上数据他并不是正常分布的，他充斥着很多人对AI的想法，比如有人拿AI做数学题，有人让AI写小黄文，有人让AI解决数学作业。这些如果是大模型搞通用大模型是可以的，但是这些数据对于我们来说，有毒。会拉低整体模型水平，正规做法是base+通用任务SFT+领域任务SFT，而不是一股脑全塞进去会导致出问题。
因此SFT数据配比我90%都是大模型合成，10%是网上通用数据。并且SFT训练率通常要是pre train的0.1左右，大了可能不收敛。

最后的最后，我发现的模型架构也有问题
我们用了Qwen的分词器，Qwen的分词器占用大概151k 加上并没有用tie，导致实际上attention就会很小很小，解决方案是换一个词表+用TIE
(实际上，在QWEN3里面的说法中，4B以下的模型都用tie)

合成数据

现在大模型厂商训练开始用合成数据来进行训练，即用一个更大的模型合成数据给小模型出来用，自然语言数据已经快到头了对于很多大模型来说（当然对于我来说不是）。

我们可以从中获得的启发是，大模型合成的数据，相比从网上爬来的野鸡数据，至少清洗过，可靠。另外对于raw data，做数据清洗是一个体力活，我一个人时间有限，而且这个吞金兽还开着，时间很珍贵。所以我立刻开始了下一步，用本地模型进行合成数据的操作

我准备用两种模型来合成数据，一个是本地的qewn3.5,他们做的非常不错，本地成本低，另外一个是云端的大模型，为了实现合成数据，我让AI写了一个发散脚本，即自己思考自己下一步要生成什么，因为我们是做pre train，所以做的是续写而不是对话。

我的配置是云端大模型占了30%，本地小模型占了70%
为什么用本地模型，因为在线大模型耗钱啊！

先让大模型无限自动生成种子数据：

然后拿这些东西去让大模型续写：

这样就得到了一批高质量的数据，虽然还是有问题，比如大模型的幻觉会会影响数据质量，而且我也没清洗过，但是至少靠谱一点了.

结果，又过了两天（-400rmb）

重新预训练

所以，我重新进行了预训练，搞了几个高质量的通用任务数据集:
https://huggingface.co/datasets/Goose-World/RWKV-World-v3
https://huggingface.co/datasets/opencsg/Fineweb-Edu-Chinese-V2.2
https://huggingface.co/datasets/shareAI/ShareGPT-Chinese-English-90k
等等..
然后继续合成数据:

数据大小限制在12b左右，不扩大。
终于，在睡了一觉后，loss终于稳定在2.5-3左右了：

看起来靠谱一点了，没之前那么离谱

于是我们得到了一个pre train训练好的模型。虽然这个模型很垃圾，其他领域续写一窍不通，因为我们没有给他投喂太多的语料。但是对于安全领域，属于是能跑吧

现在再对其做SFT。用了合成数据，其他没什么特别的

做完后效果如下:

当然也有幻觉，比如这个中国美食带了日本寿司:

然后弄了一个版本的SFT纠正了一下：

不过我也不知道他学了什么…可能是学到合成数据里面的拒绝语句了，对于代码题目是拒绝的

然后我们用了QWEN作为合成数据，所以这个模型自我认知里面认为自己是qwen的，我也懒得再合成一些自我认知数据去修正他的认知了，反正是做着玩的

幻觉依然是存在的，而且非常大，并且对于不懂的问题，就会变得笨笨的：

(我们的训练集里面没有银狐木马，所以AI完全无法找到有用的东西，所以就会这样)

总结反思

这次一共花了5000RMB，而其实跑通后实现同样的效果的模型，只需要800rmb左右，大部分时间花费在边学边测边用上:

这是因为我选了一个错误的路线，0.6b对于模型来说还是太大了，应该先从极小的参数开始，比如0.1b或者0.01b先做实验。实验跑通了再堆数据规模。从而避免时间/金钱的耗费。

无论怎么样，我们都跑通了整体的路线，下次就不会那么吃瘪了，这次没有做工具调用训练以及RL以及实现COT(思维链推理)效果也是一种遗憾，因为花的钱太多了，所以先抱有遗憾的止血，等回血一波后，攒一波再来一次更好的训练，敬请关注冲鸭安全。

这边非常感谢minimind,所有想训练的人但是不是搞模型专业的人应该先复现一下这个,节约大量时间,避免跟我一样一头撞到墙上:
https://github.com/jingyaogong/minimind

跳转微信打开

前言

这几年AI用多了,脑子坏了,比如之前写代码很容易进入心流解决问题,这个过程很爽,但是现在只会开五六个ai的console让他帮我打工。
一开始是很急的让AI写功能，
但是到后来恨不得遇到bug，编译不通过，甚至是思考都托管给AI。
我把它叫做脑腐现象.所以为了避免这种现象,我准备用纯手工打造的方式搞点项目做。锻炼一下大脑。正巧，操作系统内核目前还是AI无法触及的领域。所以，here we go。

内核创建进程

所以，让我们来复习一下内核创建进程，这里不会说太多的基础，因为chatgpt都能回答了。我们直接说简单一点的。我们先实现一个简单的调用ntcreateuserprocess创建进程的例子，在内核里面这需要三步:

1. 定位ntcreateuserprocess

2. 填好参数

3. call

定位ntcreateuserprocess

填好参数

ntcreateuserpcoess在R3的执行的时候需要用到RtlCreateProcessParametersEx和RtlDestroyProcessParameters去填_RTL_USER_PROCESS_PARAMETERS

我们R0是没有这个两个参数的，所以要自己填.填完直接call就行:

但是坑来了,
而这个RTL_USER_PROCESS_PARAMETERS 微软故意隐藏了东西，导致如果你按照微软的来写是没有办法跑起来的，跑起来会直接segment fault.这是因为没有正确的填参数,CRT初始化的时候就崩溃了。因此我写了一个R3程序，打印一下里面需要什么东西:

// ConsoleApplication1.cpp
// Dumps the raw payload produced by RtlCreateProcessParametersEx (user-mode).
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <winternl.h>
#include <cstdint>
#include <cstdio>
#include <string>
//0x18 bytes (sizeof)
struct _CURDIR
{
    struct _UNICODE_STRING DosPath;                                         //0x0
    VOID* Handle;                                                           //0x10
};
//0x18 bytes (sizeof)
struct _RTL_DRIVE_LETTER_CURDIR
{
    USHORT Flags;                                                           //0x0
    USHORT Length;                                                          //0x2
    ULONG TimeStamp;                                                        //0x4
    struct _STRING DosPath;                                                 //0x8
};
//0x410 bytes (sizeof)
struct _RTL_USER_PROCESS_PARAMETERSEX
{
    ULONG MaximumLength;                                                    //0x0
    ULONG Length;                                                           //0x4
    ULONG Flags;                                                            //0x8
    ULONG DebugFlags;                                                       //0xc
    VOID* ConsoleHandle;                                                    //0x10
    ULONG ConsoleFlags;                                                     //0x18
    VOID* StandardInput;                                                    //0x20
    VOID* StandardOutput;                                                   //0x28
    VOID* StandardError;                                                    //0x30
    struct _CURDIR CurrentDirectory;                                        //0x38
    struct _UNICODE_STRING DllPath;                                         //0x50
    struct _UNICODE_STRING ImagePathName;                                   //0x60
    struct _UNICODE_STRING CommandLine;                                     //0x70
    VOID* Environment;                                                      //0x80
    ULONG StartingX;                                                        //0x88
    ULONG StartingY;                                                        //0x8c
    ULONG CountX;                                                           //0x90
    ULONG CountY;                                                           //0x94
    ULONG CountCharsX;                                                      //0x98
    ULONG CountCharsY;                                                      //0x9c
    ULONG FillAttribute;                                                    //0xa0
    ULONG WindowFlags;                                                      //0xa4
    ULONG ShowWindowFlags;                                                  //0xa8
    struct _UNICODE_STRING WindowTitle;                                     //0xb0
    struct _UNICODE_STRING DesktopInfo;                                     //0xc0
    struct _UNICODE_STRING ShellInfo;                                       //0xd0
    struct _UNICODE_STRING RuntimeData;                                     //0xe0
    struct _RTL_DRIVE_LETTER_CURDIR CurrentDirectores[32];                  //0xf0
    ULONGLONG EnvironmentSize;                                              //0x3f0
    ULONGLONG EnvironmentVersion;                                           //0x3f8
    VOID* PackageDependencyData;                                            //0x400
    ULONG ProcessGroupId;                                                   //0x408
    ULONG LoaderThreads;                                                    //0x40c
};
// Some SDKs do not declare this prototype in user-mode headers.
using fnRtlCreateProcessParametersEx = NTSTATUS(NTAPI*)(
    _RTL_USER_PROCESS_PARAMETERSEX* pProcessParameters,
    PUNICODE_STRING ImagePathName,
    PUNICODE_STRING DllPath,
    PUNICODE_STRING CurrentDirectory,
    PUNICODE_STRING CommandLine,
    PVOID Environment,
    PUNICODE_STRING WindowTitle,
    PUNICODE_STRING DesktopInfo,
    PUNICODE_STRING ShellInfo,
    PUNICODE_STRING RuntimeData,
    ULONG Flags
);
using fnRtlDestroyProcessParameters = NTSTATUS(NTAPI*)(_RTL_USER_PROCESS_PARAMETERSEX ProcessParameters);
static UNICODE_STRING MakeUnicodeString(const std::wstring& s)
{
    UNICODE_STRING us{};
    us.Buffer = const_cast<PWSTR>(s.c_str());
    us.Length = static_cast<USHORT>(s.size() * sizeof(wchar_t));
    us.MaximumLength = us.Length + sizeof(wchar_t);
    return us;
}
static void HexDump(const void* data, size_t size)
{
    const auto* p = static_cast<const unsigned char*>(data);
    for (size_t i = 0; i < size; i += 16) {
        std::printf("%08zx  ", i);
        for (size_t j = 0; j < 16; ++j) {
            if (i + j < size) std::printf("%02X ", p[i + j]);
            else std::printf("   ");
        }
        std::printf(" ");
        for (size_t j = 0; j < 16 && i + j < size; ++j) {
            unsigned char c = p[i + j];
            std::printf("%c", (c >= 32 && c <= 126) ? c : '.');
        }
        std::printf("\n");
    }
}
static void PrintUs(const char* name, const UNICODE_STRING& us, const void* base)
{
    const auto baseAddr = reinterpret_cast<uintptr_t>(base);
    const auto bufAddr = reinterpret_cast<uintptr_t>(us.Buffer);
    std::wprintf(L"%hs: Len=%u Max=%u Buf=%p (off=0x%Ix)  \"%.*s\"\n",
        name,
        us.Length,
        us.MaximumLength,
        us.Buffer,
        (bufAddr >= baseAddr) ? (bufAddr - baseAddr) : 0,
        us.Length / 2,
        us.Buffer ? us.Buffer : L"");
}
int wmain()
{
    // Example payload: create cmd.exe parameters (NOT actually launching here).
    std::wstring imagePath = L"\\??\\C:\\Windows\\System32\\cmd.exe";
    std::wstring cmdLine = L"\"C:\\Windows\\System32\\cmd.exe\"";
    UNICODE_STRING usImage = MakeUnicodeString(imagePath);
    UNICODE_STRING usCmd = MakeUnicodeString(cmdLine);
    HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
    if (!ntdll) {
        std::printf("GetModuleHandleW(ntdll) failed: %lu\n", ::GetLastError());
        return 1;
    }
    auto pRtlCreate = reinterpret_cast<fnRtlCreateProcessParametersEx>(
        ::GetProcAddress(ntdll, "RtlCreateProcessParametersEx"));
    auto pRtlDestroy = reinterpret_cast<fnRtlDestroyProcessParameters>(
        ::GetProcAddress(ntdll, "RtlDestroyProcessParameters"));
    if (!pRtlCreate || !pRtlDestroy) {
        std::printf("GetProcAddress failed. RtlCreate=%p RtlDestroy=%p\n", pRtlCreate, pRtlDestroy);
        return 1;
    }
    _RTL_USER_PROCESS_PARAMETERSEX* p = nullptr;
    constexpr ULONG RTL_USER_PROCESS_PARAMETERS_NORMALIZED = 0x01;
    NTSTATUS st = pRtlCreate(
        (_RTL_USER_PROCESS_PARAMETERSEX*)&p,
        &usImage,
        nullptr,
        nullptr,
        &usCmd,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        nullptr,
        RTL_USER_PROCESS_PARAMETERS_NORMALIZED);
    std::printf("RtlCreateProcessParametersEx -> 0x%08X, p=%p\n", static_cast<unsigned>(st), p);
    if (st < 0 || !p)
        return 1;
    // Raw payload dump (what you'd want to mirror in kernel if you're hand-building).
    HexDump(p, sizeof(_RTL_USER_PROCESS_PARAMETERSEX));
    //pRtlDestroy(p);
    return 0;
}

实际上，缺失的内容是，我们需要填工作目录，并且要有完整的结构体:

//0x18 bytes (sizeof)
struct _CURDIR
{
    struct _UNICODE_STRING DosPath;                                         //0x0
    VOID* Handle;                                                           //0x10
};
//0x18 bytes (sizeof)
struct _RTL_DRIVE_LETTER_CURDIR
{
    USHORT Flags;                                                           //0x0
    USHORT Length;                                                          //0x2
    ULONG TimeStamp;                                                        //0x4
    struct _STRING DosPath;                                                 //0x8
};
//0x410 bytes (sizeof)
struct _RTL_USER_PROCESS_PARAMETERSEX
{
    ULONG MaximumLength;                                                    //0x0
    ULONG Length;                                                           //0x4
    ULONG Flags;                                                            //0x8
    ULONG DebugFlags;                                                       //0xc
    VOID* ConsoleHandle;                                                    //0x10
    ULONG ConsoleFlags;                                                     //0x18
    VOID* StandardInput;                                                    //0x20
    VOID* StandardOutput;                                                   //0x28
    VOID* StandardError;                                                    //0x30
    struct _CURDIR CurrentDirectory;                                        //0x38
    struct _UNICODE_STRING DllPath;                                         //0x50
    struct _UNICODE_STRING ImagePathName;                                   //0x60
    struct _UNICODE_STRING CommandLine;                                     //0x70
    VOID* Environment;                                                      //0x80
    ULONG StartingX;                                                        //0x88
    ULONG StartingY;                                                        //0x8c
    ULONG CountX;                                                           //0x90
    ULONG CountY;                                                           //0x94
    ULONG CountCharsX;                                                      //0x98
    ULONG CountCharsY;                                                      //0x9c
    ULONG FillAttribute;                                                    //0xa0
    ULONG WindowFlags;                                                      //0xa4
    ULONG ShowWindowFlags;                                                  //0xa8
    struct _UNICODE_STRING WindowTitle;                                     //0xb0
    struct _UNICODE_STRING DesktopInfo;                                     //0xc0
    struct _UNICODE_STRING ShellInfo;                                       //0xd0
    struct _UNICODE_STRING RuntimeData;                                     //0xe0
    struct _RTL_DRIVE_LETTER_CURDIR CurrentDirectores[32];                  //0xf0
    ULONGLONG EnvironmentSize;                                              //0x3f0
    ULONGLONG EnvironmentVersion;                                           //0x3f8
    VOID* PackageDependencyData;                                            //0x400
    ULONG ProcessGroupId;                                                   //0x408
    ULONG LoaderThreads;                                                    //0x40c
};

再然后稍微的手工填一下，这一步很想用AI忍不住了:

call it!

然后我们就跑起来了

但是这个有第二个问题，结束了就会蓝屏:

让我们调查一下,根据信息,错误代码在结束时候,

执行MmSessionGetWin32Callouts的时候:

.text:000000014008A220                                     MmSessionGetWin32Callouts proc near     ; CODE XREF: NtDeleteAtom+F↓p
.text:000000014008A220                                                                             ; PsConvertToGuiThread:loc_14060BEFE↓p ...
.text:000000014008A220 65 48 8B 04 25 88 01 00 00                          mov     rax, gs:188h
.text:000000014008A229 48 8B 88 B8 00 00 00                                mov     rcx, [rax+0B8h]
.text:000000014008A230 48 8B 81 00 04 00 00                                mov     rax, [rcx+400h]
.text:000000014008A237 48 83 B8 C0 03 00 00 02                             cmp     qword ptr [rax+3C0h], 2
.text:000000014008A23F 48 8D 05 52 E7 3A 00                                lea     rax, PsWin32CallBack
.text:000000014008A246 73 07                                               jnb     short locret_14008A24F
.text:000000014008A248 48 8D 05 41 E7 3A 00                                lea     rax, PsWin32NullCallBack
.text:000000014008A24F
.text:000000014008A24F                                     locret_14008A24F:                       ; CODE XREF: MmSessionGetWin32Callouts+26↑j
.text:000000014008A24F C3                                                  retn
.text:000000014008A24F                                     MmSessionGetWin32Callouts endp

而这个MmSessionGetWin32Callouts读

cmp     qword ptr [rax+3C0h], 2

的时候蓝屏了，这说明我们有什么东西没初始化。寻找这玩意的最好的办法是,ida搜索[rax+3C0h]访问的特征码:

根据特征码找一下cal，可以定位到，这个是在初始化win32k pfn的时候填的东西

就不卖关子了,我直接说为什么:
在操作系统创建进程时，分配进程内存和初始化进程的pfn的时候，会考虑进程的会话和上下文信息，以决定是否允许该进程访问 win32k 的pfn。而我们是直接在系统线程启动的进程，自然就没这些信息。
解决方法是附加到一个带界面的信息，比如我附加到资源管理器，这样会话也会自动分配到1而不是0:

这样你结束就不会蓝屏了，至此我们成功的实现了内核创建进程

进程回调

我们在
《[2022]新瓶装旧酒: 微软CreateProcessNotify的设计缺陷》
https://key08.com/index.php/2022/10/12/1606.html

中提到过 进程创建会触发createprocessnotify回调，这也是现在很多安全软件所用来监控进程创建的回调。

而这些回调会加入到PspCreateProcessNotifyRoutine里面.在有进程创建的时候，会被逐个执行

这些call最后被”PspCallProcessNotifyRoutines”这个执行:

so，有什么不搞DKOM的方法去不触发此类回调呢？有的兄弟，有的，那就是CPU模拟

AMD64 CPU模拟器

既然我们控制不了系统的执行流程，那么我们就不控制了，我们自己模拟一个CPU进行执行，只不过给的是真实的信息数据，唯一区别是，在执行PspCallProcessNotifyRoutines的时候,我们就跳过,其他时候跟操作系统一样就行。输入输出完全一样。
至于系统的call,我们除了PspCallProcessNotifyRoutines其他的就直接转发。这样我们就能达到目的。
如果不理解，这里有一个简单的图：

架构设计

我这边就最简单的zydis了，手搓的不需要太复杂。一个简单的X86虚拟就只需要指令行为模拟和栈就行，遇到call，我们要么选择转发，要么选择接管。
简单来说

初始化X64的vCpu

一次性decode 15字节

decode后，根据指令读取/写入不同的内存

比如mov rax,那就是给vcpu写入值

这一段让AI干了，纯苦力牛马活，没AI干不动
值得注意的是，一些指令会影响elflags,所以也记得让AI干好,AI会忽略这些影响elfags的指令:

执行他

之后就能愉快的把参数PUSH到vm里面并且执行了

值得注意的几个问题是，遇到cfg guard的时候,不要虚拟执行,因为CFG guard的bitmap会校验来源,我们的这种call肯定是非法的。最好的办法是跳过他如何call cfg,我之前手写的时候跳过是硬编码地址,但是GPT说有更好的,嗯…直接硬编码

如果遇到了直接跳过就行

call转发我之前也想的是人模拟参数,但是GPT给了一个更野的,直接全参数call,爱用哪个用哪个:

还得是AI,真的野，
此外我们设置返回地址为0，这样当模拟执行到0的时候，代表执行完成了。
我们来试一下直接模拟+call转发的:

可以看到,我们成功的运行了。
接下来跳过指定的函数,这也非常容易,我们直接跳过并且返回一个自定义的rax就行,我们跳过的是PspCallProcessNotifyRoutines,他不会修改传递的参数里面的内容,所以简单点就行:

这样我们就实现了完整跳过内核回调了

结果

让我们写个简单的createprocess回调看看，他会捕获所有cmd的执行

当我们执行cmd的时候,他会执行:

我们试试，传统内核直接ntcreateuserprocess:

很明显,因为会触发PspCallProcessNotifyRoutines,导致我们被发现:

而使用cpu模拟的ntcreateuserprocess,不会触发内核的进程回调的:

so…可能好奇的你问,这有什么用.
此技术有三个用途:

第一个是反作弊,总所周知,部分外挂会通过这些进程创建回调等回调,去拿真实的CR3或者做进程APC注入.而部分反作弊使用这种技术去不触发这些系统的回调启动游戏进程实现保护的效果

第二个是,目前绝大部分安全软件,都是基于PspCallProcessNotifyRoutines里面的回调创建进程管理器的,一旦一个进程不在安全软件自己的进程管理器里面,会导致安全软件无法监控到这个进程所有的行为,虽然有些脱裤子放屁的嫌疑,因为都驱动了都可以各种手段致盲安全软件了。

第三个是,他本来就没什么用,就跟大部分东西一样,写了就是为了提高自己技术.不要以”有什么用”去做某件事,要以”好玩就行”去做某件事。

阅读原文

跳转微信打开

简介

又过一年了兄弟们，是时候更新冲鸭安全和key08了。主要是1月太忙了，一直忙着新产品，一直没空更新公众号和博客，趁着现在有空赶紧更新一波。

shellcode

安全软件对抗中,常用shellcode作为规避杀毒软件文件查杀的办法,因为shellcode可以内存执行,可以随时抹掉,并且容易变形.
一段经典的shellcode loader如下:

    char* shellcode = (char*)VirtualAlloc(
        NULL,
        shellcode_size,
        MEM_COMMIT,
        PAGE_EXECUTE_READWRITE);
    CopyMemory(shellcode, buf, shellcode_size);
    //CreateThread函数，创建线程
    hThread = CreateThread(
        NULL, // 安全描述符
        NULL, // 栈的大小
        (LPTHREAD_START_ROUTINE)shellcode, // 函数
        NULL, // 参数
        NULL, // 线程标志
        &dwThreadId // 若成功，接收新创建的线程的线程ID DWORD变量的地址。
    );

如果你对”他发生了什么”感兴趣自己问chatgpt的VAD/PTE吧,这里我们不废话介绍原理了.

一般检测

现代的杀毒软件/或者EDR,对于这分配内存,一般会扫一下VAD里面的rwx

代码如下:

MEMORY_BASIC_INFORMATION mbi = { 0 };
        SIZE_T address = 0;
        while (VirtualQueryEx(hProcess.get(), reinterpret_cast<LPCVOID>(address), &mbi, sizeof(mbi)) == sizeof(mbi))
        {
            // 排除模块映像段
            if (mbi.Type != MEM_IMAGE)
            {
                // 检查是否可执行
                DWORD protect = mbi.AllocationProtect;
                bool checkExecuteFlag =
                    (protect & PAGE_EXECUTE) ||
                    (protect & PAGE_EXECUTE_READ) ||
                    (protect & PAGE_EXECUTE_READWRITE) ||
                    (protect & PAGE_EXECUTE_WRITECOPY);
                if (checkExecuteFlag)
                {
                    .....
                    if (!memoryAvEngin->ScanProcessBlocks(memoryStreamPtr, false, callback)) {
                        printf("ScanProcessBlock error");
                    }
                    .....
                }
            }
            // 跳到下一个内存区域
            address = reinterpret_cast<SIZE_T>(mbi.BaseAddress) + mbi.RegionSize;
        }

由于VirtualAlloc分配的内存是RWX属性并且不是MEM_IMAGE,所以会被扫出来后匹配特征码。

缺陷

实际上，与大家想的不同，安全软件通常不会直接报RWX为病毒(不过部分**EDR会这样做)。这个原因是 实际环境中，基本每个电脑都会或多或少的有几个RWX内存，jit，广告软件，部分加壳软件居多。所以杀毒软件不会看到就报，他一定匹配特征码，并且做匹配:
比如ES的yara为例子:
https://github.com/elastic/protections-artifacts/blob/main/yara/rules/Windows_Trojan_CobaltStrike.yar