/

CVE-2026-25551

Severity:

HIGH RISK

(7.8)

Insecure .NET Deserialization (CWE-502) in BarTender DataServiceSingleton Remoting Endpoint

CVE-2026-25551

Awaiting Analysis

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Local Privilege Escalation to SYSTEM via Remote Code Execution

Severity:

HIGH RISK

(7.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

BarTender 2021 R1 through 12.0.1 exposes an insecure .NET Remoting endpoint that uses BinaryFormatter with overly permissive type filtering, enabling unsafe deserialization of attacker-controlled data.

A low-privileged local user who can connect to the localhost-bound service on TCP port 7375 may send crafted BinaryFormatter payloads to execute arbitrary code with NT AUTHORITY\SYSTEM privileges.

Affected context

The vulnerability occurs in BarTender's DataServiceSingleton .NET Remoting endpoint hosted by BtSystem.Service.exe, which listens on localhost:7375.

It affects environments where:

  • BarTender 2021 R1 through 12.0.1 is installed and the Data Service is running.
  • The .NET Remoting channel is reachable locally by non-administrative users.
  • BinaryFormatter-based remoting remains enabled with permissive type filtering (TypeFilterLevel=Full).

The issue is limited to local attack paths, but any process able to open a TCP connection to 127.0.0.1:7375 can potentially interact with the vulnerable endpoint.

Exploit preconditions

  • Attack surface: Local-only TCP endpoint on 127.0.0.1:7375 (no direct remote network exposure).
  • Required access: A low-privileged local account capable of:
  • Running arbitrary user-level code or tooling.
  • Opening outbound connections to localhost on port 7375.
  • Trigger point: Sending crafted .NET BinaryFormatter payloads to the DataServiceSingleton .NET Remoting endpoint.
  • Why exploitation is possible: The Remoting endpoint is configured with:
  • BinaryServerFormatterSinkProvider (BinaryFormatter serialization).
  • TypeFilterLevel = Full, allowing deserialization of a broad range of types.

This configuration accepts attacker-supplied serialized objects and instantiates them in the context of the service, enabling gadget-chain based code execution as NT AUTHORITY\SYSTEM.

Why this happens

The root cause is the use of insecure .NET Remoting with BinaryFormatter in a privileged Windows service, combined with permissive type filtering.

By exposing a BinaryFormatter-based BinaryServerFormatterSinkProvider endpoint with TypeFilterLevel=Full, the service effectively trusts serialized object graphs received over the network (even if bound to localhost).

This maps directly to CWE-502: Deserialization of Untrusted Data, where untrusted serialized data is passed into a powerful deserialization mechanism that can:

  • Instantiate attacker-controlled types.
  • Trigger gadget chains that execute code during or immediately after deserialization.

Because the deserialization executes within the SYSTEM-level service process, any successful exploitation results in a local privilege escalation from a low-privileged user to NT AUTHORITY\SYSTEM.

Potential impact

  • Local users could execute arbitrary code with NT AUTHORITY\SYSTEM privileges.
  • Attackers may install or run additional malware with full system control.
  • Elevation from limited domain or local accounts to complete machine compromise.
  • Tampering with BarTender service configuration, print jobs, or associated data.
  • Using the compromised host as a pivot point for further lateral movement inside the network.

General mitigation guidance

Mitigation generally focuses on eliminating unsafe deserialization paths and reducing the privileges and exposure of inter-process communication mechanisms:

  • Avoid using BinaryFormatter and legacy .NET Remoting for new or existing IPC endpoints; migrate to safer serialization technologies (e.g., JSON serializers with explicit models or gRPC with defined contracts).
  • When deserialization is unavoidable, restrict deserializable types to a minimal, known-safe set, and avoid permissive settings like TypeFilterLevel=Full.
  • Introduce strict input validation and message framing on IPC channels so that only expected, schema-conforming messages are processed.
  • Run background services with the least privileges necessary instead of NT AUTHORITY\SYSTEM, reducing the impact of potential exploitation.
  • Restrict local access to high-privilege service ports using OS-level firewall rules, access control lists, or broker processes that enforce authentication and authorization.
  • Apply hardening measures such as service isolation, sandboxing, or dedicated service accounts with limited file system and registry rights.

How teams detect issues like this

Detection can leverage both code-centric and host-centric approaches:

  • Static analysis and code review:
  • Search for .NET Remoting usage with BinaryServerFormatterSinkProvider, BinaryFormatter, or similar serializers handling data from sockets or other IPC channels.
  • Flag configurations that specify TypeFilterLevel=Full or otherwise allow broad type deserialization.
  • Review service code for deserialization of data received over network endpoints, even if bound to localhost.
  • Automated analysis tools:
  • Use SAST tools or linters configured to detect unsafe deserialization patterns, particularly BinaryFormatter and legacy remoting APIs.
  • Integrate security checks into CI/CD pipelines to prevent the introduction or reintroduction of BinaryFormatter-based IPC.
  • Runtime and host monitoring:
  • Monitor privileged services (especially those running as SYSTEM) for abnormal child process creation or unusual command-line execution patterns indicative of code execution payloads.
  • Capture and inspect connections to localhost service ports, focusing on unexpected or malformed traffic to high-privilege endpoints like port 7375.
  • Configuration and policy checks:
  • Periodically audit service configurations for deprecated serialization mechanisms and ensure adherence to secure IPC design standards.

Sources

SourceLink
gist.github.comgist.github.com/VAMorales/dde5b1c0415a8505ccd6fafdb095a618
portal.seagullscientific.comportal.seagullscientific.com/downloads/bartender
vulncheck.comvulncheck.com/advisories/seagull-software-bartender-deserialization-privilege-escalation-via-net-remoting-service

Frequently asked

questions

No, in the documented configuration the vulnerable .NET Remoting endpoint is bound to localhost only. The attack surface is restricted to processes running on the same machine, although a remote attacker who has already achieved a foothold (e.g., a low-privileged shell) could leverage it for privilege escalation.

The attacker needs only a low-privileged local account capable of opening a TCP connection to 127.0.0.1:7375. No administrative rights are required to trigger the deserialization vulnerability.

The most robust approach is to remove BinaryFormatter-based .NET Remoting entirely and replace it with a safer, contract-based communication mechanism that uses explicit message schemas and avoids general-purpose object deserialization. Additionally, run service components with reduced privileges so that, if an IPC channel is compromised, the impact is limited.

Avoid general-purpose serialization formats that can instantiate arbitrary types, particularly in high-privilege services. Prefer data-centric serializers with strict, versioned schemas; implement whitelisting of allowed message types; enforce least privilege for services; and include checks for unsafe deserialization patterns in code review guidelines and automated security tooling.

Find out what's already
exploitable in your codebase.