/

CVE-2026-50194

Severity:

HIGH RISK

(8.2)

Auth Bypass via Host Header (CWE-288) in Steeltoe

CVE-2026-50194

Deferred

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-288, CWE-639

Impact:

Unauthorized Access to Management Endpoints

Severity:

HIGH RISK

(8.2)

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

Steeltoe management endpoints can be exposed to unauthorized access when configured to listen on an alternate port, because access control relies on the user-controlled Host header instead of the actual listening socket.

An attacker who can manipulate HTTP headers and reach the application network path may bypass intended port-based isolation and access sensitive management or actuator endpoints.

Affected context

This vulnerability affects applications using Steeltoe management endpoints in versions 3.2.2 through 3.3.0 and 4.1.0 when they are configured to listen on a dedicated management port via Management:Endpoints:Port.

In such deployments, operators often assume that binding management endpoints to a separate port provides isolation from regular application traffic.

The issue appears where Steeltoe middleware enforces endpoint access rules based on the Host HTTP header instead of the actual network port on which the request was received, allowing discrepancies between perceived and real connection context.

Exploit preconditions

  • Attack surface: HTTP(S) interface exposing Steeltoe-enabled applications, especially where management endpoints are bound to a separate port.
  • Required access: Ability to send crafted HTTP requests to the application (e.g., through a browser, script, or API client) and control the Host header value.
  • Trigger point: Requests routed to management or actuator endpoints on an alternate port where middleware evaluates access using Host rather than the real socket port.
  • Why exploitation is possible: The middleware treats the Host header as authoritative for determining the target port, even though this header is supplied by the client and may not match the actual network port, enabling a mismatch between expected and real access restrictions.

Why this happens

The core issue stems from relying on user-controllable HTTP metadata to enforce access policies instead of using trusted connection attributes.

Specifically, Steeltoe management endpoint middleware checks the Host header (which includes the port value) to decide whether a request is targeting the management port, instead of inspecting the actual port on which the server accepted the connection.

This maps to CWE-288: Authentication Bypass Using an Alternate Path or Channel, because the protection mechanism can be circumvented by crafting requests that appear to target a non-management port while still reaching the protected endpoints.

It is also related to CWE-639: Authorization Bypass Through User-Controlled Key, as the decision to grant or deny access hinges on a client-controlled field that acts as a logical routing key.

Potential impact

  • Unauthorized access to Steeltoe management and actuator endpoints.
  • Exposure of sensitive operational data such as health, metrics, or configuration information.
  • Ability to trigger administrative or maintenance actions intended only for trusted operators.
  • Expanded attack surface that can aid lateral movement or further exploitation within the application environment.
  • Potential disruption of service if management endpoints permit state-changing or shutdown operations.

General mitigation guidance

Effective mitigation focuses on ensuring that access control decisions are based on trusted connection properties and explicit authorization rather than on port isolation alone.

Recommended patterns include:

  • Applying explicit authorization policies (e.g., ASP.NET Core RequireAuthorization) to all sensitive management and actuator endpoints, ensuring that identity- and role-based checks are enforced regardless of port configuration.
  • Treating port separation as a defense-in-depth measure only, not as the primary access control mechanism.
  • Using application-level checks that rely on the actual local endpoint (socket) information instead of client-supplied headers when distinguishing between management and user traffic.
  • Restricting exposure of management endpoints to dedicated networks or internal-only interfaces, such as private subnets or VPN-accessible addresses.
  • Configuring upstream reverse proxies or load balancers to sanitize and enforce consistent Host header values, preventing clients from injecting arbitrary host/port combinations.

How teams detect issues like this

Organizations can identify this class of issue through:

  • Static analysis and configuration review: Look for middleware or filters that make authorization decisions based on Host, X-Forwarded-*, or other user-controllable headers rather than on server-side connection metadata or explicit authentication/authorization.
  • Code review checklists: Include items that flag reliance on port separation or host headers as a primary security boundary for management or administrative endpoints.
  • Runtime and log analysis: Monitor access logs for unexpected Host header values or for requests to management and actuator paths originating from untrusted networks.
  • Security testing: Incorporate tests in QA and penetration testing that attempt to reach management endpoints by manipulating Host and related headers through reverse proxies and direct connections.
  • Automated tooling: Use web vulnerability scanners and API security tools that support header manipulation to probe for discrepancies between intended and actual access control behavior.

Sources

SourceLink
github.comgithub.com/SteeltoeOSS/Steeltoe/commit/4cbc352fe89ac2e6c609554e435ab28996fec5e9
github.comgithub.com/SteeltoeOSS/Steeltoe/commit/b7ca93c510aaa08d7e4ebec40ce20c5811c2c4b6
github.comgithub.com/SteeltoeOSS/security-advisories/security/advisories/GHSA-58f6-6rj2-3v8r

Frequently asked

questions

It can be, if the Steeltoe-enabled application and its management endpoints are reachable from the internet (directly or via a proxy) and the path to the service allows clients to control the Host header.

The attacker generally needs only network access to the application endpoint and the ability to craft HTTP requests with custom headers. No valid user account is strictly required if management endpoints are relying solely on port-based restrictions.

Apply explicit authorization requirements to all sensitive management and actuator endpoints so that access is controlled by authentication and role-based policies rather than by port separation. Additionally, ensure that any logic distinguishing management traffic is based on trusted server-side connection properties.

Avoid treating ports, hostnames, or client-supplied headers as primary security boundaries. Design management and administrative interfaces to always require strong authentication and authorization, validate trust based on server-controlled context, and include checks in code review and automated testing to detect header-based access control assumptions.

Find out what's already
exploitable in your codebase.