/

CVE-2026-33950

Severity:

CRITICAL RISK

(9.4)

Broken Access Control / Authentication Bypass

CVE-2026-33950

Analyzed

Vulnerability type

Category:

Broken Access Control / Authentication Bypass

CWE:

CWE-285, CWE-288, CWE-862

Impact:

Privilege Escalation to Administrator / Full Server Compromise

Severity:

CRITICAL RISK

(9.4)

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

Signal K Server versions prior to 2.24.0-beta.4 contain an access control flaw in the /enableSecurity endpoint that allows an unauthenticated attacker to inject or obtain Administrator role privileges.

When exploited, this issue can grant full administrative control over the server, enabling unauthorized modification of vessel routing data, configuration changes, and access to restricted endpoints.

Affected context

This vulnerability affects Signal K Server deployments where the /enableSecurity endpoint is reachable (for example, from the vessel's local network, Wi‑Fi, or exposed remote access).

The issue arises in configurations where security initialization or security toggling is handled through the /enableSecurity mechanism without enforcing strict authentication and authorization.

Any instance that processes requests to this endpoint before robust access checks are applied may be susceptible, regardless of underlying operating system or hosting environment.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the Signal K Server, specifically requests to /enableSecurity.
  • Required access: Network-level connectivity to the server (e.g., same LAN, exposed port via router, VPN, or port-forward).
  • Authentication state: None required; the flaw allows interaction with the security setup logic without prior login.
  • Trigger point: A crafted request to /enableSecurity that manipulates how roles or security settings are established, resulting in an Administrator role being created or assigned.
  • Why exploitation is possible: The endpoint does not sufficiently verify the caller's identity or enforce proper authorization checks when enabling or configuring security, permitting untrusted clients to influence role assignments.

Why this happens

At its core, this is a broken access control vulnerability where a security-sensitive endpoint is exposed without adequate authentication and authorization enforcement.

The /enableSecurity route appears to handle initialization or modification of security configuration, but it trusts incoming requests to perform privileged actions such as assigning administrative roles.

This maps primarily to CWE-285: Improper Authorization, complemented by:

  • CWE-288: Authentication Bypass, as the endpoint performs privileged operations without requiring valid credentials.
  • CWE-862: Missing Authorization, since no proper role or permission check gate-keeps the sensitive operation.

Conceptually, the insecure pattern is: "publicly accessible security-configuration endpoint that can create or assign high-privilege roles without binding the operation to an authenticated, authorized principal."

Potential impact

  • An attacker may gain full Administrator access to the Signal K Server web interface and API.
  • An attacker could modify sensitive vessel routing and navigation-related data managed by the server.
  • An attacker may alter server configurations, including network or plugin settings, logging, and integration endpoints.
  • An attacker can access or manipulate restricted endpoints, potentially exposing private vessel information or connected system data.
  • An attacker might install or configure malicious plugins or webhooks to maintain persistence or further compromise connected systems.
  • In environments where the server influences navigation or operational decisions, an attacker's changes could impact safety or situational awareness.

General mitigation guidance

Effective mitigation focuses on hardening access control around security-critical endpoints and ensuring that no privilege-assigning functionality is reachable without robust checks:

  • Require strong authentication for any endpoint that enables, configures, or modifies security settings or roles, and ensure these routes are never exposed as anonymous actions.
  • Enforce explicit authorization checks so that only already-authenticated administrative users can invoke role or security configuration operations.
  • Separate initialization/setup flows from runtime administration and restrict initialization to controlled conditions (e.g., first-run only, or via offline/console configuration).
  • Apply the principle of least privilege in the design of roles and permissions, limiting the scope of what a single endpoint can change.
  • Implement secure-by-default deployment guidance: avoid exposing administrative and security-related endpoints directly to untrusted networks and encourage use of network-level protections (firewalls, access control lists, VPNs).
  • Introduce defense-in-depth measures such as CSRF protections, rate limiting, and additional confirmation steps for high-impact administrative actions.

How teams detect issues like this

Detecting this class of vulnerability typically involves both code-focused and operational approaches:

  • Static analysis and code review:
  • Flag routes or controllers that modify security settings (e.g., roles, authentication configuration, user provisioning) and ensure they are always wrapped in authentication and authorization checks.
  • Look for endpoints with names like /enableSecurity, /setup, /install, or /init that can be invoked without verifying the caller's identity.
  • Review conditional logic that treats "first run" or "no admin user exists" as a reason to relax authentication; ensure those conditions cannot be triggered arbitrarily in production.
  • Security testing and policy enforcement:
  • Include tests in CI/CD that attempt unauthenticated access to administrative endpoints and verify denial of access.
  • Use automated API security scanning tools or DAST to probe for endpoints that allow privilege changes or sensitive configuration changes without proper credentials.
  • Enforce architectural policies that forbid anonymous access to any endpoint capable of altering security posture or role assignments.
  • Runtime monitoring:
  • Log and alert on calls to security-related endpoints, especially if made from unfamiliar IP addresses, at unusual times, or without an established session context.
  • Monitor for sudden creation or elevation of administrative accounts, and tie such events back to authenticated user identities.

Sources

SourceLink
github.comgithub.com/SignalK/signalk-server/releases/tag/v2.24.0-beta.4
github.comgithub.com/SignalK/signalk-server/security/advisories/GHSA-x8hc-fqv3-7gwf

Frequently asked

questions

It can be, depending on how the Signal K Server is exposed. If the HTTP(S) port is reachable from the internet (for example, via port forwarding, remote access services, or a VPN that includes untrusted users), a remote attacker with network access to the server can potentially exploit it. In more isolated deployments limited to an onboard LAN, exploitation is scoped to whoever can join that network.

The attacker only needs network connectivity to the server's HTTP(S) interface; no prior authentication is required. They do not need an existing account, because the flaw allows them to obtain or inject administrative privileges through the /enableSecurity endpoint.

The safest pattern is to require strong authentication and explicit authorization for any endpoint that configures security, creates users, or grants roles. Security setup or enabling endpoints should be tightly bound to an authenticated admin session, limited to controlled initialization flows, and disabled or locked down once setup is complete.

Preventive strategies include designing with "deny by default" access control, treating all security-configuration and role-management endpoints as strictly administrative, and systematically enforcing authentication and authorization middleware on those routes. Additionally, incorporating security-focused code review, automated tests for anonymous access to admin features, and architectural policies around safe initialization flows can help catch similar issues before release.

Find out what's already
exploitable in your codebase.