257 lines
7.6 KiB
Python
257 lines
7.6 KiB
Python
from Crypto.Cipher import AES
|
|
|
|
|
|
class MapleAes:
|
|
_user_key = bytearray([
|
|
0x13, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
|
|
0xB4, 0x00, 0x00, 0x00, 0x1B, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00,
|
|
0x33, 0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x00
|
|
])
|
|
|
|
@classmethod
|
|
def transform(cls, buff, iv):
|
|
remaining = len(buff)
|
|
length = 0x5B0
|
|
start = 0
|
|
|
|
real_iv = bytearray(16)
|
|
|
|
iv_bytes = [
|
|
iv.value & 0xFF,
|
|
iv.value >> 8 & 0xFF,
|
|
iv.value >> 16 & 0xFF,
|
|
iv.value >> 24 & 0xFF,
|
|
]
|
|
|
|
while remaining > 0:
|
|
for index in range(len(real_iv)):
|
|
real_iv[index] = iv_bytes[index % 4] # type: ignore
|
|
|
|
if remaining < length:
|
|
length = remaining
|
|
|
|
index = start
|
|
|
|
while index < start + length:
|
|
sub = index - start
|
|
|
|
if (sub % 16) == 0:
|
|
real_iv = bytearray(AES.new(cls._user_key,
|
|
AES.MODE_ECB).encrypt(real_iv))
|
|
|
|
buff[index] ^= real_iv[sub % 16]
|
|
index += 1
|
|
|
|
start += length
|
|
remaining -= length
|
|
length = 0x5B4
|
|
|
|
iv.shuffle()
|
|
|
|
return buff
|
|
|
|
@staticmethod
|
|
def get_header(iv, length, major_ver):
|
|
first = iv.hiword ^ major_ver
|
|
second = first ^ length
|
|
return bytearray([
|
|
first & 0xFF, first >> 8 & 0xFF, second & 0xFF, second >> 8 & 0xFF
|
|
])
|
|
|
|
@staticmethod
|
|
def get_length(data):
|
|
return ((data[1] << 8) + data[0]) ^ ((data[3] << 8) + data[2])
|
|
|
|
@staticmethod
|
|
def encode_length(data):
|
|
return ((data[1] << 8) + data[0]) | ((data[3] << 8) + data[2])
|
|
|
|
|
|
class MapleIV:
|
|
_shuffle = bytearray([
|
|
0xEC, 0x3F, 0x77, 0xA4, 0x45, 0xD0, 0x71, 0xBF, 0xB7, 0x98, 0x20, 0xFC,
|
|
0x4B, 0xE9, 0xB3, 0xE1, 0x5C, 0x22, 0xF7, 0x0C, 0x44, 0x1B, 0x81, 0xBD,
|
|
0x63, 0x8D, 0xD4, 0xC3, 0xF2, 0x10, 0x19, 0xE0, 0xFB, 0xA1, 0x6E, 0x66,
|
|
0xEA, 0xAE, 0xD6, 0xCE, 0x06, 0x18, 0x4E, 0xEB, 0x78, 0x95, 0xDB, 0xBA,
|
|
0xB6, 0x42, 0x7A, 0x2A, 0x83, 0x0B, 0x54, 0x67, 0x6D, 0xE8, 0x65, 0xE7,
|
|
0x2F, 0x07, 0xF3, 0xAA, 0x27, 0x7B, 0x85, 0xB0, 0x26, 0xFD, 0x8B, 0xA9,
|
|
0xFA, 0xBE, 0xA8, 0xD7, 0xCB, 0xCC, 0x92, 0xDA, 0xF9, 0x93, 0x60, 0x2D,
|
|
0xDD, 0xD2, 0xA2, 0x9B, 0x39, 0x5F, 0x82, 0x21, 0x4C, 0x69, 0xF8, 0x31,
|
|
0x87, 0xEE, 0x8E, 0xAD, 0x8C, 0x6A, 0xBC, 0xB5, 0x6B, 0x59, 0x13, 0xF1,
|
|
0x04, 0x00, 0xF6, 0x5A, 0x35, 0x79, 0x48, 0x8F, 0x15, 0xCD, 0x97, 0x57,
|
|
0x12, 0x3E, 0x37, 0xFF, 0x9D, 0x4F, 0x51, 0xF5, 0xA3, 0x70, 0xBB, 0x14,
|
|
0x75, 0xC2, 0xB8, 0x72, 0xC0, 0xED, 0x7D, 0x68, 0xC9, 0x2E, 0x0D, 0x62,
|
|
0x46, 0x17, 0x11, 0x4D, 0x6C, 0xC4, 0x7E, 0x53, 0xC1, 0x25, 0xC7, 0x9A,
|
|
0x1C, 0x88, 0x58, 0x2C, 0x89, 0xDC, 0x02, 0x64, 0x40, 0x01, 0x5D, 0x38,
|
|
0xA5, 0xE2, 0xAF, 0x55, 0xD5, 0xEF, 0x1A, 0x7C, 0xA7, 0x5B, 0xA6, 0x6F,
|
|
0x86, 0x9F, 0x73, 0xE6, 0x0A, 0xDE, 0x2B, 0x99, 0x4A, 0x47, 0x9C, 0xDF,
|
|
0x09, 0x76, 0x9E, 0x30, 0x0E, 0xE4, 0xB2, 0x94, 0xA0, 0x3B, 0x34, 0x1D,
|
|
0x28, 0x0F, 0x36, 0xE3, 0x23, 0xB4, 0x03, 0xD8, 0x90, 0xC8, 0x3C, 0xFE,
|
|
0x5E, 0x32, 0x24, 0x50, 0x1F, 0x3A, 0x43, 0x8A, 0x96, 0x41, 0x74, 0xAC,
|
|
0x52, 0x33, 0xF0, 0xD9, 0x29, 0x80, 0xB1, 0x16, 0xD3, 0xAB, 0x91, 0xB9,
|
|
0x84, 0x7F, 0x61, 0x1E, 0xCF, 0xC5, 0xD1, 0x56, 0x3D, 0xCA, 0xF4, 0x05,
|
|
0xC6, 0xE5, 0x08, 0x49
|
|
])
|
|
|
|
def __init__(self, seed: int = 0):
|
|
self.value = seed
|
|
|
|
def __int__(self):
|
|
return self.value
|
|
|
|
def __str__(self):
|
|
return str(self.value)
|
|
|
|
def __bool__(self):
|
|
return self.value != 0
|
|
|
|
def __call__(self, seed: int):
|
|
self.value = seed
|
|
|
|
def reset(self):
|
|
self.value = 0
|
|
|
|
@property
|
|
def hiword(self):
|
|
return self.value >> 16
|
|
|
|
@property
|
|
def loword(self):
|
|
return self.value
|
|
|
|
def get_header(self, version, length):
|
|
first = self.hiword ^ version
|
|
second = first ^ length
|
|
return bytearray([
|
|
first & 0xFF, first >> 8 & 0xFF, second & 0xFF, second >> 8 & 0xFF
|
|
])
|
|
|
|
def shuffle(self):
|
|
seed = [0xF2, 0x53, 0x50, 0xC6]
|
|
p_iv = self.value
|
|
|
|
for i in range(4):
|
|
temp_p_iv = (p_iv >> (8 * i)) & 0xFF
|
|
|
|
a = seed[1]
|
|
b = a
|
|
b = self._shuffle[b & 0xFF]
|
|
b -= temp_p_iv
|
|
seed[0] += b
|
|
b = seed[2]
|
|
b ^= self._shuffle[int(temp_p_iv) & 0xFF]
|
|
a -= int(b) & 0xFF
|
|
seed[1] = a
|
|
a = seed[3]
|
|
b = a
|
|
a -= seed[0] & 0xFF
|
|
b = self._shuffle[b & 0xFF]
|
|
b += temp_p_iv
|
|
b ^= seed[2]
|
|
seed[2] = b & 0xFF
|
|
a += self._shuffle[temp_p_iv & 0xFF] & 0xFF
|
|
seed[3] = a
|
|
|
|
c = seed[0] & 0xFF
|
|
c |= (seed[1] << 8) & 0xFFFF
|
|
c |= (seed[2] << 16) & 0xFFFFFF
|
|
c |= (seed[3] << 24) & 0xFFFFFFFF
|
|
|
|
c = (c << 0x03) | (c >> 0x1D)
|
|
|
|
seed[0] = c & 0xFF
|
|
seed[1] = (c >> 8) & 0xFFFF
|
|
seed[2] = (c >> 16) & 0xFFFFFF
|
|
seed[3] = (c >> 24) & 0xFFFFFFFF
|
|
|
|
c = seed[0] & 0xFF
|
|
c |= (seed[1] << 8) & 0xFFFF
|
|
c |= (seed[2] << 16) & 0xFFFFFF
|
|
c |= (seed[3] << 24) & 0xFFFFFFFF
|
|
|
|
self.value = c
|
|
|
|
|
|
def decrypt_transform(data):
|
|
for j in range(1, 7):
|
|
remember = 0
|
|
data_length = len(data) & 0xFF
|
|
next_remember = 0
|
|
if j % 2 == 0:
|
|
for i in range(len(data)):
|
|
cur = data[i]
|
|
cur = (cur - 0x48) & 0xFF
|
|
cur = ~cur & 0xFF
|
|
cur = roll_left(cur, data_length & 0xFF)
|
|
next_remember = cur
|
|
cur ^= remember
|
|
remember = next_remember
|
|
cur = (cur - data_length) & 0xFF
|
|
cur = roll_right(cur, 3)
|
|
data[i] = cur
|
|
data_length -= 1
|
|
else:
|
|
for i in reversed(range(len(data))):
|
|
cur = data[i]
|
|
cur = roll_left(cur, 3)
|
|
cur ^= 0x13
|
|
next_remember = cur
|
|
cur ^= remember
|
|
remember = next_remember
|
|
cur = (cur - data_length) & 0xFF
|
|
cur = roll_right(cur, 4) & 0xFF
|
|
data[i] = cur
|
|
data_length -= 1
|
|
|
|
return data
|
|
|
|
|
|
def encrypt_transform(data):
|
|
b = {str(i): 0 for i in range(len(data))}
|
|
cur = 0
|
|
|
|
for _ in range(3):
|
|
length = len(data) & 0xFF
|
|
xor_key = 0
|
|
i = 0
|
|
while i < len(data):
|
|
|
|
cur = roll_left(data[i], 3)
|
|
cur = cur + length
|
|
cur = (cur ^ xor_key) & 0xFF
|
|
xor_key = cur
|
|
cur = ~roll_right(cur, length & 0xFF) & 0xFF
|
|
cur = (cur + 0x48) & 0xFF
|
|
data[i] = cur
|
|
b[str(i)] = cur
|
|
length -= 1
|
|
i += 1
|
|
|
|
xor_key = 0
|
|
length = len(data) & 0xFF
|
|
i = len(data) - 1
|
|
|
|
while i >= 0:
|
|
cur = roll_left(data[i], 4)
|
|
cur += length
|
|
cur = (cur ^ xor_key) & 0xFF
|
|
xor_key = cur
|
|
cur ^= 0x13
|
|
cur = roll_right(cur, 3)
|
|
data[i] = cur
|
|
b[str(i)] = cur
|
|
length -= 1
|
|
i -= 1
|
|
|
|
return bytearray([byte for byte in b.values()])
|
|
|
|
|
|
def roll_left(value, shift):
|
|
num = value << (shift % 8)
|
|
return (num & 0xFF) | (num >> 8)
|
|
|
|
|
|
def roll_right(value, shift):
|
|
num = (value << 8) >> (shift % 8)
|
|
return (num & 0xFF) | (num >> 8)
|