Permission Conflation and Authority Leaks in Web Interfaces

75 concepts37 papers1 proposal

Modern application security relies heavily on boundaries. We isolate untrusted code inside sandboxes, enforce the Same-Origin Policy (SOP) in browsers, and rely on API contracts to keep data safe. However, a major class of security vulnerabilities arises not from broken cryptography or simple buffer overflows, but from architectural mismatches and permission conflation at the interfaces of these systems. When two different security paradigms interact—or when a broad permission model treats distinct entities as a single unit—subtle blindspots emerge that allow attackers to implicitly transfer authority and bypass explicit security gates.

Mismatched Security Paradigms: Access Control vs. Object Capabilities

To understand why these vulnerabilities occur, consider how modern web browsers manage security. As Adam Barth et al. demonstrated in Cross-Origin JavaScript Capability Leaks: Detection, Exploitation, and Defense, browsers operate under two conflicting security models simultaneously. The Document Object Model (DOM) uses an explicit access control model (checking the origin of a request before granting access), whereas the underlying JavaScript engine operates on an implicit object-capability model. In an object-capability system, if a script holds a direct pointer reference to an object, it inherently possesses the authority to manipulate it—no further origin checks are performed.

When implementation errors cause a JavaScript pointer to cross an origin boundary, an attacker gains immediate, implicit authority over the target origin, completely circumventing the SOP. This architectural friction means that even if a website's code is perfectly secure, a flaw in the underlying browser engine's pointer management can completely undermine its security.

Origin Conflation and the Fallacy of Uniform Trust

Another major blindspot stems from how web environments group code. Under the traditional Same-Origin Policy, all scripts loaded by a page are executed within the exact same security context. As Gayatri Priyadarsini Kancherla et al. point out in Least Privilege Access for Persistent Storage Mechanisms in Web Browsers, this creates a dangerous conflation of privileges. A host website might load a trusted core script alongside an untrusted third-party analytics script or advertisement. Because the browser treats the entire origin uniformly, the untrusted script inherits full read and write access to the host's persistent storage, including cookies and localStorage.

This lack of isolation allows attackers to exploit side channels. For instance, Sooel Son et al. showed in What Mobile Ads Know About Mobile Users that even when direct data reading is blocked, malicious scripts can use standard resource-loading tags as a "local resource oracle." By listening to success or error events when loading local files, an isolated script can probe the file system to infer highly sensitive user data, bypassing traditional origin-based isolation entirely.

To counter this, researchers argue for shifting from a script-centric security model to an object-centric one. Rui Zhao et al. propose in Beast in the Cage a fine-grained permission system built directly into the browser engine to lock down individual UI elements and data stores, preventing unauthorized manipulation even from compromised third-party libraries or extensions.

Bridging the Gap: WebViews as Confused Deputies

The danger of mismatched boundaries escalates significantly when web content interacts with native operating systems through hybrid mobile applications. Developers frequently embed WebViews inside mobile apps and build custom bridges to allow web-based scripts to invoke native system functions.

As Claudio Rizzo et al. discovered in BabelView, these JavaScript-to-native interfaces essentially act as public APIs exposed to any script running inside the WebView, regardless of its origin. If an attacker can inject code via a standard cross-site scripting (XSS) vulnerability, they can escalate their access to execute native system functions with elevated permissions. The native application becomes a "confused deputy," executing malicious file system modifications or launching external applications on behalf of the untrusted web script.

Guangliang Yang et al. expanded on this in Automated Generation of Event-Oriented Exploits in Android Hybrid Apps, demonstrating how web events can be chained together as gadgets to manipulate an app's internal native state. Furthermore, Yoonjung Choi et al. highlighted in PhishinWebView that these embedded environments often lack the robust, multi-layered anti-phishing protections found in standalone browsers, leaving users highly vulnerable to targeted evasion tactics.

Developer Blindspots and Semantic API Misuse

Why do these architectural gaps persist? A significant part of the problem lies in how developers interact with complex APIs. Yuriy Brun et al. studied this phenomenon in Blindspots in Python and Java APIs Result in Vulnerable Code, revealing that APIs often contain subtle, counter-intuitive behaviors—"blindspots"—that lead developers to write insecure code. Crucially, the authors found that professional experience and formal education do not mitigate this tendency, indicating a fundamental breakdown in how API specifications are understood and applied.

When developers misunderstand these subtle behaviors, they introduce critical usage violations. For example, Insu Yun et al. (APISan) and Binbin Zhao et al. (UVSCAN) demonstrated that failing to verify return values or neglecting strict call sequences in complex APIs remains a primary driver of vulnerabilities like privilege escalation and man-in-the-middle attacks across both desktop software and IoT firmware.

Exploiting Multi-Format and Cross-Tier Representations

Finally, attackers exploit boundaries by manipulating how different layers of an application interpret data formats. A prime example is the use of polyglot files. As Harun Oz et al. explained in (In)Security of File Uploads in Node.js, a polyglot file is simultaneously valid in two distinct formats—such as a valid JPEG image that also contains executable JavaScript.

+-------------------------------------------------------+
|                 POLYGLOT FILE GADGET                  |
+-------------------------------------------------------+
|  1. Image Headers (Valid JPEG according to Server)    |
|  2. Binary Image Data                                 |
|  3. Embedded Script: <script>alert('XSS')</script>    |
+-------------------------------------------------------+
                           |
        Uploaded to Server | Bypasses type check
                           v
+-------------------------------------------------------+
|                 CLIENT-SIDE BROWSER                   |
+-------------------------------------------------------+
|  Interprets file as Script -> Executes Malicious Code |
+-------------------------------------------------------+

When a user uploads this file, the server-side validation checks the image headers and deems it safe because the server does not execute it. However, when the browser renders the file, it interprets the embedded script, executing a client-side XSS attack.

Similarly, security models often misclassify risks based on execution assumptions. Chendong Yu et al. showed in File Hijacking Vulnerability: The Elephant in the Room that developers often treat file read operations as low-risk compared to file execution. Yet, hijacking a file that an application merely reads can allow an attacker to inject malicious configurations or force URL redirections.

This cross-tier data manipulation is also evident in client-side prototype pollution. As Zifeng Kang et al. observed in Probe the Proto, vulnerabilities originating within client-side JavaScript can alter shared data structures and propagate risks directly across application tiers, subverting the integrity of the entire system. Furthermore, as Dolière Francis Somé demonstrates in MatriXSSed: A New Taxonomy for XSS in the Modern Web, manipulating specific HTTP headers like Service-Worker-Allowed can allow a script restricted to a specific subdirectory to override default directory-level restrictions and escalate its authority to manage network requests for an entire domain.

Key Foundational Work

Cross-Origin JavaScript Capability Leaks: Detection, Exploitation, and Defense (2009) — contributed 3 concept elements to this direction.
xBook: Redesigning Privacy Control in Social Networking Platforms (2009) — contributed 1 concept elements to this direction.
Securing Frame Communication in Browsers (2008) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_api_blindspots_01bbeaa5,
  title = {API blindspots},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/api-blindspots/rdr_01bbeaa5b4624ea88a7065ec46759773},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_api_blindspots_01bbeaa5_v1,
  title = {API blindspots},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/api-blindspots/rdr_01bbeaa5b4624ea88a7065ec46759773/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake