By:w00w00SecurityDevelopmentarticlebyNicolasDubee
+ N. u3 b- E  s6 \& k+ [" u译：大鹰
' x4 h8 y* E6 z/ D* F. V, Q/ H2 s, X
以下代码均在Linuxi862.0.x的内核下面测试通过。它也许可以在之前的版本通
) D2 Q9 c$ @# P' D: d4 r& E过,但并没有被测试过.因为从2.1.x内核版本就引入了相当大的改变,显著地内存
  q1 N5 E4 U7 a* l0 u1 J5 J2 K, }管理上的差别,但这些不是我们现在要讨论的内容.
8 e! R; d5 X- l! K- }9 ^- X; q! G0 ^! B
ThankstoHalflifewhofirstgottheideatouselkmformalicious4 s: P, b$ x) P. T& e( ?7 ]
purposes,andtiepilot,mylivinghero.（一些感谢信息就不翻啦，西西）6 V! c" u1 v  A% w0 |& U

- l1 f  J- I, A, D* h1 c* ~1 v
6 F# x6 ]; T2 T% @: }# a! d# ^
1 R) V' g( E" Z/ p6 n  R用户空间与内核空间
+ |, f5 G/ A9 B8 {( _4 `$ [---------------------------
+ t9 ~. N% \& J+ \) k! h) `: H' o
linux是一个具有保护模式的操作系统。它一直工作在i386cpu的保护模式之下。6 Z4 y, N9 g% o+ E7 X
内存被分为两个单元:内核区域和用户区域。（译者注：我觉得还是这样叫比较顺口）7 c2 {, i" B/ [* F  \
内核区域存放并运行着核心代码,当然，顾名思义，用户区域也存放并运行用户程序。
- s* n" }$ ]( M( P( J当然，作为用户进程来讲它是不能访问内核区域内存空间以及其他用户进程的地址
6 l6 r# C0 j/ B( ^# x2 b4 W空间的。& r) _1 c# n2 ?* U
. k5 e, r9 a# ?5 A! A; q  U
不幸地是,核心进程也有同样的情况。核心代码也同样不能访问用户区地地址空间。0 y# r# U6 Q6 P/ ]0 ^$ I1 A
那么，这样做到底有什么意义呢？好,我们假设当一个硬件驱动试图去写数据到一个用
6 \" j2 O7 e9 B: ^0 f# J+ P户内存空间的程序里的时候,它是不可以直接去完成的,但是它可以利用一些特殊的核
) V1 v9 Q$ l) T$ h: G4 ]心函数来间接完成。同样,当参数需要传递地址到核心函数中时,核心函数也不能直接+ t3 @8 T  s( }: `
的来读取该参数。同样的，它可以利用一些特殊的核心函数来传递参数。4 Z. Y( R, @! J) u
8 T2 s" n6 i7 H) b
这里有一些比较有用的核心函数用来作为内核区与用户区相互传递参数用。
" i3 \1 s9 A# m" a9 M+ Z3 o0 A
* S' H* i. @% c: s8 h* E0 B0 Y, f#include
- w! ~& s4 X) c8 h6 l. a; J/ u7 ^  N2 _
get_user(ptr)
$ t1 P: N! d+ N. R从用户内存获取给定的字节,字,或者长整形。这只是一个宏（在核心代码里面有此宏. Y$ ]  |8 k6 p! m4 B
的详细定义）,并且它依据参数类型来确定传输数量。所以你必须巧妙地利用它。
  }) a; [5 k. A
0 F4 o  U/ ~( S- [put_user(ptr)/ s9 W' P/ m. {  M& `, F
和get_user()非常相似,但，它不是从用户内存读取数据，而是想用户内存写数据。
1 f# A6 z; ~# w, E4 ~$ s7 T5 W( ?* H9 i, i7 Z0 I2 m* }
memcpy_fromfs(void*to,constvoid*from,unsignedlongn)6 A/ s! }# s- h% N, V+ Y
从用户内存中的*from拷贝n个字节到指向核心内存的指针*to。
) E; i& t1 P8 c7 S5 v7 D
3 a" u; j- h' Q# l' {+ u$ [& ]memcpy_tofs(void*to,const*from,unsignedlongn)* r* l$ \* h4 m
从核心内存中的*from拷贝n个字节数据到用户内存中的*to。+ b1 t& ?) @3 Q* ~. S) {9 q

4 s* c4 L% E, ?& ^% f% j/*译者注：这四个函数足以在2.0.x中解决内核和用户区的参数传递问题，在2.0.x以上
' x1 L6 q: h: u2 e5 o+ r! Y2 n的版本有新的实现，即copy_user_to(...)以及copy_user_from(...)根据内核版本这些
" ]$ [' f2 b9 V特殊函数会有不同，请关注核心代码的实现方法。*/
* {$ ?0 q/ _. u8 V6 N
9 g, X% ~, O* I. A
) A& a" j1 z& v  N' V! M系统调用; I3 m) M. v3 l" {! c6 _
------------
! ]4 R; p  w2 c. Q4 A; _0 a* a. ]1 h
大部分的c函数库的调用都依赖于系统调用,就是一些使用户程序可以调用的简单
0 Z- i4 i7 u0 W3 [: j核心包装函数。这些系统调用运行在内核本身或者在可加载内核模块中,就是一些
2 _9 W- p' p2 N+ n5 D可动态的加载卸载的核心代码。9 j- j/ G1 B# R4 n! o

9 x0 A" [9 }, S9 c+ h就象MS-DOS和其他许多系统一样,linux中的系统调用依赖一个给定的中断来调用多1 `2 [3 A* R, k5 E. h0 N
个系统调用。linux系统中,这个中断就是int0x80。当调用'int0x80'中断的时候,
! k3 O5 H& j. r2 q" _控制权就转交给了内核(或者，我们确切点地说,交给_system_call()这个函数),
5 p# |& Z7 F  k* m5 a4 ?; S并且实际上是一个正在进行的单处理过程。
9 D! P1 L; J) \( b8 M! C0 S+ X0 {& t5 |* T- U) e$ {0 B
*_system_call()是如何工作的?' B# l0 X$ d0 v

+ k7 n% v6 Q  c首先,所有的寄存器被保存并且%eax寄存器全面检查系统调用表,这张表列举了所有
  y5 E# Y- T! I* \的系统调用和他们的地址信息。它可以通过externvoid*sys_call_table[]来被访问到。: z& _( ~; ^3 N) h, V
该表中的每个定义的数值和内存地址都对应每个系统调用。大家可以在/usr/include/sys/syscall.h4 T0 x1 V! H8 U. h. `. _
这个头中找到系统调用的标示数。他们对应相应的SYS_systemcall名。假如一个系统调6 F+ k! o! w4 `6 b
用不存在,那么它在sys_call_table中相应的标示就为0,并且返回一个出错信息。否则,  n7 n  @  j- R  v8 v
系统调用存在并在表里相应的入口为系统调用代码的内存地址。; F, ~" z* {5 w4 \) t
) I4 u7 c) `6 s. I; P. K
这儿是一个有问题的系统调用例程:
+ m& E8 H5 w  R5 n2 a- I4 ^1 v& U1 P' [2 T- }. |& [
[root@plaguezkernel]#catno1.c6 u9 t2 L; D3 O3 M* z+ K
#include2 {  T* v- ^; A& x0 H0 j
#include
! L  B* e# v0 t3 {#include
: O  l, L8 m" [) ]1 L5 d; [3 U1 `2 ?. Q+ m" l
externvoid*sys_call_table[];
- X/ a: e* n9 o' Z0 c% `9 h. B0 B7 C+ P' Y6 A  z/ Q$ c& D' V0 n
sc()
$ G8 l# y/ ?4 J) q( A8 z$ p8 H5 k{//165这个系统调用号是不存在的。
5 T, V/ X2 [! Z__asm__(
4 Q! {0 v, v8 V, f( v"movl$165,%eax
1 y* V5 D6 E2 i* B& tint$0x80");/ @: r+ f4 M4 f& E, W* ~) l
}
) @2 c6 w2 x# y* g, r: X3 z3 P
* f, s& e" q8 e+ A: _+ M9 Y& r$ O3 Amain()
# t3 n* v6 M, E- {7 ]{
. q' }7 L. h5 W$ y% b9 }+ Zerrno=-sc();
( D( k( G' Q* l/ _; E: }perror("testofinvalidsyscall");( F) W# E8 U- j+ k
}
) j# l: Q2 o  w: F" N8 r[root@plaguezkernel]#gccno1.c: H2 E. e3 ^# M" w& A4 l4 |
[root@plaguezkernel]#./a.out5 c- O/ M- ~* O7 k7 ~+ G
testofinvalidsyscall:Functionnotimplemented* |" w' k' g9 L$ U
[root@plaguezkernel]#exit
( P/ ~: f2 [" P% I9 ^
( _5 h+ O" V. E0 J% l/ Z. d% Z" f* s) X( M% ]" J" E- g
系统控制权就会转向真正的系统调用,用来完成你的请求并返回。然后_system_call()' R- g! r9 k5 ^: E/ |
调用_ret_from_sys_call()来检查不同的返回值,并且最后返回到用户内存。
$ f0 J0 y! q' o- X# H( Z7 C
- E* M% }% S& h8 }4 a0 c* a, }$ q5 s! e1 D+ }* F
*libc
/ Q; B# P2 r/ F8 ^* B3 a& F7 p8 A/ v4 Q2 Q" s7 a
这int$0x80并不是直接被用作系统调用;更确切地是,libc函数,经常用来包装0x80中断,
1 [: f- V2 M" H这样使用的。
  M4 i7 ^! o; x/ ^2 Y/ ^/ J/ B1 l; g7 ]' `+ V8 r* B7 ^
libc通常利用_syscallX()宏来描述系统调用,X是系统调用的总参数个数。
# A4 e# p' ~2 l: K+ _! @* |
+ T) h' k0 b  P0 D2 I* o) k举个例子吧,libc中的write(2)就是利用_syscall3这个系统调用宏来实现的,因为实际的9 k4 s: r3 O; E  X6 I0 j
write(2)原型需要3个参数。在调用0x80中断之前，这个_syscallX宏假定系统调用的堆栈结8 e3 R. `; Q# g. W. r9 D9 J' R- S: C
构和要求的参数列表，最后，当_system_call()(通过int%260x80来引发)返回的时候，+ E0 O& ~  m- w0 ]+ U% j: S; e
_syscallX()宏将会查出错误的返回值（在%eax）并且为其设置errno。, Y& ?1 F& P/ l1 O1 t: I
3 x- Z2 S% N4 E. r( d
让我们看一下另一个write(2)例程并看看它是如何进行预处理的。
" @1 a0 J" o. W/ `2 E9 Q5 e# J% _$ t8 b" }* J2 K
[root@plaguezkernel]#catno2.c2 M2 m  Y; B: W+ q2 Z
#include4 F: f- R" C" q# ]: A2 A
#include
/ [$ C; D& @. d: ]# C; o& H#include
9 y$ G9 F: N, ]0 n% u#include
3 D8 @- \+ x" k* _5 j#include
0 M/ p1 C9 k/ f#include6 o  Z$ r3 a4 x" G2 D0 d6 @
#include
$ Z* }3 ~2 c) I. H* h- Z& R4 {#include9 e- \2 _; O1 x" \& [
#include- f# e& _  B0 s) Y8 h
8 X, \3 e! L4 x4 @1 B# b( \7 K
_syscall3(ssize_t,write,int,fd,constvoid*,buf,size_t,count);/*构建一个write调用*/7 C; o+ e5 O' z9 A- a

% Z- G2 @% m5 _! i$ n  D, `main()* f: {6 N/ N9 t  Q3 F( ~% s
{, C% m8 ^6 ~$ ~
char*t="thisisatest.\n";
+ w2 ^+ i) p; I& |write(0,t,strlen(t));& Y7 R( K& s4 z& h  x
}
1 Z7 J+ A0 ]- a+ K; U/ j. W6 H[root@plaguezkernel]#gcc-Eno2.c%26gt;no2.C6 J9 J) r+ B& Q6 n7 u
[root@plaguezkernel]#indentno2.C-kr: @# a5 K/ X' T; e
indent:no2.C:3304:Warningldstyleassignmentambiguityin"=-".Assuming"=-"
; g; f4 P7 F: z, u7 u( a. W
, `* e" v  g( f" U2 j[root@plaguezkernel]#tail-n50no2.C
4 R- Y7 p7 U# k( u. t4 c- u# }, ^, x
# a$ E  L, c2 X$ \. u4 b' O6 s4 p5 ]2 y5 v
#9"no2.c"23 ?! y- m- o5 ~/ h& S5 I; `' F
0 E8 n, e1 |% }4 |& g
6 |- [+ [5 I; z+ G

/ F9 y: X3 t( d, @4 b% |
) n9 z# z& z+ ^1 f) d# Wssize_twrite(intfd,constvoid*buf,size_tcount)  m2 Z6 [: k6 V
{! Z5 H0 s* q8 h) \
long__res;/ H( W( U" a2 c% S: a9 C
__asm____volatile("int$0x80":"=a"(__res):"0"(4),"b"((long)(fd)),"c"((long)(buf)),"d"((long)(count)));) W. s+ A" S8 p6 |2 h6 @6 [
if(__res%26gt;=0). S; R1 V: n# K* I+ y5 I# H
return(ssize_t)__res;4 E$ Z4 I6 b  G/ e& ?) \
errno=-__res;+ {* Y* a" b6 h0 ^- H! N0 \
return-1;
4 U7 [, K. z$ h& o1 D1 ?4 a};
! R% j, L1 [* P, a" b6 t! S) E: I4 G7 B) n/ D7 ]2 V' |: |
main()
, _, Q3 C$ x% a7 ~) N8 ?/ R{. [" q$ I0 u* j! b( `8 f. K
char*t="thisisatest.\n";. V5 R5 d" A2 M; G# f
write(0,t,strlen(t));  P3 F% ^7 ~1 Q8 q
}8 }% C3 \& k; K* I, l/ C
[root@plaguezkernel]#exit) u7 E4 @0 ~: d8 q; c
! i5 r/ S7 H2 ?8 f. Q" E* N
注意那个write()里的"0"这个参数匹配SYS_write，在/usr/include/sys/syscall.h中定义。* Q; P" [  _! _; I

$ s% h+ ?  ~$ N- a7 ]& m
) f" `) ^/ @  ?6 T. G( d) N3 [/ V0 {7 u+ P
*构建你自己的系统调用。
2 C+ q0 z/ c- d* A+ f3 E3 X$ c, l' t! W
这里给出了几个构建你自己的系统调用的方法。% X. h% L6 z2 g6 o
举个例子,你可以修改内核代码并且加入你自己的代码。一个比较简单可行的方法,
5 F& [1 i: c) m0 Y( d不过,一定要被写成可加载内核模块。
+ N+ V( c+ @( I; c5 m( W- r$ o
" K) r! e* T; S' U4 x0 k+ c没有一个代码可以象可加载内核模块那样可以当内核需要的时候被随时加载的。1 T# Q* j3 @2 l* L- S
% ], g4 T* r1 e3 N& O2 Y
我们的主要意图是需要一个很小的内核,当我们需要的时候运行insmod命令，给定的驱动就可以被5 {# l: s* y7 ]" {, O3 P. m1 S) w
自动加载。这样卸除来的lkm程序一定比在内核代码树里写代码要简单易行多了。8 r3 u* a! u8 @3 a5 s9 J
* }$ f: A: {9 b4 J
*写lkm程序
( ]( Y* k; R, G/ m, y* ?9 n3 o! T: K4 o; s! |5 O1 a! J
一个lkm程序可以用c来很容易编写出来。& n4 j! h1 K/ E, s5 q2 c
它包含了大量的#defines,一些函数,一个初始化模块的函数，叫做init_module()，和一个卸载
  E% p7 L" I2 j: u4 B- n函数：cleanup_module()。
1 u! \; V2 t% e3 L) u6 }! j
# J; X9 y' \: j( Y# O/ K这里有一个经典的lkm代码结构:" m3 \6 T- `; ?& F7 _1 I
5 ?5 {) K4 P0 ~* Q$ f% I2 G
. K) o  [; _/ u5 U. Q; S
#defineMODULE
% m8 _( ~+ |9 G% q' e4 B- V7 B+ g#define__KERNEL__& c) b  E4 a9 ?; @  [6 v
#define__KERNE_SYSCALLS__2 }. N+ U! @4 y* v! |
  ~( U2 L& ^: W: d6 m% F7 l9 v; {& K
#include
5 o+ n, U. R. i& \- M#ifdefMODULE& l. V8 J& {# s
#include
& S4 n' Y: w7 b#include
& S, w7 {& Y! y. Q5 ?& {% I# x#else
4 ^$ \# s7 ?& R, `* v#defineMOD_INC_USE_COUNT% t  x( ]: J  O( T' N; i) F
#defineMOD_DEC_USE_COUNT
; d& b/ s& B; D) z: u- o+ |#endif, y& L  y! z8 n% J

& _- `# \. ^/ p; }6 N1 K* S#include1 i1 ?% s2 t3 a' H, z2 D
#include
. r; k  ~2 ]& M2 ?3 j#include: m3 W7 c; \  H$ M
#include
9 s9 U3 [" ?' d* w+ q#include
5 @$ b) D; V! q; R8 j: O% e; n#include0 {; U7 I! e1 t; b
#include
& {0 k5 d6 n$ R+ U; e& Q: e* R3 u#include1 ~, {$ f* H( `& @+ y
#include7 S+ W- ?7 K: I- k, c
#include0 ]1 T, f! H0 _1 x7 G9 G. @  A
#include) a* D& h# Q; |0 E" w$ _( V
#include2 I* ]2 T- |& c, ~8 N  h. V, ^
#include
" }% [$ }+ d5 t' @: b* B" {% S$ k' h2 B. _
interrno;3 s0 _+ T* t; g7 y! A" w" M' y

7 Q4 s6 d; u: U* j# D$ echartmp[64];
# Y9 m2 j0 m* `0 T$ [0 U: G& U3 q/ {5 a  O  Z4 |3 @
/*假如，我们要用到ioctl调用*/) r2 B1 ^4 J& x1 Q# ]6 W
_syscall3(int,ioctl,int,d,int,request,unsignedlong,arg);. u+ J3 _, F6 t  y, r0 t
, C; O0 Y9 Y0 n1 G6 ~& w
intmyfunction(intparm1,char*parm2)" @' K. H5 w# ^
{; g  Z( f- \2 t( G0 S# Q8 e
inti,j,k;
3 {+ U) Z8 p. F  {1 l/*...*/' `$ R9 I% r  I5 \  ^/ ~
}- x( ~5 S$ b4 f% p( ^
1 b0 }$ L" @$ C) _/ d; i. U1 a- H
intinit_module(void)
* r2 H4 |' O& P{
! v$ I; Y7 E+ S  E5 q4 a/*...*/- u; Y8 @6 z+ k/ m  v% F
printk("\nModuleloaded.\n");& w  O  L2 _1 x2 g( a& w
return0;, k  K+ O# G! R
}% [  j5 ]% a0 i& ]
' ]/ \' g, B& h$ |8 k( L2 y1 I; [
voidcleanup_module(void)
) X. Y) ?9 L* f9 R; W{. K2 q2 {4 M; @* i) w  k( b7 ?
/*...*/
4 c# s' B, N- T0 r5 K5 z- @}+ N( }" [, g0 E0 w& R) e2 ]) N

" p5 e, |; E; h; G' o检查代码中的#defines(#defineMODULE,#define__KERNEL__)和; D, \  n& T5 d6 Z
#includes(#include...)
" j3 [1 c- m) W/ ?5 }7 k8 e4 @' n; K  X% v! D, P
一定要注意的是我们的lkm讲要被运行在内核状态,我们就不能用libc包装的函数了,但是我们可以
8 [5 {5 ?/ _+ x0 y, ~) t2 L通过前面所讨论的_syscallX()宏来构建系统调用。
( O+ C5 a% T: d9 x5 e4 O0 k8 S3 g/ H
! M0 ^9 |5 j* T  R1 ~& o! s你可以这样编译你的模块'gcc-c-O3module.c'并且利用'insmodmodule.o'来加载。
1 Y, _, r  `* H( f: C# W3 h* S' y
' M" U" I( B9 c提一个建议,lkm也可以用来在不完全重建核心代码的情况下来修改内核代码。举个例子,你可以修改# \0 ~- F# s* i& u. M: F+ i
write系统调用让它隐藏一部分给定的文件，就象我们把我们的backdoors放到一个非常好的地方：当: p* w0 w: A1 m% d, m
你无法再信任你的系统内核的时候会怎么样呢？! t; L0 Z  `. e, k7 i; O
# {8 Y- X, i! t; |: a/ E: M/ z

& k4 ?* M2 V6 o
4 c" z, l( y8 F0 c. Q*内核和系统调用后门4 f& I# A+ c+ h' F9 Y3 u

6 j6 G. i2 l! Y( W4 j" l4 m在简单介绍了上述理论，我们主要可以用来做什么呢。我们可以利于lkm截获一些对我们有影响的系
$ y; a- o+ {" u) p3 w统调用,这样可以强制内核按照我们的方式运行。例如：我们可以利用ioctl系统调用来隐藏sniffer: S! ~) ]$ e9 E- m
所造成的网卡PROMISC模式的显示。非常有效。
$ y' Q9 N% w7 V$ F! V! T
, i) V" [4 F+ o& ]. {去改变一个给定的系统调用,只需要在你的lkm程序中增加一个定义externvoid*sys_call_table[],; D) f& j% ]) p. j! R- [1 j- D
并且利用init_module()函数来改变sys_call_table里的入口来指向我们自己的代码。改变后的调用可
2 i: Y; ^0 d, G" M/ C* u# Z以做我们希望它做的一切事情,利用改变sys_call_table来导出更多的原系统调用，并且。。。。
3 F% @% [2 {5 Z2 C  n' J& q& e( ?. J2 B1 U; g" X

' E, ^5 ?: P5 g3 M5 }, ]译者后话：这篇文章相对比较浅显易懂，所以可以作为大家入门lkm编程来用，它着重讲述了linux系
+ j4 l. n9 F: s9 {3 b6 j3 q统调用systemcall的原理，以及我们如何通过lkm来截获它并换成我们想要的代码来建立后门程序。
. s* ?; _- V5 h/ K# L再次强调本文的依据是linux内核版本2.0.x，大家在自己系统实现时请对比内核代码来做改变。

******请登陆论坛查看内容******