/

CVE-2026-23751

Severity:

CRITICAL RISK

(9.8)

.NET Remoting / Insecure Remote Method Invocation

CVE-2026-23751

Awaiting Analysis

Vulnerability type

Category:

.NET Remoting / Insecure Remote Method Invocation

CWE:

CWE-306, CWE-441

Impact:

Remote Code Execution and Sensitive Data Exposure

Severity:

CRITICAL RISK

(9.8)

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

Kofax Capture (Tungsten Capture) 6.0.0.0 exposes a deprecated .NET Remoting HTTP channel on port 2424 over an unauthenticated, publicly known endpoint.

By abusing .NET Remoting object unmarshalling, a remote attacker can instantiate powerful framework classes like System.Net.WebClient to read and write arbitrary files, trigger NTLM authentication to attacker-controlled hosts, and potentially achieve remote code execution depending on service account privileges.

Affected context

The vulnerability occurs in the Ascent Capture Service within Kofax/Tungsten Capture deployments that:

  • Have the .NET Remoting HTTP channel listening on port 2424
  • Expose this port to untrusted or semi-trusted networks (e.g., corporate LAN, VPN, or beyond)
  • Use the default, publicly documented endpoint identifier
  • Do not enforce transport-level or application-level authentication in front of the remoting endpoint

In these conditions, the .NET Remoting interface becomes a network-exposed, unauthenticated entry point into the server process.

Exploit preconditions

  • Attack surface: Network-accessible .NET Remoting HTTP channel on TCP port 2424.
  • Required access: Ability to connect to the Ascent Capture Service over the network; no valid application credentials are required.
  • Trigger point: Sending crafted .NET Remoting payloads to the default endpoint, causing the service to unmarshal attacker-controlled objects.
  • Why exploitation is possible:
  • The service exposes a deprecated .NET Remoting interface that performs object unmarshalling based on network input.
  • There is no authentication or authorization gate on the exposed endpoint (CWE-306: Missing Authentication for Critical Function).
  • The endpoint identifier is a known default, lowering the barrier to discovery.
  • .NET Remoting semantics allow instantiation and use of framework types (e.g., System.Net.WebClient) with attacker-controlled parameters, enabling file operations and outbound authentication coercion (CWE-441: Unintended Proxy or Intermediary).

Why this happens

The core issue is the continued use and exposure of a legacy .NET Remoting HTTP channel as a remotely accessible control interface.

.NET Remoting was designed for trusted, internal scenarios and relies on binary object serialization and unmarshalling of remote calls. When such an interface is placed on a network port without strong authentication or endpoint hardening, any reachable client can supply serialized data that the server will deserialize and act upon.

This design maps to:

  • CWE-441: Unintended Proxy or Intermediary, because the application becomes a powerful intermediary that will perform file system and network operations on behalf of an attacker by invoking framework APIs.
  • CWE-306: Missing Authentication for Critical Function, since sensitive operations are exposed over a network channel that does not require authentication.

In abstract terms, the insecure pattern is:

  • A privileged server process exposes a remote invocation endpoint.
  • The endpoint trusts incoming marshalled objects and method calls by default.
  • There is no strong boundary (authentication, authorization, input constraints) between untrusted network input and powerful system APIs reachable via the remoting interface.

Potential impact

  • Remote reading of arbitrary files that the service account can access, potentially exposing configuration files, credentials, or sensitive business data.
  • Remote writing of attacker-controlled files, which may enable:
  • Dropping web shells or backdoors if writable directories are executed or served by other services.
  • Tampering with application configuration or workflow data.
  • Coercion of outbound NTLMv2 authentication to attacker-controlled infrastructure, allowing capture and offline cracking of service account credentials.
  • Remote code execution via abuse of file writes, configuration manipulation, or other reachable execution paths, depending on environment and privileges.
  • Denial of service by causing the service to perform expensive operations, crash, or become unstable under malformed or resource-intensive remoting requests.
  • Lateral movement within the network using the service account's trust relationships and file or network access.

General mitigation guidance

Effective mitigation focuses on eliminating or hardening the legacy .NET Remoting surface and reducing the trust placed in network-originated calls:

  • Remove or replace .NET Remoting endpoints:
  • Prefer modern, authenticated APIs (e.g., HTTPS-based REST services, gRPC) with explicit input validation instead of generic remoting and binary serialization.
  • Disable unused or deprecated remoting channels at the configuration or deployment level.
  • Enforce strict access control in front of remote interfaces:
  • Place network access controls (firewall rules, segmentation, reverse proxies) to limit exposure of service ports to only necessary systems.
  • Where remoting cannot be fully removed, require strong authentication and authorization at the outer boundary (e.g., TLS mutual authentication, gateway-level auth).
  • Constrain what remote calls can do:
  • Avoid exposing generic or overly powerful remoting methods that allow construction of arbitrary framework types or unrestricted parameter values.
  • Introduce server-side validation and whitelisting of allowed operations, arguments, and targets (files, URLs, resources).
  • Reduce privilege and environmental impact:
  • Run the service under a dedicated, minimally privileged account without local administrator rights or domain-wide privileges.
  • Limit file system permissions for the service account to only the directories strictly required for operation.
  • Restrict outbound network access from the service host, especially for protocols that can carry authentication (e.g., SMB, HTTP with integrated auth).
  • Secure-by-default deployment patterns:
  • Ship configurations that disable legacy remoting or bind it only to loopback/local interfaces.
  • Provide administrators with clear hardening guidance and templates that minimize exposed surfaces.

How teams detect issues like this

Detection generally involves a combination of network, host, and code-level analysis:

  • Network-level monitoring:
  • Inspect for unexpected or suspicious traffic to TCP port 2424 or other remoting ports, especially from non-administrative or non-application hosts.
  • Use IDS/IPS rules to identify .NET Remoting or other binary serialization patterns over HTTP and flag anomalous sources or payloads.
  • Host and application logging:
  • Enable detailed logging for the Ascent Capture Service and surrounding components, capturing remote invocation attempts, errors, and stack traces.
  • Monitor for unusual file access patterns or outbound connections initiated by the service account, particularly to unrecognized hosts.
  • Static and configuration analysis:
  • Use code review and static analysis to locate .NET Remoting endpoints, binary serialization, and object unmarshalling in server code.
  • Scan deployment configurations for enabled remoting channels, default endpoint identifiers, and network bindings that expose them to broader networks.
  • Policy and CI/CD controls:
  • Enforce organizational policies that ban or restrict the use of deprecated technologies like .NET Remoting for new or updated services.
  • Integrate automated scanning tools into CI/CD pipelines to detect usage of insecure remoting patterns and require explicit review or waivers.

Sources

SourceLink
docshield.tungstenautomation.comdocshield.tungstenautomation.com/Portal/Products/en_US/KC/11.1.0-40hy9nfk91/KC.htm
gist.github.comgist.github.com/VAMorales/3888941d6e5efdd4b2e673e999f68ca2
vulncheck.comvulncheck.com/advisories/kofax-capture-unauthenticated-file-read-write-smb-coercion-via-net-remoting

Frequently asked

questions

Yes. As described, an attacker who can reach the exposed .NET Remoting HTTP channel on port 2424 can interact with the service without prior authentication, making this a remotely exploitable issue within the reachable network scope.

No application credentials are required to trigger the vulnerable behavior. The primary prerequisite is network connectivity to the Ascent Capture Service port and knowledge (or discovery) of the remoting endpoint, which uses a default identifier.

The most robust fix pattern is to remove or fully disable the legacy .NET Remoting interface and replace it with a modern, authenticated API boundary. In parallel, enforce strict network segmentation so that any remaining management or control interfaces are not accessible from untrusted networks.

Avoid exposing generic remote invocation or binary serialization technologies directly over the network, require strong authentication and authorization for all administrative or high-impact functions, and adopt secure-by-default configurations that disable legacy communication channels unless explicitly and narrowly justified. Regular architecture reviews and automated scanning for deprecated frameworks can help catch similar issues early in the development lifecycle.

Find out what's already
exploitable in your codebase.