mirror
/
devilutionX
mirror of https://github.com/diasurgical/devilutionX.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Clean up encrypt.cpp (#424)

pull/25/head
Anders Jenbo 8 years ago committed by GitHub
parent
b162e22ae7
commit
37d294acc9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 104 additions and 163 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 249
      Source/encrypt.cpp
  2. 8
      Source/encrypt.h
  3. 10
      structs.h

249
Source/encrypt.cpp
Unescape View File

@ -2,195 +2,136 @@
#include "../types.h"
int hashtable[1280];
DWORD hashtable[1280];
void __fastcall Decrypt(void *block, int size, int key)
void __fastcall Decrypt(void *block, DWORD size, DWORD key)
{
unsigned int v3; // edx
int v4; // eax
unsigned int v5; // edi
unsigned int v6; // edx
int v7; // eax
int v8; // esi
v3 = (unsigned int)size >> 2;
v4 = 0xEEEEEEEE;
if (v3) {
v5 = v3;
v6 = key;
do {
v7 = hashtable[(unsigned char)v6 + 1024] + v4;
*(_DWORD *)block ^= v7 + v6;
v8 = *(_DWORD *)block;
block = (char *)block + 4;
v4 = 33 * v7 + v8 + 3;
v6 = ((~v6 << 21) + 0x11111111) | (v6 >> 11);
--v5;
} while (v5);
DWORD *castBlock = (DWORD *)block;
DWORD seed = 0xEEEEEEEE;
for (DWORD i = 0; i < (size >> 2); i++) {
seed += hashtable[0x400 + (key & 0xFF)];
*castBlock ^= seed + key;
seed += *castBlock + (seed << 5) + 3;
key = ((~key << 0x15) + 0x11111111) | (key >> 0x0B);
castBlock++;
}
}
void __fastcall Encrypt(void *block, int size, int key)
void __fastcall Encrypt(void *block, DWORD size, DWORD key)
{
unsigned int v3; // edx
int v4; // eax
unsigned int v5; // edi
unsigned int v6; // edx
int v7; // eax
int v8; // ebx
v3 = (unsigned int)size >> 2;
v4 = 0xEEEEEEEE;
if (v3) {
v5 = v3;
v6 = key;
do {
v7 = hashtable[(unsigned char)v6 + 1024] + v4;
v8 = *(_DWORD *)block ^ (v7 + v6);
v4 = 33 * v7 + *(_DWORD *)block + 3;
*(_DWORD *)block = v8;
block = (char *)block + 4;
v6 = ((~v6 << 21) + 0x11111111) | (v6 >> 11);
--v5;
} while (v5);
DWORD *castBlock = (DWORD *)block;
DWORD seed = 0xEEEEEEEE;
for (DWORD i = 0; i < (size >> 2); i++) {
DWORD ch = *castBlock;
seed += hashtable[0x400 + (key & 0xFF)];
*castBlock ^= seed + key;
seed += ch + (seed << 5) + 3;
key = ((~key << 0x15) + 0x11111111) | (key >> 0x0B);
castBlock++;
}
}
int __fastcall Hash(const char *s, int type)
DWORD __fastcall Hash(const char *s, int type)
{
int v2; // ebp
const char *v3; // ebx
signed int v4; // esi
int v5; // edi
int v6; // ST00_4
char v7; // al
v2 = type;
v3 = s;
v4 = 0x7FED7FED;
v5 = 0xEEEEEEEE;
while (v3 && *v3) {
v6 = *v3++;
v7 = toupper(v6);
v4 = (v5 + v4) ^ hashtable[v7 + (v2 << 8)];
v5 = v7 + 33 * v5 + v4 + 3;
char ch;
DWORD seed1 = 0x7FED7FED;
DWORD seed2 = 0xEEEEEEEE;
while (s != NULL && *s) {
ch = *s++;
ch = toupper(ch);
seed1 = hashtable[(type << 8) + ch] ^ (seed1 + seed2);
seed2 += ch + seed1 + (seed2 << 5) + 3;
}
return v4;
return seed1;
}
void __cdecl InitHash()
{
unsigned int v0; // eax
int *v1; // edi
unsigned int v2; // eax
int v3; // ecx
signed int v4; // [esp+Ch] [ebp-8h]
int *v5; // [esp+10h] [ebp-4h]
v0 = 0x100001;
v5 = hashtable;
do {
v1 = v5;
v4 = 5;
do {
v2 = (125 * v0 + 3) % 0x2AAAAB;
v3 = (unsigned short)v2 << 16;
v0 = (125 * v2 + 3) % 0x2AAAAB;
*v1 = (unsigned short)v0 | v3;
v1 += 256;
--v4;
} while (v4);
++v5;
} while ((signed int)v5 < (signed int)&hashtable[256]);
DWORD seed = 0x00100001;
for (int i = 0; i < 256; i++) {
for (int j = 0; j < 5; j++) {
seed = (125 * seed + 3) % 0x2AAAAB;
DWORD ch = (seed & 0xFFFF);
seed = (125 * seed + 3) % 0x2AAAAB;
hashtable[i + j * 256] = ch << 16 | (seed & 0xFFFF);
}
}
}
int __fastcall PkwareCompress(void *buf, int size)
{
unsigned char *v2; // ebx
unsigned char *v3; // esi
int v4; // ecx
unsigned char *v5; // edi
TDataInfo param; // [esp+Ch] [ebp-20h]
unsigned int type; // [esp+20h] [ebp-Ch]
unsigned int dsize; // [esp+24h] [ebp-8h]
char *ptr; // [esp+28h] [ebp-4h]
v2 = (unsigned char *)buf;
v3 = (unsigned char *)size;
ptr = (char *)DiabloAllocPtr(CMP_BUFFER_SIZE); // 36312
v4 = 2 * (_DWORD)v3;
if ((unsigned int)(2 * (_DWORD)v3) < 0x2000)
v4 = 0x2000;
v5 = (unsigned char *)DiabloAllocPtr(v4);
param.pbInBuffEnd = 0;
param.pbOutBuffEnd = 0;
type = 0;
param.pbInBuff = v2;
param.pbOutBuff = v5;
param.pbSize = v3;
dsize = 4096;
implode(
PkwareBufferRead,
PkwareBufferWrite,
ptr,
&param,
&type,
&dsize);
if (param.pbOutBuffEnd < v3) {
memcpy(v2, v5, (size_t)param.pbOutBuffEnd);
v3 = param.pbOutBuffEnd;
BYTE *srcData = (BYTE *)buf;
char *ptr = (char *)DiabloAllocPtr(CMP_BUFFER_SIZE);
unsigned int destSize = 2 * size;
if (destSize < 8192)
destSize = 8192;
BYTE *destData = (BYTE *)DiabloAllocPtr(destSize);
TDataInfo param;
param.srcData = srcData;
param.srcOffset = 0;
param.destData = destData;
param.destOffset = 0;
param.size = size;
unsigned int type = 0;
unsigned int dsize = 4096;
implode(PkwareBufferRead, PkwareBufferWrite, ptr, &param, &type, &dsize);
if (param.destOffset < size) {
memcpy(srcData, destData, param.destOffset);
size = param.destOffset;
}
mem_free_dbg(ptr);
mem_free_dbg(v5);
return (int)v3;
mem_free_dbg(destData);
return size;
}
unsigned int __cdecl PkwareBufferRead(char *buf, unsigned int *size, void *param)
{
TDataInfo *pInfo = (TDataInfo *)param;
int v3; // edi
unsigned char *v4; // ecx
v3 = *size;
v4 = pInfo->pbInBuffEnd;
if (*size >= (unsigned int)(pInfo->pbSize - v4))
v3 = pInfo->pbSize - v4;
memcpy(buf, &v4[(unsigned int)pInfo->pbInBuff], v3);
pInfo->pbInBuffEnd += v3;
return v3;
DWORD sSize;
if (*size >= pInfo->size - pInfo->srcOffset) {
sSize = pInfo->size - pInfo->srcOffset;
} else {
sSize = *size;
}
memcpy(buf, pInfo->srcData + pInfo->srcOffset, sSize);
pInfo->srcOffset += sSize;
return sSize;
}
void __cdecl PkwareBufferWrite(char *buf, unsigned int *size, void *param)
{
TDataInfo *pInfo = (TDataInfo *)param;
memcpy(&pInfo->pbOutBuffEnd[(unsigned int)pInfo->pbOutBuff], buf, *size);
pInfo->pbOutBuffEnd += *size;
memcpy(pInfo->destData + pInfo->destOffset, buf, *size);
pInfo->destOffset += *size;
}
void __fastcall PkwareDecompress(void *param, int recv_size, int dwMaxBytes)
{
unsigned char *v3; // edi
unsigned char *v4; // ebx
unsigned char *v5; // esi
TDataInfo info; // [esp+Ch] [ebp-18h]
char *ptr; // [esp+20h] [ebp-4h]
v3 = (unsigned char *)param;
v4 = (unsigned char *)recv_size;
ptr = (char *)DiabloAllocPtr(CMP_BUFFER_SIZE); // 36312
v5 = (unsigned char *)DiabloAllocPtr(dwMaxBytes);
info.pbInBuffEnd = 0;
info.pbOutBuffEnd = 0;
info.pbInBuff = v3;
info.pbOutBuff = v5;
info.pbSize = v4;
explode(
PkwareBufferRead,
PkwareBufferWrite,
ptr,
&info);
memcpy(v3, v5, (size_t)info.pbOutBuffEnd);
char *ptr = (char *)DiabloAllocPtr(CMP_BUFFER_SIZE);
BYTE *pbInBuff = (BYTE *)param;
BYTE *pbOutBuff = DiabloAllocPtr(dwMaxBytes);
TDataInfo info;
info.srcData = pbInBuff;
info.srcOffset = 0;
info.destData = pbOutBuff;
info.destOffset = 0;
info.size = recv_size;
explode(PkwareBufferRead, PkwareBufferWrite, ptr, &info);
memcpy(pbInBuff, pbOutBuff, info.destOffset);
mem_free_dbg(ptr);
mem_free_dbg(v5);
mem_free_dbg(pbOutBuff);
}

8
Source/encrypt.h
Unescape View File

@ -2,11 +2,11 @@
#ifndef __ENCRYPT_H__
#define __ENCRYPT_H__
extern int hashtable[1280];
extern DWORD hashtable[1280];
void __fastcall Decrypt(void *block, int size, int key);
void __fastcall Encrypt(void *block, int size, int key);
int __fastcall Hash(const char *s, int type);
void __fastcall Decrypt(void *block, DWORD size, DWORD key);
void __fastcall Encrypt(void *block, DWORD size, DWORD key);
DWORD __fastcall Hash(const char *s, int type);
void __cdecl InitHash();
int __fastcall PkwareCompress(void *buf, int size);
unsigned int __cdecl PkwareBufferRead(char *buf, unsigned int *size, void *param);

10
structs.h
Unescape View File

@ -1574,11 +1574,11 @@ struct PCXHeader {
//////////////////////////////////////////////////
struct TDataInfo {
unsigned char *pbInBuff;
unsigned char *pbInBuffEnd;
unsigned char *pbOutBuff;
unsigned char *pbOutBuffEnd;
unsigned char *pbSize;
BYTE *srcData;
DWORD srcOffset;
BYTE *destData;
DWORD destOffset;
DWORD size;
};
//////////////////////////////////////////////////

Write Preview
Loading…
Cancel
Save