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
헤더의 나머지 부분은 0입니다. 파일 내에서 페이로드 길이를 탐색한 후, 또 다른 헤더와 추가 펌웨어 데이터가 존재할 수 있습니다. 이를 펌웨어 "섹션"이라고 부를 수 있습니다. 지금은 첫 번째 섹션에만 집중하겠습니다.
특정 펌웨어 파일에서는 하나의 패턴이 나타납니다. 각 워드를 다음 워드에 섞어 넣는 레이어가 존재합니다.
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하면 긴 연속된 0과 읽을 수 있는 구조가 드러납니다.
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)를 진행시키고,
블록 키에서 시작하여 매 단계마다 18비트씩 회전하는 마스크와 XOR한다.
따라서 알려진 워드 하나로 전체 블록을 풀 수 있다. 수식을 재배열하면 알려진 키스트림 워드로부터 블록 키를 구할 수 있다:
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)
각 블록의 키는 어디에서 왔는가? 이는 256개 항목의 시드 테이블에서 가져온 두 개의 16비트 절반으로 분해된다:
def block_key_of(block, seed_table):
hi = seed_table[block]
lo = seed_table[block ^ 0xF9]
return (hi << 16) | lo
시드 테이블 자체에는 특별한 공식이 없는 것으로 보인다. 아마도 각 기기의 부트로더 어딘가에 저장된 512바이트 상수일 것이다. 그러나 0xF9와의 XOR은 아름다운 부작용을 제공한다: 바로 거울 법칙이다. 어떤 블록과 그 파트너 block ^ 0xF9는 동일한 두 테이블 항목이 서로 교환된 형태로 구성된다.
mirror = block_key_of(block ^ 0xF9, seed_table)
assert mirror == rotr(block_key_of(block, seed_table), 16)
이것은 이전에 알려지지 않았던 영역을 크랙했다. 전체 블록 키를 맹목적으로 추측하는 대신, 두 개의 16비트 절반을 추측하고 어떤 선택이 두 블록을 그럴듯한 문자열이나 ARM 명령어로 바꾸는지 점수를 매길 수 있다.
이를 통해 이 특정 암호를 사용하는 모든 펌웨어 데이터에 대해 100% 커버리지를 얻었다.
위의 암호는 8BitDo의 대부분의 GD32 기기에 존재하는 것으로 보이며, 그래서 나는 이것을 "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 파트너로부터 구성되지만, 각각은 먼저 작은 테이블의 값과 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]
def block_key_of(block, seed_table):
e = (block + (block >> 8)) & 0xFF
hi = seed_table[seed_index(e)]
lo = seed_table[seed_index(e ^ 0xF9)]
return (hi << 16) | lo
복호화된 이미지는 SDK 잔여물로 판단컨대 대부분 Yichip 기반인 것으로 보인다. 실제로 최근 Zero 2 기기의 분해 결과 해당 기기가 특정적으로 YC3121을 사용하는 것으로 나타났다. 따라서 이를 "Yichip 암호"라고 명명하겠다.
GD32 암호와 달리 Yichip 암호는 256 블록으로 제한되지 않는다. 256 블록마다 스케줄이 래핑된다. 즉, 카운터 베이스가 1 증가하고(GD32 암호의 block // 2 항과 매우 유사함) 키 인덱스가 1씩 전진한다. 이는 600 블록 이상에 걸쳐 끝에서 끝까지 복호화되는 초기 64 BT 빌드에서 실제로 확인된다.