- Atlas
- Computer Science
- Systems Security
Systems Security
Systems security is the branch of cybersecurity concerned with the machine itself: the operating system, the hardware beneath it, the configuration it runs in, and the people who administer and use it.
11 frameworks, from 1972 to today · Cybersecurity · Computer Science
- Reference Monitor and Trusted Computing Base 1972-Present
- Multilevel Security and Mandatory Access Control 1973-Present
- Evaluation Criteria and Assurance 1983-Present
- Firewall 1988-2010
- Host-based intrusion detection system 1993-Present
- Least Privilege and System Hardening 1995-Present
- Vulnerability and Configuration Management 1995-Present
- Usable Security 1999-Present
- Virtualization and Workload Isolation 2001-Present
- Secure Development Lifecycle 2002-Present
- Zero Trust Architecture 2010-Present
Overview
Systems security is the branch of cybersecurity concerned with the machine itself: the operating system, the hardware beneath it, the configuration it runs in, and the people who administer and use it. Where network security guards the links between computers and software security guards individual programs, systems security asks whether the whole assembled platform can be trusted to enforce a policy—who may read what, which code may run, and whether anyone can tell when something has gone wrong. Its history is a long argument about where to put the boundary of trust, and what to do when that boundary turns out to be in the wrong place.
The reference monitor and the trusted computing base
The field's founding idea came from an operational problem. In the 1960s, time-sharing systems let many users run jobs on one machine, and the military wanted to put classified work on shared computers without leaking secrets between cleared and uncleared users12. The U.S. Air Force sponsored a study, published in 1972 as the Anderson Report, that framed the question sharply: a system is secure only if every access by a subject to an object is mediated by a small, tamper-proof, always-invoked piece of hardware and software. This was the reference monitor—an abstract enforcement point—and the collection of components that must be trusted to implement it became the trusted computing base (TCB)34. The TCB concept's power was diagnostic: it told designers that security depended on the size and correctness of a specific, identifiable part of the system, not on the whole thing being well built.
The idea was made concrete in the early 1970s at MIT's Project MAC, where Jerome Saltzer and Michael Schroeder, working on the Multics system, distilled a set of design principles—economy of mechanism, fail-safe defaults, complete mediation, open design, separation of privilege, least privilege, least common mechanism, psychological acceptability—that remain the field's catechism. Multics itself, a joint MIT–Bell Labs–General Electric effort, was the first operating system designed from the ground up around protection rings and per-segment access control, and its ring architecture directly influenced the Intel 80286 and later x86 privilege levels.
Multilevel security and mandatory access control
The military's need produced a formal theory. In 1973, David Bell and Leonard LaPadula at MITRE published a model of multilevel security in which every subject and object carries a classification, and access is governed by two rules: no read up (a secret-cleared user cannot read top-secret data) and no write down (a top-secret process cannot write to a secret file). This mandatory access control (MAC) contrasted with discretionary access control (DAC), in which the owner of a file decides who may access it—the model inherited from Unix's permission bits. The Bell–LaPadula model was later shown to have a subtle flaw: it constrains information flow but not the covert channels through which a high-level process can signal a low-level one by, say, modulating CPU load. Kenneth Biba's 1977 integrity model addressed a different axis, preventing low-integrity data from contaminating high-integrity data5.
These models were not merely academic. They shaped real systems: Honeywell's SCOMP, delivered in 1983, was the first system evaluated at the highest class of the Trusted Computer System Evaluation Criteria (the "Orange Book," 1983), and the later MULTICS and GEMSOS systems implemented multilevel security in production. The enduring lesson was that MAC requires the operating system to enforce policy the user cannot override—a stance that clashed with the Unix tradition of owner-controlled permissions and would resurface decades later in SELinux and AppArmor.
Evaluation criteria and the assurance problem
How do you know a TCB is trustworthy? The Orange Book answered with a ladder of evaluation classes (D through A1), each demanding more evidence: from informal testing at C1, through structured design and covert-channel analysis at B2, to formal top-level specification and verification at A1. The criteria spread internationally—the European ITSEC in 1991, the Canadian CTCPEC, and eventually the Common Criteria (ISO 15408) in 1999, which replaced the national schemes with a framework of protection profiles and evaluation assurance levels (EAL1–EAL7)67.
The assurance problem never fully went away. Formal verification of a whole operating system was attempted—the Kernelized Secure Operating System (KSOS) in the late 1970s, and later the seL4 microkernel, whose functional correctness was machine-checked in 2009—but the cost was enormous, and evaluation schemes were criticized for certifying paperwork as much as code. The deeper issue, articulated by Ken Thompson in his 1984 Turing Award lecture "Reflections on Trusting Trust," is that you cannot verify a compiler with a compiler: trust has to bottom out somewhere, and the TCB concept is really a discipline for being honest about where.
Perimeter defense and the firewall era
Through the 1980s, as machines joined networks, systems security increasingly meant defending a boundary. The first firewalls—packet filters at AT&T Bell Labs in the late 1980s, then application-layer proxies like DEC's SEAL and Marcus Ranum's TIS firewall toolkit in the early 1990s—embodied a simple model: a trusted inside, an untrusted outside, and a chokepoint between them. This perimeter defense was cheap and legible, and it dominated practice for two decades. Its weakness was structural: it assumed the inside was trustworthy, so a single compromised host or a laptop carried past the wall dissolved the boundary. The 1988 Morris worm, which spread through a buffer overflow in fingerd and weak passwords, showed how fast a single flaw could cross a network; the 1999 Melissa and 2000 ILOVEYOU outbreaks showed the same for email.
Host-based monitoring and integrity detection
Inside the perimeter, defenders needed to know when a host had been altered. The idea of checking file integrity against a known-good baseline was formalized by Gene Kim and Eugene Spafford in 1993 with Tripwire, which hashed critical system files and alerted on change. This host-based intrusion detection was joined by log analysis and, later, by kernel-level auditing. The approach's limitation is the baseline problem: on a busy system, files change constantly, and an attacker who compromises the machine can also compromise the checker. The same tension drove the development of antivirus signature scanning (from the late 1980s) and, much later, endpoint detection and response, which watches process behavior rather than file hashes.
Least privilege, vulnerability, and configuration management
Two quieter traditions matured in the 1990s. The first was least privilege in practice: running services as unprivileged users, dropping capabilities, and eventually sandboxing8. The second was the recognition that most compromises exploit misconfiguration and unpatched software rather than novel attacks. Vulnerability scanning tools (SATAN in 1995, Nessus in 1998) and configuration benchmarks turned systems security into a continuous hygiene discipline. The 2000s added automated patch management and, after high-profile breaches traced to default passwords and open services, the idea of a hardened baseline image. This is unglamorous work, but it is where most real incidents are prevented or missed.
Virtualization and workload isolation
The mainframe had virtual machines since the 1960s (IBM's VM/370), but the modern era began when VMware brought x86 virtualization to commodity servers around 1999–2001. Virtualization gave systems security a new isolation primitive: a hypervisor could separate workloads more strongly than an operating system could separate processes, and a compromised guest need not compromise its neighbors. The same logic later produced containers (Linux namespaces and cgroups, popularized by Docker from 2013), which isolate at the operating-system level with weaker but cheaper boundaries. The security question shifted to the hypervisor and container runtime themselves—the new TCB—and to side channels such as the 2017 Meltdown and Spectre speculative-execution flaws, which crossed isolation boundaries that had been assumed solid.
Usable security
A parallel thread asked why users defeat security. In 1999, Alma Whitten and J. D. Tygar published "Why Johnny Can't Encrypt," showing that a well-designed encryption tool was unusable by competent non-experts—and therefore insecure in practice. This founded usable security as an empirical discipline: study what people actually do, measure whether a design helps them do it, and treat unusable security as broken security9. The finding reshaped everything from password policy (the 2017 NIST guidelines abandoned forced complexity and expiry in favor of length and breach checks) to the design of permission prompts and security warnings.
Secure development and the shift-left movement
By the 2000s, the field had learned that security bolted on after deployment is expensive and leaky. Microsoft's Trustworthy Computing memo of 2002, prompted by a series of worms against its products, led to the Security Development Lifecycle (SDL): threat modeling at design time, static analysis and code review during development, penetration testing before release, and incident response after. The secure development lifecycle moved security work earlier—"shift left"—and made it a process rather than a product. It spread through the industry as a set of practices (threat modeling, security champions, bug bounty programs) rather than a single standard.
Zero trust and the present
The perimeter model finally broke under cloud computing and remote work. In 2010, John Kindervag at Forrester argued for zero trust: no implicit trust based on network location; every request authenticated and authorized, every session inspected, least privilege enforced continuously. Google's BeyondCorp (described publicly in 2014) was the landmark implementation, replacing a VPN with per-request access checks1011. Zero trust is less a product than an architecture, and its adoption has been uneven—many organizations run a "zero trust" label over a traditional perimeter—but it has decisively reframed the field's central question from "is this host inside the wall?" to "is this request, from this identity, on this device, authorized for this resource, right now?"
Today the main approaches descend directly from the history above: reference-monitor thinking survives in hypervisors, sandboxes, and hardware roots of trust (TPM, secure enclaves); mandatory access control in SELinux and its kin; evaluation and assurance in the Common Criteria and in formal-verification projects like seL4; integrity and behavior monitoring in endpoint detection; hygiene in vulnerability and configuration management; usable security in every serious design review; and zero trust in the architecture of cloud-native systems121314. The open questions are the old ones in new clothes: how to shrink the TCB when firmware and supply chains are opaque; how to verify that a system enforces its policy when the policy itself is written in natural language and changes constantly; and how to make the secure path the easy path for the people who must walk it.
References
- Trusted Computer System Evaluation Criteria (History), Wikipedia
- Penetration test (History), Wikipedia
- Reference monitor, Wikipedia
- Trusted computing base, Wikipedia
- Biba Model, Wikipedia
- Common Criteria (History), Wikipedia
- Evaluation Assurance Level, Wikipedia
- Principle of least privilege, Wikipedia
- Usable security (introduction, History), Wikipedia
- Zero trust architecture (History), Wikipedia
- BeyondCorp (introduction, Background), Wikipedia
- Computer security (Terminology), Wikipedia
- Security-evaluated operating system, Wikipedia
- Mandatory access control, Wikipedia
The frameworks of Systems Security
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1972-Present
Reference Monitor and Trusted Computing Base
What must be trusted to enforce access control?
- 1973-Present
Multilevel Security and Mandatory Access Control
How can classifications govern who reads and writes what?
- 1983-Present
Evaluation Criteria and Assurance
How do we know a system is actually secure?
- 1988-2010
- 1993-Present
Host-based intrusion detection system
How do we tell when a host has been altered?
- 1995-Present
Least Privilege and System Hardening
How little privilege can each part be given?
- 1995-Present
Vulnerability and Configuration Management
Which flaws and misconfigurations leave us exposed?
- 1999-Present
- 2001-Present
Virtualization and Workload Isolation
How can workloads be kept apart from one another?
- 2002-Present
Secure Development Lifecycle
How do we build security into development from the start?
- 2010-Present
Zero Trust Architecture
Should any part of a network be trusted by default?
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Multilevel Security and Mandatory Access Control influenced by Reference Monitor and Trusted Computing Base
The reference monitor's complete-mediation requirement gave Bell and LaPadula the enforcement mechanism their multilevel model presupposed: a tamper-proof kernel mediating every subject-object access. The TCB concept then defined which components had to be trusted to enforce the no-read-up/no-write-down rules.
Carried by David Bell; Leonard LaPadula; Anderson Report (1972).
Evaluation Criteria and Assurance grew out of Reference Monitor and Trusted Computing Base
The Orange Book's evaluation classes were defined by how much evidence a system offered that its trusted computing base correctly implemented a reference monitor, from informal testing up to formal top-level specification. Assurance criteria were thus a direct outgrowth of the TCB concept.
Carried by Trusted Computer System Evaluation Criteria (1983).
Zero Trust Architecture reacted against Firewall
Zero trust architecture defined itself against the perimeter model: it rejected the assumption of a trusted inside protected by a chokepoint firewall and instead required authentication and authorization for every request. The firewall era's structural weakness, that one compromised host dissolves the boundary, was the explicit target.
Carried by John Kindervag.
Least Privilege and System Hardening influenced by Reference Monitor and Trusted Computing Base
Saltzer and Schroeder's design principles, distilled from Multics and the reference-monitor tradition, included least privilege and economy of mechanism; these principles were later taken up as the practical basis for running services unprivileged and shrinking the trusted base.
Carried by Jerome Saltzer; Michael Schroeder.
Virtualization and Workload Isolation influenced by Reference Monitor and Trusted Computing Base
Virtualization recast the trusted computing base: the hypervisor became the small, mediating layer that had to be trusted to isolate workloads, and the security argument was made in reference-monitor terms. Later side-channel flaws such as Meltdown and Spectre were analyzed as failures of that isolation boundary.
Carried by VMware.
Evaluation Criteria and Assurance grew out of Multilevel Security and Mandatory Access Control
The evaluation ladder's higher classes (B2 and above) demanded structured design and covert-channel analysis of mandatory access control, so the criteria were written around the multilevel security models. SCOMP, the first A1 system, was built to enforce Bell-LaPadula policy.
Carried by Trusted Computer System Evaluation Criteria (1983); SCOMP.
Least Privilege and System Hardening influenced by Multilevel Security and Mandatory Access Control
The mandatory-access-control stance that policy must be enforced by the operating system rather than left to the user resurfaced in SELinux and AppArmor, which hardened Linux hosts by confining processes regardless of owner permissions.
Carried by SELinux; AppArmor.
Secure Development Lifecycle influenced by Evaluation Criteria and Assurance
The assurance tradition's demand for evidence that security was designed in, not bolted on, carried into secure development lifecycle frameworks, which specify threat modeling, review gates and verification activities at each stage. The evaluation mindset was applied to the development process itself.
Carried by Microsoft Security Development Lifecycle.
Virtualization and Workload Isolation influenced by Least Privilege and System Hardening
Container isolation built on the least-privilege and hardening tradition by using Linux namespaces and cgroups to confine workloads, dropping privileges and limiting what a process can reach. Docker popularized this as a cheaper boundary than full virtualization.
Carried by Docker.
Beyond the field
Where Systems Security's ideas came from in other fields, and what they led to there: the strongest 12 of 49 links.
Multilevel Security and Mandatory Access Control led to Access control in Security Theory
General access control grew out of multilevel security and mandatory access control: Bell-LaPadula's lattice and mandatory rules were abstracted into access-matrix and role-based models covering discretionary and commercial systems.
Carried by David F. Ferraiolo; Ravi Sandhu.
Multilevel Security and Mandatory Access Control influenced by Reference Monitor and Trusted Computing Base in Security Theory
The reference monitor concept gave multilevel security its enforcement mechanism: Bell and LaPadula's model assumed a monitor mediating all accesses against the lattice of labels. The TCB notion then defined what had to be trusted to enforce the policy.
Carried by David Elliott Bell; Leonard J. LaPadula.
Multilevel Security and Mandatory Access Control influenced by Reference monitor and trusted computing base in Cybersecurity
Same reference monitor and TCB idea, filed under Cybersecurity, which directly underpinned multilevel security enforcement. The monitor mediates the mandatory checks the MLS policy requires.
Carried by James P. Anderson.
Evaluation Criteria and Assurance influenced by Reference Monitor and Trusted Computing Base in Security Theory
Reference monitor and TCB ideas are the substance the evaluation criteria measure, with assurance levels tied to how completely the monitor is enforced and verified. The Orange Book's classes are defined in these terms.
Carried by Department of Defense Trusted Computer System Evaluation Criteria (1983).
Evaluation Criteria and Assurance influenced by Reference monitor and trusted computing base in Cybersecurity
Same reference monitor and TCB idea, filed under Cybersecurity, which the evaluation criteria formalized into assurance ratings. The criteria grade systems by the rigor with which the monitor and TCB are designed and verified.
Carried by Department of Defense Trusted Computer System Evaluation Criteria (1983).
Host-based intrusion detection system grew out of Intrusion Detection and Prevention in Network Security
Host-based intrusion detection grew directly out of the intrusion detection framework, applying Denning's anomaly and misuse models to audit logs on a single machine. Early host-based systems such as IDES and later Tripwire implemented that model locally.
Carried by Dorothy E. Denning.
Least Privilege and System Hardening influenced by Secure Design Principles in Software Security
Least privilege is one of Saltzer and Schroeder's secure design principles, and system hardening practice is built on applying it along with complete mediation and fail-safe defaults. The later framework is a direct extension of those principles into operational hardening.
Carried by Jerome H. Saltzer; Michael D. Schroeder.
Virtualization and Workload Isolation led to Container-based isolation in Operating Systems
Container-based isolation grew directly out of OS-level virtualization and workload isolation, using kernel namespaces and cgroups to partition a shared kernel. The container is a refinement of the isolation mechanisms developed in that earlier work.
Virtualization and Workload Isolation influenced by Hypervisor in Operating Systems
The hypervisor, developed from IBM's CP-67 and later Xen, is the mechanism by which virtualized workloads are isolated; Xen's 2003 design made the hypervisor the security boundary for multi-tenant workloads.
Carried by CP-67 (1967); Xen (2003).
Secure Development Lifecycle grew out of Systems development life cycle in Software Process Models
The secure development lifecycle is a direct refinement of the systems development life cycle: Microsoft's SDL inserted security activities such as threat modelling and security testing into each phase of the established SDLC.
Carried by Microsoft Security Development Lifecycle; Michael Howard; Steve Lipner.
Zero Trust Architecture reacted against Perimeter Security Model in Network Security
Zero trust architecture arose as an explicit rejection of the perimeter security model, arguing that once the perimeter is breached, implicit trust inside the network is indefensible; Kindervag's 2010 work framed zero trust as its replacement.
Carried by John Kindervag; Forrester Research.
Reference Monitor and Trusted Computing Base influenced Zero trust architecture in Cybersecurity
The trusted computing base notion shaped zero trust's assumption that no network location is inherently trustworthy and that trust must be established per request. Enforcement points and policy decision points in zero trust are a reworking of the reference monitor and its trusted base.

Systems Security is a planet in Nousfarer
Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.
Land on Systems SecurityRelated fields
Fields its ideas are linked to
- Software Security 14 links
- Network Security 7 links
- Security Theory 7 links
- Operating Systems 5 links
- Cybersecurity 4 links
- Computer Systems 4 links
- Embedded Systems 1 link
- Human Computer Interaction 1 link
- Interaction Design 1 link
- Systems Analysis And Design 1 link
- Technology And Internet Law 1 link
- Network Architecture 1 link
More in Cybersecurity
- Applied Cryptography
- Cybersecurity
- Digital Forensics
- Digital Privacy
- Malware Analysis
- Network Security
- Security Economics
- Security Theory
- Software Security
See where Systems Security sits on the Map of Human Knowledge