diff --git a/tools/backalyzer.py b/tools/backalyzer.py index d848777fd..c344ed6f9 100755 --- a/tools/backalyzer.py +++ b/tools/backalyzer.py @@ -1,12 +1,16 @@ #! /usr/bin/env python3 import argparse +import logging + from Crypto.Cipher import AES from rfc8452 import AES_GCM_SIV from Crypto.Hash import SHA512 import binascii from datetime import datetime import bcrypt -from cryptography.hazmat.primitives.keywrap import aes_key_unwrap_with_padding, aes_key_wrap_with_padding +from cryptography.hazmat.primitives.keywrap import aes_key_unwrap_with_padding +from cryptography.hazmat.primitives import hashes +from cryptography.hazmat.primitives.kdf.hkdf import HKDF from pddbcommon import * @@ -14,41 +18,6 @@ from bip_utils import ( Bip39MnemonicValidator, Bip39MnemonicDecoder ) -def keycommit_decrypt(key, aad, pp_data): - # print([hex(d) for d in pp_data[:32]]) - nonce = pp_data[:12] - ct = pp_data[12:12+4004] - kcom_nonce = pp_data[12+4004:12+4004+32] - kcom = pp_data[12+4004+32:12+4004+32+32] - mac = pp_data[-16:] - - #print([hex(d) for d in kcom_nonce]) - # print([hex(d) for d in kcom]) - #h_test = SHA512.new(truncate="256") # just something to make sure our hash functions are sane - #h_test.update(bytes([0x43, 0x6f, 0x6, 0xd6, 0xd, 0x69, 0x74, 0x01, 0x01])) - #print(h_test.hexdigest()) - - h_enc = SHA512.new(truncate="256") - h_enc.update(key) - h_enc.update(bytes([0x43, 0x6f, 0x6, 0xd6, 0xd, 0x69, 0x74, 0x01, 0x01])) - h_enc.update(kcom_nonce) - k_enc = h_enc.digest() - - h_com = SHA512.new(truncate="256") - h_com.update(key) - h_com.update(bytes([0x43, 0x6f, 0x6, 0xd6, 0xd, 0x69, 0x74, 0x01, 0x02])) - h_com.update(kcom_nonce) - k_com_derived = h_com.digest() - print('kcom_stored: ' + binascii.hexlify(kcom).decode('utf-8')) - print('kcom_derived: ' + binascii.hexlify(k_com_derived).decode('utf-8')) - - cipher = AES_GCM_SIV(k_enc, nonce) - pt_data = cipher.decrypt(ct + mac, aad) - if k_com_derived != kcom: - print("basis failed key commit test") - raise Exception(ValueError) - return pt_data - def bytes_to_semverstr(b): maj = int.from_bytes(b[0:2], 'little') min = int.from_bytes(b[2:4], 'little') @@ -69,6 +38,14 @@ def get_key(index, keyrom, length): return ret def main(): + global MBBB_PAGES + FSCB_PAGES = 16 + FSCB_LEN_PAGES = 2 + KEY_PAGES = 1 + global PAGE_SIZE + global VPAGE_SIZE + MAX_DICTS = 16384 + parser = argparse.ArgumentParser(description="Debug Backup Images") parser.add_argument( "-p", "--pin", required=True, help="unlock PIN", type=str, @@ -79,10 +56,24 @@ def main(): parser.add_argument( "--basis", required=False, type=str, help="Extra Bases to unlock, as `name:pass`. Each additional basis requires another --basis separator. Note that : is not legal to use in a Basis name.", action="append", nargs="+" ) + parser.add_argument( + "--loglevel", required=False, help="set logging level (INFO/DEBUG/WARNING/ERROR)", type=str, default="INFO", + ) args = parser.parse_args() + numeric_level = getattr(logging, args.loglevel.upper(), None) + if not isinstance(numeric_level, int): + raise ValueError('Invalid log level: %s' % args.loglevel) + logging.basicConfig(level=numeric_level) - print(args.basis) + basis_credentials = {} + if args.basis: + for pair in args.basis: + credpair = pair[0].split(':', 1) + if len(credpair) != 2: + logging.error("Basis credential pair with name {} has a formatting problem, aborting!".format(credpair[0])) + exit(1) + basis_credentials[credpair[0]] = credpair[1] # insert your mnemonic here. This is the "zero-key" mnemonic. mnemonic = args.backup_key @@ -91,7 +82,7 @@ def main(): # Like before with automatic language detection key = Bip39MnemonicDecoder().Decode(mnemonic) - print("Using backup key: 0x{}".format(key.hex())) + logging.debug("Using backup key: 0x{}".format(key.hex())) with open("backup.pddb", "rb") as backup_file: SYSTEM_BASIS = b".System" @@ -126,45 +117,46 @@ def main(): h_com.update(bytes([0x43, 0x6f, 0x6, 0xd6, 0xd, 0x69, 0x74, 0x01, 0x02])) h_com.update(commit_nonce) k_com_derived = h_com.digest() - print('kcom_stored: ' + binascii.hexlify(commit).decode('utf-8')) - print('kcom_derived: ' + binascii.hexlify(k_com_derived).decode('utf-8')) + logging.debug('kcom_stored: ' + binascii.hexlify(commit).decode('utf-8')) + logging.debug('kcom_derived: ' + binascii.hexlify(k_com_derived).decode('utf-8')) if k_com_derived != commit: - print("Key commitment is incorrect") + logging.error("Key commitment is incorrect") exit(1) cipher = AES_GCM_SIV(k_enc, nonce) try: pt_data = cipher.decrypt(ct + mac, AAD) except: - print("Ciphertext did not pass AES-GCM-SIV validation") + logging.error("Ciphertext did not pass AES-GCM-SIV validation") exit(1) i = 0 - print("Backup version: 0x{:08x}".format(int.from_bytes(pt_data[i:i+4], 'little'))) + logging.info("Backup version: 0x{:08x}".format(int.from_bytes(pt_data[i:i+4], 'little'))) i += 4 - print("Xous version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) + logging.info("Xous version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) i += 16 - print("SOC version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) + logging.info("SOC version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) i += 16 - print("EC version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) + logging.info("EC version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) i += 16 - print("WF200 version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) + logging.info("WF200 version: {}".format(bytes_to_semverstr(pt_data[i:i+16]))) i += 16 i += 4 # padding because align=8 ts = int.from_bytes(pt_data[i:i+8], 'little') / 1000 - print("Timestamp: {} / {}".format(ts, datetime.utcfromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S'))) + logging.info("Timestamp: {} / {}".format(ts, datetime.utcfromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S'))) i += 8 - print("Language code: {}".format(int.from_bytes(pt_data[i:i+4], 'little'))) + logging.info("Language code: {}".format(int.from_bytes(pt_data[i:i+4], 'little'))) i += 4 - print("Keyboard layout code: {}".format(int.from_bytes(pt_data[i:i+4], 'little'))) + logging.info("Keyboard layout code: {}".format(int.from_bytes(pt_data[i:i+4], 'little'))) i += 4 - print("DNA: 0x{:x}".format(int.from_bytes(pt_data[i:i+8], 'little'))) + logging.info("DNA: 0x{:x}".format(int.from_bytes(pt_data[i:i+8], 'little'))) dna = pt_data[i:i+8] + dna_int = int.from_bytes(dna, 'little') i += 8 i += 48 # reserved op = int.from_bytes(pt_data[i:i+4], 'little') - print("Opcode: {}".format(op)) + logging.info("Stored Backup Opcode: {}".format(op)) i += 8 # padding because align=8 keyrom = pt_data[i:i+1024] @@ -179,13 +171,13 @@ def main(): for b in bytes(boot_pw.encode('utf-8')): boot_pw_array[pw_len] = b pw_len += 1 - pw_len += 1 + pw_len += 1 # null terminate, so even the null password is one character long bcrypter = bcrypt.BCrypt() - print("{}".format(boot_pw_array[:pw_len])) - print("user_key_enc: {}".format(list(user_key_enc))) - print("salt: {}".format(list(pepper))) + # logging.debug("{}".format(boot_pw_array[:pw_len])) + logging.debug("user_key_enc: {}".format(list(user_key_enc))) + logging.debug("salt: {}".format(list(pepper))) hashed_pw = bcrypter.crypt_raw(boot_pw_array[:pw_len], pepper, 7) - print("hashed_pw: {}".format(list(hashed_pw))) + logging.debug("hashed_pw: {}".format(list(hashed_pw))) hasher = SHA512.new(truncate="256") hasher.update(hashed_pw) user_pw = hasher.digest() @@ -193,47 +185,146 @@ def main(): user_key = [] for (a, b) in zip(user_key_enc, user_pw): user_key += [a ^ b] - print("user_key: {}".format(user_key)) + logging.debug("user_key: {}".format(user_key)) rollback_limit = 255 - int.from_bytes(keyrom[254 * 4 : 254 * 4 + 4], 'little') - print("rollback limit: {}".format(rollback_limit)) + logging.info("rollback limit: {}".format(rollback_limit)) for i in range(rollback_limit): hasher = SHA512.new(truncate="256") hasher.update(bytes(user_key)) user_key = hasher.digest() - print("hashed_key: {}".format(list(user_key))) + logging.debug("hashed_key: {}".format(list(user_key))) pddb = backup[4096:] PDDB_A_LEN = 0x620_0000 pt_len = (PDDB_A_LEN // 0x1000) * 16 - pt = pddb[pt_len] static_crypto_data = pddb[pt_len:pt_len + 0x1000] scd_ver = int.from_bytes(static_crypto_data[:4], 'little') if scd_ver != 2: - print("Static crypto data has wrong version {}", 2) + logging.error("Static crypto data has wrong version {}", 2) exit(1) wrapped_key_pt = static_crypto_data[4:4+40] wrapped_key_data = static_crypto_data[4+40:4+40+40] pddb_salt = static_crypto_data[4+40+40:] - print(len(wrapped_key_pt)) - print("decap input: {}".format(list(wrapped_key_pt))) - - # inverse test - to_wrap = [5, 34, 117, 252, 137, 19, 29, 131, 64, 99, 195, 103, 228, 67, 165, 53, 179, 207, 169, 87, 232, 122, 52, 219, 202, 54, 210, 9, 233, 198, 38, 34] - wrap_key = [113, 227, 211, 48, 222, 183, 93, 94, 212, 86, 127, 203, 43, 125, 76, 117, 10, 249, 161, 96, 84, 206, 90, 170, 26, 207, 205, 203, 122, 177, 77, 171] - wrapped_key = aes_key_wrap_with_padding(bytes(wrap_key), bytes(to_wrap)) - print("wrapped_key: {}".format(list(wrapped_key))) - + # extract the .System key key_pt = aes_key_unwrap_with_padding(bytes(user_key), bytes(wrapped_key_pt)) key_data = aes_key_unwrap_with_padding(bytes(user_key), bytes(wrapped_key_data)) - print("key_pt {}".format(key_pt)) - print("key_data {}".format(key_data)) + logging.debug("key_pt {}".format(key_pt)) + logging.debug("key_data {}".format(key_data)) + keys = {} + keys['.System'] = [key_pt, key_data] + + + for name, pw in basis_credentials.items(): + bname_copy = [0]*64 + plaintext_pw = [0]*73 + i = 0 + for c in list(name.encode('utf-8')): + bname_copy[i] = c + i += 1 + pw_len = 0 + for c in list(pw.encode('utf-8')): + plaintext_pw[pw_len] = c + pw_len += 1 + pw_len += 1 # null terminate + # print(bname_copy) + # print(plaintext_pw) + hasher = SHA512.new(truncate="256") + hasher.update(pddb_salt[32:]) + hasher.update(bytes(bname_copy)) + hasher.update(bytes(plaintext_pw)) + derived_salt = hasher.digest() + + bcrypter = bcrypt.BCrypt() + hashed_pw = bcrypter.crypt_raw(plaintext_pw[:pw_len], derived_salt[:16], 7) + hkdf = HKDF(algorithm=hashes.SHA256(), length=32, salt=pddb_salt[:32], info=b"pddb page table key") + pt_key = hkdf.derive(hashed_pw) + hkdf = HKDF(algorithm=hashes.SHA256(), length=32, salt=pddb_salt[:32], info=b"pddb data key") + data_key = hkdf.derive(hashed_pw) + keys[name] = [pt_key, data_key] + + # data_aad = SYSTEM_BASIS + PDDB_VERSION + dna + + # now that we have the credentials, extract the baseline image + pddb_len = len(pddb) + pddb_size_pages = pddb_len // PAGE_SIZE + logging.info("Database size: 0x{:x}".format(pddb_len)) + + mbbb_offset = pddb_size_pages * Pte.PTE_LEN + PAGE_SIZE * KEY_PAGES + if mbbb_offset & (PAGE_SIZE - 1) != 0: + mbbb_offset = (mbbb_offset + PAGE_SIZE) & 0xFFFF_F000 # round up to nearest page + logging.info("MBBB: 0x{:x}".format(mbbb_offset)) + + img_index = 0 + tables = decode_pagetable(pddb, pddb_size_pages, keys, pddb[mbbb_offset:mbbb_offset + MBBB_PAGES * PAGE_SIZE]) + img_index += pddb_size_pages * Pte.PTE_LEN + if img_index & (PAGE_SIZE - 1) != 0: + img_index = (img_index + PAGE_SIZE) & 0xFFFF_F000 + + rawkeys = pddb[img_index : img_index + PAGE_SIZE * KEY_PAGES] + logging.debug("Keys: 0x{:x}".format(img_index)) + img_index += PAGE_SIZE * KEY_PAGES + + mbbb = pddb[img_index : img_index + PAGE_SIZE * MBBB_PAGES] + logging.debug("MBBB check: 0x{:x}".format(img_index)) + img_index += PAGE_SIZE * MBBB_PAGES + + fscb = decode_fscb(pddb[img_index: img_index + PAGE_SIZE * FSCB_PAGES], keys, FSCB_LEN_PAGES=FSCB_LEN_PAGES, dna=dna_int) + logging.debug("FSCB: 0x{:x}".format(img_index)) + img_index += PAGE_SIZE * FSCB_PAGES + + logging.debug("Data: 0x{:x}".format(img_index)) + data = pddb[img_index:] + + for name, key in keys.items(): + if name in tables: + logging.info("Basis '{}', key_pt: {}, key_data: {}".format(name, key[0].hex(), key[1].hex())) + v2p_table = tables[name][0] + p2v_table = tables[name][1] + # v2p_table[0xfe0fe0] = 0x1200* 0x100 + + basis_data = bytearray() + pp_start = v2p_table[VPAGE_SIZE] + # print("pp_start: {:x}".format(pp_start)) + pp_data = data[pp_start:pp_start + PAGE_SIZE] + try: + pt_data = keycommit_decrypt(key[1], basis_aad(name, dna=dna_int), pp_data) + basis_data.extend(bytearray(pt_data)) + logging.debug("decrypted vpage @ {:x} ppage @ {:x}".format(VPAGE_SIZE, v2p_table[VPAGE_SIZE])) + # print([hex(x) for x in basis_data[:256]]) + basis = Basis(basis_data) + logging.info(basis.as_str()) + + basis_dicts = {} + dicts_found = 0 + dict_index = 0 + while dict_index < MAX_DICTS and dicts_found < basis.num_dicts: + bdict = BasisDicts(dict_index, v2p_table, data, key[1], name, dna=dna_int) + if bdict.valid: + basis_dicts[bdict.name] = bdict + dicts_found += 1 + dict_index += 1 + if dicts_found != basis.num_dicts: + logging.error("Expected {} dictionaries, only found {}; searched {}".format(basis.num_dicts, dicts_found, dict_index)) + + logging.info(" Dictionaries: ") + for bdict in basis_dicts.values(): + logging.info(bdict.as_str()) + + for bdict in basis_dicts.values(): + logging.info("==================================================================") + logging.info("Dict {}".format(bdict.as_str())) + + except ValueError: + logging.error("couldn't decrypt basis root vpage @ {:x} ppage @ {:x}".format(VPAGE_SIZE, v2p_table[VPAGE_SIZE])) + + + - data_aad = SYSTEM_BASIS + PDDB_VERSION + dna # INFO:root_keys::implementation: pw: a, salt: [187, 174, 50, 20, 242, 60, 232, 34, 102, 172, 228, 51, 131, 21, 250, 2] (services\root-keys\src\implementation.rs:698) # INFO:root_keys::implementation: hashed_pw: [115, 198, 244, 53, 109, 213, 137, 82, 182, 170, 10, 46, 17, 117, 175, 42, 179, 60, 9, 238, 104, 66, 199, 143] (services\root-keys\src\implementation.rs:700)