skitter-creek-bath-salts: one bit flip in the DRAM controller, and why the datasheets help
Unlocking _everything_ on the CPU with DRAM scrambling
At a glance
- What is it?
- A hardware research project that rewrites the memory controller's address translation on a running AMD processor, which makes protected memory reachable and makes an address stop pointing at itself. It is written as an explanation of the memory hierarchy, and the most careful parts are the caveats about what the documentation does not say.
- Who is it for?
- Read this as a paper rather than as a tool. It has no package to install, no configuration to set, and its deliverable is an argument about where the memory hierarchy can be attacked from, supported by an explicit account of what the processor documentation does and does not tell you.
- 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 94 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/skitter-creek-bath-salts2,304 ★ · +245
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| xoreaxeaxeax/skitter-creek-bath-salts | 2.1k | 2.3k |
245 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The attack surface is the layer below every memory fence
The opening claim is that an address can be made to land anywhere in memory by manipulating the memory controller, and that the project does this by modifying the bottom of the memory hierarchy so that physical address translation is rewired.
The reasoning is a stack argument, and it is worth following precisely because the conclusion depends on where each protection sits. Every mechanism the processor, firmware, uncore, and chipset use to wall off protected memory operates above the memory controller. The fences guard physical addresses. The memory controller issues DRAM coordinates, which are a different thing. Rearrange the coordinates and the barriers above never see it happen.
So the project is not claiming to defeat a fence. It is claiming to act underneath one, at a stage where no fence exists to be defeated. The regions it reaches are described as carveouts that are invisible even to the kernel, meaning there is no software-visible mapping to check first.
That framing also explains why the demonstration is written the way it is. The stated goal is to show a platform whose view of memory is internally inconsistent, where the same address expression yields different values depending on when in the sequence it is evaluated. That is a more general and more portable claim than a particular secret being read.
The security consequences stated at the top cover a list of platform features, all of them subcomponents whose trust depends on those translations holding still.
It targets one vendor and one generation, and says why that is not arbitrary
The target statement is unusually precise. The work was developed and tested on one processor family, described as the last generation whose datasheets document the memory controller's translation registers, and the specific claim is that those documents show the registers cannot be locked. Later generations simply leave that information out.
That is a real and unusual constraint to state plainly. Most research that depends on undocumented hardware registers is silent about which documentation was available. Here, the availability of the documentation is the reason for the target, not a coincidence.
The project then makes a broader claim about portability. It says the pattern of descending through the address pipeline is similar across generations and architectures, and that the underlying transforms extend to other instruction set architectures as well. Then it immediately bounds its own claim, saying it shows only how to begin.
That last sentence does a lot of work. Everything above it is a scoping statement, and this is the disclaimer. A reader could take the portability paragraph as a claim that other architectures are solved; the sentence after it says the opposite.
The examples directory supports the framing. Four of its five files are animated images with names describing stages of the technique, and the fifth is a still photograph. That is the artefact set of a write-up rather than of a distributable tool.
The exploit is presented as one instruction, and the difficulty is stated to be elsewhere
The README shows the entire rewiring as a single operation on a memory-mapped register: an exclusive-or of a value into a fixed location, in a register whose position corresponds to the bank-swizzle mode in the data fabric.
Then a sentence that reframes the difficulty. The bit in question is one of dozens controlling the address remaps at the final layer, so poking them is the easy part. What is hard is keeping the platform operational while all of system memory is scrambled underneath it.
The described method is a race. Stop the application processors, prime the translation lookaside buffers, warm the cache, disable interrupts, flush the target, serialise memory accesses, rewire the controller, read from the protected region, restore the mapping, serialise again, re-enable interrupts, resume the processors.
The assembly fragment that follows shows the sequence, and the comments carry the argument. A fence is annotated as ensuring no coherent world access, and another is annotated as being reordered into the scrambled view. Two lines flip the same bit, once to scramble and once to restore, and the fragment ends mid-sequence at the restore.
What is striking is the framing of the prefetcher. One step of the described method is to hope the processor has already fetched the upcoming instructions, which is presented plainly rather than engineered around. A demonstration that depends on a cache-timing assumption is a different kind of artefact from a tool, and the README does not pretend otherwise.
The hard part is stated as an underspecified datasheet, and the answer is linear algebra
Once the translation can be rewritten, a second problem appears and the README is explicit about it: the project does not know what transform the memory controller will actually apply. The datasheets are described as underspecified at exactly this point, with three specific complaints. The exclusive-or maps are wrong. The subtractive stage in the memory-mapped I/O path is unordered. And details vary across models.
So without a solution, memory scrambles but cannot be reconstructed.
The solution is a property of the hardware rather than of the documentation. The address transform is described as a linear map over a finite field, which means the unknown mapping can be recovered with basic linear algebra instead of being guessed from tables.
The README then works the problem through. It sets up the normal case as a matrix equation, showing a transformation matrix applied to a physical address vector producing a secret vector, with the matrix drawn as a large table and the address and secret as column vectors beside it.
Then it shows the same equation after the rewiring, where a different transform lets an alias reach the same secret. That is the constructive heart of the project: two configurations, one equation each, and the difference between them is the attack.
The framing is what generalises. Treat an undocumented hardware address remap as a linear system, solve for the coefficients, and an incomplete datasheet becomes a solvable problem rather than an obstacle. The project also notes the address is 16 bits wide in the example, which bounds the linear algebra to something hand-computable.
The sequence of steps is the actual content of the low-level example
The low-level fragment is where the project's claims are either earned or not, and it is worth reading line by line rather than as a proof of concept.
There is a read from the controller's own register space annotated as priming the translation buffer for that space. There is a read from the target physical address, annotated as priming the buffer for the target. The flags are pushed to preserve them, and then interrupts are disabled.
The target is then flushed from the cache, with a comment that this evicts it and forces the read to actually go to memory. Two fences follow. The first is annotated as a barrier that guarantees no coherent view of memory access remains outstanding. The second is annotated as being reordered into the scrambled view, which is the entire trick: one fence orders against the coherent world, the other does not.
And only then is the bit flipped. The fetch from the target happens in the scrambled view, and the same bit is flipped again to restore.
So the ordering is not incidental. If the flush or either fence is in the wrong place the sequence returns a coherent value, and if the restore happens before the fetch the read returns nothing useful. The fragment is short enough to audit completely, which is unusual for a security proof of concept and is the main reason to trust the demonstration rather than take it on faith.
The repository is a paper that happens to compile
The tree is six entries and a makefile with three targets, which is the whole build story.
default:
$(MAKE) -C kernel
$(MAKE) -C userspace
clean:
$(MAKE) -C kernel clean
$(MAKE) -C userspace cleanThe other entries are two README files, a licence, a gitignore, and three directories for analysis, data, and examples. The second document is a usage guide, so the project ships with a manual as well as the write-up.
The language is C, and the split between the two build directories is the standard shape for a project that needs privileged code and unprivileged code. Kernel-side code is what makes this sort of work possible at all, since the registers involved are in processor silicon rather than in an operating system.
No releases have ever been published, which is consistent with the framing. This is not distributed software with versions; it is a finding that includes source code so a reader can check it. That also means there is no compatibility matrix, no changelog, and no statement of which kernels or distributions it has been built against.
The last commit is dated 2026-08-13.
Editorial conclusion
Read this as a paper rather than as a tool. It has no package to install, no configuration to set, and its deliverable is an argument about where the memory hierarchy can be attacked from, supported by an explicit account of what the processor documentation does and does not tell you. The part that generalises beyond one chip generation is the linear-algebra framing: a hardware address remap is a matrix over a finite field, so an unknown transform can be solved for rather than guessed, which turns an underspecified datasheet into a tractable problem. Judge the work on that argument and on the honest limits stated alongside it, not on whether it runs on your hardware, since it targets one vendor and one family whose documentation happens to be complete.
Frequently asked questions
What does xoreaxeaxeax/skitter-creek-bath-salts do?
It rewrites the DRAM controller's address translation on a running system, which scrambles the memory map and exposes protected regions, including carveouts invisible to the kernel. The project describes the mechanism as modifying the lowest layer of the address pipeline, below the level any memory fence operates at.
What hardware does skitter-creek-bath-salts target?
AMD Family 16h processors, described as the last generation whose datasheets document the memory controller's translation registers and show they cannot be locked. The project says the pattern is similar across generations and architectures, while also stating it shows only how to begin.
How does skitter-creek-bath-salts solve for the unknown address mapping?
By treating the controller's address transform as a linear map over a finite field, which makes it recoverable with basic linear algebra. The project notes the datasheets are underspecified at this point, that the exclusive-or maps are wrong, and that the subtractive memory-mapped I/O stage is unordered.
Is skitter-creek-bath-salts distributed as a tool?
No. There are no releases, and the makefile has only a default build target recursing into a kernel directory and a userspace directory, plus a clean target. The repository ships the write-up, a usage guide, and source so a reader can check the claims.
What platforms does the approach in skitter-creek-bath-salts extend to?
The project states the pattern of the address pipeline is similar across generations and architectures, and that the underlying transforms extend to ARM, RISC-V, and beyond. It immediately bounds this by saying the project shows only how to begin.
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-skitter-creek-bath-salts)Star history chart for your README
[](https://hysenlabs.com/projects/xoreaxeaxeax-skitter-creek-bath-salts)Was this useful?