stormlib 1.0.0 → 1.0.1

data/ext/stormlib/StormLib/src/SFileVerify.cpp

@@ -0,0 +1,1059 @@
+/*****************************************************************************/
+/* SFileVerify.cpp                        Copyright (c) Ladislav Zezula 2010 */
+/*---------------------------------------------------------------------------*/
+/* MPQ files and MPQ archives verification.                                  */
+/*                                                                           */
+/* The MPQ signature verification has been written by Jean-Francois Roy      */
+/* <bahamut@macstorm.org> and Justin Olbrantz (Quantam).                     */
+/* The MPQ public keys have been created by MPQKit, using OpenSSL library.   */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/*   Date    Ver   Who  Comment                                              */
+/* --------  ----  ---  -------                                              */
+/* 04.05.10  1.00  Lad  The first version of SFileVerify.cpp                 */
+/*****************************************************************************/
+
+#define __STORMLIB_SELF__
+#include "StormLib.h"
+#include "StormCommon.h"
+
+//-----------------------------------------------------------------------------
+// Local defines
+
+#define MPQ_DIGEST_UNIT_SIZE      0x10000
+
+//-----------------------------------------------------------------------------
+// Known Blizzard public keys
+// Created by Jean-Francois Roy using OpenSSL
+
+static const char * szBlizzardWeakPrivateKey =
+    "-----BEGIN PRIVATE KEY-----"
+    "MIIBOQIBAAJBAJJidwS/uILMBSO5DLGsBFknIXWWjQJe2kfdfEk3G/j66w4KkhZ1"
+    "V61Rt4zLaMVCYpDun7FLwRjkMDSepO1q2DcCAwEAAQJANtiztVDMJh2hE1hjPDKy"
+    "UmEJ9U/aN3gomuKOjbQbQ/bWWcM/WfhSVHmPqtqh/bQI2UXFr0rnXngeteZHLr/b"
+    "8QIhAMuWriSKGMACw18/rVVfUrThs915odKBH1Alr3vMVVzZAiEAuBHPSQkgwcb6"
+    "L4MWaiKuOzq08mSyNqPeN8oSy18q848CIHeMn+3s+eOmu7su1UYQl6yH7OrdBd1q"
+    "3UxfFNEJiAbhAiAqxdCyOxHGlbM7aS3DOg3cq5ayoN2cvtV7h1R4t8OmVwIgF+5z"
+    "/6vkzBUsZhd8Nwyis+MeQYH0rpFpMKdTlqmPF2Q="
+    "-----END PRIVATE KEY-----";
+
+static const char * szBlizzardWeakPublicKey =
+    "-----BEGIN PUBLIC KEY-----"
+    "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJJidwS/uILMBSO5DLGsBFknIXWWjQJe"
+    "2kfdfEk3G/j66w4KkhZ1V61Rt4zLaMVCYpDun7FLwRjkMDSepO1q2DcCAwEAAQ=="
+    "-----END PUBLIC KEY-----";
+
+static const char * szBlizzardStrongPublicKey =
+    "-----BEGIN PUBLIC KEY-----"
+    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsQZ+ziT2h8h+J/iMQpgd"
+    "tH1HaJzOBE3agjU4yMPcrixaPOZoA4t8bwfey7qczfWywocYo3pleytFF+IuD4HD"
+    "Fl9OXN1SFyupSgMx1EGZlgbFAomnbq9MQJyMqQtMhRAjFgg4TndS7YNb+JMSAEKp"
+    "kXNqY28n/EVBHD5TsMuVCL579gIenbr61dI92DDEdy790IzIG0VKWLh/KOTcTJfm"
+    "Ds/7HQTkGouVW+WUsfekuqNQo7ND9DBnhLjLjptxeFE2AZqYcA1ao3S9LN3GL1tW"
+    "lVXFIX9c7fWqaVTQlZ2oNsI/ARVApOK3grNgqvwH6YoVYVXjNJEo5sQJsPsdV/hk"
+    "dwIDAQAB"
+    "-----END PUBLIC KEY-----";
+
+static const char * szWarcraft3MapPublicKey =
+    "-----BEGIN PUBLIC KEY-----"
+    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA1BwklUUQ3UvjizOBRoF5"
+    "yyOVc7KD+oGOQH5i6eUk1yfs0luCC70kNucNrfqhmviywVtahRse1JtXCPrx2bd3"
+    "iN8Dx91fbkxjYIOGTsjYoHKTp0BbaFkJih776fcHgnFSb+7mJcDuJVvJOXxEH6w0"
+    "1vo6VtujCqj1arqbyoal+xtAaczF3us5cOEp45sR1zAWTn1+7omN7VWV4QqJPaDS"
+    "gBSESc0l1grO0i1VUSumayk7yBKIkb+LBvcG6WnYZHCi7VdLmaxER5m8oZfER66b"
+    "heHoiSQIZf9PAY6Guw2DT5BTc54j/AaLQAKf2qcRSgQLVo5kQaddF3rCpsXoB/74"
+    "6QIDAQAB"
+    "-----END PUBLIC KEY-----";
+
+static const char * szWowPatchPublicKey =
+    "-----BEGIN PUBLIC KEY-----"
+    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwOsMV0LagAWPEtEQM6b9"
+    "6FHFkUyGbbyda2/Dfc9dyl21E9QvX+Yw7qKRMAKPzA2TlQQLZKvXpnKXF/YIK5xa"
+    "5uwg9CEHCEAYolLG4xn0FUOE0E/0PuuytI0p0ICe6rk00PifZzTr8na2wI/l/GnQ"
+    "bvnIVF1ck6cslATpQJ5JJVMXzoFlUABS19WESw4MXuJAS3AbMhxNWdEhVv7eO51c"
+    "yGjRLy9QjogZODZTY0fSEksgBqQxNCoYVJYI/sF5K2flDsGqrIp0OdJ6teJlzg1Y"
+    "UjYnb6bKjlidXoHEXI2TgA/mD6O3XFIt08I9s3crOCTgICq7cgX35qrZiIVWZdRv"
+    "TwIDAQAB"
+    "-----END PUBLIC KEY-----";
+
+static const char * szWowSurveyPublicKey =
+    "-----BEGIN PUBLIC KEY-----"
+    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnIt1DR6nRyyKsy2qahHe"
+    "MKLtacatn/KxieHcwH87wLBxKy+jZ0gycTmJ7SaTdBAEMDs/V5IPIXEtoqYnid2c"
+    "63TmfGDU92oc3Ph1PWUZ2PWxBhT06HYxRdbrgHw9/I29pNPi/607x+lzPORITOgU"
+    "BR6MR8au8HsQP4bn4vkJNgnSgojh48/XQOB/cAln7As1neP61NmVimoLR4Bwi3zt"
+    "zfgrZaUpyeNCUrOYJmH09YIjbBySTtXOUidoPHjFrMsCWpr6xs8xbETbs7MJFL6a"
+    "vcUfTT67qfIZ9RsuKfnXJTIrV0kwDSjjuNXiPTmWAehSsiHIsrUXX5RNcwsSjClr"
+    "nQIDAQAB"
+    "-----END PUBLIC KEY-----";
+
+static const char * szStarcraft2MapPublicKey =
+    "-----BEGIN PUBLIC KEY-----"
+    "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmk4GT8zb+ICC25a17KZB"
+    "q/ygKGJ2VSO6IT5PGHJlm1KfnHBA4B6SH3xMlJ4c6eG2k7QevZv+FOhjsAHubyWq"
+    "2VKqWbrIFKv2ILc2RfMn8J9EDVRxvcxh6slRrVL69D0w1tfVGjMiKq2Fym5yGoRT"
+    "E7CRgDqbAbXP9LBsCNWHiJLwfxMGzHbk8pIl9oia5pvM7ofZamSHchxlpy6xa4GJ"
+    "7xKN01YCNvklTL1D7uol3wkwcHc7vrF8QwuJizuA5bSg4poEGtH62BZOYi+UL/z0"
+    "31YK+k9CbQyM0X0pJoJoYz1TK+Y5J7vBnXCZtfcTYQ/ZzN6UcxTa57dJaiOlCh9z"
+    "nQIDAQAB"
+    "-----END PUBLIC KEY-----";
+
+//-----------------------------------------------------------------------------
+// Local functions
+
+static void memrev(unsigned char *buf, size_t count)
+{
+    unsigned char *r;
+
+    for (r = buf + count - 1; buf < r; buf++, r--)
+    {
+        *buf ^= *r;
+        *r   ^= *buf;
+        *buf ^= *r;
+    }
+}
+
+static bool decode_base64_key(const char * szKeyBase64, rsa_key * key)
+{
+    unsigned char decoded_key[0x200];
+    const char * szBase64Begin;
+    const char * szBase64End;
+    unsigned long decoded_length = sizeof(decoded_key);
+    unsigned long length;
+
+    // Find out the begin of the BASE64 data
+    szBase64Begin = szKeyBase64 + strlen("-----BEGIN PUBLIC KEY-----");
+    szBase64End   = szBase64Begin + strlen(szBase64Begin) - strlen("-----END PUBLIC KEY-----");
+    if(szBase64End[0] != '-')
+        return false;
+
+    // decode the base64 string
+    length = (unsigned long)(szBase64End - szBase64Begin);
+    if(base64_decode((unsigned char *)szBase64Begin, length, decoded_key, &decoded_length) != CRYPT_OK)
+        return false;
+
+    // Create RSA key
+    if(rsa_import(decoded_key, decoded_length, key) != CRYPT_OK)
+        return false;
+
+    return true;
+}
+
+static void GetPlainAnsiFileName(
+    const TCHAR * szFileName,
+    char * szPlainName)
+{
+    const TCHAR * szPlainNameT = GetPlainFileName(szFileName);
+
+    // Convert the plain name to ANSI
+    while(*szPlainNameT != 0)
+        *szPlainName++ = (char)*szPlainNameT++;
+    *szPlainName = 0;
+}
+
+// Calculate begin and end of the MPQ archive
+static void CalculateArchiveRange(
+    TMPQArchive * ha,
+    PMPQ_SIGNATURE_INFO pSI)
+{
+    ULONGLONG TempPos = 0;
+    char szMapHeader[0x200];
+
+    // Get the MPQ begin
+    pSI->BeginMpqData = ha->MpqPos;
+
+    // Warcraft III maps are signed from the map header to the end
+    if(FileStream_Read(ha->pStream, &TempPos, szMapHeader, sizeof(szMapHeader)))
+    {
+        // Is it a map header ?
+        if(szMapHeader[0] == 'H' && szMapHeader[1] == 'M' && szMapHeader[2] == '3' && szMapHeader[3] == 'W')
+        {
+            // We will have to hash since the map header
+            pSI->BeginMpqData = 0;
+        }
+    }
+
+    // Get the MPQ data end. This is stored in the MPQ header
+    pSI->EndMpqData = ha->MpqPos + ha->pHeader->ArchiveSize64;
+
+    // Get the size of the entire file
+    FileStream_GetSize(ha->pStream, &pSI->EndOfFile);
+}
+
+static bool CalculateMpqHashMd5(
+    TMPQArchive * ha,
+    PMPQ_SIGNATURE_INFO pSI,
+    LPBYTE pMd5Digest)
+{
+    hash_state md5_state;
+    ULONGLONG BeginBuffer;
+    ULONGLONG EndBuffer;
+    LPBYTE pbDigestBuffer = NULL;
+
+    // Allocate buffer for creating the MPQ digest.
+    pbDigestBuffer = STORM_ALLOC(BYTE, MPQ_DIGEST_UNIT_SIZE);
+    if(pbDigestBuffer == NULL)
+        return false;
+
+    // Initialize the MD5 hash state
+    md5_init(&md5_state);
+
+    // Set the byte offset of begin of the data
+    BeginBuffer = pSI->BeginMpqData;
+
+    // Create the digest
+    for(;;)
+    {
+        ULONGLONG BytesRemaining;
+        LPBYTE pbSigBegin = NULL;
+        LPBYTE pbSigEnd = NULL;
+        DWORD dwToRead = MPQ_DIGEST_UNIT_SIZE;
+
+        // Check the number of bytes remaining
+        BytesRemaining = pSI->EndMpqData - BeginBuffer;
+        if(BytesRemaining < MPQ_DIGEST_UNIT_SIZE)
+            dwToRead = (DWORD)BytesRemaining;
+        if(dwToRead == 0)
+            break;
+
+        // Read the next chunk
+        if(!FileStream_Read(ha->pStream, &BeginBuffer, pbDigestBuffer, dwToRead))
+        {
+            STORM_FREE(pbDigestBuffer);
+            return false;
+        }
+
+        // Move the current byte offset
+        EndBuffer = BeginBuffer + dwToRead;
+
+        // Check if the signature is within the loaded digest
+        if(BeginBuffer <= pSI->BeginExclude && pSI->BeginExclude < EndBuffer)
+            pbSigBegin = pbDigestBuffer + (size_t)(pSI->BeginExclude - BeginBuffer);
+        if(BeginBuffer <= pSI->EndExclude && pSI->EndExclude < EndBuffer)
+            pbSigEnd = pbDigestBuffer + (size_t)(pSI->EndExclude - BeginBuffer);
+
+        // Zero the part that belongs to the signature
+        if(pbSigBegin != NULL || pbSigEnd != NULL)
+        {
+            if(pbSigBegin == NULL)
+                pbSigBegin = pbDigestBuffer;
+            if(pbSigEnd == NULL)
+                pbSigEnd = pbDigestBuffer + dwToRead;
+
+            memset(pbSigBegin, 0, (pbSigEnd - pbSigBegin));
+        }
+
+        // Pass the buffer to the hashing function
+        md5_process(&md5_state, pbDigestBuffer, dwToRead);
+
+        // Move pointers
+        BeginBuffer += dwToRead;
+    }
+
+    // Finalize the MD5 hash
+    md5_done(&md5_state, pMd5Digest);
+    STORM_FREE(pbDigestBuffer);
+    return true;
+}
+
+static void AddTailToSha1(
+    hash_state * psha1_state,
+    const char * szTail)
+{
+    unsigned char * pbTail = (unsigned char *)szTail;
+    unsigned char szUpperCase[0x200];
+    unsigned long nLength = 0;
+
+    // Convert the tail to uppercase
+    // Note that we don't need to terminate the string with zero
+    while(*pbTail != 0)
+    {
+        szUpperCase[nLength++] = AsciiToUpperTable[*pbTail++];
+    }
+
+    // Append the tail to the SHA1
+    sha1_process(psha1_state, szUpperCase, nLength);
+}
+
+static bool CalculateMpqHashSha1(
+    TMPQArchive * ha,
+    PMPQ_SIGNATURE_INFO pSI,
+    unsigned char * sha1_tail0,
+    unsigned char * sha1_tail1,
+    unsigned char * sha1_tail2)
+{
+    ULONGLONG BeginBuffer;
+    hash_state sha1_state_temp;
+    hash_state sha1_state;
+    LPBYTE pbDigestBuffer = NULL;
+    char szPlainName[MAX_PATH];
+
+    // Allocate buffer for creating the MPQ digest.
+    pbDigestBuffer = STORM_ALLOC(BYTE, MPQ_DIGEST_UNIT_SIZE);
+    if(pbDigestBuffer == NULL)
+        return false;
+
+    // Initialize SHA1 state structure
+    sha1_init(&sha1_state);
+
+    // Calculate begin of data to be hashed
+    BeginBuffer = pSI->BeginMpqData;
+
+    // Create the digest
+    for(;;)
+    {
+        ULONGLONG BytesRemaining;
+        DWORD dwToRead = MPQ_DIGEST_UNIT_SIZE;
+
+        // Check the number of bytes remaining
+        BytesRemaining = pSI->EndMpqData - BeginBuffer;
+        if(BytesRemaining < MPQ_DIGEST_UNIT_SIZE)
+            dwToRead = (DWORD)BytesRemaining;
+        if(dwToRead == 0)
+            break;
+
+        // Read the next chunk
+        if(!FileStream_Read(ha->pStream, &BeginBuffer, pbDigestBuffer, dwToRead))
+        {
+            STORM_FREE(pbDigestBuffer);
+            return false;
+        }
+
+        // Pass the buffer to the hashing function
+        sha1_process(&sha1_state, pbDigestBuffer, dwToRead);
+
+        // Move pointers
+        BeginBuffer += dwToRead;
+    }
+
+    // Add all three known tails and generate three hashes
+    memcpy(&sha1_state_temp, &sha1_state, sizeof(hash_state));
+    sha1_done(&sha1_state_temp, sha1_tail0);
+
+    memcpy(&sha1_state_temp, &sha1_state, sizeof(hash_state));
+    GetPlainAnsiFileName(FileStream_GetFileName(ha->pStream), szPlainName);
+    AddTailToSha1(&sha1_state_temp, szPlainName);
+    sha1_done(&sha1_state_temp, sha1_tail1);
+
+    memcpy(&sha1_state_temp, &sha1_state, sizeof(hash_state));
+    AddTailToSha1(&sha1_state_temp, "ARCHIVE");
+    sha1_done(&sha1_state_temp, sha1_tail2);
+
+    // Finalize the MD5 hash
+    STORM_FREE(pbDigestBuffer);
+    return true;
+}
+
+static DWORD VerifyRawMpqData(
+    TMPQArchive * ha,
+    ULONGLONG ByteOffset,
+    DWORD dwDataSize)
+{
+    ULONGLONG DataOffset = ha->MpqPos + ByteOffset;
+    LPBYTE pbDataChunk;
+    LPBYTE pbMD5Array1;                 // Calculated MD5 array
+    LPBYTE pbMD5Array2;                 // MD5 array loaded from the MPQ
+    DWORD dwBytesInChunk;
+    DWORD dwChunkCount;
+    DWORD dwChunkSize = ha->pHeader->dwRawChunkSize;
+    DWORD dwMD5Size;
+    DWORD dwErrCode = ERROR_SUCCESS;
+
+    // Don't verify zero-sized blocks
+    if(dwDataSize == 0)
+        return ERROR_SUCCESS;
+
+    // Get the number of data chunks to calculate MD5
+    assert(dwChunkSize != 0);
+    dwChunkCount = ((dwDataSize - 1) / dwChunkSize) + 1;
+    dwMD5Size = dwChunkCount * MD5_DIGEST_SIZE;
+
+    // Allocate space for data chunk and for the MD5 array
+    pbDataChunk = STORM_ALLOC(BYTE, dwChunkSize);
+    if(pbDataChunk == NULL)
+        return ERROR_NOT_ENOUGH_MEMORY;
+
+    // Allocate space for MD5 array
+    pbMD5Array1 = STORM_ALLOC(BYTE, dwMD5Size);
+    pbMD5Array2 = STORM_ALLOC(BYTE, dwMD5Size);
+    if(pbMD5Array1 == NULL || pbMD5Array2 == NULL)
+        dwErrCode = ERROR_NOT_ENOUGH_MEMORY;
+
+    // Calculate MD5 of each data chunk
+    if(dwErrCode == ERROR_SUCCESS)
+    {
+        LPBYTE pbMD5 = pbMD5Array1;
+
+        for(DWORD i = 0; i < dwChunkCount; i++)
+        {
+            // Get the number of bytes in the chunk
+            dwBytesInChunk = STORMLIB_MIN(dwChunkSize, dwDataSize);
+
+            // Read the data chunk
+            if(!FileStream_Read(ha->pStream, &DataOffset, pbDataChunk, dwBytesInChunk))
+            {
+                dwErrCode = ERROR_FILE_CORRUPT;
+                break;
+            }
+
+            // Calculate MD5
+            CalculateDataBlockHash(pbDataChunk, dwBytesInChunk, pbMD5);
+
+            // Move pointers and offsets
+            DataOffset += dwBytesInChunk;
+            dwDataSize -= dwBytesInChunk;
+            pbMD5 += MD5_DIGEST_SIZE;
+        }
+    }
+
+    // Read the MD5 array
+    if(dwErrCode == ERROR_SUCCESS)
+    {
+        // Read the array of MD5
+        if(!FileStream_Read(ha->pStream, &DataOffset, pbMD5Array2, dwMD5Size))
+            dwErrCode = GetLastError();
+    }
+
+    // Compare the array of MD5
+    if(dwErrCode == ERROR_SUCCESS)
+    {
+        // Compare the MD5
+        if(memcmp(pbMD5Array1, pbMD5Array2, dwMD5Size))
+            dwErrCode = ERROR_FILE_CORRUPT;
+    }
+
+    // Free memory and return result
+    if(pbMD5Array2 != NULL)
+        STORM_FREE(pbMD5Array2);
+    if(pbMD5Array1 != NULL)
+        STORM_FREE(pbMD5Array1);
+    if(pbDataChunk != NULL)
+        STORM_FREE(pbDataChunk);
+    return dwErrCode;
+}
+
+static DWORD VerifyWeakSignature(
+    TMPQArchive * ha,
+    PMPQ_SIGNATURE_INFO pSI)
+{
+    BYTE RevSignature[MPQ_WEAK_SIGNATURE_SIZE];
+    BYTE Md5Digest[MD5_DIGEST_SIZE];
+    rsa_key key;
+    int hash_idx = find_hash("md5");
+    int result = 0;
+
+    // The signature might be zeroed out. In that case, we ignore it
+    if(!IsValidSignature(pSI->Signature))
+        return ERROR_WEAK_SIGNATURE_OK;
+
+    // Calculate hash of the entire archive, skipping the (signature) file
+    if(!CalculateMpqHashMd5(ha, pSI, Md5Digest))
+        return ERROR_VERIFY_FAILED;
+
+    // Import the Blizzard key in OpenSSL format
+    if(!decode_base64_key(szBlizzardWeakPublicKey, &key))
+        return ERROR_VERIFY_FAILED;
+
+    // Verify the signature
+    memcpy(RevSignature, &pSI->Signature[8], MPQ_WEAK_SIGNATURE_SIZE);
+    memrev(RevSignature, MPQ_WEAK_SIGNATURE_SIZE);
+    rsa_verify_hash_ex(RevSignature, MPQ_WEAK_SIGNATURE_SIZE, Md5Digest, sizeof(Md5Digest), LTC_LTC_PKCS_1_V1_5, hash_idx, 0, &result, &key);
+    rsa_free(&key);
+
+    // Return the result
+    return result ? ERROR_WEAK_SIGNATURE_OK : ERROR_WEAK_SIGNATURE_ERROR;
+}
+
+static DWORD VerifyStrongSignatureWithKey(
+    unsigned char * reversed_signature,
+    unsigned char * padded_digest,
+    const char * szPublicKey)
+{
+    rsa_key key;
+    int result = 0;
+
+    // Import the Blizzard key in OpenSSL format
+    if(!decode_base64_key(szPublicKey, &key))
+    {
+        assert(false);
+        return ERROR_VERIFY_FAILED;
+    }
+
+    // Verify the signature
+    if(rsa_verify_simple(reversed_signature, MPQ_STRONG_SIGNATURE_SIZE, padded_digest, MPQ_STRONG_SIGNATURE_SIZE, &result, &key) != CRYPT_OK)
+        return ERROR_VERIFY_FAILED;
+
+    // Free the key and return result
+    rsa_free(&key);
+    return result ? ERROR_STRONG_SIGNATURE_OK : ERROR_STRONG_SIGNATURE_ERROR;
+}
+
+static DWORD VerifyStrongSignature(
+    TMPQArchive * ha,
+    PMPQ_SIGNATURE_INFO pSI)
+{
+    unsigned char reversed_signature[MPQ_STRONG_SIGNATURE_SIZE];
+    unsigned char Sha1Digest_tail0[SHA1_DIGEST_SIZE];
+    unsigned char Sha1Digest_tail1[SHA1_DIGEST_SIZE];
+    unsigned char Sha1Digest_tail2[SHA1_DIGEST_SIZE];
+    unsigned char padded_digest[MPQ_STRONG_SIGNATURE_SIZE];
+    DWORD dwResult;
+    size_t digest_offset;
+
+    // Calculate SHA1 hash of the archive
+    if(!CalculateMpqHashSha1(ha, pSI, Sha1Digest_tail0, Sha1Digest_tail1, Sha1Digest_tail2))
+        return ERROR_VERIFY_FAILED;
+
+    // Prepare the signature for decryption
+    memcpy(reversed_signature, &pSI->Signature[4], MPQ_STRONG_SIGNATURE_SIZE);
+    memrev(reversed_signature, MPQ_STRONG_SIGNATURE_SIZE);
+
+    // Prepare the padded digest for comparison
+    digest_offset = sizeof(padded_digest) - SHA1_DIGEST_SIZE;
+    memset(padded_digest, 0xbb, digest_offset);
+    padded_digest[0] = 0x0b;
+
+    // Try Blizzard Strong public key with no SHA1 tail
+    memcpy(padded_digest + digest_offset, Sha1Digest_tail0, SHA1_DIGEST_SIZE);
+    memrev(padded_digest + digest_offset, SHA1_DIGEST_SIZE);
+    dwResult = VerifyStrongSignatureWithKey(reversed_signature, padded_digest, szBlizzardStrongPublicKey);
+    if(dwResult == ERROR_STRONG_SIGNATURE_OK)
+        return dwResult;
+
+    // Try War 3 map public key with plain file name as SHA1 tail
+    memcpy(padded_digest + digest_offset, Sha1Digest_tail1, SHA1_DIGEST_SIZE);
+    memrev(padded_digest + digest_offset, SHA1_DIGEST_SIZE);
+    dwResult = VerifyStrongSignatureWithKey(reversed_signature, padded_digest, szWarcraft3MapPublicKey);
+    if(dwResult == ERROR_STRONG_SIGNATURE_OK)
+        return dwResult;
+
+    // Try WoW-TBC public key with "ARCHIVE" as SHA1 tail
+    memcpy(padded_digest + digest_offset, Sha1Digest_tail2, SHA1_DIGEST_SIZE);
+    memrev(padded_digest + digest_offset, SHA1_DIGEST_SIZE);
+    dwResult = VerifyStrongSignatureWithKey(reversed_signature, padded_digest, szWowPatchPublicKey);
+    if(dwResult == ERROR_STRONG_SIGNATURE_OK)
+        return dwResult;
+
+    // Try Survey public key with no SHA1 tail
+    memcpy(padded_digest + digest_offset, Sha1Digest_tail0, SHA1_DIGEST_SIZE);
+    memrev(padded_digest + digest_offset, SHA1_DIGEST_SIZE);
+    dwResult = VerifyStrongSignatureWithKey(reversed_signature, padded_digest, szWowSurveyPublicKey);
+    if(dwResult == ERROR_STRONG_SIGNATURE_OK)
+        return dwResult;
+
+    // Try Starcraft II public key with no SHA1 tail
+    memcpy(padded_digest + digest_offset, Sha1Digest_tail0, SHA1_DIGEST_SIZE);
+    memrev(padded_digest + digest_offset, SHA1_DIGEST_SIZE);
+    dwResult = VerifyStrongSignatureWithKey(reversed_signature, padded_digest, szStarcraft2MapPublicKey);
+    if(dwResult == ERROR_STRONG_SIGNATURE_OK)
+        return dwResult;
+
+    return ERROR_STRONG_SIGNATURE_ERROR;
+}
+
+static DWORD VerifyFile(
+    HANDLE hMpq,
+    const char * szFileName,
+    LPDWORD pdwCrc32,
+    char * pMD5,
+    DWORD dwFlags)
+{
+    hash_state md5_state;
+    unsigned char * pFileMd5;
+    unsigned char md5[MD5_DIGEST_SIZE];
+    TFileEntry * pFileEntry;
+    TMPQFile * hf;
+    BYTE Buffer[0x1000];
+    HANDLE hFile = NULL;
+    DWORD dwVerifyResult = 0;
+    DWORD dwTotalBytes = 0;
+    DWORD dwCrc32 = 0;
+
+    //
+    // Note: When the MPQ is patched, it will
+    // automatically check the patched version of the file
+    //
+
+    // Make sure the md5 is initialized
+    memset(md5, 0, sizeof(md5));
+
+    // If we have to verify raw data MD5, do it before file open
+    if(dwFlags & SFILE_VERIFY_RAW_MD5)
+    {
+        TMPQArchive * ha = (TMPQArchive *)hMpq;
+
+        // Parse the base MPQ and all patches
+        while(ha != NULL)
+        {
+            // Does the archive have support for raw MD5?
+            if(ha->pHeader->dwRawChunkSize != 0)
+            {
+                // The file has raw MD5 if the archive supports it
+                dwVerifyResult |= VERIFY_FILE_HAS_RAW_MD5;
+
+                // Find file entry for the file
+                pFileEntry = GetFileEntryLocale(ha, szFileName, g_lcFileLocale);
+                if(pFileEntry != NULL)
+                {
+                    // If the file's raw MD5 doesn't match, don't bother with more checks
+                    if(VerifyRawMpqData(ha, pFileEntry->ByteOffset, pFileEntry->dwCmpSize) != ERROR_SUCCESS)
+                        return dwVerifyResult | VERIFY_FILE_RAW_MD5_ERROR;
+                }
+            }
+
+            // Move to the next patch
+            ha = ha->haPatch;
+        }
+    }
+
+    // Attempt to open the file
+    if(SFileOpenFileEx(hMpq, szFileName, SFILE_OPEN_FROM_MPQ, &hFile))
+    {
+        // Get the file size
+        hf = (TMPQFile *)hFile;
+        pFileEntry = hf->pFileEntry;
+        dwTotalBytes = SFileGetFileSize(hFile, NULL);
+
+        // Initialize the CRC32 and MD5 contexts
+        md5_init(&md5_state);
+        dwCrc32 = crc32(0, Z_NULL, 0);
+
+        // Also turn on sector checksum verification
+        if(dwFlags & SFILE_VERIFY_SECTOR_CRC)
+            hf->bCheckSectorCRCs = true;
+
+        // Go through entire file and update both CRC32 and MD5
+        for(;;)
+        {
+            DWORD dwBytesRead = 0;
+
+            // Read data from file
+            SFileReadFile(hFile, Buffer, sizeof(Buffer), &dwBytesRead, NULL);
+            if(dwBytesRead == 0)
+            {
+                if(GetLastError() == ERROR_CHECKSUM_ERROR)
+                    dwVerifyResult |= VERIFY_FILE_SECTOR_CRC_ERROR;
+                break;
+            }
+
+            // Update CRC32 value
+            if(dwFlags & SFILE_VERIFY_FILE_CRC)
+                dwCrc32 = crc32(dwCrc32, Buffer, dwBytesRead);
+
+            // Update MD5 value
+            if(dwFlags & SFILE_VERIFY_FILE_MD5)
+                md5_process(&md5_state, Buffer, dwBytesRead);
+
+            // Decrement the total size
+            dwTotalBytes -= dwBytesRead;
+        }
+
+        // If the file has sector checksums, indicate it in the flags
+        if(dwFlags & SFILE_VERIFY_SECTOR_CRC)
+        {
+            if((hf->pFileEntry->dwFlags & MPQ_FILE_SECTOR_CRC) && hf->SectorChksums != NULL && hf->SectorChksums[0] != 0)
+                dwVerifyResult |= VERIFY_FILE_HAS_SECTOR_CRC;
+        }
+
+        // Check if the entire file has been read
+        // No point in checking CRC32 and MD5 if not
+        // Skip checksum checks if the file has patches
+        if(dwTotalBytes == 0)
+        {
+            // Check CRC32 and MD5 only if there is no patches
+            if(hf->hfPatch == NULL)
+            {
+                // Check if the CRC32 matches.
+                if(dwFlags & SFILE_VERIFY_FILE_CRC)
+                {
+                    // Only check the CRC32 if it is valid
+                    if(pFileEntry->dwCrc32 != 0)
+                    {
+                        dwVerifyResult |= VERIFY_FILE_HAS_CHECKSUM;
+                        if(dwCrc32 != pFileEntry->dwCrc32)
+                            dwVerifyResult |= VERIFY_FILE_CHECKSUM_ERROR;
+                    }
+                }
+
+                // Check if MD5 matches
+                if(dwFlags & SFILE_VERIFY_FILE_MD5)
+                {
+                    // Patch files have their MD5 saved in the patch info
+                    pFileMd5 = (hf->pPatchInfo != NULL) ? hf->pPatchInfo->md5 : pFileEntry->md5;
+                    md5_done(&md5_state, md5);
+
+                    // Only check the MD5 if it is valid
+                    if(IsValidMD5(pFileMd5))
+                    {
+                        dwVerifyResult |= VERIFY_FILE_HAS_MD5;
+                        if(memcmp(md5, pFileMd5, MD5_DIGEST_SIZE))
+                            dwVerifyResult |= VERIFY_FILE_MD5_ERROR;
+                    }
+                }
+            }
+            else
+            {
+                // Patched files are MD5-checked automatically
+                dwVerifyResult |= VERIFY_FILE_HAS_MD5;
+            }
+        }
+        else
+        {
+            dwVerifyResult |= VERIFY_READ_ERROR;
+        }
+
+        SFileCloseFile(hFile);
+    }
+    else
+    {
+        // Remember that the file couldn't be open
+        dwVerifyResult |= VERIFY_OPEN_ERROR;
+    }
+
+    // If the caller required CRC32 and/or MD5, give it to him
+    if(pdwCrc32 != NULL)
+        *pdwCrc32 = dwCrc32;
+    if(pMD5 != NULL)
+        memcpy(pMD5, md5, MD5_DIGEST_SIZE);
+
+    return dwVerifyResult;
+}
+
+// Used in SFileGetFileInfo
+bool QueryMpqSignatureInfo(
+    TMPQArchive * ha,
+    PMPQ_SIGNATURE_INFO pSI)
+{
+    TFileEntry * pFileEntry;
+    ULONGLONG ExtraBytes;
+    DWORD dwFileSize;
+
+    // Make sure it's all zeroed
+    memset(pSI, 0, sizeof(MPQ_SIGNATURE_INFO));
+
+    // Flush the archive, if it was modified
+    if(ha->dwFlags & MPQ_FLAG_CHANGED)
+        SFileFlushArchive((HANDLE)(ha));
+
+    // Calculate the range of the MPQ
+    CalculateArchiveRange(ha, pSI);
+
+    // If there is "(signature)" file in the MPQ, it has a weak signature
+    pFileEntry = GetFileEntryLocale(ha, SIGNATURE_NAME, LANG_NEUTRAL);
+    if(pFileEntry != NULL)
+    {
+        // Calculate the begin and end of the signature file itself
+        pSI->BeginExclude = ha->MpqPos + pFileEntry->ByteOffset;
+        pSI->EndExclude = pSI->BeginExclude + pFileEntry->dwCmpSize;
+        dwFileSize = (DWORD)(pSI->EndExclude - pSI->BeginExclude);
+
+        // Does the signature have proper size?
+        if(dwFileSize == MPQ_SIGNATURE_FILE_SIZE)
+        {
+            // Read the weak signature
+            if(!FileStream_Read(ha->pStream, &pSI->BeginExclude, pSI->Signature, dwFileSize))
+                return false;
+
+            pSI->SignatureTypes |= SIGNATURE_TYPE_WEAK;
+            pSI->cbSignatureSize = dwFileSize;
+            return true;
+        }
+    }
+
+    // If there is extra bytes beyond the end of the archive,
+    // it's the strong signature
+    ExtraBytes = pSI->EndOfFile - pSI->EndMpqData;
+    if(ExtraBytes >= (MPQ_STRONG_SIGNATURE_SIZE + 4))
+    {
+        // Read the strong signature
+        if(!FileStream_Read(ha->pStream, &pSI->EndMpqData, pSI->Signature, (MPQ_STRONG_SIGNATURE_SIZE + 4)))
+            return false;
+
+        // Check the signature header "NGIS"
+        if(pSI->Signature[0] != 'N' || pSI->Signature[1] != 'G' || pSI->Signature[2] != 'I' || pSI->Signature[3] != 'S')
+            return true; //Not a valid signature, but another filetype could've been appended so not always an error.
+
+        pSI->SignatureTypes |= SIGNATURE_TYPE_STRONG;
+        return true;
+    }
+
+    // Succeeded, but no known signature found
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+// Support for weak signature
+
+DWORD SSignFileCreate(TMPQArchive * ha)
+{
+    TMPQFile * hf = NULL;
+    BYTE EmptySignature[MPQ_SIGNATURE_FILE_SIZE];
+    DWORD dwErrCode = ERROR_SUCCESS;
+
+    // Only save the signature if we should do so
+    if(ha->dwFileFlags3 != 0)
+    {
+        // The (signature) file must be non-encrypted and non-compressed
+        assert(ha->dwFlags & MPQ_FLAG_SIGNATURE_NEW);
+        assert(ha->dwFileFlags3 == MPQ_FILE_EXISTS);
+        assert(ha->dwReservedFiles > 0);
+
+        // Create the (signature) file file in the MPQ
+        // Note that the file must not be compressed or encrypted
+        dwErrCode = SFileAddFile_Init(ha, SIGNATURE_NAME,
+                                      0,
+                                      sizeof(EmptySignature),
+                                      LANG_NEUTRAL,
+                                      ha->dwFileFlags3 | MPQ_FILE_REPLACEEXISTING,
+                                     &hf);
+
+        // Write the empty signature file to the archive
+        if(dwErrCode == ERROR_SUCCESS)
+        {
+            // Write the empty zeroed file to the MPQ
+            memset(EmptySignature, 0, sizeof(EmptySignature));
+            dwErrCode = SFileAddFile_Write(hf, EmptySignature, (DWORD)sizeof(EmptySignature), 0);
+        }
+
+        // Finalize the signature
+        if(dwErrCode == ERROR_SUCCESS)
+        {
+            // Clear the CRC as it will not be valid
+            hf->pFileEntry->dwCrc32 = hf->dwCrc32 = 0;
+            SFileAddFile_Finish(hf);
+
+            // Clear the invalid mark
+            ha->dwFlags &= ~(MPQ_FLAG_SIGNATURE_NEW | MPQ_FLAG_SIGNATURE_NONE);
+            ha->dwReservedFiles--;
+        }
+    }
+
+    return dwErrCode;
+}
+
+DWORD SSignFileFinish(TMPQArchive * ha)
+{
+    MPQ_SIGNATURE_INFO si = {0};
+    unsigned long signature_len = MPQ_WEAK_SIGNATURE_SIZE;
+    BYTE WeakSignature[MPQ_SIGNATURE_FILE_SIZE];
+    BYTE Md5Digest[MD5_DIGEST_SIZE];
+    rsa_key key;
+    int hash_idx = find_hash("md5");
+
+    // Sanity checks
+    assert((ha->dwFlags & MPQ_FLAG_CHANGED) == 0);
+    assert(ha->dwFileFlags3 == MPQ_FILE_EXISTS);
+
+    // Query the weak signature info
+    if(!QueryMpqSignatureInfo(ha, &si))
+        return ERROR_FILE_CORRUPT;
+
+    // There must be exactly one signature
+    if(si.SignatureTypes != SIGNATURE_TYPE_WEAK)
+        return ERROR_FILE_CORRUPT;
+
+    // Calculate MD5 of the entire archive
+    if(!CalculateMpqHashMd5(ha, &si, Md5Digest))
+        return ERROR_VERIFY_FAILED;
+
+    // Decode the private key
+    if(!decode_base64_key(szBlizzardWeakPrivateKey, &key))
+        return ERROR_VERIFY_FAILED;
+
+    // Sign the hash
+    memset(WeakSignature, 0, sizeof(WeakSignature));
+    rsa_sign_hash_ex(Md5Digest, sizeof(Md5Digest), WeakSignature + 8, &signature_len, LTC_LTC_PKCS_1_V1_5, 0, 0, hash_idx, 0, &key);
+    memrev(WeakSignature + 8, MPQ_WEAK_SIGNATURE_SIZE);
+    rsa_free(&key);
+
+    // Write the signature to the MPQ. Don't use SFile* functions, but write the hash directly
+    if(!FileStream_Write(ha->pStream, &si.BeginExclude, WeakSignature, MPQ_SIGNATURE_FILE_SIZE))
+        return GetLastError();
+
+    return ERROR_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+// Public (exported) functions
+
+bool WINAPI SFileGetFileChecksums(HANDLE hMpq, const char * szFileName, LPDWORD pdwCrc32, char * pMD5)
+{
+    DWORD dwVerifyResult;
+    DWORD dwVerifyFlags = 0;
+
+    if(pdwCrc32 != NULL)
+        dwVerifyFlags |= SFILE_VERIFY_FILE_CRC;
+    if(pMD5 != NULL)
+        dwVerifyFlags |= SFILE_VERIFY_FILE_MD5;
+
+    dwVerifyResult = VerifyFile(hMpq,
+                                szFileName,
+                                pdwCrc32,
+                                pMD5,
+                                dwVerifyFlags);
+
+    // If verification failed, return zero
+    if(dwVerifyResult & VERIFY_FILE_ERROR_MASK)
+    {
+        SetLastError(ERROR_FILE_CORRUPT);
+        return false;
+    }
+
+    return true;
+}
+
+
+DWORD WINAPI SFileVerifyFile(HANDLE hMpq, const char * szFileName, DWORD dwFlags)
+{
+    return VerifyFile(hMpq,
+                      szFileName,
+                      NULL,
+                      NULL,
+                      dwFlags);
+}
+
+// Verifies raw data of the archive Only works for MPQs version 4 or newer
+DWORD WINAPI SFileVerifyRawData(HANDLE hMpq, DWORD dwWhatToVerify, const char * szFileName)
+{
+    TMPQArchive * ha = (TMPQArchive *)hMpq;
+    TFileEntry * pFileEntry;
+    TMPQHeader * pHeader;
+
+    // Verify input parameters
+    if(!IsValidMpqHandle(hMpq))
+        return ERROR_INVALID_PARAMETER;
+    pHeader = ha->pHeader;
+
+    // If the archive doesn't have raw data MD5, report it as OK
+    if(pHeader->dwRawChunkSize == 0)
+        return ERROR_SUCCESS;
+
+    // If we have to verify MPQ header, do it
+    switch(dwWhatToVerify)
+    {
+        case SFILE_VERIFY_MPQ_HEADER:
+
+            // Only if the header is of version 4 or newer
+            if(pHeader->dwHeaderSize >= (MPQ_HEADER_SIZE_V4 - MD5_DIGEST_SIZE))
+                return VerifyRawMpqData(ha, 0, MPQ_HEADER_SIZE_V4 - MD5_DIGEST_SIZE);
+            return ERROR_SUCCESS;
+
+        case SFILE_VERIFY_HET_TABLE:
+
+            // Only if we have HET table
+            if(pHeader->HetTablePos64 && pHeader->HetTableSize64)
+                return VerifyRawMpqData(ha, pHeader->HetTablePos64, (DWORD)pHeader->HetTableSize64);
+            return ERROR_SUCCESS;
+
+        case SFILE_VERIFY_BET_TABLE:
+
+            // Only if we have BET table
+            if(pHeader->BetTablePos64 && pHeader->BetTableSize64)
+                return VerifyRawMpqData(ha, pHeader->BetTablePos64, (DWORD)pHeader->BetTableSize64);
+            return ERROR_SUCCESS;
+
+        case SFILE_VERIFY_HASH_TABLE:
+
+            // Hash table is not protected by MD5
+            return ERROR_SUCCESS;
+
+        case SFILE_VERIFY_BLOCK_TABLE:
+
+            // Block table is not protected by MD5
+            return ERROR_SUCCESS;
+
+        case SFILE_VERIFY_HIBLOCK_TABLE:
+
+            // It is unknown if the hi-block table is protected my MD5 or not.
+            return ERROR_SUCCESS;
+
+        case SFILE_VERIFY_FILE:
+
+            // Verify parameters
+            if(szFileName == NULL || *szFileName == 0)
+                return ERROR_INVALID_PARAMETER;
+
+            // Get the offset of a file
+            pFileEntry = GetFileEntryLocale(ha, szFileName, g_lcFileLocale);
+            if(pFileEntry == NULL)
+                return ERROR_FILE_NOT_FOUND;
+
+            return VerifyRawMpqData(ha, pFileEntry->ByteOffset, pFileEntry->dwCmpSize);
+    }
+
+    return ERROR_INVALID_PARAMETER;
+}
+
+
+// Verifies the archive against the signature
+DWORD WINAPI SFileVerifyArchive(HANDLE hMpq)
+{
+    MPQ_SIGNATURE_INFO si = {0};
+    TMPQArchive * ha = (TMPQArchive *)hMpq;
+
+    // Verify input parameters
+    if(!IsValidMpqHandle(hMpq))
+        return ERROR_VERIFY_FAILED;
+
+    // Get the MPQ signature and signature type
+    if(!QueryMpqSignatureInfo(ha, &si))
+        return ERROR_VERIFY_FAILED;
+
+    // If there is no signature
+    if(si.SignatureTypes == 0)
+        return ERROR_NO_SIGNATURE;
+
+    // We haven't seen a MPQ with both signatures
+    assert(si.SignatureTypes == SIGNATURE_TYPE_WEAK || si.SignatureTypes == SIGNATURE_TYPE_STRONG);
+
+    // Verify the strong signature, if present
+    if(si.SignatureTypes & SIGNATURE_TYPE_STRONG)
+        return VerifyStrongSignature(ha, &si);
+
+    // Verify the weak signature, if present
+    if(si.SignatureTypes & SIGNATURE_TYPE_WEAK)
+        return VerifyWeakSignature(ha, &si);
+
+    return ERROR_NO_SIGNATURE;
+}
+
+// Verifies the archive against the signature
+bool WINAPI SFileSignArchive(HANDLE hMpq, DWORD dwSignatureType)
+{
+    TMPQArchive * ha;
+
+    // Verify the archive handle
+    ha = IsValidMpqHandle(hMpq);
+    if(ha == NULL)
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return false;
+    }
+
+    // We only support weak signature, and only for MPQs version 1.0
+    if(dwSignatureType != SIGNATURE_TYPE_WEAK)
+    {
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return false;
+    }
+
+    // The archive must not be malformed and must not be read-only
+    if(ha->dwFlags & (MPQ_FLAG_READ_ONLY | MPQ_FLAG_MALFORMED))
+    {
+        SetLastError(ERROR_ACCESS_DENIED);
+        return false;
+    }
+
+    // If the signature is not there yet
+    if(ha->dwFileFlags3 == 0)
+    {
+        // Turn the signature on. The signature will
+        // be applied when the archive is closed
+        ha->dwFlags |= MPQ_FLAG_SIGNATURE_NEW | MPQ_FLAG_CHANGED;
+        ha->dwFileFlags3 = MPQ_FILE_EXISTS;
+        ha->dwReservedFiles++;
+    }
+
+    return true;
+}
+