Kernels: Understanding the Heart of Operating Systems & Understanding Kernel Exploitation

Latar Belakang

Sebuah sistem operasi (OS) merupakan jaringan dari instruksi yang mengatur cara kerja perangkat lunak dan perangkat keras komputer. Saat memulai, sistem operasi akan memuat beberapa perangkat lunak dasar, seperti kernel, dan memulakan proses-proses yang diperlukan. Kernel adalah inti dari sistem operasi dan bertanggung jawab atas pengelolaan sumber daya komputer dan interaksi dengan perangkat keras.

Deskripsi

Dalam materi/artikel ini, kita akan memahami kernels dari sudut pandang konseptual dan teknis. Kita akan memulihkan latar belakang kernels dan bagaimana mereka bekerja sama dengan sistem operasi. Kita akan membahas beberapa jenis kernels, seperti monolithic, micro, dan hybrid kernels, serta menguraikan kelebihan dan kekurangan masing-masing jenis. Selain itu, kita akan melihat contoh-contoh kernels yang populer, seperti Linux, Windows, dan macOS.

Kita akan memperjelas peran kernels dalam pengelolaan memori, proses, dan input/output device, serta bagaimana mereka mengelola interrups dan system calls. Kita akan menjelaskan cara kerja virtual memory dan bagaimana kernels mengelola akses memori. Selain itu, kita akan membahas tentang keamanan kernels dan cara mencegah serangan terhadap kernels.

Manfaat

Artikel ini akan memberikan gambaran yang lebih baik tentang kernels dan bagaimana mereka bekerja sama dengan sistem operasi. Kita akan memahami peran kernels dalam pengelolaan sumber daya komputer dan interaksi dengan perangkat keras. Artikel ini akan bermanfaat bagi para pemula dalam bidang sistem operasi dan para ahli yang ingin memperjelas pengetahuan mereka tentang kernels.

Ringkasan Isi

1. Pengenalan ke kernels dan sistem operasi
2. Jenis-jenis kernels dan contoh-contoh kernels populer
3. Peran kernels dalam pengelolaan memori, proses, dan input/output device
4. Cara kerja virtual memory dan pengelolaan akses memori
5. Keamanan kernels dan cara mencegah serangan terhadap kernels

Daftar Isi

1. Pendahuluan 1.1 Latar Belakang 1.2 Deskripsi 1.3 Manfaat 1.4 Ringkasan Isi 1.5 Batasan dan Tujuan
2. Kernels dan Sistem Operasi 2.1 Pengenalan ke Sistem Operasi 2.2 Pengenalan ke Kernels 2.3 Peran Kernels dalam Sistem Operasi
3. Jenis-Jenis Kernels 3.1 Monolithic Kernels 3.2 Micro Kernels 3.3 Hybrid Kernels 3.4 Contoh-Contoh Kernels Populer
4. Peran Kernels dalam Pengelolaan Sumber Daya Komputer 4.1 Pengelolaan Memori 4.2 Pengelolaan Proses 4.3 Pengelolaan Input/Output Device 4.4 Pengelolaan Interrups dan System Calls
5. Virtual Memory dan Pengelolaan Akses Memori 5.1 Cara Kerja Virtual Memory 5.2 Pengelolaan Akses Memori
6. Keamanan Kernels 6.1 Peran Kernels dalam Keamanan Sistem Operasi 6.2 Cara Mencegah Serangan Terhadap Kernels
7. Kesimpulan dan Saran 7.1 Kesimpulan 7.2 Saran

Batasan dan Tujuan

Artikel ini memiliki tujuan untuk memahami kernels dari sudut pandang konseptual dan teknis. Kita akan membahas beberapa jenis kernels dan contoh-contoh kernels yang populer. Selain itu, kita akan memperjelas peran kernels dalam pengelolaan sumber daya komputer dan interaksi dengan perangkat keras. Artikel ini tidak akan membahas tentang pengembangan kernels atau cara membuat kernels sendiri.

© copyright by Pwned 0Day Security Executions Code (pwn0sec)

Perkenalan:

Dalam lanskap keamanan siber yang terus berkembang, konsep eksploitasi kernel merupakan tantangan berat bagi pembela HAM dan penyerang. Kernel, komponen inti sistem operasi yang bertanggung jawab mengelola sumber daya sistem, adalah target utama eksploitasi karena hak istimewanya yang lebih tinggi. Dalam postingan blog ini, kita akan mempelajari seluk-beluk eksploitasi kernel, mengeksplorasi mekanisme yang mendasarinya, kerentanan umum, dan permainan kucing-kucingan antara peneliti keamanan dan pelaku kejahatan.

Peran Kernel:

Sebelum mempelajari eksploitasi, penting untuk memahami peran kernel. Kernel berfungsi sebagai jembatan antara perangkat keras dan perangkat lunak, mengelola sumber daya seperti memori, proses, dan komunikasi perangkat. Hak istimewanya yang tinggi menjadikannya target utama bagi penyerang yang ingin mendapatkan kendali atas suatu sistem.

Kerentanan Kernel Umum:

Buffer Meluap:

1. Buffer overflow tetap menjadi kerentanan umum di ruang kernel. Hal ini terjadi ketika suatu program menulis lebih banyak data ke dalam buffer daripada yang dapat ditampungnya, sehingga menyebabkan kerusakan memori. Di kernel, hal ini bisa sangat berbahaya karena memungkinkan penyerang menimpa struktur data penting atau mengeksekusi kode arbitrer.

Contoh Buffer Overflow:

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

#define BUFFER_SIZE 16
static char *kernel_buffer;
static int __init buffer_overflow_init(void) {
    printk(KERN_INFO "Buffer Overflow Example: Module Loaded\n");
    // Allocate memory for the kernel buffer
    kernel_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
    // Simulate a buffer overflow by copying user input without proper bounds checking
    char *user_input = "This is a long string that causes a buffer overflow!";
    strcpy(kernel_buffer, user_input);
    return 0;
}
static void __exit buffer_overflow_exit(void) {
    // Free the allocated memory
    kfree(kernel_buffer);
    printk(KERN_INFO "Buffer Overflow Example: Module Unloaded\n");
}
module_init(buffer_overflow_init);
module_exit(buffer_overflow_exit);
MODULE_LICENSE("GPL");

Dalam contoh ini, modul kernel diinisialisasi dengan mengalokasikan buffer (kernel_buffer) dengan ukuran tetap 16 byte. Kemudian, ia menyalin input pengguna ke buffer ini menggunakan fungsi strcpy , yang tidak melakukan pemeriksaan batas. Kurangnya validasi ini dapat menyebabkan buffer overflow jika string input melebihi ukuran buffer yang dialokasikan.

Sumber Daya untuk Memahami Konsep:

1. Penjelasan Buffer Overflow:

• Penjelasan Serangan Buffer Overflow (GeeksforGeeks)

1. Memahami Petunjuk:

• C — Pointer (titik tutorial)

1. Alokasi Memori di C:

• Alokasi Memori Dinamis di C (GeeksforGeeks)

1. Pemrograman Modul Kernel Linux:

• Menulis Modul Kernel Linux Sederhana

1. Memahami Pemrograman C:

• Pemrograman C (Akademi Khan)

Gunakan-Setelah-Gratis:

1. Kerentanan penggunaan setelah bebas terjadi ketika program terus menggunakan penunjuk setelah objek yang ditunjuknya dibebaskan. Di kernel, ini dapat dieksploitasi untuk mendapatkan kendali atas aliran eksekusi dan memanipulasi perilaku sistem.

Contoh Penggunaan Setelah Bebas:

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

static char *kernel_data;
static int __init use_after_free_init(void) {
    printk(KERN_INFO "Use-After-Free Example: Module Loaded\n");
    // Allocate memory for kernel data
    kernel_data = kmalloc(sizeof(char), GFP_KERNEL);
    // Free the allocated memory, simulating a use-after-free scenario
    kfree(kernel_data);
    // Access the freed memory, leading to a use-after-free vulnerability
    printk(KERN_INFO "Data after freeing: %c\n", *kernel_data);
    return 0;
}
static void __exit use_after_free_exit(void) {
    printk(KERN_INFO "Use-After-Free Example: Module Unloaded\n");
}
module_init(use_after_free_init);
module_exit(use_after_free_exit);
MODULE_LICENSE("GPL");

Dalam contoh ini, modul kernel diinisialisasi dengan mengalokasikan memori untuk kernel_data menggunakan kmalloc Namun, modul ini segera mengosongkan memori ini menggunakan kfree . Selanjutnya, ada upaya untuk mengakses memori yang dibebaskan dengan melakukan dereferensi pointer kernel_data . Skenario ini mensimulasikan kerentanan penggunaan setelah bebas di mana program terus menggunakan pointer setelah memori yang mendasarinya dibatalkan alokasinya.

Sumber Daya untuk Memahami Penggunaan-Setelah-Gratis:

1. Penjelasan Penggunaan-Setelah-Gratis:

• Gunakan Setelah Gratis — OWASP

1. Memahami Manajemen Memori di C:

• Manajemen Memori di C (GeeksforGeeks)

1. Alokasi Memori Kernel Linux:

• Alokasi Memori di Kernel Linux (LWN.net)

1. Memahami Alokasi Memori di C:

• Alokasi Memori di C (poin tutorial)

Masalah Dereferensi Penunjuk

1. Penanganan pointer yang tidak tepat dapat menyebabkan kerentanan kernel. Penyerang dapat memanipulasi pointer untuk mengakses wilayah memori yang tidak sah, yang menyebabkan pengungkapan informasi atau eksekusi kode yang tidak sah.

Contoh Masalah Dereferensi Pointer:

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

static int *kernel_ptr;
static int __init pointer_dereference_init(void) {
    printk(KERN_INFO "Pointer Dereference Issue Example: Module Loaded\n");
    // Initialize a pointer to NULL
    kernel_ptr = NULL;
    // Attempt to dereference the NULL pointer, leading to a dereferencing issue
    printk(KERN_INFO "Dereferencing NULL Pointer: %d\n", *kernel_ptr);
    return 0;
}
static void __exit pointer_dereference_exit(void) {
    printk(KERN_INFO "Pointer Dereference Issue Example: Module Unloaded\n");
}
module_init(pointer_dereference_init);
module_exit(pointer_dereference_exit);
MODULE_LICENSE("GPL");

Dalam contoh ini, modul kernel diinisialisasi dengan mendeklarasikan pointer kernel_ptr dan menginisialisasinya ke NULL . Selanjutnya, ada upaya untuk melakukan dereferensi penunjuk NULL , yang menyebabkan masalah dereferensi penunjuk. Dereferensi penunjuk NULL adalah perilaku yang tidak terdefinisi dan dapat mengakibatkan error atau perilaku tak terduga lainnya dalam skenario dunia nyata.

Sumber Daya untuk Memahami Dereferensi Pointer:

1. Pengertian Pointer di C:

• Pointer di C (GeeksforGeeks)

1. Dasar-dasar Penunjuk:

• C — Pointer (titik tutorial)

1. Pointer dan Dereferensi NULL:

• Pointer NULL di C (GeeksforGeeks)

1. Petunjuk Kernel Linux:

• Pointer di Kernel Linux (LWN.net)

Kerentanan Peningkatan Hak Istimewa

1. Kerentanan eskalasi hak istimewa adalah masalah keamanan penting yang memungkinkan penyerang meningkatkan hak istimewa mereka dan mendapatkan akses tidak sah ke sumber daya sistem. Dalam konteks kernel Linux, kerentanan ini sering kali melibatkan kelemahan dalam implementasi panggilan sistem, pemeriksaan izin, atau mekanisme lain yang bertanggung jawab untuk menerapkan kontrol akses. Mari kita jelajahi contoh sederhana untuk mengilustrasikan kerentanan eskalasi hak istimewa dalam modul kernel:

Contoh Kerentanan Eskalasi Hak Istimewa:

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

#define DEVICE_NAME "vuln_device"
#define BUF_SIZE 100
static char *kernel_buffer;
static int device_open(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device Opened\n");
    return 0;
}
static int device_release(struct inode *inode, struct file *file) {
    printk(KERN_INFO "Device Released\n");
    return 0;
}
static ssize_t device_read(struct file *filp, char *buffer, size_t length, loff_t *offset) {
    printk(KERN_INFO "Device Read\n");
    // Copy data from kernel_buffer to user buffer without proper permission checks
    copy_to_user(buffer, kernel_buffer, length);
    return length;
}
static struct file_operations fops = {
    .read = device_read,
    .open = device_open,
    .release = device_release,
};
static int __init privilege_escalation_init(void) {
    printk(KERN_INFO "Privilege Escalation Example: Module Loaded\n");
    // Allocate memory for the kernel buffer
    kernel_buffer = kmalloc(BUF_SIZE, GFP_KERNEL);
    // Initialize kernel_buffer with sensitive data
    memset(kernel_buffer, 'X', BUF_SIZE);
    // Register the character device
    register_chrdev(0, DEVICE_NAME, &fops);
    return 0;
}
static void __exit privilege_escalation_exit(void) {
    // Unregister the character device
    unregister_chrdev(0, DEVICE_NAME);
    // Free the allocated memory
    kfree(kernel_buffer);
    printk(KERN_INFO "Privilege Escalation Example: Module Unloaded\n");
}
module_init(privilege_escalation_init);
module_exit(privilege_escalation_exit);
MODULE_LICENSE("GPL");

Dalam contoh ini, kita memiliki perangkat karakter yang terdaftar dengan operasi baca yang menyalin data dari kernel_buffer ke buffer pengguna tanpa pemeriksaan izin yang tepat. Kurangnya pemeriksaan izin yang tepat ini dapat dimanfaatkan oleh pengguna jahat untuk membaca data kernel sensitif, yang menunjukkan kerentanan peningkatan hak istimewa.

Sumber Daya untuk Memahami Peningkatan Hak Istimewa:

1. Penjelasan Peningkatan Hak Istimewa:

• Peningkatan Hak Istimewa (OWASP)

1. Memahami Model Hak Istimewa Linux:

• Model Hak Istimewa Linux (Keamanan Linux)

1. Panggilan Sistem dan Izin di Linux:

• Memahami Panggilan Sistem dan Izin (LWN.net)

1. Modul Kernel dan Perangkat Karakter:

• Modul Kernel Linux — Perangkat Karakter (LWN.net)

Luapan/Aliran Bawah Integer

1. Kerentanan integer overflow dan underflow terjadi ketika operasi aritmatika menghasilkan nilai di luar kapasitas tipe data, sehingga menyebabkan perilaku yang tidak terduga. Dalam konteks kernel Linux, kerentanan tersebut dapat terwujud dalam skenario di mana pemeriksaan batas yang tidak tepat dilakukan, dan operasi aritmatika tidak divalidasi secara memadai. Berikut adalah contoh sederhana untuk mengilustrasikan kerentanan integer overflow dalam modul kernel

Contoh Luapan Integer:

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

static int counter = 0;
static int __init integer_overflow_init(void) {
    printk(KERN_INFO "Integer Overflow Example: Module Loaded\n");
    // Simulate an integer overflow
    unsigned int increment = UINT_MAX;  // Maximum value for an unsigned int
    counter = counter + increment;
    printk(KERN_INFO "Counter Value after Overflow: %d\n", counter);
    return 0;
}
static void __exit integer_overflow_exit(void) {
    printk(KERN_INFO "Integer Overflow Example: Module Unloaded\n");
}
module_init(integer_overflow_init);
module_exit(integer_overflow_exit);
MODULE_LICENSE("GPL");

Dalam contoh ini, kita memiliki modul kernel yang menginisialisasi counter dan mencoba untuk mensimulasikan integer overflow dengan menambahkan nilai maksimum untuk integer unsigned (UINT_MAX) ke counter. Hal ini akan mengakibatkan overflow, dan counter akan membungkus ke nilai yang lebih kecil.

Sumber Daya untuk Memahami Integer Overflow/Underflow:

1. Penjelasan Integer Overflow/Underflow:

• Luapan Integer (OWASP)

1. Memahami Luapan Integer:

• Memahami Integer Overflow di C/C++ (GeeksforGeeks)

1. Luapan Integer di Kernel Linux:

• Integer Overflow di Kernel Linux (LWN.net)

1. Memahami Tipe Data di C:

• Tipe Data di C (poin tutorial)

Teknik Eksploitasi:

1. ROP (Pemrograman Berorientasi Kembali): ROP adalah teknik di mana penyerang membuat urutan instruksi gadget dari kode yang ada, mengalihkan aliran kontrol tanpa memasukkan kode baru. Hal ini membantu melewati mekanisme keamanan tertentu dengan menggunakan cuplikan kode yang sah.
2. Kernel Shellcode: Membuat shellcode yang dapat dieksekusi dalam batasan kernel adalah teknik eksploitasi yang umum. Hal ini melibatkan memasukkan kode berbahaya ke dalam ruang kernel dan memanfaatkan kerentanan untuk mengeksekusi payload.
3. Eksploitasi Kumpulan Kernel: Eksploitasi kumpulan kernel melibatkan manipulasi struktur data kumpulan memori kernel. Teknik seperti penyemprotan kolam dan perawatan tumpukan bertujuan untuk menciptakan lingkungan yang mendukung eksploitasi.

Mitigasi dan Mekanisme Pertahanan:

1. ASLR (Address Space Layout Randomization): ASLR mengacak alamat memori komponen sistem utama, sehingga mempersulit penyerang untuk memprediksi lokasi fungsi atau gadget tertentu.
2. DEP/NX (Pencegahan Eksekusi Data/No-Execute): DEP/NX mencegah eksekusi kode di wilayah memori tertentu, sehingga mengurangi risiko keberhasilan injeksi kode.
3. Teknik Pengerasan Kernel: Memperbarui dan melakukan patching kernel secara teratur, menggunakan firewall tingkat kernel, dan memanfaatkan kerangka keamanan seperti SELinux atau AppArmor berkontribusi pada lingkungan kernel yang lebih aman.

Kesimpulan:

Eksploitasi kernel masih menjadi tantangan yang terus-menerus dalam bidang keamanan siber, sehingga memerlukan kewaspadaan dan inovasi terus-menerus baik dari para pembela HAM maupun peneliti keamanan. Seiring kemajuan teknologi, taktik yang digunakan oleh pelaku kejahatan juga meningkat. Selalu mengetahui perkembangan terkini dalam keamanan kernel dan menerapkan mekanisme pertahanan yang kuat merupakan langkah penting dalam menjaga ekosistem digital kita dari ancaman yang terus berkembang.