/

CVE-2026-37235

Severity:

HIGH RISK

(7.5)

Improper Access Control on xApp Identification (CWE-284) in FlexRIC E2 Interface

CVE-2026-37235

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-284

Impact:

Impersonation and Denial of Service

Severity:

HIGH RISK

(7.5)

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

FlexRIC v2.0.0 accepts the xapp_id from incoming E42 messages without binding it to the sender's SCTP association, allowing any endpoint to claim any valid xApp identity.

A remote, unauthenticated attacker can impersonate another xApp when talking to the iApp on port 36422, leading to misrouted responses and potential crashes of the victim xApp, the RIC, or the iApp due to inconsistent internal state.

Affected context

This vulnerability appears in FlexRIC v2.0.0 within the control-plane messaging path between xApps and the intelligent application (iApp) over SCTP (port 36422).

The issue manifests when the platform:

  • Uses xapp_id values from E42 message payloads to identify and route to xApps
  • Only validates that xapp_id falls within an assigned numeric range
  • Does not cryptographically or logically bind xapp_id to the SCTP association or any authenticated identity

In deployments where multiple xApps share the same RIC/iApp instance and where network access to port 36422 is not strongly restricted, the risk is significantly higher.

Exploit preconditions

  • Attack surface: Network-accessible iApp endpoint listening on SCTP port 36422.
  • Required access: Ability to open an SCTP association and send E42 messages to the iApp; no prior authentication is needed if the port is reachable.
  • Trigger point: Sending crafted E42 messages that specify a chosen xapp_id belonging to another xApp in the system.
  • Why exploitation is possible: The valid_xapp_id() function only enforces that xapp_id lies within an allowed range and does not bind it to the originating SCTP association or any trusted identity, so the routing logic accepts attacker-supplied identifiers as authoritative.

Why this happens

The core problem is an improper access control design where identity and authorization for xApps are inferred solely from an untrusted payload field (xapp_id) rather than from a trusted binding to the communication channel or an authenticated principal.

The valid_xapp_id() function implements only a range check, treating any in-range identifier as valid for any SCTP association.

This aligns with CWE-284: Improper Access Control, where the system fails to enforce ownership and binding of identities to specific clients.

Because routing and state management structures (such as the red-black tree used to track xApp sessions) rely on this weak identity model, an attacker can corrupt or confuse the internal mapping, leading to impersonation and state inconsistencies that can crash xApps, the RIC, or the iApp.

Potential impact

  • An attacker can impersonate any existing xApp by claiming its xapp_id.
  • Responses and control messages may be misrouted to a victim xApp, disrupting its normal operation.
  • The internal red-black tree state can become inconsistent, potentially leading to crashes of:
  • The victim xApp
  • The RIC platform
  • The iApp service itself
  • Denial of service for specific xApps or potentially the entire RIC environment.
  • Degradation of network control behavior if critical xApps are impacted or misrouted.

General mitigation guidance

Effective mitigation focuses on binding logical identities to trusted channels and tightening authorization checks:

  • Associate each xApp with its SCTP association or another authenticated transport-level identity and treat the payload xapp_id only as advisory, or ignore it altogether.
  • Introduce a secure registration/handshake phase where xApps obtain a server-side identity that is used for subsequent routing, independent of client-controlled fields.
  • Enforce that any identifier used in routing or session lookup is derived from server-tracked session state rather than from untrusted message payloads.
  • Harden the data structures (like red-black trees) against inconsistent state by validating invariants before updates and handling duplicate/unexpected entries defensively.
  • Apply network segmentation and access control lists (ACLs) to limit which hosts or segments may initiate SCTP connections to port 36422, reducing unauthenticated exposure.

How teams detect issues like this

Detection can target both design flaws and runtime anomalies:

  • Static/code analysis:
  • Flag locations where routing or authorization decisions depend directly on client-controlled identifiers without transport or authentication binding.
  • Search for validation functions that only perform range or format checks (such as valid_xapp_id()) but are used as sole authorization gates.
  • Identify uses of shared data structures (e.g., red-black trees keyed by client-supplied IDs) updated without verifying ownership of those IDs.
  • Code review practices:
  • Review trust boundaries around message parsing and routing logic, verifying that each identity used for authorization is tied to a trusted session or credential.
  • Examine error-handling and consistency checks in stateful structures to ensure they remain robust against malformed or conflicting entries.
  • Runtime/operational monitoring:
  • Log and alert on multiple different SCTP associations claiming the same xapp_id.
  • Monitor for frequent crashes, restarts, or integrity check failures in the RIC, iApp, or xApps that correlate with abnormal message patterns.
  • Automated security review tools can complement manual review by flagging insecure identity handling patterns and unbounded trust in payload fields.

Sources

SourceLink
github.comgithub.com/MinamiKotor1/oran-security-advisories-zhongnan-luo/blob/main/advisories/CVE-2026-37235.md
gitlab.eurecom.frgitlab.eurecom.fr/mosaic5g/flexric

Frequently asked

questions

Yes. If an attacker can reach the iApp's SCTP port (36422), they can open a connection and send crafted E42 messages without prior authentication, enabling remote exploitation.

No explicit credentials are required. The flaw stems from trusting the xapp_id field itself; as long as the attacker knows or guesses a valid xapp_id within the allowed range and can connect to the iApp, they can impersonate that xApp.

The most robust pattern is to bind xApp identity to a trusted context—such as the SCTP association established during a registration phase—and to use that server-managed identity for all routing and authorization decisions, rather than relying on client-supplied identifiers in message payloads.

Establish clear trust boundaries and design protocols so that all security-sensitive identifiers are derived from authenticated sessions or tokens controlled by the server. During development, mandate security reviews for routing and identity logic, and use automated checks to detect when authorization decisions depend directly on untrusted message fields.

Find out what's already
exploitable in your codebase.