Authorization: Controlling Access to System Resources
Authorization Models
Read aloud is unavailable in this browser.
The Gatekeeper Problem
After a user has been authenticated (their identity verified), the operating system faces an equally critical question: What is this user allowed to do?
This is the domain of authorization—the process of determining whether a verified identity has permission to perform a requested operation on a specific resource. While authentication answers "Who are you?", authorization answers "What can you do?"
Authorization is among the most consequential decisions an operating system makes. A single flaw in authorization logic can expose sensitive data to unauthorized access, allow privilege escalation attacks, or enable complete system compromise. The 2017 Equifax breach, which exposed 147 million records, stemmed partly from authorization failures. The 2020 SolarWinds attack exploited authorization weaknesses to move laterally across networks.
Understanding authorization models isn't just academic—it's essential knowledge for building secure systems at any scale.
By the end of this page, you will understand the fundamental models that govern authorization decisions, their mathematical foundations, their tradeoffs in different security contexts, and how modern operating systems implement these concepts. You'll gain the vocabulary and mental models to reason about authorization in any system you build or analyze.
Authorization Fundamentals
Before examining specific models, we must establish the fundamental concepts that all authorization systems share. These concepts form the vocabulary for precise discussion of access control.
The Authorization Triple
Every authorization decision fundamentally involves three elements:
- Subject — The active entity requesting access (user, process, service, device)
- Object — The passive entity being accessed (file, memory region, network socket, database record)
- Operation — The specific action requested (read, write, execute, delete, append)
The authorization system's job is to determine whether a given (subject, operation, object) triple should be allowed or denied.
1234567891011121314151617181920
// The fundamental authorization decisionfunction authorize(subject: Subject, operation: Operation, object: Object): Decision { // Option 1: Explicit allow if (policyExplicitlyAllows(subject, operation, object)) { return ALLOW; } // Option 2: Explicit deny if (policyExplicitlyDenies(subject, operation, object)) { return DENY; } // Option 3: No explicit rule - use default return DEFAULT_POLICY; // Usually DENY (fail-safe default)} // Example authorization checks:// authorize(user_alice, READ, /etc/passwd) -> ALLOW (world-readable)// authorize(user_alice, WRITE, /etc/shadow) -> DENY (root only)// authorize(kernel, WRITE, /dev/mem) -> ALLOW (privileged)The Reference Monitor Concept
The reference monitor is the abstract machine that mediates all access between subjects and objects. First formalized in the 1972 Anderson Report, the reference monitor has three essential properties:
- Complete Mediation — Every access must be checked; there are no bypasses
- Tamper-Proof — The reference monitor cannot be modified by unauthorized subjects
- Verifiable — The implementation is small enough to be subject to formal analysis
In practice, the operating system kernel serves as the reference monitor. System calls cross the user-kernel boundary, and the kernel enforces authorization before granting access to protected resources.
Complete mediation requires that literally every access path goes through the authorization check. Covert channels (timing, storage, or shared resources that leak information) represent paths that bypass the reference monitor. Achieving true complete mediation in complex systems remains an open challenge.
Authorization vs. Access Control
These terms are often used interchangeably, but there's a subtle distinction:
- Authorization is the abstract decision-making process
- Access Control is the implementation that enforces authorization decisions
An authorization policy specifies what is allowed. An access control mechanism enforces that policy. This separation is crucial—the same authorization policy can be enforced by different mechanisms, and the same mechanism can enforce different policies.
| Term | Definition | Example |
|---|---|---|
| Subject | Active entity requesting access | User process, kernel thread, network service |
| Object | Resource being accessed | File, socket, memory page, IPC channel |
| Principal | The authenticated identity associated with a subject | User ID (UID), service account, X.509 certificate |
| Permission | A specific operation allowed on an object | read, write, execute, delete, setattr |
| Policy | Rules defining which accesses are permitted | DAC rules, SELinux policy, RBAC configuration |
| Reference Monitor | Abstract machine enforcing policy | OS kernel, hypervisor, database engine |
The Access Matrix Model
The Access Matrix is the fundamental abstraction for reasoning about authorization. Introduced by Lampson in 1971 and formalized by Graham and Denning in 1972, the access matrix provides a complete representation of all access rights in a system.
Structure of the Access Matrix
The access matrix A is a two-dimensional structure where:
- Rows represent subjects (S₁, S₂, ..., Sₙ)
- Columns represent objects (O₁, O₂, ..., Oₘ)
- Cell A[Sᵢ, Oⱼ] contains the set of rights that subject Sᵢ has over object Oⱼ
Each cell contains zero or more rights from a defined set R = {r₁, r₂, ..., rₖ}. Common rights include:
- read (r) — Retrieve object contents
- write (w) — Modify object contents
- execute (x) — Run object as a program
- own — Modify rights for this object
- control — Modify row (subject's rights)
Access Matrix for a Simple Unix-like System============================================ │ /etc/passwd │ /etc/shadow │ /home/alice │ /bin/ls │ process_42───────────────┼─────────────┼─────────────┼─────────────┼─────────┼───────────root │ r, w, own │ r, w, own │ r, w, own │ r, x │ controlalice │ r │ - │ r, w, own │ r, x │ controlbob │ r │ - │ - │ r, x │ -shadow (group) │ r │ r │ - │ - │ - Key: r = read, w = write, x = execute own = can modify permissions (column) control = can modify process (row) - = no access Observations:- root has universal access (superuser)- alice owns her home directory (can grant/revoke access)- /bin/ls is executable by all, writable by none (integrity protected)- /etc/shadow is readable only by root and shadow group membersSubjects as Objects
A crucial insight is that subjects can also be objects. A process (subject) can be killed, signaled, traced, or debugged by other processes. This is represented by including each subject as a column in the matrix.
When subject Sᵢ has the control right over subject Sⱼ (in column Sⱼ), Sᵢ can modify Sⱼ's capabilities. This models administrative hierarchies and process management.
Special Rights: Own and Control
Two meta-rights are essential for matrix management:
- Own (for objects) — If A[S, O] includes 'own', then S can grant or revoke any right in column O (except own itself, in some models)
- Control (for subjects) — If A[S₁, S₂] includes 'control', then S₁ can modify rights in row S₂
These meta-rights create power structures within the access matrix.
Lampson identified six primitive operations for modifying the access matrix: create subject, delete subject, create object, delete object, enter right (add a right to a cell), and delete right (remove a right from a cell). All authorization policy changes can be expressed as sequences of these primitives.
The Implementation Problem
The access matrix is conceptually elegant but impractical to implement directly. Consider a system with:
- 10,000 users (subjects)
- 1,000,000 files (objects)
- Each cell storing a 32-byte rights structure
Direct representation would require 10,000 × 1,000,000 × 32 = 320 GB just for the matrix, most of which would be empty (sparse).
This motivates two practical implementations:
- Access Control Lists (ACLs) — Store matrix by column (object-oriented)
- Capability Lists — Store matrix by row (subject-oriented)
We'll explore these implementations in subsequent pages. For now, understand that the access matrix is a conceptual model, not a direct implementation strategy.
The Lampson Protection Model
Butler Lampson's protection model extends the access matrix with a formal framework for reasoning about authorization changes over time. This model addresses a crucial question: Given the current state of the access matrix, which future states are reachable?
Protection System Components
A protection system is defined by the tuple (S, O, R, C):
- S — Set of possible subjects
- O — Set of possible objects
- R — Set of rights (r, w, x, own, control, ...)
- C — Set of commands (operations that modify the matrix)
State and State Transitions
The protection state at any moment is captured by:
- Current subjects S_current ⊆ S
- Current objects O_current ⊆ O
- Current access matrix A: S_current × O_current → 2^R
Commands trigger state transitions. Each command has:
- Preconditions (which rights must be present)
- Effects (which matrix cells are modified)
12345678910111213141516171819202122232425262728293031323334
// Example commands in Lampson's model command CREATE_FILE(creator: Subject, newFile: Object): precondition: creator ∈ S_current // creator must exist newFile ∉ O_current // file must not already exist effect: O_current := O_current ∪ {newFile} A[creator, newFile] := {read, write, execute, own} command GRANT_READ(owner: Subject, grantee: Subject, file: Object): precondition: own ∈ A[owner, file] // owner must have own right grantee ∈ S_current // grantee must exist effect: A[grantee, file] := A[grantee, file] ∪ {read} command TRANSFER_OWN(owner: Subject, newOwner: Subject, file: Object): precondition: own ∈ A[owner, file] control ∈ A[owner, newOwner] // must have control over new owner effect: A[newOwner, file] := A[newOwner, file] ∪ {own} A[owner, file] := A[owner, file] - {own} command EXECUTE_SETUID(user: Subject, setuidProgram: Object, targetFile: Object): // Model for setuid execution - subject temporarily gains program owner's rights precondition: execute ∈ A[user, setuidProgram] setuid ∈ attributes(setuidProgram) // program has setuid bit effect: let programOwner = owner(setuidProgram) in // Execution context gains programOwner's rights on targetFile A[executionContext, targetFile] := A[programOwner, targetFile]The Safety Question
Lampson's model enables formal reasoning about the Safety Question:
Given initial state Q₀ and set of commands C, is there a sequence of commands that leaks right r to subject s for object o?
A system is safe with respect to right r if there's no way for an unauthorized subject to obtain r through any sequence of valid commands.
Harrison-Ruzzo-Ullman Result
In 1976, Harrison, Ruzzo, and Ullman proved a devastating result about the safety question:
In the general access matrix model, the safety question is undecidable.
This means no algorithm can determine, for all possible protection systems, whether a given right can leak. The proof works by showing that an access matrix system can simulate a Turing machine, making the safety question equivalent to the halting problem.
The undecidability of general safety doesn't mean we must abandon formal analysis. It means we must either: (1) restrict the model to decidable subsets (mono-operational systems), (2) use approximation techniques (type systems, information flow analysis), or (3) verify specific finite configurations rather than general safety. All modern security models adopt one of these strategies.
Mono-Operational Systems
Safety becomes decidable when each command performs at most one primitive operation. In this restricted model:
- Commands like "create an object AND grant read" are forbidden
- Each command does exactly one thing (enter a right, delete a right, etc.)
- Safety can be decided in polynomial time
Most practical discretionary access control systems are not strictly mono-operational, so additional analysis techniques are required.
Take-Grant Model
Developed by Lipton and Snyder in 1977, the Take-Grant model is a restricted access matrix model where safety is decidable. It uses graph-based representations and has efficient algorithms for answering safety questions. We'll explore this in the context of capability systems.
Authorization Model Categories
Authorization models can be categorized based on how they determine access rights and who controls them. The three fundamental categories are:
- Discretionary Access Control (DAC)
- Mandatory Access Control (MAC)
- Role-Based Access Control (RBAC)
Additionally, Attribute-Based Access Control (ABAC) has emerged as a flexible hybrid approach.
Each model answers differently the fundamental question: Who decides what access is permitted?
| Aspect | DAC | MAC | RBAC | ABAC |
|---|---|---|---|---|
| Control Authority | Resource owner | Central policy | Role administrator | Attribute evaluator |
| Policy Location | Per-object metadata | System-wide labels | Role-permission mapping | Policy engine rules |
| Flexibility | High (users decide) | Low (fixed lattice) | Medium (roles evolve) | Very high (any attribute) |
| Administration | Decentralized | Centralized | Hierarchical | Policy-based |
| Security Guarantee | Weak (user error) | Strong (formal proof) | Medium (role design) | Depends on policy |
| Revocation | Immediate (modify object) | Immediate (change label) | Immediate (remove role) | Immediate (update attribute) |
| Common Use | File systems, databases | Military, government | Enterprise IT | Cloud, microservices |
Discretionary Access Control (DAC)
In DAC, the owner of a resource has discretion over who can access it. The owner can grant, revoke, or transfer access rights at will.
Characteristics:
- Users control access to objects they own
- Permissions propagate at the owner's discretion
- No central authority restricts owner decisions
- Trusts users to make appropriate access decisions
Traditional Unix permissions are DAC: the file owner sets read/write/execute for owner, group, and others.
Vulnerability: DAC cannot prevent authorized users from copying information to locations accessible by unauthorized users. A user with read access can copy content elsewhere—DAC provides no confidentiality guarantee against malicious insiders.
Mandatory Access Control (MAC)
In MAC, a central policy authority assigns security labels to subjects and objects. Access decisions are based on comparing labels according to fixed rules that users cannot override.
Characteristics:
- Security labels assigned by administrators
- Users cannot modify labels or grant access beyond their clearance
- Formal security properties can be proven
- Prevents information flow to lower classification levels
The Bell-LaPadula model (confidentiality) and Biba model (integrity) are foundational MAC models. SELinux implements MAC through type enforcement.
Strength: MAC can provide mathematical guarantees that information does not flow to unauthorized entities, regardless of user behavior or programming errors.
Role-Based Access Control (RBAC)
In RBAC, access is determined by roles assigned to subjects, not by individual subject identity. Permissions are associated with roles, and subjects acquire permissions by being assigned to roles.
Characteristics:
- Subjects are assigned roles (developer, admin, auditor)
- Roles are granted permissions (read_code, deploy_prod, view_logs)
- Subjects receive permissions through role membership
- Simplifies administration for large organizations
NIST standardized RBAC with hierarchies (role inheritance), constraints (separation of duty), and session management.
Advantage: RBAC maps naturally to organizational structures. When an employee changes departments, only their role assignments change—not individual permissions across thousands of resources.
Attribute-Based Access Control (ABAC)
ABAC generalizes previous models by making access decisions based on attributes of subjects, objects, actions, and the environment. Policies are expressed as rules over attribute values.
Characteristics:
- Subjects have attributes (department, clearance, location)
- Objects have attributes (classification, type, owner)
- Environment has attributes (time, threat level, network zone)
- Policies are rules: "IF subject.clearance >= object.classification AND time.is_business_hours THEN allow"
ABAC is highly expressive and can simulate DAC, MAC, and RBAC as special cases.
Trade-off: ABAC's flexibility comes with complexity. Policy analysis, debugging failed access, and ensuring policy consistency become harder as attribute sets grow.
Most production systems combine models. A cloud platform might use: RBAC for user management, DAC for user-created resources, MAC (labels) for regulatory compliance, and ABAC for fine-grained API authorization. Understanding each model enables you to compose them appropriately.
Formal Security Properties
Authorization models can be evaluated against formal security properties. These properties give precise meaning to statements like "the system is secure" and enable mathematical proofs.
Simple Security Property (No Read Up)
A system satisfies the simple security property if subjects can only read objects at or below their security level.
Formally: If subject S with clearance level L(S) reads object O with classification L(O), then:
L(S) ≥ L(O) (dominates)
This prevents subjects from reading information classified above their clearance.
Star Property (*-Property, No Write Down)
A system satisfies the *-property if subjects can only write to objects at or above their security level.
Formally: If subject S with clearance level L(S) writes object O with classification L(O), then:
L(O) ≥ L(S) (dominates)
This prevents subjects from copying high-classification data to low-classification containers.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950
// Bell-LaPadula Model: Multilevel Security for Confidentiality // Security levels form a lattice (e.g., TOP_SECRET > SECRET > CONFIDENTIAL > UNCLASSIFIED)enum SecurityLevel { UNCLASSIFIED, CONFIDENTIAL, SECRET, TOP_SECRET } // Each subject has a clearance level// Each object has a classification levelfunction clearance(subject: Subject): SecurityLevel;function classification(object: Object): SecurityLevel; function authorizeBellLaPadula( subject: Subject, operation: Operation, object: Object): Decision { let subjectLevel = clearance(subject); let objectLevel = classification(object); switch (operation) { case READ: // Simple Security Property: No read up // Subject can read object only if subject dominates object if (subjectLevel >= objectLevel) { return ALLOW; } return DENY; case WRITE: // *-Property: No write down // Subject can write object only if object dominates subject if (objectLevel >= subjectLevel) { return ALLOW; } return DENY; case EXECUTE: // Execute typically requires read access if (subjectLevel >= objectLevel) { return ALLOW; } return DENY; }} // Example: Alice (SECRET clearance) tries to:// - Read TOP_SECRET document: DENY (would violate simple security)// - Write UNCLASSIFIED file: DENY (would violate *-property)// - Read CONFIDENTIAL memo: ALLOW (clearance dominates)// - Write SECRET report: ALLOW (classification matches or dominates)Tranquility Properties
The Bell-LaPadula model also defines tranquility:
- Strong Tranquility: Security levels never change (impractical)
- Weak Tranquility: Security levels never change in a way that violates the security properties (practical)
Weak tranquility allows administrative operations while preserving security invariants.
Biba Model: Integrity Properties
While Bell-LaPadula focuses on confidentiality, the Biba model (1977) addresses integrity. It reverses the flow direction:
- Simple Integrity Property: No read down (subjects cannot read lower-integrity objects)
- *Integrity -Property: No write up (subjects cannot write to higher-integrity objects)
This prevents untrusted data from corrupting trusted data.
| Property | Bell-LaPadula (Confidentiality) | Biba (Integrity) |
|---|---|---|
| Focus | Prevent unauthorized disclosure | Prevent unauthorized modification |
| Read Rule | No read up (can't read above clearance) | No read down (can't read below integrity) |
| Write Rule | No write down (can't write below clearance) | No write up (can't write above integrity) |
| Information Flow | High → Low forbidden | Low → High forbidden |
| Threat Model | Malicious reader | Malicious writer |
| Real-World Example | Military classification | Software integrity levels |
Bell-LaPadula and Biba are duals of each other. Confidentiality restricts information flow downward; integrity restricts it upward. Achieving both simultaneously is difficult—a subject at a single level can only read and write at exactly that level, limiting practical utility. Real systems typically prioritize one property or use separate mechanisms for each.
Information Flow Control
Classical access control protects data at rest—who can read or write files. But data doesn't stay static. Once read, it flows through programs, is transformed, combined with other data, and written elsewhere. Information Flow Control (IFC) tracks data as it moves through a system.
The Problem Access Control Misses
Consider this scenario:
- Alice has SECRET clearance and reads a SECRET document
- Alice writes a summary to an UNCLASSIFIED file (allowed by simple DAC if she owns the file)
- The SECRET information now resides in an UNCLASSIFIED container
Traditional access control checked permissions at each step but didn't track the information flow. IFC addresses this by labeling data and following its propagation.
Labels and Lattices
Information flow uses security labels organized in a lattice (a partially ordered set where every pair of elements has a unique least upper bound and greatest lower bound).
Security Lattice for Multilevel Security========================================== Classic Four-Level Military Lattice: TOP_SECRET ↑ SECRET ↑ CONFIDENTIAL ↑ UNCLASSIFIED Information can flow upward: UNCLASSIFIED → CONFIDENTIAL → SECRET → TOP_SECRETInformation CANNOT flow downward. Compartmented Lattice (with categories): (TS, {A, B}) / \ (TS, {A}) (TS, {B}) \ / (TS, {}) | SECRET | CONFIDENTIAL | UNCLASSIFIED Categories (A, B) are disjoint compartments.(TS, {A}) means: Top Secret clearance with access to compartment A.(TS, {A, B}) dominates both (TS, {A}) and (TS, {B}). Join (Least Upper Bound): join((S, {A}), (S, {B})) = (S, {A, B}) Meet (Greatest Lower Bound): meet((S, {A}), (S, {B})) = (S, {})Security Labels in Practice
When data from multiple sources is combined, the resulting data inherits the join (least upper bound) of the input labels. This ensures the result is protected at the level of the most sensitive input.
Example:
- Data A is CONFIDENTIAL
- Data B is SECRET
- Combined data (A + B) becomes SECRET (the join)
This automatic label propagation is called taint tracking in some systems.
Explicit and Implicit Flows
IFC must track both:
-
Explicit Flows — Direct data movement
y = x;copies x's value (and label) to y -
Implicit Flows — Information revealed through control flow
if (secret) { y = 1; }reveals secret's value through y (if y = 1, secret was true)
Tracking implicit flows is harder and can lead to label creep (everything becomes highly classified) if not carefully managed.
Strict non-interference (information never flows to lower levels) is impractical. Real systems need controlled downgrading: declassification (reducing confidentiality label) and endorsement (increasing integrity label). These operations are security-critical and must be carefully controlled—typically limited to trusted code or explicit administrator action.
Decentralized Information Flow Control (DIFC)
Traditional IFC uses a centralized authority to assign labels. Decentralized IFC allows principals to create their own labels and grant declassification rights.
The Flume system (SOSP 2007) and Asbestos (SOSP 2005) implemented DIFC at the OS level. Key concepts:
- Tags — Fine-grained labels created by processes
- Capabilities — Rights to add or remove specific tags
- Sandboxing — Processes limited to communicating through labeled channels
DIFC enables powerful security patterns: a web server can receive a request, spawn a sandboxed worker with a tag for that user's data, and prevent that worker from leaking data to other users' workers.
The Clark-Wilson Model
The Clark-Wilson model (1987) was developed for commercial environments where integrity—not just confidentiality—is paramount. Unlike military models focused on preventing disclosure, Clark-Wilson addresses practical business concerns: preventing fraud, ensuring data accuracy, and maintaining audit trails.
Core Philosophy
Clark-Wilson recognizes that in commercial systems:
- Well-formed transactions are as important as access restrictions
- Users shouldn't directly manipulate data; they invoke validated procedures
- Separation of duties prevents single individuals from committing fraud
- All actions must be auditable
Key Concepts
- Constrained Data Items (CDIs) — Data requiring integrity protection (account balances, inventory)
- Unconstrained Data Items (UDIs) — Data without integrity requirements (user input before validation)
- Transformation Procedures (TPs) — Certified programs that transform CDIs while preserving integrity
- Integrity Verification Procedures (IVPs) — Programs that verify CDIs satisfy integrity constraints
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// Clark-Wilson Model Applied to Banking // CDIs (Constrained Data Items) - require integrity protectiontype AccountBalance = CDI<Decimal>;type TransactionLog = CDI<LogEntry[]>; // UDIs (Unconstrained Data Items) - untrusted inputtype DepositRequest = UDI<{ accountId: string, amount: number }>; // IVP (Integrity Verification Procedure)// Verifies that the sum of all account balances equals total assetsfunction verifyBalanceIntegrity(): boolean { let totalInAccounts = sum(allAccounts.map(a => a.balance)); let totalAssets = ledger.totalAssets; return totalInAccounts === totalAssets;} // TP (Transformation Procedure) - certified to maintain integrity@TransformationProcedure@RequiresRole("teller")@SeparationOfDuty("authorizer", "executor") // Different person must authorizefunction processDeposit( request: DepositRequest, // UDI input account: AccountBalance, // CDI to modify log: TransactionLog // CDI for audit): Result<void> { // 1. Validate UDI input if (request.amount <= 0 || request.amount > MAX_DEPOSIT) { log.append({ type: "REJECTED", reason: "invalid amount", ... }); return Err("Invalid deposit amount"); } // 2. Transform CDI let newBalance = account.value + request.amount; // 3. Maintain invariants assert(newBalance >= account.value); // No overflow // 4. Update CDI atomically atomic { account.value = newBalance; log.append({ type: "DEPOSIT", amount: request.amount, ... }); } // 5. Post-condition assert(verifyBalanceIntegrity()); return Ok(());} // Certification Rules:// CR1: IVP must verify all CDIs in consistent state// CR2: TP must transform CDIs from valid state to valid state// CR3: Users can only execute TPs through well-defined interfaces// CR4: User access is certified: (User, TP, {CDIs}) triples// CR5: TPs reject UDIs that would cause invalid CDI statesCertification and Enforcement Rules
Clark-Wilson defines two types of rules:
Certification Rules (CR) — Requirements for certifiers (auditors/administrators)
- CR1: IVPs must ensure all CDIs are in a valid state when installed
- CR2: TPs must be certified to transform CDIs from valid to valid states
- CR3: Access triples (user, TP, CDIs) must be certified
- CR4: TPs must ensure all UDIs are properly validated before updating CDIs
- CR5: TPs must maintain well-formed transaction properties
Enforcement Rules (ER) — Requirements for the system to enforce
- ER1: System must maintain certified access triples
- ER2: System must ensure users can only invoke TPs they're authorized for
- ER3: System must authenticate users before allowing TP execution
- ER4: Only authorized certifiers can modify access triples
While not always explicitly named, Clark-Wilson principles appear throughout modern system design: stored procedures in databases (TPs acting on CDIs), input validation layers, internal vs. external data segregation, and mandatory code review for changes to sensitive procedures. The model provides a vocabulary for reasoning about commercial integrity requirements.
Separation of Duties
A key Clark-Wilson contribution is formalizing separation of duties — no single person should have enough authority to complete a sensitive transaction alone. This prevents fraud through:
- Static separation: Mutually exclusive role assignment (auditor cannot also be accountant)
- Dynamic separation: Transaction requires multiple approvals (payment requires submitter and approver)
- Operational separation: Different people for different phases (developer cannot deploy their own code)
Modern RBAC systems implement these constraints through mutual exclusion rules on role assignments.
KEEP LEARNING
Keep learning for free.
Read the complete lesson, save your notes and pick up where you left off with a free account. No card needed.