/

CVE-2026-29023

Severity:

HIGH RISK

(7.3)

Hard-Coded Credentials in Keygraph Shannon Router

CVE-2026-29023

Deferred

Vulnerability type

Category:

Hard-Coded Credentials

CWE:

CWE-798

Impact:

Authentication Bypass and Unauthorized API Usage

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

Keygraph Shannon includes a hard-coded API key in its router configuration, allowing anyone who can reach the exposed router port to authenticate with a publicly known static credential.

When exploited, attackers can proxy traffic through the Shannon instance using the victim's upstream provider API credentials, leading to unauthorized API usage and exposure of proxied request and response data.

Affected context

This vulnerability affects deployments of Keygraph Shannon where:

  • The router component is enabled in the configuration
  • The router port is reachable over a network (e.g., from the internet or a shared internal network)
  • Upstream provider API credentials are configured on the Shannon instance

In these contexts, the hard-coded API key effectively functions as a universal password for accessing the router, undermining any expected isolation or access control around the proxy capability.

Exploit preconditions

  • Attack surface: Network-accessible router port exposed by a Shannon instance
  • Required access: Ability to send TCP/HTTP requests to the router port (no prior authentication needed beyond the static key)
  • Trigger point: Presenting the known hard-coded API key in requests to the router interface when it is enabled
  • Why exploitation is possible: The router logic trusts a single static credential embedded in the code/configuration, which is identical for all affected deployments and publicly discoverable, allowing attackers to impersonate legitimate clients and piggyback on the victim's upstream API credentials.

Why this happens

The underlying issue is the presence of a hard-coded authentication secret in application logic, mapped to CWE-798: Use of Hard-coded Credentials.

Instead of deriving credentials from per-deployment configuration, secure storage, or dynamic authorization mechanisms, the router relies on a static API key baked into its configuration.

Because this key is constant and not bound to a specific environment or user, any party aware of the key can authenticate as a trusted client wherever the router is exposed, defeating meaningful access control around the proxy and creating a single point of failure across installations.

Potential impact

  • Unauthorized use of the victim's upstream provider API credentials via the Shannon router
  • Exposure of proxied request and response payloads, including potentially sensitive data
  • Increased operational costs or quota exhaustion on upstream APIs due to abusive traffic
  • Potential correlation and leakage of usage patterns, metadata, or identifiers tied to the victim's account
  • Leveraging the proxy for further abuse or reconnaissance against upstream services

General mitigation guidance

Effective mitigation focuses on eliminating universal, hard-coded secrets and strengthening access control around the router:

  • Replace hard-coded API keys with per-deployment credentials sourced from configuration or secret management systems, ensuring they are unique and revocable.
  • Require robust authentication and authorization for all router access, such as token-based schemes tied to specific users, clients, or services.
  • Restrict network exposure of the router port, placing it behind internal networks, service meshes, or API gateways with additional policy enforcement.
  • Apply least-privilege principles to upstream provider credentials, limiting the scope and permissions available to the router.
  • Rotate any previously exposed secrets and monitor for anomalous upstream API usage that may indicate prior abuse.

How teams detect issues like this

Detection generally combines code-level review, configuration analysis, and runtime monitoring:

  • Static analysis and code review: Look for constants, string literals, or configuration defaults that contain API keys, tokens, or authentication headers, particularly within router or proxy components.
  • Configuration review: Examine deployment manifests, environment variables, and config files for shared or identical credentials across environments, and verify that router authentication is configurable and non-static.
  • Runtime monitoring: Track access logs for the router endpoint to identify suspicious sources, unusual request rates, or patterns inconsistent with expected clients.
  • Policy enforcement: Use internal security policies or automated tools (e.g., secret scanners, CI checks) to block introduction of hard-coded credentials and to enforce that authentication for network-facing services is configurable, unique, and periodically rotated.

Sources

SourceLink
github.comgithub.com/KeygraphHQ/shannon/issues/186
github.comgithub.com/KeygraphHQ/shannon/pull/224
github.comgithub.com/KeygraphHQ/shannon/pull/224/changes/023cc953db742602964b7826105278d15c28a420
vulncheck.comvulncheck.com/advisories/keygraph-shannon-hard-coded-router-api-key

Frequently asked

questions

Yes, if the Shannon router port is exposed over a network (for example, to the internet or a shared internal network), a remote attacker who knows the static key can authenticate and use the router.

No user-specific credentials are required. The core issue is that the router trusts a single hard-coded API key, which can be known to attackers and reused across deployments.

Replace the hard-coded key with configurable, per-deployment credentials managed via a secure secret store, enforce strong authentication and authorization on the router, and ensure the router is not unnecessarily exposed on untrusted networks.

Establish development policies that prohibit hard-coded secrets, adopt automated secret scanning in CI, integrate secure configuration and secret management from the outset, and perform security-focused code reviews for any component that handles authentication or network-facing endpoints.

Find out what's already
exploitable in your codebase.