Not Using Complete Mediation

Draft Class

Structure: Simple

Description

This vulnerability occurs when software fails to verify access permissions every single time a user or process tries to use a resource. Instead, it might rely on a single, outdated check, creating a security gap if the user's privileges are later revoked or changed.

Extended Description

Complete mediation is the security principle that every access to every object must be checked for authorization. Developers often break this rule by caching an initial permission check—like when a user first opens a file or page—and then assuming that permission remains valid for the entire session. This creates a time-of-check to time-of-use (TOCTOU) window where a user's reduced privileges are not enforced, allowing continued access they should no longer have. To prevent this, implement a consistent authorization layer that validates permissions on each individual request, regardless of previous checks. Treat all access as stateless and never assume a prior grant is still valid. This is especially critical in long-running sessions, multi-step transactions, or systems with dynamic user roles, where privilege changes must be reflected immediately to close security loopholes.

Common Consequences 1

Scope: IntegrityConfidentialityAvailabilityAccess ControlOther

Impact: Gain Privileges or Assume IdentityExecute Unauthorized Code or CommandsBypass Protection MechanismRead Application DataOther

A user might retain access to a critical resource even after privileges have been revoked, possibly allowing access to privileged functionality or sensitive information, depending on the role of the resource.

Potential Mitigations 2

Phase: Architecture and Design

Invalidate cached privileges, file handles or descriptors, or other access credentials whenever identities, processes, policies, roles, capabilities or permissions change. Perform complete authentication checks before accepting, caching and reusing data, dynamic content and code (scripts). Avoid caching access control decisions as much as possible.

Phase: Architecture and Design

Identify all possible code paths that might access sensitive resources. If possible, create and use a single interface that performs the access checks, and develop code standards that require use of this interface.

Demonstrative Examples 2

ID : DX-166

When executable library files are used on web servers, which is common in PHP applications, the developer might perform an access check in any user-facing executable, and omit the access check from the library file itself. By directly requesting the library file (Direct Request ('Forced Browsing')), an attacker can bypass this access check.

When a developer begins to implement input validation for a web application, often the validation is performed in each area of the code that uses externally-controlled input. In complex applications with many inputs, the developer often misses a parameter here or a cookie there. One frequently-applied solution is to centralize all input validation, store these validated inputs in a separate data structure, and require that all access of those inputs must be through that data structure. An alternate approach would be to use an external input validation framework such as Struts, which performs the validation before the inputs are ever processed by the code.

Observed Examples 1

CVE-2007-0408Server does not properly validate client certificates when reusing cached connections.

References 2

The Protection of Information in Computer Systems

Jerome H. Saltzer and Michael D. Schroeder

Proceedings of the IEEE 63

09-1975

http://web.mit.edu/Saltzer/www/publications/protection/

ID: REF-196

Complete Mediation

Sean Barnum and Michael Gegick

12-09-2005