NefMoto

text:10001CC5                 call    edi ; MString::operator char const *(void) ; MString::operator char const *(void)
.text:10001CC7                 push    ebx             ; dest_zip_filename
.text:10001CC8                 push    eax             ; frf_filename
.text:10001CC9                 lea     ecx, [ebp+var_170]
.text:10001CCF                 call    MY_getKey_and_goto_descramble
.text:10001CD4                 lea     ecx, [ebp+var_170]
.text:10001CDA                 mov     byte ptr [ebp+var_4], 2
.text:10001CDE                 call    MY_unzipper_stuff
.text:10001CE3                 test    al, al
.text:10001CE5                 jnz     short loc_10001CFC
.text:10001CE7                 lea     ecx, [ebp+var_28]
.text:10001CEA                 push    offset unk_100046E0
.text:10001CEF                 push    ecx
.text:10001CF0                 mov     [ebp+var_28], offset aNotOne_odxInAr ; "Not one .odx in archive"
.text:10001CF7                 call    _CxxThrowException

from array import array

img = array("B", img)

import struct
h = 'Hi'
s = struct.unpack('>H', h)[0]
print s

def decompress_raw_lzss10(indata, decompressed_size):
    """Decompress LZSS-compressed bytes. Returns a bytearray."""
    data = bytearray()

    it = iter(indata)

    def writebyte(b):
        data.append(b)
    def readbyte():
        return next(it)
    def readshort():
        # big-endian
        a = next(it)
        b = next(it)
        return (a << 8) | b
    def copybyte():
        data.append(next(it))

    while len(data) < decompressed_size:
        b = readbyte()
        flags = bits(b)
        for flag in flags:
            if flag == 0:
                copybyte()
            elif flag == 1:
                sh = readshort()
                count = (sh >> 10)
                disp = (sh & 0x3ff)
                for _ in range(count):
                    writebyte(data[-disp])
            else:
                raise ValueError(flag)

            if decompressed_size <= len(data):
                break
    return data

 //high nibble of data format
        public enum CompressionType : byte
        {
            Uncompressed = 0x00,
            Bosch = 0x10,
            Hitachi = 0x20,
            Marelli = 0x30,
            Lucas = 0x40,
            BoschUncompressed = 0x90 //for testing
        }

        //low nibble of data format
        public enum EncryptionType : byte
        {
            Unencrypted = 0x00,
            Bosch = 0x01,
            Hitachi = 0x02,
            Marelli = 0x03,
            Lucas = 0x04
        }

def deleterepeat(s):
	s = binascii.hexlify(s)
	i = (s+s).find(s, 1, -1)
	return binascii.unhexlify(s) if i == -1 else binascii.unhexlify(s[:i])

def stripBCBHead(imgxor):
	return imgxor[imgxor.index(b"\x1A\x01") + 2:]

def freqtable(data, klen):
	freqtable = {}
	for x in range (0, klen):
		curfreq = {}
		for y in range (0, 256):
			curfreq[y] = 0
		freqtable[x] = curfreq

	for nr in range(len(data)):
		freqtable[nr % klen][data[nr]] += 1
		
	return freqtable

def findXORkeyfreq(bcbdata, byte, confidence, maxlen):
	data = stripBCBHead(bcbdata)
	keyFound = False
	key = bytearray()
	debug = config.getint("main", "debug", fallback=0)

	for curlen in reversed(range(4, maxlen+1)):
		fqtable = freqtable(data, curlen)
		key = bytearray(curlen)
		
		avgconf1 = 0
		for fqpos in sorted(fqtable):
			sortedlist = sorted(fqtable[fqpos].items(), key=lambda x: x[1], reverse=True)
			avgconf1 += 100 - sortedlist[1][1]/sortedlist[0][1]*100
			key[fqpos] = sortedlist[0][0] ^ byte
		
		avgconf1 = avgconf1/curlen
		
		if (avgconf1 >= confidence):
			key = deleterepeat(key)
			return key
	return b""