Read IW4 signed headers

src/ZoneLoading/Loading/Steps/StepLoadHash.cpp

@@ -0,0 +1,42 @@
+#include "StepLoadHash.h"
+#include "Loading/Exception/UnexpectedEndOfFileException.h"
+#include <cassert>
+
+StepLoadHash::StepLoadHash(const size_t hashSize, const unsigned hashCount)
+    : m_hash_size(hashSize),
+      m_hash_count(hashCount),
+      m_hashes(std::make_unique<uint8_t[]>(hashSize * hashCount))
+{
+}
+
+StepLoadHash::~StepLoadHash()
+= default;
+
+void StepLoadHash::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+{
+    assert(stream != nullptr);
+
+    if (stream->Load(m_hashes.get(), m_hash_size * m_hash_count) != m_hash_size * m_hash_count)
+        throw UnexpectedEndOfFileException();
+}
+
+void StepLoadHash::GetHash(const unsigned hashIndex, const uint8_t** pHash, size_t* pSize)
+{
+    assert(pHash != nullptr);
+    assert(pSize != nullptr);
+    assert(hashIndex >= 0 && hashIndex < m_hash_count);
+
+    assert(m_hashes);
+
+    *pHash = &m_hashes[m_hash_size * hashIndex];
+    *pSize = m_hash_size;
+}
+
+void StepLoadHash::GetCapturedData(const uint8_t** pCapturedData, size_t* pSize)
+{
+    assert(pCapturedData != nullptr);
+    assert(pSize != nullptr);
+    
+    *pCapturedData = m_hashes.get();
+    *pSize = m_hash_size * m_hash_count;
+}

src/ZoneLoading/Loading/Steps/StepLoadHash.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <memory>
+
+#include "Loading/ICapturedDataProvider.h"
+#include "Loading/ILoadingStep.h"
+#include "Loading/IHashProvider.h"
+
+class StepLoadHash final : public ILoadingStep, public IHashProvider, public ICapturedDataProvider
+{
+    const size_t m_hash_size;
+    const unsigned m_hash_count;
+    std::unique_ptr<uint8_t[]> m_hashes;
+
+public:
+    StepLoadHash(size_t hashSize, unsigned hashCount);
+    ~StepLoadHash() override;
+
+    StepLoadHash(const StepLoadHash& other) = delete;
+    StepLoadHash(StepLoadHash&& other) noexcept = default;
+    StepLoadHash& operator=(const StepLoadHash& other) = delete;
+    StepLoadHash& operator=(StepLoadHash&& other) noexcept = delete;
+
+    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+    void GetHash(unsigned hashIndex, const uint8_t** pHash, size_t* pSize) override;
+    void GetCapturedData(const uint8_t** pCapturedData, size_t* pSize) override;
+};

src/ZoneLoading/Loading/Steps/StepRemoveProcessor.cpp

@@ -0,0 +1,26 @@
+#include "StepRemoveProcessor.h"
+#include <cassert>
+
+StepRemoveProcessor::StepRemoveProcessor(StreamProcessor* streamProcessor)
+    : m_stream_processor(streamProcessor),
+      m_removed(false)
+{
+}
+
+StepRemoveProcessor::~StepRemoveProcessor()
+{
+    if(m_removed)
+    {
+        delete m_stream_processor;
+        m_stream_processor = nullptr;
+    }
+}
+
+void StepRemoveProcessor::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+{
+    assert(zoneLoader != nullptr);
+    assert(m_stream_processor != nullptr);
+
+    zoneLoader->RemoveStreamProcessor(m_stream_processor);
+    m_removed = true;
+}

src/ZoneLoading/Loading/Steps/StepRemoveProcessor.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Loading/ILoadingStep.h"
+
+class StepRemoveProcessor final : public ILoadingStep
+{
+    StreamProcessor* m_stream_processor;
+    bool m_removed;
+
+public:
+    explicit StepRemoveProcessor(StreamProcessor* streamProcessor);
+    ~StepRemoveProcessor() override;
+
+    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+};

src/ZoneLoading/Loading/Steps/StepVerifyFileName.cpp

@@ -1,4 +1,7 @@
 #include "StepVerifyFileName.h"
+
+#include <sstream>
+
 #include "Loading/Exception/InvalidFileNameException.h"
 
 StepVerifyFileName::StepVerifyFileName(std::string fileName, const size_t fileNameBufferSize)
@@ -12,7 +15,7 @@ StepVerifyFileName::StepVerifyFileName(std::string fileName, const size_t fileNa
 
 void StepVerifyFileName::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
 {
-    std::string originalFileName;
+    std::stringstream originalFilenameStream;
     unsigned bufferOffset = 0;
     char c;
 
@@ -27,7 +30,7 @@ void StepVerifyFileName::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* str
             break;
         }
 
-        originalFileName += c;
+        originalFilenameStream << c;
     }
 
     // Skip the rest of the buffer which should be null bytes
@@ -37,6 +40,8 @@ void StepVerifyFileName::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* str
         bufferOffset++;
     }
 
+    std::string originalFileName = originalFilenameStream.str();
+
     if(originalFileName != m_file_name)
         throw InvalidFileNameException(m_file_name, originalFileName);
 }

src/ZoneLoading/Loading/Steps/StepVerifyHash.cpp

@@ -0,0 +1,39 @@
+#include "StepVerifyHash.h"
+
+#include <memory>
+
+#include "Loading/Exception/InvalidHashException.h"
+
+StepVerifyHash::StepVerifyHash(std::unique_ptr<IHashFunction> hashFunction, const unsigned hashIndex, IHashProvider* hashProvider,
+    ICapturedDataProvider* dataProvider)
+    : m_hash_function(std::move(hashFunction)),
+      m_hash_index(hashIndex),
+      m_hash_provider(hashProvider),
+      m_data_provider(dataProvider)
+{
+}
+
+StepVerifyHash::~StepVerifyHash()
+= default;
+
+void StepVerifyHash::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream)
+{
+    const uint8_t* dataToHash = nullptr;
+    size_t dataToHashSize = 0;
+    m_data_provider->GetCapturedData(&dataToHash, &dataToHashSize);
+
+    const uint8_t* hashData = nullptr;
+    size_t hashSize = 0;
+    m_hash_provider->GetHash(m_hash_index, &hashData, &hashSize);
+
+    if (hashSize != m_hash_function->GetHashSize())
+        throw InvalidHashException();
+
+    const std::unique_ptr<uint8_t[]> hashMemory = std::make_unique<uint8_t[]>(m_hash_function->GetHashSize());
+    m_hash_function->Init();
+    m_hash_function->Process(dataToHash, dataToHashSize);
+    m_hash_function->Finish(hashMemory.get());
+
+    if(std::memcmp(hashData, hashMemory.get(), m_hash_function->GetHashSize()) != 0)
+        throw InvalidHashException();
+}

src/ZoneLoading/Loading/Steps/StepVerifyHash.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <memory>
+
+#include "Crypto.h"
+#include "Loading/ILoadingStep.h"
+#include "Loading/ICapturedDataProvider.h"
+#include "Loading/IHashProvider.h"
+
+class StepVerifyHash final : public ILoadingStep
+{
+    std::unique_ptr<IHashFunction> m_hash_function;
+    unsigned m_hash_index;
+    IHashProvider* m_hash_provider;
+    ICapturedDataProvider* m_data_provider;
+
+public:
+    StepVerifyHash(std::unique_ptr<IHashFunction> hashFunction, unsigned hashIndex, IHashProvider* hashProvider, ICapturedDataProvider* dataProvider);
+    ~StepVerifyHash();
+    StepVerifyHash(const StepVerifyHash& other) = delete;
+    StepVerifyHash(StepVerifyHash&& other) noexcept = default;
+    StepVerifyHash& operator=(const StepVerifyHash& other) = delete;
+    StepVerifyHash& operator=(StepVerifyHash&& other) noexcept = default;
+
+    void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
+};

src/ZoneLoading/Loading/Steps/StepVerifySignature.cpp

@@ -2,7 +2,7 @@
 #include "Loading/Exception/InvalidSignatureException.h"
 #include <cassert>
 
-StepVerifySignature::StepVerifySignature(IPublicKeyAlgorithm* signatureAlgorithm, ISignatureProvider* signatureProvider, ISignatureDataProvider* signatureDataProvider)
+StepVerifySignature::StepVerifySignature(IPublicKeyAlgorithm* signatureAlgorithm, ISignatureProvider* signatureProvider, ICapturedDataProvider* signatureDataProvider)
 {
     m_algorithm = signatureAlgorithm;
     m_signature_provider = signatureProvider;
@@ -27,7 +27,7 @@ void StepVerifySignature::PerformStep(ZoneLoader* zoneLoader, ILoadingStream* st
 
     const uint8_t* signatureData;
     size_t signatureDataSize;
-    m_signature_data_provider->GetSignatureData(&signatureData, &signatureDataSize);
+    m_signature_data_provider->GetCapturedData(&signatureData, &signatureDataSize);
 
     if(!m_algorithm->Verify(signatureData, signatureDataSize, signature, signatureSize))
     {

src/ZoneLoading/Loading/Steps/StepVerifySignature.h

@@ -3,17 +3,21 @@
 #include "Loading/ILoadingStep.h"
 #include "Crypto.h"
 #include "Loading/ISignatureProvider.h"
-#include "Loading/ISignatureDataProvider.h"
+#include "Loading/ICapturedDataProvider.h"
 
 class StepVerifySignature final : public ILoadingStep
 {
     IPublicKeyAlgorithm* m_algorithm;
     ISignatureProvider* m_signature_provider;
-    ISignatureDataProvider* m_signature_data_provider;
+    ICapturedDataProvider* m_signature_data_provider;
 
 public:
-    StepVerifySignature(IPublicKeyAlgorithm* signatureAlgorithm, ISignatureProvider* signatureProvider, ISignatureDataProvider* signatureDataProvider);
+    StepVerifySignature(IPublicKeyAlgorithm* signatureAlgorithm, ISignatureProvider* signatureProvider, ICapturedDataProvider* signatureDataProvider);
     ~StepVerifySignature();
+    StepVerifySignature(const StepVerifySignature& other) = default;
+    StepVerifySignature(StepVerifySignature&& other) noexcept = default;
+    StepVerifySignature& operator=(const StepVerifySignature& other) = default;
+    StepVerifySignature& operator=(StepVerifySignature&& other) noexcept = default;
 
     void PerformStep(ZoneLoader* zoneLoader, ILoadingStream* stream) override;
 };