Skip to content

Archive

Access Control

55 articles
Cybersecurity 21 Sep 2026 6 min read

SSH Certificates Shift Access Trust to a Signing Authority

SSH Certificates Shift Access Trust to a Signing Authority Public-key SSH access often starts with a simple mapping: place a user’s public key in authorized_keys, keep the private key with the user, and let the server accept possession of the matching private key. The model is direct and effective, but its administrative cost rises as people and hosts multiply. Every host can become another place where access state must be added, audited, and removed.

Cybersecurity 21 Sep 2026 6 min read

SSH Certificates Bind Identity to Principals and Constraints

SSH Certificates Bind Identity to Principals and Constraints A raw SSH public key answers a narrow question: does the connecting client possess the private key corresponding to this public key? Authorization still needs another mapping. A server commonly places accepted keys in authorized_keys, often with options that restrict what a particular key may do. OpenSSH certificates add a signed identity layer around a public key. A certificate can carry principals, a validity interval, critical options, extensions, a serial number, and a key identifier. A server configured to trust the signing CA can validate that certificate without storing the holder’s raw public key as a separate authorization entry.

Cybersecurity 19 Sep 2026 6 min read

IMA Appraisal Binds File Access to Integrity Metadata

A file can have ordinary read or execute permission and still fail an integrity check at the kernel boundary. Linux Integrity Measurement Architecture (IMA) appraisal can apply policy rules at selected hooks and require file content to agree with integrity metadata before the covered operation proceeds. This adds a content-integrity condition to access decisions without turning Unix mode bits or application authorization into integrity mechanisms. IMA contains related but distinct functions. Measurement records file state in an integrity measurement list and can extend measurements into a TPM. Appraisal evaluates a file against integrity metadata and can reject access when policy and enforcement mode require a valid result. Audit records security-relevant state. A deployment that only measures files gains evidence about observed state; it does not automatically gain the blocking behavior associated with appraisal.

Cybersecurity 19 Sep 2026 7 min read

fanotify Permission Events Put File Access Behind a User-Space Decision

A process can pass ordinary filesystem permission checks and still wait before its file operation completes. Linux fanotify permission events let a monitoring group intercept selected operations and require a user-space listener to return an allow or deny response. The mechanism inserts a synchronous decision point into the access path rather than merely reporting activity after it occurs. That distinction makes fanotify useful for security products that need content inspection or policy evaluation close to file access. It also creates a dependency that ordinary notification systems do not have: the kernel may be holding another process at a permission event while user space decides its fate.

Cybersecurity 18 Sep 2026 7 min read

OverlayFS Stashed Credentials Separate Overlay Access from Backing Filesystem Access

OverlayFS Stashed Credentials Separate Overlay Access from Backing Filesystem Access A process opens a path through an OverlayFS mount and appears to access one ordinary filesystem object. The kernel may actually consult an upper layer, a lower layer, or both, and a write can trigger copy-up before the requested operation proceeds. That indirection creates an authorization problem: the caller must be permitted to use the object as exposed by the overlay, while the internal access to the backing filesystems must also run under a defined security identity.

Cybersecurity 18 Sep 2026 7 min read

Landlock Adds a Process-Local Restriction Layer to Linux Access Control

A service may start with every filesystem permission granted to its Unix identity, yet only need a small subset after initialization. Changing the service account or mount topology can reduce that authority, but both are deployment-wide decisions. Linux Landlock provides a different boundary: a process can add restrictions to itself and its descendants without receiving privilege to grant new access. Landlock is a stackable Linux Security Module. Its rules are additional constraints, not replacements for discretionary access control, capabilities, or other active LSM policy. A Landlock rule cannot turn a denied operation into an allowed one. It can only remove authority that the process would otherwise possess.

Cybersecurity 18 Sep 2026 4 min read

Idmapped Mounts Remap File Ownership Without Rewriting Inodes

Idmapped Mounts Remap File Ownership Without Rewriting Inodes A container needs read-write access to a directory whose files carry host ownership values that do not line up with the container’s user namespace. Recursively changing ownership can make the directory usable, but it also mutates persistent inode metadata and can disrupt every other view of the same filesystem. Linux idmapped mounts provide a narrower mechanism: one mount can apply a different identity mapping while the stored ownership remains intact.

Cybersecurity 18 Sep 2026 6 min read

Fanotify Permission Events Put File Access Behind a Userspace Decision

A process calls execve() for a binary on a monitored filesystem, but the kernel does not immediately complete the execution open. A fanotify group has requested FAN_OPEN_EXEC_PERM, so the access waits while a userspace listener receives an event and returns FAN_ALLOW or FAN_DENY. The mechanism inserts a synchronous userspace decision into a filesystem operation that would otherwise proceed after ordinary kernel permission checks. That interception point is useful for policy engines that need information outside normal inode permissions, but it creates a distinct enforcement boundary. Availability now depends on a userspace responder, event coverage depends on the selected fanotify marks and event classes, and the mechanism does not convert every form of file use into a mediated operation.

Cybersecurity 17 Sep 2026 6 min read

SCM_RIGHTS Transfers File-Descriptor Authority Across Unix Sockets

SCM_RIGHTS Transfers File-Descriptor Authority Across Unix Sockets A privileged service can open a file that another process could not open by pathname, then pass that access through a Unix-domain socket. The receiving process gets a new file descriptor referring to the same kernel open-file state. No second pathname lookup is required, and the receiver’s ability to open that path is not re-evaluated as part of the transfer. That property makes SCM_RIGHTS more than an IPC convenience. It moves an already-established kernel capability across a process boundary. Security therefore depends on both sides of the exchange: the sender must constrain which descriptors can leave its authority domain, and the receiver must treat incoming descriptors as privileged objects whose properties require validation.

Cybersecurity 11 Sep 2026 7 min read

Validate Origin Before Trusting Browser Requests

A web endpoint can receive a valid session cookie and still receive a request that the user did not intend to send. Browsers attach cookies according to cookie rules, not according to the intent of the page that caused a request. For sensitive state changes, that distinction matters. One useful defense is to check the request’s browser origin before accepting the action. An origin identifies the scheme, host, and port of the context that initiated a request. Comparing it with a small set of expected origins can reject requests arriving from browser contexts your application does not trust.

Cybersecurity 11 Sep 2026 9 min read

Manage Concurrent Sessions Without Breaking Legitimate Use

A user signs in on a laptop, then on a phone, and later on a work computer. All three sessions may be legitimate. If one device is lost or a session token is stolen, though, the same account can also have a session the user no longer controls. A simple rule such as “allow only one login at a time” looks like a security control, but it mixes two different questions: how many sessions exist, and whether each session is still trustworthy. Strict concurrency limits can disrupt legitimate users while doing little to identify the session that actually needs to be removed.

Cybersecurity 10 Sep 2026 9 min read

Require Independent Approval for High-Risk Administrative Actions

Some administrative actions are too consequential to depend on one account making one decision. An administrator might be compromised, might misunderstand the target, or might simply select the wrong option. If that one identity can immediately disable a critical control, grant powerful access, or approve a destructive change, ordinary authentication cannot distinguish a legitimate decision from a costly mistake. Independent approval changes that failure mode. One authorized person proposes the action, and a different authorized person must approve the same action before it can execute. The control is sometimes called two-person approval or a four-eyes rule. Its useful security property is narrower than those names suggest: a single administrator’s authority is insufficient for a defined class of high-risk operations.

Cybersecurity 09 Sep 2026 10 min read

Treat Security Bypass Flags as Privileged Controls

A security control sometimes needs an emergency exception. A certificate check may need a temporary compatibility mode during a migration. A fraud rule may need a narrow exemption for a broken integration. An administrator may need a recovery path when the normal authentication service is unavailable. The dangerous mistake is to treat the switch that disables or weakens that control as ordinary configuration. If changing require_strong_check = true to false removes a protection, then permission to change that value carries security authority. A compromised deployment account, careless operator, stale test setting, or poorly protected configuration service can turn the exception into a persistent bypass.

Cybersecurity 09 Sep 2026 9 min read

Treat Client-Side Authorization State as Untrusted Input

Applications often send useful state to a client: a user role for rendering navigation, an owner identifier for displaying a record, or a flag that controls whether a button appears. The security problem begins when the server later accepts that client-supplied state as proof that an action is allowed. A client is outside the server’s trust boundary. A browser, mobile application, API consumer, or desktop client can send requests that differ from the interface the developer intended. If changing a client-controlled field can change an authorization result, a user may gain authority that the server never granted.

Cybersecurity 09 Sep 2026 10 min read

Treat Account Email Changes as Security-Sensitive

Changing an account email address can look like an ordinary profile edit. In many systems, however, the email address is also used for sign-in, password recovery, security notifications, or proving control of the account. That makes the change a security-sensitive transition, not merely a text-field update. If an application lets a valid session replace the account email without additional checks, a stolen or unattended session may be enough to redirect future recovery messages to someone else. The legitimate user can then lose both a warning channel and a path back into the account.

Cybersecurity 09 Sep 2026 10 min read

Make Tenant Context Part of Every Authorization Decision

A multi-tenant application can have correct login logic and still expose one customer’s data to another. The failure often begins with an authorization check that asks only whether a user may access a resource, while forgetting to verify the tenant in whose context that access is being requested. A tenant is an isolated customer, organization, workspace, or similar security domain that shares an application with other tenants. Tenant isolation means actions intended for one tenant should not silently cross into another.

Cybersecurity 09 Sep 2026 8 min read

Make Authorization Policy Conflicts Explicit

Authorization becomes difficult when more than one rule applies to the same request. One policy may grant a developer access to a project while another restricts access to confidential records. If the system has no explicit rule for combining those policies, a small implementation detail can decide whether access is granted. That is a security problem because developers, administrators, and reviewers may believe different policies take precedence. A later refactor can then change effective access without anyone intending to change the security model.

Cybersecurity 09 Sep 2026 10 min read

Keep a Credential Inventory You Can Revoke

A service can have strong authentication and still accumulate a dangerous access problem: nobody can reliably answer which machine credentials are valid, who owns them, or which ones can be revoked. That uncertainty matters during routine maintenance and incidents. An old integration may disappear while its API key remains valid. A team may find a credential in a secret store but hesitate to disable it because the last known caller is unclear. If the credential is later exposed, its authority survives simply because nobody knows whether anything still depends on it.

Cybersecurity 09 Sep 2026 8 min read

Expire Sessions with Idle and Absolute Timeouts

A login session is convenient because a user does not need to authenticate on every request. The same property becomes a security problem when a session credential is copied: whoever possesses a usable credential may keep acting with the authority attached to it until the application stops accepting it. Expiration limits that window. But a single vague setting called “session timeout” is often not enough. Two different questions matter: how long may a session sit unused, and how long may it exist even if it stays active? These are the idle timeout and the absolute timeout.

Cybersecurity 09 Sep 2026 10 min read

Do Not Use Security Questions as Authenticators

An application can protect normal sign-in with a strong password or multi-factor authentication and then weaken the same account with one recovery question such as a pet name or birthplace. If answering that question is enough to reset a password or regain access, the question is effectively another authenticator. That matters because many personal facts are easier to discover, infer, reuse, or guess than a deliberately chosen authentication secret. The recovery path can therefore become easier to satisfy than the sign-in path it is meant to recover.

Cybersecurity 08 Sep 2026 12 min read

Revoke Access When Identity Ownership Ends

Access is often granted deliberately and removed accidentally. A developer joins a project and receives repository access. A contractor gets an administrative role for a migration. A service account is created for an integration. Months later, the person leaves, the project ends, or the integration is replaced, but some of the access remains. That leftover access is a security problem because its original justification has disappeared. A credential may still work, a group membership may still grant permissions, or an unattended service identity may still be able to call sensitive systems. If that identity or credential is later misused, the system may accept the request even though nobody can explain why the access still exists.

Cybersecurity 08 Sep 2026 9 min read

Quarantine Compromised Accounts Without Destroying Evidence

When an account appears compromised, the fastest reaction is often to delete it. That can stop some activity, but deletion can also remove identity records, group memberships, session metadata, ownership information, and other state that responders need to understand what happened. It may also make recovery harder if resources still depend on that identity. A better incident-response mental model is to separate containment from destruction. Containment removes or sharply limits the account’s ability to cause new harm. Preservation keeps the relevant identity and evidence available long enough to investigate, recover, and make deliberate cleanup decisions.

Cybersecurity 08 Sep 2026 10 min read

Make Destructive Actions Recoverable Before They Become Permanent

A delete button can turn one stolen session, one excessive permission, or one operator mistake into permanent data loss. Authentication and authorization still matter, but they answer only whether a request is allowed now. They do not answer whether the effect should become irreversible immediately. For data whose loss would be costly, a useful defensive pattern is to separate logical deletion from permanent deletion. The first step removes the object from normal use without destroying the underlying recovery copy. Permanent deletion happens later, after a defined recovery window or a stronger authorization step.

Cybersecurity 08 Sep 2026 10 min read

Design Break-Glass Access for Emergencies

Strong access controls can create an uncomfortable failure mode: the controls that protect administration may themselves become unavailable during an incident. An identity provider can fail, a privileged-access service can be misconfigured, or an administrator can accidentally remove the last usable administrative role. If every recovery action depends on the failed component, responders may be unable to repair the system. A break-glass path is emergency privileged access kept for situations where the normal administrative path cannot be used. The name suggests breaking a physical emergency panel: using it is exceptional, visible, and followed by investigation and repair. That analogy is useful, but the actual mechanism is simply a deliberately separate way to obtain narrowly defined privileged access under controlled conditions.