/

CVE-2026-33631

Severity:

HIGH RISK

(8.7)

Missing Authorization in ClearanceKit Endpoint Security

CVE-2026-33631

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Local Authorization Bypass and Policy Evasion

Severity:

HIGH RISK

(8.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

ClearanceKit's macOS Endpoint Security extension previously enforced file access policies only for file-open events, leaving seven other file operation types unevaluated.

A locally running process could perform these uncovered operations to bypass configured File Access Authorization (FAA) policies without triggering a denial, undermining host-level data protection on affected systems.

Affected context

This vulnerability affects macOS systems that rely on ClearanceKit's opfilter Endpoint Security system extension to enforce per-process file access policies.

In impacted versions, the extension subscribed only to ES_EVENT_TYPE_AUTH_OPEN events while omitting subscriptions for seven additional authorization-relevant file event types (such as rename and unlink).

As a result, any file operations routed through those unmonitored event types could proceed without being matched against the configured FAA policies, despite policy rules suggesting they would be controlled.

Exploit preconditions

  • Attack surface: Local macOS host where ClearanceKit is installed and FAA policies are deployed.
  • Required access: Ability to execute code as a local user or process; no special entitlements beyond the ability to perform standard file operations.
  • Trigger point: Performing file operations that map to the non-subscribed Endpoint Security authorization events (e.g., certain rename, delete, or other file-manipulation operations).
  • Why exploitation is possible: The opfilter extension subscribed only to ES_EVENT_TYPE_AUTH_OPEN and did not subscribe to the seven additional authorization event types. These unmonitored event types were therefore never evaluated by the FAA policy engine, allowing operations to succeed regardless of user-configured restrictions.

Why this happens

The root cause is incomplete authorization coverage in the Endpoint Security event subscription logic.

ClearanceKit's opfilter extension implemented policy enforcement for file access by subscribing to ES_EVENT_TYPE_AUTH_OPEN events and routing them through its FAA policy evaluator.

However, it failed to subscribe to seven other authorization event types that can modify or interact with files in ways relevant to access control.

This maps to CWE-862: Missing Authorization: authorization checks were conceptually intended but not actually applied to all relevant actions, leaving a gap between the policy model and the enforced behavior.

Potential impact

  • Local processes may bypass configured file access restrictions by using file operations that trigger unmonitored Endpoint Security event types.
  • Sensitive files protected by FAA policies could be renamed, deleted, or otherwise manipulated despite policy rules meant to prevent such actions.
  • Application-level or per-process data isolation on the host can be weakened, potentially enabling lateral data access between applications.
  • Security monitoring and change-detection logic relying on consistent policy enforcement may produce incomplete or misleading results.

General mitigation guidance

Mitigation strategies focus on ensuring complete and consistent authorization coverage across all relevant file operation paths and tightening host-level trust boundaries:

  • Review all file operation event types supported by the macOS Endpoint Security framework and ensure that every operation with a security impact is subscribed to and evaluated against policy.
  • Centralize authorization decisions in a single policy engine and route all relevant event types through that engine, avoiding special-case paths that bypass checks.
  • Design FAA policies assuming that any unmonitored operation type could be abused; when in doubt, treat new or rarely used event types as deny-by-default until explicitly handled.
  • Apply least-privilege principles to processes on the host, so that even if policy enforcement gaps exist, compromised or untrusted processes have minimal access to sensitive data.
  • Combine file access enforcement with additional layers such as OS-level permissions, sandboxing, and application isolation rather than relying on a single filter layer.

How teams detect issues like this

Detection approaches for this class of issue typically revolve around verifying enforcement coverage and analyzing behavior for inconsistencies:

  • Static analysis / code review:
  • Examine Endpoint Security client code to confirm that it subscribes to all relevant ES_EVENT_TYPE_AUTH_* event types, not just open events.
  • Look for event handlers that perform authorization decisions; verify that each security-relevant event type ultimately flows into the same FAA policy evaluation logic.
  • Identify any explicit allow-list paths or exceptions that bypass the main policy engine; ensure they are narrow and well-justified.
  • Behavioral testing / dynamic analysis:
  • Develop tests that perform common file operations (open, rename, unlink, create, truncate, etc.) under restrictive FAA policies and confirm that all operations are consistently enforced.
  • Compare expected denials (from policy configuration) with actual runtime outcomes to detect mismatches that signal missing authorization checks.
  • Operational monitoring:
  • Monitor for unexpected file operations by processes that are supposed to be restricted by FAA policies, using host telemetry or Endpoint Security logging.
  • Use automated policy validation tools, if available, to verify that newly added or updated event types are not left unenforced.

Sources

SourceLink
github.comgithub.com/craigjbass/clearancekit/commit/a3d1733d2691a0d40209c48b01bf9291bf645207
github.comgithub.com/craigjbass/clearancekit/security/advisories/GHSA-25f8-8cj2-m887

Frequently asked

questions

The issue is highly exploitable for any local user or process that can perform file operations. No complex exploitation is required: an attacker simply needs to use file operation types that were not previously covered by the FAA policy enforcement logic.

Typically no. Exploitation only requires the ability to run code or a process on the affected macOS host and perform standard file operations. The vulnerability exists because the policy engine was not applied to certain event types, regardless of the attacker's privilege level.

The safest pattern is to ensure that authorization is centralized and applied consistently to all security-relevant operations. In practice, this means subscribing to all relevant Endpoint Security event types and routing them through a single FAA policy evaluator, with a conservative default-deny stance when an operation type is not explicitly handled.

Prevention involves designing access control systems with full coverage in mind: maintain an inventory of all event types or APIs that can perform sensitive actions, enforce authorization checks uniformly across them, and incorporate automated tests and code review checklists that explicitly validate coverage whenever new event types or OS capabilities are introduced.

Find out what's already
exploitable in your codebase.