Access Control List vs Capability List

Published
Length
3 min read

Luis Felipe Dias

All posts

The access control list vs capability list debate centers on where security rules live. Teams use access control lists on shared files and capability lists for fast apps. Both models come from a classic security grid. This grid maps subjects like users against objects like files or databases. One model slices the grid by column, while the other slices by row. Understanding this split helps you design safer systems for your engineering team. How the access control list vs capability list model

Your coding agents run with your access.

Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.

The access control list vs capability list debate centers on where security rules live. Teams use access control lists on shared files and capability lists for fast apps.

Both models come from a classic security grid. This grid maps subjects like users against objects like files or databases. One model slices the grid by column, while the other slices by row. Understanding this split helps you design safer systems for your engineering team.

How the access control list vs capability list models work

An access control list attaches rules right to the target object. When a user asks to read a file, the system checks that file's list. The list names each user or role and states what they can do. File systems and cloud storage buckets use this model every day. It works well when admins manage permissions from one central spot.

A capability list flips this layout around and attaches rules to the user. Each user or app holds a set of unforgeable tokens called capabilities. Each token names one object and grants specific rights like read or write. When the app wants to read a file, it presents the matching token. The system checks the token validity instead of looking up a user identity. Microservices and container tools often use this pattern for fast checks.

Auditing and revocation tradeoffs in both models

Auditing resources is very simple when you use an access control list. You can inspect one database table and see every user who can read it. Revoking a user from that one table is also fast and direct. You just remove their name from the list on that object. Still, finding everything one user can touch requires scanning every object in your system.

Capability lists make it easy to see what one user can do. You just inspect the tokens held by that user or app process. Passing a narrow permission to a helper process is also very safe. The main tradeoff comes when you need to revoke permissions right away. You must track down active tokens or wait for short tokens to expire. Knowing everyone who can reach a specific file is also harder here.

K8s RBAC Role vs ClusterRole: architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

Why static permissions need runtime session controls

Both models share a big blind spot in daily production work. Once a user passes the check, the static rule steps out of the way. An engineer with read rights on a database can run any read query. Static lists cannot inspect the actual commands or queries inside an active session. They also cannot rewrite sensitive fields like emails, phone numbers, or card numbers.

The confused deputy problem is another risk for teams using static identity lists. A trusted app might get tricked into misusing its broad rights for a caller. Capability tokens reduce this risk by tying actions to narrow, task-specific keys. Still, human engineers need safe ways to run live commands on production systems. Pairing static roles with command checks and data masking closes this gap.

Check database and API queries on the wire

Identity tools, roles, and network rules decide who opens a session. Setup alone cannot check what each query does or mask sensitive values in a response once a session starts. When workflows touch Postgres, MySQL, SQL Server, MongoDB, ClickHouse, Kubernetes APIs, SSH, or internal HTTP APIs, hoop.dev sits inline in the wire protocol beside those services as an open-source proxy, a sidecar for your Postgres or API. On every query an AI agent or engineer runs against production, hoop.dev decides to pass, mask, block, or hold it for human review.

Your login details and client tools stay as they are while hoop.dev guardrails refuse bad deletes or drops before they run, and hoop.dev data masking rewrites matched sensitive values in responses in memory. Furthermore, hoop.dev holds SOC 2 Type II, is MIT licensed, and writes every query and decision to an audit trail that generates evidence for HIPAA, GDPR, and PCI DSS. See the source on GitHub.

Frequently asked questions

What is the main difference between an ACL and a capability?

An ACL lives on the resource and lists which users can use it. A capability lives with the user and acts like a key to one resource.

Which model prevents the confused deputy problem?

Capability lists prevent this problem because the caller passes a specific token for the task. The service uses that narrow token instead of its own broad permissions.

Can a system use both access control lists and capabilities?

Yes, many modern cloud platforms mix both models to get the best results. A system can check an ACL at login and then issue a short capability token.

The query runs. The emails stay hidden.