Added kernel section clear/protect after init

This is a huge security improvement as it prevents potential exploits
of using or modifying internal kernel functions or data.

9 files changed, 259 insertions, 101 deletions

diff --git a/kernel/drivers/cpu.c b/kernel/drivers/cpu.c
new file mode 100644
index 0000000..774d9f7
--- /dev/null
+++ b/kernel/drivers/cpu.c
@@ -0,0 +1,155 @@
+// MIT License, Copyright (c) 2020 Marvin Borner
+// This file is a wrapper around some CPU asm calls
+
+#include <cpu.h>
+#include <def.h>
+#include <print.h>
+
+u8 inb(u16 port)
+{
+	u8 value;
+	__asm__ volatile("inb %1, %0" : "=a"(value) : "Nd"(port));
+	return value;
+}
+
+u16 inw(u16 port)
+{
+	u16 value;
+	__asm__ volatile("inw %1, %0" : "=a"(value) : "Nd"(port));
+	return value;
+}
+
+u32 inl(u16 port)
+{
+	u32 value;
+	__asm__ volatile("inl %1, %0" : "=a"(value) : "Nd"(port));
+	return value;
+}
+
+void outb(u16 port, u8 data)
+{
+	__asm__ volatile("outb %0, %1" ::"a"(data), "Nd"(port));
+}
+
+void outw(u16 port, u16 data)
+{
+	__asm__ volatile("outw %0, %1" ::"a"(data), "Nd"(port));
+}
+
+void outl(u16 port, u32 data)
+{
+	__asm__ volatile("outl %0, %1" ::"a"(data), "Nd"(port));
+}
+
+CLEAR static void cpuid(int code, u32 *a, u32 *b, u32 *c, u32 *d)
+{
+	__asm__ volatile("cpuid" : "=a"(*a), "=b"(*b), "=c"(*c), "=d"(*d) : "a"(code));
+}
+
+CLEAR static char *cpu_string(char buf[16])
+{
+	// wtf
+	cpuid(CPUID_VENDOR_STRING, (u32 *)(buf + 12), (u32 *)(buf), (u32 *)(buf + 8),
+	      (u32 *)(buf + 4));
+
+	return buf;
+}
+
+CLEAR void cpu_print(void)
+{
+	char buf[16] = { 0 };
+	printf("CPU vendor: %s\n", cpu_string(buf));
+}
+
+CLEAR u32 cr0_get(void)
+{
+	u32 cr0;
+	__asm__ volatile("movl %%cr0, %%eax" : "=a"(cr0));
+	return cr0;
+}
+
+CLEAR void cr0_set(u32 cr0)
+{
+	__asm__ volatile("movl %%eax, %%cr0" ::"a"(cr0));
+}
+
+u32 cr3_get(void)
+{
+	u32 cr3;
+	__asm__ volatile("movl %%cr0, %%eax" : "=a"(cr3));
+	return cr3;
+}
+
+void cr3_set(u32 cr3)
+{
+	__asm__ volatile("movl %%eax, %%cr3" ::"a"(cr3));
+}
+
+CLEAR u32 cr4_get(void)
+{
+	u32 cr4;
+	__asm__ volatile("movl %%cr4, %%eax" : "=a"(cr4));
+	return cr4;
+}
+
+CLEAR void cr4_set(u32 cr4)
+{
+	__asm__ volatile("movl %%eax, %%cr4" ::"a"(cr4));
+}
+
+static u32 cpu_cfeatures = 0;
+u8 cpu_has_cfeature(enum cpuid_features feature)
+{
+	return (cpu_cfeatures & feature) != 0;
+}
+
+static u32 cpu_dfeatures = 0;
+u8 cpu_has_dfeature(enum cpuid_features feature)
+{
+	return (cpu_dfeatures & feature) != 0;
+}
+
+static void fpu_handler(struct regs *r)
+{
+	UNUSED(r);
+	__asm__ volatile("clts");
+}
+
+static u8 fpu_state[512] ALIGNED(16);
+void fpu_restore(void)
+{
+	__asm__ volatile("fxrstor (%0)" ::"r"(fpu_state));
+}
+
+CLEAR void cpu_enable_features(void)
+{
+	u32 a, b, c, d;
+	cpuid(CPUID_FEATURES, &a, &b, &c, &d);
+	cpu_cfeatures = c;
+	cpu_dfeatures = d;
+	if (cpu_has_dfeature(CPUID_FEAT_EDX_SSE)) {
+		cr0_set(cr0_get() & ~(1 << 2));
+		cr0_set(cr0_get() | (1 << 1));
+		cr4_set(cr4_get() | (3 << 9));
+	} else {
+		panic("No SSE support!\n");
+	}
+
+	if (cpu_has_dfeature(CPUID_FEAT_EDX_FPU)) {
+		__asm__ volatile("fninit");
+		__asm__ volatile("fxsave %0" : "=m"(fpu_state));
+		irq_install_handler(7, fpu_handler);
+	} else {
+		panic("No FPU support!\n");
+	}
+}
+
+CLEAR void cli(void)
+{
+	__asm__ volatile("cli");
+}
+
+CLEAR void sti(void)
+{
+	__asm__ volatile("sti");
+}
diff --git a/kernel/drivers/fb.c b/kernel/drivers/fb.c
index 0a9494a..577debf 100644
--- a/kernel/drivers/fb.c
+++ b/kernel/drivers/fb.c
@@ -21,8 +21,8 @@ struct vbe_basic {
 	u8 stuff3[212];
 };
 
-static u32 dev_id = 0;
-static struct vid_info *info = NULL;
+PROTECTED static u32 dev_id = 0;
+PROTECTED static struct vid_info *info = NULL;
 
 static u32 fb_owner = 0;
 static res fb_ioctl(u32 request, void *arg1, void *arg2, void *arg3, struct device *dev)
@@ -65,7 +65,7 @@ void fb_map_buffer(struct page_dir *dir, struct vid_info *boot)
 	memory_map_identity(dir, memory_range_around((u32)vbe->fb, size), MEMORY_USER);
 }
 
-void fb_install(struct vid_info *boot)
+CLEAR void fb_install(struct vid_info *boot)
 {
 	info = boot;
 
diff --git a/kernel/drivers/ide.c b/kernel/drivers/ide.c
index 7146eb2..f19fe4d 100644
--- a/kernel/drivers/ide.c
+++ b/kernel/drivers/ide.c
@@ -8,13 +8,13 @@
 #include <mem.h>
 #include <print.h>
 
-static u8 *ide_buf = NULL;
+PROTECTED static u8 *ide_buf = NULL;
 
 struct ata_data {
 	u8 drive;
 };
 
-static void ide_select_drive(u8 bus, u8 drive)
+CLEAR static void ide_select_drive(u8 bus, u8 drive)
 {
 	if (bus == ATA_PRIMARY) {
 		if (drive == ATA_MASTER)
@@ -29,7 +29,7 @@ static void ide_select_drive(u8 bus, u8 drive)
 	}
 }
 
-static u8 ide_find(u8 bus, u8 drive)
+CLEAR static u8 ide_find(u8 bus, u8 drive)
 {
 	u16 io = bus == ATA_PRIMARY ? ATA_PRIMARY_IO : ATA_SECONDARY_IO;
 	ide_select_drive(bus, drive);
@@ -116,12 +116,12 @@ static res ata_read(void *buf, u32 lba, u32 sector_count, struct device *dev)
 	return sector_count;
 }
 
-int ata_pm = 0, ata_ps = 0, ata_sm = 0, ata_ss = 0;
-static void ata_probe(void)
+u8 ata_pm = 0, ata_ps = 0, ata_sm = 0, ata_ss = 0;
+CLEAR static void ata_probe(void)
 {
-	for (int i = 0; i < 4; i++) {
-		int bus = i < 2 ? ATA_PRIMARY : ATA_SECONDARY;
-		int drive = i % 2 ? ATA_MASTER : ATA_SLAVE;
+	for (u8 i = 0; i < 4; i++) {
+		u32 bus = i < 2 ? ATA_PRIMARY : ATA_SECONDARY;
+		u32 drive = i % 2 ? ATA_MASTER : ATA_SLAVE;
 
 		if (!ide_find(bus, drive))
 			continue;
@@ -156,7 +156,7 @@ static void ata_probe(void)
 	}
 }
 
-void ata_install(void)
+CLEAR void ata_install(void)
 {
 	ide_buf = zalloc(SECTOR_SIZE);
 	ata_probe();
diff --git a/kernel/drivers/interrupts.c b/kernel/drivers/interrupts.c
index 0189b6c..9898ef1 100644
--- a/kernel/drivers/interrupts.c
+++ b/kernel/drivers/interrupts.c
@@ -14,10 +14,11 @@
  * IDT
  */
 
+// TODO: Why does PROTECTED on idt only work when debug mode is disabled? File size?
 static struct idt_entry idt[256] = { 0 };
-static struct idt_ptr idt_ptr = { 0 };
+PROTECTED static struct idt_ptr idt_ptr = { 0 };
 
-void idt_set_gate(u8 num, u32 base, u16 sel, u8 flags)
+CLEAR void idt_set_gate(u8 num, u32 base, u16 sel, u8 flags)
 {
 	// Specify the interrupt routine's base address
 	idt[num].base_low = (u16)(base & 0xFFFF);
@@ -30,14 +31,14 @@ void idt_set_gate(u8 num, u32 base, u16 sel, u8 flags)
 }
 
 // Install IDT
-static void idt_install(void)
+CLEAR static void idt_install(void)
 {
 	// Set IDT pointer and limit
-	idt_ptr.limit = (sizeof(struct idt_entry) * 256) - 1;
+	idt_ptr.limit = sizeof(idt) - 1;
 	idt_ptr.base = &idt;
 
 	// Clear IDT by setting memory cells to 0
-	memset(&idt, 0, sizeof(struct idt_entry) * 256);
+	memset(&idt, 0, sizeof(idt));
 
 	__asm__ volatile("lidt %0" : : "m"(idt_ptr));
 }
@@ -46,22 +47,22 @@ static void idt_install(void)
  * IRQ
  */
 
-static void (*irq_routines[16])(struct regs *) = { 0 };
+PROTECTED static void (*irq_routines[16])(struct regs *) = { 0 };
 
 // Install IRQ handler
-void irq_install_handler(int irq, void (*handler)(struct regs *r))
+CLEAR void irq_install_handler(int irq, void (*handler)(struct regs *r))
 {
 	irq_routines[irq] = handler;
 }
 
 // Remove IRQ handler
-void irq_uninstall_handler(int irq)
+CLEAR void irq_uninstall_handler(int irq)
 {
 	irq_routines[irq] = 0;
 }
 
 // Remap the IRQ table
-static void irq_remap(void)
+CLEAR static void irq_remap(void)
 {
 	outb(0x20, 0x11);
 	outb(0xA0, 0x11);
@@ -95,7 +96,7 @@ void irq_handler(struct regs *r)
 }
 
 // Map ISRs to the correct entries in the IDT
-static void irq_install(void)
+CLEAR static void irq_install(void)
 {
 	irq_remap();
 
@@ -122,57 +123,59 @@ static void irq_install(void)
  * ISR
  */
 
-static void (*isr_routines[256])(struct regs *) = { 0 };
-
-const char *isr_exceptions[32] = { "Division By Zero",
-				   "Debug",
-				   "Non Maskable Interrupt",
-				   "Breakpoint",
-				   "Into Detected Overflow",
-				   "Out of Bounds",
-				   "Invalid Opcode",
-				   "No Coprocessor",
-
-				   "Double Fault",
-				   "Coprocessor Segment Overrun",
-				   "Bad TSS",
-				   "Segment Not Present",
-				   "Stack Fault",
-				   "General Protection Fault",
-				   "Page Fault",
-				   "Unknown Interrupt",
-
-				   "Coprocessor Fault",
-				   "Alignment Check",
-				   "Machine Check",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved",
-				   "Reserved" };
-
-void isr_install_handler(int isr, void (*handler)(struct regs *r))
+PROTECTED static void (*isr_routines[256])(struct regs *) = { 0 };
+
+PROTECTED const char *isr_exceptions[32] = {
+	"Division By Zero",
+	"Debug",
+	"Non Maskable Interrupt",
+	"Breakpoint",
+	"Into Detected Overflow",
+	"Out of Bounds",
+	"Invalid Opcode",
+	"No Coprocessor",
+
+	"Double Fault",
+	"Coprocessor Segment Overrun",
+	"Bad TSS",
+	"Segment Not Present",
+	"Stack Fault",
+	"General Protection Fault",
+	"Page Fault",
+	"Unknown Interrupt",
+
+	"Coprocessor Fault",
+	"Alignment Check",
+	"Machine Check",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+	"Reserved",
+};
+
+CLEAR void isr_install_handler(int isr, void (*handler)(struct regs *r))
 {
 	isr_routines[isr] = handler;
 }
 
-void isr_uninstall_handler(int isr)
+CLEAR void isr_uninstall_handler(int isr)
 {
 	isr_routines[isr] = 0;
 }
 
 void isr_panic(struct regs *r)
 {
-	printf("%s Exception (%x) at 0x%x (ring %d), exiting!\n", isr_exceptions[r->int_no],
+	printf("%s Exception (code %x) at 0x%x (ring %d), exiting!\n", isr_exceptions[r->int_no],
 	       r->err_code, r->eip, RING(r));
 	struct proc *proc = proc_current();
 	if (proc) {
@@ -196,7 +199,7 @@ void isr_handler(struct regs *r)
 		isr_panic(r);
 }
 
-static void isr_install(void)
+CLEAR static void isr_install(void)
 {
 	idt_set_gate(0, (u32)isr0, 0x08, 0x8E);
 	idt_set_gate(1, (u32)isr1, 0x08, 0x8E);
@@ -245,7 +248,8 @@ static void isr_install(void)
 /**
  * Combined
  */
-void interrupts_install(void)
+
+CLEAR void interrupts_install(void)
 {
 	idt_install();
 	isr_install();
diff --git a/kernel/drivers/keyboard.c b/kernel/drivers/keyboard.c
index 63005b9..b917e4e 100644
--- a/kernel/drivers/keyboard.c
+++ b/kernel/drivers/keyboard.c
@@ -13,10 +13,10 @@
 #include <str.h>
 #include <sys.h>
 
-static struct event_keyboard *event = NULL;
-static struct stack *queue = NULL;
-static u32 dev_id = 0;
+PROTECTED static struct stack *queue = NULL;
+PROTECTED static u32 dev_id = 0;
 
+static struct event_keyboard *event = NULL;
 static int state = 0;
 static int merged = 0;
 static void keyboard_handler(struct regs *r)
@@ -78,12 +78,12 @@ static res keyboard_ready(void)
 	return !stack_empty(queue);
 }
 
-void keyboard_reset(void)
+CLEAR void keyboard_reset(void)
 {
 	stack_clear(queue);
 }
 
-void keyboard_install(void)
+CLEAR void keyboard_install(void)
 {
 	//keyboard_rate(); TODO: Fix keyboard rate?
 	irq_install_handler(1, keyboard_handler);
diff --git a/kernel/drivers/mouse.c b/kernel/drivers/mouse.c
index db0d2fb..eb05d08 100644
--- a/kernel/drivers/mouse.c
+++ b/kernel/drivers/mouse.c
@@ -13,13 +13,12 @@
 #include <str.h>
 #include <sys.h>
 
-static char mouse_cycle = 0;
-static char mouse_byte[3] = { 0 };
-static struct stack *queue = NULL;
-static u32 dev_id = 0;
+PROTECTED static struct stack *queue = NULL;
+PROTECTED static u32 dev_id = 0;
 
 static struct event_mouse *event = NULL;
-
+static char mouse_cycle = 0;
+static char mouse_byte[3] = { 0 };
 static void mouse_handler(struct regs *r)
 {
 	UNUSED(r);
@@ -54,7 +53,7 @@ static void mouse_handler(struct regs *r)
 	}
 }
 
-static void mouse_serial_wait(u8 a_type)
+CLEAR static void mouse_serial_wait(u8 a_type)
 {
 	u32 time_out = 100000;
 	if (a_type == 0) {
@@ -70,7 +69,7 @@ static void mouse_serial_wait(u8 a_type)
 	}
 }
 
-static void mouse_serial_write(u8 a_write)
+CLEAR static void mouse_serial_write(u8 a_write)
 {
 	mouse_serial_wait(1);
 	outb(0x64, 0xD4);
@@ -78,7 +77,7 @@ static void mouse_serial_write(u8 a_write)
 	outb(0x60, a_write);
 }
 
-static u8 mouse_serial_read(void)
+CLEAR static u8 mouse_serial_read(void)
 {
 	mouse_serial_wait(0);
 	return inb(0x60);
@@ -101,7 +100,7 @@ static res mouse_read(void *buf, u32 offset, u32 count, struct device *dev)
 	return MIN(count, sizeof(*e));
 }
 
-void mouse_install(void)
+CLEAR void mouse_install(void)
 {
 	u8 status;
 
@@ -143,7 +142,7 @@ void mouse_install(void)
 	mouse_serial_read();
 	status = (u8)mouse_serial_read();
 	if (status == 3) {
-	};
+	}
 	/* printf("Scrollwheel support!\n"); */
 
 	// Activate 4th and 5th mouse buttons
@@ -166,7 +165,7 @@ void mouse_install(void)
 	mouse_serial_read();
 	status = (u8)mouse_serial_read();
 	if (status == 4) {
-	};
+	}
 	/* printf("4th and 5th mouse button support!\n"); */
 
 	/* TODO: Fix mouse laggyness
diff --git a/kernel/drivers/pci.c b/kernel/drivers/pci.c
index 72b9aa8..829f5b9 100644
--- a/kernel/drivers/pci.c
+++ b/kernel/drivers/pci.c
@@ -7,13 +7,13 @@
 #include <mem.h>
 #include <pci.h>
 
-void pci_write_field(u32 device, int field, u32 value)
+CLEAR void pci_write_field(u32 device, int field, u32 value)
 {
 	outl(PCI_ADDRESS_PORT, pci_get_addr(device, field));
 	outl(PCI_VALUE_PORT, value);
 }
 
-u32 pci_read_field(u32 device, int field, int size)
+CLEAR u32 pci_read_field(u32 device, int field, int size)
 {
 	outl(PCI_ADDRESS_PORT, pci_get_addr(device, field));
 
@@ -30,13 +30,13 @@ u32 pci_read_field(u32 device, int field, int size)
 	return 0xFFFF;
 }
 
-u16 pci_find_type(u32 device)
+CLEAR u16 pci_find_type(u32 device)
 {
 	return (u16)((pci_read_field(device, PCI_CLASS, 1) << 8) |
 		     pci_read_field(device, PCI_SUBCLASS, 1));
 }
 
-void pci_scan_hit(pci_func_t f, u32 dev, void *extra)
+CLEAR void pci_scan_hit(pci_func_t f, u32 dev, void *extra)
 {
 	int dev_vend = (int)pci_read_field(dev, PCI_VENDOR_ID, 2);
 	int dev_dvid = (int)pci_read_field(dev, PCI_DEVICE_ID, 2);
@@ -44,7 +44,7 @@ void pci_scan_hit(pci_func_t f, u32 dev, void *extra)
 	f(dev, (u16)dev_vend, (u16)dev_dvid, extra);
 }
 
-void pci_scan_func(pci_func_t f, int type, int bus, int slot, int func, void *extra)
+CLEAR void pci_scan_func(pci_func_t f, int type, int bus, int slot, int func, void *extra)
 {
 	u32 dev = pci_box_device(bus, slot, func);
 	if (type == -1 || type == pci_find_type(dev))
@@ -53,7 +53,7 @@ void pci_scan_func(pci_func_t f, int type, int bus, int slot, int func, void *ex
 		pci_scan_bus(f, type, (int)pci_read_field(dev, PCI_SECONDARY_BUS, 1), extra);
 }
 
-void pci_scan_slot(pci_func_t f, int type, int bus, int slot, void *extra)
+CLEAR void pci_scan_slot(pci_func_t f, int type, int bus, int slot, void *extra)
 {
 	u32 dev = pci_box_device(bus, slot, 0);
 	if (pci_read_field(dev, PCI_VENDOR_ID, 2) == PCI_NONE)
@@ -68,13 +68,13 @@ void pci_scan_slot(pci_func_t f, int type, int bus, int slot, void *extra)
 	}
 }
 
-void pci_scan_bus(pci_func_t f, int type, int bus, void *extra)
+CLEAR void pci_scan_bus(pci_func_t f, int type, int bus, void *extra)
 {
 	for (int slot = 0; slot < 32; ++slot)
 		pci_scan_slot(f, type, bus, slot, extra);
 }
 
-void pci_scan(pci_func_t f, int type, void *extra)
+CLEAR void pci_scan(pci_func_t f, int type, void *extra)
 {
 	if ((pci_read_field(0, PCI_HEADER_TYPE, 1) & 0x80) == 0) {
 		pci_scan_bus(f, type, 0, extra);
@@ -90,17 +90,17 @@ void pci_scan(pci_func_t f, int type, void *extra)
 	}
 }
 
-static void find_isa_bridge(u32 device, u16 vendor_id, u16 device_id, void *extra)
+CLEAR static void find_isa_bridge(u32 device, u16 vendor_id, u16 device_id, void *extra)
 {
 	if (vendor_id == 0x8086 && (device_id == 0x7000 || device_id == 0x7110))
 		*((u32 *)extra) = device;
 }
 
-static u32 pci_isa = 0;
-static u8 pci_remaps[4] = { 0 };
+PROTECTED static u32 pci_isa = 0;
+PROTECTED static u8 pci_remaps[4] = { 0 };
 
 // Remap
-void pci_install(void)
+CLEAR void pci_install(void)
 {
 	pci_scan(&find_isa_bridge, -1, &pci_isa);
 	if (pci_isa) {
@@ -116,7 +116,7 @@ void pci_install(void)
 	}
 }
 
-int pci_get_interrupt(u32 device)
+CLEAR int pci_get_interrupt(u32 device)
 {
 	if (pci_isa) {
 		u32 irq_pin = pci_read_field(device, 0x3D, 1);
diff --git a/kernel/drivers/serial.c b/kernel/drivers/serial.c
index 98108eb..6f00ac7 100644
--- a/kernel/drivers/serial.c
+++ b/kernel/drivers/serial.c
@@ -5,7 +5,7 @@
 #include <serial.h>
 #include <str.h>
 
-void serial_install(void)
+CLEAR void serial_install(void)
 {
 	outb(0x3f8 + 1, 0x00);
 	outb(0x3f8 + 3, 0x80);
diff --git a/kernel/drivers/timer.c b/kernel/drivers/timer.c
index 8887279..2a7ca2a 100644
--- a/kernel/drivers/timer.c
+++ b/kernel/drivers/timer.c
@@ -7,9 +7,9 @@
 #include <timer.h>
 
 static u32 timer_ticks = 0;
-static u8 call_scheduler = 0;
+PROTECTED static u8 call_scheduler = 0;
 
-static void timer_phase(int hz)
+CLEAR static void timer_phase(int hz)
 {
 	int divisor = 3579545 / 3 / hz;
 	outb(0x43, 0x36); // 01 10 11 0b // CTR, RW, MODE, BCD
@@ -38,12 +38,12 @@ void timer_wait(u32 ticks)
 {
 	u32 eticks = timer_ticks + ticks;
 	while (timer_ticks < eticks) {
-		__asm__ volatile("sti//hlt//cli");
+		__asm__ volatile("sti\nhlt\ncli");
 	}
 }
 
 // Install timer handler into IRQ0
-void timer_install(void)
+CLEAR void timer_install(void)
 {
 	/* hpet_install(10000); // TODO: Find optimal femtosecond period */
 	/* if (!hpet) */
@@ -51,13 +51,13 @@ void timer_install(void)
 	irq_install_handler(0, timer_handler);
 }
 
-void scheduler_enable(void)
+CLEAR void scheduler_enable(void)
 {
 	call_scheduler = 1;
 	irq_install_handler(0, timer_handler);
 }
 
-void scheduler_disable(void)
+CLEAR void scheduler_disable(void)
 {
 	call_scheduler = 0;
 	irq_install_handler(0, timer_handler);