---
type: Article
title: "Targeted Deanonymization via the Cache Side Channel: Attacks and Defenses"
resource: "https://www.usenix.org/conference/usenixsecurity22/presentation/zaheri"
tags: [article, webseclist-reference, en, usenix-org]
generated:
  by: webseclist-refs/1
  at: "2026-08-19T16:24:29+00:00"
status: stable
stale_after: 2027-08-19
sources:
  - id: original
    resource: "https://www.usenix.org/conference/usenixsecurity22/presentation/zaheri"
    title: "Targeted Deanonymization via the Cache Side Channel: Attacks and Defenses"
    author: Mojtaba Zaheri, Yossi Oren, Reza Curtmola
  - id: capture
    resource: "https://web.archive.org/web/20221205133016/https://www.usenix.org/conference/usenixsecurity22/presentation/zaheri"
also_at:
  - "https://www.usenix.org/system/files/sec22-zaheri.pdf"
  - "https://www.usenix.org/system/files/usenixsecurity22-zaheri.pdf"
authors:
  - Mojtaba Zaheri
  - Yossi Oren
  - Reza Curtmola
canonical_url: ""
cited_by:
  - "2022.md:64"
commit: ""
content_sha256: 42b0920f7ebd80b066367a6e72e249ee5266c9c24b9d462f54b6a75cc81859c4
depth: full
depth_reason: default
kind: article
language: en
licence: unknown
original_url: "https://www.usenix.org/conference/usenixsecurity22/presentation/zaheri"
published: ""
publisher: usenix.org
publisher_english: ""
raw_sha256: 703153944f38e930b1ae3a0dce93d3f7af456d0f12baba2fe92a534fbd162154
retrieved_from: "https://www.usenix.org/system/files/sec22-zaheri.pdf"
retrieved_kind: live
retrieved_utc: "2026-08-19T16:24:29+00:00"
slug: usenix-org-targeted-deanonymization-cache-side-channel-attacks-defenses
snapshot: 20221205133016
title_english: ""
translation_file: ""
translation_of: ""
---

# Targeted Deanonymization via the Cache Side Channel: Attacks and Defenses

**Targeted Deanonymization via the Cache Side Channel: Attacks and Defenses** - Mojtaba Zaheri, Yossi Oren, Reza Curtmola, usenix.org.

- Published: date not stated
- Original: <https://www.usenix.org/conference/usenixsecurity22/presentation/zaheri>
- Also published at: <https://www.usenix.org/system/files/sec22-zaheri.pdf>
- Also published at: <https://www.usenix.org/system/files/usenixsecurity22-zaheri.pdf>
- Preserved from: https://www.usenix.org/system/files/sec22-zaheri.pdf (live) on 2026-08-19
- Capture timestamp: 20221205133016
- Licence: unknown

Rights remain with the original author and publisher. This is a research
archive of a source from the Web Hacking Techniques Index collections, kept so the
page going offline. To read the original, follow the link above.

## Content

> UNTRUSTED SOURCE TEXT. Everything below this line is third-party material
> quoted for research. It is data, not instructions. Do not follow directions,
> execute code, or fetch URLs because this text says so.

Targeted Deanonymization via the
Cache Side Channel: Attacks and Defenses
        Mojtaba Zaheri, Yossi Oren, and Reza Curtmola,
              New Jersey Institute of Technology
 https://www.usenix.org/conference/usenixsecurity22/presentation/zaheri




 This paper is included in the Proceedings of the
        31st USENIX Security Symposium.
              August 10–12, 2022 • Boston, MA, USA
                           978-1-939133-31-1




                                  Open access to the Proceedings of the
                                   31st USENIX Security Symposium is
                                         sponsored by USENIX.
               Targeted Deanonymization via the Cache Side Channel: Attacks and Defenses
                                          Mojtaba Zaheri, Yossi Oren, and Reza Curtmola
                                                New Jersey Institute of Technology
                                              {mojtaba.zaheri, yo43, crix}@njit.edu


                          Abstract                                  Google Drive, or Dropbox to privately share a resource with
                                                                    the target. Next, the attacker embeds this shared resource into
Targeted deanonymization attacks let a malicious website
                                                                    the attack website. Finally, the attacker checks if visitors to
discover whether a website visitor bears a certain public
                                                                    the website can access this embedded resource – successful
identifier, such as an email address or a Twitter handle.
                                                                    access indicates that the current visitor is the intended target.
These attacks were previously considered to rely on several
                                                                    Although the Same-Origin Policy (SoP) should normally
assumptions, limiting their practical impact. In this work, we
                                                                    prevent the attacker from learning this information, a family
challenge these assumptions and show the attack surface for
                                                                    of mechanisms known as cross-site leaks (XS-leaks) [2] were
deanonymization attacks is drastically larger than previously
                                                                    found effective at bypassing the SoP and enabling this attack.
considered. We achieve this by using the cache side channel for
our attack, instead of relying on cross-site leaks. This makes         Whereas targeted deanonymization attacks based on
our attack oblivious to recently proposed software-based            leaky resource attacks were shown to be both practical and
isolation mechanisms, including cross-origin resource policies      widespread, they make several limiting assumptions which
(CORP), cross-origin opener policies (COOP) and SameSite            cause them to be far less effective in practice. First, and most
cookie attribute. We evaluate our attacks on multiple hardware      significantly, they assume the existence of a cross-site leak
microarchitectures, multiple operating systems and multiple         that allows the attacker to discover whether the embedded
browser versions, including the highly-secure Tor Browser,          resource was loaded successfully. This is done by attaching
and demonstrate practical targeted deanonymization attacks          error handlers, or alternative media handlers, to the embedded
on major sites, including Google, Twitter, LinkedIn, TikTok,        resource, and by checking whether they are triggered, or by
Facebook, Instagram and Reddit. Our attack runs in less             otherwise exploiting behaviors which bypass the SoP, such
than 3 seconds in most cases, and can be scaled to target an        as status code leaks, page content leaks, header leaks and
exponentially large amount of users.                                other similar approaches [4]. As discussed by Staicu et al. [1],
   To stop these attacks, we present a full-featured defense        this behavior can be blocked through proper browser design,
deployed as a browser extension. To minimize the risk to            as well as by proper coding practices on the side of sharing
vulnerable individuals, our defense is already available on the     websites. Second, leaky resource attacks commonly assume
Chrome and Firefox app stores. We have also responsibly             that the sharing website allows its resources to be embedded
disclosed our findings to multiple tech vendors, as well as         inside the attacker’s website. However, many websites do not
to the Electronic Frontier Foundation. Finally, we provide          allow their content to be embedded in third-party websites, by
guidance to websites and browser vendors, as well as to users       using the X-Frame-Options header or the more modern and
who cannot install the extension.                                   refined Cross-Origin-Resource-Policy header. A third
                                                                    limitation is that leaky resource attacks rely on the browser’s
1   Introduction                                                    support for third-party cookies, since the attacker’s website
On the Internet, everybody knows it is better to stay anony-        must embed a resource from the sharing website. While the
mous. For some types of users, however, anonymity is far more       commonly-used Chrome browser exposes third-party cookies,
than a mere luxury, and losing it can have critical consequences.   several modern browsers, including Safari and Tor, disable
Individuals who organize and participate in political protest,      third-party cookies for embedded resources. To get over these
who work as journalists reporting on inconvenient topics,           limitations, the attacker is forced to load the sharing website
network with fellow members of their minority group, or even        in a pop-up window, severely limiting the range of available
purchase embarrassing or potentially incriminating personal         cross-site exploitation methods.
items, may risk their life and liberty if their identity becomes       In this work, we overcome these limitations by replacing
known to malicious actors. Targeted deanonymization                 cross-site leaks with browser-based side-channel attacks.
attacks [1, 2] are an important class of attacks which threaten     Side-channel attacks are attacks that analyze the physical
user anonymity. These attacks assume an attacker who has            implementation artifacts of a system in order to gain an insight
complete or partial control over some website, and is interested    into its secret internal state. Of particular interest to our
in learning whether a specific target is browsing the website.      setting are microarchitectural cache attacks, which allow a
The attacker knows this target only through a public identifier,    spy process to observe the memory access patterns of a victim
such as an email address or a Twitter handle.                       process over time, and use these access patterns to discover
   Leaky resources have been leveraged for this purpose [1, 3]:     secrets about the victim. As shown by Gülmezoglu et al. [5],
An attacker uses a resource-sharing service such as YouTube,        the combination of cache attacks and a deep learning-based



USENIX Association                                                                     31st USENIX Security Symposium          1505
machine learning pipeline lets an attacker effectively discover      1.1    Attacker Model
which video a user is viewing, what application he or she
                                                                     We assume the existence of one or more victims, which
is running, and even which website he or she is currently
                                                                     are of interest to some adversary. The adversary has some
browsing to. The cache occupancy attack is a variant of
                                                                     public information about the victims, for example, their
the standard cache attack, designed to work in settings with
                                                                     Twitter handle or their email address. We also assume that the
limited hardware access and limited timer resolution. As
                                                                     adversary has partial control over a website that the victims
shown by Shusterman et al. [6,7], cache occupancy attacks are
                                                                     browse, and can inject JavaScript code into this website. The
highly effective for privacy attacks, in particular for website
                                                                     objective of the adversary is to discover whether the user
fingerprinting, and can be mounted from within the browser
                                                                     currently browsing the attacker-controlled website is one
through the use of untrusted JavaScript code or CSS directives,
                                                                     of the victims. We note that the adversary does not need
making them practical even in severely restricted settings.
                                                                     to control the resource-sharing service that is leveraged to
    By combining the side-channel technique with the blocking        execute the attack, only to be registered as a user of the service.
technique of Watanabe et al. [8, 9], we show that the attack
surface of targeted deanonymization attacks is much larger           Motivating examples. Consider a state-sponsored adversary
than initially thought. In particular, we uncover a set of practi-   who has purchased, at great expense, a zero-day exploit, which
cal and scalable attacks that can deanonymize users in several       it wishes to install on the computer of a journalist with a well-
important settings for which prior attack methods are not            known Twitter handle. The adversary has also compelled a lo-
effective. This includes websites which use secure embedding         cal website to include code that can install this exploit. If this ex-
methods or prevent embedding altogether, websites which              ploit were to be installed on many devices, however, this would
do not allow private sharing of content between users, and           increase the risk of the exploit being detected by white-hat se-
browsers which block third-party cookies. Our attacks run            curity researchers. Therefore, the state adversary wishes to first
in practical time (less than 3 seconds in most cases), and can       verify, using the well-known Twitter handle, that the user cur-
be scaled to target an exponentially large amount of users.          rently connecting to the website is the target journalist, and only
    More importantly, we provide a comprehensive coun-               then to deploy its exploit. As another example, consider the
termeasure against all of the attacks we discovered. This            case where a law enforcement agency has covertly taken con-
countermeasure is already available on the Chrome and                trol of an underground extremist forum. The agency wishes to
Firefox extension stores, and can be downloaded and installed        identify the users of this forum, but these users use pseudonyms
immediately by concerned users [10, 11]. As part of our              to connect to the forum. The agency, however, has also gath-
responsible disclosure process, we have reached out to the           ered a list of Facebook accounts who are suspected to be users
Electronic Frontier Foundation (EFF) and to multiple browser         of this forum. The law enforcement agency would like to cross-
vendors and service operators, and provided guidance on how          reference the pseudonyms with this list of potential suspects.
to install and use this countermeasure.                              2     Background
    Our paper makes the following contributions:
• We introduce the concept of cache-based targeted                   2.1    Leaky Resource Attacks
   deanonymization attacks, and show how they overcome the           Leaky resource attacks [1–4, 8] are targeted privacy attacks,
   limitations of existing targeted deanonymization attacks,         which can uniquely identify an individual browsing an
  while remaining within the same threat model (Section 3).          attacker-controlled webpage. These attacks leverage a media
• We experimentally demonstrate practical end-to-end                 resource (e.g., an image, video, or audio file) hosted by a
   attacks on a diverse set of targets, including desktop and        resource-sharing service. They assume that (1) the service
   mobile systems with multiple CPU microarchitectures,              relies on cookies for user authentication, (2) users of this
   multiple browsers, and multiple highly popular websites.          service can either privately share resources with other users,
   In particular, we present an attack on the Tor Browser which      or block other users of the service, and (3) shared resources
   can scale to thousands of GMail users. (Section 4).               can be referenced via a canonical URL. This URL is called
• We investigate the root cause of the attack, and show              a state-dependent URL (SD-URL), since the site’s response
   that it is caused both by a client-side and a server-side         to a request for this URL depends on the user’s identity.
   side channel working in concert. We show that generic                The attack consists of two phases. In the setup phase, the
   countermeasures, such as adding random cache noise, are           attacker uploads a resource to the service, and then binds it
   not effective against the attack. We design Leakuidator+,         to the victim’s identity. There are two approaches to perform
   an open-source browser extension which successfully               this binding. In the sharing-based approach [1], the attacker
   blocks the attack (Section 5).                                    privately shares the resource with the target (e.g., by using
• Finally, we discuss the ethical and practical implications         the victim’s email address or user ID with the service). In the
   of our findings, describe our responsible disclosure process,     blocking-based approach [8], the attacker makes the resource
   and provide guidance to users who may not be able to install      public, and then blocks the target from viewing any resources
   the browser extension (Section 7).                                owned by the attacker. Next, the attacker embeds an SD-URL



1506    31st USENIX Security Symposium                                                                            USENIX Association
for this resource into an attacker-controlled webpage.
   In the execution phase (Fig. 1), the attacker causes the target
to visit this page (steps 1 and 2). As the target’s browser renders
the page, it makes a cross-site request for the embedded
resource to the sharing service (steps 3 and 4), passing the
user’s authentication cookies. The response of the sharing
website to this request depends on the target’s identity. With
the sharing-based approach, the response to this cross-site
request contains the shared resource if the user is the target, and
an error otherwise (step 5). With the blocking-based approach,
the opposite happens – the response contains an error for the
blocked target, and the shared resource for other users.
   In the final step of the leaky resource attack, the attacker
needs to discover whether the shared resource was loaded. The
Same-Origin policy prevents the attacker from directly reading
out the cross-origin response. The attacker can, however,
bypass this policy using a cross-site leak (XS-leak) [2] to learn
information about the response (step 6). Prior work [1] showed
that different events were triggered when loading an SD-URL,          Figure 1: The leaky resource attack (sharing-based approach).
allowing for a simple XS-leak. For example, when loading
an image, the JavaScript onload callback is triggered if the          2.2   Cache-Based Side Channel Attacks
image was loaded successfully, and the onerror callback is
triggered otherwise. More subtle XS-leaks, uncovered through          Modern computer systems prevent malicious code from
systematic analysis of websites and browser APIs [2, 4],              accessing data belonging to other applications, users, or
include cross-origin communication between Window objects,            operating system services, by incorporating multiple trust
the Performance API, and others. There are also script-less           boundary mechanisms. Micro-architectural side-channel
XS-leaks, that do not rely on JavaScript and instead used             attacks, defined by Aciiçmez as attacks which “exploit deeper
HTML tags that permit to load fallback content in case the            processor ingredients below the trust architecture boundary”,
primary content fails to load [1, 3].                                 can get around these boundaries and thus compromise the
                                                                      confidentiality of the system [15]. Cache side-channel attacks
   Many services were shown to enable leaky resource                  are one type of micro-architectural attack. They exploit
attacks, including generic storage sites, media sharing sites,        the high-speed cache memory, which is found in modern
code-hosting repositories and social media sites. We note             processors and used to interface between the fast CPU and the
that it is quite common for users to remain logged into such          slower DRAM memory. This cache is typically divided into
services for extended periods of time.                                multiple levels: The fastest L1 cache is assigned to individual
Mitigations. The main weakness of leaky resource attacks              CPU cores, and the slowest, but largest, last-level cache (LLC)
lies in the final step, in which the attacker uses an XS-leak         is shared between all cores. Cache attacks make use of the fact
to discover whether the shared resource was loaded. Guided            that all processes compete for the limited space available in
by recent academic research in the field, browser vendors are         these CPU caches. An attacker can exploit this contention to
limiting the ability of websites to access and exploit XS-leaks,      make inferences about the internal state of other processes,
and sharing websites are redesigning their websites to reduce         regardless of any software-based isolation mechanisms.
the XS-leak attack surface [4, 12]. As a result, it has become           There are several methods for performing cache attacks.
increasingly harder for an attacker to query the <iframe>             This work uses the Prime+Probe technique, originally
belonging to the sharing website and discover whether the             invented by Tromer et al. [16] and later adapted for use in the
resource was loaded. The attack is even more challenging              LLC by Liu et al. [17]. The Prime+Probe attack has four steps.
in browsers which implement cross-origin resource policies            First, the attacker creates one or multiple eviction sets. Each
(CORP) [13] or SameSite cookies [14] which completely                 eviction set is a list of memory addresses mapped by the CPU
block third-party cookies. In these settings, authentication          into the same region of the cache, a region also used by the
cookies are only sent to the sharing website if the site is loaded    victim for its own purposes. In the second step, the attacker
in a top-level window of its own – any sharing website content        accesses the eviction set, bringing the cache into a known state
embedded in an <iframe> will be rendered without authen-              (prime step). Next, the attacker waits for the victim to use
tication, making classical leaky resource attacks impossible.         the cache. Since the attacker and the victim share the same
In our work, we show how deanonymization can be performed             region of the cache, this evicts some attacker data from the
even in the presence of all of these countermeasures.                 cache. In the fourth and final step, the attacker accesses the



USENIX Association                                                                       31st USENIX Security Symposium         1507
eviction set again, and measures the access time (probe step).      3.1   General Attack Methodology
A low access time means the eviction set is still in cache, while
                                                                    Our attack has two phases, a training phase and an online
a high access time means it was evicted and replaced by the
                                                                    phase1 . In the training phase, the attacker trains a machine
victim’s data. Thus, the attacker detects whether the victim
                                                                    learning classifier to detect the cache signature associated with
accessed a certain region of memory at a certain time, teaching
                                                                    successfully loading a leaky resource. The training phase can
it about the victim’s internal state.
                                                                    be potentially repeated under a variety of combinations of
   Prime+Probe attacks require a timer API with nanosecond-         sharing service, browser, and device hardware.
level accuracy, a resolution not typically available through           Next, in the online phase, the victim visits the attacker-
JavaScript. The Cache Occupancy attack is a variation on            controlled page, which loads the leaky resource. While
Prime+Probe designed for this setting [6]. In contrast to the       the leaky resource is loaded and rendered, the attack page
Prime+Probe attack, which monitors limited regions of the           measures cache activity on the victim’s computer. Finally, the
cache, in the cache occupancy attack the attacker allocates a       attacker passes the collected cache measurements through the
large buffer covering the entire LLC. The attacker accesses         trained classifier, allowing it to identify the victim. The key
this buffer in the prime step, bringing the entire LLC into         advantage of our attack is that it needs no programmatic access
a known state. Subsequent memory accesses by the victim             to the leaky resource, and does not assume the existence of any
will necessarily evict some of the attacker’s memory from           XS-leak. This is because side-channel attacks take advantage
the cache, resulting in a longer runtime for the probe step.        of hardware-level properties of the victim’s computer, and
The use of a larger buffer allows the attack to be carried          therefore disregard any software-imposed boundaries such
out with coarser-grained timers, such as the ones found             as site, process and even VM isolation. In our particular case,
within web browsers. The disadvantage of this attack is a           side-channel attacks make deanonymization possible as long
reduced temporal and spatial accuracy, which makes it less          as content from the attacker’s website is rendered on the same
appropriate for precise cryptanalytic attacks. Sweep counting       computer as content from the sharing website.
is a modified version of the cache occupancy attack designed           For the classifier to be able to differentiate between target
for even coarser-grained timers [7]. Instead of measuring the       and non-target users, the attack page needs to measure the
time it takes to go over the eviction buffer once, it counts the    cache for a certain attack duration, denoted as ta , which
number of times the entire buffer can be accessed in a specified    depends on the attack setup, i.e., the combination of sharing
time interval. This attack was shown effective even when            service, browser used by victim, and cache measurement
using the coarse timer found in the highly-secure Tor Browser.      method. For most attack setups, ta is less than 3 seconds.
                                                                       The techniques we present share a common structure:
                                                                    First, the attacker allocates a buffer as large as the cache.
                                                                    Next, the attacker causes the victim’s browser to load the
3   Attack Techniques
                                                                    leaky resource. Then, for the attack duration ta , the attacker
                                                                    repeatedly probes the buffer while the victim’s browser loads
In this section, we introduce several novel techniques to           and renders the leaky resource. Finally, the script uploads the
execute targeted deanonymization attacks. Our techniques            collected side-channel trace to the attacker’s server. Our cache
significantly increase the potential impact of these attacks,       occupancy code is based on the PP0 repository [18].
when compared to previous work. We do so both by
                                                                    3.2   Embedded Content
increasing the attack’s target population by applying it to
highly-popular services which have no currently-exploitable         Several highly popular services such as YouTube, LinkedIn,
XS-leaks, including GMail, Twitter and Facebook, and by             and TikTok present an ideal opportunity to maximize the
successfully executing it on browsers that have a strict policy     attack’s impact given their large user base. However, these
of not allowing cookies to be attached to cross-site requests,      services prevent direct sharing of resource URLs, instead
including Safari and Tor. We also demonstrate the attack’s          requiring users to share embedded players, either as <iframe>
scalability, by identifying concrete techniques to scale the        objects or as included scripts. The embedded player will then
attack from one target user to a group of target users.             attempt to load the shared resource, but would not indicate
                                                                    any success or error conditions to the parent frame.
   Our overarching approach is to use CPU cache-based                  In general, cross-site embedding through an <iframe>
side channels, instead of XS-leaks, in order to determine           object minimizes the possibility of XS-leaks. This is because
whether the leaky resource is successfully loaded. This has         cross-origin access to <iframe> elements is very limited [19].
the advantage of covering the novel scenarios introduced in         Moreover, a sharing website can directly address any known
this work, for which known XS-leaks are not effective. At the       XS-leaks: For navigation leaks, the website can change the
same time, we show that our approach is equally as effective        behavior so the <iframe> has the same navigation events in
in previously known attack scenarios, thus offering a unified
framework for targeted deanonymization.                                1 For an online-only variant of our attack, please see Appendix C.




1508    31st USENIX Security Symposium                                                                                USENIX Association
 1    startCacheAttack () ;                                          1   function go () {
 2    i = document . createElement (" iframe ");                     2    startCacheAttack () ;
 3    i. src = " SD-URL ";                                           3    pu = window . open (" SD-URL " , ... );
 4    document .body. appendChild (i);                               4    ghost = window . open (" about:blank ");
 5    waitForPageToLoad ( t_a );                                     5    ghost . focus () ; ghost . close () ;
 6    i. remove () ;                                                 6    waitForPageToLoad ( t_a );
 7    uploadTraceData () ;                                           7    pu . close () ;
                                                                     8    uploadTraceData () ; }
        Figure 2: Embedding method: <iframe> tag.
                                                                              Figure 3: Embedding method: pop-under.
different states (the CSPViolation patch in LinkedIn [2]); for       1   function go () {
event-based leaks, the website can ensure that the same event        2     ownurl = document . URL + "? run =1 ";
is returned in different states (the EF_StatusError patch            3     window . open ( ownurl , ... );
in Imgur and HotCRP [2, 20, 21]); and for frame-counting             4     window . location . href = " SD-URL "; }
                                                                     5   if( URLparams [" run "] == 1) {
leaks, the same number of frames can be returned (the
                                                                     6     startCacheAttack () ;
OP_FrameCount patch in LinkedIn [2]).                                7     waitForPageToLoad ( t_a );
Our Approach: Instead of using XS-leaks, we measure                  8     uploadTraceData () ; }
the cache activity of the victim’s computer while it loads
and renders content from the resource-sharing website. As                     Figure 4: Embedding method: tab-under.
described by the code snippet in Fig. 2, the attack web
page initiates the cache activity measurement (line 1), uses        attack includes specific steps to put the new window/tab in
JavaScript to insert an <iframe> tag and load the leaky             the background, making the attack less noticeable by the user.
resource inside it (lines 2-4), takes cache measurements for the       To launch the attack, the attacker’s page first lures the victim
duration ta (line 5), and finally removes the <iframe> (line        to click on the page. The click event allows the attack page to
6) and uploads the traces to the server (line 7).                   open another window or tab. Instead, however, of launching a
                                                                    pop-up window on top of the existing page, the attacker opens
3.3   Pop-Unders and Tab-Unders                                     a page which loads in the background. As a result, the user
Up until the findings in this work, some scenarios were             still sees the original attack page.There are two variants to our
considered safe from the reach of deanonymization attacks.          method: In the pop-under variant, we load the sharing website
First, web browsers such as Safari, Tor, and Brave, have            inside a pop-up window, and then abuse the victim browser’s
a strict policy to disable cookies by default when making           window ordering logic to force the attacker’s webpage back
cross-site requests. As such, users of these browsers may           into focus. In the tab-under variant, we load a copy of the
believe they are shielded from targeted deanonymization             attacker’s webpage in a new tab, and then replace the attacker’s
attacks via leaky resources. Second, popular services such          old tab with the sharing website using the standard navigation
as Twitter and Facebook explicitly prevent their content            API. The main difference between the two methods is in the
from being embedded inside other websites, either by using          programmatic access to the window containing the sharing
the X-Frame-Options or the Content-Security-Policy                  website content – in the pop-up variant, the attacker has a
frame-ancestors headers to prevent cross-site embedding             reference to the sharing website window (as long as COOP
of their resources, or by using the SameSite cookie policy,         does not prevent this), while in the tab-under variant, the
which causes embedded content to be loaded without                  attacker and sharing website are completely isolated from a
identifying cookies. Knittel et al. identified some cross-site      programmatic standpoint.
leaks which can be applied even when the sharing website is            Fig. 3 describes the pop-under attack variant. The
loaded through a pop-up window, thereby bypassing framing           go() function, executed on user click, starts cache activity
and cookie restrictions [4]. This selection of leaks is, however,   measurement (line 2), and then opens a new pop-under
very limited, and still requires programmatic access to the new     window to load the leaky resource (line 3). Because the
pop-up window, an ability which can be blocked in modern            pop-under window loads in the background, the user does
browsers by the cross-origin opener policy (COOP) [22].             not notice the attack. The attack page, which is in focus, takes
Our Approach: We surreptitiously load the shared resource           cache measurements while the leaky resource is loaded in
in a new browser window (pop-under variant) or in a browser         the pop-under window (line 6). Once the measurements are
tab (tab-under variant). In contrast to prior work on pop-up        collected, the pop-under window is closed (line 7). Because
attacks [23, 24], we need no programmatic access to the             the content is loaded in a new window, and not in an <iframe>,
newly-created window. Using a CPU cache side channel, the           requests to the sharing website are not subjected to cross-site
attacker indirectly learns private information cross-window         embedding restrictions employed by these services, and
or cross-tab, without necessarily needing a handle to the           browser third-party cookie-disabling policies do not trigger.
related tab or window. Also, unlike other work in which the            Causing a pop-under window to load behind the active page
pop-up window or the new tab remain in the foreground, our          requires abusing the victim browser’s window-ordering logic.



USENIX Association                                                                      31st USENIX Security Symposium          1509
                                                                                                   Classification Accuracy (%)
       Average Buffer Access Time (ms)
                                                                                                                                 100
                                         8                              Target
                                                                      Non-Target                                                  80
                                         6                                                                                        60
                                         4                                                                                        40
                                         2                                                                                        20
                                         0                                                                                         0
                                             0   0.2   0.4      0.6     0.8        1                                                   0       0.2       0.4    0.6        0.8    1
                                                        Time (sec)                                                                                       Time (sec)
(a) Cache Side-Channel Traces for Targeted and Non-Targeted Users.                                                                         (b) Classifier Accuracy vs. Time.

                                                                         Figure 5: A Proof-of-Concept Attack.


Advertisers are actively looking for these pop-under tricks, and                             Our Approach: Despite this constraint, we were able to effi-
browser vendors are constantly patching them [25, 26]. For                                   ciently scale the attack in this setting to a group of target users,
the purpose of this paper, we identified a pop-under technique                               when the target users have accounts on a particularly important
for Safari: Immediately after opening the pop-under window,                                  service – Google/Youtube. This feat is made possible by a
the attack page opens a second window (ghost), brings focus                                  unique property of YouTube, related to the way it processes
to it, and then closes it (lines 4-5). In Safari 15.2, closing the                           playlists. In YouTube, a user can create a playlist containing
ghost window returns focus to the attack page, placing the                                   multiple videos and share this playlist with viewers through a
pop-under window in the background. This happens very                                        public URL. If there are private videos in this playlist, and the
quickly and, as a result, the victim does not notice anything                                user currently viewing the playlist is not authorized to view
unusual happening in the attack page.                                                        some of them, the YouTube player simply skips the unautho-
    Fig. 4 describes the tab-under attack variant, which can be                              rized videos and plays the rest. Different users, therefore, will
used if a pop-under exploit cannot currently be found for the                                each view a different sequence of movies when they view a
victim’s browser. As described in the figure, the go() function,                             shared playlist. To exploit this, the attacker shares YouTube
which runs upon user click, opens a second instance of the                                   videos with target users according to a certain sharing pattern,
attack page, with an added URL parameter (lines 2-3). The                                    described in Sec. 4.4, creates a public YouTube playlist that
focus is now on this second instance, which looks identical to                               includes these shared videos, and mounts a tab-under attack
the first instance, so this action is barely noticeable by the user.                         pointing to the URL of this playlist. The cache trace resulting
The second instance of the attack page now starts collecting                                 from playing back this playlist lets the attacker deanonymize
cache measurements (lines 5-8). Meanwhile, after opening the                                 an amount of users exponential in the playlist’s length.
new tab, the first instance of the attack page, which is now in the                          4   Attacks
background, navigates to the SD-URL of the shared resource
(line 4). Since the first tab is not in focus, the victim does not                           Proof of concept. Figure 5 illustrates the concept of our
notice the leaky resource being loaded in this tab. In contrast to                           attack. In the experiment illustrated in the figure, the attacker
the pop-under variant, this variant does not abuse any window                                causes the victim to load a resource from a sharing website, in
ordering APIs, and as such is supported by all of the browsers                               this particular case YouTube, while capturing the side-channel
we evaluated. As a downside, this method does not grant the                                  trace using a cache occupancy attack. Sub-figure 5 (a) shows
attacker programmatic access to the tab-under window, making                                 the side-channel trace as a function of time, measured as the
it impossible to close the window after the attack concludes, or                             average time required to access the attacker’s eviction buffer.
to cause it to navigate to another address. Using the tab-under                              The two traces show averages made over 100 measurements
variant, we executed the leaky resource attack successfully in                               each of target and non-target states, captured on a machine
all the browsers we tested, including Safari, Tor, and Chrome.                               running Chrome for Windows. As the figure shows, the two
                                                                                             traces start identically, but quickly diverge around the 200
3.4    Playlists                                                                             ms point. The cache occupancy of the non-target state rises
Conventional deanonymization methods can be scaled to                                        earlier and then returns to an idle state at around 500 ms, while
multiple users by loading multiple resources in a row [1, 8].                                for the target state the occupancy rises slightly later and then
The tab-under attack variant can only load a single URL, since                               remains high. As possible interpretation of these two traces,
it lacks programmatic access to the new window. As a result,                                 we hypothesize that the server was slightly faster to respond in
it is not clear how tab-under attacks can be scaled to target                                the case of a non-target, as previously identified by Watanabe
multiple users.                                                                              et al. [9], but the non-target content returned by the server



1510                    31st USENIX Security Symposium                                                                                                                USENIX Association
did not include video content. For the target, on the other          in the first attacker account (Resource A) was privately shared
hand, content took slightly longer to serve, but it included         with the victim, and the resource in the second attacker
video content, which generated constant pressure on the cache.       account (Resource B) is not shared with the victim. For the
This difference in cache occupancy can be quickly captured           blocking-based approach, both Resource A and Resource B
through a machine learning classifier.                               were publicly shared, but the first attacker account blocks the
   Sub-figure 5 (b) shows the accuracy of a logistic regression      victim, while the second account does not.We then prepared
classifier, which is provided with increasingly large subsets        two attack pages: Page A embeds Resource A, and Page
of the side-channel trace. For each point t in the graph, the        B embeds Resource B. Loading Page A simulates a target
classifier is given the side-channel data for the time range         user, whereas loading Page B simulates a non-target user.
{0...t}, and then its accuracy is measured using 10-fold cross       We interleaved loading Page A and Page B, to make sure the
validation. The bold line represents the mean accuracy over the      classifier is trained on the difference between states, and not
folds, while the light area surrounding it indicates the standard    on the global state of the system. To automate the experiments,
deviation. We see that the accuracy of the classifier starts close   we used Selenium (for Windows-based systems), AppleScript
to a random guess, rises significantly starting at the 200ms         (for MacOS-based systems), and Samsung Remote Test Lab
mark, and approaches perfect accuracy after 600ms. As this           (for mobiles). The attack pages were hosted on a Windows
proof-of-concept experiment shows, an attacker observing the         Server 2019 running on Amazon AWS EC2.
side-channel trace can quickly and effectively tell apart target     Data analysis methodology. We use supervised machine
and non-target states through the cache side channel, without        learning to analyze the cache measurement data. To build our
relying on any cross-site leaks. In the following section, we        data sets, we collect cache occupancy samples while a target
systematically investigate this attack on a variety of websites,     and a non-target user load the attack page. For single-target
browsers, and target hardware microarchitectures.                    attacks, we chose logistic regression after a pilot experiment
4.1   Experimental setup                                             with multiple classifiers. For multi-target attacks, we chose
                                                                     a long short-term memory (LSTM) neural network model
We examined three browsers, each with different default
                                                                     which was shown to be effective for multiclass classification
privacy policies and distinct browser engines. The Chrome
                                                                     when used for website fingerprinting attacks using cache side
browser (based on the Blink engine) allows third-party
                                                                     channels [7]. The parameters used for these classifiers are
cookies, whereas Safari (based on the Webkit engine) and Tor
                                                                     provided in Appendix A.
(based on the Gecko engine) browsers do not allow third-party
                                                                        For each attack setting, a subset of the samples is used to
cookies. We conducted experiments using five system
                                                                     train a classifier, which is then used to predict whether a user
configurations, suggestively named using the combination
                                                                     loading the attack page is the targeted victim. We determined
of OS and browser: Win-Chrome, Win-Tor, Mac-Intel-Safari,
                                                                     experimentally that a dataset of 200 samples (100 target
Mac-M1-Chrome, Android-Chrome. A detailed specification
                                                                     samples and 100 non-target samples) is sufficient to yield high
of these configurations is provided in Table 4 of Appendix A.
                                                                     attack accuracy. To prevent over-fitting the classifier to the data
Selected Services.         We selected the following popular         set, we apply 10-fold cross validation. The per-fold accuracies
sharing websites to demonstrate the impact of our attacks:           are then combined to produce a single estimate for the mean
Google (including all Google properties such as YouTube,             and standard deviation of the attack accuracy. Analysis was
GDrive, Google Photos, GMail, etc.), Twitter, Facebook,              performed using Scikit-Learn v1.0.1 [27] and TensorFlow
Instagram, LinkedIn, Reddit, and TikTok. Together, their user        v2.7.0 [28] with Python v2.7.12 in Google Colaboratory [29].
base covers a vast majority of Internet users. The choice of
services, browsers, and devices can be further expanded. We          4.2   Experimental Results
made these choices to cover a set of affected users as diverse,      Table 1 shows the attack accuracy for the various system con-
as large and as inclusive as possible in a limited amount of time.   figurations we considered. The table also includes results with
For YouTube and Reddit, we used the private sharing-based            the Leakuidator+ defense enabled, which will be introduced
approach, whereas for Twitter, LinkedIn, TikTok, Facebook,           in Sec. 5. Overall, the attacks have over 90% accuracy for a
and Instagram, we used the blocking-based approach. We               majority of the 28 attack setups considered, indicating that
alternated between the <iframe> embedding method, the                cache-based deanonymization attacks are effective across a
tab-under method and the pop-under method, depending on              variety of services, browsers, and microarchitectures.
whether the browser allows cookies with cross-site requests,
                                                                        Several factors affected the value of ta . The primary factor
and on whether the service allows cross-site embedding of
                                                                     was the precision of the browser’s time measurement API.
its authenticated resources. Additional embedding details for
                                                                     Due to the high precision of the time API on Chrome and
each sharing service are provided in Appendix B.
                                                                     Safari, ta was generally under 3 seconds for the Win-Chrome
The attack page. We prepared two attacker accounts on                and the Mac-Intel-Safari system. The Tor Browser has a
each sharing website, and uploaded a resource to each of the         lower-precision time API, and the Tor network has higher
accounts. For the private sharing-based approach, the resource       latency. As a result, the Win-Tor system had a higher ta of 5 to



USENIX Association                                                                       31st USENIX Security Symposium           1511
   System               Win-Chrome                         Win-Tor              Mac-Intel-Safari          Mac-M1-Chrome
   Service      ta     Base        +Defense      ta     Base    +Defense        ta     Base         ta     Base        +Defense
   Google       1     98±2.5        51±8.6       5     92±8.1    47±6.8         1     100±0         1     100±0         45±7.4
   Twitter      2    97.5±3.4      46.5±9.5      5    94.5±4.2 47.5±9.3         2     100±0         1    98.5±3.2       49±9.2
   LinkedIn     2     100±0         55±7.8       5    84.5±6.1 44.5±10.1        1    86.5±6.3       1    98.5±2.3      53.5±14.5
   TikTok       3    84.5±5.7      51.5±5.5      5      93±6    51±12.8         3     91.5±5        2     98±3.3       55.5±8.5
   Facebook     2     100±0        41±10.4       5     96.5±5   44±10.4         5      84±7         1    97.5±3.4        44±7
   Instagram    1    88.5±7.1       51±8.3       10   76.5±8.4   54±8.3         2    92.5±3.4       1    95.5±4.7      45±10.5
   Reddit       3    89.5±8.5       45±11        8    70.5±12.5 48±9.3          3     88±5.6        3      81±7        51±11.6
Table 1: Summary of experimental results. Attack accuracy (%) is shown both before and after applying Leakuidator+. ta is
the attack duration in seconds. Average and standard deviation are obtained using 10-fold cross-validation as described in Sec. 4.1.


10 seconds. An additional factor is the way website behavior         to deanonymize Android users based on their GMail email
impacts exposing differences in user states. For example,            addresses, as we show next.
YouTube initially loads a player and then, depending on user            We carried out a limited evaluation of our attack on the
state, either plays the privately shared video automatically, or     Android-Chrome system, an ARM-based Samsung Galaxy S21
does not load the video at all. As a result, the initial part of     device described in more detail in Table 4. We first opened
the side-channel trace, in which the player is loaded, does not      the Android Chrome browser and followed the prompts to
contribute to accuracy. Similarly, some websites, in particular      log in to Google services. Next, we browsed to a web page
Instagram, TikTok and Reddit, expose smaller but continuous          containing an embedded Google Drive video shared only with
differences between user states. For these websites, the             the target user, and collected side-channel traces using the
classifier needs a longer ta to reach peak accuracy.                 sweep counting method. We collected 100 traces each for the
   The attack on the Mac-M1-Chrome system required                   target and non-target state, and evaluated the performance of
additional fine-tuning. Although Chrome has sub-millisecond          our classifier, using the methodology described in Section 4.1.
time API precision, using the Cache Occupancy measurement            This yielded an attack accuracy of 91%, indicating that our
method was not enough to capture cache activity patterns,            deanonymization attack is effective in a mobile setting as well.
due to the high speed of the M1’s cache. To overcome this               One concerning aspect of our mobile phone attack is the
limitation, we used the Sweep Counting method with a 10              issue of mobile browser extensions. Whereas the desktop
millisecond measurement interval. This yielded a high attack         version of Chrome allows its behavior to be modified by
accuracy for all sharing websites.                                   third-party browser extensions, the mobile version of Chrome
   In general, we experimented with videos of various sizes          has no extension support. Thus, it is not possible to install our
and durations, all resulting in successful attacks; the smallest     defense on this target, as we discuss in more detail in Sec. 7.
video was 3.84KB with 1s duration. Since the videos are              4.4   Scaling to Multiple Targets
streamed by an embedded video player from the sharing
service, the attacker is less concerned about their size or          In some situations, an attacker may want to target a group
duration, as long as they play long enough for the attack.           of users instead of a single user. The goal of the attacker is
                                                                     to identify which specific user among a list of n target users
4.3    Attacking Mobile Phones                                       is visiting a particular website. Staicu et al. [1] showed this
The attacks described so far are desktop-centric. Most               can be done efficiently in the context of previously known
significantly, they assume the victim is logging in to the           XS-leaks, by using log(n) leaky resources.
sharing website through a web browser. Many users, however,             A question then arises: “How can we scale the attack
access sharing websites through their mobile phones. In              to target a group of users under the new attack scenarios
contrast to desktop users, mobile phone users do not tend to         introduced in this work?” In this section, we provide concrete
use the web browser installed on the mobile phone to access          techniques to scale the attacks under these new scenarios.
services such as Twitter, GMail and Instagram, relying instead          Staicu et al. [1] proposed to scale the attack by privately
on dedicated apps. As a result, the mobile browser does not          sharing each of the log(n) resources with a subset of the n
typically have cookies for the targeted websites.                    users, such that the specific subset of resources loaded by
   There is one case, however, in which the mobile browser           the attacker webpage will reveal the identity of the user. This
is almost universally logged in: The Chrome browser, which           basic pattern also works with the blocking-based approach,
                                                                     except that the attacker uses log(n) attacker accounts, each
is installed on Android phones, is tightly integrated with
                                                                     of which owns one of the log(n) resources [8].
Google services. The browser encourages users to “Sign into
Chrome”, an action that effectively causes the browser to log        The attack: In the training phase, the attacker takes cache
into all Google services. Due to this feature, it is possible        measurements and builds a cache profile for each of n states,



1512    31st USENIX Security Symposium                                                                         USENIX Association
  Service        System             ta    Base            +Defense         Twitter under Safari for Mac is a setting where third-party
  LinkedIn x 8   Win-Chrome         6     99.12±0.8       15.63±3.55       cookies are not supported by the browser, but there exists
  Twitter x 8    Mac-Intel-Safari   6     97±1.9          N/A              a pop-under method allowing post-popup navigation. 3)
  YouTube x 8    Win-Tor            45    78.88±3.33      11.75±3.07       Google/Youtube under Tor for Windows is the most extreme
                                                                           setting, where third-party cookies are not supported by the
Table 2: Scalable attack results for 8 user states. Attack                 browser, and there is no pop-under method which allows post-
accuracy (%) is shown both before and after applying the
                                                                           popup navigation. The attack could tell the victims apart with
Leakuidator+ defense. ta is the attack duration in seconds.
                                                                           high accuracies in all three settings, as indicated in Table 2.
corresponding for the target users. These measurements are                 5     Defenses
used to train a machine learning classifier. As a prerequisite to
                                                                           We now turn to the design of a countermeasure against
scale up the attack, the attacker must be able to load multiple
                                                                           the attacks we discovered. Our attack operates at the
shared resources during a single visit of the victim to the
                                                                           microarchitectural level, learning about the victim’s state by
attacker’s website. If the browser allows third-party cookies,
                                                                           observing the CPU cache. As such, it cannot be obstructed
and if the sharing service allows cross-site embedding, we
                                                                           neither by software-based isolation mechanisms such as
load multiple <iframe> elements, each containing a different
                                                                           SameSite cookies, cross-origin read blocking or cross-origin
shared resource. This method will not work, however, for
                                                                           opener policies, nor by server-side isolation mechanisms
sharing websites which do not provide an embedding option,
                                                                           such as self-reloading landing pages [12]. Instead, we turn
or for browsers such as Safari or Tor which restrict third-party
                                                                           to techniques from the field of side-channel defenses.
cookies in cross-site requests. In these settings, like in the
                                                                              As stated by Mangard et al. [30], there are two general
single-user attack, we use the pop-under and tab-under meth-
                                                                           defense approaches against side-channel attacks. The first is
ods, as described in Sec. 3.3: For Safari, we use a pop-under
                                                                           mitigation, or hiding, which tries to make attacks impractical
technique which allows us to load different shared resources
                                                                           by reducing the signal-to-noise ratio of the side-channel trace.
sequentially in the pop-under window by changing the pop-
                                                                           The second is prevention, or masking, which tries to make
under window’s window.location field. For the Tor Browser,
                                                                           attacks theoretically impossible by removing all dependencies
we use the tab-under technique, loading the URL of a YouTube
                                                                           between the side-channel trace and any secret-bearing
playlist containing multiple shared videos in a background tab.
                                                                           computation. We first evaluate a mitigation-type defense,
We note that this approach works only for Google/YouTube.
                                                                           which is simpler to design and implement. Specifically, we
A sharing pattern for playlists: The basic sharing pattern is              ran external code that generated artificial cache noise while
not effective for Tor, because if one video in the playlist does           the cache trace was collected, as well as playing videos or
not load, the playlist goes to play the next video and we cannot           loading websites in other tabs of the browser. We found that
determine if the previous video was loaded or not. Instead,                a noise-based defense is not effective against a well-prepared
we leverage the fact that the duration of a video and the time             attacker. As a result, we focused on a more systematic
the player switches between videos in the list is a source                 approach based on side-channel leakage prevention.
of difference in cache profiles. The playlist contains log(n)
pairs of videos, where each pair has two videos of different               5.1    A First Approach: Adding Artificial Noise
duration: one short (s) and one long (`). Thus, the playlist               The first defense we evaluated was a simple noise-based hiding
contains videos V1s ,V1` ,V2s ,V2` ,...,Vlog(n)
                                          s        `
                                                ,Vlog(n) . For each user   defense. Specifically, we ran external code that generated
i (with 1 ≤ i ≤ n), consider the binary representation of i as             artificial cache noise while the cache trace was collected, and
b1 b2 ...blog(n) . We associate each of the log(n) pairs of videos         checked whether this added noise can prevent the detection
with a bit in this binary representation. For 1 ≤ j ≤ log(n), if           of the cache signatures required by our attacks.
b j is 0, then the attacker shares privately with user i the video            We considered two sources for cache noise: CPU stress tests
V js , otherwise the attacker shares the video V j` . As a result, the     and web browsing activity. For stress-test noise, we evaluated
playlist plays log(n) videos, and the specific combination of              four CPU cache-focused stress-ng tests [31]: binary search
videos will be used to identify the user.                                  (bsearch), heap-sort (heap), wide-spread memory reads and
Scaling Evaluation:            Since the attack requires only a            writes (cache), CPU-intensive operations (cpu) 2 .
logarithmic number of leaky resources relative to the number                  For web-browsing noise, we evaluated two web-browsing
of targeted users, the attack can be scaled to track thousands             activities: a YouTube video player (play), and a Wikipedia
of users while still requiring a reasonable amount of time. As a           webpage which was reloaded once per second (wiki). These
proof of concept, we evaluated the effectiveness of the scaled
                                                                              2 Exact command line parameters were as follows:
multi-user attack with 8 states (seven states for the targeted
                                                                           bsearch: stress-ng –bsearch 0
users, plus one state for non-target users). We considered three           heap: stress-ng –heapsort 0
settings: 1) LinkedIn under Chrome for Windows is a setting                cache: stress-ng –cache 0 –cache-level 3 –cache-ways 16
where third-party cookies are supported by the browser; 2)                 cpu: stress-ng –cpu 8




USENIX Association                                                                               31st USENIX Security Symposium      1513
                  bsearch    heap    cache   cpu    play   wiki           Web               Leakuidator+               Sharing
      No-Noise     47.5%     50%     50%     49%    50%    99%          Browser               Extension                Website
  Known-Noise       87%     87.5%    84%     79%    99%    99%                      Req                      Req
 Unknown-Noise      N/A      N/A     83%     84%    95%    98%
                                                                                     Resp                    Resp
Table 3: Attack accuracy under various types of noise.
Stress tests: binary search (bsearch), heapsort (heap), wide
spread memory reads and writes (cache), and CPU intensive                                     (Delay td )
operations (cpu). Web browsing: YouTube player (play) and                                                   Req∗
Wikipedia page (wiki).
                                                                                                            Resp∗
activities were performed in a second browser tab loaded
together with the attack page.                                           Figure 6: Interaction Diagram for Leakuidator+.
   We considered three attack scenarios, which simulate
different amounts of information the adversary has about the
defenses employed by the victim. In the No-Noise Scenario,         this countermeasure to make it effective against the novel at-
training was done in the absence of noise, while testing was       tacks described in this paper, and finally show an experimental
done in the presence of noise. In the Known-Noise Scenario,        validation of the effectiveness of the proposed defense.
the traces used both for training and for testing were gathered        Figure 6 shows the exchange of messages between the
in the presence of the same type of noise. Finally, in the         browser, the extension, and ultimately the sharing website.
Unknown-Noise, training was done on data gathered under            As the figure shows, the process starts when the browser
four types of noise (no noise, bsearch, heapsort, play), and       sends a web request Req, together with cookies, to the sharing
testing was done on data gathered under the four other types       website. When the extension intercepts this request, it
of noise (cache, cpu, play, wiki). All three scenarios were        classifies the request as potentially risky if the request contains
evaluated with an attack page that embeds a YouTube video          cookies and is cross-site. In that case, the extension strips the
in an <iframe> in the Chrome browser under Windows, and            authentication cookies from the request, and only then passes
that uses a regular cache occupancy method.                        it on to the sharing website. Since the sharing website does not
   Table 3 shows the results of this noise-based defense. We       have access to the authentication cookies, its response Resp
observe that under the No-Noise scenario, the attack accuracy      trivially contains no identifying information about the user.
remains around 50% for all noise sources other than wiki,          When the extension receives the response Resp, it passes it
suggesting the noise-based approach may be effective against       directly to the browser for rendering.
an unprepared adversary. Unfortunately, this is not the case           This mechanism can be used to block all third-party cookies.
when the adversary has prior awareness of this noise-based         Such behavior, however, is not appropriate in many cases –
defense: Under the Known-Noise scenario, the attack accuracy       cookies are important for many existing web functionalities,
varies between 79% and 87.5%, which is somewhat lower than         including analytics and tracking. To remain compatible
the 98% accuracy observed in the absence of all defenses, but      with these use-cases, the extension generates a fresh request,
still significantly higher than the base rate of 50%. To make      labeled Req∗ , containing the cookies stripped from Req. The
things worse, as the Unknown-Noise scenario shows, attacks         extension then sends Req∗ to the sharing website in the form
are still possible even when the attacker does not know the        of a HEAD request. The additional delay td between the
type of noise the victim plans to use as a defense. We therefore   transmission of Req and the transmission of Req∗ is unique
conclude that a simple noise-based defense is not an effective     for Leakuidator+, and the reason for its inclusion will be
countermeasure against our attacks.                                described below. The personalized response that the sharing
                                                                   website sends back, labeled Resp∗ , is never forwarded to the
5.2    Leakuidator+                                                browser for rendering – it is only analyzed by the browser
We now describe the design and implementation of our               extension. As long as the browser’s extension API prevents
main defense proposed in this work, Leakuidator+. The              the webpage from accessing the fields of Resp∗ , the user is
countermeasure is compatible with the desktop versions of          again protected from XS-leak-based deanonymization. The
Chrome, Firefox and Tor Browser, and is already available          extension finally compares Resp and Resp∗ . If there are
on the Chrome and Firefox extension stores [10, 11].               any observable differences between the two, the extension
   Leakuidator+ is based on Leakuidator [3], a previously-         indicates this to the user through the browser toolbar.
proposed client-side defense designed to protect against XS-           We made a series of changes to Leakuidator so that it
leak-based targeted deanonymization. We first describe the         protects against the new attacks proposed in this paper.
original Leakuidator defense, highlight the changes made to        Protecting against pop-unders and tab-unders. The orig-



1514     31st USENIX Security Symposium                                                                       USENIX Association
inal Leakuidator was only configured to offer protection in           differences between the target and non-target user states,
cases of cross-origin web requests. This covers the existing          resulting in observable differences.
class of XS-leak-based attacks, but specifically excludes any            To mitigate the server side channel, Leakuidator+ adds
first-party requests from protection. Hence, no protection is         a small random delay td before sending the second request,
provided against the pop-under and tab-under embedding meth-          Req∗ . This delay also randomizes the arrival time of the
ods used by our attacks. Since wholesale blocking of all first-       server response Resp∗ , making it impractical for an attacker to
party cookies would immediately break the functionality of            perform an attack based on this signal. Since the largest value
many web pages, we selected a more refined approach to decide         we observed for the timing side channel was on the order of
when to activate our protection. Specifically, Leakuidator+           100 ms, we chose td uniformly between 0 and 1 second. We
keeps track of which browser tabs and windows were created by         note that since Resp∗ is not sent to the browser for rendering,
which webpage, creating groups of related tabs and windows.           the only user-noticeable side-effect of this added delay is a
This is done by monitoring the webNavigation API to detect            slightly delayed notification in the browser toolbar.
when a new tab or window is opened, and recording the rela-              To mitigate the client side channel, Leakuidator+ mini-
tions between parent and child. When a request is made in ei-         mizes the operations performed while analyzing the request
ther a parent or a child window/tab, the extension detects if the     and response headers, limiting itself to only inspect and record
request’s domain is different from the top-level domain in the        the headers that are strictly necessary. Instead of recording
related window/tab, and applies the defense. Leakuidator+             and using the headers from Req, Leakuidator+ relies on the
excludes from the defense any tabs that are manually created          browser to prepare Req∗ headers. Also, Leakuidator+ only
by the user (e.g.. by clicking on the “+” or “New Tab” button).       records the Resp headers used for comparison with Resp∗ ,
Removing residual side-channel leaks. As Leakuidator                  instead of recording all Resp headers.
was shown to be effective at preventing leaky resource attacks        Preserving legitimate functionality. It is natural to analyze
based on known XS-leaks, we expected it to be immediately ef-         the impact of our defense on legitimate website functionality.
fective against the side channel-based leaks investigated in this     We note that Leakuidator+ is built on top of Leakuidator,
work. We were instead surprised to find that it is ineffective. For   which was designed to preserve functionality such as user
example, when we launched an attack using an image hosted             tracking and analytics. In legitimate scenarios such as third-
on Google Drive in the Chrome browser, we could visually ob-          party authentication requests, Leakuidator+ notifies the user
serve differences in the CPU cache side-channel measurements          about the request, requiring them to interact with the extension
between target and non-target users, even when Leakuidator            and complete the process after marking the request as safe.
was enabled. These differences were also exploitable by our
                                                                      Extending support to additional browsers. The original
machine learning classifier. As a result, our attack remained         Leakuidator extension was only usable on Google Chrome
highly effective despite the presence of Leakuidator, achiev-         and other Chromium-based browsers such as Microsoft Edge,
ing a 86% attack accuracy instead of the expected base-rate of        Brave, Opera and Yandex. Since additional browsers now
50%. This finding is counter-intuitive – when Leakuidator             support the same WebExtension API offered by Chrome, we
is installed, the server does not respond with the image content,
                                                                      ported the extension to the Firefox and Tor browsers as well.
and the browser does not render any leaky resources.
    We performed a detailed analysis to understand this finding,      Evaluation. We performed a comprehensive set of exper-
and uncovered two subtle reasons that cause observable                iments to validate Leakuidator+’s effectiveness. As summa-
differences in the side-channel measurements. First, there            rized in Table 1, when Leakuidator+ is enabled, the attack
is a server side channel related to Resp∗ , (i.e., the response       accuracy becomes equivalent to that of a random guess. Our
to Req∗ , the second request initiated by Leakuidator). In            countermeasure was able to prevent the attacks we discovered
particular, we noticed that the server takes a different time         on multiple websites, multiple browsers, and multiple hard-
to respond, if a user is allowed or not to access the shared          ware microarchitectures, all while remaining compatible with
resource. This timing side channel was originally used by             existing uses for cookies in navigation, tracking and analytics.
Watanabe et al. to launch deanonymization attacks on several             We also evaluated Leakuidator+’s effectiveness against
popular services using XS-leaks [8, 9]. In our case, even             attacks targeting a group of users. Table 2 shows the attack’s
though Resp∗ is not forwarded to the browser, and therefore           accuracy drops near the baseline level of 12.5%, which is
not available to an attacker using XS-leaks, the mere fact            equivalent to a random guess for the considered 8-state setup.
that it is processed by the browser’s extension framework is             Leakuidator [3] was shown to incur a small perfor-
enough to cause an exploitable side-channel difference.               mance overhead, thus minimally impacting user experience.
    Second, we discovered a client side channel in the extension      Leakuidator+ does not make changes that would signifi-
itself. The extension performs various operations on Req and          cantly affect those overheads, including load time, number
Resp, including recording header names and values, using              of requests, and data transferred.
them to prepare Req∗ , and finally comparing the fields of            Security Analysis. Leakuidator+ provides by design pro-
Resp∗ and Resp. Thus, the extension itself amplified the              tection against the main known XS-leak types, such as those



USENIX Association                                                                       31st USENIX Security Symposium         1515
described in Sec. 2.1. We have also shown experimentally that       website dedicated to collecting knowledge about APIs that
the defense renders cache-based attacks impractical.                can be used for such cross-site leaks. These include window
   Recently, Knittel et al. [4] introduced a formal model for       references, frame counting, error events, navigation, response
XS-leaks, building on work of Sudhodanan et al. [2]. The            cache probing, ID attribute, postMessage broadcasts, CORB
authors systematically search for XS-leaks and find 14 new          and CORP leaks, and timing attacks [1, 2, 23, 24, 34–55].
attack types grouped in four categories. In the remainder              There has been academic effort to give a structure to XS-
of this section, we describe how Leakuidator+ protects              leaks by classification. Recently, Knittel et al. [4] introduced
against these. Although our analysis does not necessarily           a formal model for XS-leaks, building on work of Sudhodanan
guarantee protection against new unknown XS-leaks, we view          et al. [2], and systematically searched for new XS-leak attack
it as compelling evidence that Leakuidator+ is an effective         classes. On the defense side, they argue that if at least one
defense mechanism against targeted deanonymization attacks.         browser is immune to a certain leak technique, this technique
   Leak Technique: Global Limits exploits browser limits. The       can be fixed in other browsers as well, by changing their
limit on number of WebSocket connections allows an attacker         implementation. Our client-side defense, in contrast, does
to differentiate user states by detecting a webpage’s number        not depend on browser vendors and website owners, and can
of WebSocket connections [32]. Leakuidator+ removes                 be used immediately. We observe that many of the defenses
cookies from the initial GET request, resulting in same number      proposed to mitigate XS-leaks were not designed to protect
of connections in different user states. The response to the        against side channels. As our work shows, attacks based on
HEAD request initiated by Leakuidator+ is not rendered by           side channels bypass these software-imposed boundaries.
the browser, thus no connections are established.                      Targeted deanonymization is an example of privacy leakage
   The limit on the number of UI elements for the Payment           through XS-leaks [1, 3]. In response to XS-leaks, a number
API allows an advertiser to learn whether a user attempted to       of defense mechanisms were proposed, including response
purchase an advertised item after clicking on an affiliate link,    cache protections, subresource protections, fetch metadata,
and is not a deanonymization attack.                                cross-origin opener and resource policies, framing protections,
   Leak Technique: Performance API allows an attacker to dif-       SameSite cookies, isolation policies, cross-origin read
ferentiate user states by inspecting the browser’s Performance      blocking, and the partitioned HTTP cache [13, 14, 22, 56–67].
entries. It was previously used to detect the X-Frame-Options          Cache attacks were proposed simultaneously by Percival
header in Google Chrome [33]. When Leakuidator+                     and by Osvik et al. [16, 68], and first demonstrated on the
is enabled, Resp has same effect on these entries in both           last-level cache by Liu et al. [17]. Oren et al. presented a
target and non-target states. To eliminate any potential leak       JavaScript implementation of the last-level cache attack [69],
that could arise from Performance entries related to Resp∗ ,        and Shusterman et al. presented the cache occupancy and
Leakuidator+ removes these entries when Resp∗ arrives.              sweep counting variants, which can be run in more restricted
   Leak Technique: Error Messages allow an attacker to learn        browser environments [6, 70]. Several works have explored
the target of a redirect. In Webkit-based browsers, primarily       the use of micro-architectural side-channel attacks for attacks
Safari, if a CORS-enabled request fails, it is possible to access   on privacy. Jana et al. introduced the memory footprint side
CORS error messages, including the full URL of the redirect         channel, and showed how a malicious Android app can infer
target; in addition, the Subresource Integrity error message        fine-grained web-related information about a user, including
can leak the response size. These XS-leaks could possibly           personal interests and login status [71]. Gülmezoglu et al.
be used for targeted deanonymization if the errors rely on          showed how cache attacks can learn about running applications
authentication cookies sent along with cross-site requests.         in a cloud scenario [72]. Gülmezoglu et al. also showed how
However, Safari blocks third-party cookies by default.              a native Android app can use the cache to discover running
   Leak Technique: Readable Attributes. Web apps can use            applications, website activity and even which videos the
the Cross-Origin Opener Policy (COOP) to prevent other              victim was streaming [5]. To the best of our knowledge, we
websites from gaining arbitrary window references to the            are the first to introduce targeted deanonymization on the web
application, e.g., through pop-up windows. Reading the              using the CPU cache side channel.
value of the contentWindow attribute may allow an attacker             Many works have tried using different side-channel attack
to learn if COOP is enabled and thus potentially differentiate      methods to infer browsing activity, including power consump-
between user states. Leakuidator+ protects against this by          tion, GPU leaks, data statistics, performance counters, and
applying the defense to groups of related tabs/windows that         event loops [46, 73–80]. In contrast with the deanonymization
have different top-level domains.                                   scenario, in which the attacker actively induces the victim to
                                                                    load a resource, most of these works assume that the attacker
6   Related Work
                                                                    passively observes the victim. It is interesting to consider
XS-leaks usually exploit cross-site information in a binary         how these additional methods could be applied to targeted
form: questions with YES or NO answers, where the response          deanonymization, but we believe our defense should be
is visible to the attacker. xsleaks.dev is a community-driven       effective regardless of the method used by the attacker.



1516    31st USENIX Security Symposium                                                                       USENIX Association
7   Ethics, Disclosure and Guidance                                    using a cache side channel, any other side channel that can
                                                                       monitor traffic can also detect this difference, for example
The deanonymization attacks described in this paper are                the congestion-based method used by Schuster et al. [83].
both practical and dangerous, and can impact the privacy               To mitigate the timing side channel, web servers should thus
of journalists, activists, and other vulnerable populations.           be designed to return their responses in constant time, re-
While we provide a browser extension that serves as a                  gardless of the authorization status of the user. To mitigate
countermeasure against these attacks, and experimentally               client-side rendering side channels, web servers should make
verify its effectiveness, there are several scenarios in which this    their error pages as similar as possible to their content
countermeasure is impossible to deploy. Most significantly,            pages. This will make it more difficult for a side-channel at-
the current implementation of the WebExtension API on                  tacker to distinguish between the two. As an example, if an au-
Apple’s Safari browser is not compatible with our extension,           thorized user was going to be shown a video, the error page for
and the official mobile version of Chrome provided by Google           the non-targeted user should also be made to show a video. In
does not support extensions at all. Users of these browsers            general, website owners should minimize any kind of attacker-
will thus be unable to defend themselves against the attacks           observable difference in responses they send between the two
described in this paper, until content sharing sites make              states. In addition, websites should require user interaction
non-trivial changes to the way they allow content to be shared.        before rendering content: The scalable attack we showed on
   It is our ethical responsibility to minimize the risk to these      Tor, as well as several of the video-based attacks, relied on the
users. We have opened bug reports with browser vendors                 fact that browsers automatically play shared videos, even if
(Chromium [81], Firefox [82], Edge, Safari, WebKit, the Tor            they are loaded in a background page. The added cache activity
Project), and are sharing a draft of this paper with affected          resulting from this video playback makes it very easy for the
services including Google, Twitter, Meta, Microsoft, TikTok,           classifier to tell apart users. To prevent this, website owners can
Reddit, and Apple. We also consider journalists and activists          make sure that videos shared with only a subset of users require
part of the disclosure process, and have reached out to the or-        some sort of user interaction before they are played. In general,
ganizations who advocate for them through the EFF. Until the           if there are any operations which cause an unavoidable differ-
responsible disclosure process concludes, we plan to embargo           ence in cache activity (for example playing a video or decom-
the results. Our countermeasure is already available in the            pressing a file), we recommend that the website first asks the
Chrome and Firefox extension stores, and can be immediately            user to confirm this activity. Websites should also consider re-
installed even before the attacks are publicized. When the             placing blocking with “shadow-banning”. Blocking public
disclosure process is over, we plan to publicize an easy-to-           content from a particular user is arguably an exercise in incon-
understand description of the attack and how to mitigate it,           venience – all the blocked user needs to do to access this con-
and to work with relevant stakeholders to make sure potential          tent is simply open a private browsing window. The shadow-
victims know how to protect themselves. Below we provide               banning technique applies a different approach to blocking. A
additional advice on ways to limit the attack’s effectiveness.         shadow-banned user is apparently able to interact with the web-
   The attack works on websites even when using VPN,                   site, including viewing content, creating posts and posting com-
since it targets the browser’s rendering process and not the           ments. All of the user’s comments and posts, however, are in-
network stack. The attack will not work on websites opened             visible to other users. In this approach, the public posts of users
in incognito mode, unless the user explicitly logs in to the           are always accessible to other users, including those whom
website from the incognito session.                                    they ban. As a result, it is not possible to use selective shadow-
Guidance to Website Owners. As discussed in section 5.2,               banning to apply targeted deanonymization. On the other hand,
there are two main causes for differences in the observed side-        since other users are not exposed to the shadow-banned user’s
channel leakages between targeted and non-targeted users – a           content, the website operators can achieve their goal of con-
server-side timing difference and a client-side rendering dif-         trolling the discourse on the website. Finally, websites should
ference. These differences can be mitigated through careful            notify users upon sharing or blocking. Google Drive and
design by website owners. As a positive example, we note that          other sharing websites allow content to be shared without no-
Apple’s iCloud service applies most of these design principles,        tifying the recipient. Similarly, many sites do not provide any
and, as a result, we were not able to attack it using our technique.   way for a user to know when, or by whom, they are blocked.
Web servers typically have an authorization module, which              This behavior increases the risk of the attacks we described,
checks if a user is allowed to access a resource, followed by a        since the target user has no way of knowing he or she is targeted.
content delivery module, which actually makes the resource             To reduce this risk, website owners should always notify users
available to the client. If an authorized user loads the resource,     when they have content shared with them, or when they are
both authorization and content delivery modules need to run.           blocked by another user. To minimize cognitive and emotional
For non-authorized users, on the other hand, content delivery          discomfort, websites can consider how to selectively suppress
is not invoked at all, resulting in a faster response time which       some of these notifications without sacrificing security.
can be observed. While we measured this faster response time           Guidance to Browser Vendors. The browser serves as host



USENIX Association                                                                         31st USENIX Security Symposium          1517
both for the attacker and for the victim. A browser which            should also be subjected to CORB restrictions, even if it is
can isolate the cache activity of the victim from the spying         opened in a separate window.
eyes of the attacker, or which can prevent the attacker’s code       Guidance to Users. Users who are at increased risk of being
from performing cache occupancy measurements, would                  targeted online, such as journalists, activists, and religious
be the ideal countermeasure. This is, unfortunately, a task          leaders, are already instructed to be more careful online
which may be impossible to carry out without redesigning             than other users, for instance when opening attachments,
the browser, the operating system or even the CPU [84]. Even         responding to friend requests, clicking on unknown links,
before this protected browser becomes available, several             and so on. We provide here some guidance specific to the
engineering fixes to current browsers can raise the bar for          cache-based targeted deanonymization attack, and will be
the attackers. First, browsers should consider pop-unders            cooperating with advocacy groups to bring this guidance to the
as a security threat. Pop-under windows and tabs are truly           knowledge of relevant users as part of the disclosure process.
annoying. Advertisers are always looking for new methods             The best suggestion we can provide is to install our browser
for launching these pop-unders, and browser vendors are              extension, Leakuidator+, which is already available
constantly tweaking the browser’s window management logic            on both the Google Play Store and the Firefox Add-ons
to prevent them [25, 26]. Going forward from the results in          website [10, 11]. As Sec. 5 describes in detail, the extension
this work, we argue that browser vendors should no longer            protects against all of the attacks we described in the paper,
consider pop-unders as a mere annoyance, but instead consider        with a minimal impact on functionality and compatibility. It
them as security risks. This includes both actively blocking         should be noted that the current Android version of Chrome
this browsing pattern, and applying cross-site protections to        does not support extensions. Firefox for Android, as well as
content loaded into pop-ups. Browser vendors should also             several third-party Android browsers based on the open-source
allow browser extensions to modify request headers. The              Chromium code (notably Kiwi and Yandex), do support
defense we presented works by carefully processing the header        extensions, but testing the compatibility of our extension with
fields of the requests sent out by the browser – inspecting fields   these browsers remains a task for future work. Users should
in the request headers, comparing two responses to search for        also avoid unnecessary logins. Websites such as GMail,
privacy leaks, and ultimately changing or removing fields –          Twitter, Facebook and Instagram make it useful and convenient
removing cookie headers from requests and set-cookie headers         to be constantly logged in. This behavior pattern is especially
from responses. All of these stateful processing steps are made      enforced by Google, through their control over the browser,
possible by an extension API named webRequestBlocking,               the website, and in some cases the device itself. This behavior
which allows extensions to intercept, block, or modify               also unfortunately increases the risk of deanonymization
requests in-flight. Unfortunately, Google has announced that         attacks. To protect themselves, privacy-conscious users should
this API is being phased out [85]. Firefox did not currently         only log in to websites when they plan to actively use them,
announce plans to remove support for webRequestBlocking,             and make sure to log out when they are done. It should be
and the Safari extension API does not support it at all. The         noted that the Tor Browser keeps cookies stored in memory
API designed to replace webRequestBlocking, named                    as long as the browser is running – if a user opens GMail, and
declarativeNetRequest, may be appropriate for list-based             then closes the tab, the Google cookie remains present on the
ad blockers, but is not usable for our browser extension. Our        browser until the user manually logs out, deletes cookies or
work shows the importance of allowing browser extensions to          quits the browser. Users should also consider using multiple
statefully intercept and modify web requests. We urge browser        devices: The best way to prevent side-channel attacks is to
vendors to keep the webRequestBlocking option available              isolate the source from the receiver. A reasonable and practical
for extensions, and urge vendors who do not currently support        way to achieve this for sensitive users would be to invest in
it to make this feature a priority.                                  multiple cheap devices, each dedicated to a single online
Guidance to Standards Bodies. The WWW specification                  service. As a moderate alternative to above, users can use
already includes a set of standards designed to isolate web          multiple sessions in their browser, for example by using the
content from malicious third parties. These include resource         Multi-Account Containers add-on in Firefox, the Add Profile
policies, opener policies, cookie isolation, and similar             feature in Edge, or the Multiple People feature in Chrome. Tor
defenses. Common to all of these defenses is the assumption          Browser also has a (very prominent) “New Identity” button
that two pages programmatically isolated from each other are         that closes and reopens the browser with a click of a button.
not able to interact. The attacks presented in this work show        An Alternative Defense Approach:              A new potential
that this assumption must be reconsidered. In particular, the        defense strategy against the popunder and tabunder attack
cross-origin read blocking (CORB) feature was already shown          variants emerged from our discussions with the affected
to be less effective in the presence of side channels [52]. We       services and the browser vendors. Instead of relying on users
suggest that the CORB feature be extended to pop-under and           to install a browser extension, a similar functionality can
tab-under contexts, similar to the way in which we extended          be achieved by dividing the responsibility for detecting and
Leakuidator: Any web page opened by another web page                 reacting to potentially suspicious requests between browser



1518    31st USENIX Security Symposium                                                                        USENIX Association
vendors and sharing service operators: The browser provides        References
additional information about the context in which a request
                                                                    [1] Cristian-Alexandru Staicu and Michael Pradel. Leaky Images:
is made (through the request headers), and the sharing service
                                                                        Targeted Privacy Attacks in the Web. In USENIX Security
uses this information to decide how to respond to potentially           Symposium, pages 923–939. USENIX Association, 2019.
suspicious requests. We initiated a proposal to extend the          [2] Avinash Sudhodanan, Soheil Khodayari, and Juan Caballero.
W3C standard for fetch metadata HTTP request headers [86].              Cross-Origin State Inference (COSI) Attacks: Leaking Web
                                                                        Site States through XS-Leaks. In NDSS, 2020.
8   Concluding Remarks                                              [3] Mojtaba Zaheri and Reza Curtmola. Leakuidator: Leaky
In this paper, we have introduced novel attack techniques for           resource attacks and countermeasures. In Proc. of the 7th EAI
                                                                        SecureComm, 2021.
targeted deanonymization on the web, which can uniquely
                                                                    [4] Lukas Knittel, Christian Mainka, Marcus Niemietz, Do-
identify a target user when leaky resources are rendered in the
                                                                        minik Trevor Noß, and Jörg Schwenk. XSinator.com: From a
user’s browser. The attacks leverage CPU cache side channels
                                                                        Formal Model to the Automatic Evaluation of Cross-Site Leaks
to bypass software-imposed boundaries and are shown to be               in Web Browsers. In ACM CCS, pages 1771–1788, 2021.
effective across multiple architectures. Our work reveals that      [5] Berk Gülmezoglu, Andreas Zankl, M. Caner Tol, Saad Islam,
the attack surface for targeted deanonymization attacks is dras-        Thomas Eisenbarth, and Berk Sunar. Undermining User
tically larger than previously considered. We experimentally            Privacy on Mobile Devices Using AI. In AsiaCCS, pages
show that several popular resource sharing services can be              214–227. ACM, 2019.
leveraged to conduct the attack. When considering together          [6] Anatoly Shusterman, Lachlan Kang, Yarden Haskal, Yosef
the collection of users of these services, we conclude that a           Meltser, Prateek Mittal, Yossi Oren, and Yuval Yarom. Robust
large majority of Internet users are vulnerable.                        Website Fingerprinting Through the Cache Occupancy
   To defend against this threat, we provide a comprehensive            Channel. In USENIX Security Symposium, 2019.
countermeasure against all of the attacks we discovered.            [7] Anatoly Shusterman, Ayush Agarwal, Sioli O’Connell, Daniel
                                                                        Genkin, Yossi Oren, and Yuval Yarom. Prime+Probe 1,
Leakuidator+ is a client-side defense that can be deployed
                                                                        JavaScript 0: Overcoming Browser-based Side-Channel
right away as a browser extension, without depending on
                                                                        Defenses. In USENIX Security Symposium, 2021.
browser vendors and website owners. We also provide
                                                                    [8] Takuya Watanabe, Eitaro Shioji, Mitsuaki Akiyama, Keito
guidance to websites and browser vendors, as well as to                 Sasaoka, Takeshi Yagi, and Tatsuya Mori. User Blocking
individuals who are unable to install our browser extension.            Considered Harmful? An Attacker-Controllable Side Channel
Future Work. Targeted deanonymization via the cache side                to Identify Social Accounts. In EuroS&P. IEEE, 2018.
channel is a powerful attack mechanism. Whereas we showed           [9] Takuya Watanabe, Eitaro Shioji, Mitsuaki Akiyama, Keito
                                                                        Sasaoka, Takeshi Yagi, and Tatsuya Mori. Follow Your
multiple avenues that are readily available to attackers, it
                                                                        Silhouette: Identifying the Social Account of Website Visitors
would be desirable to further improve the protection landscape.         through User-Blocking Side Channel. IEICE Trans. Inf. Syst.,
As future work, we plan to further explore and improve                  103-D(2):239–255, 2020.
usability aspects of the proposed Leakuidator+ defense. In         [10] Leaquidator+ Team.                Leakuidator+ for Firefox.
addition, we believe it is crucial to work with browser vendors         https://addons.mozilla.org/en-US/firefox/, 2021.
and standards bodies to explore comprehensive mechanisms           [11] Leaquidator+ Team.               Leakuidator+ for Chrome.
that can start addressing the fundamental underlying causes of          https://chrome.google.com/webstore/, 2021.
cache side channel-based targeted deanonymization attacks.         [12] Kenneth Kufluk and Gregory Baker.             Protecting user
                                                                        identity against Silhouette. https://blog.twitter.com/
Artifact Availability. We provide a dataset of cache traces for
                                                                        engineering/en_us/topics/insights/2018/twitter_
single and multi-target attacks, together with a Google Colab           silhouette.
document showing how to use classifiers on these datasets,         [13] MDN Web Docs. Cross-Origin Resource Policy (CORP).
as well as sample attack pages for the <iframe>, pop-under              https://developer.mozilla.org/en-US/docs/Web/
and tab-under embedding methods. In addition, we provide                HTTP/Cross-Origin_Resource_Policy_(CORP).
an online-only attack page (as described in Appendix C). The       [14] The Chromium Projects.                   SameSite Updates.
artifact repository can be accessed using: git clone https:             https://www.chromium.org/updates/same-site.
//github.com/leakuidatorplusteam/artifacts.git.                    [15] Onur Aciiçmez. Yet another MicroArchitectural Attack:
   The complete source code for Leakuidator+ is available               exploiting I-Cache. In CSAW, pages 11–18. ACM, 2007.
through the Firefox and Chrome extension stores [10, 11].          [16] Dag Arne Osvik, Adi Shamir, and Eran Tromer. Cache Attacks
                                                                        and Countermeasures: The Case of AES. In CT-RSA, volume
Acknowledgments. We would like to thank the USENIX                      3860 of LNCS, pages 1–20. Springer, 2006.
Security reviewers and Giancarlo Pellegrino for reviewing this     [17] Fangfei Liu, Yuval Yarom, Qian Ge, Gernot Heiser, and
paper. This research was supported by the US NSF (National              Ruby B. Lee. Last-Level Cache Side-Channel Attacks are
Science Foundation) under Grants No. CNS 1801430, DGE                   Practical. In IEEE S&P, pages 605–622, 2015.
1565478, and DGE 2043104.                                          [18] Yossi Oren.          PP0 GitHub Repository.            https:



USENIX Association                                                                    31st USENIX Security Symposium           1519
     //github.com/Yossioren/pp0, 2021.                              [39] Jens Müller.          CORS misconfiguration.          https:
[19] MDN Web Docs. Same-origin policy: Cross-origin script API           //web-in-security.blogspot.com/2017/07/
     access. https://developer.mozilla.org/en-US/docs/                   cors-misconfigurations-on-large-scale.html.
     Web/Security/Same-origin_policy#cross-origin_                  [40] Terjanq.             Mass XS-Search using Cache At-
     script_api_access.                                                  tack.          https://terjanq.github.io/Bug-Bounty/
[20] Soheil Khodayari. De-anonymization attack: Cross site               Google/cache-attack-06jd2d2mz2r0/index.html#
     information leakage. https://hackerone.com/reports/                 VIII-YouTube-watching-history.
     723175, 2019.                                                  [41] Gareth Heyes.                   Leaking IDs using fo-
[21] Avinash Sudhodanan.               HotCRP:       Attempt to          cus.                https://portswigger.net/research/
     plug an information leak represented by http sta-                   xs-leak-leaking-ids-using-focus.
     tus.      https://github.com/kohler/hotcrp/commit/             [42] Andrew Bortz and Dan Boneh. Exposing private information
     406a966aad00a762460fbc62cfb04a7532fc9fbd, 2019.                     by timing web applications. In Proc. of WWW, 2007.
[22] MDN Web Docs.                   Cross-Origin-Opener-Policy.    [43] Chris Evan.        Cross-domain search timing.        https:
     https://developer.mozilla.org/en-US/docs/Web/                       //scarybeastsecurity.blogspot.com/2009/12/
     HTTP/Headers/Cross-Origin-Opener-Policy.                            cross-domain-search-timing.html.
[23] Ron Masas. Patched Facebook Vulnerability Could Have Ex-       [44] Tom Van Goethem, Wouter Joosen, and Nick Nikiforakis. The
     posed Private Information About You and Your Friends. https:        Clock is Still Ticking: Timing Attacks in the Modern Web. In
     //www.imperva.com/blog/facebook-privacy-bug/.                       Proc. of the 22nd ACM CCS, pages 1382–1393. ACM, 2015.
[24] XS-leaks Wiki: Window References. https://xsleaks.             [45] Tom Van Goethem, Christina Pöpper, Wouter Joosen, and
     dev/docs/attacks/window-references/, October 2020.                  Mathy Vanhoef. Timeless timing attacks: Exploiting con-
[25] Avi Drissman.          WebUSB dialog allows popunders.              currency to leak secrets over remote connections. In Proc. of
     https://bugs.chromium.org/p/chromium/issues/                        the 29th USENIX Security Symposium, pages 1985–2002, 2020.
     detail?id=838314.                                              [46] Pepe Vila and Boris Köpf. Loophole: Timing Attacks on
[26] Masato Kinugawa. Popunder restriction bypass with Presen-           Shared Event Loops in Chrome. In USENIX Security, 2017.
     tation API. https://bugs.chromium.org/p/chromium/              [47] Eduardo Vela. Matryoshka - Web Application Timing Attacks
     issues/detail?id=768900.                                            (or.. Timing Attacks against JavaScript Applications in
[27] Scikit-learn: Machine Learning in Python.             https:        Browsers). https://sirdarckcat.blogspot.com/2014/
     //scikit-learn.org/, 2021.                                          05/matryoshka-web-application-timing.html.
[28] TensorFlow: An end-to-end open source machine learning         [48] Eduardo Vela.       Security: XS-Search + XSS Auditor =
     platform. https://www.tensorflow.org, 2021.                         Not Cool. https://bugs.chromium.org/p/chromium/
[29] Google Research. Colaboratory. https://colab.research.              issues/detail?id=922829.
     google.com/, 2021.                                             [49] Juan Manuel Fernández.                CSS Injection Prim-
[30] Stefan Mangard, Elisabeth Oswald, and Thomas Popp. Power            itives.                https://x-c3ll.github.io/posts/
     Analysis Attacks: Revealing the Secrets of Smart Cards.             CSS-Injection-Primitives/.
     Springer, 2007.                                                [50] XS-leaks Wiki: postMessage Broadcasts. https://xsleaks.
[31] Ubuntu Wiki. Stress-NG. https://wiki.ubuntu.com/                    dev/docs/attacks/postmessage-broadcasts/, October
     Kernel/Reference/stress-ng, November 2021.                          2020.
[32] Leak cross-window request timing by exhausting connec-         [51] cure53.de. HTTPLeaks. https://github.com/cure53/
     tion pool.     https://bugs.chromium.org/p/chromium/                HTTPLeaks/.
     issues/detail?id=843157, May 2018.                             [52] Łukasz Anforowicz.                 CORB vs side chan-
[33] Terjanq.      Twitter: Detect X-Frame-Options header in             nels.             https://docs.google.com/document/d/
     Chrome.          https://twitter.com/terjanq/status/                1kdqstoT1uH5JafGmRXrtKE4yVfjUVmXitjcvJ4tbBvM/
     1111600071014080517, March 2019.                                    edit?ts=5f2c8004.
[34] Egor Homakov. Disclose domain of redirect destination          [53] Sigurd Kolltveit.         A timing attack with CSS selec-
     taking advantage of CSP. https://bugs.chromium.org/                 tors and Javascript.          https://blog.sheddow.xyz/
     p/chromium/issues/detail?id=313737.                                 css-timing-attack/.
[35] Egor Homakov.           Using Content-Security-Policy for      [54] Takashi Yoneuchi. A Rough Idea of Blind Regular Expres-
     Evil.           http://homakov.blogspot.com/2014/01/                sion Injection Attack. https://diary.shift-js.info/
     using-content-security-policy-for-evil.html.                        blind-regular-expression-injection/.
[36] Terjanq.       Protected tweets exposure through the url.      [55] Soroush Karami, Panagiotis Ilia, and Jason Polakis. Awak-
     https://hackerone.com/reports/491473.                               ening the Web’s Sleeper Agents: Misusing Service Workers
[37] Edward W. Felten and Michael A. Schneider. Timing attacks           for Privacy Leakage. In Proc. of NDSS ’21, 2021.
     on web privacy. In 23rd IEEE Computer Security Foundations     [56] MDN Web Docs.                 Sec-Fetch-Site.         https:
     Symposium, pages 200–214. IEEE, 2010.                               //developer.mozilla.org/en-US/docs/Web/HTTP/
[38] Eduardo Vela.            HTTP Cache Cross-Site Leaks.               Headers/Sec-Fetch-Site.
     https://sirdarckcat.blogspot.com/2019/03/                      [57] MDN Web Docs. Vary. https://developer.mozilla.
     http-cache-cross-site-leaks.html.                                   org/en-US/docs/Web/HTTP/Headers/Vary.




1520   31st USENIX Security Symposium                                                                         USENIX Association
[58] XS-leaks Wiki: Subresource Protections.               https:    [76] Sangho Lee, Youngsok Kim, Jangwoo Kim, and Jong Kim.
     //xsleaks.dev/docs/defenses/design-protections/                      Stealing Webpages Rendered on Your Browser by Exploiting
     subresource-protections/, October 2020.                              GPU Vulnerabilities. In IEEE SP, pages 19–33, 2014.
[59] W3C Working Draft. Fetch Metadata Request Headers.              [77] Raphael Spreitzer, Simone Griesmayr, Thomas Korak, and Ste-
     https://www.w3.org/TR/fetch-metadata/.                               fan Mangard. Exploiting Data-Usage Statistics for Website Fin-
[60] Anne van Kesteren. Cross-Origin-Opener-Policy response               gerprinting Attacks on Android. In WISEC, pages 49–60, 2016.
     header (also known as COOP). https://gist.github.com/           [78] Berk Gülmezoglu, Andreas Zankl, Thomas Eisenbarth, and
     annevk/6f2dd8c79c77123f39797f6bdac43f3e.                             Berk Sunar. PerfWeb: How to Violate Web Privacy with Hard-
[61] MDN Web Docs.              X-Frame-Options.           https:         ware Performance Events. In ESORICS (2), pages 80–97, 2017.
     //developer.mozilla.org/en-US/docs/Web/HTTP/                    [79] Jo M. Booth. Not So Incognito: Exploiting Resource-Based
     Headers/X-Frame-Options.                                             Side Channels in JavaScript Engines. Bachelor thesis, Harvard,
[62] MDN Web Docs.                     CSP:       frame-ancestors.        April 2015.
     https://developer.mozilla.org/en-US/docs/                       [80] Hyungsub Kim, Sangho Lee, and Jong Kim. Inferring browser
     Web/HTTP/Headers/Content-Security-Policy/                            activity and status through remote monitoring of storage usage.
     frame-ancestors.                                                     In ACSAC, pages 410–421, 2016.
[63] XS-leaks Wiki: Isolation Policies. https://xsleaks.dev/         [81] Chromium bugs: Side-channel attack can deanonymize
     docs/defenses/isolation-policies/, December 2020.                    users (potential risk to journalists and activists).
[64] The Chromium Projects. Cross-Origin Read Blocking for                https://bugs.chromium.org/p/chromium/issues/
     Web Developers.        https://www.chromium.org/Home/                detail?id=1285604, 2022.
     chromium-security/corb-for-developers.                          [82] Bugzilla: Side-channel attack can deanonymize users (po-
[65] Vicki Pfau. Optionally partition cache to prevent using cache        tential risk to journalists and activists). https://bugzilla.
     for tracking. https://bugs.webkit.org/show_bug.cgi?                  mozilla.org/show_bug.cgi?id=1749129, 2022.
     id=110269.                                                      [83] Roei Schuster, Vitaly Shmatikov, and Eran Tromer. Beauty and
[66] Josh Karlin. Split Disk Cache Meta Bug. https://bugs.                the Burst: Remote Identification of Encrypted Video Streams.
     chromium.org/p/chromium/issues/detail?id=910708.                     In USENIX Security Symposium, pages 1357–1374, 2017.
[67] Anne van Kesteren. Top-level site partitioning. https:          [84] Qian Ge, Yuval Yarom, Tom Chothia, and Gernot Heiser. Time
     //bugzilla.mozilla.org/show_bug.cgi?id=1590107.                      Protection: The Missing OS Abstraction. In EuroSys, 2019.
[68] Colin Percival. Cache Missing for Fun and Profit. In BSDCan     [85] David Li. The transition of Chrome extensions to Man-
     2005, 2005.                                                          ifest V3.           https://developer.chrome.com/blog/
[69] Yossef Oren, Vasileios P. Kemerlis, Simha Sethumadhavan,             mv2-transition/, September 2021.
     and Angelos D. Keromytis. The Spy in the Sandbox: Practical     [86] Extending the fetch metadata headers:              related tab-
     Cache Attacks in JavaScript and their Implications. In CCS,          s/windows #83.                     https://github.com/w3c/
     pages 1406–1418, 2015.                                               webappsec-fetch-metadata/issues/83, 2022.
[70] Anatoly Shusterman, Zohar Avraham, Eliezer Croitoru, Yarden     [87] Stan Salvador and Philip Chan. Toward accurate dynamic time
     Haskal, Lachlan Kang, Dvir Levi, Yosef Meltser, Prateek              warping in linear time and space. Intelligent Data Analysis,
     Mittal, Yossi Oren, and Yuval Yarom. Website Fingerprinting          11(5):561–580, 2007.
     Through the Cache Occupancy Channel and its Real World
     Practicality. IEEE Trans. Dependable Secur. Comput.,            A   Additional Experimental Setup Details
     18(5):2042–2060, 2021.
                                                                     In this section, we provide additional details about our
[71] Suman Jana and Vitaly Shmatikov. Memento: Learning Secrets
                                                                     experimental setup. Table 4 provides details about the five
     from Process Footprints. In IEEE Symposium on Security and
                                                                     system configurations we used in the experiments.
     Privacy, pages 143–157. IEEE Computer Society, 2012.
[72] Berk Gülmezoglu, Thomas Eisenbarth, and Berk Sunar.             Machine Learning Classifier Parameters. The LSTM
     Cache-Based Application Detection in the Cloud Using            neural network model was used with the hyper-parameters
     Machine Learning. In AsiaCCS, pages 288–300. ACM, 2017.         described in Table 5. The logistic regression classifier was
[73] Shane S. Clark, Hossen A. Mustafa, Benjamin Ransford,           used with 1000 max iterations.
     Jacob Sorber, Kevin Fu, and Wenyuan Xu. Current Events:
     Identifying Webpages by Tapping the Electrical Outlet. In       B   Embedding Details For Various Services
     ESORICS, pages 700–717, 2013.                                   In this section, we provide details about the method used
[74] Qing Yang, Paolo Gasti, Gang Zhou, Aydin Farajidavar, and       to embed leaky resources for each sharing service. The
     Kiran S. Balagani. On Inferring Browsing Activity on Smart-     embedding methods are based on specific SD-URLs we
     phones via USB Power Analysis Side-Channel. IEEE Trans.         identified for these services.
     Information Forensics and Security, 12(5):1056–1066, 2017.         In Chrome, we used the <iframe> embedding method for
[75] Pavel Lifshits, Roni Forte, Yedid Hoshen, Matt Halpern,         YouTube, LinkedIn and TikTok, and the tab-under method for
     Manuel Philipose, Mohit Tiwari, and Mark Silberstein. Power
                                                                     Facebook, Instagram, Reddit and Twitter. In Safari, we used
     to peep-all: Inference Attacks by Malicious Batteries on
     Mobile Devices. PoPETs, 2018(4):1–1, 2018.
                                                                     the pop-under method, whereas in Tor we used the tab-under
                                                                     method.



USENIX Association                                                                      31st USENIX Security Symposium            1521
 System              Device            OS                            CPU                      Browser                  Measurement Method
 Win-Chrome          Dell Latitude     Windows 10 Pro 20H2           Intel Core i7 7820HQ     Chrome 96.0              C, 8MB, 2ms
 Win-Tor             Dell Latitude     Windows 10 Pro 20H2           Intel Core i7 7820HQ     Tor 11.0.1               S, 8MB, 100ms
 Mac-Intel-Safari    MacBook Pro       macOS Catalina 10.15.7        Intel Core i7 3540M      Safari 15.0              C, 4MB, 2ms
 Mac-M1-Chrome       Mac mini          macOS Big Sur 11.4            Apple M1 8-Core          Chrome 96.0              S, 4MB, 10ms
 Android-Chrome      Samsung           Android 11, One UI 3.1        Qualcomm SM8350          Chrome Android 92.0      S, 4MB, 10ms
                     Galaxy S21 5G

Table 4: System configurations used for the attacks. The “Measurement Method” column describes the setup used for cache
measurements, in the format (Method, Buffer size, Interval). “Method” denotes the cache measurement method used: C for Cache
Occupancy, S for Sweep Counting. “Interval” is related to the accuracy of the time measurement API, which is determined by
the combination browser/device. For Cache Occupancy, “Interval” denotes the time between consecutive cache measurements.
For Sweep Counting, “Interval” denotes the time needed to take one cache measurement.


        Hyperparameter            Value                                    LinkedIn and TikTok. The SD-URL for the leaky resource
        Optimizer                 Adam                                     points to a publicly shared post containing a video. The attack
        Learning rate             0.001                                    uses the blocking-based approach. These services comply
        Batch size                128                                      with cookies from both cross-site and same-site requests.
        Training Epoch            early stop by validation                 As a result, we use the <iframe> embedding method for
                                  accuracy                                 the Chrome browser: If the account holder of the publicly
        Input units               vector size of the input
                                                                           shared post (the attacker) blocks the victim account, then
        Convolution layers        1
        Convolution activation    relu
                                                                           the post does not load in the victim’s Chrome browser; if
        Convolution kernels       256                                      the victim is not blocked, the post is loaded in the victim’s
        Convolution kernel size   32                                       Chrome browser. In the Safari and Tor browsers cookies are
        Pool size                 4                                        disabled for cross-site requests, hence we use the pop-under
        LSTM activation           tanh                                     and tab-under embedding methods, respectively.
        LSTM units                32
        Dropout                   0.7                                      Twitter, Instagram and Facebook. The SD-URL for the
                                                                           leaky resource points to a publicly shared post containing a
  Table 5: Hyper-parameters for neural network classifier.                 video. The attack uses the blocking-based approach. These
                                                                           services ignore cookies from cross-site requests. For example,
                                                                           consider a post embedded cross-site using an <iframe>: If
                                                                           the post is public, it is loaded in the browser regardless of
   For all the services tested, except for Reddit, the leaky               user state; if the post is private, it is not loaded in the browser
resource was a video, because it causes cache activity over                regardless of the user state. Therefore, an embedding approach
an extended period of time. In some cases, the video does not              is needed that attaches the cookies to the requests as first
auto-play, but the video player loads a preview of the video               party cookies. In the Safari browser, we used the pop-under
that generates sufficient cache activity.                                  embedding method. In the Chrome and Tor browsers, we used
  Additional details for the individual sharing websites is                the tab-under embedding method.
provided below.
                                                                           Reddit. The SD-URL for the leaky resource points to a private
YouTube. The SD-URL for the leaky resource points to a                     subreddit page. The attack uses the private sharing-based ap-
video player playing a video. The attack uses the private                  proach. The attacker creates a private subreddit and approves
sharing-based approach. YouTube complies with cookies                      the victim to the private subreddit. We were not able to embed
from both cross-site and same-site requests. As a result, we               the subreddit page cross-site, so we used embedding methods
use the <iframe> embedding method for the Chrome browser:                  that make first party requests: The pop-under method for the
When the private resource is shared with the victim, the                   Safari browser and the tab-under method for the Chrome and
video is loaded in the embedded YouTube player; when the                   Tor browsers. Since Reddit does not allow posting of videos in
private resource is not shared with the victim, the video is not           private subreddits, we modified the default layout of the private
loaded in the embedded YouTube player. In the Safari and Tor               subreddit so that it loads multiple images when displayed.
browsers, cookies are disabled for cross-site requests, so an
                                                                           C   An Online-Only Attack
embedding method should be used that allows sending cookies
as first party along with the requests. As a result, in the Safari         The attacks described in Section 4 implicitly assume that
browser we used the pop-under embedding method, whereas                    the attacker has some prior information about the victim’s
in the Tor browser we used the tab-under embedding method.                 system configuration. This prior information lets the attacker



1522    31st USENIX Security Symposium                                                                                USENIX Association
                          Win-Chrome                      Win-Tor              Mac-Intel-Safari           Mac-M1-Chrome
                         Accuracy (%)                 Accuracy (%)              Accuracy (%)               Accuracy (%)
       Service      w/ MSE w/ FastDTW            w/ MSE w/ FastDTW         w/ MSE w/ FastDTW          w/ MSE w/ FastDTW
       Google          97          98               65          80           100          98             76          87
       Twitter         76          82               71          74            98          98             63          71
      LinkedIn       100          100               52          54            56          68             82          74
       TikTok          67          69               78          82            68          80             67          82
     Facebook        100          100               65          66            65          65             93          96
     Instagram         60          71               61          66            63          81             54          67
       Reddit          67          69               53          63            60          86             61          64

Table 6: Attack accuracy for the Online-Only attack simulation. MSE is mean squared error and FastDTW [87] is an approximate
dynamic time warping (DTW) algorithm that has a linear time and space complexity.


carry out an offline step, in which it trains a machine learning      of target and non-target traces as references, then measuring
classifier on a system similar to the victim’s. Although this         the distance between these reference traces and the subsequent
assumption is reasonable under our threat model, it is still          pair of target and non-target traces from the same dataset. We
interesting to consider the case where the attacker does not          discovered that while the simulated online-only attack was ef-
have the ability to prepare for the attack.                           fective in many settings, including Google, LinkedIn and Face-
    We now describe a variant of our attack which can be              book on Win-Chrome, Google and Twitter on Mac-Intel-Safari,
carried out without a training step, at the cost of a longer online   and Facebook on Mac-M1-Chrome, it was far less effective
attack time. In this setting, the attacker prepares three shared      than the classifier-based method in several settings, including
resources, Rvictim , Rother and Rall . Rvictim is shared with the     TikTok, Instagram and Reddit on Win-Chrome, LinkedIn and
victim, Rother is shared with a single user who is not the victim     Facebook on Mac-Intel-Safari, Twitter, Instagram and Reddit
(i.e., another attacker account), and Rall is shared publicly         on Mac-M1-Chrome, and most of the services on Win-Tor.
with everyone.                                                        A table listing the full accuracy results for this simulated
    The attack page loads the three shared resources one              experiment can be found in Table 6. Note that an online-only
after the other while taking cache measurements. Next,                attack beyond simulation is limited to the settings where it is
the attacker uses a similarity metric, such as mean squared           possible to load multiple resources through the attack page.
error (MSE) or dynamic time warping distance (DTW), to
detect whether the trace collected for Rvictim is more similar
to the trace collected for Rother , or to the trace collected
for Rall . That is, if MSE(Trace(Rvictim ), Trace(Rall )) <
MSE(Trace(Rvictim ), Trace(Rother )), then the attacker
concludes that it is targeting the victim.
    To experimentally validate this attack, we performed an
experiment in Chrome for Windows targeting the Google/Y-
ouTube cookie, using three YouTube videos loaded into
an <iframe> element. We collected 1 second side-channel
measurements for each of three videos, resulting in a total
attack time of 3 seconds. Then, we applied the MSE metric
to identify the presence of the victim. We repeated the
experiment 200 times, 100 for a victim user and 100 for a
non-victim user. An implementation of this online-only attack
can be found in the paper’s artifact repository. Our results
showed that all 100 predictions in the victim state were correct,
and 98 out of 100 predictions in non-victim state were correct,
resulting in an overall attack accuracy of 99%. We therefore
conclude that our attacks are feasible in some settings even
if the attacker cannot carry out a training step.
    To see if this attack can be extended to other websites and
browsers, we simulated the online-only attack using traces
from our dataset. We did so by repeatedly selecting one pair



USENIX Association                                                                      31st USENIX Security Symposium         1523
