KittyMemoryMgr.hpp

#pragma once
 
#include "KittyUtils.hpp"
#include "KittyIOFile.hpp"
#include "KittyMemoryEx.hpp"
#include "KittyMemOp.hpp"
#include "MemoryPatch.hpp"
#include "MemoryBackup.hpp"
#include "KittyScanner.hpp"
#include "KittyTrace.hpp"
#include "KittyAsm.hpp"
#include "KittyPtrValidator.hpp"
#include "KittyPerfEvent.hpp"
 
using KittyMemoryEx::EProcMapFilter;
using KittyMemoryEx::ProcMap;
using KittyMemoryEx::ProcStatus;

class KittyMemoryMgr
{
private:
    bool _init;
    pid_t _pid;
    std::string _process_name;
    EKittyMemOP _eMemOp;
    std::unique_ptr<IKittyMemOp> _pMemOp;
    std::unique_ptr<IKittyMemOp> _pMemOpPatch;
 
public:
    MemoryPatchMgr memPatch;
    MemoryBackupMgr memBackup;
    KittyScannerMgr memScanner;
    ElfScannerMgr elfScanner;
 
#ifdef __ANDROID__
    LinkerScannerMgr linkerScanner;
    NativeBridgeScannerMgr nbScanner;
#endif

    KittyTraceMgr trace;
 
    KittyMemoryMgr() : _init(false), _pid(0), _eMemOp(EK_MEM_OP_NONE)
    {
    }

    bool initialize(pid_t pid, EKittyMemOP eMemOp, bool initMemPatch);

    inline pid_t processID() const
    {
        return _pid;
    }

    inline std::string processName() const
    {
        return _process_name;
    }

    inline bool isMemValid() const
    {
        return _init && _pid && _pMemOp.get();
    }

    inline IKittyMemOp *memOp() const
    {
        return _pMemOp.get();
    }

    inline size_t readMem(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal) const
    {
        if (!isMemValid() || !buffer || !len)
            return 0;
 
        return _pMemOp->Read(address, buffer, len, mode);
    }

    inline size_t writeMem(uintptr_t address, void *buffer, size_t len, MemMode mode = MemMode::Normal) const
    {
        if (!isMemValid() || !buffer || !len)
            return 0;
 
        return _pMemOp->Write(address, buffer, len, mode);
    }

    std::string readMemUTF8(uintptr_t address, size_t maxLen)
    {
        if (!isMemValid() || !address || !maxLen)
            return "";
 
        return _pMemOp->ReadUTF8(address, maxLen);
    }

    std::u16string readMemUTF16(uintptr_t address, size_t maxLen)
    {
        if (!isMemValid() || !address || !maxLen)
            return u"";
 
        return _pMemOp->ReadUTF16(address, maxLen);
    }

    std::u32string readMemUTF32(uintptr_t address, size_t maxLen)
    {
        if (!isMemValid() || !address || !maxLen)
            return U"";
 
        return _pMemOp->ReadUTF32(address, maxLen);
    }

    std::wstring readMemWStr(uintptr_t address, size_t maxLen)
    {
        if (!isMemValid() || !address || !maxLen)
            return L"";
 
        return _pMemOp->ReadWStr(address, maxLen);
    }

    inline std::string readMemStr(uintptr_t address, size_t maxLen)
    {
        if (!isMemValid() || !address || !maxLen)
            return "";
 
        return _pMemOp->ReadStr(address, maxLen);
    }

    bool writeMemStr(uintptr_t address, std::string str) const
    {
        if (!isMemValid() || !address || str.empty())
            return false;
 
        return _pMemOp->WriteStr(address, str);
    }

    inline bool writeMemWStr(uintptr_t address, std::wstring str)
    {
        if (!isMemValid() || !address || str.empty())
            return false;
 
        return _pMemOp->WriteWStr(address, str);
    }

    bool dumpMemRange(uintptr_t start, uintptr_t end, const std::string &path) const;

    bool dumpMemFileMappings(const std::string &memFile, const std::string &destination) const;

    bool dumpMemELF(const ElfScanner &elf, const std::string &destination) const;
};