Security on Prepakis Georgios | Kernelstub | Security Researcher

Advanced Linux Kernel Exploitation Techniques

Thu, 27 Mar 2025 00:00:00 +0000

Introduction to Linux Kernel Exploitation

Kernel exploitation sits at the top of the difficulty curve in offensive security, and for good reason. Userspace bugs get you code execution as some unprivileged process, but the kernel runs at Ring 0 (or EL1, if you’re on ARM) with unrestricted access to physical memory, every process’s address space, and every privilege check on the system. Pop a bug in the kernel and you’re not just compromising an application, you’re compromising the thing that enforces the rules for every application on the box. That’s why a single kernel LPE (local privilege escalation) bug is often worth more on the exploit market than a browser RCE: it’s the last mile between “I have a foothold” and “I own the machine.”

Advanced Windows Kernel Debugging Techniques

Mon, 10 Mar 2025 00:00:00 +0000

Kernel debugging is a different animal from the user-mode debugging most developers grow up with. You can’t just attach a debugger to a live kernel the way you’d attach to a misbehaving process, because the kernel is the thing that’s supposed to be managing every process on the box, including the debugger’s own. If it halts, everything halts. So Windows solves this the old-fashioned way: two machines. One is the “target,” the system whose kernel you actually want to inspect. The other is the “host,” running WinDbg, connected over a transport that survives the target being frozen mid-instruction: a network link, a serial cable, or USB. When you set a breakpoint and it hits, the entire target machine stops, not just one process, and control passes to your host over that wire. That’s the mental model to keep in the back of your head for everything that follows: you’re not debugging a program, you’re debugging an operating system from the outside, one machine talking to another.

Advanced Cryptography Concepts via Classical to Post-Quantum

Tue, 14 Jan 2025 00:00:00 +0000

Cryptography has a strange history for a field that’s now load-bearing for the entire internet. A lot of the number theory underneath it was developed by mathematicians who were doing pure math for its own sake, with zero interest in secrets or spies. Then, starting in the 1970s, people realized that certain “hard” problems in number theory (the kind that are easy to state but brutal to solve at scale) were exactly what you needed to build systems where two strangers could agree on a secret over a public channel, or where you could prove your identity without ever handing over a password. This post is a walk through that stack, from the classical number-theoretic foundations, through the protocols built on top of them, and finally into the post-quantum schemes that exist because a sufficiently large quantum computer would tear a hole through most of what came before.