The WASM Cloak: Evaluating Browser Fingerprinting Defenses Under WebAssembly based Obfuscation

TL;DR

This paper evaluates how WebAssembly obfuscation affects browser fingerprinting defenses, revealing that research-based detectors are somewhat vulnerable while practical defenses remain effective, highlighting gaps and future challenges.

Contribution

It systematically assesses the impact of WASM obfuscation on fingerprinting defenses, bridging the gap between academic and practical detection methods.

Findings

Research-based detectors show moderate vulnerability to WASM obfuscation.

In-browser and native defenses remain fully effective against WASM-based fingerprinting.

WASM obfuscation exposes gaps in existing academic fingerprinting detection strategies.

Abstract

Browser fingerprinting defenses have historically focused on detecting JavaScript(JS)-based tracking techniques. However, the widespread adoption of WebAssembly (WASM) introduces a potential blind spot, as adversaries can convert JS to WASM's low-level binary format to obfuscate malicious logic. This paper presents the first systematic evaluation of how such WASM-based obfuscation impacts the robustness of modern fingerprinting defenses. We develop an automated pipeline that translates real-world JS fingerprinting scripts into functional WASM-obfuscated variants and test them against two classes of defenses: state-of-the-art detectors in research literature and commercial, in-browser tools. Our findings reveal a notable divergence: detectors proposed in the research literature that rely on feature-based analysis of source code show moderate vulnerability, stemming from outdated datasets or a lack of WASM compatibility. In contrast, defenses such as browser extensions and native browser features remained completely effective, as their API-level interception is agnostic to the script's underlying implementation. These results highlight a gap between academic and practical defense strategies and offer insights into strengthening detection approaches against WASM-based obfuscation, while also revealing opportunities for more evasive techniques in future attacks.

Tables

Table 1. TABLE I: Summary of the conversion rules.

Rule #	Target JS Pattern	Purpose
1	Literal-initialized variables	Offload literals to WASM and enable memory-based access
2	Sensitive function calls (e.g., eval, Function)	Obfuscate sensitive invocations through indirect reconstruction
3	Arrays of integers/floats	Move array data to linear memory to obscure structure
4	Simple if-else statements	Offload control flow into WASM while preserving logic
5	for loops	Obfuscate iteration logic by offloading loop structure
6	while loops	Enable indirect evaluation of loop condition and body
7	Function calls without return values	Wrap and obscure standalone invocations via WASM
8	Class definitions	Obfuscate class declarations via string storage in WASM and eval
9	Function declarations/expressions	Translate logic-heavy functions using LLMs to AssemblyScript
10	Fingerprinting-relevant member expressions	Obfuscate access to high-signal APIs (e.g., canvas.toDataURL)
11	Dynamic code generation calls	Convert runtime-generated expressions to indirect eval
12	Fingerprinting relevant code inside strings (e.g., “canvas”)	Mask known fingerprinting substrings via split reconstruction
13	Hex-encoded property accesses using screen	Detect and obfuscate fingerprinting via encoded identifiers

Table 2. TABLE II : Conversion pipeline performance per sample subset.

Sample Subset No.	Success Rate (%)	Conversion Coverage (%)	Mean Conversion Time (s)	Mean Validation Time (s)	Size Change
1	84.05%	20.21%	3.22	0.69	26.02%
2	86.75%	25.43%	3.75	0.72	19.47%
3	88.51%	21.46%	3.64	0.65	22.97%
4	84.42%	28.40%	3.40	0.74	27.91%
5	86.14%	28.01%	3.39	0.77	32.99%
6	85.80%	24.45%	3.60	0.68	15.53%
7	85.33%	30.01%	3.07	0.74	30.14%
8	85.71%	22.10%	3.45	0.65	17.99%
9	85.92%	23.91%	2.83	0.72	34.65%
10	84.93%	26.07%	4.13	0.59	17.69%
Mean $\pm$ SD	$85.76\%\pm 1.26$	$25.01\%\pm 3.20$	$3.45\pm 0.36$	$0.70\pm 0.05$	$24.54\%\pm 6.81$

Table 3. TABLE IV : DeepFPD model feature importance.

AST Tuple	Feature Importance
MemberExpression:screen	0.0214
MemberExpression:fillText	0.0192
CallExpression:canvas	0.0186
MemberExpression:language	0.0145
MemberExpression:localStorage	0.0118
MemberExpression:appName	0.0116
MemberExpression:platform	0.0110
MemberExpression:fillStyle	0.0106
MemberExpression:colorDepth	0.0105
MemberExpression:fillRect	0.0089

Table 4. TABLE VII: Summary of ablation study on conversion rules.

Conversion Rule	Success Rate (%)	Conversion Coverage (%)	Mean Conversion Time (s)	Mean Validation Time (s)	Size Difference (%)
obfuscate_functions	33.21	0	1.3774	0.5546	3.01
replace_callee	41.79	0	1.0015	0.5389	2.96
replace_canvas_api_calls	16.79	0.1255	0.6949	0.6314	199.84
replace_class_defs	52.99	0.0002	0.7069	0.6010	2.54
replace_float_arrays	23.88	0.0005	0.6744	0.5027	25.77
replace_for_loops	24.63	0	0.8179	0.3823	11.27
replace_function_calls_with_no_return	24.25	0.3335	0.6290	0.5334	-45.62
replace_func_defs	9.70	0.2154	3.4002	0.3589	21.48
replace_if_else	19.78	0.0147	0.7282	0.3824	11.30
replace_int_arrays	23.13	0.0007	0.6694	0.4910	25.71
replace_literals_recursive	21.64	0.0216	0.6909	0.4844	13.26
replace_obf_screen	53.73	0.0003	1.0849	0.5796	3.30
replace_while_loops	51.49	0.0021	1.7270	0.5618	2.95
replace_with_regex	54.10	0.0004	0.6229	0.6175	3.25

Table 5. TABLE VIII: Controlled dataset description.

Category	Fingerprinting Methods (variants)
Environment & System	Battery, Datetime Format, Navigator & Screen, Permissions, Pressure (4 each)
Graphics Rendering	Canvas, Paint, WebGL, WebGPU (4 each); SVG (3)
Input & Interaction	Gamepad, Keyboard, Pointer (4 each)
Media & Sensors	Audio (5); MediaCapabilities, MediaDevices, Motion, Sensors (4 each)
Networking	Fetch, Network, Timing (4 each); WebRTC (5)
Storage & Execution	Filesystem, IndexedDB, ServiceWorker, SharedArrayBuffer, Storage (4 each)
Timing & Performance	Performance, UserTiming (4 each); Scheduler (5)
WASM Timing Tests	Three tests (1); Full test suite (1)
Total Scripts	124

Table 6. TABLE IX : Conversion pipeline performance per category.

Category	Total	Success Rate (%)	Conversion Coverage (%)	Mean Conversion Time (s)	Mean Validation Time (s)
Canvas Fingerprinting	555	74.59	8.65	2.0249	0.6438
WebRTC Fingerprinting	242	78.93	40.31	7.6911	1.0922
Canvas-font Fingerprinting	47	100.00	0.01	22.1537	2.1263
AudioContext Fingerprinting	579	92.92	18.66	4.8480	0.9403
Non-Fingerprinting	553	95.30	39.59	1.9892	0.5693
Mean $\pm$ SD	–	88.35$\pm$ 10.99	21.44$\pm$ 18.14	7.74$\pm$ 8.39	1.07$\pm$ 0.63

Equations

$$\text{Coverage}=\frac{{\text{Chars}}_{\text{transformed}}}{{\text{Chars}}_{\text{original}}}\times 100$$

$$\text{SuccessRate}=\frac{\text{\# Scripts passing all stages}}{\text{Total \# Scripts}}\times 100$$

$$\text{Relative Increase}=\frac{{\text{Size}}_{\text{wasm+js}}-{\text{Size}}_{\text{original\_js}}}{{\text{Size}}_{\text{original\_js}}}\times 100$$

Full text

I Introduction

Browser fingerprinting enables websites and third-party trackers to uniquely identify users by collecting and analyzing subtle differences in device and browser behavior. These differences arise from variations in canvas rendering, WebGL capabilities, audio processing, hardware features, and other low-level properties [1, 2]. Recent studies have shown that approximately 69% of the top 10,000 websites from the Alexa 100K list[3] employ some form of fingerprinting, often without user awareness or consent [4]. The browser fingerprinting market itself is projected to grow significantly, from a valuation of $2.5 billion in 2023 to over$12.5 billion by 2031, with a compound annual growth rate (CAGR) of 25% [5]. This growth underscores the increasing reliance on fingerprinting for analytics, advertising, and surveillance.

Because these fingerprinting techniques do not rely on traditional identifiers such as cookies or IP addresses, they operate covertly and passively, often making them difficult to detect or block [6]. In response, researchers and browser vendors have proposed detection tools and defenses that largely focus on JavaScript(JS)-based fingerprinting. This is a natural focus, as JS remains the dominant language for client-side execution and is commonly used to extract device and browser-level attributes [7, 6, 8].

However, the web platform has evolved significantly in recent years, most notably through the introduction and growing adoption of WebAssembly (WASM) [9]. WASM is a low-level, portable binary instruction format designed to complement JS, offering performance close to native code. The adoption of WASM has steadily increased, not just for legitimate performance-critical applications, but also as a tool employed by adversaries to obfuscate JS code and code functionalities [10]. As of 2024, WASM was supported in more than 96% of the browsers worldwide, demonstrating its wide-scale adoption and usage [11].

One compelling evidence of WASM’s potential for adversarial use is Wobfuscator [10], which showed that selectively translating JS functions into WASM can help evade state-of-the-art (SOTA) malware detectors, revealing the obfuscation power of WASM in adversarial settings. Meanwhile, several recent works have used WASM alongside JS to implement new fingerprinting techniques [12, 13, 14]. One such study demonstrates that fingerprinting logic can be implemented natively in WASM without relying on JS, expanding the adversarial surface [15].

However, the above efforts so far have focused solely on building new fingerprinting primitives and have not evaluated whether the use of WASM can impair detection of browser fingerprinting. Fingerprinting detection is currently overwhelmingly JS-centric, raising the following unexplored question: Can adversaries leverage WASM to obfuscate browser fingerprinting in ways that evade detection by existing defenses? Specifically, is it feasible to convert JS-based fingerprinting scripts into WASM in a way that preserves functionality while evading detection? Our goal in this paper is not to create new fingerprinting primitives, but to reuse and translate known JS fingerprinting techniques into WASM to assess the effectiveness of existing fingerprint detection systems.

To this end, we employ a greedy translation strategy, akin to greedy algorithms, where the conversion pipeline attempts to translate as much JS code as possible into WASM without filtering or selective heuristics. This approach is motivated by the hypothesis that maximizing the scope of WASM translation may obscure syntactic and semantic patterns typically used by fingerprinting detectors. Since many detection systems operate as black boxes with unknown internal logic, a greedy strategy allows us to perform a comprehensive stress test across diverse techniques and assess their robustness under aggressive WASM conversion. Note that, we use the terms WASM conversion and obfuscation interchangeably when discussing the transformation of JS into WASM.

In summary, this paper makes the following key contributions:

• •

Conversion Pipeline To explore whether real-world JS can feasibly be converted to WASM as part of an automated obfuscation pipeline, we built a conversion framework that’s capable of processing a wide range of real-world fingerprinting scripts, maintaining functionality while potentially obscuring key logic.

• •

Datasets. We build two complementary, first-of-their-kind datasets to enable comprehensive evaluation of WASM-based fingerprinting evasion: (i) a large-scale corpus of 7.5 million JS scripts (with over 10K fingerprinting scripts) and their WASM-obfuscated counterparts using our conversion framework, and (ii) a controlled dataset of 124 fingerprinting scripts, each with paired JS and WASM (converted) versions spanning multiple representative fingerprinting categories.

• •

Detection Analysis. We extensively evaluate both SOTA fingerprinting detectors from the literature and popular commercially available tools such as browser extensions and browser-based defenses, testing their effectiveness against both WASM-obfuscated (JS-to-WASM) and native WASM fingerprinting scripts.

• •

Root Cause Evaluation. We analyze the detection outcomes of WASM-converted scripts to uncover the factors underlying successful or failed evasion of existing fingerprinting detectors.

Our experiments reveal a clear disparity in how modern fingerprinting defenses respond to WASM-obfuscated scripts. SOTA detectors in research literature that rely on analyzing JS source code were considerably weakened, with important caveats. Some became entirely unusable due to outdated toolchains lacking WASM support, while others showed performance degradation. Although retraining with updated data restored much of their effectiveness, the detectors remained fragile. In contrast, commercial browser extensions and built-in browser protections remained robust, as their API-level interception mechanisms are unaffected by changes in implementation. We also tested the only known native WASM fingerprinting technique [15] to date and observed that it bypassed all defenses except in configurations that block script execution or WASM functionality entirely. However, with only one known native WASM fingerprinting technique, broader analysis remains limited. These findings offer insights into strengthening existing defenses against WASM-based obfuscation, while also revealing potential avenues for more targeted evasion strategies.

II Background and Related Work

II-A Background

Browser Fingerprinting. Browser fingerprinting is a stateless tracking method that relies on collecting distinctive attributes from a user’s browser and device configuration. These attributes include JS-exposed APIs (e.g., WebGL, canvas), HTTP headers (e.g., User-Agent), browser plugins, system fonts, screen resolution, and more [1, 2, 16]. Unlike first-party or direct tracking methods like cookies, fingerprinting does not store data on the client and can operate without user awareness or consent [6].

The concept of fingerprinting was first formalized in 2010 by Eckersley [16] following Mayer’s earlier observations in 2009 [17]. Subsequent work expanded fingerprinting techniques to include NoScript behavior [18], JS engine quirks [19], CSS rendering features [20, 21], and canvas/WebGL rendering inconsistencies [22, 23]. Researchers have also exploited hardware-level behavior [24, 25], audio APIs [26], screen glyphs [27], and even battery APIs [28] as fingerprinting vectors.

Defenses Against Fingerprinting. Browser fingerprinting poses a significant privacy risk by enabling persistent user tracking without relying on client-side storage or user consent. As these techniques become more sophisticated and widespread, researchers and developers have proposed various defenses aimed at detecting or disrupting fingerprinting behavior. Defensive strategies against fingerprinting fall into three main categories:

(1) API Randomization and Normalization. This category includes techniques that modify the outputs of fingerprint-relevant APIs to either randomize them across sessions or normalize them across users. The goal is to reduce the uniqueness or stability of the collected attributes, thereby degrading fingerprinting accuracy. Tools such as Canvas Defender [29] and Firegloves [30] inject noise into rendering APIs, though such noise can itself become a fingerprint [31]. More principled normalization strategies are used in browsers like Brave and Tor [32, 33], but they could potentially break site functionality [4].

(2) Heuristics-Based Detection. Heuristic defenses attempt to identify fingerprinting behavior using manually curated rules or behavioral patterns. These tools flag scripts that use certain APIs or access a suspicious number of device properties. Some examples of such tools include Privacy Badger [34] and Disconnect [35], which operate at the browser extension level. However, their effectiveness depends heavily on timely rule updates and may not generalize well to novel fingerprinting strategies.

(3) Learning-Based Detection. This category includes machine learning (ML) approaches that use static, dynamic, or hybrid features extracted from JS code to classify scripts as fingerprinting or benign. Tools such as FP-Radar [36] and FProbe [37] analyze web API usage over time or via control/data flow analysis. DeepFPD [38] uses token sequences, abstract syntax trees (AST), and control flow graphs (CFG) as input features. FP-Inspector [4] combines both static and dynamic signals using ML, and has been evaluated on a large-scale corpus of real-world websites [3].

WebAssembly. WebAssembly (WASM) is a low-level, portable binary instruction format designed to complement JS by enabling high-performance execution in web browsers  [39]. It is widely used for performance-intensive purposes such as gaming, multimedia processing, and runtime environments [40]. Unlike JS, WASM runs closer to native hardware and lacks a high-level structure, making it more difficult to inspect and analyze statically. These properties, while beneficial for performance, also make WASM attractive for adversarial use cases, including code obfuscation and evasion of security mechanisms [10].

II-B Related Work

Much of the browser fingerprinting research so far [4, 38, 36, 37, 16, 17, 19, 22, 23] has focused primarily on JS-based techniques (for new fingerprinting attacks), as well as JS-focused defenses. The broad adoption and large-scale deployment of WASM has given rise to a new set of challenges for the surrounding ecosystem. Due to its binary format and limited semantic cues, WASM presents significant challenges for conventional static and dynamic analysis techniques in accurately detecting and attributing program behavior.

Trampert et al. [12] and Pisanò et al. [13] leveraged WASM for performance and stability in fingerprinting routines, such as CPU and audio-based tests. Botvinnik et al. [14] used WASM for power-based fingerprinting due to its portability. Guri et al. [15] proposed a WASM-native fingerprinting approach using timing variations caused by interactions between WASM and JS to differentiate browsers. However, none of these studies evaluated whether such techniques can evade existing fingerprinting detectors.

Romano et al. [10] demonstrated that JS code can be obfuscated through selective translation into WASM, helping malware evade detection. Their approach, termed opportunistic translation, preserved functionality while obscuring structure. To date, no comprehensive study has examined how obfuscating known JS-based fingerprinting techniques using WASM affects their detectability across modern detection tools. Furthermore, no prior work in the literature has systematically evaluated native WASM-based fingerprinting in this context. Our work addresses this gap by applying WASM-based obfuscation to specific fingerprinting functionalities, assessing their detectability across multiple defense mechanisms, and analyzing the underlying causes of detection failures.

III Adversary Model & Research Questions

III-A Adversary Model

Our adversary is a web‐based tracker whose goal is to harvest the same rich set of device and browser attributes (e.g., canvas fingerprints, WebGL parameters, audio-subsystem characteristics) that traditional JS-based fingerprinting tools extract, but without triggering existing detection mechanisms (see Figure 1). To do so, the attacker controls the server or third-party domain that delivers client-side code and can freely transform, split, or merge scripts prior to delivery. The adversary can translate JS-based fingerprinting scripts into WASM to obfuscate their implementation while preserving functionality, and also implement fingerprinting logic natively in WASM, relying on lower-level interactions rather than JS-based probes.

In the scenario where the adversary converts JS scripts into WASM, we assume a greedy conversion strategy, where the adversary attempts to translate as much JS code as possible into WASM rather than selectively targeting specific functions. This maximizes code coverage within each script and increases the chance of evading syntactic or semantic detection heuristics. We assume that the attacker is willing to incur a one-time conversion overhead, such as the time and effort required to transform JS fingerprinting scripts into WASM. Since fingerprinting scripts are reused across many users, the one-time cost of converting them to WASM is easily amortized and justified by the added obfuscation. We assume an off-the-shelf, up-to-date browser (e.g., Chrome or Firefox) with no special instrumentation or privileged access, reflecting the typical environment encountered by real-world fingerprinters. The adversary cannot escape the JS/WASM sandbox, load native plugins, or tamper with the browser engine, as such capabilities extend beyond fingerprinting and would render fingerprinting unnecessary. From a defense perspective, we assume that the user may employ both static and dynamic fingerprinting detectors (i.e., tools that analyze code statically without execution or dynamically based on runtime behavior). We also assume that the attacker has no knowledge of the defense model’s architecture, parameters, or training data, if the defense employs a machine learning-based approach.

III-B Research Questions

To assess the feasibility and detection implications of WASM-based browser fingerprinting, we structure our investigation around the three following RQs.

• •

RQ1 (Conversion Feasibility): The first question we investigate is whether existing JS-based fingerprinting scripts can be effectively and reliably translated into WASM while preserving their functional behavior. Further, can such translations maintain accuracy across different fingerprinting categories (e.g., Canvas, WebGL, Audio, Sensors), and how well does this approach scale in terms of code coverage and fingerprinting type/category diversity?

• •

RQ2 (Detection Robustness): We next examine how well SOTA fingerprinting detection tools perform when faced with WASM-based implementations. Specifically, we analyze the effectiveness of detectors proposed in the research literature, browser-integrated defenses, and privacy extensions in detecting fingerprinting scripts that are either translated into or natively implemented in WASM.

• •

RQ3 (Evasion Analysis): Finally, we seek to understand the factors that contribute to detection failures or successes when the fingerprinting scripts are converted into WASM. Specifically, what structural, functional, or behavioral properties (of the scripts and/or detectors) contribute to detection failures or successes, and do current detection mechanisms exhibit blind spots or assumptions that can be exploited by adversaries?

IV Methodology

To address the research questions posed in Section III-B, we conduct a series of four carefully structured experiments. Specifically, we propose a conversion pipeline that systematically transforms JS-based fingerprinting scripts into semantically equivalent WASM variants. We then examine whether such conversion is practical when applied to a large volume of scripts (RQ1), whether it degrades the effectiveness of existing fingerprinting detectors and browser defenses (RQ2), and which specific transformations contribute the most to evasion, if at all (RQ3).

IV-A Conversion Pipeline

Converting JS to WASM is non-trivial for a few reasons. WASM operates as a statically typed stack-based virtual machine, while JS runs as a dynamically typed, event-driven language. As a result, their runtime models and execution models differ fundamentally. Furthermore, many idiomatic JS constructs, such as closures, dynamic evaluation (eval), and asynchronous callbacks, have no direct equivalents in WASM’s instruction set or execution semantics. Moreover, every WASM module requires a small amount of JS glue code, a wrapper that instantiates the module and mediates Document Object Model (DOM) access, before it can run in the browser.

Despite these challenges, we deliberately embrace the complexity of WASM translation to enable a detailed evaluation of its impact on fingerprint detection. Operating under a black-box adversarial model, we assume no internal knowledge of how fingerprinting detectors identify malicious scripts or on which specific features they rely on. Moreover, given the complexity and obfuscation present in modern JS, there is no reliable way to determine which portions of a script may influence classification. This motivates a greedy conversion strategy, i.e. we attempt to translate as much of the JS as possible to WASM. By maximizing the WASM footprint, we hypothesize that we will increase the likelihood of disrupting whatever heuristics or features detection tools may implicitly depend on. To this end, we design thirteen conversion rules: nine that match general-purpose language constructs (e.g., literals, control flow, arrays, functions) and four that target fingerprinting-relevant patterns such as property access or dynamic HTML element creation. Each function replaces matched JS segments with semantically equivalent WASM or WASM-obfuscated logic, preserving functionality while structurally diverging from the original script. We implement these WASM modules using AssemblyScript [41], a statically typed subset of TypeScript that compiles to WASM. AssemblyScript is developer-friendly and closely mirrors JavaScript syntax, allowing us to write lightweight and high-performance WASM logic without needing to drop to low-level languages such as Rust or C/C++.

Before discussing how the conversion functions operate, we must first outline the structure of the resulting WASM-converted code. The converted code wraps the WASM startup logic in an immediately invoked asynchronous function expression (IIAFE). This pattern allows the code to execute as soon as it is defined. Inside the IIAFE, the raw .wasm bytes are embedded in a Uint8Array, the required JS import object is provided, and WebAssembly.instantiate is called to obtain the module’s instance and exported memory. The IIAFE returns a WASM module instance (an executable version of the compiled code) and a memory object (a block of linear memory accessible by the module) wrapped in a JS promise, which resolves asynchronously when the instantiation is complete. When the promise resolves, the caller, sets up helper utilities (e.g., a getString routine to read UTF-8 data from linear memory) using them, and finally executes the modified JS that has been rewritten to invoke the new WASM exports instead of the original pure-JS logic. We follow the guidance from MDN Web Docs[42], which advises that synchronous instantiation, WebAssembly.Instance, should be used only when absolutely necessary, as it is a blocking function. Consequently, our implementation relies exclusively on asynchronous instantiation, WebAssembly.instantiate(). We maintain only one WASM module for all modifications made, which reduces the computation and memory requirements during compilation and execution. A single WASM module also circumvents the complications that may arise from using multiple asynchronous instantiations at nested scopes in the code.

The overall conversion pipeline (Figure 2) is as follows:

The input JS code is parsed into an Abstract Syntax Tree (AST), which is recursively traversed to identify code fragments matching the syntactic patterns of the defined translation rules. We use the open-source Python library pyesprima [43] to generate and manipulate the AST. 2. 2.

For each matched fragment, the corresponding rule generates three artifacts: (i) an AssemblyScript snippet to be compiled into WASM, (ii) any required entries for the import object, and (iii) a JS glue snippet to interface with the compiled WASM module in place of the original code. 3. 3.

The artifacts from all matched rules are aggregated: AssemblyScript snippets are merged into a single file and compiled into a WASM binary; import object entries are unified into a single import object; and glue code snippets are inserted into the original JS at their respective positions. Overlapping replacements are filtered out to prevent conflicts.

IV-B WASM Conversion Rules

We define 13 transformation rules to convert JS code into WASM-compatible forms (summarized in Table I). Nine rules target general language constructs (e.g., literals, control flow, function declarations), and four focus specifically on browser fingerprinting behaviors. Several of the general-purpose rules were inspired by patterns used in Wobfuscator [10], a JS obfuscation tool that also compiles selected code fragments to WASM. Below, we highlight a subset of representative rules to demonstrate the breadth and novelty of our transformation pipeline. The details of the remaining rules are provided in Section -A.

Rule 1 – Replace Literals: This rule replaces variable declarations initialized with literal values such as strings, integers, floats, or booleans with equivalent AssemblyScript exports. For example, a JS declaration such as:

⬇

let x = 42;

is transformed into AssemblyScript:

⬇

export let x_pos: i32 = 42;

To access the exported value at runtime, the following JS glue code is inserted:

⬇

let x = instance.exports.x_pos;

For string literals, a helper function is used to reconstruct it from WASM linear memory by reading its length and decoding the corresponding byte sequence starting at a given pointer. Literals inside loop headers (e.g., for-loop initializers or conditions) are excluded to preserve control flow behavior. All replacements are indexed to support precise patching into the original source.

Rule 2 - Obfuscate Sensitive Function Calls: This rule replaces direct invocations of JS functions, such as eval, Function, atob, and unescape with WASM equivalents where function names are stored as strings in WASM linear memory and reconstructed at runtime, potentially preventing direct static analysis. These JS functions are commonly used for dynamic code execution or content decoding. Although such functions are not exclusive to fingerprinting, they frequently appear in evasive or dynamically generated code, including fingerprinting scripts, making them relevant targets for obfuscation-aware transformations.

This rule targets all direct invocations of these functions, including standard calls, member expressions (e.g., WScript.Shell), and instantiations via new. For each matched call, it extracts the function name (e.g., eval), the start and end character indices in the original code, and a simplified representation of its arguments. For an eval invocation at starting index 123 it would be:

⬇

export let eval_123: string = "eval";

The binding code would look like this:

⬇

(function(){

let pointer_eval_123 = instance.exports.eval_123;

const globalObject_123 = typeof window !== ’undefined’ ? window : global;

globalObject_123getString(pointer_eval_123);

})();

The helper function getString() decodes string fragments stored in WASM linear memory. By resolving the function name dynamically at runtime from memory, this approach prevents the function from being visible as a static string in the JS source, complicating detection by signature-based or heuristic defenses.

This rule explicitly skips transformations of expressions such as new ActiveXObject(...) to preserve object construction semantics and focuses only on invocations directly associated with execution or encoding/decoding.

Rule 5 - Replace For Loops: This rule targets “for” loop constructs and replaces them with equivalent WASM-compatible representations. The initializer (loop variable and its initial value), the loop condition, increment expression, and loop body are converted into AssemblyScript logic encapsulated within an exported function. Typical AssemblyScript code looks like:

⬇

@external("js", "body_pos")

declare function body_pos(): void;

export function for_pos(): void {

let i: i32 = 0;

while (i < 10) {

body_pos();

i++;}}

Simultaneously, the loop body is stored as an import object component, to be attached to the WASM module as a function during instantiation. The original JS loop is replaced by a single binding call that invokes the corresponding exported WASM function. For example:

⬇

instance.exports.for_pos();

Rule 9 - Replace Function Definitions (LLM-based): This rules targets standalone JS function declarations and expressions, including FunctionDeclaration, FunctionExpression, and ArrowFunctionExpression nodes; and replaces them with semantically equivalent AssemblyScript exports. It excludes class methods and focuses on converting top-level or inline-defined functions. This exclusion is due to the additional complexity introduced by class semantics, i.e., the behavior of class methods often depends on the run-time value of this and access to private object state. Accurately preserving this context across the JS-WASM boundary would require custom handling of object identity, closures, and memory layout, effectively necessitating a full object-model emulation layer. Due to the engineering complexity this entails, we focused exclusively on standalone function transformation in this work.

Unlike other rules that rely on structural transformation, this rule leverages a Large Language Model (LLM) to translate the JS function into valid AssemblyScript. For the LLM, we use Qwen2.5-Coder-14B-Instruct from huggingface which is part of the Qwen2.5-Coder series, the latest series of Code-Specific Qwen large language models, formerly known as CodeQwen [44]. The LLM is prompted with a system message like this:

“ Write the following JS function in AssemblyScript, name it func_def_123, and export it. Only provide the code; no explanation or use case.”

This LLM-generated AssemblyScript code is then compiled and validated before inclusion in the main script. A typical output for a named function looks like:

⬇

export function add(a: i32, b: i32): i32 {

return a + b;}

Depending on whether the original was a declaration or expression, the appropriate JS binding code is generated. For named declarations, this is straightforward:

⬇

let add = instance.exports.add

For anonymous expressions or arrow functions, a generic reference is used:

⬇

instance.exports.func_def_123

Each transformed function is recorded in a dictionary that contains its position and binding code to enable patching.

Why LLM-based translation is required: Function definitions in JS exhibit wide syntactic and semantic diversity, including nested scopes, closures, higher-order constructs, and dynamic typing. Crafting deterministic rules to handle such variability would be brittle and incomplete. LLMs offer a flexible alternative by generalizing across syntactic forms and generating well-typed, semantically aligned AssemblyScript code from varied JS inputs.

Rule 10 - Obfuscate Fingerprinting-Relevant MemberExpressions: This rule targets property accesses including fingerprinting-relevant APIs (e.g., canvas.toDataURL, navigator.hardwareConcurrency, screen.availHeight, etc.) and replaces them with dynamically reconstructed property names using WASM-exported string fragments. The transformation attempts to obscure key API names by splitting them into two halves and reconstructing them at runtime, making static analysis and detection more difficult.

The property name is split into two halves (e.g., “fillText” becomes “fill” and “Text”).

A pair of AssemblyScript string exports is generated to hold each half:

⬇

export const f_h_123: string = "fill";

export const s_h_123: string = "Text";

These are stored in memory to be dynamically reconstructed in JS using a getString function and concatenated:

⬇

[getString(instance.exports.f_h_123) + getString(instance.exports.s_h_123)]

Depending on how the property is originally accessed, dot notation (e.g., ctx.fillText) or string literal (e.g., ctx["fillText"]), the replacement logic adapts accordingly. Dot accesses include the leading dot in the replacement range, while bracket-style string keys are reconstructed directly. This is particularly useful where visibility of key API names (such as toDataURL, getContext, or platform) must be hidden or scrambled to reduce traceability by heuristic or signature-based detectors.

IV-C Datasets

Real-World JS Corpus Existing fingerprinting datasets (such as DeepFPD [38]) are several years old and may no longer reflect current web practices. Therefore, we constructed a large-scale real-world dataset by crawling the May 2025 snapshot of Google’s CrUX Top-1M list[45], giving us an up-to-date snapshot of the current landscape of fingerprinting code and enabling comprehensive evaluation in our experiments.

To ensure realism and minimize detection or cloaking, each request included realistic desktop User-Agent strings, standard language and compression headers, and a five-second timeout. Crawling was distributed across a 64-core node with 8000 parallel workers, with a two-second inter-request delay per host. We avoided authentication, form submissions, or JS execution, thus preventing self-fingerprinting and aligning with established ethical guidelines. For every reachable site, we parsed the landing HTML to extract inline scripts and external scripts referenced via <script src>. Recognizing that publishers often place first-party code on subsidiary hosts, we additionally visited subdomains discovered in anchor links that shared the same effective top-level domain. Third-party domains were excluded to maintain focus on publisher-controlled content.

Each script was normalized (UTF-8, LF line endings) to ensure consistent parsing and to eliminate platform-dependent differences, deduplicated (SHA-256), and stored in chunked JSONs with rich metadata (origin, capture time, MIME type, status, size, initiator, WASM flag). We then used a heuristic pattern-matching pipeline—built upon FP-Inspector (a SOTA fingerprinting detection in research literature), heuristics [4] to label scripts as fingerprinting or non-fingerprinting, tagging them by fingerprinting category. Our real-world JS corpus consists of 7,578,653 script files. From this corpus, we heuristically identified 10,742 scripts as containing fingerprinting behavior. Among them, we found a total of 8730, 1780, 1986, and 109 script of categories AudioContext, Canvas, WebRTC and Canvas-font respectively.

Controlled Dataset While evaluating real-world scripts is critical for assessing the practical impact of our conversion approach, it presents significant challenges in verifying whether fingerprinting functionality is preserved post-conversion. This difficulty arises because fingerprinting code found in the wild is often heavily obfuscated and often encapsulates its core logic within nested subroutines. As a result, isolating and verifying fingerprinting behavior requires extensive manual effort and is not scalable. To address this limitation, we additionally use a controlled dataset of paired JS and WASM scripts that are manually crafted using known fingerprinting vectors to reflect common fingerprinting characteristics. These scripts produce and display a fingerprint derived using the SHA-256 hashing algorithm, allowing us to directly compare the output before and after conversion. This enables a precise evaluation of whether the fingerprinting functionality remains the same before and after WASM-conversion.

The controlled dataset contains 32 JS scripts of 7 different types of fingerprinting techniques. 17 scripts generate stable and unique fingerprint hashes, making them useful for monitoring their behavior over time. The remaining scripts, although they do not produce consistent hashes, still extract valuable information that can assist in device categorization or serve as supplementary features in broader fingerprinting techniques. An example of a fingerprinting technique that produces unstable hashes but is still useful is the method proposed by Guri et al. [15], which we implement in the WASM Timing Tests category of our controlled dataset. Although this technique does not generate a stable or unique hash, the authors claim that the datapoints it collects can still be used to train a ML classifier that effectively distinguishes between Chromium-based and non-Chromium browsers.

The dataset also contains up to 4 different WASM-obfuscated variants of each script. We first use our conversion pipeline to create obfuscated variants, then generate additional variants using simple obfuscation techniques. These simple obfuscations are feasible for these scripts because they are relatively simple and manually crafted, giving us full control over their structure. Generating multiple variants allows for more extensive and robust testing. The obfuscated variants are:

The JS code is passed through our conversion pipeline to get a WASM-obfuscated version of the code. The conversion pipeline is discussed in detail in section IV-A. 2. 2.

Property accesses are obfuscated by converting any property access to computed property access with split strings. The split strings are added to the AssemblyScript code and imported from the WASM module after compilation. For example, canvas[’fillText’] or canvas.fillText is converted to canvas[getString(instance.exports.str_1)+getString2(instance.exports.str_2)]. The AssemblyScript code for this looks like:

⬇

const str_1: string = "fill";

const str_2: string = "Text"; 3. 3.

We embed the entire JS code as a string inside a WASM module. At runtime, the code is extracted and executed using a WASM-obfuscated eval function. This allows dynamic generation without static inclusion in the original source code. The binding code looks like this:

⬇

windowgetString(instance.exports.e_s)

Where e_s is a string ’eval’ and s is the whole code as a string, stored inside the WASM module. 4. 4.

We replace the JS hashing function with a hashing library implemented in WASM. We replace the usage of built-in node module crypto with the hash-wasm[46] library.

A brief overview of the scripts in the controlled dataset is presented in Table VIII.

V Experimental Setup

Our evaluation is structured around four key experiments that are driven by the research questions described in Section III-B. These experiments are conducted using both our real-world and controlled datasets to assess the feasibility of WASM-based obfuscation and its impact on current fingerprinting defenses.

Dataset Sampling Strategy. Due to the scale of our real-world dataset, we adopt a two-stage sampling strategy to construct 10 balanced and representative evaluation subsets to run our experiments. As described in Section IV-C, we split the dataset into fingerprinting and non-fingerprinting pools. Each subset contains 500 scripts, with 400 fingerprinting and 100 non-fingerprinting scripts. The fingerprinting samples are selected by stratified sampling to preserve technique diversity across four categories: canvas, WebRTC, canvas-font, and AudioContext. The resulting fingerprinting pool includes 414, 537, 47, and 190 scripts, respectively, from each category. The non-fingerprinting samples are drawn using reservoir sampling [47] to ensure randomness.

V-A Experiment 1: Conversion Pipeline Evaluation

This initial experiment quantifies the operational characteristics of our conversion pipeline to establish the viability of transforming JS into WASM-obfuscated code at scale. We measure performance across four dimensions:

Conversion Coverage. We compute the proportion of a script’s original JS that is transformed into WASM-backed bindings. This is measured as the number of characters replaced or removed from the original JS string during conversion, divided by the total number of characters in the input and is represented as:

[TABLE]

Conversion Success Rate. A script is considered successfully converted if it passes a three-stage validation pipeline:

• •

The generated AssemblyScript compiles into valid WASM using the asc compiler.

• •

The modified JS (with injected bindings) parses correctly into an AST using python-esprima.

• •

The modified JS executes without runtime exceptions when injected into a test website running in a headless Chromium instance

We report success rate as the fraction of scripts that pass all the three checks:

[TABLE]

Conversion and Validation Time. We measure the total time taken to convert each script, including AST traversal, transformation rule application, AssemblyScript generation, and WASM compilation. This is reported as the average conversion time per script to assess the feasibility of large-scale transformation pipelines. We also measure the validation time, which is the time required for the final code to be parsed and executed. No statistical modeling is performed on the timing data.

Change in Code Size. We compare the size of the original JS file to the total size of the WASM-converted output, which includes (i) the transformed JS, (ii) the compiled ‘.wasm‘ binary, and (iii) any helper glue code. The size is calculated by writing the scripts to .js files and calculating the number of bytes occupied on the disk. We report both absolute and relative differences to highlight any increase in payload size:

[TABLE]

V-B Experiment 2: Detection Performance Analysis

This experiment examines whether SOTA fingerprinting detectors in research literature can identify fingerprinting behavior after our WASM conversion.

Detection Tool Implementation We evaluate two representative detectors from the literature, implemented as follows:

Tool-1: DeepFPD (Static Detector) The original DeepFPD paper [38] proposes a deep learning-based fingerprinting detector that leverages features derived from the Abstract Syntax Tree (AST), token sequences, and Control Flow Graphs (CFGs). These features are used to train Long Short-Term Memory (LSTM) and Gated Graph Neural Network (GGNN) models. While attempting to reproduce the system using the authors’ publicly available code, we encountered multiple issues. The deep learning pipeline relied on deprecated libraries, and even after manually replacing these dependencies, we were unable to replicate the reported performance on their original dataset. Notably, the authors also reported that a simpler Random Forest model trained on their extracted features achieved higher precision than their deep models, with only a modest decline in recall and F1-score. Motivated by this, we used DeepFPD’s feature extraction pipeline to build a Random Forest-based detector. The extracted features are tokenized AST elements such as MemberExpression:screen, which are encoded into a sparse Bag-of-Words matrix using CountVectorizer (with a vocabulary size capped at 5000 features).

Tool-2: FP-Inspector (Hybrid Detector) FP-Inspector [4] is a combined static and dynamic analysis based browser fingerprinting script detection tool which consists primarily of two parts. The first part is an OpenWPM[6] based web crawler with custom instrumentations designed to target markers of browser fingerprinting. This crawler produces an SQL file upon successful visits of websites, which is then used to extract static and dynamic features. These features are used to train two machine learning models; one for static features and one for dynamic features. These two models detect browser fingerprinting scripts through an OR operation of their predictions. We implemented FP-Inspector’s crawler following the authors’ official guidelines. To test the tool, we embedded both JS and WASM-obfuscated fingerprinting scripts into simple HTML pages and hosted them locally using a Python HTTP server. The crawler was run in headless mode to visit these test pages and generate the resulting logs. These logs were subsequently processed using FP-Inspector’s feature extraction scripts in preparation for classification.

V-C Experiment 3: Evaluation Against Browser-Based Defenses

This experiment evaluates whether our WASM-converted scripts can evade defenses integrated into modern browsers and popular anti-fingerprinting browser extensions.

Defense Tools. We tested a total of 10 extensions: (1) JSheter[48], (2) Trace[49], (3) Chameleon[50], (4) Canvas Blocker - Fingerprint Protect[51], (5) Canvas Fingerprint Defender[52], (6) Random User-Agent (Switcher)[53], (7) Privacy Badger[54], (8) Browser Fingerprint Protector[55], (9) Disconnect[56], and (10) Ublock-origin[57]. We also tested latest (as of July 2025) stable releases of five browsers: Brave[58], Chrome[59], Edge[60], Mozilla Firefox[61] and Opera[62] to see if their in-built defenses impacted WASM-obfuscated fingerprinting as implemented by us in this work.

Methodology. Using our controlled dataset to ensure behavioral consistency, we test each script against a suite of defenses. A defense is considered bypassed if the script is not blocked, its functionality is not disrupted, and its fingerprinting hash output (for stable scripts) does not change.

V-D Experiment 4: Ablation Study on Conversion Rules

To isolate the contribution of each of our 13 WASM transformation rules, this experiment re-evaluates detection performance by applying only one rule at a time. This ablation study allows us to understand the specific impact of each rule on the potential for detection evasion.

VI Results

VI-A Experiment 1: Conversion Pipeline Evaluation

We began by pre-processing the sampled scripts from our real-world dataset to ensure compatibility with our tooling. Scripts that could not be reliably parsed using pyesprima were excluded. In particular, we removed any scripts that triggered parsing errors or exceeded 100 kB in size, as such large scripts frequently caused crashes during AST construction.

The performance of our conversion pipeline is summarized in Table II (per-sample) and  Table IX (per-category). The pipeline achieved a mean success rate of 85.76% across all samples, with a mean conversion coverage of 25.01%. The 95% confidence intervals for all metrics are narrow, as shown in Figure 6, indicating low variability and precise estimates across samples. We observed a mean conversion time of 3.45s and mean size change of 24.54%.

The success rate of conversion varied across fingerprinting categories. A comparison of conversion metrics for categories is provided in Figure 3. Canvas-font scripts achieved a perfect 100%, while Canvas scripts were the most difficult to convert, with a success rate of 74.59%. Conversion coverage also differed by category, ranging from a high of 40.31% for WebRTC scripts to just 0.01% for Canvas-font. Additionally, Canvas-font scripts had the highest mean conversion time (22.15s), whereas Non-fingerprinting scripts were the fastest to convert, with a mean time of 1.99s. We attribute the faster conversion of Non-fingerprinting scripts to their simpler structure, whereas fingerprinting scripts often contain extraneous or obfuscated code that increases conversion time.

Experiment 1 Summary: Our conversion pipeline successfully transformed large majority of the attempted real-world JS fingerprinting scripts into functional WASM-obfuscated variants with a success rate exceeding 85%. This shows that the large-scale conversion of existing fingerprinting scripts to WASM is not merely a theoretical possibility but a practical and automatable adversarial strategy. With the threat vector established, we next evaluate its impact on SOTA fingerprinting detection and prevention systems.

VI-B Experiment 2: Detection Performance Analysis

We evaluated the fingerprinting detection performance of DeepFPD and FP-Inspector on both original and WASM-obfuscated scripts. Implementation details are provided in Section V-B; here, we present the findings from this evaluation.

Tool 1: DeepFPD We evaluated the resilience of DeepFPD against WASM-based obfuscation across four distinct scenarios. In the first three scenarios, we trained the model once using DeepFPD’s original training set, which consists of 10,240 non-fingerprinting and 343 fingerprinting scripts. This trained model was then evaluated on three different test sets: (i) DeepFPD’s own test set (311 non-fingerprinting and 18 fingerprinting scripts), (ii) our newly collected real-world dataset, and (iii) our controlled dataset. The fourth scenario involved retraining the model after augmenting the training set with WASM-obfuscated scripts.

A summary of the classification performance for the first three scenarios is presented in Table III. The performance of DeepFPD detector was significantly impaired by WASM obfuscation, when tested on its own dataset. The recall dropped sharply from 77.78% on the original scripts to just 44.44% when converted to WASM (see Figure 4). On the new real-world dataset we collected, the detector’s performance was only slightly impacted, with recall dropping modestly from 86.40% to 81.28%. We investigate the underlying reasons for this discrepancy later in the section through a detailed feature importance analysis.

To evaluate whether the drops in fingerprint detection/classification are due to the lack of WASM scripts in DeepFPD’s training data, we retrain DeepFPD with WASM-converted scripts from our real-world script dataset added to the train set. However, simply adding WASM-converted fingerprinting scripts to the training set tended to significantly worsen model performance. We then performed a category-wise addition to the training set to observe the effect on performance. We observed that the addition of category-specific WASM-converted scripts (only fingerprinting) impaired the classifier. For Canvas and WebRTC inputs, the accuracy on the original JS test set stayed high (98.43% with 88.24% precision, 83.33% recall), but the accuracy on the WASM obfuscated test set fell to about 6% and precision to about 5.7%; recall remained 100%. AudioContext scripts drove both JS and WASM accuracy and precision to 5.64%, again with recall at 100%. In effect, the model labeled almost everything as fingerprinting-positive, preserving recall but losing precision and overall accuracy, especially for WASM. A balanced augmentation, i.e., 414 Canvas, 537 AudioContext, 190 WebRTC fingerprinting scripts, plus 525 non-fingerprinting scripts restored stability. The model reached 98.12% accuracy, 87.50% precision, and 77.78% recall on both the JS test set and its WASM-converted version, showing that balanced category coverage eliminates decline in model performance seen in earlier experiments and lets the same model handle JS and WASM equally well.

We use the treeinterpreter [63] package to calculate feature importance of the Random Forest classifier; which in this case is the per-feature contribution towards the classifier’s decision for fingerprinting class (i.e., class 1).Table IV lists the top 10 most important features for the classifier, which are overwhelmingly high-signal AST tuples related to known fingerprinting APIs, such as those for screen, canvas, and localStorage.

The delta plots (Figures 7 and 5) show the change in the contribution of each feature to the classification outcome after conversion. In these plots, a negative value (a red bar) indicates that a feature’s contribution towards identifying a script as fingerprinting was diminished by our process. The aggregated delta plot in Figure 5 reveals a systematic trend across all misclassified scripts. Notably, MemberExpression:screen, the single most important feature from the table shows the largest negative change, indicating that its influence on the classifier’s decision was significantly reduced after substitution. Other important features such as MemberExpression:getTimezoneOffset, BinaryExpression:type, and Property:getScreenResolution also saw their contributions significantly diminished because of WASM obfuscation.

This helps explain the sharper recall drop observed on the DeepFPD test set (78% to 44%) compared to our real-world dataset (86% to 81%). The features most impacted by WASM obfuscation, such as screen, getTimezoneOffset, and localStorage, are also the top contributors in DeepFPD’s test set, so their suppression removes critical classification signals. In contrast, our real-world dataset contains fewer scripts that use these features and a greater proportion of scripts involving canvas rendering and plugin-related properties (canvas, font, fillRect, plugins), which are less affected by WASM obfuscation. This allows the classifier to retain much of its effectiveness.

DeepFPD’s mixed performance in detecting WASM-obfuscated scripts (created using our tool) could be attributed as a consequence of our greedy black-box strategy, which attempts to convert as much code as possible without knowledge of the detector’s logic. However, an adversary with the internal knowledge of these detectors could perform a more targeted conversion, focusing only on the most important features to maximize evasion.

Tool 2: FP-Inspector The hybrid static-dynamic detector, FP-Inspector, suffered a catastrophic failure. Its crawler was unable to process any of our WASM-converted scripts; they were not picked up or included in the extracted features, rendering the entire detection pipeline virtually useless.

The root cause for this is a critical toolchain dependency: FP-Inspector relies on a version of Firefox 52 ESR that has WASM support disabled. The detector was not merely evaded but was rendered completely inoperable by the presence of a modern web technology. It highlights a critical technological fragility, where a detector’s viability is tied to an outdated and incompatible browser environment. While FP-Inspector may still function on legacy JS-based fingerprinting scripts, it becomes fundamentally unusable in the presence of WASM obfuscation. This highlights the importance of maintaining compatibility with evolving browser technologies in dynamic fingerprinting defenses.

Potential of Modern Dynamic Analysis FP-Inspector incorporates a dynamic analysis component, yet it failed entirely on our WASM-obfuscated scripts due to its reliance on a legacy browser environment with no WASM support. This raised an important question: is dynamic analysis fundamentally incompatible with WASM obfuscation, or was FP-Inspector’s failure simply due to outdated tooling? To explore this, we developed a proof-of-concept heuristics based dynamic analysis tool using modern browser instrumentation. The goal was to assess whether dynamic analysis techniques are capable of detecting fingerprinting behavior even after WASM obfuscation.

Our tool launches a headless Chromium browser using Playwright and establishes a Chrome DevTools Protocol (CDP)[64] session to observe JS execution at the engine level. It sets breakpoints on a curated list of high-entropy fingerprinting APIs, including property accesses like navigator.userAgent, navigator.hardwareConcurrency, and screen.width, as well as active sensor methods such as HTMLCanvasElement.prototype.toDataURL and AudioContext.prototype.createAnalyser. When any of these APIs are invoked, CDP emits a Debugger.paused event, which we capture using a custom handler that logs the call and immediately resumes execution, ensuring the original script’s timing behavior remains unaffected. Additional implementation details and are provided in Section -D.

Despite its simplicity, the tool showed promising results. It detected 5 out of 18 fingerprinting scripts from the original DeepFPD JavaScript-only test set, as well as their WASM-obfuscated counterparts. On our controlled dataset, it detected 3 scripts (WebGL, Canvas, Navigator & Screen) and their WASM-obfuscated variants. These preliminary result suggests that even a naive detector built with modern dynamic analysis frameworks can be effective. By monitoring API calls and property accesses directly, they have the potential to bypass code-level obfuscation and reliably detect fingerprinting behavior.

Experiment 2 Summary: Our evaluations revealed that while SOTA detectors research literature are robust to WASM-based obfuscation to a certain extent, they can at times be fragile and can be bypassed by WASM-obfuscated code. However, our preliminary tests with a modern dynamic analysis tool suggest this approach has strong potential for developing into robustly detecting WASM-obfuscated fingerprinting.

VI-C Experiment 3: Evaluation of Anti-Fingerprinting Extensions and in-built Browser Defenses

In contrast to the SOTA detectors in research literature, we found that popular commercial in-browser defenses and browser extensions were largely unaffected by our WASM obfuscation technique. As shown in Table V and Table VI, all 10 tested browser extensions (including CanvasBlocker, Privacy Badger, and uBlock Origin) and all 5 browser configurations (including Firefox with Enhanced Tracking Protection and Brave with fingerprinting protection) remained unaffected by WASM obfuscation.

Our analysis reveals that this resilience arises from a fundamentally different defense model. Tools such as CanvasBlocker and browsers like Firefox (in Strict Mode) do not rely on static or dynamic code analysis to detect fingerprinting. Instead, they use API-level defenses by intercepting and spoofing sensitive outputs (e.g., from canvas or audio APIs), or by blocking access to specific browser interfaces. These defenses are agnostic to the origin or structure of the invoking code and, therefore, remain effective regardless of whether the fingerprinting logic is implemented in JS or WASM. Similarly, extensions such as Disconnect, Privacy Badger, and uBlock Origin rely on domain-level blocking to prevent tracking. Since our evaluation was conducted on locally hosted pages, these tools were not triggered and did not intervene. This reflects a limitation in their operational scope rather than a weakness against WASM obfuscation.

Bypassing Defenses with WASM-Native Techniques While our JS-to-WASM conversion did not evade defenses that operate at the API level, we also evaluated a fully WASM-native fingerprinting technique proposed by Guri et al. [15], which bypasses them entirely. This approach performs timing-based micro-benchmarking inside a WASM module to capture subtle variations in browser execution. By embedding the logic directly in WASM bytecode and avoiding APIs frequently leveraged for browser fingerprinting, such as Canvas or WebGL, this technique evades detectors that monitor these invocations. In our testing, it successfully fingerprinted the browser even when all popular defenses such as CanvasBlocker and Firefox Strict Mode were enabled. This highlights a key limitation of current API-centric defenses: they remain blind to fingerprinting behaviors that exploit microarchitectural or timing side-channels from within WASM.

Experiment 3 Summary: We found no evidence that anti-fingerprinting extensions or built-in browser defenses were impacted by WASM obfuscation. This suggests that API-level intervention is a more durable defense paradigm against obfuscation than static or dynamic code analysis. However, emerging WASM-native fingerprinting techniques that avoid these monitored APIs may still pose a significant threat.

VI-D *Experiment 4: Ablation Study on Conversion

Rules*

The ablation study, summarized in Table VII, assessed the individual contribution of each of our 13 conversion rules. When evaluating the transformed scripts using DeepFPD, we observed that no single rule alone was sufficient to produce a notable evasion effect. In fact, applying only one rule resulted in no change in classification metrics between the JS or WASM versions of the DeepFPD test set. During conversion, replace_with_regex achieved the highest stand-alone conversion success rate of $54.10\%$ while contributing a modest $3.25\%$ increase in size and conversion coverage of $0.0004\%$ . In contrast, replace_canvas_api_calls significantly increased size by nearly $200\%$ but yielded a relatively low conversion success rate of $16.79\%$. Meanwhile, replace_func_defs showed the weakest performance overall, with the longest processing time (3.40 s per script) and the lowest conversion success rate (9.70%). The reason for such high conversion time required is it’s use of an LLM.

Experiment 4 Summary: The ablation study shows that the detection evasion observed in Experiment 2 was not caused by any single transformation but rather by the combined effect of multiple conversion rules. This suggests that successful evasion requires a comprehensive obfuscation strategy that targets several aspects of a script, rather than depending on a single simple modification, thereby justifying our use of a broad, greedy conversion approach.

VII Discussion

In this work, we investigated whether converting JS-based fingerprinting scripts to WASM could evade modern detection systems. Our empirical analysis reveals a stark and consequential divide: academic, feature-based detectors are in certain cases vulnerable to this obfuscation technique, whereas practical, in-browser defenses are largely immune. This suggests a significant disconnect between the focus of academic research and the architecture of robust, real-world defenses.

Limitations. Our study, while comprehensive, has a few limitations that point to promising directions for future work. First, our analysis focused primarily on DeepFPD as a representative static detector, since the dynamic tool FP-Inspector was incompatible with our WASM-obfuscated test cases. While these tools exemplify their respective classes, evaluating a broader range of modern static and dynamic detectors would help validate the generality of our findings. Second, our use of a greedy black-box conversion strategy was intended to model an attacker with no knowledge of the detector. Our results suggest that a feature-aware approach that selectively obfuscates high-impact features may yield even stronger evasion, motivating future exploration of more targeted strategies.

Future Work. Our findings also highlight critical avenues for future research in developing more resilient defenses against fingerprinting. One key direction is the development of WASM-aware detectors that can operate directly on WebAssembly binaries. These detectors could leverage static analysis to identify suspicious instruction patterns or apply dynamic techniques that trace execution across the JS and WASM boundary. Complementing this, our results suggest that hybrid defense models, which combine structural code analysis with API-level interception, may offer improved robustness. By integrating behavioral cues, such as API spoofing or access blocking, with code-level features, these hybrid models could detect fingerprinting even when obfuscation techniques obscure traditional signals.

VIII Conclusion

This paper provides the first systematic evaluation of the impact of JS-to-WASM conversion on the browser fingerprinting ecosystem. We demonstrated that this technique poses a critical threat to the current generation of academic feature-based detectors, while practical, API-level defenses remain robust. This highlights a crucial divergence in defensive strategies and suggests that future research should focus on building defenses that are less reliant on the syntactic properties of JS and more attuned to the underlying behavior of web technologies. By charting the limitations of current tools, we provide a clear path forward for developing more resilient defenses against the next generation of tracking and evasion techniques.

Ethics Considerations

We analysed only JavaScript that was publicly available in the May 2025 CrUX Top‑1M snapshot; no personal or user‑generated data were collected, so the study is outside the scope of human‑subjects research and required no IRB review. Throughout the crawl we respected public‑content boundaries, added a two‑second delay between requests, and avoided any authentication or form submission, following standard ethical‑crawling practice. Our primary contribution, the JS-to-WASM conversion pipeline, did not reveal any new security vulnerabilities in the tested commercial browser extensions or built-in defenses. Consequently, no responsible disclosure was necessary. We note that our evaluation of a pre-existing, publicly documented WASM native fingerprinting technique from prior research did demonstrate an evasion of these tools. As this technique is already in the public domain, it does not fall under the standard protocol for disclosing a newly discovered vulnerability. Its inclusion serves to highlight the limitations of current API-centric defenses for the academic and security communities.

-A Remainder of Translation Rules

Rule 3 – Replace Integer and Float Arrays: This rule identifies array declarations initialized exclusively with integer or float values. It recursively traverses the JS abstract syntax tree (AST) to locate such array literals and replaces them with equivalent AssemblyScript code that stores the array contents in WASM linear memory.

The generated code for an integer array looks like this:

⬇

export function get_arrName_posPointer(): i32 {

const arrName = new Array<i32>(length);

arrName[0] = value0;

// arrName[N] = valueN;

const ptr = __alloc(length * sizeof<i32>());

for (let i = 0; i < arrName.length; i++) {

store<i32>(ptr + i * sizeof<i32>(), arrName[i]);

}

return ptr;

}

It also generates the necessary JS binding code to reconstruct the array at runtime from WASM memory:

⬇

const createArray_arrName = instance.exports.get_arrName_posPointer;

const ptr_arrName = createArray_arrName();

const arrName = new Int32Array(instance.exports.memory.buffer, ptr_arrName, length);

Arrays instantiated via new Array() or containing mixed types are ignored.

Rule 4 – Replace If-Else Statements: This rule identifies simple if-else constructs and extracts IfStatement nodes whose then and else branches do not contain disruptive control flow keywords such as return, throw, or break. It then extracts the test condition, then-branch, and else-branch, along with the character indices of the block. This rule then generates equivalent AssemblyScript code in the form of a dispatch function, typically structured as:

⬇

@external("js", "$imp1_pos")

declare function $imp1_pos(): void;

@external("js", "$imp2_pos")

declare function $imp2_pos(): void;

export function $if_else_pos(condition: i32): void {

if (condition == 1) {imp1_pos();} else{imp2_pos();

}}

and stores this in a list. Simultaneously, it generates necessary JS binding and import object components, which includes inlined then and else blocks. The binding code evaluates the condition in JS and passes a binary flag to the WASM function. Typical binding code looks like this:

⬇

let wasmTestCondition_pos = test_expr ? 1 : 0;

instance.exports.$if_else_pos(wasmTestCondition_pos);

Also, support nested if-else blocks. This transformation supports WASM offloading of conditional control while maintaining runtime functionality.

Rule 6 – Replace While Loops: This rule finds while loop constructs and extracts loop conditions, bodies, and the set of variable identifiers referenced in the condition expression. The loop termination condition is handled by an if-else block inside the AssemblyScript code.

A typical AssemblyScript transformation looks like:

⬇

@external("js", "cond_pos")

declare function cond_pos(var1: i32, var2: i32): i32;

@external("js", "body_pos")

declare function body_pos(var1: i32, var2: i32): void;

export function f_pos(var1: i32, var2: i32): void {

while (true) {

if (cond_pos(var1, var2) == 0) {

break;

}

body_pos(var1, var2);

}

}

The names and count of parameters are dynamically derived from the variables used in the loop condition. The condition and body logic are used as import object components.A JS binding code is generated to invoke the exported loop function:

⬇

instance.exports.f_pos();

Rule 7 – Replace Function Calls Without Return Values: This rule identifies standalone function calls whose return values are not used. These are calls embedded directly within expression statements (e.g., doSomething();) rather than assignments, return statements, or logical expressions. For each matched call, the function generates AssemblyScript code that typically looks like this:

⬇

@external("js", "impFunc_pos")

declare function impFunc_pos(): void;

export function f_pos(): void {impFunc_pos();}

The function body is stored as an import object component such as this:

⬇

impFunc_pos: () => {doSomething();}

The original function call in JS is replaced with a binding call to the exported WASM wrapper:

⬇

instance.exports.f_pos();

This rule accounts for all child node structures and ensures that calls nested within unused expression statements are included, while excluding those embedded within assignment chains, returns, or expressions that utilize their return value.

Rule 8 – Replace Class Definitions: This rule finds class definitions and rewrites them into AssemblyScript exports and runtime binding logic. The goal is to offload the class declarations into WASM. However, since WASM does not support passing complex objects such as class definitions between its memory and JS, the class definitions are stored in AssemblyScript as strings and dynamically injected back into the DOM during execution.

This rule locates nodes of type ClassDeclaration or ClassExpression. For each match, it generates AssemblyScript code that declares the entire class as a raw string export:

⬇

export let class_pos: string = class MyClass { constructor() { ... } };

This string is later reconstructed in JS using WASM linear memory and embedded into the DOM by creating a new script element. Typical binding logic looks like this:

⬇

const classContent_pos = ${getString(instance.exports.class_pos)};

const script_pos = document.createElement("script");

script_pos.textContent = classContent_pos;

document.body.appendChild(script_pos);

This rule supports both named and anonymous class expressions and ensures that the full content of the class is preserved and re-injected at runtime.

Rule 11 - Obfuscate Dynamic Code Generation Calls: This rule targets dynamic JS constructs, such as canvas() or fingerprinting-relevant member expressions like screen.availHeight, that are potential candidates for runtime code generation. It transforms these code fragments by lifting them into WASM memory as obfuscated string constants and later executing them through an indirect eval() call from JS.

The rule targets two kinds of suspicious patterns:

• •

Calls to a canvas function.

• •

Member expressions access objects such as screen, which are known to be part of fingerprinting logic.

These patterns are sliced from the original source code using its location metadata and transformed into two AssemblyScript string exports:

⬇

export const e_call_123: string = "eval";

export const c_str_123: string = "canvas()";

These values are used in the JS binding layer to reconstruct and execute the original call at runtime:

⬇

window[getString(instance.exports.e_call_123)][getString(instance.exports.c_str_123)]

This pattern makes the use of eval indirect, preventing static string detection and enabling runtime execution of previously extracted code.

Rule 12 – Regex-Based Obfuscation of Fingerprinting Strings: This rule uses regular expressions to locate hard-coded occurrences of the word ”canvas”, a known fingerprinting artifact, embedded as string literals. It then replaces these literal strings with dynamically reconstructed equivalents composed of multiple WASM string exports.

The core of the transformation relies on a regex pattern:

⬇

(([’"]|)+canvas([’"]|)+)"

which captures occurrences of ”canvas” enclosed in quotes or escaped characters. For each match, the transformation verifies that the match is not part of a key-value pair (e.g., ”canvas”: …) by checking that the matched string is not immediately followed by a colon(:).

For valid matches, it emits the following AssemblyScript code:

⬇

export const cv1_poka: string = "can";

export const cv2_poka: string = "vas";

and generates the corresponding JS reconstruction using a memory lookup and concatenation:

⬇

getString(instance_lit.exports.cv1_poka) + getString(instance_lit.exports.cv2_poka)

Rule 13 – Obfuscate MemberExpressions with screen Using Split Identifiers: This rule identifies obfuscated screen and canvas member expressions. Certain use cases access them using hex-encoded strings that obfuscate multiple property names, making them difficult to detect with AST traversal. An example of such a use case would be:

⬇

const props = {

"\x61\x76\x61\x69\x6C\x48\x65\x69\x67\x68\x74": "availHeight",

"\x61\x76\x61\x69\x6C\x57\x69\x64\x74\x68": "availWidth",

"\x63\x6F\x6C\x6F\x72\x44\x65\x70\x74\x68": "colorDepth"};

const propKey = "\x61\x76\x61\x69\x6C\x48\x65\x69\x67\x68\x74"; // "availHeight"

const value = screen[props[propKey]];

For each match (for this example, screen), the transformation emits a pair of AssemblyScript string exports representing the split form of the word:

⬇

export const sc1_poi: string = "scr";

export const sc2_poi: string = "een";

At runtime, the JS binding logic reconstructs the original object name by reading these strings from WASM memory and concatenating them:

⬇

window[getString(instance_lit.exports.sc1_poi)+getString(instance_lit.exports.sc2_poi)]

-B Controlled Dataset Details

A description of the scripts in the controlled dataset including the script categories and number of variants is provided in Table VIII.

-C Additional Results

-C1 Conversion Metrics

Figure 6 shows the running mean and 95% confidence intervals for four key metrics; Success Rate, Conversion Coverage, Mean Conversion Time, and Size Change for real-world dataset.

-C2 DeepFPD Model Analysis

We visualize the shift in feature attribution scores for representative samples from the DeepFPD test set in Figure 7. Figure 8 provides confusion matrices comparing classification outcomes on JS vs. WASM-obfuscated scripts under the DeepFPD model.

-C3 Conversion Performance by Category

Table IX reports pipeline-level performance (e.g., coverage and success rate) across different fingerprinting categories in our dataset.

-D Naive Dynamic Analysis

Our dynamic analysis tool uses Playwright’s async Python API with the Chrome DevTools Protocol (CDP) to monitor fingerprinting behavior. It launches a headless browser, attaches a CDP session, and sets Debugger.setBreakpointOnFunctionCall hooks on selected navigator, screen, canvas, and audio APIs.

The tool evaluates each target in the page context, registers a function-call breakpoint, and maps its ID to a label. When any monitored API is accessed, CDP emits a Debugger.paused event. The handler records the label and resumes execution immediately. This process is encapsulated in a coroutine that instruments a page, runs the input JS, and returns an ordered list of accessed fingerprinting-relevant APIs.

The tool required no modification to the original script, i.e., it did not rewrite code, insert proxies, or rely on monkey patching. This minimized detection risk and preserved execution semantics. However, its stability was limited: for some scripts (both JS and WASM), the tool failed to register breakpoints or crashed during page load, likely due to timing issues or conflicts with CDP event handling.

We did not extensively debug these failures or optimize the tool’s design. Addressing such engineering challenges, while important for production-grade systems, was outside the scope of this study. Our focus was to evaluate whether a basic dynamic engine-level monitoring approach could detect runtime fingerprinting behavior, even after WASM obfuscation. The results confirm that this class of defense holds significant potential and deserves deeper exploration.