/

CVE-2026-47719

Severity:

HIGH RISK

(8.2)

Server-Side Request Forgery (CWE-918) in FUXA Socket.IO

CVE-2026-47719

Deferred

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-918

Impact:

Unauthorized Internal Resource Access and Data Exposure

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

A high-severity server-side request forgery (SSRF) vulnerability in FUXA allows unauthenticated remote users to influence outbound requests made by Socket.IO handlers. When exposed handlers accept attacker-controlled destinations without write-authorization checks, the FUXA server may retrieve data from internal HTTP, HTTPS, OPC UA, or ODBC services and return results to the requester.

Affected context

The issue occurs in FUXA deployments before the security fix when the DEVICE_WEBAPI_REQUEST and DEVICE_PROPERTY Socket.IO handlers process untrusted endpoint or property-address data. Risk is increased when the FUXA host can reach cloud metadata services, internal administrative interfaces, industrial systems, or database services that are not directly accessible from the internet. Enabling secure transport alone may not prevent the issue if destination authorization remains absent.

Exploit preconditions

  • Attack surface: Internet- or network-exposed FUXA Socket.IO handlers
  • Required access: No authentication may be required when the affected handlers are reachable
  • Trigger point: Processing of attacker-controlled web request, OPC UA, or ODBC connection data
  • Why exploitation is possible: The server performs outbound connections to destinations supplied by the client and exposes the resulting response through a corresponding Socket.IO event

Why this happens

The underlying bug is a missing authorization check on Socket.IO operations that cause server-side network access. The affected handlers omit the isSocketWriteAuthorized control and pass attacker-controlled addresses or endpoint data to outbound connection logic, including HTTP requests made through Axios. This behavior maps to CWE-918: Server-Side Request Forgery, because untrusted input determines a request made from the server's more privileged network position.

Potential impact

  • An attacker may read cloud instance metadata or internal service responses
  • An attacker could access administrative interfaces reachable from the FUXA host
  • Sensitive industrial endpoint information may be disclosed
  • ODBC-accessible data may be exposed
  • Internal network topology and service availability may be inferred
  • Requests could contribute to unauthorized interaction with operational technology environments

General mitigation guidance

Mitigation generally focuses on enforcing authorization before any server-side network operation and reducing the set of destinations the application can contact.

Common defensive patterns include:

  • Require authentication and operation-specific authorization for Socket.IO handlers
  • Apply strict allowlists for approved schemes, hosts, ports, and service types
  • Reject loopback, link-local, private, multicast, and other sensitive network ranges unless explicitly required
  • Resolve hostnames and validate the resulting addresses before connecting, including protections against DNS rebinding
  • Use safe-by-default outbound network policies and isolated egress paths
  • Separate industrial, database, and management networks from the FUXA runtime
  • Avoid returning unrestricted upstream responses to clients
  • Run the application with only the network and data privileges it needs

How teams detect issues like this

Detection can combine code review, runtime monitoring, and policy enforcement:

  • Use static analysis to identify request or connection APIs receiving values from Socket.IO, HTTP, or other client-controlled inputs
  • Review handlers for authorization checks before outbound network operations
  • Search for unrestricted Axios, OPC UA, ODBC, or similar connection calls
  • Monitor FUXA processes for unusual outbound connections, especially to metadata addresses, private ranges, management ports, or unexpected industrial services
  • Enforce egress firewall policies and alert on destinations outside approved allowlists
  • Use automated security review tools to flag SSRF data flows and missing authorization controls

Sources

SourceLink
github.comgithub.com/frangoteam/FUXA/commit/7b2088eaae2be318d962dcba34bfc7a7f26837bd
github.comgithub.com/frangoteam/FUXA/pull/2344
github.comgithub.com/frangoteam/FUXA/releases/tag/v1.3.2
github.comgithub.com/frangoteam/FUXA/security/advisories/GHSA-w86f-rf9w-h3x6

Frequently asked

questions

Yes. Where the affected Socket.IO handlers are reachable without authentication, a remote unauthenticated user may influence server-side connections from the FUXA host.

The attacker generally needs network access to the FUXA service and a deployment where the affected handlers accept requests without effective authentication or authorization.

Enforce authorization before connection handling, validate destinations against strict allowlists, and restrict outbound network access with application and infrastructure controls.

No. HTTPS or another secure transport protects a connection's channel but does not establish that the requested destination is trusted or authorized.

Treat all client-supplied destinations as untrusted, centralize outbound-request policy, apply least-privilege egress controls, and continuously monitor unexpected server-side network activity.

Find out what's already
exploitable in your codebase.