Access control is the selective restriction of access to resources. In computing, it determines whether a user, program, device, or service may perform a particular operation on data or another system component. In physical security, it governs entry to buildings, rooms, equipment, and other protected spaces. Its central task is to translate rules about legitimate use into decisions that an enforcement mechanism can apply.
Access control is a foundation of information security because identifying a requester does not establish what that requester should be allowed to do. Authentication establishes or verifies an identity or another relevant claim; authorization determines permitted actions. Access control implements and enforces those permissions, often with supporting identity management, logging, and administrative processes. An authenticated employee, for example, may be permitted to read a project document but not change its ownership or disclose it outside the organization.
Access-control systems range from file permissions and door locks to organization-wide policies evaluated across distributed services. Their design involves several distinct questions: how permissions are represented, who may grant them, where decisions are enforced, how delegation and revocation work, and how the system behaves when information or infrastructure is unavailable. No single model resolves all these questions, and practical systems commonly combine several approaches.
Foundations and historical development
A basic access-control decision concerns a subject, an object, and an operation. A subject is an active entity, such as a running process acting for a user. An object is a protected resource, such as a file, database row, network service, or door. An operation is an action such as reading, writing, executing, administering, or entering. A principal is an entity to which authority can be attributed; it may be a person, service account, device, or organization. The principal and subject are related but not identical: several processes can act for one principal, and a service may act under delegated authority.
A simple mathematical representation is the access-control matrix. If is the set of subjects, the set of objects, and the set of rights, then an authorization state can be represented as
The entry contains the rights that subject has over object . Permission to read might therefore be expressed as . The matrix is a conceptual model rather than a requirement to store a large rectangular table. Real implementations usually exploit sparse representations, groups, roles, labels, or rules.
Time-sharing systems made access control a central computing concern during the 1960s and 1970s. Multiple users shared expensive processors and storage, making isolation and controlled sharing essential. Multics developed influential mechanisms for protection domains, segmented memory, and hierarchical protection rings. Butler Lampson’s 1971 paper “Protection” presented a systematic account of protection using subjects, objects, and an access matrix. These developments helped separate the representation of authority from the machinery that enforces it.
James Anderson’s 1972 computer-security study articulated the reference monitor concept: an abstract mechanism through which relevant accesses must pass. Its classic requirements are resistance to tampering, complete mediation of access, and sufficient simplicity to permit analysis and testing. Jerome Saltzer and Michael Schroeder’s 1975 account of protection principles further emphasized least privilege, fail-safe defaults, complete mediation, separation of privilege, and economy of mechanism. These principles remain influential even when an implementation is too large to satisfy the reference-monitor ideal directly.
An access-control policy is meaningful only relative to a threat model and a trusted computing base—the hardware, software, and administrative components relied upon to enforce it. File permissions cannot protect data from an administrator who can replace the operating-system kernel unless additional mechanisms constrain that administrator. Similarly, application permissions do not provide confidentiality against someone who can read unencrypted database storage directly. The relevant protection boundary determines which forms of access the system can actually control.
Discretionary permissions, access lists, and capabilities
Discretionary access control allows designated principals, often resource owners, to decide who else may access their resources. A document owner might grant a colleague read access or permit a group to edit a directory. The approach supports flexible collaboration, but authority can spread through delegation and copying. Permission to read information ordinarily allows a user to reproduce it elsewhere unless another mechanism restricts the resulting information flow.
An access-control list, or ACL, records permissions associated with an object. Conceptually, it represents one column of the access-control matrix. An entry may name a user or group and specify allowed operations; some systems also support explicit denials, inheritance, conditional entries, and ordering rules. These details are not interchangeable across implementations. A denial may take precedence over an allowance in one system, while another evaluates entries in a defined sequence. Correct interpretation therefore depends on the actual evaluation rules, not simply on the presence of an “allow” entry.
Traditional Unix file permissions are a compact discretionary mechanism. They distinguish the file owner, a group, and other users, with read, write, and execute bits for each class. The familiar nine permission bits yield possible basic combinations, apart from additional mode bits. Directory permissions have distinct semantics: execute generally permits searching or traversing the directory, while write permits changes to directory entries when the other required conditions hold. Deleting a file is therefore principally governed by permissions on its containing directory, with further restrictions possible through mechanisms such as the sticky bit.
Capability-based security represents authority through possession of an unforgeable reference that identifies an object and permitted operations. Conceptually, capabilities resemble entries distributed by subject rather than lists stored with objects. A process may receive authority by being passed a capability, and it may delegate a restricted form if the system supports attenuation. An open file descriptor can provide capability-like authority to an already opened file, although an operating system containing file descriptors is not necessarily a pure capability system.
Capability designs make the transfer of authority explicit and can reduce dependence on global names or ambient privileges. Their security depends on preventing forgery and controlling how references are obtained or transferred. Revocation requires deliberate design: possible mechanisms include indirection, revocable proxy objects, generations, and expiration. In ACL-based systems, removing a list entry can be straightforward, but existing handles, cached decisions, or copied data may remain usable. Neither representation automatically solves revocation in every setting.
Discretionary control is also distinct from the particular data structure used to enforce it. An ACL can encode centrally imposed, nondiscretionary rules, and a capability system can restrict delegation through system policy. The important questions are who has authority to change permissions and what limits apply to that authority, rather than whether a product describes itself using one implementation label.
Mandatory policies and information flow
Mandatory access control imposes rules that ordinary users and resource owners cannot freely override. Decisions commonly depend on security labels assigned to subjects and objects. This is useful where the organization must preserve classification, integrity, or isolation requirements despite the preferences of an individual owner. Mandatory and discretionary mechanisms can coexist: an operation may need to satisfy both a system-wide label policy and an object’s ordinary permissions.
The Bell–LaPadula model, developed in the 1970s, formalized confidentiality rules for systems handling security classifications. Labels can include both hierarchical levels and nonhierarchical categories. A label dominates when its level is at least as high and its category set contains the other’s categories. For example, access to information marked “Secret, Project A” requires more than a sufficient classification level; the relevant category must also be present. Because category sets need not contain one another, labels form a partial order rather than a single ladder.
In a simplified presentation, Bell–LaPadula’s simple-security property prevents “reading up,” while its star property prevents “writing down.” These restrictions are intended to stop information from moving from a more restricted classification to a less restricted one through ordinary subject activity. Formal variants distinguish maximum clearance from a subject’s current operating level and may include trusted subjects or additional conditions. The slogans are useful mnemonics, but they are not substitutes for the precise model.
Integrity policies address a different objective. Kenneth Biba’s 1977 work explored models intended to prevent lower-integrity information from contaminating higher-integrity information. A commonly presented strict form uses “no read down” and “no write up,” reversing the direction of the confidentiality restrictions. The Clark–Wilson model, introduced in 1987, instead emphasizes well-formed transactions, constrained data items, certified transformation procedures, and separation of duties. Its treatment of commercial data integrity is closer to controlled business workflows than to a classification hierarchy.
Information-flow security extends the inquiry beyond whether a particular read or write was authorized. It asks whether changes in secret inputs can influence observations available to a less privileged observer. Noninterference formalizes versions of this requirement. Traditional access checks alone cannot ensure it: a permitted reader may disclose a secret through another output, and a program may reveal information through timing or resource consumption. Covert channels exploit communication paths that were not intended to carry the protected information.
Legitimate systems also need controlled exceptions. Declassification permits specified information to leave a confidentiality boundary, while endorsement allows information to be treated as sufficiently trustworthy under defined conditions. These operations require rules about who can perform them and why. A report containing approved aggregate statistics, for example, may be released even though its underlying records remain restricted; merely granting unrestricted read access to the raw records would implement a different policy.
Roles, attributes, and relationships
Role-based access control (RBAC) assigns permissions to organizational roles and assigns users to those roles. Instead of granting every payroll employee a separate collection of permissions, an organization can associate the necessary operations with a payroll role. A session may activate only some of a user’s assigned roles, limiting the authority exercised for a particular task. David Ferraiolo and Richard Kuhn presented an influential RBAC model in 1992; a family of models published by Ravi Sandhu and colleagues in 1996 helped clarify core RBAC, role hierarchies, and constraints.
Role hierarchies allow one role to inherit permissions from another according to a defined seniority relation. Constraints express restrictions that simple group membership cannot capture. Static separation of duties can prohibit assigning one person two conflicting roles, such as payment preparation and payment approval. Dynamic separation of duties can allow both assignments while preventing their simultaneous activation or use within a particular transaction. The intended business rule matters: preventing one user from approving the payment they created is more specific than merely separating two role names.
RBAC reduces repeated administration when duties are stable and shared, but it can suffer from role explosion. If permissions vary independently by department, region, project, data classification, and employment status, administrators may create many narrowly differentiated roles. A role called “analyst” can also accumulate unrelated permissions over time. Roles do not automatically implement least privilege; their contents, assignment rules, inheritance, and lifecycle determine the resulting authority.
Attribute-based access control (ABAC) evaluates attributes of the subject, resource, requested action, and environment. A rule might allow editing if the requester is an active employee, the document belongs to the requester’s project, the device meets a security requirement, and the document is not under a preservation restriction. In abstract form, the result can be written as
where is the policy, and are subject and object attributes, is the action, and represents environmental attributes. Decisions may include permit, deny, not applicable, or indeterminate, depending on the policy language. Missing attributes and conflicting rules require explicit handling.
Relationship-based access control expresses permissions through relationships among users, groups, and resources. A user may be an editor of a folder, and a document may belong to that folder; a policy can derive editing authority from those relationships. This is useful for collaboration systems with nested groups, ownership, sharing, and parent–child resources. Google’s 2019 Zanzibar paper described a large-scale authorization system using relationship-oriented access-control data and consistency mechanisms, contributing to wider adoption of this style.
These models are often combined. A role can itself be a subject attribute, while a relationship can establish project membership and a mandatory label can impose a final restriction. Policy evaluation must specify how such components interact. A simple union of all permissions may accidentally bypass a restriction intended to apply universally; conversely, requiring every independent component to permit an operation can deny legitimate requests when some components are not applicable.
Enforcement in operating systems, databases, and applications
Policy enforcement must occur at a point that controls the protected operation. In an operating system, the kernel mediates operations such as opening files, creating processes, changing credentials, and accessing devices. Hardware privilege levels and memory-protection mechanisms help prevent ordinary programs from modifying the enforcement code or accessing another process’s memory directly. A check in a user-interface component is not equivalent: another program may invoke the underlying operation without using that interface.
Opening a file illustrates the distinction between authorization at acquisition and authority during use. The kernel commonly checks permissions when resolving a path and opening the file, then returns a handle. Later reads and writes use that handle under the operating system’s rules rather than necessarily repeating the original pathname permission check. Changing the file’s permissions therefore does not always invalidate existing handles. Path resolution also introduces complications involving symbolic links, mount points, directory permissions, and concurrent changes.
Linux combines traditional Unix permissions with additional mechanisms, including POSIX-style ACLs, privilege capabilities, and security modules. Linux capabilities divide some traditionally all-powerful superuser privileges into separately representable units; they are distinct from the general object-capability model. Security modules support controls such as SELinux’s label-based policies and AppArmor’s profile-based restrictions. Microsoft Windows uses access tokens and security descriptors to represent security information and evaluate access to securable objects, with discretionary and system ACLs serving different purposes.
A database management system can enforce permissions on databases, schemas, tables, views, procedures, columns, and, in some products, individual rows. SQL commonly provides GRANT and REVOKE, although privilege inheritance and revocation behavior vary. Views can expose selected columns or filtered records, while row-level security can impose predicates based on the executing principal or session context. Execution under an object owner’s authority can support carefully restricted procedures, but incorrect ownership, search-path handling, or dynamic SQL can turn such procedures into privilege-escalation paths.
Applications must additionally enforce business-level rules that lower layers do not understand. A database may permit a service account to read every invoice, while the application must restrict each customer to invoices belonging to that customer. Authorization therefore needs to bind the authenticated requester, requested action, and actual target object. Checking that an identifier is syntactically valid or that the requester can reach an endpoint does not establish permission to access the identified record.
A common implementation separates a policy enforcement point from a policy decision point. The former intercepts and applies decisions; the latter evaluates policy using relevant information. Policy administration and attribute-information services may be separate as well. This separation can improve consistency across applications, but the enforcement point must handle errors, obligations, and bypass paths correctly. A centralized decision service provides little protection if an unprotected alternate endpoint can perform the same operation.
Distributed authorization, delegation, and revocation
In distributed computing, the requester, identity provider, policy service, and protected resource may run in different administrative or network environments. Services must establish not only who originally initiated a request but also which intermediaries are acting, what authority they possess, and whether that authority is appropriate for the destination. Transport Layer Security can protect a connection and authenticate its endpoints, but it does not by itself determine whether a particular business operation is authorized.
OAuth 2.0, standardized in 2012, provides a framework for delegated access using access tokens. A client can obtain a token representing limited authority to a resource server without receiving the resource owner’s password. Scopes express categories of permitted access, but their meanings are defined by the relevant service. A scope such as documents.read does not necessarily answer which individual documents may be read. OAuth is not itself an end-user authentication protocol; OpenID Connect adds an identity layer with separate purposes and validation rules.
Bearer tokens confer authority to whoever possesses them. Their protection therefore includes secure transport, limited exposure, suitable lifetimes, and correct validation by the resource server. A signed token is not automatically an appropriate token for every recipient: issuer, audience, expiration, and other applicable conditions must be checked. Sender-constrained mechanisms bind token use to proof of possession of a key, reducing some consequences of token theft. Digital signatures establish authenticity and integrity under stated assumptions, not the appropriateness of the permissions encoded.
Delegation raises the confused deputy problem, described by Norman Hardy in 1988. A deputy is a program with authority of its own that can be induced to exercise that authority incorrectly on someone else’s behalf. For example, a service permitted to read internal storage may accept a requester-supplied reference without establishing whether the requester is entitled to the referenced object. Preserving the distinction between the caller’s authority and the service’s operational privileges is essential, especially across chains of microservices.
Revocation is difficult when authorization state is replicated or embedded in credentials. Removing a group membership at a central server does not instantly change an already issued self-contained token or an authorization result cached elsewhere. Short expiration periods bound some delays but increase renewal traffic and do not guarantee immediate invalidation. Alternatives include token introspection, revocation lists, versioned authorization state, event-driven cache invalidation, and online checks for particularly sensitive actions. Each introduces availability, latency, or operational costs.
Zero-trust architecture treats network location alone as insufficient grounds for trust and emphasizes explicit, policy-based access decisions. In cloud computing, this often involves workload identities, resource policies, organizational restrictions, and contextual signals. It does not require asking a human to authenticate for every low-level operation. The architectural issue is whether trust is appropriately scoped, verified, and maintained as circumstances change, including when services are compromised or policy infrastructure becomes unavailable.
Failure modes, testing, and formal assurance
Broken access control occurs when an implementation permits actions outside the intended policy. One common form is object-level authorization failure: changing a record identifier in a request exposes another user’s data because the server checks login status but not entitlement to that record. Function-level failures allow unauthorized operations, such as invoking an administrative endpoint. Property-level failures permit reading or updating individual fields that should be restricted, even when access to the surrounding object is legitimate.
Client-side restrictions are especially weak enforcement boundaries. Hiding a button, disabling a form field, or omitting a link may improve usability, but a requester can often send the corresponding API request directly. The server must authorize the operation independently. Similarly, opaque identifiers can make guessing harder but do not establish access rights. Unpredictability is not a substitute for checking whether the requester may act on the selected object.
Concurrency can create authorization errors even when a check appears correct in isolation. A time-of-check-to-time-of-use race occurs when a relevant fact changes between validation and execution. A program may check a pathname and subsequently open a different object after an attacker changes a symbolic link. Business workflows can have analogous races: two concurrent requests may both observe that an approval or spending limit is available. Secure handling may require atomic operations, stable object handles, locking, or appropriate database transaction isolation.
Policy composition creates another class of failures. Group nesting, inherited permissions, default roles, ownership rules, and emergency exceptions can interact in unexpected ways. A newly introduced explicit denial may not have the assumed precedence, or a broad resource policy may expose data despite a restrictive user policy. Authorization caches can compound the problem when their keys omit relevant context, such as tenant identity or policy version. Testing only whether authorized requests succeed misses these negative cases.
Formal verification can establish properties of a model or implementation under explicit assumptions. The Harrison–Ruzzo–Ullman result, published in 1976, showed that the general safety problem for a sufficiently expressive access-control model is undecidable: no algorithm can determine in all cases whether a specified right can eventually leak to an unauthorized subject. This does not make every practical authorization question undecidable. Restricted models, bounded analyses, policy languages with limited expressiveness, and application-specific invariants can support useful automated reasoning.
Practical assurance combines policy review, unit and integration tests, cross-user and cross-tenant tests, penetration testing, and monitoring. A test matrix can enumerate subjects, objects, actions, and relevant states, including missing attributes, expired credentials, revoked memberships, and unavailable dependencies. Audit records are more useful when they capture the effective principal, target, requested action, outcome, and policy context. Such logs themselves require protection because they can reveal sensitive activity and may be targets for alteration.
Administrative lifecycle, least privilege, and accountability
An access-control system includes the processes that create and change authority, not just the runtime decision engine. Identity provisioning, group assignment, role design, service-account creation, and resource ownership establish the authorization state on which decisions depend. Joiner–mover–leaver processes address the creation of access when someone arrives, its revision when duties change, and its removal when the relationship ends. Changes of responsibility are particularly important because granting new access without removing obsolete access produces privilege accumulation.
The principle of least privilege calls for granting only the authority needed for the relevant task and duration. It applies to applications and services as well as people. A reporting service that only reads approved views does not ordinarily need permission to alter database schemas. Least privilege is not equivalent to assigning the fewest possible permission names: a single broad administrative privilege can confer much more authority than many narrowly defined rights. The relevant measure is what actions the principal can actually cause.
Privileged access management adds controls around highly consequential authority. Examples include separate administrative identities, temporary elevation, approval workflows, credential rotation, and recording of privileged sessions. Just-in-time access limits how long elevated authority exists, while task-specific privileges limit its scope. Emergency or “break-glass” access may bypass ordinary approval when availability is critical, but it requires explicit conditions and accountable handling. An emergency path that is routinely used becomes part of the normal privilege structure.
Separation of duties reduces dependence on any one actor by distributing sensitive steps. A purchasing workflow may distinguish requesting, approving, receiving, and paying. Technical enforcement must connect these distinctions to the actual transaction and identities rather than merely to job titles. Two accounts controlled by the same person do not necessarily provide meaningful independence. Likewise, requiring two approvals is ineffective if one approver can silently modify the transaction after the other has approved it.
Access reviews examine whether existing rights remain justified. Effective review requires understandable descriptions of resources and permissions, ownership information, and evidence of the relationships that produced access. A reviewer shown only opaque group identifiers may be unable to assess the resulting authority. Usage records can reveal dormant entitlements, but absence of recent use does not by itself establish that access is unnecessary; infrequent emergency and periodic business tasks create legitimate exceptions.
Accountability depends on attribution and protection of records. Shared accounts can obscure which person acted, while delegated service calls can lose the original requester’s identity unless it is propagated securely. Multifactor authentication can strengthen confidence in an administrative login, but it does not correct an overbroad authorization policy. Privacy also affects audit design: collecting every available detail may expose personal or confidential information, so access to logs, retention periods, and the purposes of monitoring form part of the control system.
Physical access control and cyber-physical integration
Physical access control governs movement into protected places and use of tangible assets. Mechanisms range from keys and staffed reception points to electronic credentials, turnstiles, vehicle barriers, and interlocking doors. The same subject–object–action structure applies: a named employee may enter a laboratory during specified hours but not open an equipment cabinet. Physical systems nevertheless face constraints that differ from software, including human safety, movement through shared spaces, and the difficulty of determining who actually crossed a threshold.
Electronic systems commonly combine a credential, reader, controller, locking mechanism, and management service. The reader obtains credential information; the controller determines whether access is permitted and operates the lock. Some controllers retain local authorization data so that doors continue functioning during a network outage. This improves resilience but creates a revocation problem: a recently cancelled credential may remain accepted until updates reach the controller. The appropriate failure behavior depends on the door’s purpose and the surrounding safety requirements.
A credential may be something possessed, such as a card or mobile device; something known, such as a personal identification number; or a biometric characteristic. Biometric matching produces probabilistic results rather than an infallible identity determination, with false matches and false nonmatches affected by thresholds and operating conditions. A credential presentation also does not guarantee that exactly one authorized person entered. Tailgating allows another person to follow through an opened door, while credential sharing separates the recorded identity from the actual entrant.
Anti-passback rules attempt to detect or prevent implausible credential sequences, such as repeated entry without an intervening exit. Their effectiveness depends on reliable observation of movement and appropriate handling of exceptions. Interlocking entrance spaces can restrict passage through successive doors, but they require careful integration with accessibility and emergency egress. “Fail-safe” and “fail-secure” describe lock behavior under specified failure conditions; they do not independently determine whether an overall installation satisfies life-safety requirements. Exit behavior may be governed separately from entry control.
Network-connected controllers, readers, and management software introduce cybersecurity dependencies. A compromised administrative workstation may change door permissions, while an insecure communication link may permit replay or manipulation of credential data. Physical access can in turn undermine digital protections by exposing server consoles, storage devices, maintenance ports, or network equipment. Consequently, the boundary between physical and logical authorization is often organizational rather than technical.
Integration can connect building credentials with personnel records, visitor management, equipment access, and logical accounts. It can also create excessive dependence on one identity service or administrative role. A person entitled to enter a data center is not necessarily entitled to read the information stored there, and a remote system administrator does not automatically require physical entry. Keeping these authorities distinct allows policies to reflect different responsibilities while still correlating records when an authorized investigation requires it.