Common OS-Level Vulnerabilities
Operating systems enforce boundaries between users, processes, memory regions, files, devices, and kernel code. Those boundaries are strong only when software uses them correctly.
A privileged program can check one file and accidentally open another. A service can leak an administrative socket into a child process. A kernel driver can trust a length supplied by an unprivileged caller. In each case, the operating system may faithfully perform every requested operation while the program violates its own security intent.
These are OS-level vulnerabilities: flaws at or near operating-system interfaces that allow an attacker to cross a protection boundary, gain unintended authority, disclose data, corrupt state, or deny service.
The recurring causes are remarkably consistent:
- Treating a mutable name as if it were a stable object
- Separating a security check from the operation it is meant to authorize
- Processing untrusted data with more privilege than necessary
- Mishandling memory, sizes, credentials, or inherited process state
- Assuming a mitigation removes the underlying bug
Learning to recognize these broken assumptions is more useful than memorizing a list of famous exploits.
This chapter examines memory-safety flaws, check-then-use races, pathname and temporary-file hazards, privilege and confused-deputy mistakes, inherited-authority leaks, availability attacks, and layered review and mitigation practices.