From 37d294acc92f806f822e85dcdaf32031f4b54c97 Mon Sep 17 00:00:00 2001
From: Anders Jenbo <anders@jenbo.dk>
Date: Sat, 27 Oct 2018 17:11:45 +0200
Subject: [PATCH] Clean up encrypt.cpp (#424)

---
 Source/encrypt.cpp | 249 +++++++++++++++++----------------------------
 Source/encrypt.h   |   8 +-
 structs.h          |  10 +-
 3 files changed, 104 insertions(+), 163 deletions(-)

diff --git a/Source/encrypt.cpp b/Source/encrypt.cpp
index e95b2f1a4..83d8ec82e 100644
--- a/Source/encrypt.cpp
+++ b/Source/encrypt.cpp
@@ -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);
 }
diff --git a/Source/encrypt.h b/Source/encrypt.h
index cec2a24c5..042f49195 100644
--- a/Source/encrypt.h
+++ b/Source/encrypt.h
@@ -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);
diff --git a/structs.h b/structs.h
index 25ff83d9f..0ec00faf3 100644
--- a/structs.h
+++ b/structs.h
@@ -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;
 };
 
 //////////////////////////////////////////////////