/

CVE-2026-22207

Severity:

CRITICAL RISK

(9.8)

Broken Access Control / Missing Authentication

CVE-2026-22207

Awaiting Analysis

Vulnerability type

Category:

Broken Access Control / Missing Authentication

CWE:

CWE-306

Impact:

Unauthenticated Administrative Access and Privilege Escalation to ROOT

Severity:

CRITICAL RISK

(9.8)

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

OpenViking through version 0.1.18 (prior to commit 0251c70) contains a broken access control issue where omitting the root_api_key configuration leaves administrative endpoints unprotected.

In this misconfigured state, unauthenticated attackers can call privileged APIs without authentication headers and potentially obtain ROOT-level access to account management, resource operations, and system configuration.

Affected context

The vulnerability arises in OpenViking deployments where the root_api_key is left unset or omitted in configuration.

In these cases, server-side checks that should enforce authentication for critical administrative endpoints do not activate, effectively treating all incoming requests as trusted.

The issue is limited to environments where OpenViking is reachable over a network (e.g., internet-facing APIs, internal service meshes, or shared development clusters) and the process runs with high privileges or controls critical resources.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoints exposed by OpenViking, particularly those intended for administrative or ROOT-level operations.
  • Required access: Network-level connectivity to the OpenViking service; no prior authentication or valid API key is needed when root_api_key is omitted.
  • Trigger point: Sending requests to protected endpoints without authentication headers (e.g., no root API key) while the service is running with a missing root_api_key configuration.
  • Why exploitation is possible: The authorization layer does not enforce authentication when the root_api_key is not configured, implicitly defaulting to an "open access" state instead of failing closed.

Why this happens

This issue is a classic CWE-306: Missing Authentication for Critical Function.

The design or implementation implicitly assumes that a root_api_key will always be configured and does not define a secure default behavior for when it is absent.

Instead of failing closed and rejecting all administrative requests when no root credential is present, the system continues to expose high-privilege endpoints without enforcing authentication checks.

This insecure default configuration pattern leads to unauthenticated access to critical functionality that should always require robust authorization and authentication.

Potential impact

  • Unauthenticated attackers can invoke ROOT-level administrative endpoints.
  • Unauthorized creation, modification, or deletion of user accounts and roles.
  • Arbitrary changes to system and security configuration, including logging and access policies.
  • Destructive resource operations, such as wiping data, shutting down services, or manipulating runtime parameters.
  • Full compromise of the OpenViking deployment and potential pivot to other infrastructure resources.

General mitigation guidance

Effective mitigation focuses on enforcing secure-by-default access control and ensuring fail-closed behavior:

  • Require a valid administrative credential (such as root_api_key or equivalent) to be configured before the service starts, and refuse to boot if it is missing.
  • Implement explicit checks so that, in the absence of a configured administrative credential, all privileged endpoints are disabled or reject requests.
  • Separate administrative interfaces from regular user-facing APIs and restrict network access (e.g., bind to internal interfaces, limit via firewall or service mesh policies).
  • Apply the principle of least privilege to the process environment, limiting what ROOT-level actions the service can actually perform at the OS and infrastructure level.
  • Provide clear configuration documentation and warnings around the security implications of leaving high-privilege keys unset.

How teams detect issues like this

Detection can combine configuration validation, runtime monitoring, and code-level review:

  • Configuration checks: Implement startup-time validation that flags or blocks deployments where root_api_key (or equivalent admin credentials) are missing, and integrate these checks into deployment automation (CI/CD pipelines, Helm charts, etc.).
  • Static analysis and code review: Look for authorization logic that branches on configuration flags or keys without a defined fail-closed path; highlight any code paths where missing configuration yields permissive behavior.
  • Runtime monitoring: Monitor access logs for administrative endpoints being called without authentication headers, especially from untrusted networks, and raise alerts on anomalous patterns.
  • Policy enforcement: Use infrastructure-level controls (API gateways, reverse proxies, service meshes) to require authentication at the edge for administrative routes, even if the application misconfigures internal checks.

Sources

SourceLink
github.comgithub.com/volcengine/OpenViking/commit/0251c7045b3f8092c4d2e1565115b1ba23db282f
github.comgithub.com/volcengine/OpenViking/issues/302
github.comgithub.com/volcengine/OpenViking/pull/310
vulncheck.comvulncheck.com/advisories/openviking-missing-root-api-key-allows-anonymous-root-access

Frequently asked

questions

Yes, if the OpenViking instance is network-accessible and the root_api_key is omitted, an attacker can remotely access administrative endpoints without authentication.

No. In the vulnerable configuration, no credentials are required; only network connectivity to the exposed OpenViking API is needed.

Enforce a strict requirement that administrative credentials are configured and validated at startup, and ensure that in their absence the service fails closed by disabling or rejecting access to all privileged endpoints.

Adopt secure-by-default configurations, treat missing security parameters as hard failures, centralize authorization checks for critical functions, and include automated configuration and code reviews focused on fail-closed access control logic.

Find out what's already
exploitable in your codebase.