diff --git a/DecimaExplorer.vcxproj b/DecimaExplorer.vcxproj index b1bcab4..e9a37c0 100644 --- a/DecimaExplorer.vcxproj +++ b/DecimaExplorer.vcxproj @@ -22,32 +22,32 @@ 15.0 {05B0E20F-1ED1-4EA1-B3BF-9FDFDD7E26B3} DecimaExplorer - 10.0.16299.0 + 10.0 Application true - v141 + v142 MultiByte Application false - v141 + v142 true MultiByte Application true - v141 + v142 MultiByte Application false - v141 + v142 true MultiByte @@ -117,6 +117,8 @@ + + @@ -124,11 +126,15 @@ + + + + diff --git a/DecimaExplorer.vcxproj.filters b/DecimaExplorer.vcxproj.filters index 36a47d2..d644b32 100644 --- a/DecimaExplorer.vcxproj.filters +++ b/DecimaExplorer.vcxproj.filters @@ -27,6 +27,12 @@ Source Files + + Source Files + + + Source Files + @@ -44,8 +50,16 @@ Header Files + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/DecimaExplorer.vcxproj.user b/DecimaExplorer.vcxproj.user index 316bd3a..c86dd08 100644 --- a/DecimaExplorer.vcxproj.user +++ b/DecimaExplorer.vcxproj.user @@ -7,4 +7,8 @@ -e Initial.bin 0 c:\test.bin WindowsLocalDebugger + + -e 7017f9bb9d52fc1c4433599203cc51b1.bin 0 0out.bin + WindowsLocalDebugger + \ No newline at end of file diff --git a/README.md b/README.md index 42daa36..365008f 100644 --- a/README.md +++ b/README.md @@ -2,16 +2,20 @@ # Decima Explorer -Decima Explorer is a free and open-source program designed to allow you to unpack files from the archive structure used by games using the Decima engine. Currently files must be extracted using their ID as I am unaware of how the file names are mapped. I suspect a hashing algorithm is used for lookup but am unsure of which one. +Decima Explorer is a free and open-source program designed to allow you to unpack files from the archive structure used by games using the Decima engine. Currently files must be extracted using their ID as I am unaware of how the file names are mapped. + +Early work-in-progress support for encrypted files has been added thanks to Ekey, and [Wunkolo](https://github.com/Wunkolo) for researching, implementing and documenting the decryption algorithm. Wunkolo's [implementation can be found here](https://github.com/Wunkolo). This program uses [Ooz](https://github.com/powzix/ooz) created by [Powzix](https://github.com/powzix) for decompression. It is slightly modified for this programs purposes. Ooz is under GPL licensing. +This program also uses [Murmur3](https://github.com/PeterScott/murmur3) by [Peter Scott](https://github.com/PeterScott/murmur3). + If anyone has any issue with this project's existence please feel free to reach out to me. ### To Do - Create GUI variant - Implement Repack command - - Understand how the file strings match to files + - Understand how the file strings match to files (Appears to be Murmur3Hash but not seeing expected results) ## Usage diff --git a/archive/DecimaArchive.cpp b/archive/DecimaArchive.cpp index 927fe17..ced2aa2 100644 --- a/archive/DecimaArchive.cpp +++ b/archive/DecimaArchive.cpp @@ -2,7 +2,11 @@ #include "DecimaArchiveError.h" bool DecimaArchive::checkMagic() { - return header.magic == 0x20304050; + return (header.magic == 0x20304050) || (header.magic == 0x21304050); +} + +bool DecimaArchive::isEncrypted() { + return header.magic == 0x21304050; } std::string DecimaArchive::getFilename() { @@ -18,7 +22,7 @@ DecimaArchive::DecimaArchive(std::string filename) { } int DecimaArchive::getVersion() { - return header.version; + return header.key; } DecimaArchive::~DecimaArchive() { @@ -38,7 +42,7 @@ int DecimaArchive::calculateChunkTableOffset(uint64_t fileTableCount) { void DecimaArchive::parseHeader(FILE* f) { fread(&header.magic, 4, 1, f); - fread(&header.version, 4, 1, f); + fread(&header.key, 4, 1, f); fread(&header.fileSize, 8, 1, f); fread(&header.dataSize, 8, 1, f); fread(&header.fileTableCount, 8, 1, f); @@ -51,11 +55,11 @@ void DecimaArchive::parseFileTable(FILE* f, uint64_t fileTableCount) { DecimaFileEntry fileEntry; fread(&fileEntry.entryNum, 4, 1, f); - fread(&fileEntry.unknown, 4, 1, f); - fread(&fileEntry.unknown2, 8, 1, f); + fread(&fileEntry.key, 4, 1, f); + fread(&fileEntry.hash, 8, 1, f); fread(&fileEntry.offset, 8, 1, f); fread(&fileEntry.size, 4, 1, f); - fread(&fileEntry.unknown3, 4, 1, f); + fread(&fileEntry.key2, 4, 1, f); fileTable.push_back(fileEntry); } @@ -68,10 +72,10 @@ void DecimaArchive::parseChunkTable(FILE* f, uint64_t chunkTableCount) { fread(&chunkEntry.uncompressedOffset, 8, 1, f); fread(&chunkEntry.uncompressedSize, 4, 1, f); - fread(&chunkEntry.unknown, 4, 1, f); + fread(&chunkEntry.key, 4, 1, f); fread(&chunkEntry.compressedOffset, 8, 1, f); fread(&chunkEntry.compressedSize, 4, 1, f); - fread(&chunkEntry.unknown2, 4, 1, f); + fread(&chunkEntry.key2, 4, 1, f); chunkTable.push_back(chunkEntry); } @@ -146,7 +150,9 @@ DataBuffer DecimaArchive::extract(DecimaFileEntry fileEntry) { DataBuffer tempBuffer(maxNeededSize); for (int i = firstChunkRow; i <= lastChunkRow; i++) { - decompressChunkData(getChunkData(chunkTable[i]), chunkTable[i].uncompressedSize, &tempBuffer[pos]); + DataBuffer chunkData = getChunkData(chunkTable[i]); + if (isEncrypted()) decryptChunkData(i, &chunkData); + decompressChunkData(chunkData, chunkTable[i].uncompressedSize, &tempBuffer[pos]); pos += chunkTable[i].uncompressedSize; } @@ -160,6 +166,61 @@ DataBuffer DecimaArchive::extract(DecimaFileEntry fileEntry) { } +void DecimaArchive::decryptHeader() { + uint32_t* p = (uint32_t*)&header + 2; + cipher(header.key, header.key + 1, p); +} + +void DecimaArchive::decryptFileTable() { + for (int i = 0; i< header.fileTableCount; i++) { + uint32_t* p = (uint32_t*)&fileTable[i]; + cipher(fileTable[i].key, fileTable[i].key2, p); + } +} + +void DecimaArchive::decryptChunkTable() { + for (int i = 0; i < header.chunkTableCount; i++) { + uint32_t* p = (uint32_t*)&chunkTable[i]; + uint32_t saveKey = chunkTable[i].key; + cipher(chunkTable[i].key, chunkTable[i].key2, p); + chunkTable[i].key = saveKey; + } +} + +void DecimaArchive::decryptChunkData(int32_t id, DataBuffer* data) { + dataCipher(id, &(*data)[0], data->size()); +} + +void DecimaArchive::cipher(uint32_t key, uint32_t key2, uint32_t *src) { + uint32_t iv[4]; + uint32_t inputKey[2][4] = { + { key, murmurSalt[1], murmurSalt[2], murmurSalt[3] }, + { key2, murmurSalt[1], murmurSalt[2], murmurSalt[3] } + }; + + for (int i = 0; i < 2; i++) { + MurmurHash3_x64_128(inputKey[i], 0x10, seed, iv); + for (int j = 0; j < 4; j++) { + src[(i * 4) + j] ^= iv[j]; + } + } +} + +void DecimaArchive::dataCipher(uint32_t chunkID, uint8_t* src, int size) { + uint32_t iv[4]; + MurmurHash3_x64_128(&chunkTable[chunkID].uncompressedOffset, 0x10, seed, iv); + + for (int i = 0; i < 4; i++) { + iv[i] ^= murmurSalt2[i]; + } + + md5_byte_t* digest = md5Hash((md5_byte_t*)iv, 16); + + for (int i = 0; i < size; i++) { + src[i] ^= digest[i % 16]; + } +} + int DecimaArchive::open() { FILE *f; fopen_s(&f, getFilename().c_str(), "rb"); @@ -176,8 +237,14 @@ int DecimaArchive::open() { return 0; } + if (isEncrypted()) decryptHeader(); + parseFileTable(f, header.fileTableCount); + if (isEncrypted()) decryptFileTable(); + parseChunkTable(f, header.chunkTableCount); + if (isEncrypted()) decryptChunkTable(); + fclose(f); return 1; } @@ -193,4 +260,4 @@ int DecimaArchive::extractFile(uint32_t id, std::string output) { DataBuffer data = extract(fileTable[i]); if (!writeDataToFile(data, output)) return 0; return 1; -} +} \ No newline at end of file diff --git a/archive/DecimaArchive.h b/archive/DecimaArchive.h index 41450c5..5df7401 100644 --- a/archive/DecimaArchive.h +++ b/archive/DecimaArchive.h @@ -1,12 +1,15 @@ #pragma once #include "../ooz/Kraken.h" +#include "../hash/md5.h" +#include "../hash/MurmurHash3.h" +#include #include #include typedef struct DecimaHeader { uint32_t magic; //0x20304050 - uint32_t version; //0x3D + uint32_t key; uint64_t fileSize; uint64_t dataSize; uint64_t fileTableCount; @@ -16,20 +19,20 @@ typedef struct DecimaHeader { typedef struct DecimaFileEntry { uint32_t entryNum; - uint32_t unknown; - uint64_t unknown2; //maybe file hash, not sure + uint32_t key; + uint64_t hash; uint64_t offset; uint32_t size; - uint32_t unknown3; + uint32_t key2; } DecimaFileTable; typedef struct DecimaChunkEntry { uint64_t uncompressedOffset; //relative offset once uncompressed uint32_t uncompressedSize; - uint32_t unknown; + uint32_t key; uint64_t compressedOffset; uint32_t compressedSize; - uint32_t unknown2; + uint32_t key2; } DecimaChunkTable; typedef std::vector DataBuffer; @@ -42,18 +45,29 @@ class DecimaArchive { std::string filename; + uint8_t seed = 0x2A; + uint32_t murmurSalt[4] = { 0x0FA3A9443, 0x0F41CAB62, 0x0F376811C, 0x0D2A89E3E }; + uint32_t murmurSalt2[4] = { 0x06C084A37, 0x07E159D95, 0x03D5AF7E8, 0x018AA7D3F }; + void parseHeader(FILE* file); void parseFileTable(FILE* f, uint64_t fileTableCount); void parseChunkTable(FILE* f, uint64_t chunkTableCount); bool checkMagic(); + bool isEncrypted(); + void decryptHeader(); + void decryptFileTable(); + void decryptChunkTable(); uint32_t getFileEntryIndex(int id); DecimaFileEntry getFileEntry(int id); void setFilename(std::string filename); int findChunkWithOffset(uint64_t offset); DataBuffer extract(DecimaFileEntry fileEntry); + void decryptChunkData(int32_t id, DataBuffer* data); DataBuffer getChunkData(DecimaChunkEntry chunkEntry); int calculateChunkTableOffset(uint64_t fileTableCount); + void cipher(uint32_t key, uint32_t key2, uint32_t* src); + void dataCipher(uint32_t chunkID, uint8_t* src, int size); int writeDataToFile(DataBuffer data, std::string filename); uint64_t calculateFirstContainingChunk(uint64_t fileOffset, int chunkSize); uint64_t calculateLastContainingChunk(uint64_t fileOffset, int fileSize, int chunkSize); diff --git a/hash/MurmurHash3.cpp b/hash/MurmurHash3.cpp new file mode 100644 index 0000000..7c6f75d --- /dev/null +++ b/hash/MurmurHash3.cpp @@ -0,0 +1,334 @@ +//----------------------------------------------------------------------------- +// MurmurHash3 was written by Austin Appleby, and is placed in the public +// domain. The author hereby disclaims copyright to this source code. + +// Note - The x86 and x64 versions do _not_ produce the same results, as the +// algorithms are optimized for their respective platforms. You can still +// compile and run any of them on any platform, but your performance with the +// non-native version will be less than optimal. + +#include "MurmurHash3.h" + +//----------------------------------------------------------------------------- +// Platform-specific functions and macros + +// Microsoft Visual Studio + +#if defined(_MSC_VER) + +#define FORCE_INLINE __forceinline + +#include + +#define ROTL32(x,y) _rotl(x,y) +#define ROTL64(x,y) _rotl64(x,y) + +#define BIG_CONSTANT(x) (x) + +// Other compilers + +#else // defined(_MSC_VER) + +#define FORCE_INLINE inline __attribute__((always_inline)) + +inline uint32_t rotl32(uint32_t x, int8_t r) +{ + return (x << r) | (x >> (32 - r)); +} + +inline uint64_t rotl64(uint64_t x, int8_t r) +{ + return (x << r) | (x >> (64 - r)); +} + +#define ROTL32(x,y) rotl32(x,y) +#define ROTL64(x,y) rotl64(x,y) + +#define BIG_CONSTANT(x) (x##LLU) + +#endif // !defined(_MSC_VER) + +//----------------------------------------------------------------------------- +// Block read - if your platform needs to do endian-swapping or can only +// handle aligned reads, do the conversion here + +FORCE_INLINE uint32_t getblock32(const uint32_t * p, int i) +{ + return p[i]; +} + +FORCE_INLINE uint64_t getblock64(const uint64_t * p, int i) +{ + return p[i]; +} + +//----------------------------------------------------------------------------- +// Finalization mix - force all bits of a hash block to avalanche + +FORCE_INLINE uint32_t fmix32(uint32_t h) +{ + h ^= h >> 16; + h *= 0x85ebca6b; + h ^= h >> 13; + h *= 0xc2b2ae35; + h ^= h >> 16; + + return h; +} + +//---------- + +FORCE_INLINE uint64_t fmix64(uint64_t k) +{ + k ^= k >> 33; + k *= BIG_CONSTANT(0xff51afd7ed558ccd); + k ^= k >> 33; + k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53); + k ^= k >> 33; + + return k; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_32(const void * key, int len, + uint32_t seed, void * out) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 4; + + uint32_t h1 = seed; + + const uint32_t c1 = 0xcc9e2d51; + const uint32_t c2 = 0x1b873593; + + //---------- + // body + + const uint32_t * blocks = (const uint32_t *)(data + nblocks * 4); + + for (int i = -nblocks; i; i++) + { + uint32_t k1 = getblock32(blocks, i); + + k1 *= c1; + k1 = ROTL32(k1, 15); + k1 *= c2; + + h1 ^= k1; + h1 = ROTL32(h1, 13); + h1 = h1 * 5 + 0xe6546b64; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks * 4); + + uint32_t k1 = 0; + + switch (len & 3) + { + case 3: k1 ^= tail[2] << 16; + case 2: k1 ^= tail[1] << 8; + case 1: k1 ^= tail[0]; + k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; + + h1 = fmix32(h1); + + *(uint32_t*)out = h1; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_128(const void * key, const int len, + uint32_t seed, void * out) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 16; + + uint32_t h1 = seed; + uint32_t h2 = seed; + uint32_t h3 = seed; + uint32_t h4 = seed; + + const uint32_t c1 = 0x239b961b; + const uint32_t c2 = 0xab0e9789; + const uint32_t c3 = 0x38b34ae5; + const uint32_t c4 = 0xa1e38b93; + + //---------- + // body + + const uint32_t * blocks = (const uint32_t *)(data + nblocks * 16); + + for (int i = -nblocks; i; i++) + { + uint32_t k1 = getblock32(blocks, i * 4 + 0); + uint32_t k2 = getblock32(blocks, i * 4 + 1); + uint32_t k3 = getblock32(blocks, i * 4 + 2); + uint32_t k4 = getblock32(blocks, i * 4 + 3); + + k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1; + + h1 = ROTL32(h1, 19); h1 += h2; h1 = h1 * 5 + 0x561ccd1b; + + k2 *= c2; k2 = ROTL32(k2, 16); k2 *= c3; h2 ^= k2; + + h2 = ROTL32(h2, 17); h2 += h3; h2 = h2 * 5 + 0x0bcaa747; + + k3 *= c3; k3 = ROTL32(k3, 17); k3 *= c4; h3 ^= k3; + + h3 = ROTL32(h3, 15); h3 += h4; h3 = h3 * 5 + 0x96cd1c35; + + k4 *= c4; k4 = ROTL32(k4, 18); k4 *= c1; h4 ^= k4; + + h4 = ROTL32(h4, 13); h4 += h1; h4 = h4 * 5 + 0x32ac3b17; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks * 16); + + uint32_t k1 = 0; + uint32_t k2 = 0; + uint32_t k3 = 0; + uint32_t k4 = 0; + + switch (len & 15) + { + case 15: k4 ^= tail[14] << 16; + case 14: k4 ^= tail[13] << 8; + case 13: k4 ^= tail[12] << 0; + k4 *= c4; k4 = ROTL32(k4, 18); k4 *= c1; h4 ^= k4; + + case 12: k3 ^= tail[11] << 24; + case 11: k3 ^= tail[10] << 16; + case 10: k3 ^= tail[9] << 8; + case 9: k3 ^= tail[8] << 0; + k3 *= c3; k3 = ROTL32(k3, 17); k3 *= c4; h3 ^= k3; + + case 8: k2 ^= tail[7] << 24; + case 7: k2 ^= tail[6] << 16; + case 6: k2 ^= tail[5] << 8; + case 5: k2 ^= tail[4] << 0; + k2 *= c2; k2 = ROTL32(k2, 16); k2 *= c3; h2 ^= k2; + + case 4: k1 ^= tail[3] << 24; + case 3: k1 ^= tail[2] << 16; + case 2: k1 ^= tail[1] << 8; + case 1: k1 ^= tail[0] << 0; + k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len; + + h1 += h2; h1 += h3; h1 += h4; + h2 += h1; h3 += h1; h4 += h1; + + h1 = fmix32(h1); + h2 = fmix32(h2); + h3 = fmix32(h3); + h4 = fmix32(h4); + + h1 += h2; h1 += h3; h1 += h4; + h2 += h1; h3 += h1; h4 += h1; + + ((uint32_t*)out)[0] = h1; + ((uint32_t*)out)[1] = h2; + ((uint32_t*)out)[2] = h3; + ((uint32_t*)out)[3] = h4; +} + +//----------------------------------------------------------------------------- + +void MurmurHash3_x64_128(const void * key, const int len, + const uint32_t seed, void * out) +{ + const uint8_t * data = (const uint8_t*)key; + const int nblocks = len / 16; + + uint64_t h1 = seed; + uint64_t h2 = seed; + + const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5); + const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f); + + //---------- + // body + + const uint64_t * blocks = (const uint64_t *)(data); + + for (int i = 0; i < nblocks; i++) + { + uint64_t k1 = getblock64(blocks, i * 2 + 0); + uint64_t k2 = getblock64(blocks, i * 2 + 1); + + k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1; + + h1 = ROTL64(h1, 27); h1 += h2; h1 = h1 * 5 + 0x52dce729; + + k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2; + + h2 = ROTL64(h2, 31); h2 += h1; h2 = h2 * 5 + 0x38495ab5; + } + + //---------- + // tail + + const uint8_t * tail = (const uint8_t*)(data + nblocks * 16); + + uint64_t k1 = 0; + uint64_t k2 = 0; + + switch (len & 15) + { + case 15: k2 ^= ((uint64_t)tail[14]) << 48; + case 14: k2 ^= ((uint64_t)tail[13]) << 40; + case 13: k2 ^= ((uint64_t)tail[12]) << 32; + case 12: k2 ^= ((uint64_t)tail[11]) << 24; + case 11: k2 ^= ((uint64_t)tail[10]) << 16; + case 10: k2 ^= ((uint64_t)tail[9]) << 8; + case 9: k2 ^= ((uint64_t)tail[8]) << 0; + k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2; + + case 8: k1 ^= ((uint64_t)tail[7]) << 56; + case 7: k1 ^= ((uint64_t)tail[6]) << 48; + case 6: k1 ^= ((uint64_t)tail[5]) << 40; + case 5: k1 ^= ((uint64_t)tail[4]) << 32; + case 4: k1 ^= ((uint64_t)tail[3]) << 24; + case 3: k1 ^= ((uint64_t)tail[2]) << 16; + case 2: k1 ^= ((uint64_t)tail[1]) << 8; + case 1: k1 ^= ((uint64_t)tail[0]) << 0; + k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1; + }; + + //---------- + // finalization + + h1 ^= len; h2 ^= len; + + h1 += h2; + h2 += h1; + + h1 = fmix64(h1); + h2 = fmix64(h2); + + h1 += h2; + h2 += h1; + + ((uint64_t*)out)[0] = h1; + ((uint64_t*)out)[1] = h2; +} + +//----------------------------------------------------------------------------- diff --git a/hash/MurmurHash3.h b/hash/MurmurHash3.h new file mode 100644 index 0000000..b2f7f73 --- /dev/null +++ b/hash/MurmurHash3.h @@ -0,0 +1,37 @@ +//----------------------------------------------------------------------------- +// MurmurHash3 was written by Austin Appleby, and is placed in the public +// domain. The author hereby disclaims copyright to this source code. + +#ifndef _MURMURHASH3_H_ +#define _MURMURHASH3_H_ + +//----------------------------------------------------------------------------- +// Platform-specific functions and macros + +// Microsoft Visual Studio + +#if defined(_MSC_VER) && (_MSC_VER < 1600) + +typedef unsigned char uint8_t; +typedef unsigned int uint32_t; +typedef unsigned __int64 uint64_t; + +// Other compilers + +#else // defined(_MSC_VER) + +#include + +#endif // !defined(_MSC_VER) + +//----------------------------------------------------------------------------- + +void MurmurHash3_x86_32(const void * key, int len, uint32_t seed, void * out); + +void MurmurHash3_x86_128(const void * key, int len, uint32_t seed, void * out); + +void MurmurHash3_x64_128(const void * key, int len, uint32_t seed, void * out); + +//----------------------------------------------------------------------------- + +#endif // _MURMURHASH3_H_ \ No newline at end of file diff --git a/hash/md5.c b/hash/md5.c new file mode 100644 index 0000000..891d158 --- /dev/null +++ b/hash/md5.c @@ -0,0 +1,386 @@ +/* + Copyright (C) 1999, 2000, 2002 Aladdin Enterprises. All rights reserved. + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + L. Peter Deutsch + ghost@aladdin.com + */ + /* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */ + /* + Independent implementation of MD5 (RFC 1321). + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + The original and principal author of md5.c is L. Peter Deutsch + . Other authors are noted in the change history + that follows (in reverse chronological order): + 2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order + either statically or dynamically; added missing #include + in library. + 2002-03-11 lpd Corrected argument list for main(), and added int return + type, in test program and T value program. + 2002-02-21 lpd Added missing #include in test program. + 2000-07-03 lpd Patched to eliminate warnings about "constant is + unsigned in ANSI C, signed in traditional"; made test program + self-checking. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5). + 1999-05-03 lpd Original version. + */ + +#include "md5.h" +#include + +#undef BYTE_ORDER /* 1 = big-endian, -1 = little-endian, 0 = unknown */ +#ifdef ARCH_IS_BIG_ENDIAN +# define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1) +#else +# define BYTE_ORDER 0 +#endif + +#define T_MASK ((md5_word_t)~0) +#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87) +#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9) +#define T3 0x242070db +#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111) +#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050) +#define T6 0x4787c62a +#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec) +#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe) +#define T9 0x698098d8 +#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850) +#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e) +#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841) +#define T13 0x6b901122 +#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c) +#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71) +#define T16 0x49b40821 +#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d) +#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf) +#define T19 0x265e5a51 +#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855) +#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2) +#define T22 0x02441453 +#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e) +#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437) +#define T25 0x21e1cde6 +#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829) +#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278) +#define T28 0x455a14ed +#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa) +#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07) +#define T31 0x676f02d9 +#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375) +#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd) +#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e) +#define T35 0x6d9d6122 +#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3) +#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb) +#define T38 0x4bdecfa9 +#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f) +#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f) +#define T41 0x289b7ec6 +#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805) +#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a) +#define T44 0x04881d05 +#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6) +#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a) +#define T47 0x1fa27cf8 +#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a) +#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb) +#define T50 0x432aff97 +#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58) +#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6) +#define T53 0x655b59c3 +#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d) +#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82) +#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e) +#define T57 0x6fa87e4f +#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f) +#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb) +#define T60 0x4e0811a1 +#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d) +#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca) +#define T63 0x2ad7d2bb +#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e) + + +static void +md5_process(md5_state_t* pms, const md5_byte_t* data /*[64]*/) +{ + md5_word_t + a = pms->abcd[0], b = pms->abcd[1], + c = pms->abcd[2], d = pms->abcd[3]; + md5_word_t t; +#if BYTE_ORDER > 0 + /* Define storage only for big-endian CPUs. */ + md5_word_t X[16]; +#else + /* Define storage for little-endian or both types of CPUs. */ + md5_word_t xbuf[16]; + const md5_word_t* X; +#endif + + { +#if BYTE_ORDER == 0 + /* + * Determine dynamically whether this is a big-endian or + * little-endian machine, since we can use a more efficient + * algorithm on the latter. + */ + static const int w = 1; + + if (*((const md5_byte_t*)&w)) /* dynamic little-endian */ +#endif +#if BYTE_ORDER <= 0 /* little-endian */ + { + /* + * On little-endian machines, we can process properly aligned + * data without copying it. + */ + if (!((data - (const md5_byte_t*)0) & 3)) { + /* data are properly aligned */ + X = (const md5_word_t*)data; + } + else { + /* not aligned */ + memcpy(xbuf, data, 64); + X = xbuf; + } + } +#endif +#if BYTE_ORDER == 0 + else /* dynamic big-endian */ +#endif +#if BYTE_ORDER >= 0 /* big-endian */ + { + /* + * On big-endian machines, we must arrange the bytes in the + * right order. + */ + const md5_byte_t* xp = data; + int i; + +# if BYTE_ORDER == 0 + X = xbuf; /* (dynamic only) */ +# else +# define xbuf X /* (static only) */ +# endif + for (i = 0; i < 16; ++i, xp += 4) + xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); + } +#endif + } + +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) + + /* Round 1. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */ +#define F(x, y, z) (((x) & (y)) | (~(x) & (z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + F(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 7, T1); + SET(d, a, b, c, 1, 12, T2); + SET(c, d, a, b, 2, 17, T3); + SET(b, c, d, a, 3, 22, T4); + SET(a, b, c, d, 4, 7, T5); + SET(d, a, b, c, 5, 12, T6); + SET(c, d, a, b, 6, 17, T7); + SET(b, c, d, a, 7, 22, T8); + SET(a, b, c, d, 8, 7, T9); + SET(d, a, b, c, 9, 12, T10); + SET(c, d, a, b, 10, 17, T11); + SET(b, c, d, a, 11, 22, T12); + SET(a, b, c, d, 12, 7, T13); + SET(d, a, b, c, 13, 12, T14); + SET(c, d, a, b, 14, 17, T15); + SET(b, c, d, a, 15, 22, T16); +#undef SET + + /* Round 2. */ + /* Let [abcd k s i] denote the operation + a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */ +#define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + G(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 1, 5, T17); + SET(d, a, b, c, 6, 9, T18); + SET(c, d, a, b, 11, 14, T19); + SET(b, c, d, a, 0, 20, T20); + SET(a, b, c, d, 5, 5, T21); + SET(d, a, b, c, 10, 9, T22); + SET(c, d, a, b, 15, 14, T23); + SET(b, c, d, a, 4, 20, T24); + SET(a, b, c, d, 9, 5, T25); + SET(d, a, b, c, 14, 9, T26); + SET(c, d, a, b, 3, 14, T27); + SET(b, c, d, a, 8, 20, T28); + SET(a, b, c, d, 13, 5, T29); + SET(d, a, b, c, 2, 9, T30); + SET(c, d, a, b, 7, 14, T31); + SET(b, c, d, a, 12, 20, T32); +#undef SET + + /* Round 3. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */ +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + H(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 5, 4, T33); + SET(d, a, b, c, 8, 11, T34); + SET(c, d, a, b, 11, 16, T35); + SET(b, c, d, a, 14, 23, T36); + SET(a, b, c, d, 1, 4, T37); + SET(d, a, b, c, 4, 11, T38); + SET(c, d, a, b, 7, 16, T39); + SET(b, c, d, a, 10, 23, T40); + SET(a, b, c, d, 13, 4, T41); + SET(d, a, b, c, 0, 11, T42); + SET(c, d, a, b, 3, 16, T43); + SET(b, c, d, a, 6, 23, T44); + SET(a, b, c, d, 9, 4, T45); + SET(d, a, b, c, 12, 11, T46); + SET(c, d, a, b, 15, 16, T47); + SET(b, c, d, a, 2, 23, T48); +#undef SET + + /* Round 4. */ + /* Let [abcd k s t] denote the operation + a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */ +#define I(x, y, z) ((y) ^ ((x) | ~(z))) +#define SET(a, b, c, d, k, s, Ti)\ + t = a + I(b,c,d) + X[k] + Ti;\ + a = ROTATE_LEFT(t, s) + b + /* Do the following 16 operations. */ + SET(a, b, c, d, 0, 6, T49); + SET(d, a, b, c, 7, 10, T50); + SET(c, d, a, b, 14, 15, T51); + SET(b, c, d, a, 5, 21, T52); + SET(a, b, c, d, 12, 6, T53); + SET(d, a, b, c, 3, 10, T54); + SET(c, d, a, b, 10, 15, T55); + SET(b, c, d, a, 1, 21, T56); + SET(a, b, c, d, 8, 6, T57); + SET(d, a, b, c, 15, 10, T58); + SET(c, d, a, b, 6, 15, T59); + SET(b, c, d, a, 13, 21, T60); + SET(a, b, c, d, 4, 6, T61); + SET(d, a, b, c, 11, 10, T62); + SET(c, d, a, b, 2, 15, T63); + SET(b, c, d, a, 9, 21, T64); +#undef SET + + /* Then perform the following additions. (That is increment each + of the four registers by the value it had before this block + was started.) */ + pms->abcd[0] += a; + pms->abcd[1] += b; + pms->abcd[2] += c; + pms->abcd[3] += d; +} + +void +md5_init(md5_state_t* pms) +{ + pms->count[0] = pms->count[1] = 0; + pms->abcd[0] = 0x67452301; + pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476; + pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301; + pms->abcd[3] = 0x10325476; +} + +void +md5_append(md5_state_t* pms, const md5_byte_t* data, int nbytes) +{ + const md5_byte_t* p = data; + int left = nbytes; + int offset = (pms->count[0] >> 3) & 63; + md5_word_t nbits = (md5_word_t)(nbytes << 3); + + if (nbytes <= 0) + return; + + /* Update the message length. */ + pms->count[1] += nbytes >> 29; + pms->count[0] += nbits; + if (pms->count[0] < nbits) + pms->count[1]++; + + /* Process an initial partial block. */ + if (offset) { + int copy = (offset + nbytes > 64 ? 64 - offset : nbytes); + + memcpy(pms->buf + offset, p, copy); + if (offset + copy < 64) + return; + p += copy; + left -= copy; + md5_process(pms, pms->buf); + } + + /* Process full blocks. */ + for (; left >= 64; p += 64, left -= 64) + md5_process(pms, p); + + /* Process a final partial block. */ + if (left) + memcpy(pms->buf, p, left); +} + +void +md5_finish(md5_state_t* pms, md5_byte_t digest[16]) +{ + static const md5_byte_t pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 + }; + md5_byte_t data[8]; + int i; + + /* Save the length before padding. */ + for (i = 0; i < 8; ++i) + data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3)); + /* Pad to 56 bytes mod 64. */ + md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); + /* Append the length. */ + md5_append(pms, data, 8); + for (i = 0; i < 16; ++i) + digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3)); +} + +md5_byte_t* +md5Hash(md5_byte_t* in, int size) { + md5_state_t state; + md5_byte_t digest[16]; + + md5_init(&state); + md5_append(&state, in, size); + md5_finish(&state, digest); + + return digest; +} \ No newline at end of file diff --git a/hash/md5.h b/hash/md5.h new file mode 100644 index 0000000..0b6890f --- /dev/null +++ b/hash/md5.h @@ -0,0 +1,86 @@ +/* + Copyright (C) 1999, 2002 Aladdin Enterprises. All rights reserved. + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + L. Peter Deutsch + ghost@aladdin.com + */ + /* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */ + /* + Independent implementation of MD5 (RFC 1321). + This code implements the MD5 Algorithm defined in RFC 1321, whose + text is available at + http://www.ietf.org/rfc/rfc1321.txt + The code is derived from the text of the RFC, including the test suite + (section A.5) but excluding the rest of Appendix A. It does not include + any code or documentation that is identified in the RFC as being + copyrighted. + The original and principal author of md5.h is L. Peter Deutsch + . Other authors are noted in the change history + that follows (in reverse chronological order): + 2002-04-13 lpd Removed support for non-ANSI compilers; removed + references to Ghostscript; clarified derivation from RFC 1321; + now handles byte order either statically or dynamically. + 1999-11-04 lpd Edited comments slightly for automatic TOC extraction. + 1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5); + added conditionalization for C++ compilation from Martin + Purschke . + 1999-05-03 lpd Original version. + */ + +#ifndef md5_INCLUDED +# define md5_INCLUDED + + /* + * This package supports both compile-time and run-time determination of CPU + * byte order. If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be + * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is + * defined as non-zero, the code will be compiled to run only on big-endian + * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to + * run on either big- or little-endian CPUs, but will run slightly less + * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined. + */ + +typedef unsigned char md5_byte_t; /* 8-bit byte */ +typedef unsigned int md5_word_t; /* 32-bit word */ + +/* Define the state of the MD5 Algorithm. */ +typedef struct md5_state_s { + md5_word_t count[2]; /* message length in bits, lsw first */ + md5_word_t abcd[4]; /* digest buffer */ + md5_byte_t buf[64]; /* accumulate block */ +} md5_state_t; + +#ifdef __cplusplus +extern "C" +{ +#endif + + /* Initialize the algorithm. */ + void md5_init(md5_state_t* pms); + + /* Append a string to the message. */ + void md5_append(md5_state_t* pms, const md5_byte_t* data, int nbytes); + + /* Finish the message and return the digest. */ + void md5_finish(md5_state_t* pms, md5_byte_t digest[16]); + + /* Use Algorithm*/ + md5_byte_t* md5Hash(md5_byte_t* in, int size); + +#ifdef __cplusplus +} /* end extern "C" */ +#endif + +#endif /* md5_INCLUDED */ \ No newline at end of file