Chinaunix

标题: 突破linux内核模块验证 [打印本页]

---

作者: W.Z.T    时间: 2009-12-25 10:55
标题: 突破linux内核模块验证
本篇文章是讲内核安全方面的， 不感兴趣的同学可绕过， 文章写的比较仓促， 有问题的话， 欢迎指出。

Bypassing Linux kernel module version check

By wzt

1、 为什么要突破模块验证
2、 内核是怎么实现的
3、 怎样去突破
4、 总结
5、 参考
6、 附录


1、 为什么要突破模块验证
    Linux内核版本很多，升级很快，2个小内核版本中内核函数的定义可能都不一样，为了确保不一致的驱动程序导致kernel oops，
    开发者加入了模块验证机制。它在加载内核模块的时候对模块进行校验， 如果模块与主机的一些环境不一致，就会加载不成功。
    看下面一个例子，它简单的输出当期系统中的模块列表：

1. 
   
2. #include <linux/kernel.h>
   
3. #include <linux/module.h>
   
4. #include <linux/init.h>
   
5. #include <linux/version.h>
   
6. #include <linux/string.h>
   
7. #include <linux/list.h>
   
8. 
   
9. MODULE_LICENSE("GPL");
   
10. MODULE_AUTHOR("wzt");
    
11. 
    
12. struct module *m = &__this_module;
    
13. 
    
14. int print_module_test(void)
    
15. {
    
16.         struct module *mod;
    
17. 
    
18.         list_for_each_entry(mod, &m->list, list) {
    
19.                 printk("%s\n", mod->name);
    
20.         }
    
21.         return NULL;
    
22. }
    
23. 
    
24. static int list_print_init(void)
    
25. {
    
26.         printk("load list_print module.\n");
    
27. 
    
28.         print_module_test();
    
29. 
    
30.         return 0;
    
31. }
    
32. 
    
33. static void list_print_exit(void)
    
34. {
    
35.         printk("unload list_print module.\n");
    
36. }
    
37. 
    
38. module_init(list_print_init);
    
39. module_exit(list_print_exit);
    

复制代码

我们在centos5.3环境中编译一下：

1. 
   
2. [root@localhost list]# uname -a
   
3. Linux localhost.localdomain 2.6.18-128.el5 #1 SMP Wed Jan 21 10:44:23 EST 2009 i686 i686 i386 GNU/Linux
   

复制代码

然后拷贝到另一台主机centos5.1xen上：

1. 
   
2. [root@localhost ~]# uname -a
   
3. Linux localhost.localdomain 2.6.18-53.el5xen #1 SMP Mon Nov 12 03:26:12 EST 2007 i686 i686 i386 GNU/Linux
   

复制代码

用insmod加载：

1. 
   
2. [root@localhost ~]# insmod list.ko
   
3. insmod: error inserting 'list.ko': -1 Invalid module format
   

复制代码

报错了，在看下dmesg的信息：

1. 
   
2. [root@localhost ~]# dmesg|tail -n 1
   
3. list: disagrees about version of symbol struct_module
   

复制代码

先不管这是什么， 总之我们的模块在另一台2.6.18的主机中加载失败。 通常的做法是要在主机中对源代码进行编译，
然后才能加载成功， 但是如果主机中缺少内核编译环境的话， 我们的rootkit就不能编译， 也不能安装在主机之中，
这是多么尴尬的事情。 没错， 这就是linux kernel开发的特点， 你别指望像windows驱动一样，编译一个驱动，
然后可以满世界去装^_^. 一些rootkit开发者抛弃了lkm类型rk的开发， 转而去打kmem, mem的注意，像sk，
moodnt这样的rk大家都喜欢， 可以在用户层下动态patch内核，不需要编译环境， wget下来，install即可。
但是它也有很多缺点，比如很不稳定，而且在2.6.x后内核已经取消了kmem这个设备， mem文件也做了映射和读写的
限制。 rk开发者没法继续sk的神话了。反过来， 如果我们的lkm后门不需要编译环境，也可以达到直接insmod的目的，
这是件多么美好的事情，而且lkm后门更加稳定，还不用像sk在内核中添加了很多自己的数据结构。


2、内核是怎么实现的
   我们去看看内核在加载模块的时候都干了什么， 或许我们可以发现点bug， 然后做点手脚，欺骗过去：）
   grep下dmesg里的关键字， 看看它在哪个文件中：

1. 
   
2. [root@localhost linux-2.6.18]# grep -r -i 'disagrees about' kernel/
   
3. kernel/module.c:                printk("%s: disagrees about version of symbol %s\n",
   

复制代码

2.6.18/kernel/module.c:
insmod调用了sys_init_module这个系统调用, 然后进入load_module这个主函数，它解析elf格式的ko文件，然后加载
到内核中：

1. 
   
2. /* Allocate and load the module: note that size of section 0 is always
   
3.    zero, and we rely on this for optional sections. */
   
4. static struct module *load_module(void __user *umod,
   
5.                                   unsigned long len,
   
6.                                   const char __user *uargs)
   
7. {
   
8. ...
   
9.         if (!check_modstruct_version(sechdrs, versindex, mod)) {
   
10.                 err = -ENOEXEC;
    
11.                 goto free_hdr;
    
12.         }
    
13. 
    
14.         modmagic = get_modinfo(sechdrs, infoindex, "vermagic");
    
15.         /* This is allowed: modprobe --force will invalidate it. */
    
16.         if (!modmagic) {
    
17.                 add_taint(TAINT_FORCED_MODULE);
    
18.                 printk(KERN_WARNING "%s: no version magic, tainting kernel.\n",
    
19.                        mod->name);
    
20.         } else if (!same_magic(modmagic, vermagic)) {
    
21.                 printk(KERN_ERR "%s: version magic '%s' should be '%s'\n",
    
22.                        mod->name, modmagic, vermagic);
    
23.                 err = -ENOEXEC;
    
24.                 goto free_hdr;
    
25.         }
    
26. ...
    
27. }
    

复制代码

check_modstruct_version就是用来计算模块符号的一些crc值，不相同就会出现我们在dmesg里看到的
“disagrees about version of symbol”信息。 get_modinfo取得了内核本身的vermagic值，然后用same_magic
函数和内核的vermagic去比较，不同也会使内核加载失败。 所以在这里，我们看到内核对模块验证的时候采用了
2层验证的方法：模块crc值和vermagic检查。

继续跟踪check_modstruct_version， 现在的内核默认的都开启了CONFIG_MODVERSIONS， 如果没有指定这个选项，
函数为空，我们的目的是要在As, Centos下安装模块，redhat不是吃干饭的， 当然开了MODVERSIONS选项。

1. 
   
2. static inline int check_modstruct_version(Elf_Shdr *sechdrs,
   
3.                                           unsigned int versindex,
   
4.                                           struct module *mod)
   
5. {
   
6.         const unsigned long *crc;
   
7.         struct module *owner;
   
8. 
   
9.         if (!__find_symbol("struct_module", &owner, &crc, 1))
   
10.                 BUG();
    
11.         return check_version(sechdrs, versindex, "struct_module", mod,
    
12.                              crc);
    
13. }
    

复制代码

__find_symbol找到了struct_module这个符号的crc值，然后调用check_version去校验：

1. 
   
2. static int check_version(Elf_Shdr *sechdrs,
   
3.                          unsigned int versindex,
   
4.                          const char *symname,
   
5.                          struct module *mod,
   
6.                          const unsigned long *crc)
   
7. {
   
8.         unsigned int i, num_versions;
   
9.         struct modversion_info *versions;
   
10. 
    
11.         /* Exporting module didn't supply crcs?  OK, we're already tainted. */
    
12.         if (!crc)
    
13.                 return 1;
    
14. 
    
15.         versions = (void *) sechdrs[versindex].sh_addr;
    
16.         num_versions = sechdrs[versindex].sh_size
    
17.                 / sizeof(struct modversion_info);
    
18. 
    
19.         for (i = 0; i < num_versions; i++) {
    
20.                 if (strcmp(versions[i].name, symname) != 0)
    
21.                         continue;
    
22. 
    
23.                 if (versions[i].crc == *crc)
    
24.                         return 1;
    
25.                 printk("%s: disagrees about version of symbol %s\n",
    
26.                        mod->name, symname);
    
27.                 DEBUGP("Found checksum %lX vs module %lX\n",
    
28.                        *crc, versions[i].crc);
    
29.                 return 0;
    
30.         }
    
31.         /* Not in module's version table.  OK, but that taints the kernel. */
    
32.         if (!(tainted & TAINT_FORCED_MODULE)) {
    
33.                 printk("%s: no version for \"%s\" found: kernel tainted.\n",
    
34.                        mod->name, symname);
    
35.                 add_taint(TAINT_FORCED_MODULE);
    
36.         }
    
37.         return 1;
    
38. }
    

复制代码

它搜寻elf的versions小节， 循环遍历数组中的每个符号表，找到struct_module这个符号，然后去比较crc的值。
现在有个疑问， versions小节是怎么链接到模块的elf文件中去的呢?  在看下编译后的生成文件， 有一个list.mod.c

1. 
   
2. [root@localhost list]# cat list.mod.c
   
3. #include <linux/module.h>
   
4. #include <linux/vermagic.h>
   
5. #include <linux/compiler.h>
   
6. 
   
7. MODULE_INFO(vermagic, VERMAGIC_STRING);
   
8. 
   
9. struct module __this_module
   
10. __attribute__((section(".gnu.linkonce.this_module"))) = {
    
11. .name = KBUILD_MODNAME,
    
12. .init = init_module,
    
13. #ifdef CONFIG_MODULE_UNLOAD
    
14. .exit = cleanup_module,
    
15. #endif
    
16. };
    
17. 
    
18. static const struct modversion_info ____versions[]
    
19. __attribute_used__
    
20. __attribute__((section("__versions"))) = {
    
21.         { 0x89e24b9c, "struct_module" },
    
22.         { 0x1b7d4074, "printk" },
    
23. };
    
24. 
    
25. static const char __module_depends[]
    
26. __attribute_used__
    
27. __attribute__((section(".modinfo"))) =
    
28. "depends=";
    
29. 
    
30. 
    
31. MODULE_INFO(srcversion, "26DB52D8A56205333D414B9");
    

复制代码

这个文件是模块在编译的时候，调用了linux-2.6.18/scripts/modpost这个文件生成的。
里面增加了2个小节.gnu.linkonce.this_module和__versions。 __versions小节的内容就是
一些字符串和值组成的数组，check_version就是解析这个小节去做验证。 这里还有一个
MODULE_INFO宏用来生成模块的magic字符串，这个在以后的vermagic中要做验证。

先看下vermagic的格式：

1. 
   
2. [root@localhost list]# modinfo list.ko
   
3. filename:       list.ko
   
4. author:         wzt
   
5. license:        GPL
   
6. srcversion:     26DB52D8A56205333D414B9
   
7. depends:        
   
8. vermagic:       2.6.18-128.el5 SMP mod_unload 686 REGPARM 4KSTACKS gcc-4.1
   

复制代码

这里可以看到vermagic跟内核版本，smp，gcc版本，内核堆栈大小都有关。

1. 
   
2. /* First part is kernel version, which we ignore. */
   
3. static inline int same_magic(const char *amagic, const char *bmagic)
   
4. {
   
5.         amagic += strcspn(amagic, " ");
   
6.         bmagic += strcspn(bmagic, " ");
   
7.         return strcmp(amagic, bmagic) == 0;
   
8. }
   

复制代码

same_magic忽略了对内核版本的判断， 直接比较后面的值。

3、怎样去突破

  知道了内核是怎么实现的了， 下面开始想办法绕过这些验证：）

  3.1 怎么突破crc验证：
  
  在仔细看下代码：

1. 
   
2.         for (i = 0; i < num_versions; i++) {
   
3.                 if (strcmp(versions[i].name, symname) != 0)
   
4.                         continue;
   
5. 
   
6.                 if (versions[i].crc == *crc)
   
7.                         return 1;
   
8.                 printk("%s: disagrees about version of symbol %s\n",
   
9.                        mod->name, symname);
   
10.                 DEBUGP("Found checksum %lX vs module %lX\n",
    
11.                        *crc, versions[i].crc);
    
12.                 return 0;
    
13.         }
    
14.         /* Not in module's version table.  OK, but that taints the kernel. */
    
15.         if (!(tainted & TAINT_FORCED_MODULE)) {
    
16.                 printk("%s: no version for \"%s\" found: kernel tainted.\n",
    
17.                        mod->name, symname);
    
18.                 add_taint(TAINT_FORCED_MODULE);
    
19.         }
    
20.         return 1;
    

复制代码

check_version在循环中只是在寻找struct_module符号， 如果没找到呢？ 它会直接返回1！  没错， 这是一个
逻辑bug，在正常情况下，module必会有一个struct_module的符号， 这是modpost生成的。如果我们修改elf文件，
把struct_module这个符号改名，岂不是就可以绕过crc验证了吗？ 先做个实验看下：
.mod.c是由modpost这个工具生成的， 它在linux-2.6.18/scripts/Makefile.modpost文件中被调用， 去看下：

1. 
   
2. PHONY += __modpost
   
3. __modpost: $(wildcard vmlinux) $(modules:.ko=.o) FORCE
   
4.         $(call cmd,modpost)
   

复制代码

我们用一个很土的方法， 就是在编译模块的时候，modpost生成.mod.c文件后， 暂停下编译，sleep 30秒吧，我们用
这个时间去改写下.mod.c， 把struct_module换个名字。

1. 
   
2. PHONY += __modpost
   
3. __modpost: $(wildcard vmlinux) $(modules:.ko=.o) FORCE
   
4.         $(call cmd,modpost)
   
5.         @sleep 30
   

复制代码

随便将struct_module改个名：

1. 
   
2. [root@localhost list]# cat list.mod.c
   
3. #include <linux/module.h>
   
4. #include <linux/vermagic.h>
   
5. #include <linux/compiler.h>
   
6. 
   
7. MODULE_INFO(vermagic, VERMAGIC_STRING);
   
8. 
   
9. struct module __this_module
   
10. __attribute__((section(".gnu.linkonce.this_module"))) = {
    
11. .name = KBUILD_MODNAME,
    
12. .init = init_module,
    
13. #ifdef CONFIG_MODULE_UNLOAD
    
14. .exit = cleanup_module,
    
15. #endif
    
16. };
    
17. 
    
18. static const struct modversion_info ____versions[]
    
19. __attribute_used__
    
20. __attribute__((section("__versions"))) = {
    
21.         { 0x89e24b9c, "stauct_module" },
    
22.         { 0x1b7d4074, "printk" },
    
23. };
    
24. 
    
25. static const char __module_depends[]
    
26. __attribute_used__
    
27. __attribute__((section(".modinfo"))) =
    
28. "depends=";
    
29. 
    
30. MODULE_INFO(srcversion, "26DB52D8A56205333D414B9");
    

复制代码

我们是在centos5.3下编译的， 然后拷贝到centos5.1下， 在执行下insmod看下：

1. 
   
2. [root@localhost ~]# insmod list.ko
   
3. [root@localhost ~]# dmesg|tail
   
4. ata_piix
   
5. libata
   
6. sd_mod
   
7. scsi_mod
   
8. ext3
   
9. jbd
   
10. ehci_hcd
    
11. ohci_hcd
    
12. uhci_hcd
    

复制代码

成功了！ 这跟我们预期的一样， 我们用这个逻辑bug绕过了模块的crc验证！ 这个bug直到2.6.31版本中
才得到修正。 我们可以用这种方法在redhat主机中任意安装模块了。 那么怎样绕过在2.6.31以后的内核呢？
看下它是怎么修补的：

1. 
   
2.         for (i = 0; i < num_versions; i++) {
   
3.                 if (strcmp(versions[i].name, symname) != 0)
   
4.                         continue;
   
5. 
   
6.                 if (versions[i].crc == *crc)
   
7.                         return 1;
   
8.                 DEBUGP("Found checksum %lX vs module %lX\n",
   
9.                        *crc, versions[i].crc);
   
10.                 goto bad_version;
    
11.         }
    
12. 
    
13.         printk(KERN_WARNING "%s: no symbol version for %s\n",
    
14.                mod->name, symname);
    
15.         return 0;
    
16. 
    
17. bad_version:
    
18.         printk("%s: disagrees about version of symbol %s\n",
    
19.                mod->name, symname);
    
20. 
    
21.         return 0;
    

复制代码

如果没找到struct_module也会返回0， 这样我们就必须将struct_module的值改为正确后， 才能继续安装。
如何找到模块符号的crc值呢? 我们可以去找目标主机中那些已被系统加载的模块的crc值，如ext3文件系统
的模块， 自己写个程序去解析elf文件， 就可以得到某些符号的crc值了。
还有没有更简单的方法呢？去/boot目录下看看，symvers-2.6.18-128.el5.gz貌似和crc有关，gunzip解压后看看：

1. 
   
2. [root@localhost boot]# grep 'struct_module' symvers-2.6.18-128.el5
   
3. 0x89e24b9c      struct_module   vmlinux EXPORT_SYMBOL
   

复制代码

原来内核中所有符号的crc值都保存在这个文件中。如何改写struct_module的值呢，可以用上面那个土方法，
或者自己写程序去解析elf文件， 然后改写其值。本文最后附上一个小程序用来修改elf的符号和crc值。

3.2 如何突破vermagic验证：
   如果我们用list.mod.c中的做法， 用MODULE_INFO宏来生成一个与目标主机相同的vermagic呢？ 答案是
否定的，gcc链接的时候会把modinfo小节链接在最后，加载模块的时候还是会读取第一个.modinfo小节。
我们可以用上面那种很土的方法， 先用modinfo命令得到目标主机中某个模块的信息：

1. 
   
2. [root@localhost list]# modinfo /lib/modules/2.6.18-128.el5/kernel/fs/ext3/ext3.ko
   
3. filename:       /lib/modules/2.6.18-128.el5/kernel/fs/ext3/ext3.ko
   
4. license:        GPL
   
5. description:    Second Extended Filesystem with journaling extensions
   
6. author:         Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others
   
7. srcversion:     B048AC103E5034604A721C5
   
8. depends:        jbd
   
9. vermagic:       2.6.18-128.el5 SMP mod_unload 686 REGPARM 4KSTACKS gcc-4.1
   
10. module_sig:     883f3504977495e4f3f897cd3dced211288209f551cc1da557f96ea18d9a4efd6cfb0fc2612e009c8845fd776c825d586f492ceab19e17b2319da8f
    

复制代码

然后在用那个很土的方面， 将.mod.c中vermagic值进行修改。还有一种直接修改elf文件的方法，附录在本文后面。

4、总结
  前面有一点没有提到， 就是某些内核版本的相同接口的函数代码可能已经变化， 这样在使用这项技术的时候，
  最好在同一个大内核版本使用。你也可能感觉要想跨平台安装模块有些麻烦， 这里还有2个方法， 作为一个专业
  搞渗透的人来说，他会自己在本地装很多发行版本的linux，特别是root掉一台主机后，会在本地装一个一模一样
  的发行版本，smp、kernel stack size、gcc version都一样。在本地机器装上开发环境，这样编译出来的模块
  也是可以直接装到目标主机上的，但这很麻烦，因为linux有太多的发行版本了：）， 另一个方法就是自己
  装一个linux，编译下内核，然后将build后的开发包集成到自己的后门里， 压缩后大概几m。 然后传到主机
  去解压，编译。庆幸的是，现在大多数主机中都有内核开发环境， 直接去主机编译就ok了。

5、参考
【1】 linux kernel source code
       http://www.kernel.org
【2】 module injection in 2.6 kernel - Coolq
       http://www.nsfocus.net/index.php ... o=view&mid=2533

[ 本帖最后由 W.Z.T 于 2009-12-25 11:00 编辑 ]

---

作者: W.Z.T    时间: 2009-12-25 10:56
6、附录

1. 
   
2. /*
   
3. * Linux kernel module fucker
   
4. *
   
5. * by wzt       <[email]wzt.wzt@gmail.com[/email]>
   
6. *
   
7. */
   
8. 
   
9. #include <stdio.h>
   
10. #include <string.h>
    
11. #include <stdlib.h>
    
12. #include <unistd.h>
    
13. #include <fcntl.h>
    
14. #include <elf.h>
    
15. #include <sys/stat.h>
    
16. #include <sys/mman.h>
    
17. 
    
18. #define MODULE_NAME_LEN         (64 - sizeof(unsigned long))
    
19. 
    
20. struct modversion_info
    
21. {
    
22.         unsigned long crc;
    
23.         char name[MODULE_NAME_LEN];
    
24. };
    
25. 
    
26. Elf32_Ehdr *ehdr = NULL;
    
27. Elf32_Phdr *phdr = NULL;
    
28. Elf32_Shdr *shdr = NULL;
    
29. Elf32_Shdr *shstrtab = NULL;
    
30. Elf32_Sym *dynsym_ptr = NULL;
    
31. Elf32_Sym *symtab_ptr = NULL;
    
32. Elf32_Sym *dynstr_ptr = NULL;
    
33. 
    
34. char *Real_strtab = NULL;
    
35. char *dynstr = NULL;
    
36. char *strtab_ptr = NULL;
    
37. char dynstr_buffer[2048];   
    
38. char strtab_buffer[4096];
    
39. char *real_strtab = NULL;
    
40. 
    
41. unsigned int shstrtab_off, shstrtab_len, shstrtab_num;
    
42. unsigned int strtab_off, strtab_size;
    
43. 
    
44. int elf_fd;
    
45. struct stat f_stat;
    
46.    
    
47. void usage(char *pro)
    
48. {
    
49.         fprintf(stderr, "usage: %s <options> <module>\n\n", pro);
    
50.         fprintf(stderr, "-w -v\tCheck vermgaic in module.\n");
    
51.         fprintf(stderr, "-w -c\tCheck crc value in module.\n");
    
52.         fprintf(stderr, "-s -v <new_vermagic>\tSet vermagic in module.\n");
    
53.         fprintf(stderr, "-s -c\tSet crc value in module.\n");
    
54. 
    
55.         exit(0);
    
56. }
    
57. 
    
58. int init_load_elf(char *elf_file)
    
59. {
    
60.         char buff[1024];
    
61. 
    
62.         elf_fd = open(elf_file, O_RDWR);
    
63.         if (elf_fd == -1) {
    
64.                 perror("open");
    
65.                 return 0;
    
66.         }
    
67.         fprintf(stderr, "[+] Open %s ok.\n", elf_file);
    
68. 
    
69.         if (fstat(elf_fd, &f_stat) == -1) {
    
70.                 perror("fstat");
    
71.                 return 0;
    
72.         }
    
73. 
    
74.         ehdr = (Elf32_Ehdr *)mmap(NULL, f_stat.st_size, PROT_WRITE|PROT_READ, MAP_SHARED, elf_fd, 0);
    
75.         if(ehdr == MAP_FAILED) {
    
76.                 perror("mmap");
    
77.                 return 0;
    
78.         }
    
79. 
    
80.         phdr = (Elf32_Phdr *)((unsigned long)ehdr + ehdr->e_phoff);
    
81.         shdr = (Elf32_Shdr *)((unsigned long)ehdr + ehdr->e_shoff);
    
82. 
    
83.         shstrtab = &shdr[ehdr->e_shstrndx];
    
84.         shstrtab_off = (unsigned int)shstrtab->sh_offset;
    
85.         shstrtab_len = shstrtab->sh_size;
    
86. 
    
87.         real_strtab = (char *)( (unsigned long)ehdr + shstrtab_off );
    
88. 
    
89.         printf("[+] .Shstrtab Size :0x%x,%d\n", shstrtab->sh_size, shstrtab->sh_name);
    
90.         printf("[+] .Shstrtab Off: 0x%x\n", shstrtab_off);
    
91. 
    
92.         return 1;
    
93. }
    
94. 
    
95. int display_module_crc_info(void)
    
96. {
    
97.         struct modversion_info *versions;
    
98.         char *buff = NULL;
    
99.         unsigned int version_off, version_size, num_versions;
    
100.         int i, j;
     
101. 
     
102.         buff = (char *)malloc(shstrtab_len + 2);
     
103.         if (!buff) {
     
104.                 fprintf(stderr, "[-] Malloc failed.\n");
     
105.                 return 0;
     
106.         }
     
107. 
     
108.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
109.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
110.                 if (!strcmp(buff + shdr[i].sh_name,"__versions")){
     
111.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
112.                         version_off = (unsigned int)shdr[i].sh_offset;
     
113.                         version_size = (unsigned int)shdr[i].sh_size;
     
114.                         printf("[+] version off: 0x%x\n", version_off);
     
115.                         printf("[+] version size: 0x%x\n", version_size);
     
116.                         break;
     
117.                 }
     
118.         }
     
119. 
     
120.         printf("[+] %x,%x\n", (unsigned long)ehdr + version_off, shdr[i].sh_addr);
     
121.         versions = (void *)((unsigned long)ehdr + version_off);
     
122.         num_versions = version_size / sizeof(struct modversion_info);
     
123.         printf("[+] num_versions: %d\n", num_versions);
     
124. 
     
125.         for (j = 0; j < num_versions; j++) {
     
126.                 printf("[+] %s:0x%08x.\n", versions[j].name, versions[j].crc);
     
127.         }
     
128. 
     
129.         free(buff);
     
130.         return 1;
     
131. }
     
132. 
     
133. int set_module_crc_info(void)
     
134. {
     
135.         struct modversion_info *versions;
     
136.         char *buff = NULL;
     
137.         unsigned int version_off, version_size, num_versions;
     
138.         int i, j;
     
139. 
     
140.         buff = (char *)malloc(shstrtab_len + 2);
     
141.         if (!buff) {
     
142.                 fprintf(stderr, "[-] Malloc failed.\n");
     
143.                 return 0;
     
144.         }
     
145. 
     
146.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
147.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
148.                 if (!strcmp(buff + shdr[i].sh_name,"__versions")){
     
149.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
150.                         version_off = (unsigned int)shdr[i].sh_offset;
     
151.                         version_size = (unsigned int)shdr[i].sh_size;
     
152.                         printf("[+] version off: 0x%x\n", version_off);
     
153.                         printf("[+] version size: 0x%x\n", version_size);
     
154.                         break;
     
155.                 }
     
156.         }
     
157. 
     
158.         printf("[+] %x,%x\n", (unsigned long)ehdr + version_off, shdr[i].sh_addr);
     
159.         versions = (void *)((unsigned long)ehdr + version_off);
     
160.         num_versions = version_size / sizeof(struct modversion_info);
     
161.         printf("[+] num_versions: %d\n", num_versions);
     
162. 
     
163.         for (j = 0; j < num_versions; j++) {
     
164.                 printf("[+] %s:0x%08x.\n", versions[j].name, versions[j].crc);
     
165.                 if (!strcmp(versions[j].name, "struct_module")) {
     
166.                         fprintf(stderr, "[+] Found symbol struct_module.\n");
     
167.                         versions[j].name[0] = 'T';
     
168.                         break;
     
169.                 }
     
170.         }
     
171. 
     
172.         for (j = 0; j < num_versions; j++) {
     
173.                 printf("[+] %s:0x%08x.\n", versions[j].name, versions[j].crc);
     
174.         }
     
175. 
     
176.         free(buff);
     
177.         return 1;
     
178. }
     
179. 
     
180. static char *next_string(char *string, unsigned long *secsize)
     
181. {
     
182.         /* Skip non-zero chars */
     
183.         while (string[0]) {
     
184.                 string++;
     
185.                 if ((*secsize)-- <= 1)
     
186.                         return NULL;
     
187.         }
     
188. 
     
189.         /* Skip any zero padding. */
     
190.         while (!string[0]) {
     
191.                 string++;
     
192.                 if ((*secsize)-- <= 1)
     
193.                         return NULL;
     
194.         }
     
195.         return string;
     
196. }
     
197. 
     
198. static char *get_modinfo(Elf32_Shdr *sechdrs, unsigned int info, const char *tag)
     
199. {
     
200.         char *p;
     
201.         unsigned int taglen = strlen(tag);
     
202.         unsigned long size = sechdrs[info].sh_size;
     
203. 
     
204.         for (p = (char *)(ehdr +sechdrs[info].sh_offset); p; p = next_string(p, &size)) {
     
205.                 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
     
206.                         return p + taglen + 1;
     
207.         }
     
208.         return NULL;
     
209. }
     
210. 
     
211. int display_module_vermagic_info(void)
     
212. {
     
213.         char *buff, *p;
     
214.         char *ver = "vermagic";
     
215.         unsigned int taglen = strlen(ver);
     
216.         int size, i;
     
217. 
     
218.         buff = (char *)malloc(shstrtab_len + 2);
     
219.         if (!buff) {
     
220.                 fprintf(stderr, "[-] Malloc failed.\n");
     
221.                 return 0;
     
222.         }
     
223. 
     
224.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
225.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
226.                 if (!strcmp(buff + shdr[i].sh_name,".modinfo")){
     
227.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
228.                         break;
     
229.                 }
     
230.         }
     
231. 
     
232.         size = shdr[i].sh_size;
     
233.         printf("[+] size: 0x%x.\n", size);
     
234. 
     
235.         p = (char *)((unsigned long)ehdr + shdr[i].sh_offset);
     
236.         printf("[+] 0x%08x\n", p);
     
237. 
     
238.         for (; p; p = next_string(p, &size)) {
     
239.                 printf("[+] %s\n", p);
     
240.                 if (strncmp(p, "vermagic", taglen) == 0 && p[taglen] == '=') {
     
241.                         printf("[+] %s\n", p + taglen + 1);
     
242.                         //memset(p + taglen + 1, 'A', 30);
     
243.                 }
     
244.         }
     
245. 
     
246.         return 1;
     
247. }
     
248. 
     
249. int set_module_vermagic_info(char *new_vermagic)
     
250. {
     
251.         char *buff, *p;
     
252.         char *ver = "vermagic";
     
253.         unsigned int taglen = strlen(ver);
     
254.         int size, i;
     
255. 
     
256.         buff = (char *)malloc(shstrtab_len + 2);
     
257.         if (!buff) {
     
258.                 fprintf(stderr, "[-] Malloc failed.\n");
     
259.                 return 0;
     
260.         }
     
261. 
     
262.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
263.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
264.                 if (!strcmp(buff + shdr[i].sh_name,".modinfo")){
     
265.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
266.                         break;
     
267.                 }
     
268.         }
     
269. 
     
270.         size = shdr[i].sh_size;
     
271.         printf("[+] size: 0x%x.\n", size);
     
272. 
     
273.         p = (char *)((unsigned long)ehdr + shdr[i].sh_offset);
     
274.         printf("[+] 0x%08x\n", p);
     
275. 
     
276.         for (; p; p = next_string(p, &size)) {
     
277.                 printf("[+] %s\n", p);
     
278.                 if (strncmp(p, "vermagic", taglen) == 0 && p[taglen] == '=') {
     
279.                         printf("[+] %s\n", p + taglen + 1);
     
280.                         if (strlen(p + taglen + 1) < strlen(new_vermagic)) {
     
281.                                 printf("[-] New vermagic len must < current magic len.\n");
     
282.                                 return 0;
     
283.                         }
     
284.                         memset(p + taglen + 1, '\0', strlen(new_vermagic));
     
285.                         memcpy(p + taglen + 1, new_vermagic, strlen(new_vermagic));
     
286.                 }
     
287.         }
     
288. 
     
289.         return 1;
     
290. }
     
291. 
     
292. int exit_elf_load(void)
     
293. {
     
294.         close(elf_fd);
     
295.         if (munmap(ehdr, f_stat.st_size) == -1) {
     
296.                 return 0;
     
297.         }
     
298. 
     
299.         return 1;
     
300. }
     
301. 
     
302. int main(int argc, char **argv)
     
303. {
     
304.         if (argc == 1) {
     
305.                 usage(argv[0]);
     
306.         }
     
307. 
     
308.         if (!strcmp(argv[1], "-w") && !strcmp(argv[2], "-c")) {
     
309.                 fprintf(stderr, "[+] Display %s module crc value.\n", argv[3]);
     
310.                 if (!init_load_elf(argv[3])) {
     
311.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
312.                         return 0;
     
313.                 }
     
314.                 display_module_crc_info();
     
315.                 exit_elf_load();
     
316.         }
     
317.         else if (!strcmp(argv[1], "-s") && !strcmp(argv[2], "-c")) {
     
318.                 fprintf(stderr, "[+] Set %s module crc value.\n", argv[3]);
     
319.                 if (!init_load_elf(argv[3])) {
     
320.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
321.                         return 0;
     
322.                 }
     
323.                 set_module_crc_info();
     
324.                 exit_elf_load();
     
325.         }
     
326.         if (!strcmp(argv[1], "-w") && !strcmp(argv[2], "-v")) {
     
327.                 fprintf(stderr, "[+] Display %s module crc value.\n", argv[3]);
     
328.                 if (!init_load_elf(argv[3])) {
     
329.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
330.                         return 0;
     
331.                 }
     
332.                 display_module_vermagic_info();
     
333.                 exit_elf_load();
     
334.         }
     
335.         if (!strcmp(argv[1], "-s") && !strcmp(argv[2], "-v")) {
     
336.                 fprintf(stderr, "[+] Display %s module crc value.\n", argv[4]);
     
337.                 if (!init_load_elf(argv[4])) {
     
338.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
339.                         return 0;
     
340.                 }
     
341.                 set_module_vermagic_info(argv[3]);
     
342.                 exit_elf_load();
     
343.         }
     
344.         else {
     
345.                 return 0;
     
346.         }
     
347. 
     
348. }
     

复制代码

---

作者: ubuntuer    时间: 2009-12-25 11:19
不错

---

作者: Godbach    时间: 2009-12-25 12:19
多谢LZ的好文。

---

作者: platinum    时间: 2009-12-25 15:34
不同内核版本的公用结构却不能加载的确很烦
但是这样突破的话，一点基本防护都没有了，很容易 oops
个人建议，如果确实有必要的话可以 modprobe -f 加载

---

作者: Godbach    时间: 2009-12-25 15:59

个人建议，如果确实有必要的话可以 modprobe -f 加载

白金兄的意思是强制加载吗

---

作者: emmoblin    时间: 2009-12-25 16:41
终于知道modpost是干嘛用的了

---

作者: platinum    时间: 2009-12-25 17:17

原帖由 Godbach 于 2009-12-25 15:59 发表

白金兄的意思是强制加载吗

对呀，既然可以突破冲突检测而让系统很自然的加载而未告知用户可能有隐患，不如用户直接强制加载

---

作者: W.Z.T    时间: 2009-12-25 17:52

原帖由 platinum 于 2009-12-25 15:34 发表
不同内核版本的公用结构却不能加载的确很烦
但是这样突破的话，一点基本防护都没有了，很容易 oops
个人建议，如果确实有必要的话可以 modprobe -f 加载

如果modprobe -f能这么容易的加载的话，  我不就用费这么大劲来做内核校验技术的研究了~ 不知道兄弟试过没， 呵呵。

---

作者: W.Z.T    时间: 2009-12-25 17:59

原帖由 platinum 于 2009-12-25 15:34 发表
不同内核版本的公用结构却不能加载的确很烦
但是这样突破的话，一点基本防护都没有了，很容易 oops
个人建议，如果确实有必要的话可以 modprobe -f 加载

很容易oops?   呵呵， 不见得， 文章已经说的很清楚了， 大内核版本， 函数接口都不会变很多，尤其向AS5-92, AS5-128之类的版本。

---

作者: platinum    时间: 2009-12-25 19:41

原帖由 W.Z.T 于 2009-12-25 17:59 发表


很容易oops?   呵呵， 不见得， 文章已经说的很清楚了， 大内核版本， 函数接口都不会变很多，尤其向AS5-92, AS5-128之类的版本。

我说很容易 oops，是说在接口不同的情况下会报错，不会在你自己不知情的情况下被强行加载
当然，如果你一定要 modprobe -f xxxx.ko 的话当然也很容易 oops
但对于没有任何提示的内核来说，没有提示自动加载比有提示却强行加载的情况下更容易 oops

另外恕我无知，我还真没见过不能 modprobe -f 而用兄弟的方法却可以加载的模块，兄弟能否提供一个让我测试一下？

---

作者: W.Z.T    时间: 2009-12-25 21:15

1. 
   
2. #include <linux/kernel.h>
   
3. #include <linux/module.h>
   
4. #include <linux/init.h>
   
5. #include <linux/version.h>
   
6. #include <linux/string.h>
   
7. #include <linux/list.h>
   
8. 
   
9. MODULE_LICENSE("GPL");
   
10. MODULE_AUTHOR("wzt");
    
11. 
    
12. struct module *m = &__this_module;
    
13. 
    
14. int print_module_test(void)
    
15. {
    
16.         struct module *mod;
    
17. 
    
18.         list_for_each_entry(mod, &m->list, list) {
    
19.                 printk("%s\n", mod->name);
    
20.         }
    
21.         return NULL;
    
22. }
    
23. 
    
24. static int list_print_init(void)
    
25. {
    
26.         printk("load list_print module.\n");
    
27. 
    
28.         print_module_test();
    
29. 
    
30.         return 0;
    
31. }
    
32. 
    
33. static void list_print_exit(void)
    
34. {
    
35.         printk("unload list_print module.\n");
    
36. }
    
37. 
    
38. module_init(list_print_init);
    
39. module_exit(list_print_exit);
    

复制代码

你可以在as5.2下编译， 然后到as5.4或到as4.7上看看能直接安装不？ 前提是要开启CONFIG_MODVERSIONS选项。

---

作者: platinum    时间: 2009-12-25 22:23
是编译的环境需要开启 CONFIG_MODVERSIONS，还是加载模块的内核需要开启 CONFIG_MODVERSIONS？

---

作者: W.Z.T    时间: 2009-12-26 07:40

原帖由 platinum 于 2009-12-25 22:23 发表
是编译的环境需要开启 CONFIG_MODVERSIONS，还是加载模块的内核需要开启 CONFIG_MODVERSIONS？

加载模块的内核需要开启 CONFIG_MODVERSIONS。 默认的AS系列内核都已经打开这个选项了。

---

作者: platinum    时间: 2009-12-27 08:34
又仔细看了一次文章，真不好意思是我之前没有完全理解你的意图
这个方法可是够危险的啊，不知道 2.6.31 以后的内核会不会再次有针对性的修正……

---

作者: smalloc    时间: 2009-12-29 18:35
这个高版本ko到低版本好使吗?2.6.26到2.6.25 PCI的网卡驱动,PC上做试验麻烦死了.

---

作者: li32768    时间: 2009-12-30 11:04
这个很好很强大，应该多看看理解一下，但是我怎么收藏呢

---

作者: playmud    时间: 2010-01-06 15:12
楼主最好可以再开篇醒目的位置描述一下这种绕过机制的场景，免得误导读者。
linux内核模块的这种验证机制本意是好的，保证其健壮性，但其实现机制是比较差的，

---

作者: W.Z.T    时间: 2010-01-06 15:21
I AM BLACKHAT.

---

作者: swanrobin    时间: 2010-01-11 00:33
好东西，收藏一下！

---

作者: accessory    时间: 2010-01-16 14:29
从头到尾看完了。支持下。

---

作者: mzj1984cs    时间: 2010-01-25 16:51
很好很强大

---

作者: zonian    时间: 2010-02-03 12:27
回复 1# W.Z.T

虽然不会这样去用，但学习了，多谢楼主

---

作者: jjinl    时间: 2010-03-16 10:45
强悍！学习！

---

作者: mxzwish    时间: 2011-11-12 14:11


linux这样设计还有一个目的就是强制所有内核模块开发者开源

否则根本没有通用性！这就是赤裸裸的强制开源精神

我目前在研究vmx，在物理机上不能调试只能靠猜，在bochs上可以调试vmx

想用bochs调试却发现所有发行版都没办法在bochs上安装或使用（有些能安装上的却用不了！bochs太慢了！）

想用ttylinux之类小型linux却没有kernel头文件没办法编译内核模块！

楼主这篇文章好！我可以编译在ttylinux上运行的内核模块了

---

作者: jhl19880722    时间: 2012-10-02 11:18
我想问一下，你这个方法一个核心的解决方法是不是分析文件格式，修改要加载的ko文件里面要检查的参数，我以前也试过直接修改编译的内核参数，让模块加载。

---

作者: mousexqshe    时间: 2014-08-28 15:10
最近正好遇到这个问题，先学习一下，不懂在问。

---

作者: Jacob_linux    时间: 2015-10-20 19:56
楼主 能发下Makefile吗， 我想实现这个跨版本加载的功能，怎么生成module.mod.c之后sleep30秒呢， 求具体操作方法。

---

作者: mordorwww    时间: 2016-02-19 14:47
留 爪, 收藏

---

作者: custjcy    时间: 2019-12-20 16:05


楼主后面发的工具代码，只是把struct_module改名的。如果需要修改某个symbol的crc值，可以参考下面的代码（把楼主的工具修改了一下）。直接存成文件比如module_fucker.c，然后gcc -o module_fucker.bin module_fucker.c 生成可执行文件，然后执行命令修改，例如： ./module_fucker.bin -s -c sample.ko struct_module 0x76656456

如果要修改的地方比较多，可以参考 https://blog.csdn.net/mr_pang_1991/article/details/50014211 帖子生成Module.symvers文件后编译驱动

1. 
   
2. /*
   
3. * Linux kernel module fucker
   
4. *
   
5. * by wzt       <[email]wzt.wzt@gmail.com[/email]>
   
6. *
   
7. */
   
8. 
   
9. #include <stdio.h>
   
10. #include <string.h>
    
11. #include <stdlib.h>
    
12. #include <unistd.h>
    
13. #include <fcntl.h>
    
14. #include <elf.h>
    
15. #include <sys/stat.h>
    
16. #include <sys/mman.h>
    
17. 
    
18. #define MODULE_NAME_LEN         (64 - sizeof(unsigned long))
    
19. 
    
20. struct modversion_info
    
21. {
    
22.         unsigned long crc;
    
23.         char name[MODULE_NAME_LEN];
    
24. };
    
25. 
    
26. Elf32_Ehdr *ehdr = NULL;
    
27. Elf32_Phdr *phdr = NULL;
    
28. Elf32_Shdr *shdr = NULL;
    
29. Elf32_Shdr *shstrtab = NULL;
    
30. Elf32_Sym *dynsym_ptr = NULL;
    
31. Elf32_Sym *symtab_ptr = NULL;
    
32. Elf32_Sym *dynstr_ptr = NULL;
    
33. 
    
34. char *Real_strtab = NULL;
    
35. char *dynstr = NULL;
    
36. char *strtab_ptr = NULL;
    
37. char dynstr_buffer[2048];   
    
38. char strtab_buffer[4096];
    
39. char *real_strtab = NULL;
    
40. 
    
41. unsigned int shstrtab_off, shstrtab_len, shstrtab_num;
    
42. unsigned int strtab_off, strtab_size;
    
43. 
    
44. int elf_fd;
    
45. struct stat f_stat;
    
46.    
    
47. void usage(char *pro)
    
48. {
    
49.         fprintf(stderr, "usage: %s <options> <module>\n\n", pro);
    
50.         fprintf(stderr, "-w -v\tCheck vermgaic in module.\n");
    
51.         fprintf(stderr, "-w -c\tCheck crc value in module.\n");
    
52.         fprintf(stderr, "-s -v <new_vermagic>\tSet vermagic in module.\n");
    
53.         fprintf(stderr, "-s -c\tSet crc value in module. please append two more arguments after <module>: <symbol> <crc>. i.e. %s -s -c sample.ko module_layout 0xa925871a\n", pro);
    
54. 
    
55.         exit(0);
    
56. }
    
57. 
    
58. int init_load_elf(char *elf_file)
    
59. {
    
60.         char buff[1024];
    
61. 
    
62.         elf_fd = open(elf_file, O_RDWR);
    
63.         if (elf_fd == -1) {
    
64.                 perror("open");
    
65.                 return 0;
    
66.         }
    
67.         fprintf(stderr, "[+] Open %s ok.\n", elf_file);
    
68. 
    
69.         if (fstat(elf_fd, &f_stat) == -1) {
    
70.                 perror("fstat");
    
71.                 return 0;
    
72.         }
    
73. 
    
74.         ehdr = (Elf32_Ehdr *)mmap(NULL, f_stat.st_size, PROT_WRITE|PROT_READ, MAP_SHARED, elf_fd, 0);
    
75.         if(ehdr == MAP_FAILED) {
    
76.                 perror("mmap");
    
77.                 return 0;
    
78.         }
    
79. 
    
80.         phdr = (Elf32_Phdr *)((unsigned long)ehdr + ehdr->e_phoff);
    
81.         shdr = (Elf32_Shdr *)((unsigned long)ehdr + ehdr->e_shoff);
    
82. 
    
83.         shstrtab = &shdr[ehdr->e_shstrndx];
    
84.         shstrtab_off = (unsigned int)shstrtab->sh_offset;
    
85.         shstrtab_len = shstrtab->sh_size;
    
86. 
    
87.         real_strtab = (char *)( (unsigned long)ehdr + shstrtab_off );
    
88. 
    
89.         printf("[+] .Shstrtab Size :0x%x,%d\n", shstrtab->sh_size, shstrtab->sh_name);
    
90.         printf("[+] .Shstrtab Off: 0x%x\n", shstrtab_off);
    
91. 
    
92.         return 1;
    
93. }
    
94. 
    
95. int display_module_crc_info(void)
    
96. {
    
97.         struct modversion_info *versions;
    
98.         char *buff = NULL;
    
99.         unsigned int version_off, version_size, num_versions;
    
100.         int i, j;
     
101. 
     
102.         buff = (char *)malloc(shstrtab_len + 2);
     
103.         if (!buff) {
     
104.                 fprintf(stderr, "[-] Malloc failed.\n");
     
105.                 return 0;
     
106.         }
     
107. 
     
108.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
109.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
110.                 if (!strcmp(buff + shdr[i].sh_name,"__versions")){
     
111.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
112.                         version_off = (unsigned int)shdr[i].sh_offset;
     
113.                         version_size = (unsigned int)shdr[i].sh_size;
     
114.                         printf("[+] version off: 0x%x\n", version_off);
     
115.                         printf("[+] version size: 0x%x\n", version_size);
     
116.                         break;
     
117.                 }
     
118.         }
     
119. 
     
120.         printf("[+] %x,%x\n", (unsigned long)ehdr + version_off, shdr[i].sh_addr);
     
121.         versions = (void *)((unsigned long)ehdr + version_off);
     
122.         num_versions = version_size / sizeof(struct modversion_info);
     
123.         printf("[+] num_versions: %d\n", num_versions);
     
124. 
     
125.         for (j = 0; j < num_versions; j++) {
     
126.                 printf("[+] %s:0x%08x.\n", versions[j].name, versions[j].crc);
     
127.         }
     
128. 
     
129.         free(buff);
     
130.         return 1;
     
131. }
     
132. 
     
133. int set_module_crc_info(char* moduleName, char* moduleCrc)
     
134. {
     
135.         struct modversion_info *versions;
     
136.         char *buff = NULL;
     
137.         unsigned int version_off, version_size, num_versions;
     
138.         int i, j;
     
139. 
     
140.         buff = (char *)malloc(shstrtab_len + 2);
     
141.         if (!buff) {
     
142.                 fprintf(stderr, "[-] Malloc failed.\n");
     
143.                 return 0;
     
144.         }
     
145. 
     
146.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
147.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
148.                 if (!strcmp(buff + shdr[i].sh_name,"__versions")){
     
149.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
150.                         version_off = (unsigned int)shdr[i].sh_offset;
     
151.                         version_size = (unsigned int)shdr[i].sh_size;
     
152.                         printf("[+] version off: 0x%x\n", version_off);
     
153.                         printf("[+] version size: 0x%x\n", version_size);
     
154.                         break;
     
155.                 }
     
156.         }
     
157. 
     
158.         printf("[+] %x,%x\n", (unsigned long)ehdr + version_off, shdr[i].sh_addr);
     
159.         versions = (void *)((unsigned long)ehdr + version_off);
     
160.         num_versions = version_size / sizeof(struct modversion_info);
     
161.         printf("[+] num_versions: %d\n", num_versions);
     
162. 
     
163.         for (j = 0; j < num_versions; j++) {
     
164.                 printf("[+] %s:0x%08x.\n", versions[j].name, versions[j].crc);
     
165.                 if (moduleName != NULL && !strcmp(versions[j].name, moduleName)) {
     
166.                         if (moduleCrc != NULL) {
     
167.                                 fprintf(stderr, "[+] Found symbol %s, and will set crc code to %s\n", moduleName, moduleCrc);
     
168.                                 sscanf(moduleCrc, "0x%08x", &versions[j].crc);
     
169.                                 
     
170.                         } else {
     
171.                                 fprintf(stderr, "[+] Found symbol %s, please input the crc code (like format: 0xa925871a):\n", moduleName);
     
172.                                 scanf("0x%08x", &versions[j].crc);
     
173.                         }
     
174.                         break;
     
175.                 }
     
176.         }
     
177. 
     
178.         printf("[+] after set moduel crc:\n");
     
179.         for (j = 0; j < num_versions; j++) {
     
180.                 printf("[+] %s:0x%08x.\n", versions[j].name, versions[j].crc);
     
181.         }
     
182. 
     
183.         free(buff);
     
184.         return 1;
     
185. }
     
186. 
     
187. static char *next_string(char *string, unsigned long *secsize)
     
188. {
     
189.         /* Skip non-zero chars */
     
190.         while (string[0]) {
     
191.                 string++;
     
192.                 if ((*secsize)-- <= 1)
     
193.                         return NULL;
     
194.         }
     
195. 
     
196.         /* Skip any zero padding. */
     
197.         while (!string[0]) {
     
198.                 string++;
     
199.                 if ((*secsize)-- <= 1)
     
200.                         return NULL;
     
201.         }
     
202.         return string;
     
203. }
     
204. 
     
205. static char *get_modinfo(Elf32_Shdr *sechdrs, unsigned int info, const char *tag)
     
206. {
     
207.         char *p;
     
208.         unsigned int taglen = strlen(tag);
     
209.         unsigned long size = sechdrs[info].sh_size;
     
210. 
     
211.         for (p = (char *)(ehdr +sechdrs[info].sh_offset); p; p = next_string(p, &size)) {
     
212.                 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
     
213.                         return p + taglen + 1;
     
214.         }
     
215.         return NULL;
     
216. }
     
217. 
     
218. int display_module_vermagic_info(void)
     
219. {
     
220.         char *buff, *p;
     
221.         char *ver = "vermagic";
     
222.         unsigned int taglen = strlen(ver);
     
223.         int size, i;
     
224. 
     
225.         buff = (char *)malloc(shstrtab_len + 2);
     
226.         if (!buff) {
     
227.                 fprintf(stderr, "[-] Malloc failed.\n");
     
228.                 return 0;
     
229.         }
     
230. 
     
231.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
232.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
233.                 if (!strcmp(buff + shdr[i].sh_name,".modinfo")){
     
234.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
235.                         break;
     
236.                 }
     
237.         }
     
238. 
     
239.         size = shdr[i].sh_size;
     
240.         printf("[+] size: 0x%x.\n", size);
     
241. 
     
242.         p = (char *)((unsigned long)ehdr + shdr[i].sh_offset);
     
243.         printf("[+] 0x%08x\n", p);
     
244. 
     
245.         for (; p; p = next_string(p, &size)) {
     
246.                 printf("[+] %s\n", p);
     
247.                 if (strncmp(p, "vermagic", taglen) == 0 && p[taglen] == '=') {
     
248.                         printf("[+] %s\n", p + taglen + 1);
     
249.                         //memset(p + taglen + 1, 'A', 30);
     
250.                 }
     
251.         }
     
252. 
     
253.         return 1;
     
254. }
     
255. 
     
256. int set_module_vermagic_info(char *new_vermagic)
     
257. {
     
258.         char *buff, *p;
     
259.         char *ver = "vermagic";
     
260.         unsigned int taglen = strlen(ver);
     
261.         int size, i;
     
262. 
     
263.         buff = (char *)malloc(shstrtab_len + 2);
     
264.         if (!buff) {
     
265.                 fprintf(stderr, "[-] Malloc failed.\n");
     
266.                 return 0;
     
267.         }
     
268. 
     
269.         memcpy(buff, real_strtab, shstrtab_len + 1);
     
270.         for (i = 0 ; i < (int)ehdr->e_shnum ; i++){
     
271.                 if (!strcmp(buff + shdr[i].sh_name,".modinfo")){
     
272.                         printf("[+] found section %s.\n", buff + shdr[i].sh_name);
     
273.                         break;
     
274.                 }
     
275.         }
     
276. 
     
277.         size = shdr[i].sh_size;
     
278.         printf("[+] size: 0x%x.\n", size);
     
279. 
     
280.         p = (char *)((unsigned long)ehdr + shdr[i].sh_offset);
     
281.         printf("[+] 0x%08x\n", p);
     
282. 
     
283.         for (; p; p = next_string(p, &size)) {
     
284.                 printf("[+] %s\n", p);
     
285.                 if (strncmp(p, "vermagic", taglen) == 0 && p[taglen] == '=') {
     
286.                         printf("[+] %s\n", p + taglen + 1);
     
287.                         if (strlen(p + taglen + 1) < strlen(new_vermagic)) {
     
288.                                 printf("[-] New vermagic len must < current magic len.\n");
     
289.                                 return 0;
     
290.                         }
     
291.                         memset(p + taglen + 1, '\0', strlen(new_vermagic));
     
292.                         memcpy(p + taglen + 1, new_vermagic, strlen(new_vermagic));
     
293.                 }
     
294.         }
     
295. 
     
296.         return 1;
     
297. }
     
298. 
     
299. int exit_elf_load(void)
     
300. {
     
301.         close(elf_fd);
     
302.         if (munmap(ehdr, f_stat.st_size) == -1) {
     
303.                 return 0;
     
304.         }
     
305. 
     
306.         return 1;
     
307. }
     
308. 
     
309. int main(int argc, char **argv)
     
310. {
     
311.         if (argc == 1) {
     
312.                 usage(argv[0]);
     
313.         }
     
314. 
     
315.         if (!strcmp(argv[1], "-w") && !strcmp(argv[2], "-c")) {
     
316.                 fprintf(stderr, "[+] Display %s module crc value.\n", argv[3]);
     
317.                 if (!init_load_elf(argv[3])) {
     
318.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
319.                         return 0;
     
320.                 }
     
321.                 display_module_crc_info();
     
322.                 exit_elf_load();
     
323.         }
     
324.         else if (!strcmp(argv[1], "-s") && !strcmp(argv[2], "-c")) {
     
325.                 fprintf(stderr, "[+] Set %s module crc value.\n", argv[3]);
     
326.                 if (!init_load_elf(argv[3])) {
     
327.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
328.                         return 0;
     
329.                 }
     
330.                 set_module_crc_info( argc >= 4 ? argv[4] : NULL, argc >= 5 ? argv[5] : NULL);
     
331.                 exit_elf_load();
     
332.         }
     
333.         if (!strcmp(argv[1], "-w") && !strcmp(argv[2], "-v")) {
     
334.                 fprintf(stderr, "[+] Display %s module crc value.\n", argv[3]);
     
335.                 if (!init_load_elf(argv[3])) {
     
336.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
337.                         return 0;
     
338.                 }
     
339.                 display_module_vermagic_info();
     
340.                 exit_elf_load();
     
341.         }
     
342.         if (!strcmp(argv[1], "-s") && !strcmp(argv[2], "-v")) {
     
343.                 fprintf(stderr, "[+] Display %s module crc value.\n", argv[4]);
     
344.                 if (!init_load_elf(argv[4])) {
     
345.                         fprintf(stderr, "[-] Init elf load failed.\n");
     
346.                         return 0;
     
347.                 }
     
348.                 set_module_vermagic_info(argv[3]);
     
349.                 exit_elf_load();
     
350.         }
     
351.         else {
     
352.                 return 0;
     
353.         }
     
354. 
     
355. }
     

复制代码

---

作者: custjcy    时间: 2019-12-20 16:08
其它参考帖子：绕过CONFIG_MODVERSIONS
https://blog.csdn.net/mr_pang_1991/article/details/50014211

---

作者: custjcy    时间: 2019-12-20 16:19
如果crc 不一致多的话，可以参考这个帖子 https://blog.csdn.net/mr_pang_1991/article/details/50014211

---

作者: custjcy    时间: 2019-12-20 16:21
如果要修改的地方比较多，可以参考这个帖子：
绕过CONFIG_MODVERSIONS

---

欢迎光临 Chinaunix (http://bbs.chinaunix.net/)

Powered by Discuz! X3.2