MIT Researchers Discover Flaws in the Apple M1 SoC

While the M1 may be a number of years old now, it is still a relevant processor and introduced the world to a new era of ARM computing. Until now, it was thought that the M1 processor was a generally safe designs, but a team of researchers from MIT have recently discovered new flaws never seen before in the design. What made the M1 a revolution in computing for Apple, what did the researchers discover, and is our use of speculative execution systems causing too many headaches?

The M1 SoC is a series of ARM based devices created by Apple and was launched in 2020. The introduction of this series of devices marked the end of Apple's use of Intel technologies, and signaled a new era of low-energy computing. As the capabilities of traditional architectures (x86/x64) reached their limits for Apple, engineers started to look towards alternative solutions that would allow for increased energy efficiency.

While CISC (Complex Instruction Set Architecture) provides many different instructions for specific tasks, it requires more transistors to realize, and as such, consume more energy. In contrast, RISC (Reduced Instruction Set Architecture) uses far fewer, more generic instructions. With fewer instructions, a RISC CPU may spend more time jumping around in programs, requiring more program execution cycles, but each cycle consumes far less energy. When combining this with the fact that RISC CPUs have significantly fewer transistors, it becomes possible to put many more cores onto a single piece of silicon, thus allowing for massively parallel computing.

This is essentially how the M1 is able to be so incredibly efficient , combining eight ARM cores (four low-power and four high-performance) with a unified memory, an integrated Neural Engine (providing AI execution acceleration), and a GPU, all on a single package. The total number of transistors on the M1 varies, with the total transistor count for the Ultra variant being approximately 114 billion (with 20 CPU cores).

But the capabilities of the M1 didn’t just extend into the field of low energy computing; it was also able to provide massive performance boosts for even complex tasks. For example, the M1 is able to provide users with an efficient computing system when running office applications, while providing excellent graphics capabilities thanks to the integrated GPU and performance cores.

Recognising the potential capabilities of the M1, a team of researchers from MIT decided to create a custom operating system , called Fractal, with the hope of being able to better understand how the M1 behaves. The researchers specifically chose to use the Apple M1 as it is a relatively new technology, but this also made it a more interesting case study as it lacks the many exploits often found in older technologies. Furthermore, the researchers developed Fractal to also be able to target many different processor types including x86_64, ARM64, and RISC-V.

After exploring Apple’s Silicon, the researchers then turned their attention to the CSV2 mechanism used to protect code from execution in protected areas. Simply put, the M1 has multiple execution environments including secure, non-secure, and user space, and these different areas cannot execute code from another area (for example, secure areas can’t peek into user space).

However, when trying to prevent this, it is essential that code can be executed across boundaries in safe environments (such as during debugging). As such, Apple’s Silicon incorporates a mechanism called Code Segment Verification Level 2 (CSV2), which prevents the execution of out-of-bounds code.

But the researchers also discovered that while the CSV2 mechanism blocks the execution of code, it doesn’t prevent the data cache from being prefetched. This means that an attacker can use data to trigger prefetching which can then be used to jump to arbitrary code execution. But this vulnerability isn’t just limited to the M1, the researchers also discovered a vulnerability class called “Phantom Speculation, which has also been seen on Intel and AMD processors.

It seems that every time a new CPU comes out using speculative execution , researchers eventually find vulnerabilities, making many wonder if this is becoming too much of a problem.

There is no doubt that speculative execution accelerators are extremely brilliant pieces of engineering, able to massively increase execution throughput. These accelerators grab memory that will eventually be needed as well as performing potential future operations to deliver results faster.

However, because these accelerators peek into memory and guess what needs to be executed , it quickly becomes very trivial to use speculative execution to perform illicit tasks. Of course, vulnerabilities of these systems are not solely the fault of these accelerators, as they are merely hardware circuits. Often, these vulnerabilities arise due to a lack of internal privilege checking and correct enforcement of protected areas of memory. Spectre and Meltdown are just two examples of a few of the many speculative execution vulnerabilities that have been discovered.

Looking forward, it is likely that speculative execution will continue to cause headaches, and engineers will need to potentially rethink how speculative execution is done. Regardless of what solutions are eventually found, it doesn’t currently look good for speculative execution, and the use of speculative execution in modern CPUs may need to be rethought.

Robin Mitchell is an electronic engineer who has been involved in electronics since the age of 13. After completing a BEng at the University of Warwick, Robin moved into the field of online content creation, developing articles, news pieces, and projects aimed at professionals and makers alike. Currently, Robin runs a small electronics business, MitchElectronics , which produces educational kits and resources.