The Native Menace: Host-to-Browser Cross-Boundary Attacks via Native Messaging
summary
The gist
Modern browsers are complex software platforms that users can customize through browser extensions to further expand their functionality.
In short
This research exposes critical security flaws in web browser native messaging, allowing non-privileged apps to intercept communications or launch confused deputy attacks against other native applications. The study systematically analyzes protocol weaknesses like manifest search order and lack of client validation, demonstrating real-world risks such as impersonating users for document signing and stealing password vault data.
Key concepts
- Native Messaging API
- A feature that allows a web browser extension to communicate with a native application installed on the user's system. The paper investigates how this communication protocol is fundamentally insecure, enabling malicious apps to misuse it.
- Manifest Search Order
- This flaw allows an attacker to place a malicious configuration file in the user-level directory. Because browsers search for extensions in a specific order, this allows the attacker's malicious manifest to 'shadow' or hide a legitimate extension, tricking the system into using the wrong code.
- Confused Deputy Attack
- This attack occurs when an app with high privileges is tricked into performing an action on behalf of a lower-privileged process. The research shows how Native Messaging can be exploited to make native apps perform unauthorized actions, such as signing documents or accessing sensitive data.
Terminology used across episodes
This episode discusses
- The Native Menace: Host-to-Browser Cross-Boundary Attacks via Native Messaging · Paper Radio
- Unauthorized Cross-App Resource Access on MAC OS X and iOS
The paper
The Native Menace: Host-to-Browser Cross-Boundary Attacks via Native Messaging · Read on arXiv
Jyotirmay Chauhan, Rownak Islam, Jason Polakis
University of Illinois Chicago
Modern browsers are complex software platforms that users can customize through browser extensions to further expand their functionality. Extensions derive their functionality from privileged browser APIs that expose powerful capabilities. Prior work has extensively studied how malicious webpages or extensions can target those capabilities. However, prior research has overlooked the NativeMessaging API, which allows extensions to create a communication channel that bridges the gap between web content rendered in the browser and native apps running on the user's machine. This API enables workflows that cross the browser's boundary to perform critical operations (e.g., digital signing) or exchange sensitive data (e.g., credentials). In this paper, we conduct the first, to our knowledge, empirical security analysis of NativeMessaging, and present a novel attack that allows a non-privileged malicious native app to misuse browsers' native messaging capabilities to stealthily intercept sensitive communications or launch confused deputy attacks against other native apps. To demonstrate the significant risk introduced by native messaging, we present a series of concrete attacks against popular and critical apps (e.g., 1Password, the European Union's eID system, Google Drive), whose browser extensions have more than 532 million cumulative downloads. Our attacks have severe ramifications, including full password vault leakage, and arbitrary document signing in governmental workflows. Fundamentally, these attacks are possible due to native messaging being built on top of an untrusted communication channel without providing a root of trust or enforcing some form of client attestation. Accordingly, we propose a straightforward mitigation technique of message encryption with out-of-band secret sharing, to prevent our attacks.
Transcript
Introduction to the show: ident: Security Radio. Generated commentary on the latest security and cryptography papers.
Nadia: I'm Nadia.
Elias: And I'm Elias, here with Priya.
Nadia: We're looking at the paper: "The Native Menace".
Elias: Here's the gist of the paper. Modern browsers are complex software platforms that users can customize through browser extensions to further expand their functionality.
Nadia: This paper presents a novel attack that allows a non-privileged malicious native app to misuse browsers’ native messaging capabilities to stealthily intercept sensitive communications or launch confused deputy attacks against other native apps.
Elias: The Core Research Focus The research focuses on the attack surface introduced by web browsers’ native messaging functionality.
Nadia: The authors conduct the first systematic empirical analysis of the NativeMessaging API, uncovering fundamental design flaws that expose users to significant risks.
Title and authors: Nadia: So we're looking at this paper now called "The Native Menace: Host-to-Browser Cross-Boundary Attacks via Native Messaging." It sounds like it’s diving deep into how these browser extensions can talk to native apps and where that communication breaks down.
Elias: Yeah, the authors are focusing on the design of the NativeMessaging API itself, showing that there are fundamental flaws in how it's built and deployed that leave users exposed. It’s not just about bad code; it’s about protocol issues.
Priya: What does this mean for us practically? Are we talking about a theoretical vulnerability or something that could actually happen right now when you use a browser extension?
Nadia: It's concrete, Priya. The paper presents a novel attack where an unprivileged app, meaning one without special permissions, can misuse these native messaging capabilities to secretly intercept communications or set up confused deputy attacks against other native apps.
Elias: That’s the core idea: a low-level app exploiting the mechanism meant to bridge the web and native worlds. They conduct an empirical analysis across Chrome v151 on macOS, Windows eleven Education Build ten point zero.twenty-six thousand two hundred and Firefox v154 on macOS.
Priya: So they’ve tested it in real environments, which is important because those kinds of protocol flaws can sometimes hide in the testing environment. What were the main design problems they found?
Nadia: They found several things that are pretty fundamental to how this whole system works. First, there’s a problem with the manifest search order where an attacker could shadow a privileged installation by dropping their own malicious manifest file in a user-level directory.
Elias: And second, they point out a lack of client validation. The protocol doesn't have built-in authentication, so any process that can establish this native messaging connection can pretend to be a legitimate extension.
Priya: That sounds like it opens the door wide for impersonation then. Can an attacker just pretend to be something they aren't?
Nadia: Exactly. They also found extension ID spoofing, where a malicious extension could fake the target extension’s public key by using a malicious Chrome profile, and finally, message verification is missing because the protocol is stateless and doesn't check for message integrity on its own.
Elias: These findings lead them to develop two types of cross-boundary attack variants. One is bidirectional interception which is essentially a man-in-the-middle attack when the extension sends session specific values, requiring an attacker sitting between the native host and the target extension.
Priya: And there’s the unidirectional interception variant, which they say is applicable when the protocol uses fixed endpoints with predictable messages that lets an attacker mimic one of those endpoints.
Nadia: The implications here are pretty serious because they show concrete use cases against popular and critical applications. They demonstrated how adversaries can impersonate users in government services across the EU, Latin America, and India to sign legally binding documents for instance.
Title and authors: Elias: They also showed that this attack vector lets adversaries extract full password vaults from password managers and access or interfere with video conferencing sessions by obtaining authentication tokens.
Priya: So what’s the real-world impact for someone who just uses a browser every day? Is this something they need to worry about immediately?
Nadia: It means that if you rely on these native messaging features for things like digital signing or sensitive data exchange, your security is being challenged because of these design flaws.
Elias: To address this, the authors propose a few ways to harden the system. They suggest message encryption using out-of-band secret sharing as a primary mitigation strategy to protect against intercepted communications.
Priya: What else did they suggest for fixing those specific issues they found, like the manifest poisoning or the lack of validation?
Nadia: For manifest poisoning, they say you can neutralize it by setting kNativeMessagingUserLevelHosts to false in Chromium browsers or using MDM or Group Policy on Windows to restrict host resolution only to system level registrations, which requires administrator privileges for manipulation.
Elias: On the process invocation side, they suggest kernel enforced validation of the caller’s identity before the host starts running, mentioning things like Launch Constraints on macOS. They also propose moving key establishment out-of-band by having the extension and native host authenticate to a shared backend over TLS to get a per session symmetric key.
Priya: That sounds like a lot of work for developers to implement, but it’s about securing the actual communication channel, not just patching individual bugs. So, what is the big picture here regarding how we secure these cross-boundary interactions?
Nadia: It highlights that native messaging isn't just a convenience feature; it's an attack surface because of inherent flaws in its design and deployment. This paper, "The Native Menace: Host-to-Browser Cross-Boundary Attacks via Native Messaging," shows how a low privileged app can exploit these gaps to perform high impact actions like document signing impersonation or token theft.
Elias: The authors argue that the risk comes from trusting the protocol too much without proper client authentication and integrity checks. Their proposed fixes, like out-of-band key exchange, focus on making the communication channel itself trustworthy regardless of what's happening between the browser and native app.
Priya: It’s clear that for developers, they need to be much more rigorous about how they handle manifest files and how they validate every incoming message. The work shows that protocol design choices have severe real-world consequences for user privacy and security across multiple platforms like Chrome and Firefox.
Nadia: So, to wrap up this segment, the Native Menace paper lays out a clear path for attack by showing how flaws in native messaging allow non-privileged apps to intercept data or impersonate users in sensitive scenarios. We’ll take a quick break now and come back with another look at how other security research is addressing these types of cross-boundary threats.
The paper's summary: Nadia: So, this paper is really about how a regular app that doesn't even have special permissions can use the way web browsers talk to native programs to spy on stuff or mess with other apps.
Elias: Exactly. They’re looking at the Native Messaging API and showing that there are some serious design flaws in how it’s set up that leave people exposed. It’s not just a small bug; it's about the whole protocol being open to exploitation.
Priya: So, what does this mean for a regular user who thinks their browser is safe? Are we talking about something that could happen on their computer right now?
Nadia: We're talking about things like an attacker impersonating a government employee to sign legal documents across different regions, or someone stealing everything from a password manager. These aren't just theoretical risks; they’re concrete ways bad actors can get real-world access.
Elias: The authors found several core problems in the design, like how manifests are searched, and they pointed out there’s no built-in way to check if the app trying to connect is actually who it claims to be. That lack of client validation is a big deal for trust.
Priya: So if any process can just establish that connection, it can pretend to be anything? That sounds like a massive security hole. What about the actual communication itself?
Nadia: They found issues with message verification too. The protocol doesn't check if the messages were tampered with while they're in transit because it’s stateless and doesn't have that built-in integrity check. You could just change a message on the fly.
Elias: And for the attack, they developed two ways to do this cross-boundary thing. One is this bidirectional interception, which is basically a man-in-the-middle attack when data flows back and forth between the native host and the browser extension.
Priya: And the other one? The unidirectional one sounds different.
Elias: That one works when the protocol uses fixed endpoints with predictable messages, letting an attacker mimic just one of those endpoints easily. It shows how little structure is there to stop someone from pretending to be a legitimate partner in that conversation.
Nadia: To fix this, they suggest encrypting the communication and using some secret sharing for that key management. They also recommend restricting where apps can even look for the native host—making them only allowed if they have system-level permissions, which should stop those sneaky manifest poisoning attacks.
Elias: And they also want kernel validation on macOS to check who is actually trying to launch the host before it even gets a chance to run. It’s about making sure the identity of the caller is cryptographically verified at the protocol level.
Priya: So it sounds like a lot of work for developers to implement all those checks, but if they do, it closes a huge gap in how we secure these app integrations.
Nadia: That’s right. It shows that trusting the native messaging layer without these specific layers of validation is leaving critical personal and professional data wide open. Next up, we're going to look at some other papers focusing on how AI agents are handling long-term effects from authority evidence during commit time authorization.
The paper's improvements: Tom: So, now we’re looking at how these researchers are trying to fix the problems they found in that paper about Native Messaging vulnerabilities.
Nadia: They propose a few ways to harden the system, starting with stopping manifest poisoning by telling Chromium browsers not to look for hosts outside of system-level registrations. That should require admin or root privileges to manipulate anything.
Elias: And they also suggest kernel-enforced validation on macOS, similar to what you see in Launch Constraints, but they want that identity check done cryptographically at the protocol level by including a hash of the extension ID when authenticating messages.
Priya: That sounds like making sure the caller is who they say they are before any host code even starts running. Does that address the lack of client validation we talked about?
Nadia: It should, yes, by restricting process invocation based on identity verification. They also suggest moving key establishment out-of-band by having the extension and native host talk to a shared backend over TLS to get a session specific symmetric key.
Elias: That’s good because it addresses the message integrity problem we saw earlier. If they have to authenticate through a shared backend for every session, you can't just tamper with the flow without knowing the right key.
Priya: So, if they implement those measures, does it truly neutralize the risk of someone intercepting sensitive data or impersonating a user?
Nadia: It aims to do that by adding layers of cryptographic proof and stricter access control. They also mentioned using an attacker controlled browser profile with a spoofed extension whose Chrome ID matches the target to show how imitation can be done.
Elias: That's interesting because it shows how easily someone could perform that identity spoofing we talked about earlier, even by just setting up a fake profile in the browser.
Priya: It’s important that they show these specific mitigation techniques because just saying "encrypt it" isn't enough; you need to know exactly how that encryption and key sharing works in practice.
Nadia: Exactly. It shows the difference between a theoretical fix and something an engineer can actually implement on a production system. Now, let’s look at how this relates to those papers on AI agents making durable decisions based on past authority evidence during commit time authorization.
Conclusion: Tom: So we’re wrapping up this look at "The Native Menace: Host-to-Browser Cross-Boundary Attacks via Native Messaging."
Nadia: The paper shows that the way web browsers talk to native apps has some serious fundamental flaws that non-privileged apps can exploit to intercept communications or launch confused deputy attacks.
Elias: Right, they mapped out how an attacker can use those design weaknesses—like missing client validation and message verification—to get access where they shouldn't be.
Priya: So the big picture is that we need to stop trusting the Native Messaging API without adding these extra layers of security and identity checking.
Nadia: Exactly, because the paper gives us concrete examples of how this could lead to real-world issues like signing documents or stealing password vault data.
Elias: The mitigation strategies they proposed, like out-of-band secret sharing for encryption and kernel validation for process launching, are specific engineering solutions we can look at implementing.
Priya: I just hope those fixes are robust enough to handle the complexity of real-world deployments across different operating systems.
Nadia: That’s the challenge, I guess; making sure those security layers work consistently everywhere.
Elias: It does show that protocol design choices have very direct consequences for user privacy and security across different platforms like Chrome and Firefox.
Priya: It really highlights how crucial it is to look beyond just the surface functionality of an API to understand the underlying security assumptions.
Nadia: That’s what we’re aiming for with these papers, looking deep into how systems actually operate under pressure.
Elias: And that brings us to another area of interest, like how AI agents are handling durable effects based on authority evidence during commit time authorization.
More episodes
- 2608.27496-ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection
- Daily Summary for 2026-11-19
- 2607.07085-Is Randomness Necessary for Adaptive Data Analysis?
- The day in conversation for 2026-11-19
- Daily Summary for 2026-11-19
- 2609.10601-Threshold Choice, Not Sample Size, Bounds Trustless Verification of Nondeterministic Compound AI Workflows
- 2610.38786-Adversarial Process Disturbances at a Deployable Alarm Budget: Detector Evaluation on a Simulator and a Real Plant
- 2511.08660-Binary and Multiclass Cyberattack Classification on GeNIS Dataset
- 2604.27302-Static Attribution of Android Residential Proxy Malware Using Graph Kernels
- Daily Summary for 2026-11-18