A computer address sounds wonderfully final. Ask for memory location X, and the machine should return X, not its neighbor, not a secret room, and certainly not whatever happens to be behind the next electrical shrub. Yet a hardware-security experiment showed that, on older AMD Family 16h systems, the address on a request could stay exactly the same while the memory controller briefly sent it to different DRAM coordinates.
The trick was not changing the protected physical address. It was changing the final map used after that address had passed the usual fences. Think of an envelope that clears every security desk because its street address is allowed, followed by a postal sorter quietly deciding that the same street now points to another building. The envelope is innocent. The map has become adventurous.
The quiet promise inside every pointer
Software lives by a small act of faith: if two instructions refer to the same address, they are talking about the same place. Programmers write that faith into pointers. Operating systems build virtual-memory tables around it. Hypervisors, secure regions, and firmware protections then decide which physical-address ranges a caller may touch.
A request may be checked against page permissions, privilege levels, isolation rules, and protected ranges before it gets near a memory chip. The resulting physical address feels like a passport stamped by several stern offices.
But a passport is not a hotel room key. Physical addresses form a flat numbering system; DRAM is arranged as channels, banks, rows, and columns. The memory controller translates one into the other, and it gets the final word.
An address still has one more trip to make
AMD’s documentation describes this step directly: a physical address becomes DRAM coordinates. The mapping can distribute nearby addresses across channels and banks instead of queueing every request at one overworked doorway.
Normally, this is invisible housekeeping. X passes through the same mapping and lands on the same cells. Christopher Domas’s research focused on older AMD Family 16h hardware where the relevant controls were publicly documented and, according to the project, could not be locked against later changes.
That made a strange question testable: what if the CPU keeps requesting physical address X, the protection system keeps approving physical address X, but the memory controller briefly changes what X means at the DRAM pins?
The fence watches the envelope
Most protections here watch the address presented to them. A guard checks the requested physical number and stops forbidden ranges. Sensible. Necessary. Also one stage too early for this experiment.
The final DRAM map sits downstream. If that map changes after the guard has approved X, the guard does not automatically know that X now opens the cells previously associated with Y. No fence was smashed. The sign on the gate remained legible. Someone rotated the building behind it.
This explains the project’s paradoxical slogan: an address can appear unequal to itself. Mathematically, X remains X. Electrically, its destination can change. It is a broken promise about what happens after a pointer is checked.
Changing the map without moving the address
The project altered a memory-controller mapping mode briefly, making some physical addresses resolve to different DRAM coordinates. Restoring the mode restored the ordinary relationship. WonderSift is omitting commands and low-level values because the useful idea is the boundary failure, not a recipe for modern sculpture.
According to the project, the remapping could expose regions associated with system-management mode, platform-security-processor memory, C6 state, and CPU microcode. Those are the project’s reported results, not findings WonderSift independently reproduced. They also do not establish the same behavior on current AMD systems, or on Intel or Arm machines.
The demonstrated target matters. Family 16h is older hardware. AMD’s current documentation remains useful for understanding that DRAM mapping exists, but it is not evidence that today’s products share the same controls or weakness. Architecture rhymes; vulnerabilities require their own proof.
How not to turn the experiment into instant confetti
Changing where memory lands while an operating system runs is like swapping every apartment number during dinner service. The CPU is fetching instructions, reading page tables, updating data, and handling interrupts. A leisurely remap would end useful execution quickly.
The research therefore relied on a narrow survival window. Conceptually, caches and translation lookaside buffers kept some urgently needed information close to the CPU. Interrupts were controlled so unexpected work would not wander into the changed map. The original mapping was restored rapidly, before ordinary memory traffic had much time to become confused.
The computer did not continue because the map change was harmless. The experiment was choreographed around its short-term memory of where things had been. Even the attack needed the machine forgetful and stubborn at exactly the right moments.
A narrow result with a broad lesson
This is not a reason to distrust every RAM stick or assume modern processors are quietly shuffling secrets. It is a specific demonstration on older AMD Family 16h hardware. The result earns attention because it exposes a general design question: after a security check approves an identifier, can a later programmable stage change what that identifier reaches?
The same question travels beyond memory controllers. Access controls often validate names, paths, handles, tokens, or addresses and then trust downstream machinery to preserve their meaning. If meaning can be remapped later, the strongest fence may protect a label rather than the destination.
A computer forgetting where its memory lives sounds whimsical. The engineering lesson is less cute. Security boundaries need to cover the last consequential translation, not merely the last one visible to software. Otherwise the envelope can pass every guard while the building quietly moves.
Sources
Related reading
Another hidden technical assumption becomes visible when two 3D files look the same but are not.
Keep sifting
Browse WonderSift’s daily editions, explainers, and durable tools in one place.