ProcessModules.h

#pragma once

#include "../Config.h"
#include "../Include/Winheaders.h"
#include "../PE/PEImage.h"
#include "../Misc/Utils.h"

#include <string>
#include <map>
#include <unordered_map>
#include <algorithm>

namespace std
{
    template <>
    struct hash < struct pair<wstring, blackbone::eModType> >
    {
        size_t operator()( const pair<wstring, blackbone::eModType>& value ) const
        {
            hash<wstring> sh;
            return sh( value.first ) ^ value.second;
        }
    };
}


namespace blackbone
{

struct exportData
{
    ptr_t procAddress = 0;          // Function address

    std::wstring forwardModule;     // Name of forward module
    std::string forwardName;        // Forwarded function name
    WORD forwardOrdinal = 0;        // Forwarded function ordinal

    bool isForwarded = false;       // Function is forwarded to another module
    bool forwardByOrd = false;      // Forward is done by ordinal
};

class ProcessModules
{
public:
    typedef std::unordered_map<std::pair<std::wstring, eModType>, ModuleData> mapModules;

public:
    BLACKBONE_API ProcessModules( class Process& proc );
    BLACKBONE_API ~ProcessModules();

    BLACKBONE_API const ModuleData* GetModule(
        const std::wstring& name,
        eModSeachType search = LdrList,
        eModType type = mt_default
        );

    BLACKBONE_API const ModuleData* GetModule(
        std::wstring& name,
        eModSeachType search = LdrList,
        eModType type = mt_default,
        const wchar_t* baseModule = L""
        );

    BLACKBONE_API const ModuleData* GetModule(
        module_t modBase,
        eModSeachType search = LdrList,
        eModType type = mt_default
        );

    BLACKBONE_API  const ModuleData* GetMainModule();

    BLACKBONE_API const ProcessModules::mapModules& GetAllModules( eModSeachType search = LdrList );

    BLACKBONE_API void GetManualModules( ProcessModules::mapModules& mods );

    BLACKBONE_API exportData GetExport( const ModuleData* hMod, const char* name_ord, const wchar_t* baseModule = L"" );

    BLACKBONE_API const ModuleData* Inject( const std::wstring& path, NTSTATUS* pStatus = nullptr );

#ifdef COMPILER_MSVC
    BLACKBONE_API bool InjectPureIL(
        const std::wstring& netVersion,
        const std::wstring& netAssemblyPath,
        const std::wstring& netAssemblyMethod,
        const std::wstring& netAssemblyArgs,
        DWORD& returnCode
        );
#endif

    BLACKBONE_API bool Unload( const ModuleData* hMod );

    BLACKBONE_API bool Unlink( const ModuleData* mod );

    BLACKBONE_API const ModuleData* AddManualModule( 
        const std::wstring& FilePath,
        module_t base,
        size_t size, 
        eModType mt
        );

    BLACKBONE_API void RemoveManualModule( const std::wstring& filename, eModType mt );

    BLACKBONE_API bool ValidateModule( module_t base );

    BLACKBONE_API void reset();

private:
    ProcessModules( const ProcessModules& ) = delete;
    ProcessModules operator =(const ProcessModules&) = delete;

private:
    class Process&       _proc;
    class ProcessMemory& _memory;
    class ProcessCore&   _core;

    mapModules _modules;            // Fast lookup cache
    CriticalSection _modGuard;      // Module guard        
    bool _ldrPatched;               // Win7 loader patch flag
};

};