smiiiiiiiiiiiiiiii: breaking the SMM rendezvous with one long instruction
A very very very very very very very long interrupt
At a glance
- What is it?
- A proof of concept showing that System Management Mode's core invariant, that all processors are inside or outside SMM together, can be broken by keeping one core busy for longer than the firmware's one-second synchronization timeout. The trick is a single wide vector load from an MMIO address that answers at a crawl, and the build is four lines of Makefile around one C file.
- Who is it for?
- Read this if you maintain firmware, hypervisors or anything that treats SMM as a trustworthy boundary, because the finding is that the boundary rests on a one-second timer rather than on anything the attacker has to defeat. Two things to keep in mind.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 89 days ago.
- What is it written in?
- Mainly C, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- xoreaxeaxeax/smiiiiiiiiiiiiiiii369 ★ · +4
| Repository | 2026-09-17 | 2026-11-15 |
|---|---|---|
| xoreaxeaxeax/smiiiiiiiiiiiiiiii | 365 | 369 |
4 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
SMM's one guarantee is that nothing else runs while it does
The security model is worth stating plainly before the attack, because everything else depends on it. System Management Mode is described as the secure, ultra privileged execution environment running invisibly in the background of every x86 CPU, and the property the rest of the platform leans on is that while it runs, nothing else does. That property is not enforced per core. It is enforced collectively: SMM requires that all cores are either in SMM or out of SMM at the same time, and when one thread enters, it makes all the others enter too. The moment that stops being true, a handler running with full privilege is checking its assumptions about a machine where normal code is still executing. The attack is therefore not about corrupting SMM state directly. It is about arranging for one core to be unavailable at the moment the collective entry is supposed to happen, so the two sides of the invariant are briefly false at once and an ordinary ring zero attacker has a window.
Firmware waits one second, then gives up on the straggler
The rendezvous is implemented in x86 firmware, and the project links the exact code it is attacking, a loop in the EDK2 module that runs when a processor enters SMM:
for (Timer = StartSyncTimer ();
!IsSyncTimerTimeout (Timer, mTimeoutTicker) && SyncNeeded;
)
{
mSmmMpSyncData->AllApArrivedWithException = AllCpusInSmmExceptBlockedDisabled ();
if (mSmmMpSyncData->AllApArrivedWithException) {
break;
}
CpuPause ();
}The loop has two exit conditions and no third: either every core has arrived, which it re-checks each pass, or the sync timer has hit its ticker, in which case it stops waiting and proceeds anyway. The documented behaviour is that it waits for all cores to enter SMM, or for up to one second, whichever occurs first. Between polls it only issues a CpuPause, which is a hint to the core that it is in a spin loop. That timeout is the entire attack surface. It exists so that a wedged or absent processor cannot hang the whole machine in SMM forever, and in exchange it converts a collective invariant into a one-second promise that an attacker with ring zero access can hold up.
The delay has to be one instruction, not a million fast ones
The obvious approach of simply executing a lot of work does not work, and the reason is architectural. A system management interrupt is taken at an instruction boundary, so any gap between two instructions gives the pending SMI somewhere to land, and the moment the core reaches a boundary it gets pulled into SMM like any other. A loop of cheap arithmetic is therefore useless: every iteration boundary is an invitation. What is required is a single uninterruptible operation that outlasts the one-second rendezvous on its own, with no boundary inside it. That reframes the problem as a memory system problem rather than a computation problem, because the one category of x86 operation that blocks the pipeline for an unbounded time under the core's control is a load from a device that is slow to respond. The proof of concept is described as needing an instruction that takes around four billion cycles, over a second of wall clock time, against a baseline where add takes a single cycle.
A wide vector load from an address that answers at a crawl
The recipe is described roughly, with the explicit caveat that the exact approach varies from platform to platform. Find a high latency MMIO address, then convince the processor to read from it as slowly as possible, which in practice means abusing an undocumented region that answers reads at a crawl, use the widest load the instruction set will give you so a single instruction moves as many bytes as possible across the bus, and let the other cores contend for the same bus to slow it further. One read, one instruction, and the core is stuck holding it for the better part of a second. The version in the repository is tuned for a Zen 3 Ryzen 7 5800H, where a wide vector register load from a specific slow address stalls long enough to break the all-cores rendezvous:
mov $0xfcc68860, %rsi ; the target MMIO address
vmovdqu (%rsi), %xmm0 ; the very, very long loadThe address is a property of that chip's memory map rather than of the instruction set, which is why the same technique needs re-finding on each platform and why the project declines to claim a universal payload.
Two cores, a spin loop, an MSR counter and port 0xb2
The proof of concept pits one core against another and measures the result rather than asserting it. The victim core is held outside SMM by spinning on the slow load, too busy to service an SMI:
/* the victim core: spin on the ~1-second load, too busy to answer the SMI */
for (;;)
asm volatile ("vmovdqu (%0), %%xmm0" :: "r"(mmio) : "xmm0");The other core arms the per-core SMI counters, using the AMD performance event select register and its paired 48-bit counter, and enables the event with a fixed configuration value, then fires a storm of system management interrupts by writing to port 0xb2, and finally reads every core's tally back and compares them:
asm volatile ("outb %%al, $0xb2" :: "a"(0)); /* kick port 0xb2 -> #SMI */uint64_t delta = smi_max - smi_min;
if (delta)
puts("!!! a core ran outside SMM");If the counts diverge, a core kept running outside SMM while the others were pulled in, meaning it missed the interrupts the rest serviced. The repository ships an animated capture of exactly that, with the counters stepping in lockstep until one core falls far enough behind to break the synchronization, and it is candid that this is behind a deliberately flashy and entirely pointless interface.
Why a hundred SMM race bugs have stayed unpatched
This is the part that makes the finding matter beyond a curiosity. The readme points at more than a hundred SMM time-of-check-to-time-of-use CVEs, where a handler checks a value in shared memory and then uses it. The exploitation requirement for that whole class is trivial once you are inside: rewrite the value in between the check and the use, and the handler operates on your data. Those bugs have sat dormant and largely unpatched because of the rendezvous itself, since exploitation requires something to modify shared memory while SMM executes, and while the rendezvous holds, no core is outside SMM in a position to launch the attack. Historically the only route in was a DMA capable peripheral writing behind the processor's back, which means physical access or a malicious device, and that is why the class has been written off as a hardware problem rather than a software one. Breaking the rendezvous removes the assumption the dismissal rests on, and turns a physical attack requirement into a software one.
Four lines of Makefile around a single C file
The build is about as small as a proof of concept gets:
CC = gcc
CFLAGS = -O2 -Wall -mavx -march=native
TARGET = smiiiiiiiiiiiiiiiiThere is one source file at the root, a target that compiles it, and a clean rule, with the repository also carrying a license, a readme, an ignore file and an examples directory holding an animated capture. Two details in those flags matter more than they look. The AVX flag is required rather than optional, since the whole technique depends on a wide vector load being available. The native architecture flag means the compiler targets the build machine, which is correct for a payload tuned to one microarchitecture's memory map and simultaneously means the resulting binary will not run on anything else, so this is a demonstration to run on hardware you own rather than a tool to distribute. The project is MIT licensed, publishes no releases, and was last pushed on 2026-08-18.
Editorial conclusion
Read this if you maintain firmware, hypervisors or anything that treats SMM as a trustworthy boundary, because the finding is that the boundary rests on a one-second timer rather than on anything the attacker has to defeat. Two things to keep in mind. The proof of concept is tuned to a specific microarchitecture, a Zen 3 Ryzen 7 5800H with a wide vector load from one particular slow MMIO address, and the file is explicit that the exact approach varies from platform to platform, so treat it as a demonstration of the class rather than a portable exploit. It is also built with -march=native, so the binary will not run anywhere but the machine it was compiled on. The repository is MIT licensed with no releases, and the last push was on 2026-08-18.
Frequently asked questions
What does smiiiiiiiiiiiiiiii demonstrate?
That a single long-running machine instruction can break System Management Mode's all-cores invariant. SMM requires every core to be in or out together, and the firmware rendezvous only waits one second, so keeping one core busy inside a single uninterruptible operation longer than that leaves it running outside SMM while the others are inside.
What is the one-second timeout in the SMM rendezvous?
It is the sync loop in the EDK2 PiSmmCpuDxeSmm module that runs when a processor enters SMM. It re-checks whether all cores have arrived and stops either when they have or when the sync timer reaches its ticker, so the wait is capped at one second, with only a CpuPause between polls.
Why must the delay be a single instruction?
Because a system management interrupt is taken at an instruction boundary, so any gap between two instructions lets the pending interrupt pull the core into SMM. A loop of fast operations therefore never works; the proof of concept needs one uninterruptible operation, a wide vector load from a slow MMIO address, that outlasts the whole one-second rendezvous by itself.
What hardware is the smiiiiiiiiiiiiiiii proof-of-concept tuned for?
A Zen 3 Ryzen 7 5800H, where a wide vector register load from the slow MMIO address 0xfcc68860 stalls long enough to break the all-cores rendezvous. The project states that many approaches exist and that the exact method varies from platform to platform, since the address is a property of the chip's memory map.
Why have SMM race condition bugs gone unpatched?
The readme links more than a hundred SMM time-of-check-to-time-of-use CVEs and explains they stayed dormant because exploiting one requires modifying shared memory while SMM executes, and the rendezvous leaves no core outside SMM to do it. The only previous route was a DMA capable peripheral writing behind the processor, which needs physical access, so the class was treated as a hardware problem.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/xoreaxeaxeax-smiiiiiiiiiiiiiiii)Star history chart for your README
[](https://hysenlabs.com/projects/xoreaxeaxeax-smiiiiiiiiiiiiiiii)Was this useful?