#include <windows.h>
#include <stdio.h>
#include "TestDLL.h"
BOOL Decompress(char *src, char *dst)
{
//Use calloc vs malloc. Temp buffer is for the dictionary
void *pTmpbuff;
pTmpbuff = (int*) calloc(0x4080u, sizeof(unsigned int));
if (src && dst)
{
__asm
{
xor ebx, ebx; //Need to clear ebx register
SUB ESP, 0x40; //Need to subtract stack, so we don’t overwrite some Ctypes return data
MOV ESI, ESP;
PUSH EAX;
POP EDI; //Our Temp Buffer
PUSH[EBP + 8]; //Source Buffer
POP EAX;
PUSH[EBP + 0xC]; //Destination Buffer
POP EDX;
LEA ECX, DWORD PTR DS : [EAX + 1]; //Where we start. Get the 1st DWORD of the compressed data appears to be magic value
MOV DWORD PTR DS : [ESI], EDI;//Temp buffer address
MOV DWORD PTR DS : [ESI + 0x1C], EDX;//Destination address
MOV DWORD PTR DS : [ESI + 0x18], ECX;//Compressed Data
MOV BYTE PTR DS : [ESI + 0x20], BL;//0
MOV CL, BYTE PTR DS : [EAX];//08
PUSH 1;
POP EAX;
MOV BYTE PTR DS : [ESI + 0x22], CL;
SHL EAX, CL;
MOV DWORD PTR DS : [ESI + 0x30], EBX;
MOV WORD PTR DS : [ESI + 8], AX;
INC EAX;
MOV WORD PTR DS : [ESI + 0xA], AX;
MOV EAX, DWORD PTR SS : [EBP + 0x10];
MOV DWORD PTR DS : [ESI + 0x2C], EAX;
LEA EAX, DWORD PTR DS : [EAX * 8 + 0x1F];
SHR EAX, 5;
SHL EAX, 2;
CMP BYTE PTR SS : [EBP + 0x18], BL;
MOV DWORD PTR DS : [ESI + 0x38], EAX;
SETE AL;
DEC EAX;
AND AL, 1;
ADD EAX, 0x0FF;
CMP AL, BL;
MOV BYTE PTR DS : [ESI + 0xC], AL;
JNZ SHORT check3;
MOV EAX, DWORD PTR SS : [EBP + 0x14];
MOV DWORD PTR DS : [ESI + 0x14], EDX;
MOV DWORD PTR DS : [ESI + 0x28], EAX;
MOV DWORD PTR DS : [ESI + 0x34], EBX;
check3:
MOV ECX, ESI;
CALL check4;
check26:
MOV ECX, ESI;
CALL check10;
MOV EDI, EAX;
CMP DI, WORD PTR DS : [ESI + 0xA];
JE Finished;
CMP DI, WORD PTR DS : [ESI + 8];
JNZ SHORT check22;
MOV ECX, ESI;
CALL check4;
check24:
MOV ECX, ESI;
CALL check10;
MOV EDI, EAX
CMP DI, WORD PTR DS : [ESI + 8]
JNZ SHORT check23;
JMP SHORT check24;
check22:
CMP DI, WORD PTR DS : [ESI + 0X24]
JNB SHORT check25;
PUSH EDI
JMP SHORT check27;
check25:
PUSH EBX;
check27:
MOV ECX, ESI;
CALL check28;
MOVZX AX, AL;
PUSH EAX;
PUSH EBX;
MOV ECX, ESI;
CALL check31;
PUSH EDI;
MOV ECX, ESI;
CALL check35;
MOV EBX, EDI;
JMP SHORT check26;
check10:
MOVZX EAX, BYTE PTR DS : [ECX + 0x20];
PUSH EBX;
PUSH ESI;
PUSH EDI;
MOVZX EDI, BYTE PTR DS : [ECX + 0x23];
ADD EAX, EDI;
CMP EAX, 8;
JA SHORT Check6;
MOV EDX, DWORD PTR DS : [ECX + 0x18];
MOVZX ESI, BYTE PTR DS : [EDX];
JMP SHORT Check8;
Check6:
MOV EDX, DWORD PTR DS : [ECX + 0x18];
CMP EAX, 0x10;
JA SHORT Check7;
MOVZX ESI, WORD PTR DS : [EDX];
JMP SHORT Check8;
Check7:
MOVZX ESI, BYTE PTR DS : [EDX + 2];
MOVZX EBX, WORD PTR DS : [EDX];
SHL ESI, 0X10;
OR ESI, EBX;
Check8:
MOV EBX, EAX;
PUSH 0x20;
SHR EBX, 3;
ADD EBX, EDX;
MOV DL, AL;
AND DL, 7;
MOV DWORD PTR DS : [ECX + 0X18], EBX;
MOV BYTE PTR DS : [ECX + 0X20], DL;
POP ECX;
SUB ECX, EAX;
MOV EAX, ESI;
PUSH 0x20;
SHL EAX, CL;
POP ECX;
SUB ECX, EDI;
POP EDI;
POP ESI;
POP EBX;
SHR EAX, CL;
RETN;
check28:
MOV EAX, DWORD PTR DS : [ECX];
MOV EDX, DWORD PTR SS : [ESP + 4];
check30:
MOVZX ECX, DX;
MOV CX, WORD PTR DS : [EAX + ECX * 4];
CMP CX, 0x0FFFF;
JE SHORT check29;
MOV EDX, ECX;
JMP SHORT check30;
check29:
MOVZX ECX, DX;
MOV AL, BYTE PTR DS : [EAX + ECX * 4 + 2];
RETN 4;
check31:
MOVZX EDX, WORD PTR DS : [ECX + 0x24];
LEA EAX, DWORD PTR DS : [ECX + 0x24];
PUSH ESI;
MOV ESI, DWORD PTR DS : [ECX];
PUSH EDI;
MOV DI, WORD PTR SS : [ESP + 0xC];
MOV WORD PTR DS : [ESI + EDX * 4], DI;
MOV ESI, DWORD PTR DS : [ECX];
MOVZX EDX, WORD PTR DS : [EAX];
MOV DI, WORD PTR SS : [ESP + 0x10];
MOV WORD PTR DS : [ESI + EDX * 4 + 2], DI;
INC WORD PTR DS : [EAX];
MOV AX, WORD PTR DS : [EAX];
POP EDI;
CMP AX, 8;
POP ESI;
JE SHORT check32;
CMP AX, 0x10;
JE SHORT check32;
CMP AX, 0x20;
JE SHORT check32;
CMP AX, 0x40;
JE SHORT check32;
CMP AX, 0x80;
JE SHORT check32;
CMP AX, 0x100;
JE SHORT check32;
CMP AX, 0x200;
JE SHORT check32;
CMP AX, 0x400;
JE SHORT check32;
CMP AX, 0x800;
JNZ SHORT check33;
check32:
INC BYTE PTR DS : [ECX + 0x23];
check33:
RETN 8;
check4:
MOV EDX, ECX;
PUSH EDI;
MOV ECX, 0x1000;
OR EAX, 0xFFFFFFFF;
MOV EDI, DWORD PTR DS : [EDX]
REP STOS DWORD PTR ES : [EDI];
XOR EAX, EAX;
POP EDI;
CMP WORD PTR DS : [EDX + 8], AX;
JBE SHORT check1;
PUSH ESI;
MOV ESI, DWORD PTR DS : [EDX];
check2:
MOVZX ECX, AX;
MOV WORD PTR DS : [ESI + ECX * 4 + 2], AX;
INC EAX;
CMP AX, WORD PTR DS : [EDX + 8];
JB SHORT check2;
POP ESI;
check1:
MOV AX, WORD PTR DS : [EDX + 0xA];
INC AX;
MOV WORD PTR DS : [EDX + 0x24], AX;
MOV AL, BYTE PTR DS : [EDX + 0x22];
INC AL;
MOV BYTE PTR DS : [EDX + 0x23], AL;
RETN;
check23:
PUSH EDI;
MOV ECX, ESI;
CALL check35;
MOV EBX, EDI;
JMP SHORT check26;
check35:
PUSH EBP;
MOV EBP, ESP;
PUSH ESI;
PUSH EDI;
MOV ESI, ECX;
NOP;
MOV AX, WORD PTR SS : [EBP + 8];
CMP AX, WORD PTR DS : [ESI + 8];
JNB SHORT check36;
NOP;
MOV ECX, DWORD PTR DS : [ESI];
MOV EDX, DWORD PTR DS : [ESI + 0x1C];
MOV EDI, DWORD PTR DS : [ESI + 0x30];
MOVZX EAX, AX;
MOV AL, BYTE PTR DS : [ECX + EAX * 4 + 2];
MOV BYTE PTR DS : [EDX + EDI], AL;
INC DWORD PTR DS : [ESI + 0x30];
NOP;
MOV EAX, DWORD PTR DS : [ESI + 0x30];
CMP EAX, DWORD PTR DS : [ESI + 0x2C];
JNZ SHORT FuncRetn;
MOV ECX, ESI;
CALL check37;
NOP;
JMP SHORT FuncRetn;
check36:
MOVZX EDI, AX;
MOV EAX, DWORD PTR DS : [ESI];
MOV ECX, ESI;
SHL EDI, 2;
MOV AX, WORD PTR DS : [EDI + EAX];
PUSH EAX;
CALL check35;
NOP;
MOV EAX, DWORD PTR DS : [ESI];
MOV ECX, ESI;
MOV AX, WORD PTR DS : [EDI + EAX + 2];
PUSH EAX;
CALL check35;
NOP;
NOP;
POP EDI;
POP ESI;
POP EBP;
RETN 4;
check38:
MOVZX EDX, AL;
MOVZX EDX, BYTE PTR DS : [EDX + ECX + 0xD];
ADD DWORD PTR DS : [ECX + 0x34], EDX;
MOV EDX, DWORD PTR DS : [ECX + 0x34];
CMP EDX, DWORD PTR DS : [ECX + 0x28];
JB SHORT FuncRetrn2;
INC AL;
CMP AL, 4;
MOV BYTE PTR DS : [ECX + 0xC], AL;
JNB SHORT Frtn;
MOVZX EAX, AL;
MOVZX EAX, BYTE PTR DS : [EAX + ECX + 0xD];
SHR EAX, 1;
MOV DWORD PTR DS : [ECX + 0x34], EAX;
FuncRetrn2:
MOV EAX, DWORD PTR DS : [ECX + 0x38];
MOV EDX, DWORD PTR DS : [ECX + 0x14];
IMUL EAX, DWORD PTR DS : [ECX + 0x34];
SUB EDX, EAX;
MOV DWORD PTR DS : [ECX + 0x1C], EDX;
Frtn:
RETN;
FuncRetn:
NOP;
POP EDI;
POP ESI;
POP EBP;
RETN 4;
check37:
MOV AL, BYTE PTR DS : [ECX + 0xC];
AND DWORD PTR DS : [ECX + 0x30], 0;
CMP AL, 0x0FF;
JNZ SHORT check38;
MOV EAX, DWORD PTR DS : [ECX + 0x38];
SUB DWORD PTR DS : [ECX + 0x1C], EAX;
RETN;
Finished:
MOV ESP,EBP;
POP EBP;
//Debug VS Release build have different stack sizes. The following is needed for the return parameters and CTYPES
#ifdef _DEBUG
ADD ESI, 0x120;
#else
ADD ESI, 0x58; //Need for Pythnon CTypes return parameters!
#endif
RETN;
}
}
return TRUE;
}