Ядро Linux: пример перехвата системных вызовов

Я пытаюсь написать простой тестовый код для демонстрации перехвата таблицы системных вызовов.

"sys_call_table" больше не экспортируется в 2.6, поэтому я просто извлекаю адрес из файла System.map и вижу, что он правильный (просматривая память по найденному адресу, я вижу указатели на системные вызовы).

Тем не менее, когда я пытаюсь изменить эту таблицу, ядро ​​выдает "К сожалению" с "невозможно обработать запрос ядра на виртуальный адрес c061e4f4", и машина перезагружается.

Это CentOS 5.4 с 2.6.18-164.10.1.el5. Есть ли какая-то защита или у меня просто ошибка? Я знаю, что это идет с SELinux, и я пытался перевести его в разрешающий режим, но это не имеет значения

Вот мой код:

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/unistd.h>

void **sys_call_table;

asmlinkage int (*original_call) (const char*, int, int);

asmlinkage int our_sys_open(const char* file, int flags, int mode)
{
   printk("A file was opened\n");
   return original_call(file, flags, mode);
}

int init_module()
{
    // sys_call_table address in System.map
    sys_call_table = (void*)0xc061e4e0;
    original_call = sys_call_table[__NR_open];

    // Hook: Crashes here
    sys_call_table[__NR_open] = our_sys_open;
}

void cleanup_module()
{
   // Restore the original call
   sys_call_table[__NR_open] = original_call;
}
Источник

5 ответов

Решение

Я наконец нашел ответ сам.

http://www.linuxforums.org/forum/linux-kernel/133982-cannot-modify-sys_call_table.html

В какой-то момент ядро ​​было изменено, поэтому таблица системных вызовов доступна только для чтения.

шифропанк:

Даже если уже поздно, но Решение может заинтересовать и других: в файле entry.S вы найдете: Код:

.section .rodata,"a"
#include "syscall_table_32.S"

sys_call_table -> ReadOnly Вы должны скомпилировать новое ядро, если вы хотите "взломать" его с помощью sys_call_table...

Ссылка также содержит пример изменения памяти для записи.

nasekomoe:

Всем привет. Спасибо за ответы. Я давно решил проблему, изменив доступ к страницам памяти. Я реализовал две функции, которые делают это для моего кода верхнего уровня:

#include <asm/cacheflush.h>
#ifdef KERN_2_6_24
#include <asm/semaphore.h>
int set_page_rw(long unsigned int _addr)
{
    struct page *pg;
    pgprot_t prot;
    pg = virt_to_page(_addr);
    prot.pgprot = VM_READ | VM_WRITE;
    return change_page_attr(pg, 1, prot);
}

int set_page_ro(long unsigned int _addr)
{
    struct page *pg;
    pgprot_t prot;
    pg = virt_to_page(_addr);
    prot.pgprot = VM_READ;
    return change_page_attr(pg, 1, prot);
}

#else
#include <linux/semaphore.h>
int set_page_rw(long unsigned int _addr)
{
    return set_memory_rw(_addr, 1);
}

int set_page_ro(long unsigned int _addr)
{
    return set_memory_ro(_addr, 1);
}

#endif // KERN_2_6_24

Вот модифицированная версия оригинального кода, которая работает для меня.

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/unistd.h>
#include <asm/semaphore.h>
#include <asm/cacheflush.h>

void **sys_call_table;

asmlinkage int (*original_call) (const char*, int, int);

asmlinkage int our_sys_open(const char* file, int flags, int mode)
{
   printk("A file was opened\n");
   return original_call(file, flags, mode);
}

int set_page_rw(long unsigned int _addr)
{
   struct page *pg;
   pgprot_t prot;
   pg = virt_to_page(_addr);
   prot.pgprot = VM_READ | VM_WRITE;
   return change_page_attr(pg, 1, prot);
}

int init_module()
{
    // sys_call_table address in System.map
    sys_call_table = (void*)0xc061e4e0;
    original_call = sys_call_table[__NR_open];

    set_page_rw(sys_call_table);
    sys_call_table[__NR_open] = our_sys_open;
}

void cleanup_module()
{
   // Restore the original call
   sys_call_table[__NR_open] = original_call;
}
Источник

Спасибо, Стивен, ваше исследование здесь было полезно для меня. У меня было несколько проблем, так как я пробовал это на ядре 2.6.32 и получал WARNING: at arch/x86/mm/pageattr.c:877 change_page_attr_set_clr+0x343/0x530() (Not tainted) за ним следует OOPS ядра о невозможности записи в адрес памяти.

Комментарий выше упомянутой строки гласит:

// People should not be passing in unaligned addresses

Следующий модифицированный код работает:

int set_page_rw(long unsigned int _addr)
{
    return set_memory_rw(PAGE_ALIGN(_addr) - PAGE_SIZE, 1);
}

int set_page_ro(long unsigned int _addr)
{
    return set_memory_ro(PAGE_ALIGN(_addr) - PAGE_SIZE, 1);
}

Обратите внимание, что в некоторых ситуациях это все еще не делает страницу доступной для чтения / записи. static_protections() функция, которая вызывается внутри set_memory_rw()удаляет _PAGE_RW флаг, если:

  • Это в области BIOS
  • Адрес находится внутри.rodata
  • CONFIG_DEBUG_RODATA установлен, а ядро ​​установлено только для чтения

Я выяснил это после отладки, почему я все еще "не смог обработать запрос на подкачку ядра" при попытке изменить адрес функций ядра. В конце концов я смог решить эту проблему, найдя запись таблицы страниц для адреса самостоятельно и вручную установив ее для записи. К счастью, lookup_address() функция экспортирована в версии 2.6.26+. Вот код, который я написал для этого:

void set_addr_rw(unsigned long addr) {

    unsigned int level;
    pte_t *pte = lookup_address(addr, &level);

    if (pte->pte &~ _PAGE_RW) pte->pte |= _PAGE_RW;

}

void set_addr_ro(unsigned long addr) {

    unsigned int level;
    pte_t *pte = lookup_address(addr, &level);

    pte->pte = pte->pte &~_PAGE_RW;

}

Наконец, хотя ответ Марка технически верен, при запуске внутри Xen возникнут проблемы. Если вы хотите отключить защиту от записи, используйте функции чтения / записи cr0. Я макрос их так:

#define GPF_DISABLE write_cr0(read_cr0() & (~ 0x10000))
#define GPF_ENABLE write_cr0(read_cr0() | 0x10000)

Надеюсь, что это поможет любому, кто наткнется на этот вопрос.

Источник

Обратите внимание, что следующее также будет работать вместо использования change_page_attr и не может быть амортизировано:

static void disable_page_protection(void) {

    unsigned long value;
    asm volatile("mov %%cr0,%0" : "=r" (value));
    if (value & 0x00010000) {
            value &= ~0x00010000;
            asm volatile("mov %0,%%cr0": : "r" (value));
    }
}

static void enable_page_protection(void) {

    unsigned long value;
    asm volatile("mov %%cr0,%0" : "=r" (value));
    if (!(value & 0x00010000)) {
            value |= 0x00010000;
            asm volatile("mov %0,%%cr0": : "r" (value));
    }
}
Источник

Если вы имеете дело с ядром 3.4 и новее (оно также может работать с более ранними ядрами, я не тестировал его), я бы порекомендовал более разумный способ получения местоположения таблицы системных вызовов.

Например

#include <linux/module.h>
#include <linux/kallsyms.h>

static unsigned long **p_sys_call_table;
/* Aquire system calls table address */
p_sys_call_table = (void *) kallsyms_lookup_name("sys_call_table");

Вот и все. Нет адресов, все работает нормально с каждым ядром, которое я тестировал.

Таким же образом вы можете использовать не экспортированную функцию ядра из вашего модуля:

static int (*ref_access_remote_vm)(struct mm_struct *mm, unsigned long addr,
                void *buf, int len, int write);
ref_access_remote_vm = (void *)kallsyms_lookup_name("access_remote_vm");

Наслаждайтесь!

Источник

Как уже намекали другие, теперь на современных ядрах все немного по-другому. Я расскажу здесь о x86-64, для перехвата системных вызовов на современном arm64 обратитесь к этому другому моему ответу . Также ПРИМЕЧАНИЕ : это простой перехват системных вызовов . Неинвазивное подключение может быть выполнено гораздо более удобным способом с помощью kprobes .

Начиная с Linux v4.17, x86 (как 64-, так и 32-разрядная) теперь использует оболочки системных вызовов, которыеstruct pt_regs *в качестве единственного аргумента (см. commit 1, commit 2). Ты можешь видеть arch/x86/include/asm/syscall.hдля определений.

Кроме того, как уже описывали другие в разных ответах, самый простой способ изменить — временно отключить бит CR0 WP (защита от записи), что можно сделать с помощьюread_cr0()иwrite_cr0(). Однако, начиная с Linux v5.3,[native_]write_cr0проверит конфиденциальные биты, которые никогда не должны изменяться (например, WP), и откажется их изменять ( commit). Чтобы обойти это, нам нужно написать CR0 вручную, используя встроенный ассемблер.

Вот работающий модуль ядра (протестирован на Linux 5.10 и 5.18), который перехватывает системные вызовы на современном Linux x86-64, учитывая приведенные выше предостережения и предполагая, что вы уже знаете адресsys_call_table(если вы также хотите найти это в модуле, см. Правильный способ получения адреса неэкспортированных символов ядра в модуле ядра Linux ):

      // SPDX-License-Identifier: (GPL-2.0 OR MIT)
/**
 * Test syscall table hijacking on x86-64. This module will replace the `read`
 * syscall with a simple wrapper which logs every invocation of `read` using
 * printk().
 *
 * Tested on Linux x86-64 v5.10, v5.18.
 *
 * Usage:
 *
 *     sudo cat /proc/kallsyms | grep sys_call_table # grab address
 *     sudo insmod syscall_hijack.ko sys_call_table_addr=0x<address_here>
 */

#include <linux/init.h>          // module_{init,exit}()
#include <linux/module.h>        // THIS_MODULE, MODULE_VERSION, ...
#include <linux/kernel.h>        // printk(), pr_*()
#include <asm/special_insns.h>   // {read,write}_cr0()
#include <asm/processor-flags.h> // X86_CR0_WP
#include <asm/unistd.h>          // __NR_*

#ifdef pr_fmt
#undef pr_fmt
#endif
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

typedef long (*sys_call_ptr_t)(const struct pt_regs *);

static sys_call_ptr_t *real_sys_call_table;
static sys_call_ptr_t original_read;

static unsigned long sys_call_table_addr;
module_param(sys_call_table_addr, ulong, 0);
MODULE_PARM_DESC(sys_call_table_addr, "Address of sys_call_table");

// Since Linux v5.3 [native_]write_cr0 won't change "sensitive" CR0 bits, need
// to re-implement this ourselves.
static void write_cr0_unsafe(unsigned long val)
{
    asm volatile("mov %0,%%cr0": "+r" (val) : : "memory");
}

static long myread(const struct pt_regs *regs)
{
    pr_info("read(%ld, 0x%lx, %lx)\n", regs->di, regs->si, regs->dx);
    return original_read(regs);
}

static int __init modinit(void)
{
    unsigned long old_cr0;

    real_sys_call_table = (typeof(real_sys_call_table))sys_call_table_addr;

    pr_info("init\n");

    // Temporarily disable CR0 WP to be able to write to read-only pages
    old_cr0 = read_cr0();
    write_cr0_unsafe(old_cr0 & ~(X86_CR0_WP));

    // Overwrite syscall and save original to be restored later
    original_read = real_sys_call_table[__NR_read];
    real_sys_call_table[__NR_read] = myread;

    // Restore CR0 WP
    write_cr0_unsafe(old_cr0);
    pr_info("init done\n");

    return 0;
}

static void __exit modexit(void)
{
    unsigned long old_cr0;

    pr_info("exit\n");

    old_cr0 = read_cr0();
    write_cr0_unsafe(old_cr0 & ~(X86_CR0_WP));

    // Restore original syscall
    real_sys_call_table[__NR_read] = original_read;

    write_cr0_unsafe(old_cr0);

    pr_info("goodbye\n");
}

module_init(modinit);
module_exit(modexit);
MODULE_VERSION("0.1");
MODULE_DESCRIPTION("Test syscall table hijacking on x86-64.");
MODULE_AUTHOR("Marco Bonelli");
MODULE_LICENSE("Dual MIT/GPL");
Источник
Другие вопросы по тегам