Researchers have demonstrated a way to protect the secret information of a computer program while still allowing faster computations.

Although multiple programs running on the same machine may not be capable of directly accessing each other’s secret information, they can share the same memory hardware so that malicious programs could steal their secrets through a “memory timing attack side-channel.”

The malicious program detects delays in accessing a computer’s memory because it shares the hardware with all other programs on the machine. The malicious program can use these delays to access another program’s secrets, such as passwords or cryptographic keys.

This can be done to avoid these attacks by allowing only one program to access the memory controller at any time. However, this will dramatically slow down the computation. MIT researchers devised a new method that allows memory sharing while protecting against side-channel attacks. This method can speed up programs by 12 per cent compared with state-of-the-art security systems.

Researchers say the technique can target shared computing resources and provide better security.

It is common to share computers with others nowadays, especially if you’re doing computations in the cloud or on your mobile device. This sharing of resources is a common practice. These shared resources allow attackers to find even fine-grained information,” Mengjia Yan (the Homer A. Burnell Career Developer Professor of Electrical Engineering and Computer Science and a member of the Computer Science and Artificial Intelligence Laboratory, CSAIL) says.

Peter Deutsch, a CSAIL graduate student, and Yuheng Yang, the co-lead writers. Joel Emer (a professor of the practice for EECS) and CSAIL graduate student Jules Drean are additional co-authors. The research will be presented during the International Conference on Architectural Support for Programming Languages and Operating Systems.

Committed to memory

You can see a computer’s memories as a library and the memory controller like a library. To retrieve stored information, a program must go to the library. The program will then open the library door briefly to get inside.

A malicious program could exploit shared memory to access secret information in many ways. The contention attack is where an attacker must determine when the victim program is using the library door. This attacker attempts to use both the library door and the victim program simultaneously.

The attacker is looking at the memory controller (the library door) to ask, “Is it busy now?” If they get blocked by the library door opening, they will be delayed because the victim program uses the memory controller. Emer says that the information being leaked is what you should be noticing.

Researchers devised a method to prevent contention attacks by “shaping” programs’ memory requests according to a predefined pattern. This is independent of when they need the memory controller. A program must first access the memory controller before it can interfere with another program’s memory request. This “request shaper”, which uses a graph structure to process the requests and send them to the memory controller on a set schedule, is required before it can do so. This graph is called a directed-acyclic graph (DAG), while the security scheme for the team is DAGguise.

Fooling an attacker

DAGguise can sometimes delay a program’s request to access memory until the next permitted time (according to the fixed schedule) or submit a fake request if it does not require access to memory at the next interval.

Sometimes the program may have to wait a bit longer to get to the library, and other times it will go when it wasn’t necessary. This structured pattern allows you to conceal what you’re doing from attackers. “These delays and these fake requests ensure security,” Deutsch states.

DAGguise is a graph of memory access requests for programs. Each request is stored as a “node”, and the edges connecting the nodes represent time dependencies between requests. Request A must be completed before request B. The edges between nodes, or the time between each request, are fixed.

DAGguise can send a memory request whenever a program needs it. DAGguise will adjust its timing to ensure security. The attacker cannot see the time it takes to process a memory query. This happens according to a set schedule.

This graph structure allows the memory controller to share dynamically. DAGguise can adapt to multiple programs using memory simultaneously and adjust the fixed schedule accordingly. This allows for more efficient use of shared memory hardware while maintaining security.

Performance boost

DAGguise was tested by researchers who simulated its performance in an actual implementation. The researchers sent constant signals to the memory controller. This is how an attacker could try to find another program’s memory access patterns. They confirmed that no private data had been leaked with every possible attempt.

They then used a computer simulation to test how their system performed compared to other security measures.