Vulnerabilities in Local Inter-Process Communication Channels

This direction is merged into another direction: sensitive infrastructure exposure. Its last version stays readable and citable here.

Version 1 of 17 papers15 conceptsfrozen 2026-10-04

Modern operating systems rely on sandboxing to isolate applications, ensuring that one malicious app cannot easily peek into the files of another. However, applications rarely exist in total isolation; they must communicate with the system, with other apps, and between their own internal components. This "inter-process communication" (IPC) creates a hidden attack surface. When these communication channels lack robust authentication or are improperly configured, they become "backdoors" that bypass the very sandboxing meant to protect the user.

The Failure of Implicit Trust

The core issue is a gap between isolation and authentication. While a sandbox isolates data at rest, the operating system often fails to provide a standard way to verify the identity of the parties at either end of a communication pipe.

In the Apple ecosystem, Luyi Xing and colleagues identified this as Unauthorized Cross-App Resource Access (XARA). They found that while OS X and iOS apps are strictly sandboxed, the channels they use—such as local WebSockets or custom URL schemes—often lack sender verification. A malicious app can "squat" on a communication endpoint intended for a legitimate app, intercepting sensitive data like password tokens or Keychain secrets because the system does not enforce unique ownership of these local channels.

Intent Hijacking and Privilege Escalation

On Android, the primary mechanism for this communication is the "Intent." Applications use intents to request actions from other components. However, as William Enck, Damien Octeau, and their team discovered in A Study of Android Application Security, these broadcasts are often unencrypted and unauthenticated. This allows a passive observer app on the same device to "sniff" private data as it moves between components.

Beyond passive sniffing, these interfaces can be actively exploited. Ammar Askar and the team behind MALintent demonstrated that because these IPC interfaces often lack input validation, a low-privileged app can send "fuzzed" or malicious intents to a high-privileged app. This can trigger unauthorized actions, such as leaking private messages from WhatsApp or Chrome, effectively using the IPC channel to jump across trust boundaries.

The Localhost Exposure Gap

A common developer shortcut is to use local network ports (TCP/UDP) for communication between a background service and a user interface. This is particularly common in DRM systems and mobile apps.

The danger arises from how these ports are "bound" to the device's network interfaces. Daoyuan Wu and Debin Gao found that many Android apps incorrectly bind to the "any-interface" address (0.0.0.0) instead of the "local loopback" (127.0.0.1).

  • Loopback (127.0.0.1): Limits communication to the device itself.
  • Any-interface (0.0.0.0): Opens the port to the entire local Wi-Fi or cellular network.

This mistake transforms a local communication channel into a remote vulnerability. Joe Cho-Ki Yau noted that even when restricted to the local host, if the communication isn't isolated, an adversary on the same machine can still sniff the data stream.

From Software Leaks to Physical Hijacking

The risks of unauthenticated local communication are not limited to data theft; they extend to physical safety in embodied AI and robotics. Junchao Li and Boyang Ma audited the Unitree Go2 robot and found that it relied on unauthenticated local ports for internal relaying of commands.

Because these internal ports were exposed and lacked authentication, a malicious application on the same network could bypass the robot's primary security and inject motion commands directly. This demonstrates a critical principle: even if an AI model is "aligned" and safe, the underlying system is only as secure as the channels connecting its parts. If the "nerves" of the system—its local IPC—are open to injection, the entire entity can be hijacked.

Papers in this version

History & citationVersion 1 · 2026-10-04

Merged into another direction · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_vulnerabilities_in_local_inter_process_c_81735091,
  title = {Vulnerabilities in Local Inter-Process Communication Channels},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/vulnerabilities-in-local-inter-process-communication-channels/rdr_81735091086a444e8b2018877e4c54a7},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_vulnerabilities_in_local_inter_process_c_81735091_v1,
  title = {Vulnerabilities in Local Inter-Process Communication Channels},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/vulnerabilities-in-local-inter-process-communication-channels/rdr_81735091086a444e8b2018877e4c54a7/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}