Papers for

web browser developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Browser immune system detects web threats using onsite AI model

Browser Immune System (BIS): Innate and Adaptive Threat Detection in the Browser with a Cybersecurity Transformer

Abstract: Security decisions about a web page are best made where the page is: in the browser, before anything leaves the machine. We present the Browser Immune System (BIS), a browser extension that screens navigation with a cybersecurity transformer running entirely on the user's GPU, and alias-web, the model that powers it: a 4B-parameter model that starts from the dual-regime cybersecurity transformer (CT0), extends its public release alias3-micro with a context-category sensor, and is quantised to 4 bits and compiled to a 2.44 GB graph for WebGPU. alias-web is the first in-browser realisation of that model's typed decision mode, System 1, with its official pieces: the marker-token mapping, the complete pointer head and the final normalisation that the exported graph omits. It answers a typed security question in about 150 ms on a laptop GPU, and the same weights generate explanations at 10.5 tokens/s on demand. BIS treats the model as an immune system: an innate response, one System 1 question per threat class, runs on every page; an adaptive response, System 2 text, explains a verdict only when the user asks. On BISBENCH-8, eight synthetic sites of which six execute real but harmless malicious behaviour and two are adversarial controls, BIS returns the expected page verdict on 7/8 sites with both controls green and a class-level micro-F1 of 0.71, scans a page in 0.9 to 6.4 s, and gives identical verdicts across samples and across Chrome and Firefox. Single-variable diagnostics trace both benchmark errors to what the model was shown and, with a first pass over eleven real public pages, show that two of the seven questions answer yes on ordinary scripts and login forms: specificity on the real web is the open problem. We report every error, the engineering obstacles between a research checkpoint and a working extension, and what the evidence does not yet support.

Wed 11 NovCryptography and Security
The gist
Websites can sometimes behave badly or try to trick your computer, and it's safest to catch these problems right inside your browser before anything happens. The authors built a browser extension called Browser Immune System (BIS) that uses a smart AI model running locally on your computer's graphics processor to quickly check each page you visit for security threats. BIS uses a two-step approach: a fast initial check for known threat types and a slower, detailed explanation only when you want to understand the warning. Their tests show BIS can reliably spot threats on test sites and works similarly across different browsers, though some normal web features still confuse it.
Open → 2611.15302v1

Information flow control secures browser agents from attacks and data leaks

SPIDES: Information-Flow Control for Browser Agents

Abstract: Browser agents automate complex workflows by reading and acting on arbitrary page content, but this flexibility exposes them to prompt injection attacks and unintended data exfiltration. Recent work argues that LLM-driven browser agents erode traditional web security boundaries such as the Same-Origin Policy (SOP) by acting across origins with the user's authority and no built-in isolation. We argue that restoring SOP is neither sufficient (a same-origin public sink can leak private data) nor necessary (legitimate tasks require authorized cross-origin flows) for protecting the security of users. We propose SPIDES, which instead enforces information-flow control by gating primitive browser actions such as typing, clicking and navigating on labels propagated from element-level HTML confidentiality and integrity annotations. Untrusted and confidential content is masked from the agent's context, while policies block unauthorized flows, providing security guarantees against both prompt injection and data exfiltration that hold independently of the model driving the agent. To evaluate SPIDES and baseline defenses under a common threat model, we build MicroNet, a closed ecosystem of 28 interlinked websites with element-level ground-truth labels and paired benign/adversarial tasks. SPIDES achieves 0% attack success rate by design while retaining high task completion rate and autonomy. Our findings demonstrate that information-flow control is an effective technique to extend web security to browser agents, gaining on autonomy and utility against state-of-the-art baselines. The source code and data are openly accessible at https://github.com/microsoft/SPIDES.

Fri 16 OctCryptography and SecurityArtificial Intelligence
The gist
Browser agents act on websites to automate tasks but can be tricked into leaking private data or performing harmful actions. The authors show that simply relying on traditional web security rules is not enough or always practical. They built SPIDES, a system that controls what data the agent can see and act on by marking parts of webpages with security labels. This approach stops attacks and protects data without blocking useful actions, no matter what AI model drives the agent.
Open → 2610.24277v1

Base64 decoding speeds up internet data parsing with whitespace handling

Fast Forgiving Base64 Decoding with SIMD Instructions

Abstract: On the Internet, we use the Base64 format to represent binary data (e.g., images or cryptographic keys) as text. The ES2026 JavaScript standard, following the WHATWG forgiving-base64 rules, requires decoders to ignore ASCII whitespace while rejecting other non-alphabet characters. Prior SIMD Base64 decoders assume whitespace-free input. We present a block-oriented decoding algorithm that removes whitespace inside the SIMD loop: clean 64-character blocks are decoded directly, while blocks with ignorable characters are compacted into a small stack buffer. We provide implementations for x64 (SSSE3 through AVX-512 VBMI2), ARM NEON, and LoongArch. Our C++ decoder reaches up to 94 GB/s on recent AMD Zen 5 processors. In Node.js 25, integration of our decoder raises Uint8Array.fromBase64 throughput by up to 6x compared with Node.js 19. The implementation has been adopted by major browsers and JavaScript runtimes.

Mon 12 OctData Structures and AlgorithmsCryptography and Security
The gist
Base64 is a way to turn complex data like images into plain text so computers can read it easily. Usually, computers expect this text without spaces, but web rules say spaces should be ignored when decoding. The authors created a faster method that can skip spaces while decoding Base64 data all at once using special computer instructions. Their method works on different types of processors and makes decoding much quicker in JavaScript environments used on many websites and apps.
Open → 2610.17406v1

JavaScript engine flaws reveal how attacks chain and spread

When Flaws Cascade: Understanding Vulnerabilities and Exploitation Chains in JavaScript Engines

Abstract: JavaScript engines are pivotal to modern web browsers, enabling the execution of dynamic and interactive web applications. However, their complexity and widespread adoption make them prime targets for attackers exploiting vulnerabilities. While existing research has focused on detecting vulnerabilities of JavaScript engines, a significant gap remains in systematically understanding the characteristics of these vulnerabilities, including their symptoms, root causes, and exploitability. This paper bridges this gap by presenting the first comprehensive empirical study on vulnerabilities in JavaScript engines, investigating their characteristics and potential exploitation strategies. We construct a dataset comprising 241 vulnerabilities across four mainstream JavaScript engines from 2017 to 2024. Through in-depth analysis, we first develop taxonomies for symptoms and root causes. Building on this understanding, we investigate the exploitability of these vulnerabilities, identifying key prerequisites and extracting vulnerability trigger chains that demonstrate how logical errors propagate into memory safety violations. Additionally, we analyze the mitigation strategies to counter these exploits. Finally, we summarize key implications for various stakeholders, including developers and researchers, offering actionable insights to improve the security and resilience of JavaScript engines.

Wed 7 OctCryptography and SecuritySoftware Engineering
The gist
JavaScript engines help run interactive websites but have many bugs that attackers try to exploit. The paper studies 241 real bugs in four popular engines to understand how problems start, what they look like, and how attackers chain them together to cause bigger security issues. The authors also analyze how these bugs can be stopped and offer advice to make engines safer. This helps developers protect browsers from complex attack strategies.
Open → 2610.10844v1

Faith aligned browser shapes muslim user trust and internet use

Imagining a Muslim Internet: Trust, Autonomy, and Segregation in a Faith-Aligned Browser

Abstract: Religiously branded platforms raise important questions about trust, usability, and autonomy when technology is built around a specific faith. Prior HCI work on Islam and Muslim technology has focused on single-purpose tools such as prayer, scripture, and health apps, leaving infrastructures like browsers, which shape a user's relationship with the Internet, unexamined. We address this gap through semi-structured interviews with 16 users of Kahf Browser, a faith-aligned browser designed to support Muslims' online activities. Findings show religious identity motivates adoption but does not sustain it. Trust is not fixed by religious branding but shifts over time based on the browser's functionality, and users take pride in Muslim-built infrastructure. Building on these insights, we introduce porous digital segregation: a model where users seek not a sealed alternative internet but a protected default with selective exit mechanisms. We conclude by connecting findings to broader issues in faith-aligned technology and offering design recommendations.

Sun 4 OctHuman-Computer Interaction
The gist
The paper looks at a special web browser made for Muslim users called Kahf Browser. It studies why people start using this browser, how their trust changes over time, and how the browser supports both religious and everyday internet activities. The authors found that people like using Muslim-built internet tools but don’t want a completely separate internet. Instead, they want a protected space that still allows some access to the wider internet. The paper offers ideas on how to design technology that respects faith while giving users choices.
Open → 2610.05444v1

Visual detection improves phishing website identification with yolo v8

A Computer Vision Approach to Visual Fraud Detection in Phishing Websites Using YOLOv8

Abstract: Phishing remains one of the most common vectors for financial and identity fraud, and most detection systems still rely on inspecting a page's URL, HTML markup, or domain registration history. These signals are easy for an attacker to rotate or obfuscate, and they say very little about what actually convinces a victim to hand over a password or a card number: the way the page looks. This paper describes a visual, image-based approach to phishing detection that treats a rendered webpage the same way a human eye would, as a picture that either matches a trusted brand or doesn't. A YOLOv8 convolutional neural network was trained to classify full-page website screenshots as phishing or legitimate based on layout, logo placement, color scheme, and login-form structure, rather than on text extracted from the page. The system reached 92% classification accuracy on a held-out test set, processed a single screenshot in roughly 100 milliseconds, and, after a round of data augmentation aimed specifically at lighting, compression, and scaling variation, cut the false-positive rate by 11% relative to the pre-augmentation baseline. The paper walks through the dataset construction, the augmentation strategy, the model architecture and training setup, and the resulting performance, and closes with a discussion of where this kind of visual detector fits alongside, rather than instead of, existing URL- and content-based defenses.

Sun 27 SeptArtificial IntelligenceComputer Vision and Pattern Recognition
The gist
Phishing websites try to trick people by looking like real sites to steal passwords or credit card numbers. Instead of checking website addresses or code, the authors used a computer vision method that looks at website screenshots just like a person would. Their system learned to tell real sites from fake ones with 92% accuracy by focusing on logos, colors, and layout. They also made the system better at avoiding false alarms by training it on a variety of images. This helps add a new layer of protection alongside existing detection methods.
Open → 2609.34015v1

Agents leak private info through website behavior despite warnings

AgentTell: Behavioural Side-Channel Leakage in Browser-Use Agents

Abstract: Browser-use agents often carry information in their context as they move between websites. While it may be necessary for task completion, it also creates a privacy risk, especially when the information contains a private fact regarding the user. For example, an agent may learn a user's affiliation after reading a membership record. If it later selects a registration option specific to that affiliation on another website instead of a general option, the information gets leaked. In this work, we define and study behavioural side-channel leakage in browser-use agents, where an agent's actions inadvertently reveal private information (secret) retained from a prior website, despite an explicit instruction not to disclose it. We introduce AgentTell, a benchmark of 20 scenarios and 100 tasks in which an agent acquires a secret on one website and then completes a task on another website that offers secret-specific actions alongside a general action that reveals nothing. Our evaluation across 9,760 sessions on six backbones shows that agents carrying a secret reveal it through their actions in 61.1% of sessions. Even when agents explicitly state in memory that the secret must not be shared, they still reveal it in 56.7% of those sessions. Moreover, in 34.5% of leaking sessions, their final responses falsely assure users that the secret was not disclosed. These findings show that agents often fail to recognize side-channel leakage as a privacy risk.

Sat 26 SeptCryptography and SecurityArtificial Intelligence
The gist
Sometimes, web browsing helpers called agents remember private details from one website and accidentally reveal them on another website by how they act. The authors studied these agents using a set of examples where agents had to choose options that could leak secrets, even when told not to share them. They found that most agents still ended up revealing private information over half the time, and often even lied about keeping it secret. This shows that these agents can unintentionally put users’ privacy at risk by how they behave across websites.
Open → 2609.32915v1

WebGPU testing finds browser bugs using smart test changes

Dynamic Conformance Testing of WebGPU Through Specification-Driven Mutation

Abstract: WebGPU is a low-level graphics and compute API that exposes modern GPU functionality to web applications. While the official WebGPU Conformance Test Suite (CTS) focuses on well-formed usage under the WebGPU specification, it is not designed to stress implementations with semantic edge cases or adversarial inputs. General-purpose fuzzers, in contrast, struggle with WebGPU because of its complex graphics stack and multi-process architecture. We introduce LANTERN, a specification-guided dynamic conformance testing framework that mutates CTS tests using constraints extracted from the WebGPU specification. LANTERN extracts explicit syntactic API rules from WebIDL definitions and recovers semantic constraints, such as command ordering and object lifetimes, from natural-language specification text. Selected rules guide AST-located textual transformations that generate both valid and intentionally invalid CTS variants. We execute the resulting tests at scale on AddressSanitizer-instrumented Chromium to discover bugs. Our evaluation discovers three reproducible bugs, including a heap corruption, in Chromium versions current at the time of study. These results demonstrate that syntactically seeded, semantics-aware mutation of conformance tests provides a way to uncover browser bugs during WebGPU testing.

Tue 22 SeptSoftware EngineeringCryptography and Security
The gist
WebGPU allows web apps to use advanced graphics features from your computer’s graphics card. The current official tests check for normal, correct usage but may miss tricky or rare bugs. The authors created a tool named LANTERN that changes these tests based on the official WebGPU rules and description to try new, edge-case scenarios, some intentionally incorrect. Running these changed tests on a popular browser found real bugs, showing this approach can improve browser reliability for WebGPU.
Open → 2609.25520v1

JavaScript engine fuzzing improved by smart state-aware instrumentation

State-Aware Fuzzing of JavaScript Engines with LLM-Guided Instrumentation

Abstract: The security of the modern web depends on the correctness of JavaScript (JS) engines, yet these complex systems remain vulnerable to high-impact bugs. A critical limitation of state-of-the-art fuzzers is the coverage plateau: once a fuzzer saturates the control-flow graph, edge coverage loses its ability to guide discovery. Because complex engine behaviors, such as JIT optimization tiers and hidden class transitions, often share identical edge coverage, standard coverage metrics are blind to the distinct internal states required to trigger deep errors. To bridge this gap, we present StateLens, a framework that employs Large Language Models (LLM) to automate the discovery of deep internal states. Blindly placing instrumentation probes at all states is infeasible due to the vast state space and the high runtime overhead. StateLens introduces a novel agent-based reasoning pipeline that emulates the intuition of a security researcher. By iteratively traversing code and developer comments, our agents intelligently select high-value instrumentation targets, effectively separating logic-driving state variables from irrelevant data. This results in synthesizable, high-signal feedback probes that map the engine's hidden configurations. This instrumentation feeds a dual-feedback mechanism, effectively guiding the fuzzer toward unexplored engine semantics. Our evaluation confirms that StateLens significantly outperforms state-of-the-art fuzzers and uncovering 68 new bugs.

Mon 21 SeptCryptography and Security
The gist
JavaScript engines that run web code are very complex and sometimes have hidden problems that can cause security bugs. The researchers found that traditional testing methods get stuck because they can't tell apart different internal states of the engine that look the same on the surface. They created a new way called StateLens that uses large language models to find important internal engine details automatically, adding sensors that help tests explore deeper hidden bugs. Their approach helps the testing tools find more serious errors by understanding what’s really happening inside the engine.
Open → 2609.24550v1

Cpu trojans activated by high-level code executed in browsers

Exploiting Software-level Abstractions To Support Practical Hardware Trojan Attacks

Abstract: Hardware trojan (HT) attacks against CPUs typically assume threat scenarios where an attacker targeting a system with a trojanized CPU is able to execute arbitrary code (i.e. machine-level instructions) to reliably interact with the implanted trojan. On end-user devices (i.e., mobiles, laptops), achieving arbitrary code execution in practice requires software exploits tailored to each specific target. Such strong adversarial premises reduce the generality of existing threat models casting doubt on CPU trojan attacks as a pragmatic threat vector. To push the envelope on HT attacks against client devices, we introduce the SURF class of CPU-trojans that can be activated without arbitrary code execution. Our key insight is that integer operations expressed in a high-level language can be mapped to microarchitectural side-effects distinguishable by a SURF trigger circuit. This observation unlocks HT activation via runtime engines, constrained environments executing untrusted high-level code. We demonstrate a SURF trojan inside a RISC-V processor and exploit JavaScript-level memory indexing operations inside Google's V8 engine to perform a code injection attack. Importantly, we show that SURF trojans remain effective across multiple JavaScript engine versions, enabling long-term compromise of endpoint devices. To facilitate research, we opensource SURF's design and supporting software.

Sat 19 SeptCryptography and Security
The gist
Most hardware trojan attacks assume the attacker can run any code on a device, which is hard to do in real-world users’ phones or laptops. The authors show a new kind of CPU trojan (called SURF) that can activate just by running certain high-level language instructions, like JavaScript code in a browser. They tested this on a RISC-V CPU and used JavaScript memory operations to trigger the trojan without needing full control over the device’s software. This means malicious hardware trojans could remain hidden and active across many browser versions, posing risks to everyday devices.
Open → 2609.23173v1

Gaussian process optimization improves word hyphenation patterns efficiently

The Art of Hierarchical Competing Patterns: Gaussian Process Optimization of Hyphenation

Abstract: Hyphenation patterns remain a compact and widely deployed solution for word breaking in typesetting systems, text processors, and web rendering engines, but their generation still depends on manually tuned patgen program parameter profiles. We formulate patgen profile selection as a black-box hyperparameter optimization problem and evaluate Gaussian-process Bayesian optimization for this task. The search objective combines a precision-oriented F_{1/7}-score with an explicit trie size-accuracy trade-off using a normalized trie-size penalty. We evaluate the method on 17 hyphenated word-list datasets covering 14 languages and multiple scripts. Against two strong hand-tuned profiles regenerated from the same 8/10 training split and evaluated on the same 1/10 held-out test split, the GP-optimized profiles improve F_{1/7} on 16 of 17 datasets and reduce trie size on all 17. The median optimized/baseline trie ratio is 0.407. A dataset-level sign test gives p = 1.37e-4; a separate budget-matched comparison on five representative datasets shows that systematic search is competitive and usually improves over the best hand-tuned profile under the fixed comparison objective. The results show that model-based optimization can make pattern generation more reproducible and less dependent on expert trial-and-error while keeping the accuracy-compactness trade-off explicit.

Mon 7 SeptComputation and LanguageDigital LibrariesMachine Learning
The gist
Breaking words correctly at the end of a line is important for neat text layouts, and this uses rules called hyphenation patterns. These rules usually need expert tuning, which can be slow and inconsistent. The authors show that a machine learning method called Gaussian-process Bayesian optimization can automatically find better rules that both improve accuracy and reduce rule size. They tested this on many languages and found it usually beats expert-made rules, making the process easier and more reliable.
Open → 2609.07638v1