/

CVE-2026-27449

Severity:

HIGH RISK

(7.5)

Broken Access Control in Umbraco Engage

CVE-2026-27449

Awaiting Analysis

Vulnerability type

Category:

Broken Access Control

CWE:

CWE-284, CWE-306, CWE-639

Impact:

Unauthorized Access to Sensitive Data

Severity:

HIGH RISK

(7.5)

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

Umbraco Engage exposes several API endpoints that do not enforce authentication or authorization, allowing unauthenticated users to access sensitive records by supplying a user-controlled identifier.

Because the endpoints perform no access control checks, attackers can enumerate predictable IDs and retrieve sensitive analytics, tracking, or customer-related data at scale over the network.

Affected context

This vulnerability occurs in Umbraco Engage deployments where certain backend API endpoints are reachable over the network and do not enforce authentication or authorization.

The issue is triggered when requests containing user-controlled identifier parameters (such as ?id=) are processed without verifying the caller's identity or permissions.

It affects both v16 and v17 release lines in configurations where these endpoints are exposed to untrusted clients (e.g., the internet, shared internal networks, or integrations with weak network isolation).

Exploit preconditions

  • Attack surface: Network-accessible HTTP(S) API endpoints in Umbraco Engage
  • Required access: None; exploitable by unauthenticated, remote users who can reach the affected endpoints
  • Trigger point: Supplying a crafted identifier parameter (e.g., ?id=123) to vulnerable endpoints that return data based solely on the provided ID
  • Why exploitation is possible: The endpoints do not enforce authentication (CWE-306) or authorization checks (CWE-284) and rely on predictable or enumerable identifiers for record selection, enabling ID-based data extraction (CWE-639)

Why this happens

The core issue is a broken access control pattern where server-side business logic trusts client-supplied identifiers without enforcing authentication or permission checks.

The affected endpoints effectively implement direct object references: the client specifies an ID, and the server returns the associated record without confirming that the caller is logged in or authorized to view that resource.

This maps primarily to CWE-284 (Improper Access Control), with related aspects of CWE-306 (Missing Authentication for Critical Function) and CWE-639 (Authorization Bypass Through User-Controlled Key).

Architecturally, this reflects an assumption that the API is only called by trusted front-end components or within a trusted network, rather than enforcing least privilege and identity verification at the API boundary.

Potential impact

  • Unauthenticated retrieval of sensitive Engage-related records by arbitrary users
  • Large-scale enumeration of IDs to exfiltrate datasets containing analytics, tracking, or customer-related information
  • Violation of confidentiality obligations, including potential privacy and regulatory compliance issues
  • Increased risk of profiling users, customers, or business activities based on exposed analytics data
  • Potential for secondary attacks leveraging exposed information (e.g., social engineering, targeted phishing)

General mitigation guidance

Sustainable mitigation focuses on enforcing robust access control at the API layer and decoupling data access from client-supplied identifiers.

Recommended defensive patterns include:

  • Enforce authentication on all sensitive endpoints: Require a valid, server-validated identity (session, token, or service principal) before processing any request that returns non-public data.
  • Apply authorization checks per resource: Ensure each requested record is evaluated against the caller's role, tenant, and ownership context, denying access by default when the relationship is unclear.
  • Avoid direct reliance on raw identifiers: Use indirect references or scoped identifiers that are meaningful only within a user or tenant context, and validate that requested IDs belong to the caller's allowed scope.
  • Adopt least privilege in API design: Design endpoints to return only what is necessary for a given operation, and partition APIs by trust level (public, authenticated, privileged).
  • Harden network exposure: Restrict management and analytics APIs to trusted networks, service-to-service channels, or API gateways that can layer on identity and policy enforcement.
  • Standardize access control frameworks: Centralize authentication and authorization logic through shared middleware or policy engines to avoid per-endpoint omissions.

How teams detect issues like this

Detection typically involves a combination of design review, code analysis, and behavioral monitoring:

  • Static analysis and code scanning:
  • Flag controller or handler methods that return sensitive objects but lack authentication or authorization middleware/attributes.
  • Detect patterns where IDs from query parameters or route variables are passed directly into data access layers without permission checks.
  • Code review practices:
  • Use checklists requiring reviewers to verify that every endpoint returning user or business data has explicit access control.
  • Examine API documentation and contracts to confirm which endpoints are intended to be public and ensure code matches that intention.
  • API gateway and policy inspection:
  • Configure gateways or service meshes to require authentication for protected paths and log exceptions where requests succeed without identity context.
  • Runtime monitoring and logging:
  • Track anomalous access patterns, such as sequential ID requests or unusually high rates of resource fetches from a single unauthenticated source.
  • Security testing:
  • Incorporate access control tests into automated API security testing, focusing on ID-based enumeration and unauthorized data access scenarios.

Sources

SourceLink
github.comgithub.com/umbraco/Umbraco.Engage.Issues/security/advisories/GHSA-86vq-ccwf-rm62

Frequently asked

questions

Yes, if the affected API endpoints are exposed to the internet or any untrusted network, an attacker can remotely exploit the issue without authentication by sending crafted requests with chosen identifiers.

No. The core problem is that the endpoints do not require authentication or enforce authorization, so no valid session, token, or user account is needed to access the exposed data.

The most robust fix is to enforce authentication and authorization on all sensitive API endpoints, centralize access control through shared middleware or policies, and validate that every requested record belongs to or is permitted for the authenticated caller before returning any data.

Prevention relies on designing for secure-by-default APIs: mandate authentication for non-public endpoints, apply least-privilege authorization checks at the resource level, avoid exposing raw identifiers without scope checks, and integrate access control verification into code review, automated testing, and API governance processes.

Find out what's already
exploitable in your codebase.