栈回溯法的一个例子

最新推荐文章于 2021-05-31 10:44:46 发布
最新推荐文章于 2021-05-31 10:44:46 发布
阅读量80 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/kedebug/archive/2010/12/22/2791748.html
版权

看了几个例子，一般都是在ExAllocatePoolWithTag这里挂钩啊，根据MemoryTag来判断，以后再发现发现有没有更精准的挂钩位置

#include <ntddk.h>
#include <windef.h>
#include <stdio.h>
#include <string.h>
#include "MmLoadSystemImage.h"


#define pwszModuleName L"ntoskrnl.exe" //这里只考虑单核的情况

#define ObjectNameInformation  1

UCHAR oldcode[5]={0};
UCHAR jmpcode[5]={0xE9,0x00,0x00,0x00,0x00};

ULONG g_ntoskrnl_addr=0;

ULONG g_ntoskrnl_size=0;

ULONG oldExAllocatePoolWithTagaddr=0;

ULONG Address_MmLoadSystemImage=0;//通过栈回溯（技术难点）得到MmLoadSystemImage函数的地址

/*
这里说明一下原先通过东方微点的Mp110003的驱动是通过Hook KeWaitForSingleObject,
然后通过栈回溯来找到MmLoadSystemImage的地址，但是通过我跟踪堆栈调用,
发现要经过很多次KeWaitForSingleObject调用，才会进入到
    KeWaitForSingleObject
    MmLoadSystemImage
    NtSetSystemInformation
    nt!KiFastCallEntry
    nt!ZwSetSystemInformation
反正是猥琐，我就更猥琐，大米兄就是这么干的，调用流程中来找到MmLoadSystemImage地址，调用过程如下：
    ExAllocatePoolWithTag
    MmLoadSystemImage
    NtSetSystemInformation
    nt!KiFastCallEntry
    nt!ZwSetSystemInformation
因此我直接HOOK ExAllocatePoolWithTag来进行栈回溯
*/
__declspec(naked) PVOID fake_ExAllocatePoolWithTag(
    IN POOL_TYPE  PoolType,
    IN SIZE_T  NumberOfBytes,
    IN ULONG  Tag)
{
    ULONG *PEBP;

    _asm{
        mov  edi,edi
        push ebp    
        mov  ebp,esp
        mov eax,[ebp+0xc] //参数是NumberOfBytes
        cmp eax,0x100
        jnz end
        mov eax,[ebp+0x10] //第三个参数Tag
        cmp eax,0x6E4C6D4D //标志为"nLmM",也就是MmLoadSystemImage装载的镜像标志
        jnz end 

        mov eax,[ebp]  //堆栈回溯的原理
        mov eax,[eax+4]
        push eax        //上一个函数的地址
        call StackTrace_for_ExAllocatePoolWithTag    
end:
        mov  eax,oldExAllocatePoolWithTagaddr
        add  eax,5
        jmp  eax
    }
}

//通过栈回溯找到 
ULONG StackTrace_for_ExAllocatePoolWithTag(ULONG RetAddress)
{
    ULONG CallAddress=0;
    ULONG JmpOffset=0;

    if (RetAddress)
    {
        CallAddress=(ULONG)RetAddress-  5 ;//Ret --->call Address
        //跳转的偏移量
        JmpOffset=*(ULONG*)((PUCHAR)CallAddress+1); //(PUCHAR)CallAddress+1--->指针CallAddress往后走一位,(PULONG)CallAddress+1,指针CallAddress往后走（sizeof(ULONG)=4）字节
        //MmLoadSystemImage函数的地址
        Address_MmLoadSystemImage=(ULONG)CallAddress + 5 +JmpOffset;
        KdPrint(("MmLoadSystemImage Address=0x%x/n",Address_MmLoadSystemImage));
        //加入判定如果ntoskrnl.Base<Address_MmLoadSystemImage<ntoskrnl.Base+size,则说明可以进行inlineHook_MmLoadSystemImage()
        if (Address_MmLoadSystemImage>g_ntoskrnl_addr&&Address_MmLoadSystemImage<(g_ntoskrnl_addr+g_ntoskrnl_size))
        {
            unlineHook_ExAllocatePoolWithTag(); 
            inlineHook_MmLoadSystemImage(); 
            KdPrint(("inlineHook MmLoadSystemImage Success!")); 
        }   
    }
    return 0;    
}



__declspec(naked) NTSTATUS OrigiMmLoadSystemImage(
    IN PUNICODE_STRING ImageFileName,
    IN PUNICODE_STRING NamePrefix OPTIONAL,
    IN PUNICODE_STRING LoadedBaseName OPTIONAL,
    IN ULONG LoadFlags,
    OUT PVOID *ImageHandle,
    OUT PVOID *ImageBaseAddress)
{
    __asm{
        push 174h 
        mov eax,Address_MmLoadSystemImage
        add eax,5
        jmp eax 
    }
}



//拦截驱动的过程
NTSTATUS fake_MmLoadSystemImage(
                                IN PUNICODE_STRING ImageFileName,
                                IN PUNICODE_STRING NamePrefix OPTIONAL,
                                IN PUNICODE_STRING LoadedBaseName OPTIONAL,
                                IN ULONG LoadFlags,
                                OUT PVOID *ImageHandle,
                                OUT PVOID *ImageBaseAddress)
{
    ANSI_STRING ImageName;

    RtlUnicodeStringToAnsiString(&ImageName,ImageFileName,TRUE);

    KdPrint(("MmLoadSystemImage LoadDriver :%s/n",ImageName.Buffer));

    return OrigiMmLoadSystemImage(ImageFileName,
        NamePrefix,
        LoadFlags,
        LoadFlags,
        ImageHandle,
        ImageBaseAddress);

}



NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject,IN PIRP Irp)
{
    NTSTATUS status;

    PEPROCESS crsEProc; 
    ANSI_STRING TestSysName;
    SYSTEM_LOAD_AND_CALL_IMAGE sysImage;

    DriverObject->DriverUnload=DriverUnload;
    status=PsLookupProcessByProcessId((ULONG)GetCsrPid(),&crsEProc); 
    if (!NT_SUCCESS(status))
    {
        KdPrint(("PsLookupProcessByProcessId() error/n"));
        return status;
    }   

    //通过DriverObject->DriverSection获得加载驱动的模块
    if (GetBase((ULONG)DriverObject)&&inlineHook_ExAllocatePoolWithTag())
    {
        //下面是调用ZwSetSystemInformation来加载驱动，从而引发跳转到fake_ExAllocatePoolWithTag中,先依附进csrss.exe,再加载测试驱动
        KeAttachProcess(crsEProc);
        //加载测试驱动; 
        RtlInitAnsiString(&TestSysName,"//??//c://Hooksys.sys");
        RtlAnsiStringToUnicodeString(&(sysImage.ModuleName),&TestSysName,TRUE);
        status= ZwSetSystemInformation(SystemExtendServiceTableInformation,&sysImage,sizeof(sysImage));
        if (!NT_SUCCESS(status))
        {         
            KdPrint(("Driver STATUS=0X%x/n",status));
        }

        KeDetachProcess();  
    }

    return STATUS_SUCCESS;
}

NTSTATUS DriverUnload(IN PDRIVER_OBJECT DriverObject )
{

    unlineHook_MmLoadSystemImage();
    KdPrint(("DriverUnload!/n"));
    return   STATUS_SUCCESS;

}


//得到模块的基址和映像大小
int GetBase(IN ULONG  EntryAddress)
{
    ULONG  listHead;
    ULONG  currentList;
    ULONG  NameAddress;
    int reault=0;

    listHead=*(ULONG*)(EntryAddress+0x14);
    currentList=*(ULONG*)(listHead+0x4); //Blink


    if (currentList!=listHead)
    {
        while (1)
        {      
            NameAddress=*(ULONG*)(currentList+0x030); 
            if ((PCWSTR)NameAddress!=NULL)
            {
                KdPrint(("ModuleName=%ws/n",(PCWSTR)NameAddress));
            }

            if(!_wcsicmp((PCWSTR)NameAddress,pwszModuleName))
            {
                g_ntoskrnl_addr=*(ULONG*)(currentList+0x18);
                g_ntoskrnl_size=*(ULONG*)(currentList+0x20);
                KdPrint(("ntoskrnl.exe [base]=0x%X,[size]=0x%X/n",g_ntoskrnl_addr,g_ntoskrnl_size));
                reault=1;
                break;
            }

            currentList=*(DWORD*)(currentList + 0x4);//下一个Blink 
            if (currentList == listHead)
            {
                KdPrint(("链表查询结束!/n"));
                break;
            }

        }      
    }

    return reault;

}

PVOID GetInfoTable(ULONG ATableType)
{
    ULONG mSize=0x4000;
    PVOID mPtr=NULL;
    NTSTATUS status;

    do 
    {
        mPtr=ExAllocatePool(PagedPool,mSize);
        memset(mPtr, 0, mSize);
        if (mPtr)
        {
            status = ZwQuerySystemInformation(ATableType,mPtr,mSize,NULL);
        }else
            return NULL;
        if (status == STATUS_INFO_LENGTH_MISMATCH)
        {
            ExFreePool(mPtr);
            mSize *=2;
        }  
    } while(status == STATUS_INFO_LENGTH_MISMATCH);

    if (status == STATUS_SUCCESS)
        return mPtr;

    ExFreePool(mPtr);
    return NULL;  
}


//得到csrss.exe的PID
HANDLE GetCsrPid()
{
    HANDLE Process,hObject;
    HANDLE CsrssId=(HANDLE)0;
    OBJECT_ATTRIBUTES obj;
    CLIENT_ID cid;
    UCHAR buff[0x100];
    POBJECT_NAME_INFORMATION objName=(PVOID)&buff;
    PSYSTEM_HANDLE_INFORMATION_EX Handles;
    ULONG i;


    Handles=GetInfoTable(SystemHandleInformation);
    if (!Handles) return CsrssId;

    for (i=0;i<Handles->NumberOfHandles;i++)
    {
        if (Handles->Information[i].ObjectTypeNumber == 21)
        {
            InitializeObjectAttributes(&obj,NULL,OBJ_KERNEL_HANDLE,NULL,NULL);
            cid.UniqueProcess=(HANDLE)Handles->Information[i].ProcessId;
            cid.UniqueThread = 0;

            if (NT_SUCCESS(NtOpenProcess(&Process,PROCESS_DUP_HANDLE,&obj,&cid)))
            {
                if (NT_SUCCESS(ZwDuplicateObject(Process,(HANDLE)Handles->Information[i].Handle,NtCurrentProcess(),&hObject,0,0,DUPLICATE_SAME_ACCESS)))
                {
                    if (NT_SUCCESS(ZwQueryObject(hObject, ObjectNameInformation, objName, 0x100, NULL)))
                    {
                        if (objName->Name.Buffer&& !wcsncmp(L"//Windows//ApiPort",objName->Name.Buffer,20))
                        {

                            CsrssId=(HANDLE)Handles->Information[i].ProcessId;

                        }

                    }     
                    ZwClose(hObject); 
                }

                ZwClose(Process);
            }    

        }

    }

    ExFreePool(Handles);

    return CsrssId;
}


//inline Hook ExAllocatePoolWithTag
BOOLEAN inlineHook_ExAllocatePoolWithTag()
{
    KIRQL  oldIrql;
    DWORD distance; 
    UNICODE_STRING unamestr;
    BOOLEAN result;

    RtlInitUnicodeString(&unamestr,L"ExAllocatePoolWithTag");
    oldExAllocatePoolWithTagaddr=(ULONG)MmGetSystemRoutineAddress(&unamestr);
    if (oldExAllocatePoolWithTagaddr)
    {
        //保存原来开始的5个字节
        RtlCopyMemory(oldcode,(BYTE*)oldExAllocatePoolWithTagaddr,5); 
        distance=(BYTE*)fake_ExAllocatePoolWithTag - (BYTE*)oldExAllocatePoolWithTagaddr -5;
        RtlCopyMemory(jmpcode+1,&distance,4);
        WPOff();
        oldIrql=KeRaiseIrqlToDpcLevel();
        RtlCopyMemory((BYTE*)oldExAllocatePoolWithTagaddr,jmpcode,5);
        KeLowerIrql(oldIrql);
        WPOn();
        result=TRUE;  
    } else
        result=FALSE;

    return result;
}


VOID unlineHook_ExAllocatePoolWithTag()
{
    KIRQL  oldIrql;

    WPOff();
    oldIrql=KeRaiseIrqlToDpcLevel();
    RtlCopyMemory((BYTE*)oldExAllocatePoolWithTagaddr,oldcode,5);
    KeLowerIrql(oldIrql);
    WPOn();

    return;
}


BOOLEAN inlineHook_MmLoadSystemImage()
{
    KIRQL  oldIrql;
    DWORD distance;  
    BOOLEAN result;

    if (Address_MmLoadSystemImage)
    {
        //保存原来开始的5个字节
        RtlCopyMemory(oldcode,(BYTE*)Address_MmLoadSystemImage,5);
        distance=(BYTE*)fake_MmLoadSystemImage - Address_MmLoadSystemImage -5;
        RtlCopyMemory(jmpcode+1,&distance,4);
        WPOff();
        oldIrql=KeRaiseIrqlToDpcLevel();
        RtlCopyMemory((BYTE*)Address_MmLoadSystemImage,jmpcode,5);
        KeLowerIrql(oldIrql);
        WPOn();
        result=TRUE;

    }else
        result=FALSE;

    return result;
}

VOID unlineHook_MmLoadSystemImage()
{
    KIRQL  oldIrql;

    WPOff();
    oldIrql=KeRaiseIrqlToDpcLevel();
    RtlCopyMemory((BYTE*)Address_MmLoadSystemImage,oldcode,5);
    KeLowerIrql(oldIrql);
    WPOn();

    return;




}




VOID WPOn()
{
    __asm {
        mov eax,cr0
        or eax,0x10000
        mov cr0,eax
        STI
    }

}

VOID WPOff()
{
    __asm{
        cli  
        mov eax, cr0
        and eax,not 0x10000
        mov cr0,eax
    }

}

 

转载于:https://www.cnblogs.com/kedebug/archive/2010/12/22/2791748.html

weixin_30425949
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
回溯法大成！以回溯法实现栈的出栈情况的遍历为例子，轻松帮你深刻领悟回溯法
qq_36523667的博客
11-19 1891
这里用回溯法实现了 栈的出栈情况的遍历 。虽然这个题有更好的做法，但是你如果用回溯法做这道题，做完后一定会对回溯法有这更高境界的领悟，而且在整个设计算法，debug算法的过程中会感受到一种酣畅淋漓的快感。因为这个题看似很小，其实规模很大，要考虑方方面面的问题，很多很多。 上题。 输入一个序列 比如 123。你进栈的顺序必须是按照这个序列来，但是你可以这样，进1，然后在2进入前，把1出栈
通过应用范例学习回溯法的设计策略
07-28
1. **装载问题**：这是一个经典的回溯法应用例子，例如，给定一定数量和重量的物品，目标是在不超过给定承重限制的情况下，使装载物品的总价值最大。回溯法在此问题中的应用是通过尝试不同的物品组合，逐步构建解决...
回溯用栈实现
chengpodu0934的博客
06-23 864
回溯用栈实现的4个重要点： 1.回溯的结束条件：栈为空的时候 2.回溯的条件：也即出栈的条件 3.回溯算法深入时候的条件：也即入栈的条件 4.回溯算法深入的状态个数：这个看具体情况 这里拿正整数有序分拆来看一下： #include <stdio.h> ...
MazePath 迷宫问题求解（回溯法） 用栈解决
XXisCC的博客
04-12 1472
MazePass 迷宫问题求解（回溯法） 问题描述： 实验内容与要求： 迷宫只有两个门，一个叫做入口，另一个叫做出口。把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫。迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。求解迷宫问题，即找出从入口到出口的路径。 知识要点： 迷宫问题是栈应用的一个典型例子。求解过程可采用回溯法。回溯法是一种不断试探且及时纠正错误的搜索方法。从入口出发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到
栈结构应用－试探回溯法
ZerinHwang
01-11 512
试探回溯法的具体内容就不赘述了，谈谈栈结构在其中起到的作用 在书中提到一个神话故事：忒修斯的法宝，这个法宝是进入迷宫时使用的绳子，用于记录从迷宫的起点到当前位置所走过的路径，以防止在迷宫中迷茫，找不到来时的路。而将试探回溯法类比到这个迷宫问题时，这个栈结构起到的就相当于绳子的作用。 考虑栈结构更高效的原因，从不采用栈结构而是其它数据结构来记录走过的路径的效果对比着来看。（注意，这里采用某一数据...
arm linux 栈帧,arm 栈帧/栈回溯/栈帧回溯 相关
weixin_30491017的博客
05-13 671
arm平台的调用栈回溯(backtrace)title: arm平台的调用栈回溯(backtrace)date: 2018-09-19 16:07:47tags:介绍arm平台的调用栈与x86平台的调用栈大致相同，稍微有些区别，主要在于栈帧的压栈内容和传参方式不同。在arm平台的不同程序，采用的编译选项不同，程序运行期间的栈帧也会不同。有些工具在对arm的调用栈回溯时，可能会遇到无法回溯的情况。例...
回溯法.pdf
04-16
回溯法是一种在解决问题时采用试探性方法的算法策略，尤其适用于解决决策树搜索问题，如0-1背包问题、图的着色问题、八皇后问题等。它通过尝试构建问题的所有可能解来寻找最优解，同时利用剪枝技术避免无效的搜索，...
算法设计与分析回溯法PPT学习教案.pptx
10-05
回溯法的一个关键特征是动态生成解空间，仅存储从根节点到当前扩展节点的路径，降低了所需的存储空间。 回溯法有两种常见的实现方式：递归回溯和迭代回溯。递归回溯是直接利用函数递归实现深度优先搜索，而迭代回溯...
回溯&搜索 经典例子及详细代码与讲解
10-04
标题提及的“八皇后问题”是一个经典的回溯法应用实例。八皇后问题是在一个8×8的棋盘上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一对角线上，问有多少种不同的摆法。这是一个...
关于回溯算法的几个示例
03-14
回溯算法会尝试所有可能的硬币组合，从最大面额的硬币开始，如果当前面额的硬币无法完全覆盖目标金额，则尝试下一个小面额的硬币。当达到目标金额或者硬币用完时，就找到了一种解决方案。如果找不到满足条件的组合，...
Windows NT引导过程源代码分析（三）
hnzwx888的专栏
06-20 1048
1.3建立用户登录会话 Windows内核在阶段1初始化的最后，启动了一个用户模式进程——会话管理器子系统（smss）。Smss进程是Windows操作系统的关键组成部分，它尽管是一个用户模式进程，但有其特殊性：首先，它是可信的，这意味着它可以做一些其他用户进程无法做的事情，比如创建安全令牌；其次，它直接建立在Windows内核的基础上，只使用Windows内核提供的系统服务，...
windows内核情景分析---设备驱动
maomao171314的专栏
04-04 1813
设备驱动 设备栈：从上层到下层的顺序依次是:过滤设备、类设备、过滤设备、小端口设备【过、类、过滤、小端口】 驱动栈：因设备堆栈原因而建立起来的一种堆栈  老式驱动：指不提供AddDevice的驱动，又叫NT式驱动 Wdm驱动：指提供了AddDevice的驱动 驱动初始化：指IO管理器加载驱动后，调用驱动的DriverEntry、AddDevice函数 设备栈中上层设备与下层设备的绑定关
隐藏驱动完整攻略(猥琐篇)
blackbean的专栏
09-20 4390
基础篇里说的那些东西搞完以后，任何正常的位置都找不到我们的Driver了，此时相应的手段基本上只剩下暴搜PE镜像或暴搜DriverObject了。而且，基础篇讲的那些东西，因为都是M$定好的一些格式和位置，代码怎么写都差不多，固定的路子而已。而抹PE镜像或抹DriverObjec
教材性质的病毒代码（ＡＳＭ）
04-25 2981
 ＶＩＲＵＳ　ＣＯＤＥ　ＢＹ　ＶＸＫ／Ｃ．Ｖ．Ｃ.586.modelflatOption Casemap :None includeuseful.incinclude win32.incincludemz.incincludepe.inc.Data <!--google_ad_client = "pub-9375039986094315";google_ad_width = 468
迷宫问题——回溯法（栈）C++
weixin_45887823的博客
05-31 1529
迷宫问题——回溯法（栈）C++ #include <iostream> #include <stack> using namespace std; //栈节点 typedef struct node { int x; //迷宫数组横坐标 int y; //迷宫数组纵坐标 int c; //前进方向 }StackNode; //linkstack top[n1*n2]; //初始化迷宫数组 const
Win内核使用线程同步事件例子
qq_18811919的博客
11-06 116
#include<ntddk.h> #include<ntstrsafe.h> //提供一个Unload函数只是为了让这个程序能动态卸载 VOID DriverUnload(PDRIVER_OBJECT driver) { DbgPrint("first:Our driver is unloading...\r\n"); } struct ThreadStruct { HANDLE ThreadHandle[20];//线程句柄 UNICODE_STRING str; N
WinDBG调试驱动时中断DriverEntry的方法
06-29 335
1.无符号文件的驱动中断DriverEntry方法一: 在加载驱动之前,先使用设置异常命令sxe,设置加载驱动文件时中断. 命令格式:sxe ld <驱动文件名> 加载驱动中断后,使用lm命令查看驱动模块的基址. 命令格式:lm m <驱动文件名> 通过计算PE文件入口点地址,得到DriverEntry的地址. 计算公式如下...
ZwQuerySystemInformation 查看系统进程信息
anhkgg的专栏
09-03 1071
ZwQuerySystemInformation 查看系统进程信息 [cpp] view plaincopyprint? #include typedef enum _SYSTEM_INFORMATION_CLASS { SystemBasicInformation, SystemProcessorInformation, SystemP
每日一题39-组合总和
weixin_46398446的博客
02-15 241
1.题目详情 给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。 2.解题思路 没什么好的思路，只能通过部分测试用例，看了题解 完整题解 回溯算法+剪枝解答 3.代码实现 class Solution: def combinationSum(self, candida
回溯法解题三步法：深度优先搜索与剪枝策略
回溯法是一种常用的搜索算法，在C语言课程中尤其常见，用于解决那些具有约束条件的组合优化问题。它的核心在于通过深度优先搜索...回溯法是C语言编程中一个强大而实用的工具，对于理解和解决复杂组合优化问题至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值