Abstract

Cache side-channel attack is one of the critical security threats to modern computing systems. As a representative cache side-channel attack, Flush+Reload attack allows an attacker to steal confidential information (e.g., private encryption key) by monitoring a victim’s cache access patterns while generating the confidential values. Meanwhile, for providing high performance with memory-intensive applications that do not fit in the on-chip SRAM-based last-level cache (e.g., L3 cache), modern computing systems start to deploy DRAM cache between the SRAM-based last-level cache and the main memory DRAM, which can provide low latency and/or high bandwidth. However, in this work, we propose an approach that exploits the DRAM cache for security rather than performance, called ByCA . ByCA bypasses the L3 shared cache when accessing cache blocks suspected as target blocks of an attacker. Consequently, ByCA eliminates the timing difference when the attacker accesses the target cache blocks, nullifying the Flush+Reload attacks. To this end, ByCA keeps cache blocks suspected as target blocks of the attacker and stores their states (i.e., flushed by clflush or not) in the L4 DRAM cache even with clflush instruction; ByCA re-defines and re-implements clflush instruction not to flush cache blocks from the L4 DRAM cache while flushing the blocks from other level caches (i.e., L1, L2, and L3 caches). In addition, ByCA bypasses L3 cache when the attacker or the victim accesses the target blocks flushed by clflush , making the attacker always obtain the blocks from L4 DRAM cache regardless of the victim’s access patterns. Consequently, ByCA eliminates the timing difference, thus the attacker cannot monitor the victim’s cache access patterns. For L4 DRAM cache, we implement Alloy Cache design and use an unused bit in a tag entry for each block to store its state. ByCA only requires a single bit extension to cache blocks in L1 and L2 private caches, and a tag entry for each block in the L4 DRAM cache. Our experimental results show that ByCA completely eliminates the timing differences when the attacker reloads the target blocks. Furthermore, ByCA does not show the performance degradation for the victim while co-running with the attacker that flushes and reloads target blocks temporally and repetitively.

Highlights

  • Cache side-channel attack that can steal confidential information becomes one of the critical threats to modern computing systems

  • ARCHITECTURE we propose ByCA, Bypassing Cache Architecture, which defends against Flush+Reload attack by exploiting L4 DRAM cache

  • We show that ByCA does not degrade the performance notable even with the temporal attack, if the number of target blocks flushed by the attacker increases considerably, since the flushed blocks will permanently bypass the L3 cache even without any attacker, ByCA may suffer from performance degradation without clearing bypass bit when the victim does not co-run with the attacker that flush target blocks repetitively

Read more

Summary

Introduction

Cache side-channel attack that can steal confidential information (e.g., private encryption key) becomes one of the critical threats to modern computing systems. Exploiting the timing differences, Flush+Reload attacks can steal the confidential information that can be inferred by monitoring access pattern to the cache memory. CACHE SIDE-CHANNEL ATTACK AND FLUSH+RELOAD ATTACK The cache side-channel attacks (e.g., Flush+Reload [1], Prime+Probe [13], Evict+Reload [14] or other variants [15], [16]) can steal confidential information by inferring an execution flow represented by cache access patterns of a victim process; those attacks can directly infer confidential data (e.g., encryption key) by accessing data where the attacker does not have access permission (e.g., Meltdown [2], Spectre [3]). To infer the execution flow, the attacker keeps monitoring the access patterns by exploiting timing difference when accessing a particular cache block in the cache memory. Such cache side-channel attacks repeat following steps. Wait, and reload, the attacker can monitor the access patterns of the victim at the cache memory

Results
Discussion
Conclusion
Full Text
Published version (Free)

Talk to us

Join us for a 30 min session where you can share your feedback and ask us any queries you have

Schedule a call