Severity:

HIGH RISK

(7.3)

Missing Authentication / Broken Access Control

CVE-2026-3053

Analyzed

Vulnerability type

Category:

Missing Authentication / Broken Access Control

CWE:

CWE-287, CWE-306

Impact:

Unauthorized Access to Protected OpenAPI Functionality

Severity:

HIGH RISK

(7.3)

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

DataLinkDC Dinky up to version 1.2.5 contains a missing authentication vulnerability in the OpenAPI endpoint configuration, specifically in the addInterceptors function of AppConfig.java.

Improper or absent authentication checks on exposed OpenAPI routes can allow remote attackers to access functionality or data that should require authenticated or privileged access.

Affected context

The issue arises in deployments of DataLinkDC Dinky (≤ 1.2.5) where the OpenAPI endpoints are enabled and reachable over the network.

The addInterceptors method in AppConfig.java configures HTTP interceptors for these endpoints but does not reliably enforce authentication or may unintentionally exclude specific paths from protection.

In such setups, unauthenticated clients can reach API routes that operators typically expect to be guarded by login or session validation.

Exploit preconditions

  • Attack surface: Publicly or internally exposed HTTP(S) OpenAPI endpoints of the Dinky admin component.
  • Required access: Network-level access to the OpenAPI interface; no prior authentication required where the vulnerability is present.
  • Trigger point: Sending crafted HTTP requests directly to the affected OpenAPI routes that lack proper interceptor-based authentication or session checks.
  • Why exploitation is possible: The interceptor configuration in addInterceptors does not consistently enforce authentication, leaving certain paths or patterns outside of the security filter chain, which maps to missing or weak authentication (CWE-287/CWE-306).

Why this happens

The vulnerability stems from misconfigured or incomplete authentication enforcement in the web application configuration layer.

In Spring-based or similar Java web frameworks, the addInterceptors method is often used to attach authentication, authorization, or logging interceptors to request paths.

If sensitive OpenAPI endpoints are omitted from this configuration, or are assigned overly broad "exclude" patterns, they can become accessible without any authentication.

This behavior corresponds to CWE-287 (Improper Authentication) and CWE-306 (Missing Authentication for Critical Function), where the system fails to verify the identity of callers before granting access to protected operations.

Potential impact

  • Unauthenticated access to OpenAPI endpoints that may expose operational or configuration functionality.
  • Potential retrieval of sensitive or internal information via unauthenticated API calls.
  • Unauthorized triggering of administrative or data-modifying operations that should require login.
  • Abuse of exposed endpoints as a foothold for further compromise of the surrounding environment.

General mitigation guidance

Effective mitigation focuses on enforcing strict, centralized authentication for all sensitive endpoints and avoiding bypasses in configuration:

  • Apply a default-deny strategy to API routes, requiring authentication for all endpoints unless explicitly and safely classified as public.
  • Ensure that interceptor or filter chains responsible for authentication cover all OpenAPI paths, avoiding broad exclusion patterns such as wildcard-based ignores for entire path segments.
  • Use framework-level security modules (e.g., standardized security configuration, annotations, or middleware) rather than custom, ad-hoc checks spread across controllers.
  • Separate truly public endpoints from administrative or internal APIs, using distinct base paths and security rules to reduce configuration mistakes.
  • Run the application behind authentication-enforcing gateways or reverse proxies where feasible, adding an additional layer of protection around API entry points.

How teams detect issues like this

Organizations can identify this class of vulnerability using both code-level and behavior-level analysis:

  • Static analysis and configuration review:
  • Scan WebMvcConfigurer, security configuration, and addInterceptors usages for URL patterns that exclude authentication on non-trivial endpoints.
  • Look for controllers or OpenAPI endpoints that perform sensitive actions but lack associated authentication or authorization annotations.
  • Enforce security linting rules that flag public exposure of administrative or configuration routes.
  • Dynamic and runtime testing:
  • Use API scanning tools or test harnesses to enumerate OpenAPI routes and attempt access without authentication, noting unexpected 200/2xx responses.
  • Integrate automated security tests into CI/CD that verify important endpoints return 401/403 when accessed without valid credentials.
  • Operational monitoring:
  • Monitor logs for unauthenticated requests to sensitive endpoints and create alerts for anomalous access patterns.
  • Employ web application firewalls or API gateways with policies requiring authentication tokens for defined paths.

Sources

SourceLink
github.comgithub.com/AnalogyC0de/public_exp/issues/6
github.comgithub.com/AnalogyC0de/public_exp/issues/6#issue-3935019636
vuldb.comvuldb.com/?ctiid.347411
vuldb.comvuldb.com/?id.347411
vuldb.comvuldb.com/?submit.757589

Frequently asked

questions

Yes. As long as the OpenAPI endpoints are reachable over the network, an attacker can exploit the missing authentication remotely without prior access.

No. The core issue is that certain endpoints fail to enforce authentication at all, so attackers only need network connectivity to the affected OpenAPI interface.

Apply a centralized, default-deny authentication policy to all API routes and verify that the OpenAPI endpoints are covered by standard security configuration rather than relying solely on custom interceptor exclusions.

Design APIs with security-by-default, ensure all sensitive routes require authentication and authorization, use consistent framework-level security abstractions, and continuously test APIs for unauthenticated access using automated scanning and code review policies.

Find out what's already
exploitable in your codebase.