
Реверс-инжиниринг документации и инструментов для методов шифрования прошивки 8BitDo
Документация и инструменты, полученные путём обратной разработки, для методов шифрования прошивок, используемых 8BitDo в нескольких продуктах.
См. cryptdo8.py — инструмент для расшифровки и повторного шифрования, реализующий
алгоритмы, описанные в этом документе.
Инструмент потенциально позволяет создавать кастомные прошивки. Однако этот репозиторий не содержит никаких официальных данных прошивок. Скрипт для загрузки последних файлов прошивок можно найти в репозитории fwupd/8bitdo-firmware, где также заархивированы некоторые более старые бинарные файлы прошивок.
Если посмотреть на файл прошивки .dat снаружи, в нём присутствует 28-байтовый
заголовок в открытом виде.
import struct
raw = open("sn30.dat", "rb").read()
version, addr, payload_len, pid = struct.unpack("<IIII", raw[:16])
# version = 207 -> firmware == v2.07
# addr = 0x08003400 -> destination (probably)
# payload_len = 99328 -> section payload length in bytes
# pid = 0x0000 -> (optional, usually 0) USB PID
Остальная часть заголовка заполнена нулями. После перехода к длине полезной нагрузки в файле могут присутствовать ещё один заголовок и дополнительные данные прошивки. Мы можем называть их «секциями» прошивки. Пока мы сосредоточимся только на первой секции.
В некоторых файлах прошивки проявляется закономерность: существует слой, который смешивает каждое слово со следующим.
def rotr(x, r):
return ((x >> r) | (x << (32 - r))) & 0xFFFFFFFF
dechained = [words[0]]
for i in range(1, len(words)):
dechained.append(words[i] ^ rotr(words[i - 1], 3))
Эта цепочка сбрасывается на каждой границе блока из 128 слов. Первое слово блока
(pos = 0) не имеет предшествующего члена, а pos = 1..127 образуют цепочку от
предыдущего слова.
Слой без ключа не добавляет безопасности. Его снятие открывает более чистый промежуточный
результат (dechained), где единственное, что скрывает открытый текст, — это поток ключа.
P[i] = dechained[i] ^ keystream[i]
Репозиторий fwupd/8bitdo-firmware содержит каталог более старых прошивок. Все эти прошивки, по-видимому, имели слой цепочки.
XOR-сложение некоторых из них после удаления слоя цепочки выявляет длинные последовательности нулей и читаемую структуру.
plaintext_diff = [a ^ b for a, b in zip(dechained_a, dechained_b)]
Если один и тот же поток ключей используется в обоих...
a = dechained_a[i] ^ dechained_b[i]
b = (P_a[i] ^ keystream[i]) ^ (P_b[i] ^ keystream[i])
c = P_a[i] ^ P_b[i]
assert a == b == c
поток ключей взаимно уничтожается.
Это классический многоразовый блокнот (many-time pad). Такой поток ключей безопасен только при однократном использовании. По какой-то причине 8BitDo решила использовать не просто поток ключей для каждого продукта, а единый поток ключей для нескольких продуктов. Это значительно ослабило безопасность их шифра и сделало возможным остальной анализ, приведённый здесь.
Как только вы знаете, что два открытых текста объединены операцией XOR, вы можете угадать часть одного из них и выполнить XOR с вашей догадкой, чтобы прочитать другой. Это восстанавливает поток ключей в этом месте.
keystream[i] = dechained[i] ^ P[i]
for fw in all_fw:
P[fw][i] = dechained[fw][i] ^ keystream[i]
Проще всего это было бы сделать со строками, но самым продуктивным приёмом здесь оказалось кросс-версионное перемещение ARM-инструкций. Одна функция может присутствовать в двух версиях прошивки на смещённых позициях. Там, где поток ключа известен в одной версии, можно выровнять общий код в другой и собрать новые значения потока ключа.
Использование этого увеличило число известных слов потока ключа с ~1 500 до нескольких тысяч, сделав читаемыми примерно 18% прошивки.
На большей выборке потока ключа стали видны закономерности: позиции, отстоящие на 16 слов, которые сдвигались на почти постоянную величину, и байты, смещавшиеся на предсказуемый размер.
Путём проб и ошибок было обнаружено, что каждое слово потока ключа в блоке подчиняется формуле:
STEP = 0x92A753FA
A_MUL = 0x80000301
ROT = 18
UINT32_MAX = 0xFFFFFFFF
def rotr(x, r):
r &= 31
return ((x >> r) | (x << (32 - r))) & UINT32_MAX if r else x
def block_base(block):
return (block * A_MUL + block // 2) & UINT32_MAX
def keystream(block, pos, block_key):
counter = (block_base(block) + pos * STEP) & UINT32_MAX
mask = rotr(block_key, ROT * pos)
return counter ^ mask
Весь блок из 128 слов определяется одним 32-битным числом: его «ключом блока».
Внутри блока выполняется проход по простому счётчику (block_base(block) + pos * STEP), и
он XOR-ится с маской, которая начинается с ключа блока и поворачивается на 18 бит на каждом шаге.
Следовательно, одно известное слово разблокирует целый блок. Перестановка формулы даёт ключ блока из любого известного слова ключевого потока:
def block_key_from_known(block, pos, known_keystream):
counter = (block_base(block) + pos * STEP) & UINT32_MAX
return rotr(known_keystream ^ counter, -ROT * pos & 31)
Откуда взялся ключ каждого блока? Он раскладывается на две 16-битные половины, взятые из таблицы seed из 256 записей:
def block_key_of(block, seed_table):
hi = seed_table[block]
lo = seed_table[block ^ 0xF9]
return (hi << 16) | lo
Сама таблица seed, по-видимому, не имеет конкретной формулы; вероятно, это 512
константных байтов, хранящихся где-то в загрузчике каждого устройства. Однако
XOR с 0xF9 даёт прекрасный побочный эффект: закон зеркальности. Блок и
его партнёр block ^ 0xF9 строятся из одних и тех же двух записей таблицы, но в обратном порядке.
mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)
Это позволило взломать ранее неизвестные области. Вместо того чтобы вслепую угадывать полный ключ блока, можно угадать две 16-битные половины и оценить, какой вариант превращает оба блока в правдоподобные строки или инструкции ARM.
Благодаря этому была достигнута 100% покрытие всех данных прошивки, использующих этот конкретный шифр.
Вышеописанный шифр, по-видимому, присутствует на большинстве устройств GD32 от 8BitDo, поэтому я назвал его «шифром GD32».
Существует более новый шифр, последовательно используемый 8BitDo. Продукты, использующие этот шифр, включают большую часть линейки Ultimate/Pro, M30 и Zero 2, и это лишь некоторые из них. Последние два, похоже, имеют несколько секций в своих файлах прошивки: первая закодирована старым шифром GD32, а вторая — этим новым шифром.
После множества экспериментов я обнаружил, что этот шифр не является полностью новым. На самом деле это вариант существующего шифра GD32 с изменёнными параметрами:
CHAIN_ROT = 18 # GD32: 3
STEP = 0xEE97FAFA # GD32: 0x92A753FA
A_MUL = 0x01200210 # GD32: 0x80000301
ROT = 16 # GD32: 18
def block_base(block):
return (block * A_MUL + (block >> 8)) & UINT32_MAX
Примечательно, что ключ блока по-прежнему строится из индекса и его партнёра 0xF9, но каждый из них сначала превращается в индекс таблицы seed-значений путём XOR с значением из небольшой таблицы. Здесь e — позиция блока в расписании ключей из 256 записей:
INDEX_XOR = ((0x00, 0x82, 0x83, 0x81, 0x03, 0x81, 0x83, 0x81),
(0x86, 0x83, 0x81, 0x82, 0x03, 0x05, 0x82, 0x82))
def seed_index(e):
return e ^ INDEX_XOR[e >> 7][e & 7]