222 lines
6.4 KiB
Python
222 lines
6.4 KiB
Python
import io
|
|
import os
|
|
import traceback
|
|
|
|
from functools import partial
|
|
from glob import glob
|
|
from multiprocessing.pool import Pool
|
|
|
|
from . import crypt
|
|
from . import translate
|
|
|
|
|
|
def crypt_dir(dir_in, key, encrypt=False, no_compress=False):
|
|
if not encrypt:
|
|
files = glob(os.path.join(dir_in, "**/*.utage"), recursive=True)
|
|
else:
|
|
files = glob(os.path.join(dir_in, "**/*.tsv"), recursive=True)
|
|
|
|
if len(files) == 0:
|
|
raise FileNotFoundError("No valid files found in directory: " + dir_in)
|
|
|
|
pcrypt = partial(crypt_file, key=key, encrypt=encrypt, no_compress=no_compress)
|
|
with Pool() as p:
|
|
p.map(pcrypt, files)
|
|
|
|
|
|
def crypt_file(file_in, key, encrypt=False, no_compress=False):
|
|
with open(file_in, "rb") as inf:
|
|
in_data = inf.read()
|
|
try:
|
|
if encrypt:
|
|
if (
|
|
not file_in.endswith(".png")
|
|
and not file_in.endswith(".jpg")
|
|
and not file_in.endswith(".tsv")
|
|
):
|
|
raise ValueError("Invalid File Type for {}".format(file_in))
|
|
if not file_in.endswith(".png") and not no_compress:
|
|
enc_data = crypt.compress(in_data)
|
|
enc_data = crypt.xor_crypt(enc_data, key)
|
|
with io.open(file_in + ".utage", "wb") as output:
|
|
output.write(enc_data)
|
|
else:
|
|
if not file_in.endswith(".utage"):
|
|
raise ValueError("Invalid File Type for {}".format(file_in))
|
|
dec_data = crypt.xor_crypt(in_data, key)
|
|
if (
|
|
not file_in.endswith(".png.utage")
|
|
and not file_in.endswith(".jpg.utage")
|
|
and not no_compress
|
|
):
|
|
dec_data = crypt.decompress(dec_data)
|
|
with io.open(file_in.replace(".utage", ""), "wb") as output:
|
|
output.write(dec_data)
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
print("Error processing file: " + file_in)
|
|
|
|
|
|
def decompress(data):
|
|
osize = 0
|
|
isize = len(data)
|
|
osize_expected = int.from_bytes(data[:4], byteorder="little", signed=False)
|
|
odata = bytearray(osize_expected)
|
|
odata[:isize] = data
|
|
i = 4
|
|
while i < isize:
|
|
if (data[i] & 128) != 0:
|
|
num3 = data[i] & 15
|
|
num3 += 3
|
|
num4 = (data[i] & 112) << 4 | data[i + 1]
|
|
num4 += 1
|
|
for j in range(0, num3):
|
|
odata[osize + j] = odata[osize - num4 + j]
|
|
i += 1
|
|
else:
|
|
num3 = data[i] + 1
|
|
for j in range(0, num3):
|
|
odata[osize + j] = data[i + 1 + j]
|
|
i += num3
|
|
osize += num3
|
|
i += 1
|
|
return odata
|
|
|
|
|
|
def compress(data):
|
|
num = len(data)
|
|
bytes2 = num.to_bytes(4, byteorder="little")
|
|
anum3 = num + num / 128 + 1
|
|
array = bytearray(int(anum3))
|
|
num2 = 0
|
|
num3 = 0
|
|
num4 = 0
|
|
index = Index()
|
|
while num3 < num:
|
|
num5 = 0
|
|
num6 = 0
|
|
num7 = min(18, num - num3)
|
|
num8 = index.getFirst(data[num3])
|
|
while not index.isEnd(num8):
|
|
node = index.getNode(num8)
|
|
mPos = node.mPos
|
|
i = 1
|
|
while i < num7:
|
|
if data[mPos + i] != data[num3 + i]:
|
|
break
|
|
i = i + 1
|
|
if num5 < i:
|
|
num6 = mPos
|
|
num5 = i
|
|
if num5 == num7:
|
|
break
|
|
num8 = node.mNext
|
|
if num5 >= 3:
|
|
for j in range(num5):
|
|
num9 = num3 + j - 2048
|
|
if num9 >= 0:
|
|
index.remove(data[num9], num9)
|
|
index.add(data[num3 + j], num3 + j)
|
|
if num4 < num3:
|
|
array[num2] = num3 - num4 - 1
|
|
num2 = num2 + 1
|
|
for j in range(num4, num3):
|
|
array[num2] = data[j]
|
|
num2 = num2 + 1
|
|
num10 = num5 - 3
|
|
num11 = num3 - num6 - 1
|
|
num12 = 0x80 | num10
|
|
num12 |= (num11 & 0x700) >> 4
|
|
array[num2] = num12
|
|
array[num2 + 1] = num11 & 0xFF
|
|
num2 = num2 + 2
|
|
num3 = num3 + num5
|
|
num4 = num3
|
|
else:
|
|
num9 = num3 - 2048
|
|
if num9 >= 0:
|
|
index.remove(data[num9], num9)
|
|
index.add(data[num3], num3)
|
|
num3 = num3 + 1
|
|
if num3 - num4 == 128:
|
|
array[num2] = num3 - num4 - 1
|
|
num2 = num2 + 1
|
|
for j in range(num4, num3):
|
|
array[num2] = data[j]
|
|
num2 = num2 + 1
|
|
num4 = num3
|
|
if num4 < num3:
|
|
array[num2] = num3 - num4 - 1
|
|
num2 = num2 + 1
|
|
for j in range(num4, num3):
|
|
array[num2] = data[j]
|
|
num2 = num2 + 1
|
|
osize = num2
|
|
array2 = bytearray(osize + 4)
|
|
array2[:4] = bytes2[:4]
|
|
array2[4:] = array[:osize]
|
|
return array2
|
|
|
|
|
|
class Node:
|
|
mNext = 0
|
|
mPrev = 0
|
|
mPos = 0
|
|
|
|
|
|
class Index:
|
|
mNodes = []
|
|
mStack = []
|
|
mStackPos = 0
|
|
|
|
def __init__(self):
|
|
for i in range(2304):
|
|
x = Node()
|
|
self.mNodes.append(x)
|
|
for i in range(2048, 2304):
|
|
self.mNodes[i].mNext = i
|
|
self.mNodes[i].mPrev = i
|
|
for i in range(2048):
|
|
self.mStack.append(i)
|
|
self.mStackPos = 2048
|
|
|
|
def getFirst(self, c):
|
|
return self.mNodes[2048 + c].mNext
|
|
|
|
def getNode(self, i):
|
|
return self.mNodes[i]
|
|
|
|
def add(self, c, pos):
|
|
self.mStackPos = self.mStackPos - 1
|
|
num = self.mStack[self.mStackPos]
|
|
node = self.mNodes[num]
|
|
node2 = self.mNodes[2048 + c]
|
|
node.mNext = node2.mNext
|
|
node.mPrev = 2048 + c
|
|
node.mPos = pos
|
|
self.mNodes[node2.mNext].mPrev = num
|
|
node2.mNext = num
|
|
|
|
def remove(self, c, pos):
|
|
mPrev = self.mNodes[2048 + c].mPrev
|
|
node = self.mNodes[mPrev]
|
|
self.mStack[self.mStackPos] = self.mNodes[node.mPrev].mNext
|
|
self.mStackPos = self.mStackPos + 1
|
|
self.mNodes[node.mPrev].mNext = node.mNext
|
|
self.mNodes[node.mNext].mPrev = node.mPrev
|
|
|
|
def isEnd(self, idx):
|
|
return idx >= 2048
|
|
|
|
|
|
def xor_crypt(data, key):
|
|
odata = bytearray(len(data))
|
|
odata[:] = data
|
|
i = 0
|
|
for x in data:
|
|
if x != 0:
|
|
m = key[i % len(key)]
|
|
if x != m:
|
|
odata[i] = x ^ m
|
|
i += 1
|
|
return odata
|