鱼C论坛

 找回密码
 立即注册
查看: 2134|回复: 2

[Windows] 【进阶】《windows内核安全与驱动开发》

[复制链接]
最佳答案
214 
发表于 2016-11-19 17:40:12 | 显示全部楼层 |阅读模式

马上注册加入鱼C,享用更多服务吧^_^

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
TB1eC4MIFXXXXaOXpXXXXXXXXXX_!!0-item_pic.jpg_430x430q90.jpg

6 g/ \) l  T$ o+ O9 N* z) k! S  L0 y
书名:《windows内核安全与驱动开发》
2 ?% X; Z( e9 B7 I作者:谭文;陈铭霖
# L/ @2 B! h: O& U出版社:电子工业出版社
6 D! z% \. c( b& T; I出版年:2015年6月1日(第1版)
' j/ m3 R/ |) [0 e4 A$ @- J定价:139.00元
) ?: ~( _3 T: @9 N7 s3 W  B, r0 ?8 ~装帧:平装
) G  {5 H! x& f6 P8 mISBN:9787121262159
3 ~" [6 ], L1 T: Z+ Y' T
  I9 D% b$ i  Z8 o& a购买链接:$ z$ m% P' I( C% y/ u( c* Q) Z
# u3 }6 Q$ q4 E. A+ Z


) h5 n) t/ `# R# K, B' M4 `亚马逊 -> 传送门  ?9 N+ i" B2 t- Z1 O5 P% D' S

7 [# `# b* l7 g! v7 Y+ ]当当网 -> 传送门7 K# H' C3 F" `+ P2 g
" S. I' A# g3 w; k
京东 -> 传送门
9 O  _  {9 ]# J) Y/ J: r' r8 \+ I- u2 D7 z% P
天猫 -> 传送门8 n& ]9 n4 u2 ]2 r
4 G; f# s' G6 K4 T
9 i5 G7 a/ P# W" Y
内容简介:2 B" B1 I) K" y5 s1 V
* a& |% |  ^+ [$ J2 a0 C4 U8 h$ e


; Q: v6 w2 P6 ^/ B2 _, S7 V本书的前身是《天书夜读——从汇编语言到Windows内核编程》和《寒江独钓——Windows内核安全编程》。与 Windows 客户端安全软件开发相关的驱动程序开发是本书的主题。书中的程序使用环境从 32 位到 64 位,从 Windows XP 到 Windows 8 都有涉及,大部分程序不经过修改即可在 Windows 10 上运行。同时本书也深入浅出地介绍了进行内核安全编程所需要的操作系统、汇编等基础知识。6 G0 G( u2 `& C6 }) P5 F% |

; j  T1 V( _3 n2 O本书共分三篇,基础篇囊括了驱动开发的基础知识,降低了入门的难度;开发篇介绍了在实际工作中可能遇到的各种开发需求的技术实现,包括:串口的过滤、键盘的过滤、磁盘的虚拟、磁盘的过滤、文件系统的过滤与监控、文件系统透明加密、文件系统微过滤驱动、网络传输层过滤、Windows 过滤平台、NDIS 协议驱动、NDIS 小端口驱动、NDIS 中间层驱动、IA-32 汇编基础、IA-32 体系中的内存地址、处理器权限级别切换、IA-32 体系结构中的中断和 Windows 内核挂钩;高级篇包含了汇编语言、操作系统原理、处理器体系架构相关的内容。本书是由长期从事这个行业的工程师自己写的,所以处处以实用为准。对细节的考究主要体现在对实际问题的解决,而不是知识的详尽程度上。
) F# x2 c' k% ~' A3 ], e% u7 x; h% V* |' g( S$ j5 U! d
目录:9 p0 A5 }! C$ V) N- G! f, u0 m

0 _& [, O6 q. Y  a

' V" C$ V- a9 f9 T! u7 Q基 础 篇 + T' O: ~: m+ W3 `2 z. I7 w
0 `$ O' y- a0 N7 M( g, e) p
第1章 内核上机指导2 1 q; R! N- T$ Z" |& Q6 ]( @2 j
% L* Z4 @* Z) F
1.1 下载和使用WDK2 5 U, q, a2 |. L( u  a' K- a' S
1.1.1 下载并安装WDK2
# U. r  m1 f" c* h7 `. Q1.1.2 编写第一个C文件4
: N0 \6 J  B) J6 s1.1.3 编译一个工程5
. i' k% K* m0 |, T& L7 w) N1.2 安装与运行6
. l/ h4 L4 c' M( w' M1.2.1 下载一个安装工具6 4 M" m. x0 F$ U9 l( `
1.2.2 运行与查看输出信息7 6 i$ {# l, z* J0 V% R
1.2.3 在虚拟机中运行8 " \3 E5 ^- s/ I  s2 J2 z
1.3 调试内核模块9
. n7 r& [/ u6 e4 C2 D# t& {( h, a1.3.1 下载和安装WinDbg9 5 Y4 ^; y# ^& d  n4 l7 Y' j! h
1.3.2 设置Windows XP调试执行9 0 L' x# d' q* `. @
1.3.3 设置Vista调试执行10 % [2 c1 F" e: I5 v; z9 c5 k
1.3.4 设置VMware的管道虚拟串口11 8 t# I: {2 f" x0 F
1.3.5 设置Windows内核符号表12 ; Y. _2 d; v/ n" k
1.3.6 实战调试first13
5 p3 K+ h- W2 V1 u7 D& ^: T6 S/ o1 R7 \: V* S% ?
第2章 内核编程环境及其特殊性16
! g* s' J6 c5 M, T4 q% m) l: d6 m5 @  F+ t- I4 V
2.1 内核编程的环境16
' A0 d) E! v% y3 K! r4 V0 V2.1.1 隔离的应用程序16 + T& o6 c0 e3 X0 \! @
2.1.2 共享的内核空间17 1 j8 a: K$ v# r$ u* D* S0 H8 L
2.1.3 无处不在的内核模块18
7 ~8 [! c2 C5 q1 |2.2 数据类型19
4 s6 ~, q$ z) Q; s, X3 Q% t4 z2.2.1 基本数据类型19
9 z" \' m6 N: w2.2.2 返回状态19
) e$ ^2 Y$ F. R' H2.2.3 字符串20 ! z; b4 `) e, `. A6 i: z3 R+ \
2.3 重要的数据结构21 ! b( Z' d* r" F& A, _" n) }
2.3.1 驱动对象21
- o$ ?* h2 w" O) }, k2.3.2 设备对象22 & O; [' v- \. E4 [5 X0 y
2.3.3 请求24
3 r% n# m# q& x- a2.4 函数调用25 . e8 H, k  O& h$ `% u
2.4.1 查阅帮助25 ! C& U" P4 U/ f4 A6 c0 w5 E
2.4.2 帮助中有的几类函数26 ) U2 r/ t  |# q# ^. q
2.4.3 帮助中没有的函数28 : j5 K- |5 ?) K6 B8 n7 q6 x
2.5 Windows的驱动开发模型29 ' B; o2 {9 ~  U
2.6 WDK编程中的特殊点30 6 ?  [5 x: A7 `! D: W4 S
2.6.1 内核编程的主要调用源30
3 d6 N$ u6 c* _+ J2 W8 c2.6.2 函数的多线程安全性30
- @" H. J* E2 V) X. I* I8 X( E2.6.3 代码的中断级32 ; |6 d# i) n* J" x5 H
2.6.4 WDK中出现的特殊代码32
  @% H- M% `2 I: V  Z
% N4 _: C, v3 Q  J# ~9 c) W5 Y第3章 字符串与链表35 0 U/ E3 W& c) [1 E  J6 g  g

& g9 M' p$ u/ m, A. ], p1 y3.1 字符串操作35 4 t  a) @( c7 f) q5 j: V
3.1.1 使用字符串结构35 3 V' m0 o) i/ b
3.1.2 字符串的初始化36 + i' K! O( M5 t0 v
3.1.3 字符串的拷贝37 3 l% {& f/ Z! N$ c/ O
3.1.4 字符串的连接38 7 W6 |6 n- R% t( Y
3.1.5 字符串的打印38 " b4 \. N2 m' y4 ^0 t# C
3.2 内存与链表40
5 I) x9 j  z" J$ s3.2.1 内存的分配与释放40 ) N' W" e) }2 _1 _& @
3.2.2 使用LIST_ENTRY41
" C% D+ }: G# t$ ^1 f3.2.3 使用长长整型数据43
5 |  ]! z/ s5 P% ~3 C3 m; R: a3.3 自旋锁44
6 K7 n9 e2 c  D% Z# W3.3.1 使用自旋锁44
: ^7 I. q- i! q, o3.3.2 在双向链表中使用自旋锁45 3 Q. x! i  c4 f: O4 H9 v
3.3.3 使用队列自旋锁提高性能46
2 h0 Y, q! U! o" w  L- G/ q! I# f: i, l! e# \8 U
第4章 文件、注册表、线程47
, E) y/ q! v9 O6 U4 M3 ?+ d+ z* T8 J' m& P6 D% l- a/ E
4.1 文件操作47
# N5 w; m3 b0 M  U' ?1 q4 B4.1.1 使用OBJECT_ATTRIBUTES47
/ y9 `1 }- V0 N- d: L* T; v5 h; F4.1.2 打开和关闭文件48
# W7 s; p+ P& l$ v1 f4.1.3 文件读/写操作51
0 o! M3 \2 f$ v; o. W4.2 注册表操作53
( a! T* K/ c9 G  P. t' B% m3 m: B4.2.1 注册表键的打开53   \: l2 q' ?1 ]9 H$ r8 m& A- n
4.2.2 注册表键值的读55
$ m% P0 y4 C0 u# U3 ^4.2.3 注册表键值的写57 ) s. N8 ]- m9 U2 y4 M
4.3 时间与定时器58 - b' k+ p* g: g" a: b7 G) p
4.3.1 获得当前“滴答”数58
7 r% O7 Q! s, ^  l( r4.3.2 获得当前系统时间58
2 M! U, O: M2 |5 J- N' W5 f$ _4.3.3 使用定时器59 7 m; C* C* o* y+ H% _; p
4.4 线程与事件62 , }: e9 q# E- @
4.4.1 使用系统线程62 3 e# J  U0 L6 v: q
4.4.2 在线程中睡眠63 + w; Y+ I( d0 z+ U
4.4.3 使用同步事件64
, ?7 Z3 S% y/ }9 j1 W: [0 h5 b9 E
第5章 应用与内核通信67
: w0 E6 {' Q2 W' ~( z8 o% P* K; Q/ M8 }* D& |
5.1 内核方面的编程68 % `8 M& b: ^3 Q0 @0 w' }  e% R
5.1.1 生成控制设备68 ( \8 s. O8 d6 U- z6 ~
5.1.2 控制设备的名字和符号链接70
4 f/ x3 O0 o4 X0 p- }1 L5.1.3 控制设备的删除71
, V3 J+ ^% }6 S$ V5.1.4 分发函数72
( D* Y% E( L: y) D5.1.5 请求的处理73 4 B# S: b- J$ ?4 J" ]$ P4 A; S0 n2 O) W
5.2 应用方面的编程74 % h0 U0 ]) L( d) T6 y8 p3 j; T+ h
5.2.1 基本的功能需求74
6 |. }5 n( d" _! q5.2.2 在应用程序中打开与关闭设备75
  K  r  M' L0 I  P+ c5.2.3 设备控制请求75 ( O: }6 U  N* S2 \- G6 d. |1 O" l: \
5.2.4 内核中的对应处理77
( o/ O& h4 R! M% u7 {- |; b* f5.2.5 结合测试的效果79
: Y) V' Q! J) w) f5.3 阻塞、等待与安全设计80 5 a: [" n' k3 k' d
5.3.1 驱动主动通知应用80
6 ]0 l4 D0 Q7 m& w- N5.3.2 通信接口的测试81 + E) }' V( \* n* F; F9 q+ ]
5.3.3 内核中的缓冲区链表结构83 ) {; Z9 A3 P2 s  C# I' J; x
5.3.4 输入:内核中的请求处理中的安全检查84
" m8 |6 W: X8 f0 ^' p, o5.3.5 输出处理与卸载清理85
; s# c) d2 E/ ?1 z( T% p" z. n; m: |8 L1 m2 H5 k; b
第6章 64位和32位内核开发差异88
! U$ r- S: ]: K. p# ?
/ J. z9 Z( E$ K( f& I6.1 64位系统新增机制88
2 L! I+ Q$ K% v6.1.1 WOW64子系统88 0 n4 I5 _: l$ Q
6.1.2 PatchGuard技术91
; u- a+ Y+ f4 g* `6.1.3 64位驱动的编译、安装与运行91 , v2 B3 R1 E1 \8 h7 w/ a
6.2 编程差异92 7 O) k0 r8 r9 Y- G
6.2.1 汇编嵌入变化92
1 b- t# R2 H; D. r$ O2 V6.2.2 预处理与条件编译93 . L9 v# T* t5 J# K
6.2.3 数据结构调整93 0 s4 I+ E, e' k' h/ X
4 z: y& g, \, i% l- V

8 |" p# S* \! H3 H8 W9 n开 发 篇
6 @  I. x( m" N6 }% ]! U) o# k/ l; t0 t' E. l8 h
第7章 串口的过滤96 % ]  g& m5 q% o5 _0 K: c) b

* z, P3 q: \! Z7.1 过滤的概念96
2 k9 a8 P4 R. `" N1 ?1 _- C/ x7.1.1 设备绑定的内核API之一97 ) S3 t& j2 @; J1 J- N
7.1.2 设备绑定的内核API之二98
( p9 N! S7 P& @% C6 V2 V- E6 P7.1.3 生成过滤设备并绑定98
0 |) g. k6 f9 h: x: k7.1.4 从名字获得设备对象100
! l0 e% |* a  ]6 |8 I7.1.5 绑定所有串口101
% y) u  {+ k- S2 \: R, N7 Q7.2 获得实际数据102 0 Z$ x: O! @1 P. {, m7 L3 B
7.2.1 请求的区分102
( |5 Z$ p4 o- D/ W7.2.2 请求的结局103
% K4 A( t3 E/ |( |4 Z* R7.2.3 写请求的数据104
* g, _9 U* c, W* M" ]2 [7.3 完整的代码105 . s8 {  q/ R8 r
7.3.1 完整的分发函数105 6 U" \4 p+ P' \9 p* r/ S3 X
7.3.2 如何动态卸载106 * a! e! O1 M3 Y/ `. _9 A8 ?+ s
7.3.3 代码的编译与运行107 8 w) M/ m7 T5 N; F2 s1 D

* B1 _* X" Q' }& B  S第8章 键盘的过滤109 4 x9 ~8 |: B5 N! T1 o
% G2 P0 @* F. V) E/ v8 w
8.1 技术原理110
. ^8 T1 i/ e9 D. i+ n- Z) i" T( P9 G8.1.1 预备知识110
# d) s7 z* x0 l# T8.1.2 Windows中从击键到内核110 " K/ n) d0 c; D7 ~9 W* {
8.1.3 键盘硬件原理112
' M3 t. |9 a1 K; u* k/ s: H: H8.2 键盘过滤的框架112
7 J; F( Z. X% R5 h1 [1 N8.2.1 找到所有的键盘设备112 % j* _7 Z1 D. d: w4 c
8.2.2 应用设备扩展115 5 d% K3 j* z& {
8.2.3 键盘过滤模块的DriverEntry117 8 R" c7 W3 u8 i7 B' b- K: E
8.2.4 键盘过滤模块的动态卸载117
0 ^1 B6 e/ f) v! O) T8.3 键盘过滤的请求处理119
# u3 U$ E* Y# ]  x+ t8.3.1 通常的处理119
# h& Z5 j0 F+ \1 x" M* G8.3.2 PNP的处理120
! K4 P# H# t* ?/ t" t* P* c# M) A8.3.3 读的处理121 ; C4 `+ N+ n/ l; }9 @
8.3.4 读完成的处理122
0 z' X# t7 [% Q6 t  W8.4 从请求中打印出按键信息123
! o7 C: e+ X) p4 V$ x8.4.1 从缓冲区中获得KEYBOARD_INPUT_DATA123
$ x' g3 D3 G6 W8.4.2 从KEYBOARD_INPUT_DATA中得到键124
3 F, ]. h! B8 E( j/ M. `7 W$ C% Y8.4.3 从MakeCode到实际字符124 9 q1 [" i7 d/ w) z/ k
8.5 Hook分发函数126
* C; Y7 Z' t4 [# _8.5.1 获得类驱动对象126
4 ]% `! o! P' g. o6 y( w) p8.5.2 修改类驱动的分发函数指针127
% I& M  N# N) V5 i8.5.3 类驱动之下的端口驱动128
6 S$ a% d; R1 I9 Z8.5.4 端口驱动和类驱动之间的协作机制129 . X: L7 b/ q5 O$ w2 [9 L
8.5.5 找到关键的回调函数的条件129
7 ^" o( p9 ?0 ?8 `$ g8.5.6 定义常数和数据结构130 9 V$ o$ }* ]* M* F3 ?1 [
8.5.7 打开两种键盘端口驱动寻找设备131
/ d+ |8 C' m+ ^8.5.8 搜索在KbdClass类驱动中的地址133
# P) W" ]7 U: J0 A4 A) ]8.6 Hook键盘中断反过滤135 9 W7 }: L/ _9 n
8.6.1 中断:IRQ和INT136 - g. p2 ~; U' Z5 U* D" N! t, r) O
8.6.2 如何修改IDT136
' Y9 v7 g  d% a) N0 s9 l8.6.3 替换IDT中的跳转地址137 ( E* n/ u! G" \& P; S! X
8.6.4 QQ的PS/2反过滤措施139 & C2 s3 d$ u: n# ^8 k& r
8.7 直接用端口操作键盘139 9 ~3 s" m% t, A
8.7.1 读取键盘数据和命令端口139
/ j  u$ z6 m; }8.7.2 p2cUserFilter的最终实现140
! [; P0 u* c7 T8 `" [
& ^$ b/ F2 E: D( N6 R3 U6 j第9章 磁盘的虚拟143
5 n/ G3 v4 P# v! [
/ W  T' C( R, `9.1 虚拟的磁盘143   d) K7 R  J; H9 A5 p) B+ H! c
9.2 一个具体的例子143
4 ]" A/ J) K% K9.3 入口函数144 " \4 H% O" R: t) G- U4 }( y& I
9.3.1 入口函数的定义144
' N( N" V% W7 b! C9.3.2 Ramdisk驱动的入口函数145
! z8 v7 L; M. Z2 H3 O& W7 Y, D9.4 EvtDriverDeviceAdd函数146 $ T) ]( ?+ K! r: W6 \0 e
9.4.1 EvtDriverDeviceAdd的定义146 . r- ]4 a$ s* c' M5 \$ {
9.4.2 局部变量的声明146
- }/ v- O+ x4 ]/ B9.4.3 磁盘设备的创建147 $ U% I1 n/ z3 v" E2 R
9.4.4 如何处理发往设备的请求148 ; v5 y9 p; e$ g4 k+ |: ?
9.4.5 用户配置的初始化149
" O" w& s" T& [* o4 _% |9 V' d9.4.6 链接给应用程序151
( [& V+ |: p4 j" {& J; _9.4.7 小结152
9 E/ A( t% K5 f. G# [9 |9.5 FAT12/16磁盘卷初始化152
8 W7 j) r; b8 ^! O" e6 w9.5.1 磁盘卷结构简介152
& o5 i- u: F* Q' J; C$ z9.5.2 Ramdisk对磁盘的初始化154 ! z5 X$ R! Q8 j$ \2 c& Z5 b; }
9.6 驱动中的请求处理160
1 K+ v8 J% b1 M! _1 h8 r6 R9.6.1 请求的处理160
3 s9 a5 m- X6 A9.6.2 读/写请求160 " l$ ^6 @  u# b
9.6.3 DeviceIoControl请求162
, s+ X/ D/ Q! O/ O7 x9.7 Ramdisk的编译和安装164
# ~7 ~3 Q. a9 t5 y' X9.7.1 编译164
' ~+ {2 {% P  y5 f9 T. s; w9.7.2 安装164 6 R. O) j$ l* P4 j" s7 J2 \- R
9.7.3 对安装的深入探究165 1 ~! U5 ^, O/ F' |1 n, P
7 b% N+ z. }: F! ?
第10章 磁盘的过滤167
6 X5 o, Q4 d+ k. t0 \% G8 y
) S6 E( `+ F7 ?% @7 _: ^10.1 磁盘过滤驱动的概念167 - l* A* x/ N2 H* \- d
10.1.1 设备过滤和类过滤167
: D! [' |. H. F  ~. G) q10.1.2 磁盘设备和磁盘卷设备过滤驱动167 : @0 {, b8 `! i, \  h
10.1.3 注册表和磁盘卷设备过滤驱动168
1 o" a$ {1 [- }( t3 O, v10.2 具有还原功能的磁盘卷过滤驱动168 * y# P0 U8 e8 {/ o3 @% e: `
10.2.1 简介168 9 F. C" P! U2 d+ b
10.2.2 基本思想169 5 I) ]0 x/ Y7 ]; P' C6 I
10.3 驱动分析169 $ j4 T9 q0 r; D7 c3 E7 d; c
10.3.1 DriverEntry函数169 . \. u! G# g: C. R
10.3.2 AddDevice函数170 " t' i/ a  Y4 \" X; W
10.3.3 PnP请求的处理174
/ [4 ^; d5 ^5 I% t1 |0 p+ Q10.3.4 Power请求的处理178 / q+ k. v9 e& @/ t& y( u# g
10.3.5 DeviceIoControl请求的处理178
/ M1 h7 N: I8 R* O10.3.6 bitmap的作用和分析182 ! }1 t& K! p! b) X
10.3.7 boot驱动完成回调函数和稀疏文件187
9 j% u, F6 J, ^9 ?2 J10.3.8 读/写请求的处理190 ) }3 W# V$ ]8 ^+ W0 V- g
0 y2 v' `- V2 I6 V
第11章 文件系统的过滤与监控199 5 O; R$ O0 _1 a. U8 ?& ?* Q
3 [6 c' b" k) K0 f5 U
11.1 文件系统的设备对象200 ( `* [; ], ^" p; I9 v
11.1.1 控制设备与卷设备200 : x( v$ Q, O1 f6 i
11.1.2 生成自己的一个控制设备201 2 I# Y* o; s9 ]7 C! n2 D
11.2 文件系统的分发函数202 0 d5 U; G0 F' _2 E- N; C
11.2.1 普通的分发函数202
2 |' E  e  p3 j+ H$ ~8 [, w11.2.2 文件过滤的快速IO分发函数203
) x7 g4 H$ L: O# p7 b/ J11.2.3 快速IO分发函数的一个实现205 9 h. G  ~& X9 ~( p
11.2.4 快速IO分发函数逐个简介206 7 w. I$ X$ q- Z4 x( T3 P5 @5 [2 u
11.3 设备的绑定前期工作207
0 l8 z( H8 N# L0 {  J6 m11.3.1 动态地选择绑定函数207 9 q  B% X1 ]1 B$ m: Q
11.3.2 注册文件系统变动回调208
3 \8 b8 f9 L$ c/ G7 t11.3.3 文件系统变动回调的一个实现209
8 u, m+ a4 W% N4 p11.3.4 文件系统识别器211 2 `7 a$ U! K" a$ B, B2 r
11.4 文件系统控制设备的绑定212 / |7 Z: B" f% w' @; V0 ?
11.4.1 生成文件系统控制设备的过滤设备212
* x. x  D/ N' R9 _- U- W, j( E11.4.2 绑定文件系统控制设备213 ( s) ]9 Z+ n' Q* j" {  a( {
11.4.3 利用文件系统控制请求215
! B+ y( v2 ~7 O% y6 o8 `' y& ^0 N11.5 文件系统卷设备的绑定217
+ U5 l/ W. }6 `! E& R+ w9 D11.5.1 从IRP中获得VPB指针217 / u9 G3 V, {) e# l2 f
11.5.2 设置完成函数并等待IRP完成218
0 B  O7 W- P- E4 |. v) J11.5.3 卷挂载IRP完成后的工作221
+ Y/ q1 C4 F2 u7 y! H. z, L  V11.5.4 完成函数的相应实现223
: ?; v6 Y' S7 q9 g; s8 F11.5.5 绑定卷的实现224
; R6 ^$ V5 F" p, V7 K8 j- S: B8 H$ @7 o3 D11.6 读/写操作的过滤226 ! m( U4 G- }! l7 R
11.6.1 设置一个读处理函数226 + c6 \/ k: L$ b1 u# a# A+ I
11.6.2 设备对象的区分处理227
" \) u, T3 i6 J" C: }8 O11.6.3 解析读请求中的文件信息228 2 Q+ l* V6 S+ {0 x  o% P- d
11.6.4 读请求的完成230 8 d1 F; _2 Z) G' s* P, y; a
11.7 其他操作的过滤234
0 W4 h! q5 z  t, X" P11.7.1 文件对象的生存周期234
( P  E$ C, A; n, r% Y7 q11.7.2 文件的打开与关闭235 . }. d9 o. c' Y$ k  [
11.7.3 文件的删除237
* Q5 `5 a0 N7 _8 R11.8 路径过滤的实现238 & x# q: _& A/ U# i. v7 d8 r) @
11.8.1 取得文件路径的三种情况238
4 Y+ C- K4 W& N; u- i' h% K: t11.8.2 打开成功后获取路径238 7 G8 }& d& g; k  D( s, g) W
11.8.3 在其他时刻获得文件路径240
/ |& O1 N+ t1 K$ n1 V11.8.4 在打开请求完成之前获得路径名240 " O8 }: ~7 \( A1 g% o/ c
11.8.5 把短名转换为长名242
: C9 b6 ~3 d, t0 X11.9 把sfilter编译成静态库243 : i0 n8 X9 o! h4 k1 e4 y$ c
11.9.1 如何方便地使用sfilter243 . J# h1 x" o( \4 r8 e
11.9.2 初始化回调、卸载回调和绑定回调244 9 ~- C1 {& Z1 m5 `
11.9.3 绑定与回调245
* g+ ~+ @- d6 p- |7 k11.9.4 插入请求回调246
7 g1 G: U  c/ O11.9.5 如何利用sfilter.lib249 : P# ]- ?* @% l$ h
1 k$ r: g" y+ W0 ?! v' b
第12章 文件系统透明加密252
+ c* D% W3 r: B0 y' J2 \4 L/ Q9 F
12.1 文件透明加密的应用252 ' J: E* w8 n4 z0 {
12.1.1 防止企业信息泄密252 7 `' H; K! `( `/ c1 o) N) D& b
12.1.2 文件透明加密防止企业信息泄密253 2 d, G- f: O$ c$ V# e
12.1.3 文件透明加密软件的例子253
8 e$ s* n8 [0 `" @; p12.2 区分进程254 6 J4 ]* V3 M  P* K* c0 Y
12.2.1 机密进程与普通进程254 3 E) `! H) t! V6 }5 i
12.2.2 找到进程名字的位置255 / V- I  q# [* X- M' L& t
12.2.3 得到当前进程的名字256 ! H! _2 r$ S0 V$ C) u' z
12.3 内存映射与文件缓冲257 , @( Q( A$ C" ]8 G5 X
12.3.1 记事本的内存映射文件257
: K) r8 n2 j' ~8 f" M1 {12.3.2 Windows的文件缓冲258
& h- P. I$ w3 g1 T12.3.3 文件缓冲:明文还是密文的选择259
3 t/ ]' J# y( {/ f7 Z12.3.4 清除文件缓冲260
  F9 i# b6 k' a1 Z' y5 R12.4 加密标识2631 h2 J, R* Y% V0 |  b% L
12.4.1 保存在文件外、文件头还是文件尾 263- `5 v- {( R2 y- E9 R
12.4.2 隐藏文件头的大小 2642 E7 W% U& {1 \( w
12.4.3 隐藏文件头的设置偏移 266
4 t( f  Q9 T& I: L9 K+ L) E12.4.4 隐藏文件头的读/写偏移 267, O% v, W' r( w1 M
12.5 文件加密表 267
, \4 l! ^( y7 U& v" |; V& a/ v* h12.5.1 何时进行加密操作 267, x) R9 h! J6 A8 M
12.5.2 文件控制块与文件对象 2682 g- K; \4 V: w- q3 Z) S2 r
12.5.3 文件加密表的数据结构与初始化 2698 D7 t! D- F9 q3 r1 y
12.5.4 文件加密表的操作:查询 270
& O. J0 e, ?1 O6 Z6 G12.5.5 文件加密表的操作:添加 271' X; b; X( j3 D! h' _3 N! m
12.5.6 文件加密表的操作:删除 272
- l5 l4 L5 o' i0 H9 s7 A& u2 w- J12.6 文件打开处理 273
6 |5 L8 o: r7 y& K* A" P12.6.1 直接发送IRP进行查询与设置操作 2740 V" A+ H* e' c) ?3 I0 m" d% o
12.6.2 直接发送IRP进行读/写操作 276
& b# G7 t- X9 C) i12.6.3 文件的非重入打开 277, G$ x$ f6 C$ Z- ~
12.6.4 文件的打开预处理 280
* M1 W; V3 W4 b" Z12.7 读/写加密和解密 285. r! x% x7 T: R$ r; i" e" W
12.7.1 在读取时进行解密 285
7 r5 k4 ^+ O. N  W5 l& |+ i: a12.7.2 分配与释放MDL 286- M. q* z: }8 g
12.7.3 写请求加密 287
) A! J6 [" F5 l3 m12.8 crypt_file的组装 289
0 M$ `7 w8 i# X( W3 ]! J1 b% M12.8.1 crypt_file的初始化 289
! Z5 x( |# q$ S. e# c7 o, [6 ~12.8.2 crypt_file的IRP预处理 290
2 h: i& \9 h7 N12.8.3 crypt_file的IRP后处理 293
$ ]5 q- G6 m) h* d5 j: T$ r/ x# S& E& C& D' a7 E' h
第13章 文件系统微过滤驱动 2976 Q5 P3 N) l! O3 \1 G) w- b9 Q
) M7 {5 H! _3 t7 M
13.1 文件系统微过滤驱动简介 2973 X; `& i) W7 |$ r6 I+ I
13.1.1 文件系统微过滤驱动的由来 2979 ~! h; b: Y& g$ Z' @* Z. M
13.1.2 Minifilter的优点与不足 298
3 q. E" B3 v) Y& u5 ]13.2 Minifilter的编程框架 2981 V2 K- J" _( N) U1 g: n% \
13.2.1 微文件系统过滤的注册 299
; f# f* J/ }' I" a5 I2 {# v13.2.2 微过滤器的数据结构 3006 w" V+ D0 s- m! u2 }& U' T
13.2.3 卸载回调函数 303
9 z& k! _3 p# J9 M6 x# _13.2.4 预操作回调函数 303
5 w) v9 k+ |8 \6 C13.2.5 后操作回调函数 306
8 e1 l% @! w" t7 \/ Y% L8 g13.2.6 其他回调函数 307- L6 D& ]6 q! Q# I) C
13.3 Minifilter如何与应用程序通信 309, r7 a3 v/ L+ L) D9 ?' W
13.3.1 建立通信端口的方法 310: B% g2 I1 j1 S' m7 {% L
13.3.2 在用户态通过DLL使用通信端口的范例 311
+ k+ r) e4 z' V/ N13.4 Minifilter的安装与加载 3146 R: }) e4 `; j: ?" p. k
13.4.1 安装Minifilter的INF文件 3148 u  q& B- G) n' H2 T* ?
13.4.2 启动安装完成的Minifilter 316
! Y0 e! U: j. Y& i: _2 }" h: T& [9 x6 F* D. ?
第14章 网络传输层过滤 317' ]+ p+ M: t: b' S# q
8 h9 `! B( N  N& g, s
14.1 TDI概要 317
( N+ b; q, o  w# o( r8 N2 x; }14.1.1 为何选择TDI 317$ M" P# J$ }! Q3 v6 E: ^
14.1.2 从socket到Windows内核 3187 a2 {5 i& W: L* p2 X
14.1.3 TDI过滤的代码例子 319
3 y5 x: Z( R$ O; e14.2 TDI的过滤框架 319% W& t1 b$ B* B9 d, n( x0 g
14.2.1 绑定TDI的设备 319
2 X- Z: I, Z$ a& o14.2.2 唯一的分发函数 320
2 U& X# [' e; ]0 A14.2.3 过滤框架的实现 322- Q# z& `3 d8 e& n' U. \* X
14.2.4 主要过滤的请求类型 323
+ ]. g. D7 }8 R4 X+ M) W14.3 生成请求:获取地址 324; o1 l6 ~  v: v! H
14.3.1 过滤生成请求 3245 A5 W8 J- B" N
14.3.2 准备解析IP地址与端口 326  J3 T0 ]/ h6 F) j# ^% ?6 D9 T* R
14.3.3 获取生成的IP地址和端口 327  J9 ]: v+ R9 m7 N
14.3.4 连接终端的生成与相关信息的保存 329
% C. Y. n+ J4 l* g14.4 控制请求 330
$ A' k: B: O$ m' x14.4.1 TDI_ASSOCIATE_ADDRESS的过滤 330: ^6 `+ {( U4 X7 f: f0 Y
14.4.2 TDI_CONNECT的过滤 332! W6 g, Q, ~% b2 H! I
14.4.3 其他的次功能号 333
8 Y0 t. w  O! f+ L- O# L3 R14.4.4 设置事件的过滤 334% L( x9 I8 l5 T9 R' X
14.4.5 TDI_EVENT_CONNECT类型的设置事件的过滤 336- t- O& @; [( Z* z0 L* o
14.4.6 直接获取发送函数的过滤 337
- v5 b7 x/ m$ j" B) c. d& Z4 O14.4.7 清理请求的过滤 339
  ^9 @, I' J! q" V& i6 V. w7 e14.5 本书例子tdifw.lib的应用 341, U+ V9 H- d& K0 I
14.5.1 tdifw库的回调接口 341
" Q5 ~; r7 W/ C4 f% ]* m" D. V- j14.5.2 tdifw库的使用例子 342
# T. r+ h* \* E# x
; b! i( O- X2 g0 P) R第15章 Windows过滤平台 3451 H5 t+ i4 Q8 K% h2 o$ s5 X5 q
5 x- ~; J/ T7 C7 C1 M
15.1 WFP简介 345
6 r6 `, |" S2 ?( b& _" n. U15.2 WFP框架 345* p2 Y, D) I2 f+ V+ E
15.3 基本对象模型 347, x% M  i0 a) h, v& F8 W0 ?& u# G# ^5 }) m
15.3.1 过滤引擎 347
" J2 Q% K0 y% D; h& l4 q15.3.2 垫片 347
$ C' k/ r, ~6 f4 H+ x5 [15.3.3 呼出接口 347
2 d2 d# k8 U8 t/ j6 Y/ m15.3.4 分层 348
. I- u3 ]$ @# p: g3 H15.3.5 子层 349
. b: B& }3 [, a+ h& m& j9 Z' A; ^15.3.6 过滤器 3504 P3 W# W! R7 u" W, A( v
15.3.7 呼出接口回调函数 354
! x& e) f0 O) ^% b+ |& l" k15.4 WFP操作 359$ @4 x- `; N5 \9 Z. I/ J
15.4.1 呼出接口的注册与卸载 360" q" I# G- l8 @
15.4.2 呼出接口的添加与移除 360
5 M$ A5 C' [4 e! ?# {15.4.3 子层的添加与移除 361
# Z" }3 I; @! k" B' I0 e" w15.4.4 过滤器的添加 362
5 T/ T8 o/ m/ o* x% s% A6 Y15.5 WFP过滤例子 362
0 l" d( Z1 \- V7 Q6 n0 n* e6 e9 {3 ?( S8 i9 L1 V# g, X$ Y( V
第16章 NDIS协议驱动 370% H8 v, C/ C  B7 l) c
0 A  g' m7 b( _7 N4 J
16.1 以太网包和网络驱动架构 370
' ?7 Q( H% u  G4 E  a( @16.1.1 以太网包和协议驱动 370
; f. I; Y  _" h, v4 H16.1.2 NDIS网络驱动 371
7 q: Y% ]# G. C0 F' Q16.2 协议驱动的DriverEntry 3722 c6 c8 Q7 E" N7 D( |
16.2.1 生成控制设备 372
# ?- e0 m" A2 _% p0 s# q/ S16.2.2 注册协议 3742 I6 d0 J: v& G! }; j* q
16.3 协议与网卡的绑定 375
& }& z5 e$ J) f! j6 Y6 e16.3.1 协议与网卡的绑定概念 375
3 @9 s9 M& d% c% a# @  `" e16.3.2 绑定回调处理的实现 3767 g! q* f/ B1 @0 {' D
16.3.3 协议绑定网卡的API 3782 ~: I% i" ?7 s/ }2 K# W9 ?2 \# |
16.3.4 解决绑定竞争问题 379$ E  W" y8 T% z* c. E
16.3.5 分配接收和发送的包池与缓冲池 3802 J1 B' E0 ]6 P, O
16.3.6 OID请求的发送和请求完成回调 381! |) q8 a% N! g% w
16.3.7 ndisprotCreateBinding的最终实现 385
9 L) M- K1 j6 A  p2 W16.4 绑定的解除 390: E7 _2 U1 y/ r6 {: S
16.4.1 解除绑定使用的API 3904 j  |/ y3 Q, g" y4 G0 n. I9 V
16.4.2 ndisprotShutdownBinding的实现 392
0 S: ~! g* A2 q, H16.5 在用户态操作协议驱动 395" y5 b5 E% G: \3 B- \2 x! D
16.5.1 协议的收包与发包 3956 ^9 Y2 C. ]/ \# F/ D! v5 \
16.5.2 在用户态编程打开设备 3966 k/ K. B. _. b# f
16.5.3 用DeviceIoControl发送控制请求 397- @- ~' W6 E5 s/ ^- r+ Q$ A
16.5.4 用WriteFile发送数据包 3993 C; \6 d, a  D+ ?
16.5.5 用ReadFile发送数据包 400
# L' Y2 }) t1 R: P6 x3 M, D9 t16.6 在内核态完成功能的实现 402, O, R( a% c2 J* O; h/ k
16.6.1 请求的分发与实现 402  Y7 {. g  w; l; D! q# f# ?
16.6.2 等待设备绑定完成与指定设备名 402
5 p& v( r2 }# }2 Q! f5 X16.6.3 指派设备的完成 403
+ a/ \! ~7 D3 s. M& L/ R4 ]$ d0 R16.6.4 处理读请求 406
6 F' P- P' D4 g! ?4 |16.6.5 处理写请求 4085 ^: h  J4 q7 S& h+ c$ K; |3 B
16.7 协议驱动的接收回调 412! W# w* i, T# C! U; Q( y4 E
16.7.1 和接收包有关的回调函数 4120 a, a5 ?! [, }1 L- e
16.7.2 ReceiveHandler的实现 413
0 W" G0 E& a8 h, ^4 @5 `16.7.3 TransferDataCompleteHandler的实现 417
( c; N7 k( u3 P( W  _- q. F16.7.4 ReceivePacketHandler的实现 4187 [2 a. l" B  j0 S; ^
16.7.5 接收数据包的入队 420
0 U' G+ v# {- a3 E8 J# F; S& B16.7.6 接收数据包的出队和读请求的完成 422" e; \* B7 |, T# a: o) w

7 o. j4 ?: c2 c第17章 NDIS小端口驱动 427/ r" t( R6 i0 U2 e% G) y

$ r! u8 z1 g. i  {% c( k( k; j17.1 小端口驱动的应用与概述 427
2 e. O& ]+ y, }17.1.1 小端口驱动的应用 427( a# L% o8 t6 ~2 U* w& y
17.1.2 小端口驱动示例 428' p' k2 X+ P' i. E
17.1.3 小端口驱动的运作与编程概述 429
& j) X8 M# ^. K* i17.2 小端口驱动的初始化 429& J) N% N$ e* Y. U  c
17.2.1 小端口驱动的DriverEntry 429. b: U, t7 U0 H/ M' j, a9 B2 y( o
17.2.2 小端口驱动的适配器结构 431) I' E0 h6 j  w' P( r8 {) w8 A, o
17.2.3 配置信息的读取 433
% [7 ?& _+ c6 o. k' H4 S7 d17.2.4 设置小端口适配器上下文 4335 E& ^, m  g' T7 ]6 S+ [+ [, ~1 H+ V
17.2.5 MPInitialize的实现 434) U+ x" J1 g8 W5 @1 b* Z" _
17.2.6 MPHalt的实现 437
1 d9 V; R' k3 B17.3 打开ndisprot设备 438
1 m- ~2 E; C$ O: ^8 w0 z. i17.3.1 IO目标 438; ]( n- S4 y" k+ m
17.3.2 给IO目标发送DeviceIoControl请求 439
- l7 z# n* [& x' L; q' m& l2 s17.3.3 打开ndisprot接口并完成配置设备 441
% g- N5 J* ?8 n' @- N: V3 y3 }17.4 使用ndisprot发送包 443
. q) P" ^9 e: K( [17.4.1 小端口驱动的发包接口 4434 J! k# l+ @3 A4 t+ l# j& Q( S, E
17.4.2 发送控制块(TCB) 444
4 L, [! U  y* C. z8 }. S17.4.3 遍历包组并填写TCB 446
* F5 |7 O3 @+ |7 n: T0 h  q17.4.4 写请求的构建与发送 449
. _2 \( Z. {7 X6 S: F17.5 使用ndisprot接收包 451
5 |- x' K, a5 M% o( ^" f- }17.5.1 提交数据包的内核API 451
) u5 `$ _5 v# \# T0 S17.5.2 从接收控制块(RCB)提交包 452
! S/ _5 t5 ]  d1 d1 d2 y17.5.3 对ndisprot读请求的完成函数 4548 N- g6 x5 q) @% G. z- P( i
17.5.4 读请求的发送 4565 a$ f2 z$ C; L5 y
17.5.5 用于读包的WDF工作任务 457
) D% M+ T0 q2 {3 ]! m% Z* ^17.5.6 ndisedge读工作任务的生成与入列 4591 t: I4 e/ q) A* N
17.6 其他的特征回调函数的实现 461
$ E/ M  U' _) f8 C17.6.1 包的归还 461
' L# Z$ s( h% Z" Z. L17.6.2 OID查询处理的直接完成 462. m6 ]8 i, B& b* c6 Y0 m
17.6.3 OID设置处理 465
/ U, \. l" O9 K: ~; J3 Y, J4 Q  T8 a6 C
第18章 NDIS中间层驱动 467
! J1 e/ _1 x2 W
. e  ?& j& Q! r# k; J18.1 NDIS中间层驱动概述 467. T1 J, x4 X) C: H
18.1.1 Windows网络架构总结 467
  q% N8 n2 J6 B$ G5 p/ m18.1.2 NDIS中间层驱动简介 468
( w  E! b0 e' L% S7 n; ?7 b18.1.3 NDIS中间层驱动的应用 469! m# H  R) R' Y, k2 g; ~0 W7 L$ t  E
18.1.4 NDIS包描述符结构深究 470
2 E2 }& i1 N$ k  W; t0 h18.2 中间层驱动的入口与绑定 4730 s% `9 d9 L+ }. }! o, e
18.2.1 中间层驱动的入口函数 4736 J$ B0 X; v( t' O9 N
18.2.2 动态绑定NIC设备 474
9 j% {/ k; L' W18.2.3 小端口初始化(MpInitialize) 475
! `! M6 m( L4 m5 y" o( S5 v18.3 中间层驱动发送数据包 477$ u. [6 A. K4 b) V6 [
18.3.1 发送数据包原理 477
8 y* s8 z' O4 V, |* q6 q: R. [% M6 b18.3.2 包描述符“重利用” 478
+ O3 \0 P" ^& n$ u18.3.3 包描述符“重申请” 4817 m* q/ a* S" F9 b5 x: F/ v
18.3.4 发送数据包的异步完成 482
3 b/ u$ V/ T. n' ?/ y+ ^18.4 中间层驱动接收数据包 484  [" y" I8 i2 [9 ~. L( }
18.4.1 接收数据包概述 484
& @7 G- {" h& I1 D18.4.2 用PtReceive接收数据包 485/ _2 T+ q( E: r8 s1 \, Q0 k+ ^2 K
18.4.3 用PtReceivePacket接收 490
" d3 s7 g  x' b# B$ d/ i- T18.4.4 对包进行过滤 491
- f6 W( j. C3 u% v18.5 中间层驱动程序查询和设置 494
+ o4 i, y; ?2 K$ z18.5.1 查询请求的处理 494
% {9 _# P9 M6 Q/ r18.5.2 设置请求的处理 496
# f: o7 s+ G; p, B2 h$ J: }: J2 K% C18.6 NDIS句柄 498) |8 |4 O% |" @. L+ |: y9 ?1 f
18.6.1 不可见的结构指针 498) ~( t! t, F- y8 T4 @* P
18.6.2 常见的NDIS句柄 499  _( K/ J+ @. _* h- R! ^
18.6.3 NDIS句柄误用问题 500
, P! ?# }! m4 q) J% b, q18.6.4 一种解决方案 502
) \2 {$ x7 U  J* {7 H1 F' s% ?: w5 i18.7 生成普通控制设备 503
1 n+ c$ n0 M& S18.7.1 在中间层驱动中添加普通设备 503( {. ~8 R; a8 ]* [- D1 V0 s4 V
18.7.2 使用传统方法来生成控制设备 505
; o3 J5 X# C$ D
- g! g8 S" J$ D  r" Z第19章 IA-32汇编基础 511
; V+ u; K9 M" C
- o& g5 D4 N. h19.1 x86内存、寄存器与堆栈 511
. p, z) T7 y$ Y19.1.1 _asm关键字 511
% Z' r; O9 w9 Z0 r19.1.2 x86中的mov指令 512
6 q$ W1 }" T: [- x19.1.3 x86中的寄存器与内存 512
9 N+ {# i1 t  e- b# {19.1.4 赋值语句的实现 513, V' c1 e' B# w9 E
19.2 x86中函数的实现 5142 M8 d! `# s, C: L& W& m
19.2.1 一个函数的例子 514
" k9 ~! q/ {& A4 I5 E( J4 c19.2.2 堆栈的介绍 5154 U8 S- `9 k% S$ H, v# [7 `' o
19.2.3 寄存器的备份和恢复 516! x/ `' ~' @; @+ m* u& t; C
19.2.4 内部变量与返回值 518- O3 a% p; H# t( f) n
19.3 x86中函数的调用与返回 521+ |, e, U' x' e( [7 o7 b+ Z+ a
19.3.1 函数的调用指令call 521/ @: B5 ?6 i* _3 g  A
19.3.2 通过堆栈传递参数 521) g- I# z! W- P. z7 H
19.3.3 从函数返回 523
! Q8 M+ Z. t5 E# b6 @3 i5 P19.3.4 三种常见的调用协议 524% Y* `+ i/ e0 @, z- [6 x3 g
19.4 从32位汇编到64位汇编 526; ?' p2 T6 _# q: m
19.4.1 Intel 64与IA-32体系架构简介 526
2 W. |6 s+ u2 N5 }" ~19.4.2 64位指令与32位指令 526
) p* z5 a. X+ t( v! o( f19.4.3 通用寄存器 527- w5 w- b  ^% p9 M8 q  f8 ^( f* H/ J
19.5 64位下的函数实现 528) E2 ]) J( W, v( A
19.5.1 函数概览 528: g2 N8 U0 {% j7 Z
19.5.2 32位参数的传递 529
6 z5 U' D- t2 @& {3 ?19.5.3 64位参数与返回值 530
; y# J0 \% k- c( D1 ~. o19.5.4 栈空间的开辟与恢复 5318 V2 w' V! F; Q& N
4 {% Y8 H8 s" x+ ]
第20章 IA-32体系中的内存地址 5346 a# l9 _+ O3 O8 Q/ r! ~
; q3 Z: E, c* O3 Q& e' X
20.1 内存的虚拟地址 534. j  g9 N# T7 z
20.1.1 C语言中的内存地址 534
5 J( @* e, K' D* X6 t6 O9 [20.1.2 虚拟地址的构成 535
" Q; I+ b1 `" w20.1.3 段的选择 536+ C' l# e/ t, ~4 W5 ?, Q% B8 x
20.2 全局描述符表和段描述符 538
4 B% l3 X) E) [7 |- u5 c20.2.1 全局描述符表 5385 i4 {, d, n( n
20.2.2 段类型 539
# K8 q/ `+ ^$ Y2 e- j20.2.3 段寄存器与段选择子 5406 h8 j& n- u8 j* P9 B/ \% y
20.2.4 64位模式下的段 541
" [, U; I. k- k' h# P20.3 分段编程实践 5428 p9 v7 o; `' }
20.3.1 系统表寄存器的结构 542
$ m* ]) F/ b& L" _" S6 T! C& P20.3.2 在汇编语言中获取全局描述表的位置 543
0 {7 r0 w" A+ K! V! t1 t20.3.3 调试范例:sgdt指令的错误使用 545# w* g# ~; {. {# a2 S
20.3.4 在64位下获得全局描述符表 547
. n3 k! R4 T, O! q* }1 W' Y3 e20.4 线性地址基础 549
' c, d% y( {# Q- w20.4.1 分页控制机制 550
( f  @$ `9 Z6 Q20.4.2 线性地址的转换 551# a% J1 x1 G2 t0 G" z
20.4.3 混合页面大小 552
7 z8 C& P8 O! B) ]( t4 z20.4.4 32位物理地址的页目录和页表项 552
1 O& a8 y( U3 C0 Q, o7 F20.5 各种特殊分页方式 555
) e. q1 z, U6 G+ C5 Z20.5.1 PAE分页方式 555
# N8 p2 ^" {8 R$ E% M3 `20.5.2 PSE-36分页机制 558! F" N( A# _2 p) |. g9 m
20.5.3 IA-32e模式下的线性地址 5598 o7 `3 k9 |. ?  F& ]  O
20.6 分页编程实践 562
: \# e2 m1 I& t% D) T, |20.6.1 页目录和页目录指针表的获取 562/ ^9 Q5 a6 S$ \
20.6.2 页表的获取 5649 _0 O8 s1 f/ N! g8 |: b0 I0 j
20.6.3 线性地址的结构 567% p5 o' D/ @) u# m: ^
1 C5 ?4 \4 T6 Y* t
第21章 处理器权限级别切换 571
. a$ M, B) j5 j: ?! A
6 R" P; f2 y) m; }2 s7 I21.1 Ring0和Ring3权限级别 571
( J# _: J7 E9 J4 z; C5 K21.2 保护模式下的分页内存保护 572
' c4 ~+ m4 ~% Y21.3 分页内存不可执行保护 574( F; f' W& K2 M% `
21.3.1 不可执行保护原理 574
$ K5 G/ I" Q- ?3 ~. U1 p0 |+ |21.3.2 不可执行保护的漏洞 5753 X8 U' h- o% G3 ]: b) ^1 L  _% [
21.3.3 上机实践 577, v: l; {3 b! A* `% B0 j( h# c& [
21.4 权限级别的切换 579( V6 |+ c+ N4 p* {. V  f
21.4.1 调用门及其漏洞 579
0 K+ ?0 _) j: A) g3 k21.4.2 sysenter和sysexit指令 581* a9 u$ f/ J! U( Q" G7 V
21.4.3 上机实践 583+ n& H1 x. e2 [. S1 h

/ M* L; K- Q" z5 y& {$ T6 m; Y第22章 IA-32体系结构中的中断 5854 p4 T# q: @3 h" ~9 @! d
' A7 Y: J  I/ t8 i3 N' D
22.1 中断基础知识 5855 [, ?' \: h% L/ V0 A9 }
22.1.1 中断描述符表 585
  ?5 E  R  v9 m/ z/ u  I% ^) u22.1.2 中断处理过程 587! I9 _. X0 z! s" H
22.1.3 64位模式下的中断处理机制 589- ]6 ]6 V6 x1 x, S/ u! H
22.1.4 多核下的中断 589& u2 H' r/ R+ j4 w( s  q" r
22.2 Windows中断机制 593# I0 U, T4 m$ H  [2 g* M5 x
22.3 中断编程实践 596& V1 O8 c/ B" c- ^- v" v
22.3.1 IDT Hook 5962 @3 q8 Q/ X3 ]$ f0 L
22.3.2 巧用IDT Hook实现安全防护 598+ L, r8 ?1 o* H# v
! a5 X' @! E, @2 j
第23章 Windows内核挂钩 6011 Y* M' x) h- Q" h* U( z
% f  V) h! k* x8 T
23.1 系统服务描述符表挂钩 602
/ b, v9 O7 ~8 U# B& w# r5 u* T23.1.1 系统服务描述符表(SSDT) 602
# I8 H  v$ _; p7 h23.1.2 系统服务描述符表挂钩的意图 603
8 |2 H" ?/ j" v7 ?. `- i23.1.3 寻找要挂钩的函数的地址 604" Y' |* y; k2 L3 |: l
23.1.4 函数被挂钩的过程 6057 F2 m+ d+ n$ {2 ]" m
23.1.5 具体实现的代码 606
3 D; l$ K7 Y( i: r; b- T23.2 函数导出表挂钩 608% x$ ~5 N4 K) \9 Y; f3 h/ @
23.2.1 内核函数的种类 608
, \; o$ i. c  `8 b: n1 L* a23.2.2 挂钩IoCallDriver 610( e. p* ], s  W/ X4 o( G& {
23.2.3 对跳转地址进行修改 611
5 v, [4 N: y6 x: Y$ o0 w23.3 Windows 7系统下IofCallDriver的跟踪 612: L; u! Z3 F  V  }  v) u' ]
23.4 Windows 7系统下内联挂钩 615: C3 v, j) \) w
23.4.1 写入跳转指令并拷贝代码 615
) ~( j9 f0 X3 [) j9 x3 ?23.4.2 实现中继函数 617
( r+ R! v' o2 u% G6 E! V( `( j1 r: O
$ y( _; W( {- G& q+ w  E# D3 l/ R, A/ m: i
高 级 篇* p' e4 r3 F3 e; B; T

5 W6 O! ]' y/ j$ |% |' s第24章 Windows通知与回调 620
" a  l6 \1 [! t8 e1 q! l' K9 b" `$ v5 m- i, f1 b0 K7 I
24.1 Windows的事件通知与回调 6203 N) O$ @. u- N/ A
24.2 常用的事件通知 620
; ^3 l, P9 `- j- C; t24.2.1 创建进程通知 621
+ `2 B, i4 E% q! t% h24.2.2 创建线程通知 625
, ^% K5 N" F1 C/ y( M9 N, U24.2.3 加载模块通知 626" r) [0 p; a, I: G5 p3 B0 ?; {& z/ l
24.2.4 注册表操作通知 629
$ ^3 I. _' Z( N4 j24.3 Windows回调机制 636
- X4 D" {+ _4 ]2 D24.3.1 回调对象 636
7 e5 W3 E" Y6 L( o8 f4 g7 [24.3.2 回调对象的创建 637
) N' u) A/ z1 H( {% P7 j1 H/ X  C24.3.3 回调对象的注册 637
( C$ n- e! U% B  w24.3.4 回调的通告 638  [" T+ i; h: r3 O8 i% J- G6 P  Y
24.4 安全的死角,回调的应用 639, ^, B- l  y6 f, T, C

; k$ g% H6 V! A& }7 v第25章 保护进程 640. a% I2 b' W: Y4 i3 T( v) k
; ^: y. ~0 ^+ ?: {: t
25.1 内核对象简介 640$ a4 e( I- Z- R# \7 X9 y
25.2 内核对象的结构 641
& Y5 |6 w7 \3 w9 {2 Z25.3 保护内核对象 642
( o5 D9 S- l  O; w9 ?25.3.1 处理对象的打开 643
  h3 S- j: y7 |4 c0 p1 y* J% o; p25.3.2 处理句柄的复制 644* G- c. c' \# R% n) D
25.3.3 处理句柄的继承 646# m3 a" d4 d6 ]/ A
25.4 进程的保护 652
1 d) K/ Q2 u) N3 g0 M: r25.4.1 保护原理 652
1 [; b& x0 X, Y2 P6 K25.4.2 Vista以后的进程对象保护 6545 m- l  d: q& ~7 g& v! [: S3 j
25.4.3 进程的其他保护 655- l9 f4 d5 ~6 Y+ w
! |" V" v8 h! R4 b, J- O
附录A 如何使用本书的源码光盘 656* F( g; v0 Z0 Y! @  G7 o
1 ]8 Q% E9 M7 Y( h3 U6 T4 c, a
附录B 练习题 659  b4 ]5 O9 Q6 U' J2 ~1 G/ A" s
4 S: x4 J3 n- Y  ~3 Q1 i" {

( g+ j6 F1 q" P. R6 I2 p9 P
最佳答案
31 
发表于 2016-11-25 11:01:33 | 显示全部楼层
会驱动的都是大神啊。
最佳答案
0 
发表于 2018-3-27 22:34:32 | 显示全部楼层
哦,这个,额,不知道他讲的操作系统的内核指的是什么,这个,很好,我很想学
*滑块验证:
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

关闭

小甲鱼强烈推荐上一条 /1 下一条

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备11014136号 )

GMT+8, 2018-7-17 04:03

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表