#!/usr/bin/python3 # -*- coding: utf-8 -*- # (c) B.Kerler 2018-2025 GPLv3 License import logging import os from struct import pack, unpack from mtkclient.Library.gui_utils import LogBase, logsetup from mtkclient.Library.cryptutils import CryptUtils CustomSeed = bytes.fromhex("00be13bb95e218b53d07a089cb935255294f70d4088f3930350bc636cc49c9025ece7a62c292853ef55b23a6e" + "f7b7464c7f3f2a74ae919416d6b4d9c1d6809655dd82d43d65999cf041a386e1c0f1e58849d8ed09ef07e6a9f" + "0d7d3b8dad6cbae4668a2fd53776c3d26f88b0bf617c8112b8b1a871d322d9513491e07396e1638090055f4b8" + "b9aa2f4ec24ebaeb917e81f468783ea771b278614cd5779a3ca50df5cc5af0edc332e2b69b2b42154bcfffd0a" + "f13ce5a467abb7fb107fe794f928da44b6db7215aa53bd0398e3403126fad1f7de2a56edfe474c5a06f8dd9bc" + "0b3422c45a9a132e64e48fcacf63f787560c4c89701d7c125118c20a5ee820c3a16") g_aes_swotp = [0x7D4F7A57, 0x6025FC1D, 0xE2A78AFC, 0x98347309, 0xDDBC43BD, 0x2425A444, 0xEF7F1ACB, 0x70131C4F] g_UnqKey_Fixed_Pattern = [0x13EE5220, 0xA506CEDB, 0x51CCE623, 0xF7AB9BDF, 0xEEF8D525, 0xD80784B0, 0x78C4E975, 0xCB8B87BF, 0xB3FDF30F, 0x7CDBE782, 0xBF72F9A, 0xA0B20DCE, 0x3A3E3A21, 0x2ABA4790, 0x1F6EA02D, 0xCE26F757, 0x1098DD15, 0xD4109E9B, 0x8A5FE074, 0xD27BD9DF, 0xA586450C, 0x8A026299, 0x390ADFA1, 0x940F7F3D, 0x93E6269, 0x38C2A28D, 0x10C2414D, 0xFECC8536, 0x394DBD6, 0x20E6A02, 0x82C5F911, 0x6793A052, 0x9FB5E17B, 0x816A8DDB, 0x999F7D67, 0xFC96CC27, 0xFC96CC27, 0x8CC0FB7D, 0x9969AC67, 0x26CA6E33] g_UnqKey_IV = [0x6786CFBD, 0x44B7F1E0, 0x1544B07B, 0x53A28EB3, 0xD7AB8AA2, 0xB9E30E7E, 0x172156E0, 0x3064C973] # SEJ = Security Engine for JTAG protection def bytes_to_dwords(buf): res = [] for i in range(0, len(buf) // 4): res.append(unpack(">= 16 result = 17 if not v1 & 0xFF: v1 >>= 8 result += 8 if not ((v1 << 28) & 0xFFFFFFFF): v1 >>= 4 result += 4 if not ((v1 << 30) & 0xFFFFFFFF): v1 >>= 2 result += 2 if not v1 & 1: result += 1 return result def tz_dapc_set_master_transaction(self, master_index, permission_control): t = 1 << master_index v = self.read32(0x10007500) & ~t if t: t = self.uffs(t) val = v | permission_control << (t - 1) self.write32(0x10007500, val) return t def crypto_secure(self, val): if val: self.write32(0x10216024, 0x20002) else: self.write32(0x10216024, 0x0) def device_apc_dom_setup(self): self.write32(0x10007F00, 0) tv = self.read32(0x10007400) & 0xFFFFFFFF self.write32(0x10007400, tv | (1 << (self.uffs(0xF0000000) - 1))) # tv_0 = self.read32(0x10007400) & 0xF0FFFFFF self.write32(0x10007400, tv | (2 << (self.uffs(0xF0000000) - 1))) def sej_set_mode(self, mode): self.reg.HACC_ACON = self.reg.HACC_ACON & ((~2) & 0xFFFFFFFF) if mode == 1: # CBC self.reg.HACC_ACON |= 2 def get_world_clock_value(self): return self.read32(0x10017008) def check_timeout(self, clockvalue, timeout=200): tmp = -clockvalue curtime = self.read32(0x10017008) if curtime < clockvalue: tmp = ~clockvalue return tmp + self.read32(0x10017008) >= timeout * 1000 * 13 def sej_samsung_keygen(self, level): for i in range(0, 0xA0 // 4, 0x10 // 4): g_UnqKey_Fixed_Pattern[i] = (g_UnqKey_Fixed_Pattern[i] & 0xFFFFFF00) | level buf = b"".join(int.to_bytes(x, 4, 'little') for x in g_UnqKey_Fixed_Pattern) self.sej_samsung_special(aes256=True) seed = b"".join(int.to_bytes(x, 4, 'little') for x in g_UnqKey_IV) aes_gcm_key = self.sst_secure_algo_with_level(encrypt=True, buf=buf, m_sst_type=0x65, unlock=False, legacyxor=True, seed=seed) return aes_gcm_key def sej_samsung_special(self, aes256: bool = True): x = 1 self.reg.HACC_AKEY0 = 0 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 self.sej_set_otp(g_aes_swotp) self.reg.HACC_ACON = x self.reg.HACC_ACONK = 0 self.reg.HACC_SECINIT0 = x self.reg.HACC_AKEY0 = 0 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 if aes256: self.reg.HACC_ACON = 0x23 else: self.reg.HACC_ACON = 3 self.reg.HACC_SECINIT0 |= 2 self.reg.HACC_ACON2 = 0x40000002 while self.toSigned32(self.reg.HACC_ACON2) >= 0: continue self.reg.HACC_ACON2 = 2 self.reg.HACC_ACON = x self.reg.HACC_ACONK = 0 self.reg.HACC_SECINIT0 = x self.sej_set_otp(g_aes_swotp) return def SST_SEJ_Derive_AES_128_Key(self, pattern): self.reg.HACC_AKEY0 = 0 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 self.reg.HACC_SECINIT0 = 1 self.reg.HACC_ACON = 3 self.reg.HACC_ACONK = 0x110 self.reg.HACC_ACON2 = 2 self.reg.HACC_ACFG0 = g_UnqKey_IV[0] self.reg.HACC_ACFG1 = g_UnqKey_IV[1] self.reg.HACC_ACFG2 = g_UnqKey_IV[2] self.reg.HACC_ACFG3 = g_UnqKey_IV[3] self.reg.HACC_AOUT0 = g_UnqKey_IV[4] self.reg.HACC_AOUT1 = g_UnqKey_IV[5] self.reg.HACC_AOUT2 = g_UnqKey_IV[6] self.reg.HACC_AOUT3 = g_UnqKey_IV[7] key = self.HACC_V3_Run(pattern) self.reg.HACC_ACON2 = 2 self.reg.HACC_ACON = 0 self.reg.HACC_ACONK = 0 return key def toSigned32(self, n): n = n & 0xffffffff return n | (-(n & 0x80000000)) def SST_SEJ_Derive_AES_Key_KDF_Key(self, pattern, aes256): # SST_ChipRK_Init self.reg.HACC_AKEY0 = 0 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 self.sej_set_otp(g_aes_swotp) if not aes256: self.reg.HACC_ACON = self.HACC_AES_CHG_BO_OFF | self.HACC_AES_128 | self.HACC_AES_CBC | self.HACC_AES_ENC # 3 else: self.reg.HACC_ACON = self.HACC_AES_CHG_BO_OFF | self.HACC_AES_128 | self.HACC_AES_CBC | self.HACC_AES_ENC | 0x20 self.reg.HACC_SECINIT0 |= 2 self.reg.HACC_ACON2 |= (0x40000000 | self.HACC_AES_CLR) clockvalue = self.get_world_clock_value() while self.toSigned32(self.reg.HACC_ACON2) >= 0: if self.check_timeout(clockvalue=clockvalue, timeout=200): return 0x4005 self.reg.HACC_SECINIT0 &= 0xfffffffe self.reg.HACC_ACONK = self.HACC_AES_R2K | self.HACC_AES_BK2C # 0x110 self.reg.HACC_ACFG0 = g_UnqKey_IV[0] self.reg.HACC_ACFG1 = g_UnqKey_IV[1] self.reg.HACC_ACFG2 = g_UnqKey_IV[2] self.reg.HACC_ACFG3 = g_UnqKey_IV[3] self.reg.HACC_AOUT0 = g_UnqKey_IV[4] self.reg.HACC_AOUT1 = g_UnqKey_IV[5] self.reg.HACC_AOUT2 = g_UnqKey_IV[6] self.reg.HACC_AOUT3 = g_UnqKey_IV[7] self.HACC_V3_Run(pattern) self.sej_set_otp(g_aes_swotp) self.reg.HACC_ACON2 = 2 self.reg.HACC_ACON = 0 self.reg.HACC_ACONK = 0 def SST_SSF_Init(self, m_sst_type): if m_sst_type & 0x20 != 0: self.sej_set_otp(g_aes_swotp) key = self.SST_SEJ_Derive_AES_128_Key(g_UnqKey_Fixed_Pattern) self.SST_SEJ_Derive_AES_Key_KDF_Key(g_UnqKey_Fixed_Pattern, (m_sst_type & 0x40) != 0) return key return b"" def crypto_meta_hw(self, m_sst_type, otp, unlock, data, encrypt, samsung=False): if unlock: m_sst_type = 0x64 if samsung: self.sej_samsung_keygen(level=7) self.sej_samsung_special(aes256=True) else: self.sej_set_otp(otp) self.SST_SSF_Init(m_sst_type) self.sej_set_otp(otp) aes_top_legacy = (m_sst_type & 1) _ = aes_top_legacy if m_sst_type & 0x10 != 0: ret_dec = self.sst_secure_algo_with_level(data, encrypt=encrypt, legacyxor=True, m_sst_type=m_sst_type, unlock=unlock) else: ret_dec = self.sst_secure_algo_with_level(data, encrypt=encrypt, legacyxor=True, m_sst_type=m_sst_type, unlock=unlock) ret_enc = self.sst_secure_algo_with_level(ret_dec, encrypt=not encrypt, legacyxor=True, m_sst_type=m_sst_type, unlock=unlock) if ret_enc != data: return b"" return ret_dec def sej_set_key(self, key, flag, data=None): # 0 uses software key (sml_aes_key) # 1 uses Real HW Crypto Key # 2 uses 32 byte hw derived key from sw key # 3 uses 32 byte hw derived key from rid # 4 uses custom key (customer key ?) klen = 0x10 if flag == 0x18: klen = 0x10 elif flag == 0x20: klen = 0x20 self.write32(0x109E64, klen) self.reg.HACC_ACON = (self.reg.HACC_ACON & 0xFFFFFFCF) | klen self.reg.HACC_AKEY0 = 0 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 if key == 1: self.reg.HACC_ACONK |= 0x10 else: # Key has to be converted to be big endian keydata = [0, 0, 0, 0, 0, 0, 0, 0] for i in range(0, len(data), 4): keydata[i // 4] = unpack(">I", data[i:i + 4])[0] self.reg.HACC_AKEY0 = keydata[0] self.reg.HACC_AKEY1 = keydata[1] self.reg.HACC_AKEY2 = keydata[2] self.reg.HACC_AKEY3 = keydata[3] self.reg.HACC_AKEY4 = keydata[4] self.reg.HACC_AKEY5 = keydata[5] self.reg.HACC_AKEY6 = keydata[6] self.reg.HACC_AKEY7 = keydata[7] def tz_pre_init(self): # self.device_APC_dom_setup() # self.tz_dapc_set_master_transaction(4,1) # self.crypto_secure(1) return def HACC_V3_Run(self, data, noread: bool = False, legacy: bool = False, attr=0, sej_param=0): pdst = bytearray() if isinstance(data, list): psrc = data else: psrc = bytes_to_dwords(data) plen = len(psrc) if legacy: if (attr & 8) != 0 and (sej_param & 2) != 0: self.reg.HACC_ACONK |= self.HACC_AES_R2K else: self.reg.HACC_ACONK &= 0xFFFFFEFF pos = 0 for i in range(plen // 4): self.reg.HACC_ASRC0 = psrc[pos + 0] self.reg.HACC_ASRC1 = psrc[pos + 1] self.reg.HACC_ASRC2 = psrc[pos + 2] self.reg.HACC_ASRC3 = psrc[pos + 3] self.reg.HACC_ACON2 = self.HACC_AES_START i = 0 while i < 20: if self.reg.HACC_ACON2 & self.HACC_AES_RDY != 0: break i += 1 if i == 20: self.error("SEJ Hardware seems not to be configured correctly. Results may be wrong.") if not noread: pdst.extend(pack("I", key.key[i:i + 4])[0] if len(key.key) >= 8: self.reg.HACC_AKEY0 = keydata[0] self.reg.HACC_AKEY1 = keydata[1] if len(key.key) >= 16: self.reg.HACC_AKEY2 = keydata[2] self.reg.HACC_AKEY3 = keydata[3] if len(key.key) >= 24: self.reg.HACC_AKEY4 = keydata[4] self.reg.HACC_AKEY5 = keydata[5] if len(key.key) >= 32: self.reg.HACC_AKEY6 = keydata[6] self.reg.HACC_AKEY7 = keydata[7] if attr & 2 != 0: self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_ACFG0 = key.iv[0] # g_AC_CFG self.reg.HACC_ACFG1 = key.iv[1] self.reg.HACC_ACFG2 = key.iv[2] self.reg.HACC_ACFG3 = key.iv[3] """ def sej_aes_hw_internal_5g(self, data, encrypt, attr, sej_param, legacy=True): psrc = bytes_to_dwords(data) if encrypt: self.reg.HACC_ACON |= 1 pdst = self.HACC_V3_Run(psrc, legacy=legacy, attr=attr, sej_param=sej_param) if legacy: if (attr & 8) != 0 and (sej_param & 2) == 0: # Key_Feedback_XOR_Handler # keylen = 0x20 self.reg.HACC_AKEY0 = self.reg.HACC_AOUT0 ^ self.reg.HACC_AKEY0 self.reg.HACC_AKEY1 = self.reg.HACC_AOUT1 ^ self.reg.HACC_AKEY1 self.reg.HACC_AKEY2 = self.reg.HACC_AOUT2 ^ self.reg.HACC_AKEY2 self.reg.HACC_AKEY3 = self.reg.HACC_AOUT3 ^ self.reg.HACC_AKEY3 # Clear key self.reg.HACC_ACON2 = 2 return pdst def sej_aes_hw_internal_4g(self, data, encrypt): if encrypt: self.reg.HACC_ACON |= 1 psrc = bytes_to_dwords(data) pdst = self.HACC_V3_Run(psrc, legacy=False) return pdst def sst_init_5g(self, attr, iv, keylen=0x10, sejparam=5, key=None, m_sst_type=64): if key is None: key = [0, 0, 0, 0, 0, 0, 0, 0] self.reg.HACC_SECINIT0 = 1 if keylen == 0x10 or sejparam & 1 != 0 or attr & 1 != 0: acon_setting = self.HACC_AES_128 elif keylen == 0x18: acon_setting = self.HACC_AES_192 elif keylen == 0x20: acon_setting = self.HACC_AES_256 else: acon_setting = self.HACC_AES_128 if attr & 4 == 0: print("SEJ_3DES_HW_SetKey") if iv is not None: acon_setting |= self.HACC_AES_CBC # 0 self.reg.HACC_ACON = acon_setting if attr & 1 == 0: if attr & 2 != 0: self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_ACFG0 = iv[0] # g_AC_CFG self.reg.HACC_ACFG1 = iv[1] self.reg.HACC_ACFG2 = iv[2] self.reg.HACC_ACFG3 = iv[3] return acon_setting else: self.reg.HACC_AKEY0 = key[0] self.reg.HACC_AKEY1 = key[1] self.reg.HACC_AKEY2 = key[2] self.reg.HACC_AKEY3 = key[3] self.reg.HACC_AKEY4 = key[4] self.reg.HACC_AKEY5 = key[5] self.reg.HACC_AKEY6 = key[6] self.reg.HACC_AKEY7 = key[7] if sejparam & 1 == 0: if attr & 2 != 0: self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_ACFG0 = iv[0] # g_AC_CFG self.reg.HACC_ACFG1 = iv[1] self.reg.HACC_ACFG2 = iv[2] self.reg.HACC_ACFG3 = iv[3] return 0 elif m_sst_type & 8 == 0: if m_sst_type & 2 == 0: self.reg.HACC_ACONK = self.HACC_AES_BK2C if attr & 2 != 0: self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_ACFG0 = iv[0] # g_AC_CFG self.reg.HACC_ACFG1 = iv[1] self.reg.HACC_ACFG2 = iv[2] self.reg.HACC_ACFG3 = iv[3] return 0 if sejparam & 8 != 0: self.reg.HACC_UNK &= 0xFFFFFFFD else: self.reg.HACC_UNK |= 2 if sejparam & 4 == 0: self.reg.HACC_UNK |= 1 if m_sst_type & 2 == 0: self.reg.HACC_ACONK = self.HACC_AES_BK2C if attr & 2 != 0: self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_ACFG0 = iv[0] # g_AC_CFG self.reg.HACC_ACFG1 = iv[1] self.reg.HACC_ACFG2 = iv[2] self.reg.HACC_ACFG3 = iv[3] return 0 self.reg.HACC_ACON2 |= 0x40000000 current_clock = self.get_world_clock_value() while True: if self.reg.HACC_ACON2 < 0: self.reg.HACC_UNK &= 0xFFFFFFFE if self.check_timeout(current_clock, 200): return -1 return 0 def sst_init_4g(self, attr, iv, keylen=0x10, key=None, m_sst_type=64): if key is None: key = [0, 0, 0, 0, 0, 0, 0, 0] acon_setting = keylen & 0xF if iv is not None: acon_setting |= self.HACC_AES_CBC # 0 self.reg.HACC_AKEY0 = key[0] self.reg.HACC_AKEY1 = key[1] self.reg.HACC_AKEY2 = key[2] self.reg.HACC_AKEY3 = key[3] self.reg.HACC_AKEY4 = key[4] self.reg.HACC_AKEY5 = key[5] self.reg.HACC_AKEY6 = key[6] self.reg.HACC_AKEY7 = key[7] self.reg.HACC_ACON2 = self.HACC_AES_CLR if attr & 2 != 0: self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_ACFG0 = iv[0] # g_AC_CFG self.reg.HACC_ACFG1 = iv[1] self.reg.HACC_ACFG2 = iv[2] self.reg.HACC_ACFG3 = iv[3] if attr & 8: self.reg.HACC_SECINIT0 |= 2 self.reg.HACC_ACON2 |= 0x40000000 current_clock = self.get_world_clock_value() while self.toSigned32(self.reg.HACC_ACON2) >= 0: if self.check_timeout(current_clock, 200): return 0x4001 if m_sst_type & 2 == 0: self.reg.HACC_ACONK = 16 self.reg.HACC_ACON = acon_setting return 0 def sst_secure_algo_with_level(self, buf, encrypt=True, m_sst_type=0x64, unlock=False, legacyxor=True, seed=CustomSeed): if unlock: _iv = [self.g_HACC_CFG_1[0], self.g_HACC_CFG_1[1], self.g_HACC_CFG_1[2], self.g_HACC_CFG_1[3]] else: seed = (seed[2] << 16) | (seed[1] << 8) | seed[0] | (seed[3] << 24) _iv = [seed, (~seed) & 0xFFFFFFFF, (((seed >> 16) | (seed << 16)) & 0xFFFFFFFF), (~((seed >> 16) | (seed << 16)) & 0xFFFFFFFF)] key = SymKey() key.key = None key.key_len = 0x10 # meta_key_len = 0x10 key.mode = 1 # CBC if (m_sst_type & 1) != 0: sej_param = 3 else: sej_param = 5 if (m_sst_type & 0x10) != 0: sej_param = 7 _iv = [g_UnqKey_IV[0], g_UnqKey_IV[1], g_UnqKey_IV[2], g_UnqKey_IV[3]] key.key_len = 0x20 key.iv = _iv # Cipher Internal if sej_param & 0xC != 0: if sej_param & 4 != 0: # sej_param 5 attr = 0x3A else: attr = 0x32 metaflag = 0 else: # aes_top_legacy attr = 0x33 metaflag = 1 # CS_MTK_Cipher_Internal if metaflag: # length=0x10 _attr = 0x5B src = b"".join([int.to_bytes(val, 4, 'little') for val in self.g_CFG_RANDOM_PATTERN]) # self.sej_aes_hw_init(_attr, key, sej_param) if m_sst_type & 1 != 0: self.sst_init_5g(attr=_attr, iv=_iv, keylen=key.key_len, sejparam=sej_param, key=key.key, m_sst_type=m_sst_type) rnd = self.sej_aes_hw_internal_5g(src, encrypt=False, attr=_attr, sej_param=sej_param, legacy=legacyxor) _ = rnd else: self.sst_init_4g(attr=_attr, iv=_iv, keylen=key.key_len, key=key.key, m_sst_type=m_sst_type) rnd = self.sej_aes_hw_internal_4g(src, encrypt=False) _ = rnd attr = (attr & 0xFFFFFFFA) | 4 if m_sst_type & 1 != 0: self.sst_init_5g(attr=attr, iv=_iv, keylen=key.key_len, sejparam=sej_param, key=key.key, m_sst_type=m_sst_type) buf2 = self.sej_aes_hw_internal_5g(buf, encrypt=encrypt, attr=attr, sej_param=sej_param, legacy=legacyxor) else: self.sst_init_4g(attr=attr, iv=_iv, keylen=key.key_len, key=key.key, m_sst_type=m_sst_type) buf2 = self.sej_aes_hw_internal_4g(buf, encrypt=encrypt) self.reg.HACC_AKEY0 = 0 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 return buf2 def sej_terminate(self): self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_AKEY0 = 0 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 def SEJ_V3_Init(self, ben=True, iv=None, legacy=False): # 0x335 = MT6737M/MT6735G # 0x321 = MT6735/T,MT8735A # 0x337 = MT6753 if self.hwcode in [0x6795, 0x335, 0x321, 0x337]: legacy = False acon_setting = self.HACC_AES_CHG_BO_OFF | self.HACC_AES_128 if iv is not None: acon_setting |= self.HACC_AES_CBC if ben: acon_setting |= self.HACC_AES_ENC else: acon_setting |= self.HACC_AES_DEC # clear key self.reg.HACC_AKEY0 = 0 # 0x20 self.reg.HACC_AKEY1 = 0 self.reg.HACC_AKEY2 = 0 self.reg.HACC_AKEY3 = 0 self.reg.HACC_AKEY4 = 0 self.reg.HACC_AKEY5 = 0 self.reg.HACC_AKEY6 = 0 self.reg.HACC_AKEY7 = 0 # 0x3C # Generate META Key # 0x04 self.reg.HACC_ACON = self.HACC_AES_CHG_BO_OFF | self.HACC_AES_CBC | self.HACC_AES_128 | self.HACC_AES_DEC # init ACONK, bind HUID/HUK to HACC, this may differ # enable R2K, so that output data is feedback to key by HACC internal algorithm self.reg.HACC_ACONK = self.HACC_AES_BK2C self.reg.HACC_ACONK |= self.HACC_AES_R2K # 0x110 # clear HACC_ASRC/HACC_ACFG/HACC_AOUT self.reg.HACC_ACON2 = self.HACC_AES_CLR # 0x2 self.reg.HACC_ACFG0 = iv[0] # g_AC_CFG self.reg.HACC_ACFG1 = iv[1] self.reg.HACC_ACFG2 = iv[2] self.reg.HACC_ACFG3 = iv[3] if legacy: self.reg.HACC_UNK |= 2 # clear HACC_ASRC/HACC_ACFG/HACC_AOUT self.reg.HACC_ACON2 |= 0x40000000 i = 0 while i < 20: if self.reg.HACC_ACON2 > 0x80000000: break i += 1 if i == 20: self.error("SEJ Legacy Hardware seems not to be configured correctly. Results may be wrong.") self.reg.HACC_UNK &= 0xFFFFFFFE self.reg.HACC_ACONK = self.HACC_AES_BK2C self.reg.HACC_ACON = acon_setting else: # The reg below needed for mtee ? self.reg.HACC_UNK = 1 # encrypt fix pattern 3 rounds to generate a pattern from HUID/HUK for i in range(0, 3): pos = i * 4 self.reg.HACC_ASRC0 = self.g_CFG_RANDOM_PATTERN[pos] self.reg.HACC_ASRC1 = self.g_CFG_RANDOM_PATTERN[pos + 1] self.reg.HACC_ASRC2 = self.g_CFG_RANDOM_PATTERN[pos + 2] self.reg.HACC_ASRC3 = self.g_CFG_RANDOM_PATTERN[pos + 3] self.reg.HACC_ACON2 = self.HACC_AES_START # 0x1 i = 0 while i < 20: if self.reg.HACC_ACON2 & self.HACC_AES_RDY != 0: break i += 1 if i == 20: self.error("SEJ Hardware seems not to be configured correctly. Results may be wrong.") self.reg.HACC_ACON2 = self.HACC_AES_CLR self.reg.HACC_ACFG0 = iv[0] self.reg.HACC_ACFG1 = iv[1] self.reg.HACC_ACFG2 = iv[2] self.reg.HACC_ACFG3 = iv[3] self.reg.HACC_ACON = acon_setting self.reg.HACC_ACONK = 0 return acon_setting def hw_aes128_cbc_encrypt(self, buf, encrypt=True, iv=None, legacy=False): if iv is None: iv = self.g_HACC_CFG_1 self.tz_pre_init() self.info("AES128 CBC - HACC init") self.SEJ_V3_Init(ben=encrypt, iv=iv, legacy=legacy) self.info("AES128 CBC - HACC run") buf2 = self.HACC_V3_Run(buf) self.info("AES128 CBC - HACC terminate") self.sej_terminate() return buf2 def sej_set_otp(self, data): if isinstance(data, bytes) or isinstance(data, bytearray): pd = bytes_to_dwords(data) else: pd = data self.reg.HACC_SW_OTP0 = pd[0] self.reg.HACC_SW_OTP1 = pd[1] self.reg.HACC_SW_OTP2 = pd[2] self.reg.HACC_SW_OTP3 = pd[3] self.reg.HACC_SW_OTP4 = pd[4] self.reg.HACC_SW_OTP5 = pd[5] self.reg.HACC_SW_OTP6 = pd[6] self.reg.HACC_SW_OTP7 = pd[7] # self.reg.HACC_SECINIT0 = pd[8] # self.reg.HACC_SECINIT1 = pd[9] # self.reg.HACC_SECINIT2 = pd[0xA] # self.reg.HACC_MKJ = pd[0xB] def sej_do_aes(self, encrypt, iv=None, data=b"", length=16): self.reg.HACC_ACON2 |= self.HACC_AES_CLR if iv is not None: piv = bytes_to_dwords(iv) self.reg.HACC_ACFG0 = piv[0] self.reg.HACC_ACFG1 = piv[1] self.reg.HACC_ACFG2 = piv[2] self.reg.HACC_ACFG3 = piv[3] if encrypt: self.reg.HACC_ACON |= self.HACC_AES_ENC else: self.reg.HACC_ACON &= 0xFFFFFFFE pdst = bytearray() for pos in range(0, length, 16): psrc = bytes_to_dwords(data[(pos % len(data)):(pos % len(data)) + 16]) plen = len(psrc) pos = 0 for i in range(plen // 4): self.reg.HACC_ASRC0 = psrc[pos + 0] self.reg.HACC_ASRC1 = psrc[pos + 1] self.reg.HACC_ASRC2 = psrc[pos + 2] self.reg.HACC_ASRC3 = psrc[pos + 3] self.reg.HACC_ACON2 |= self.HACC_AES_START i = 0 while i < 20: if self.reg.HACC_ACON2 & self.HACC_AES_RDY != 0: break i += 1 if i == 20: self.error("SEJ Hardware seems not to be configured correctly. Results may be wrong.") pdst.extend(pack("> 16) | (seed << 16)) & 0xFFFFFFFF), (~((seed >> 16) | (seed << 16)) & 0xFFFFFFFF)] self.info("Meta - HACC init") if encrypt and not noxor: data = self.xor_data(bytearray(data)) self.info("Meta - HACC init") self.SEJ_V3_Init(ben=encrypt, iv=iv, legacy=legacy) self.info("Meta - HACC run") dec = self.HACC_V3_Run(data) self.info("Meta - HACC terminate") self.sej_terminate() if not encrypt and not noxor: dec = self.xor_data(dec) return dec if __name__ == "__main__": seed = (CustomSeed[2] << 16) | (CustomSeed[1] << 8) | CustomSeed[0] | (CustomSeed[3] << 24) iv = [seed, (~seed) & 0xFFFFFFFF, (((seed >> 16) | (seed << 16)) & 0xFFFFFFFF), (~((seed >> 16) | (seed << 16)) & 0xFFFFFFFF)] ivtest = [0, 0, 0, 0] ivtest[0] = 0xbb13be00 ivtest[1] = (~ivtest[0]) & 0xFFFFFFFF ivtest[2] = (ivtest[0] >> 0x10 | ivtest[0] << 0x10) & 0xFFFFFFFF ivtest[3] = (~ivtest[2]) & 0xFFFFFFFF print(b"".join(int.to_bytes(val, 4, 'little') for val in iv).hex())