Windows内核学习笔记（三）

前言

本篇并非内核学习，但有点相关，是本人看了内核区域后的遐想。
AI是一个思考的好工具，但是具体的验证还得亲为。
这样的问题我曾经也思考过，但是由于编写代码过于麻烦，而现在也该给自己一个答案了。

**图片太长，点击展开**

![image](https://img2024.cnblogs.com/blog/3336551/202502/3336551-20250225172907861-126349978.png)

尝试编码

项目结构：

TestDll：被修改的Dll
TestRunner：运行者，旁观者
DllMemoryInjectTest：修改者，管理员权限

由于已知内核代码是不能修改的，但是同一个dll在代码中的情况，windows会选择隔离进程吗？

此处省略处理代码异常过程……
最后会给出代码

结果

不同程序加载相同dll，其中一个程序修改它自身内存中dll后，另一个程序不会同步修改。
当我发现修改保护不需要管理员权限时，其实就已经不抱有太大希望了
但为了完成整个程序，还是写到了最后。
dll难道都类似于include一样，每一个exe都复制自己的dll吗

哎，有个问题。
系统dll也适用这个条件吗？
这里的基地址完全一样。

注意到，用户模块的基地址也完全一样
感觉不抱希望。
不如直接用xdbg修改试试，没必要写软件了。

随便改了一个字节，没有同步。

思考

windows应该不会像Chromium一样，因此抱着怀疑的态度询问了AI

这篇文章中的说法是不完全准确的。在Windows系统中，DLL（动态链接库）的加载和共享机制并不是通过简单地“复制一份”来实现的，而是通过复杂的内存映射和共享机制来完成的。

关于DLL的共享机制

在Windows中，DLL文件（如kernel32.dll、ntdll.dll等）是被设计为可以被多个进程共享的。当第一个进程加载某个DLL时，系统会将DLL的代码部分加载到内存中，并为该DLL创建一个共享的内存映射。

当其他进程加载相同的DLL时，系统不会重新加载DLL的代码部分，而是直接映射到已经加载的内存区域。这意味着多个进程可以共享同一个DLL的代码部分，从而节省内存。

DLL的代码与数据分离：

DLL的代码部分（即只读的指令代码）是可以被多个进程共享的，因为代码是只读的，不会被修改。
而DLL的全局数据部分（如变量等）是每个进程独立的，系统会为每个进程创建独立的数据副本，以避免进程之间的数据冲突。

基地址相同的原因：

文章中提到“用户模块的基地址完全一样”，这是因为Windows的内存管理机制会尽量将DLL加载到相同的基地址（如果可能的话）。这是为了提高性能和兼容性，但并不意味着DLL被“复制”了。

如果由于某些原因（如地址空间冲突），DLL无法加载到预期的基地址，系统会进行重定位，但代码部分仍然可以共享。

关于文章中的实验结果

文章中提到“不同程序加载相同DLL，其中一个程序修改它自身内存中的DLL后，另一个程序不会同步修改”。这个结果是正确的，因为DLL的代码部分是只读的，一旦被修改，实际上是在修改进程的私有内存映射，而不是原始的DLL代码。其他进程仍然会看到原始的DLL代码。

代码

DllMemoryInjectTest.cpp

// Program1.cpp
#include <windows.h>
#include <stdio.h>
#include <cstring> // 用于 std::memcmp 和 std::memcpy

// 搜索函数
int searchInBuffer(const char* buf, size_t buf_size, const char* target, size_t target_size) {
    if (buf == nullptr || target == nullptr || buf_size < target_size) {
        return -1; // 参数无效或目标序列比缓冲区大
    }

    for (size_t i = 0; i <= buf_size - target_size; ++i) {
        // 使用 std::memcmp 比较目标序列
        if (std::memcmp(buf + i, target, target_size) == 0) {
            return static_cast<int>(i); // 找到匹配，返回位置
        }
    }

    return -1; // 未找到
}

int main() {
    // 加载DLL
    HMODULE hDll = LoadLibrary(L"TestDll.dll");
    if (!hDll) {
        printf("Failed to load DLL\n");
        return 1;
    }

    // 获取函数地址
    FARPROC originalFunction = GetProcAddress(hDll, "MyFunction");
    if (!originalFunction) {
        printf("Failed to get function address\n");
        FreeLibrary(hDll);
        return 1;
    }
    // 获取实际函数代码地址
    // 跳板指令格式：E9 <相对偏移量> (相对跳转)
    unsigned char* thunk = (unsigned char*)originalFunction;
    unsigned int relativeOffset = *(unsigned int*)(thunk + 1); // 获取相对偏移量
    void* actualFunction = (void*)((unsigned char*)originalFunction + relativeOffset + 5); // 计算实际函数地址

    // 调用修改后的函数
    typedef void (*Func)();
    Func function = (Func)originalFunction;
    function();

    // 尝试修改代码段的保护属性
    DWORD oldProtect;
    if (!VirtualProtect(actualFunction, 1024, PAGE_EXECUTE_READWRITE, &oldProtect)) {
        printf("Failed to change protection\n");
        FreeLibrary(hDll);
        return 1;
    }

    // 尝试修改代码
    // 新函数的机器代码（x86/x64汇编实现）
// 注意：以下代码为x86架构的实现，如果需要x64架构，需要调整机器代码
    unsigned char rawCode[] = {
        0x40, 0x55,                       // push rbp
        0x57,                             // push rdi
        0x48, 0x81, 0xEC, 0xE8, 0x00, 0x00, 0x00, // sub rsp, 0xE8
        0x48, 0x8D, 0x6C, 0x24, 0x20,     // lea rbp, [rsp+20h]
        0x48, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00, // lea rcx, [rel fmt] (需要修正为字符串地址)
        0xE8, 0x00, 0x00, 0x00, 0x00,     // call printf (需要修正为printf地址)
        0x48, 0x8D, 0xA5, 0xC8, 0x00, 0x00, 0x00, // lea rsp, [rbp+0C8h]
        0x5F,                             // pop rdi
        0x5D,                             // pop rbp
        0xC3,                             // ret
        'M', 'o', 'd', 'i', 'f', 'i', 'e', 'd', ' ', 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n', 0x00 // "Modified Function\0"
    };
    unsigned char newCodeData[] = {
        'M', 'o', 'd', 'i', 'f', 'i', 'e', 'd', ' ', 'F', 'u', 'n', 'c', 't', 'i', 'o', 'n','\n', 0x00 // "Modified Function\0"
    };
    char search2[] = { 0x5D,0xC3 };
    int index2 = searchInBuffer((char*)actualFunction, 60, search2, sizeof(search2));
    if (index2 == -1) {
        printf("err2");
        return -1;
    }
    index2 += sizeof(search2);

    char search1[] = { 0x48,0x8D,0x0D };
    int index1 = searchInBuffer((char*)actualFunction, 60, search1, sizeof(search1));
    if (index1 == -1) {
        printf("err1");
        return -1;
    }
    index1 += sizeof(search1);
    int index1_ = searchInBuffer((char*)actualFunction + index1, 60, search1, sizeof(search1));
    if (index1_ != -1) {
        index1 = index1 + index1_ + sizeof(search1);
    }

    // 修正字符串地址
    char* strLo = (char*)actualFunction + index2;
    char* ripLo = (char*)actualFunction + index1 + 4;
    int releative = strLo - ripLo;

    *(int*)((char*)actualFunction + index1) = releative;
    memcpy(strLo, newCodeData, sizeof(newCodeData));

    // 恢复保护属性
    VirtualProtect(actualFunction, 1024, oldProtect, &oldProtect);

    printf("Attempted to modify DLL code\n");

    function();

    // 保持DLL加载状态，等待用户输入
    printf("Press Enter to exit...\n");
    getchar();

    FreeLibrary(hDll);
    return 0;
}

TestRunner.cpp

// Program2.cpp
#include <windows.h>
#include <stdio.h>

int main() {
    // 加载DLL
    HMODULE hDll = LoadLibrary(L"TestDll.dll");
    if (!hDll) {
        printf("Failed to load DLL\n");
        return 1;
    }

    // 获取函数地址并调用
    typedef void (*Func)();
    Func myFunction = (Func)GetProcAddress(hDll, "MyFunction");
    if (!myFunction) {
        printf("Failed to get function address\n");
        FreeLibrary(hDll);
        return 1;
    }

    // 第一次调用：验证原始状态
    printf("Calling MyFunction (Original State):\n");
    myFunction();

    // 等待用户输入，以便程序1修改DLL代码
    printf("Press Enter to continue...\n");
    getchar();

    // 第二次调用：验证修改后的状态
    printf("Calling MyFunction (Modified State):\n");
    myFunction();

    FreeLibrary(hDll);

    printf("Press Enter to exit...\n");
    getchar();
    return 0;
}

dllmain.cpp

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

extern "C" __declspec(dllexport) void MyFunction() {
    printf("Original Function\n");
}