← all systems · see it in The System
Trust boundary
A boundary where program data or execution changes its level of trust, or where two principals with different capabilities exchange data or commands; inside it all sub-systems have equal trust (src:wp:trust-boundary). In security engineering the line is drawn around what must be trusted (the trusted computing base, whose bounds 'equate to the security perimeter', src:tcsec-1985) and is enforced by a guard at a door in a wall (src:saltzer-schroeder-1975). Walked as the line, the checks made at it and the practice that draws it, from kernel and process boundaries to browser origins, network perimeters and zero trust's per-request checks; borders and checkpoints on the shelf.
Properties published scienceour proposal
Sourced fields, and our own readings.
| born at | by 1972 |
| born precision | about 5 years (rings 1971-72; reference monitor 1972) |
| boundary | Inside: the line between parts trusted to different degrees and everything that holds it: the wall that forces every reference through a door, the door itself (gates, designated entry points, interfaces, policy enforcement points), the guard's checks at it (authentication, validation, mediation), the trusted side's mechanisms (the trusted computing base, the reference validation mechanism, the policy engine) and the practice that draws the line (threat models with trust boundaries marked). Outside: the parts on either side (users, programs, networks, devices, data stores), what crosses (data and control), intruders, the access-control decision rules (walked as sys:access-control), the network devices that build one kind of perimeter (sys:firewall), and the wider security policy and mission that set what is to be protected. |
| nested level | A design element inside computer systems (rung 12): in hardware (privilege modes and rings), the operating system (kernel and process boundaries), applications and browsers (sandboxes, origins, site isolation), networks and enterprises (perimeters, micro-perimeters); drawn by people in threat models (rung 11 practice). Part of computer security and information security; the place where access control is applied. |
| scale | technological |
Measures (13) published science
| characteristic clock: one user-to-kernel crossing (getpid) | 1000-1500 cycles, of which about 100 are the switch itself (70 in, 40 back); about 150 cycles on the L3 microkernel CPU cycles |
| size of the seL4 kernel (ARMv6) | 10.2 (9.7 C, 0.5 assembler); original L4 6.4; Fiasco.OC 37.6 thousand lines of code |
| one-way IPC across a protection boundary, seL4 on ARM11 | 188 CPU cycles |
| verification limit on a kernel's size | about 9,000 source lines of code ('pushed the limits') |
| new site-isolation bugs from one month of fuzzing | 4 (one with full control of the victim site; $8000 bounty) bugs |
| site-isolation bypasses by cause, Chrome and Firefox | 39 known (text); table rows: 28 missing checks, 4 bypassed checks, 6 origin confusion = 38 vulnerabilities |
| rings: Multics against today's systems | Multics 8; x86 4; most operating systems use 2 (ring 0 and 3) privilege rings |
| normal and alerting access counts in NIST's contextual example | 20 to 30 records a day normal; alert above 100 records per day |
| work factor of four-letter passwords | 26^4 = 456,976 tries |
| element types in a threat-modelling data flow diagram | 5 (four DFD types plus trust boundaries) element types |
| readings of 'trust boundary' in DFDs | 3 (trust or privilege levels; attacker-model assumptions; deployment) interpretations |
| added cost of user-kernel crossings with KPTI | 0.28% (KAISER's authors); about 5% for most workloads, up to 30% (a Linux developer); PostgreSQL read-only 7-17% (16-23% without PCID) percent overhead |
| organisations planning zero trust capabilities in 2020 | 72% share of organisations |
Open contentions (6) open contention
Where sources or readings disagree. Both stay on the map.
- C-3834 When did security people start saying the network perimeter was dissolving: 2003 or 2004?
booked: The map keeps the competing readings; none is ruled.
the other reading: 2003; 2004 - C-3857 How much did the fix for the Meltdown chip flaw slow computers down?
booked: The map keeps the competing readings; none is ruled.
the other reading: 0.28%; about 5% (up to 30%) - C-3882 Were protection rings in computers a breakthrough, or more than was needed?
booked: The map keeps the competing readings; none is ruled.
the other reading: many rings are a real gain in protection; two modes are enough; rings a blind alley (Wilkes, quoted) - C-3894 What is a trust boundary: a line in a design drawing, or a mechanism that enforces it?
booked: The map keeps the competing readings; none is ruled.
the other reading: a line marking assumptions about where an attacker can reach; a deployment line (what runs on the same network) - C-3898 Does 'zero trust' security remove trust boundaries or multiply them?
booked: The map keeps the competing readings; none is ruled.
the other reading: zero trust removes trust as an access criterion altogether: 'Trust is a vulnerability and, like all vulnerabilities, should be eliminated' (Kindervag, quoted by Campbell 2020) - C-3899 Who coined the term 'zero trust'?
booked: The map keeps the competing readings; none is ruled.
the other reading: Kindervag first used it in a 2008 speech (Campbell 2020); Kindervag 2010 (encyclopedia); NIST: 'later coined by John Kindervag' after de-perimeterisation
Cross-scale patterns seen here (20) our proposal
Shapes that recur when the same kind of problem is solved at different scales, and how each shows in Trust boundary. Each links to every other system that shows it.
- causal ceiling (structural)
A decision point cannot reach past its place in the flow: the PDP/PEP 'cannot apply additional policies beyond its location in the flow of traffic', so everything behind it shares its level; the only remedy is to make the zone behind it small. Set by where it stands, not by its means. - nested ladder (structural)
Concentric rings of decreasing privilege, each inner ring holding what the outer ones may only ask for; TCSEC classes where B3 and above add the reference monitor requirement to what the lower classes ask. Not the general shape of trust boundaries: peer boundaries and enclaves sit outside it (see no - outside-to-inside (structural)
The line moves from the environment's edge into the system: first one perimeter at the network's edge (TIC, 'choke points', the hard crunchy shell), then enforcement points and micro-perimeters around each resource inside ('moves protections closer to the assets'). The outside phase comes first in t - same role, different builds (structural)
One job, keeping a less-trusted part from a more-trusted one except through a checked door, done by unrelated builds: hardware rings and the descriptor register, process walls and sandboxes, browser origins and site isolation, network perimeters and per-resource enforcement points, border checkpoint - same shape, opposite sign (structural)
One level-ordered read/write rule with its direction reversed per property: Bell-LaPadula lets secrets flow only upward (no read-up, no write-down); Biba, 'the direct inverse', lets integrity flow only downward. So one line between levels has a direction per property, and the two together pin readin - templating (structural)
One module reused unchanged across systems: the reference monitor's requirements (tamper proof, always invoked, small enough to analyse) applied to kernels, browsers and enterprise PEPs; the origin tuple standardised for every web protocol. - the whole sets the local reference (structural)
Where the TCB's edge falls is set by the whole policy, not by the part: a web server outside the OS's TCB is inside the TCB of the larger web application ('fundamental relativity of the boundary'); behind each PEP all traffic shares 'a common level of trust' set by that point. - trade one property for another (structural)
Speed bought with trust: putting application logic in the kernel saves crossings but enlarges what must be trusted; a singular trust algorithm is faster but misses attacks a contextual one catches; zero trust's constant checks cost user frustration. Kinds sit at different points of each trade (two-r - who opens the door (structural)
The door is opened from the inside ahead of time: protected subsystems are entered only at designated entry points the system set up; a system program 'listening' at unused terminals and ports hands each new user to a domain entry that demands authentication; zero trust's PEPs are placed in front of - barrier-gates-complexity (partial)
Controlled sharing among many users needs the wall first: Saltzer and Schroeder start from complete isolation and lower the walls in a controlled way; without a TCB a system has no security of its own and is safe only in a locked room with no network. The without-case is named, but no complexity los - borrowed-then-held (partial)
Security first supplied by the surroundings (a computer in a locked room without a network) and then held inside by a trusted computing base and its hardware. The sources set the two side by side; neither dates a borrowed phase before a held one for one system. - holding / entrainment (partial)
The privileged browser process sets the death of its renderer parts: on malformed or invalid messages it kills them, holding the compromise inside the part. - namespace completeness (the map predicts its gaps) (partial)
Threat modelling enumerates a closed set of element types (five, with trust boundaries) against a closed set of threat categories (STRIDE's six), so the grid itself says which threats to look for at each element and boundary and where none has been looked for yet. - red-queen (partial)
Defenders add checks where bypasses were found; attackers 'will not sit idle but will instead change behavior in the face of ZTA'; a month of fuzzing found four new site-isolation bugs after 39 known ones were classified. Both sides keep moving; the stalemate (neither gaining ground) is not measured - symmetry breaking (name the cut) (partial)
Before the cut all sub-systems have equal trust; the boundary is the named cut where trust changes, and the trusted side then sets what is built (the TCB, the policy). Saltzer and Schroeder start from users isolated symmetrically and break it by granting controlled sharing. - The carry (partial)
Two faces. The wait: every request waits on the check ('Delay or inability to reach a PEP ... negatively impacts the ability to perform the workflow'; NIST asks for 'minimizing temporal delays in authentication mechanisms'). The lookahead: the kernel places functions such as gettimeofday in each pro - The Payment to Entropy (partial)
Every crossing pays a toll in time: a getpid call costs 1000-1500 cycles, of which about 100 are the switch and the rest 'kernel overhead'; L4's designers measure IPC in cycles because the crossing is the critical cost (188 cycles one-way on seL4/ARM11). Form: a signal toll per hand-off across the l - Umwelt: each system carves its own slice of one shared medium (partial)
Each kind of boundary reads its own slice of the same traffic: the browser by (scheme, host, port), site isolation by scheme plus registrable domain, the CPU by its privilege bit, zero trust by identity, device posture and context, a border by documents and biometrics. - cephalization (surface)
Perimeter security gathers checking at the edge where outside traffic arrives ('choke points'); the sources give the reason as effort ('the largest effect for the effort'), not the input-first reason the shape needs. - lightning (surface)
One crossing that changes everything after it: once the perimeter is breached, lateral movement inside is unhindered. A sudden state flip, but a gated one (it needs a breach) and the sources give no discharge.
Valence: what it trades, and with whom (9) published science
Each exchange with a neighbour, read from both sides: who gains, who pays, and what carries it.
- Human (Homo sapiens) via sys:human-society · Trust boundary mixed
- Operating system via sys:computer-hardware · Trust boundary gain
- Authentication via sys:human-society · Trust boundary gain
- Access control via sys:human-society · Trust boundary gain
- Threat actor via sys:internet · Trust boundary loss
- Information security via sys:written-record · Trust boundary gain
- Computer hardware via sys:computer-hardware · Trust boundary gain
- Firewall (computing) via sys:computer-network · Trust boundary gain
- Software vulnerability via sys:software · Trust boundary loss
Partners and parts published science
Built from / builds (9)
- Reference monitor
- Transaction log
- Attackers against trust boundaries for what lies on the trusted side
- Trusted computing base
- Protection rings and privilege modes
- Policy enforcement point
- Policy engine and policy administrator (policy decision point)
- Input validation
- Trusted path
Sits inside / holds (3)
expressed by (22)
- Generation/Synthesis
- Templating / Standardization
- Interoperability/Transduction (Bridging)
- Encapsulation & Modularity (Abstraction)
- Distributed Autonomy/Decentralized Execution (Subsidiarity)
- Internal Coordination/Regulation
- Sensing/Scanning
- Mapping/Modeling
- Surprise / Change-Point Detection
- Reactive Response
- Proactive Defense
- Physical/Virtual Barrier
- Self-Monitoring
- Delay/Redirection Tactics
- Validation of Identity/Intention
- Validation of Effectiveness
- Enclave/Segregation
- Resilience & Repair
- Redundancy & Diversity
- Triage & Prioritized Allocation
- Deterrence
- Quality Control & Error Correction
floor filled by (22)
- Human (Homo sapiens)
- Software
- Human society (from local community up to societies)
- Operating system
- Authentication
- Access control
- Information security
- Microkernel
- Computer network
- Reference monitor
- Border control
- Trusted computing base
- Protection rings and privilege modes
- Policy enforcement point
- Policy engine and policy administrator (policy decision point)
- Input validation
- Trusted path
- Network perimeter
- Sandbox
- Same-origin policy (browser origins)
- Site isolation
- Data flow diagram
Kinds (13)
- Border control
- Execution trust boundary
- Data trust boundary
- Network perimeter
- Micro-perimeter (zero trust)
- Sandbox
- Same-origin policy (browser origins)
- Site isolation
- Protected subsystem (domain with entry points)
- Trusted execution environment (enclave)
- Boundary between mutually suspicious peers
- In-process compartment
- Organisational compartment (need-to-know line)
Notes published science
- The famous 'reference monitor' was first put as three plain rules in a 1972 US Air Force planning study: the checker must be tamper proof, always invoked, and small enough to test completely. Forty years later the seL4 team found that even about 9,000 lines of kernel code 'pushed the limits' of what they could formally prove correct (src:anderson-1972, src:elphinstone-heiser-2013).
- NIST's own picture of a zero trust 'implicit trust zone' is an airport: everyone past the security checkpoint, passengers and crew alike, mills about the boarding area as trusted, so the advice is to make that zone as small as possible (src:nist-sp800-207).
- Of the known breakouts from browsers' site isolation that researchers sorted by cause, 28 were simply a check that was never written; the other 10 were checks that were there but got bypassed or fooled about where content came from (src:drescher-2026-site-isolation).
Layers
The ways it takes in its world, where they meet, and how it acts back, each from L1 (where it meets the world) up.
the boardroom (shared floors)
- L5: Mediation and enforcement at the door: the reference validation mechanism, the guard, the policy enforcement point; tamper proof, always invoked, small enough to analyse
- L6: What is trusted and by what rule: the trusted computing base (its bounds are the security perimeter), the security policy, the policy engine and its trust algorithm
- L7: The protection goal: the authority structure the owners want carried out, the information and resources protected, the mission
trust boundaries as security engineers draw them: parts of a system trusted to different degrees and what passes between them, up to the protection goals the boundary serves (reader's view)
- L1: Parts of a system with different trust: users and programs, processes, devices, networks, data stores, external entities; inside a zone all have equal trust
- L2: The line: where the level of trust changes (a ring boundary, a process wall, an origin, a network perimeter, a drawn boundary on a data flow diagram)
- L3: What crosses: data from an untrusted source, control with a change of privilege, commands between principals
- L4: The checks at the door: authentication, validation, the authority check
- L5: Mediation that cannot be bypassed: the reference validation mechanism, the enforcement point, with the trust zone behind it kept small
- L6: What must be trusted and the rule it applies: the trusted computing base and the security policy; in zero trust the policy engine
- L7: The goal: the authority structure the owners want, information protected from unauthorized use
way in: Code and updates arriving from the build side (dependencies, compilers, drivers, vendor updates)
- L1: Code written by others
- L2: Built by compilers, assemblers and loaders that are themselves code
- L3: Signed: author and integrity bound to the artifact
- L4: Verified when deployed: the author's or build system's identity and a checksum
way in: Context: time, place, the subject's history, threat intelligence
- L1: Time and geolocation of the request
- L2: Recorded: the policy database, past behaviour, threat intelligence
- L3: Kept as state on each subject by the policy engine
- L4: Compared with the subject's normal pattern
way in: Control passing in: calls from a less-privileged ring, process or domain
- L1: A program in an outer ring or user mode asks for something only an inner ring may do
- L2: A system call or cross-ring call: the processor's mode bit and the gate
- L3: The crossing itself checked by hardware; calls land only at designated entry points
- L4: The inner side's entry point: the protected subsystem's procedure
way in: Data arriving from the less-trusted side (user input, network sockets, files, partner feeds)
- L1: Data from an untrusted source: user input, a network socket, an internal API or stored record
- L2: Received at the component's interface: the place the boundary is drawn on the data flow diagram
- L3: Parsed by a maintained parser for the expected format
- L4: Validated for syntax and semantics against an allowlist, wherever it crosses
way in: People and goods arriving at a checkpoint (borders; shelf)
- L1: Travellers and freight moving across borders
- L2: Met by officers and machines at the checkpoint (officers ride Human's sight channel)
- L4: Sorted and filtered by criteria, slowed or sped up; biometric passports read at automated gates
way in: Signs of compromise on the far side (malformed messages, failed checks)
- L1: A compromised renderer can send arbitrary messages
- L2: Received by the privileged browser process over IPC
- L3: Checked against the site the browser process tracks for that renderer
- L4: Judged malformed or invalid: a sign of compromise
way in: The designers' model of the system and its threats (where the line is drawn)
- L1: What the team knows of the system: 'what are we working on?'
- L2: Drawn as a data flow diagram: external entities, processes, data stores, flows
- L3: Trust boundaries added as the fifth element
- L4: STRIDE prompts applied to components, flows and boundaries
- L5: Mitigations chosen and placed (the readings of the boundary differ, so placement can go wrong)
way in: The state of the asking device (posture)
- L1: Enterprise-owned and personal devices, patched or not
- L2: Monitored for integrity and security posture
- L3: The CDM system reports the asset's state to the policy engine
- L4: Weighed into the confidence level for this request
way in: Where web content came from (its origin)
- L1: Content created by many authors, some malicious, fetched from servers by URI
- L2: Tagged with its URI as it is fetched
- L3: Grouped into origins: same scheme, host and port
- L4: Run in the sandboxed renderer process for its site; the privileged browser process checks every message
way in: Who is asking: the principal and its credentials
- L1: A person or program on the far side; the principal is who is accountable
- L2: A credential presented (password, device artifact)
- L3: Over a path untrusted software cannot imitate (trusted path)
- L4: Authenticated and authorized for this request
way out: Admitted across: entered at a controlled point with least privilege
- L1: The resource used; beyond the PEP is the trust zone hosting it
- L3: Control enters the domain at its entry point
- L5: Granted for this request only
way out: Contained: the compromised side cut off or killed
- L1: The compromise held on its side
- L3: Connection terminated by the PEP
- L5: Compromise recognised
way out: Recorded: logs and audit
- L1: Rejected input recorded without secrets
- L6: Changes to the decision rules logged
way out: Redrawn: the line moved, shrunk or split (design change)
- L1: The built system: rings, processes, perimeters, micro-perimeters
- L3: Functions moved across rings (drivers out of the kernel; vDSO into processes; some logic into the kernel for speed)
- L6: Shrink the trust zone, shrink the TCB
- L7: The goal: protect the resources that matter most
way out: Refused: default is no access
- L1: Values outside the rules rejected
- L5: No permission found: refused
way out: Waved through or slowed (checkpoints; shelf)
- L1: Some movement accelerated and waved through, some slowed, diverted or halted
- L5: Sorted into categories
where trust boundaries sit, from the hardware out to the organisation (placement reading, defence in depth)
- L1: Hardware and firmware: the processor's most privileged level and its secure areas
- L2: Hypervisor
- L3: Kernel: the user-kernel line crossed by system calls
- L4: Process: sandboxes and per-site renderer processes
- L5: Application and origin
- L6: Network: perimeters and micro-perimeters
- L7: Organisation: compartments and need-to-know