WINDOWS内核内存遍历&存取

最新推荐文章于 2024-10-14 00:11:50 发布
最新推荐文章于 2024-10-14 00:11:50 发布
阅读量117 收藏
点赞数 1
文章标签： windows 单片机 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50198957/article/details/141979392
版权 
#include <ntifs.h> 
#include <ntddk.h>
#include <wdm.h>
#include <vadefs.h>

#pragma warning(disable:6387)
#pragma warning(disable:6011)

typedef ULONG64 UL64;

#define onceReadPagesCount 64

#define DELAY_ONE_MICROSECOND     (-10)
#define DELAY_ONE_MILLISECOND    (DELAY_ONE_MICROSECOND*1000)

VOID KernelDriverThreadSleep(LONG msec)
{
    LARGE_INTEGER my_interval;
    my_interval.QuadPart = DELAY_ONE_MILLISECOND;
    my_interval.QuadPart *= msec;
    KeDelayExecutionThread(KernelMode, 0, &my_interval);
}

typedef struct _ValidAddressLink
{
    ULONG64 beginAddress;
    ULONG64 endAddress;
    ULONG memoryState;
    ULONG memoryProtectAttributes;
    BOOLEAN executeFlag;
    ULONG64 regionGap;
    ULONG64 pageNums;
    SINGLE_LIST_ENTRY ValidAddressEntry;
}VAL, * PVAL;

typedef struct _ResultSavedLink
{
    ULONG times;
    ULONG64 address;
    LIST_ENTRY ResultAddressEntry;
}RSL, *PRSL, **PPRSL;

PVAL createNode(ULONG64 begin, ULONG64 end, ULONG memState, ULONG memProtectAttributes, BOOLEAN executeFlag)
{
    PVAL newNode = (PVAL)ExAllocatePoolWithTag(PagedPool, sizeof(VAL), 'WWWW');
    if (newNode)
    {
        newNode->beginAddress = begin;
        newNode->endAddress = end;
        newNode->memoryState = memState;
        newNode->memoryProtectAttributes = memProtectAttributes;
        newNode->executeFlag = executeFlag;
        newNode->regionGap = 0x0;
        newNode->pageNums = 0x0;
        newNode->ValidAddressEntry.Next = NULL;
    }
    return newNode;
}

PRSL createResultNode(ULONG times, ULONG64 address)
{
    PRSL newNode = (PRSL)ExAllocatePoolWithTag(PagedPool, sizeof(RSL), 'VVVV');
    if(newNode)
    {
        newNode->times = times;
        newNode->address = address;
        newNode->ResultAddressEntry.Flink = NULL;
        newNode->ResultAddressEntry.Blink = NULL;
    }
    return newNode;
}

VOID getRegionGapAndPages(PVAL head)
{
    PVAL temp = head;
    while (temp->ValidAddressEntry.Next != NULL)
    {
        temp->regionGap = temp->endAddress - temp->beginAddress;
        temp->pageNums = (temp->regionGap / 0x1000) + 1;
        temp = CONTAINING_RECORD(temp->ValidAddressEntry.Next, VAL, ValidAddressEntry);
    }
    return;
}

BOOLEAN isSame(PUCHAR A, PUCHAR B, SIZE_T size)
{
    for (size_t j = 0; j < size; j++)
    {
        if (A[j] != B[j])
        {
            return 0;
        }
        else
        {
            continue;
        }
    }
    return 1;
}

VOID printList(PVAL head)
{
    size_t cnt = 0;
    PVAL temp = head;
    while (temp->ValidAddressEntry.Next != NULL)
    {
        cnt++;
        DbgPrint("ListNodeIndex: 0x%llx, begin: 0x%p\t end: 0x%p\t regionGap: 0x%llx\t pageNums: 0x%llx\t memState: %lx\t memProtect: %lx\t", cnt, (PVOID)temp->beginAddress, (PVOID)temp->endAddress, temp->regionGap, temp->pageNums, temp->memoryState, temp->memoryProtectAttributes);
        temp = CONTAINING_RECORD(temp->ValidAddressEntry.Next, VAL, ValidAddressEntry);
    }
    return;
}

ULONG64 getMaxRegionPages(PVAL head)
{
    PVAL temp = head;
    ULONG64 ret = 0x0;
    while (temp->ValidAddressEntry.Next != NULL)
    {
        if (temp->pageNums >= ret)
        {
            ret = temp->pageNums;
        }
        temp = CONTAINING_RECORD(temp->ValidAddressEntry.Next, VAL, ValidAddressEntry);
    }
    return ret;
}

VOID ReadBuffer(PVOID bufferHead, SIZE_T size)
{
    ULONG64 temp = (ULONG64)bufferHead;
    for (size_t j = 0; j < size - 16; j += 16)
    {
        DbgPrint("%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t%hhx\t",
            *(UCHAR*)(temp + j + 0),
            *(UCHAR*)(temp + j + 1),
            *(UCHAR*)(temp + j + 2),
            *(UCHAR*)(temp + j + 3),
            *(UCHAR*)(temp + j + 4),
            *(UCHAR*)(temp + j + 5),
            *(UCHAR*)(temp + j + 6),
            *(UCHAR*)(temp + j + 7),
            *(UCHAR*)(temp + j + 8),
            *(UCHAR*)(temp + j + 9),
            *(UCHAR*)(temp + j + 10),
            *(UCHAR*)(temp + j + 11),
            *(UCHAR*)(temp + j + 12),
            *(UCHAR*)(temp + j + 13),
            *(UCHAR*)(temp + j + 14),
            *(UCHAR*)(temp + j + 15)
        );
    }
}

VOID computeLPSArray(CONST UCHAR* pattern, UL64 M, UL64* lps)
{
    UL64 len = 0;
    lps[0] = 0;
    SIZE_T i = 1;
    while (i < M)
    {
        if (pattern[i] == pattern[len])
        {
            len++;
            lps[i] = len;
            i++;
        }
        else
        {
            if (len != 0)
            {
                len = lps[len - 1];
            }
            else
            {
                lps[i] = len;
                i++;
            }
        }
    }
}

VOID KMP_searchPattern(CONST UCHAR* des, CONST UCHAR* pattern, SIZE_T desLen, SIZE_T patLen, ULONG64 pageBeginAddress, UL64* lpsAddress, PRSL* headRSL)
{
    UL64 M = patLen;
    UL64 N = desLen;
    UL64* lps = (UL64*)ExAllocatePoolWithTag(PagedPool, M * sizeof(UL64),'wwww');
    UL64 j = 0;
    computeLPSArray(pattern, M, lps);
    SIZE_T i = 0;
    while (i < N)
    {
        if (pattern[j] == des[i])
        {
            j++;
            i++;
        }
        if (j == M && lps)
        {
            //DbgPrint("在地址%llx匹配成功\n", (ULONG64)(pageBeginAddress + i - j));
            if (*headRSL == NULL)
            {
                *headRSL = createResultNode(1, (ULONG64)(pageBeginAddress + i - j));
                (*headRSL)->ResultAddressEntry.Flink = &((*headRSL)->ResultAddressEntry);
                (*headRSL)->ResultAddressEntry.Blink = (*headRSL)->ResultAddressEntry.Flink;
            }
            else
            {
                PRSL temp = *headRSL;
                while (temp->ResultAddressEntry.Flink != &((*headRSL)->ResultAddressEntry))
                {
                    temp = CONTAINING_RECORD(temp->ResultAddressEntry.Flink, RSL, ResultAddressEntry);
                }
                PRSL newNode = createResultNode(1, (ULONG64)(pageBeginAddress + i - j));
                temp->ResultAddressEntry.Flink = &newNode->ResultAddressEntry;
                newNode->ResultAddressEntry.Flink = &((*headRSL)->ResultAddressEntry);
                newNode->ResultAddressEntry.Blink = &temp->ResultAddressEntry;
                (*headRSL)->ResultAddressEntry.Blink = &newNode->ResultAddressEntry;
            }
            j = lps[j - 1];
        }
        else if (i < N && pattern[j] != des[i])
        {
            if (j != 0 && lps)
            {
                j = lps[j - 1];
            }
            else
            {
                i = i + 1;
            }
        }
    }
    *lpsAddress = (UL64)lps;
}

VOID printResultLink(PRSL head)
{
    PRSL temp = head;
    while (temp->ResultAddressEntry.Flink != &head->ResultAddressEntry)
    {
        DbgPrint("times: %ld, address: %p", temp->times, (PVOID)temp->address);
        temp = CONTAINING_RECORD(temp->ResultAddressEntry.Flink, RSL, ResultAddressEntry);
    }
    DbgPrint("times: %ld, address: %p", temp->times, (PVOID)temp->address);
}

VOID DriverUnload(PDRIVER_OBJECT DriverObject)
{
    UNREFERENCED_PARAMETER(DriverObject);
}

NTSTATUS DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
    UNREFERENCED_PARAMETER(RegistryPath);
    DriverObject->DriverUnload = DriverUnload;
    HANDLE hProcess = NULL;
    NTSTATUS status;
    CLIENT_ID clientId;
    OBJECT_ATTRIBUTES objAttrs;
    clientId.UniqueProcess = (HANDLE)0x228;
    clientId.UniqueThread = NULL;
    InitializeObjectAttributes(&objAttrs, NULL, 0, NULL, NULL);
    if (!NT_SUCCESS(ZwOpenProcess(&hProcess, GENERIC_ALL, &objAttrs, &clientId)))
    {
        return STATUS_UNSUCCESSFUL;
    }
    MEMORY_INFORMATION_CLASS MIC = MemoryBasicInformation;
    MEMORY_BASIC_INFORMATION mbi = { 0 };
    ULONG64 currentAddress = 0x0;
    PVAL temp = NULL, head = NULL;
    PRSL tempRSL = NULL, headRSL = NULL;
    size_t cnt = 0x0, writeAddressLen = 0x0;
    while (currentAddress <= 0x00007FFF00000000)
    {
        if (NT_SUCCESS(ZwQueryVirtualMemory(hProcess, currentAddress, MIC, &mbi, sizeof(MEMORY_BASIC_INFORMATION), &writeAddressLen)))
        {
            if (mbi.Protect != 0x00 && mbi.Protect != 0x01 && mbi.Protect != 0x104 && mbi.Protect != 0x100)
            {
                if (head == NULL)
                {
                    if (mbi.Protect == 0x10)
                    {
                        PVAL newNode = createNode((UL64)mbi.BaseAddress, (UL64)mbi.BaseAddress + (UL64)mbi.RegionSize - 1, (UL64)mbi.State, (UL64)mbi.Protect, 1);
                        head = newNode;
                    }
                    else
                    {
                        PVAL newNode = createNode((UL64)mbi.BaseAddress, (UL64)mbi.BaseAddress + (UL64)mbi.RegionSize - 1, (UL64)mbi.State, (UL64)mbi.Protect, 0);
                        head = newNode;
                    }
                }
                else
                {
                    temp = head;
                    while (temp->ValidAddressEntry.Next != NULL)
                    {
                        temp = CONTAINING_RECORD(temp->ValidAddressEntry.Next, VAL, ValidAddressEntry);
                    }
                    if (mbi.Protect == 0x10)
                    {
                        PVAL newNode = createNode((UL64)mbi.BaseAddress, (UL64)mbi.BaseAddress + (UL64)mbi.RegionSize - 1, (UL64)mbi.State, (UL64)mbi.Protect, 1);
                        temp->ValidAddressEntry.Next = &newNode->ValidAddressEntry;
                    }
                    else
                    {
                        if (temp->endAddress + 0x1 == (UL64)mbi.BaseAddress)
                        {
                            temp->endAddress += mbi.RegionSize;
                        }
                        else
                        {
                            PVAL newNode = createNode((UL64)mbi.BaseAddress, (UL64)mbi.BaseAddress + (UL64)mbi.RegionSize - 1, (UL64)mbi.State, (UL64)mbi.Protect, 0);
                            temp->ValidAddressEntry.Next = &newNode->ValidAddressEntry;
                        }
                    }
                }
            }
        }
        currentAddress = (ULONG64)mbi.BaseAddress + mbi.RegionSize;
    }
    getRegionGapAndPages(head);
    //printList(head);
    ZwClose(hProcess);
    PEPROCESS pe = NULL;
    ULONG64 maxPagesNum = getMaxRegionPages(head);
    DbgPrint("maxPages: %llu", maxPagesNum);
    UCHAR pattern[13] = { 0x32,0x30, 0x31, 0x39, 0x33, 0x30, 0x39, 0x30, 0x31, 0x30, 0x31, 0x32, 0x30 };
    PsLookupProcessByProcessId((HANDLE)clientId.UniqueProcess, &pe);
    KAPC_STATE apc = { 0 };
    temp = head;
    while(temp->ValidAddressEntry.Next != NULL)
    {
        KeStackAttachProcess(pe, &apc);
        UCHAR* bufferReceive = (UCHAR*)ExAllocatePoolWithTag(PagedPool, temp->pageNums * 4096, 'TTTT');
        UL64 addressNeedFree = 0x0;
        __try
        {
            memcpy(bufferReceive, temp->beginAddress, temp->pageNums * 4096);
        }
        __except (1)
        {
            KeUnstackDetachProcess(&apc);
            ObDereferenceObject(pe);
            ExFreePool(bufferReceive);
        }
        KeUnstackDetachProcess(&apc);
        ObDereferenceObject(pe);
        KMP_searchPattern(bufferReceive, pattern, temp->pageNums * 4096, 13, temp->beginAddress, &addressNeedFree, &headRSL);
        ExFreePool(addressNeedFree); addressNeedFree = NULL;
        ExFreePool(bufferReceive); bufferReceive = NULL;
        temp = CONTAINING_RECORD(temp->ValidAddressEntry.Next, VAL, ValidAddressEntry);
    }
    printResultLink(headRSL);
    //free double-linked list
    tempRSL = headRSL;
    while (temp != NULL && tempRSL->ResultAddressEntry.Flink != NULL)
    {
        //一定要有temp != NULL这句！因为当temp == NULL的时候，tempRSL->ResultAddressEntry.Flink != NULL隐含了一个指针访问操作，会蓝屏！！
        PRSL tempX = CONTAINING_RECORD(tempRSL->ResultAddressEntry.Flink, RSL, ResultAddressEntry);
        tempRSL->ResultAddressEntry.Flink = NULL;
        tempRSL->ResultAddressEntry.Blink = NULL;
        ExFreePool(tempRSL); tempRSL = NULL;
        tempRSL = tempX;
    }
    temp = head;
    //free single-linked list
    while (temp != NULL && temp->ValidAddressEntry.Next != NULL)
    {
        PVAL tempX = CONTAINING_RECORD(temp->ValidAddressEntry.Next, VAL, ValidAddressEntry);
        ExFreePool(temp); temp = NULL;
        temp = tempX;
    }
    return STATUS_SUCCESS;
}

m0_50198957
关注
深入理解Linux 内核 内存管理（上）
charlie114514191的博客
05-03 1109
RAM中，剩下的自由部分被称为动态内存！因为这不仅是内进程所需要的宝贵资源，也是内核执行本身所需要的宝贵资源！实际上整个系统的性能都高度取决于如何有效的管理动态内存！因此内存管理是操作系统中非常重要的话题之一！
【内核链表】数据结构——深入理解内核链表的概念和操作&笔记
皮皮不调皮的博客
03-24 4119
内核链表一、内核链表的前置概念1、容器2、通用解决方案二、通用型链表节点的设计1、初始化2、增删操作3、查找节点4、遍历链表5、示例代码三、内核链表1、普通链表弊端2、内核链表2.1内核链表结构2.2内核链表的节点设计2.3内核链表的相关函数1）内核链表的初始化—— INIT_LIST_HEAD2）插入节点3）内核链表的遍历——list_for_each_entry（宏函数 就是一个for循环）4）内核链表节点删除——list_del5）内核链表的销毁——先把除了头结点的所有地址是否，最后释放头结点6）示例
[Windows内核源码分析4] 引导过程(Phase1部分分析)
輚至消亡
10-10 869
后查看当前处理器的线程链表中是否有需要运行的线程，如果没有就让当前处理器运行Idle线程。接着就返回准备执行阶段1的初始化工作线程。后首先调用HalAllProcessorsStarted通过HAL硬件抽象层所有处理器已经初始化完，接着就对对象管理器, 执行体管理器, 调试器管理器, 安全管理器的阶段1的初始化以及调用。下面来继续分析，首先来看看现在的调用栈, 当我们从Phase0的初始化返回时的调用栈如下。由于阶段1的初始化内容比较多，这里仅做对整体的流程分析，其中的细节之后会写文章继续分析。
Linux内核的SLAB内存管理机制
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
01-27 1236
Linux内核的SLAB内存管理机制
深入理解linux内核-内存管理-内存管理
x13262608581的博客
07-29 929
节点、管理区、页框分配器--伙伴系统、每cpu缓存、内存分配器--slab机制、内存池 、32位下高地址线性区划分--直接映射区，vmalloc区域，永久内核映射，固定映射
Spark内核之内存管理
Markble
09-17 6596
目录 一、堆内内存和堆外内存 二、内存空间分配 2.1 早期内存管理（静态内存管理） 2.2 统一内存管理 2.3 同一管理内存的优点 三、存储内存管理 3.1 RDD的持久化机制 3.2RDD的缓存过程 3.3 淘汰与落盘 四、执行内存管理 4.1 Shuffle Write 4.2 Shuffle Read 一、堆内内存和堆外内存 --1. "堆内内存"： 是指jvm所能使用的内存，并不是完全可以控制，如GC垃圾回收器的执行时间是不可控的，当你需要.
Windows内核研究总结
热门推荐
bcbobo21cn的专栏
02-05 1万+
Windows 的体系结构 分析环境reactos0.3.1 ，i386体系] 了解了windows的体系结构才知道reactos到底要干什么，以及如何干，因为reactos的目标是兼容windows。 下面是windows的体系结构： 这是整个windows的体系结构的总览。从图上可以看出系统被分成内核模式和用户模式。 内核模式的构成文件是系
Windows核心编程 第三章 内核对象
天使也掉毛
08-23 1235
Windows核心编程 第三章 内核对象
Linux内核内存相关问题，这一篇让你彻底了解
嵌入式Linux内核的博客
02-25 760
直接内存访问是一种硬件机制，它允许外围设备和主内存之间直接传输它们的 I/O 数据，而不需要系统处理器的参与2) DMA 控制器的功能能向 CPU 发出系统保持（HOLD）信号，提出总线接管请求当 CPU 发出允许接管信号后，负责对总线的控制，进入 DMA 方式能对存储器寻址及能修改地址指针，实现对内存的读写操作能决定本次 DMA 传送的字节数，判断 DMA 传送是否结束发出 DMA 结束信号，使 CPU 恢复正常工作状态。
WIndows内核学习笔记：分页机制——PAE分页模式
weixin_38526180的博客
07-21 3286
Chapter 4 Paging 4.1 分页模式和控制位 分页控制有关的寄存器 CR0 标志位：WP（bit 16）、PG（bit 31） CR4 标志位：PSE（bit 4）、PAE（bit 5）、PGE（bit 7）、PCIDE（bit 17）、SMEP（bit 20）、SMAP（bit 21）、PKE（bit 22）、CET（bit 23）、PKS（bit 24） IA32_EFER MSR 标志位：LEM（bit 8）、NXE（bit 11) EFLAGS 标志位：AC（
Rust OS Dev消息队列和动态内存分配、微内核操作系统开发等方面的最佳实践
AI天才研究院
07-29 1365
自从20年前开源界流行了Linux操作系统后，有很多企业也纷纷转向Linux操作系统，原因之一就是开源社区的强大生态，尤其是Rust语言的发明和广泛应用。然而，面对Rust语言带来的高效率和安全性，一些公司却觉得这种高性能和安全性无法完全体现出来，并且也因此想开发一款基于Rust语言和 Linux 内核 的操作系统。此时，基于微内核模式的操作系统诞生了，可以满足更多复杂场景下的系统需求。消息队列和动态内存分配、微内核操作系统等方面就是微内核操作系统开发最重要的部分。本文将主要讨论这些方面的最佳实践。
Windows内存管理与文件处理教程完整版
通过这些编程实例，可以加深对Windows内存和文件处理机制的认识，并在实际项目中应用所学知识。 【注意】本资源摘要基于文件名和描述信息进行推测，具体资源内容需用户下载后详细查阅。由于实际文件内容未知，无法...
Linux内存管理（一）：内存与内存管理机制
私房菜
06-24 1072
在操作系统还没有出现之前，程序存放在纸带上，计算机读取一张纸带就运行一条指令，这种从外部存储介质上直接运行指令的方法效率很低。后来出现了内存存储器，也就是说，程序要运行，首先要加载，然后执行，这就是所谓的 “存储的程序”。这一概念开启了操作系统快速发展的同道，直至后来出现了分页机制。在这个演变的历史过程中，出现了不少内存管理的机制。 这种动态分区法，在最开始的时候是好的，但随着时间的推移会出现很多内存空洞，内存的利用率会随之下降，这些内存空洞就是我们常说的内存碎片。为了解决碎片化的问题，操作系统需要动态地移
set的基本用法 和 底层简单了解
2302_80253411的博客
10-10 1028
set的声明如下，T就是set底层关键字的类型（可以把T 当作key）set默认要求T支持小于比较，如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模版参数set底层存储数据的内存是从空间配置器申请的，如果需要可以⾃⼰实现内存池，传给第三个参数。⼀般情况下，我们都不需要传后两个模版参数。set底层是⽤红⿊树实现，增删查效率是 ，迭代器遍历是⾛的搜索树的中序，所以是有序的。O(logN)
【华为】静态路由配置
weixin_51302020的博客
10-10 1088
1.配置接入层：LSW1（LSW3同理）:in g0/0/1in g0/0/2in g0/0/242.配置汇聚层，设置网关，实现不同vlan之间的通信：LSW2（LSW4同理）:in vlan 10in valn 20in g0/0/13.配置DHCP:LSW2（LSW4同理）:in vlan 10in vlan 20另一种配置dhcp方式（不用配置地址池）：in vlan 10。
Java 循环里怎么删除元素才安全
大东码字
10-11 369
在 Java 中，当你在循环中遍历集合时，直接删除元素可能会引发。这种方法不会在遍历中直接删除元素，而是创建一个新的过滤后的集合。为了安全地删除元素，推荐使用。
DS线性表之带头双向循环链表的讲解和实现(3)
最新发布
tan180°的博客
10-14 861
前文所讲的是不带头单向不循环链表，三个条件都相反的带头循环链表就是我们今天所要讲的内容它也很常用，所以我们有必要好好了解它一下我们发现此链表虽然听起来复杂，但是实现起来竟然比单链表好很多，这其实启发我们不要被事物的表面所吓到，说不定再撑一会儿，就拨云见日了呢~
遍历有向图链路（DFS算法）- 优化版
m0_37978198的博客
10-10 596
计算有向图链路方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值