# Access control matrix
A conceptual model in computer security that defines access rights. It's a table where rows represent subjects (like users or processes) and columns represent objects (like files or devices). Each cell specifies the access rights a subject has for a particular object, such as read, write, or execute.
**Pronunciation:** AK-sess kun-TROHL MAY-triks
**Difficulty:** Intermediate
**Synonyms:** Access matrix, Authorization matrix
**Categories:** Computer Security, Operating Systems
**Tags:** security, access control, authorization, computer science, operating systems
Canonical: https://scaleengineer.com/glossaries/access-control-matrix
---
## Definitions

- **Core Concept in Computer Security:** An **access control matrix**, often shortened to **access matrix**, is a fundamental model used in computer security to describe and enforce access control policies. It is represented as a two-dimensional table.

***

**Components:**

*   **Rows (Subjects):** Represent active entities that request access. These can be individual users, groups of users, processes, or other active system components.
*   **Columns (Objects):** Represent passive resources that need protection. Examples include files, directories, memory segments, printers, or database tables.
*   **Cells (Access Rights):** The intersection of a subject row and an object column contains a set of permissions (or rights) that the subject has for that specific object. Common rights include `read`, `write`, `execute`, `own`, and `delete`.

***

**Example:**

Consider a simple system with two users (Alice, Bob) and two files (File1, File2). The **access control matrix** might look like this:

```
        | File1        | File2
--------|--------------|----------------
Alice   | read, write  | read
Bob     | read         | - (no access)
```

In this example, Alice can read and write to File1 but only read File2. Bob can only read File1 and has no access to File2.

***

**Implementation:**

While the **authorization matrix** is a powerful theoretical model, its direct implementation is often inefficient. For a system with thousands of users and millions of files, the matrix would be enormous and mostly empty (sparse). Therefore, systems typically implement its logic in two primary ways:

*   **Access Control Lists (ACLs):** Each object (column) has a list of subjects and their corresponding permissions. This is like storing the matrix column by column. It's efficient for answering "Who can access this file?".
*   **Capabilities:** Each subject (row) has a list of objects and the permissions they hold for them. This is like storing the matrix row by row. It's efficient for answering "What files can this user access?".

## Etymology

The term is descriptive. 'Access control' refers to the function of managing who can access what. 'Matrix' describes its structure—a two-dimensional table or grid.

## First used

1971

## Historical context

The concept of an **access control matrix** was formally introduced by Butler Lampson in his seminal 1971 paper, "Protection." This paper laid the foundational principles for computer security mechanisms in multi-user systems.

Lampson's work was a response to the growing need for robust security in time-sharing operating systems like Multics, which emerged in the 1960s. These systems allowed multiple users to access a single computer simultaneously, making it crucial to isolate users and protect their data from one another.

The **access matrix** provided a clear, abstract model for specifying and analyzing protection policies. While the theoretical model is a simple table, its direct implementation is often impractical for systems with many users and objects because the matrix would be very large and mostly empty (sparse).

This impracticality led to the development of more efficient implementations derived from the matrix concept, such as Access Control Lists (ACLs) and Capabilities. ACLs store the permissions for an object (a column from the matrix), while Capabilities store the permissions for a subject (a row from the matrix). These alternative implementations are still conceptually based on the original **authorization matrix** model.

## Q&A

- **What are the three main components of an access control matrix?:** The three main components are:

*   **Subjects**: The active entities that request access to resources. These are typically users, groups, or processes. They form the rows of the matrix.
*   **Objects**: The passive entities that contain information or provide functionality. These are the resources being protected, such as files, directories, printers, or memory segments. They form the columns of the matrix.
*   **Access Rights**: The specific permissions or operations that a subject can perform on an object. Examples include read, write, execute, and own. These are placed in the cells where a subject's row and an object's column intersect.

## Usage examples

- The system administrator configured the **access control matrix** to grant the 'editors' group write permissions to the 'articles' directory.
- In our security model, the **access matrix** is too sparse to be implemented directly, so we use access control lists instead.
- To determine if a process can execute a specific file, the operating system kernel consults the **authorization matrix**.

## Related terms

- Access Control List (ACL)
- Capability-based security
- Role-Based Access Control (RBAC)
- Principle of least privilege
- Authorization

## Popular related terms

- Access Control List (ACL)
- Role-Based Access Control (RBAC)
- Authorization