mirror of
https://github.com/Obfuscator-Collections/VMProtect.git
synced 2024-12-27 08:49:27 +03:00
1698 lines
55 KiB
C++
1698 lines
55 KiB
C++
/**
|
|
* Operations with executable files.
|
|
*/
|
|
|
|
#ifndef FILES_H
|
|
#define FILES_H
|
|
|
|
#include "../runtime/common.h"
|
|
|
|
std::string NameToString(const char name[], size_t name_size);
|
|
std::string DisplayString(const std::string &str);
|
|
|
|
/// Given a number of bits, return how many bytes are needed to represent that.
|
|
#define BITS_TO_BYTES(x) (((x)+7)>>3)
|
|
#define BYTES_TO_BITS(x) ((x)<<3)
|
|
|
|
uint16_t OperandSizeToValue(OperandSize os);
|
|
uint16_t OperandSizeToStack(OperandSize os);
|
|
std::string DisplayValue(OperandSize size, uint64_t value);
|
|
|
|
struct FunctionName {
|
|
FunctionName()
|
|
: name_pos_(0) {}
|
|
FunctionName(const std::string &name, size_t name_pos = 0)
|
|
: name_(name), name_pos_(name_pos) {}
|
|
std::string name() const { return name_.substr(name_pos_); }
|
|
std::string display_name(bool show_ret = true) const { return DisplayString(show_ret ? name_ : name_.substr(name_pos_)); }
|
|
void clear()
|
|
{
|
|
name_.clear();
|
|
name_pos_ = 0;
|
|
}
|
|
bool operator==(const FunctionName &name) const
|
|
{
|
|
return (name_ == name.name_) && (name_pos_ == name.name_pos_);
|
|
}
|
|
bool operator!=(const FunctionName &name) const
|
|
{
|
|
return !(operator==(name));
|
|
}
|
|
private:
|
|
std::string name_;
|
|
size_t name_pos_;
|
|
};
|
|
|
|
FunctionName DemangleName(const std::string &name);
|
|
|
|
template<typename V, typename A>
|
|
V AlignValue(V value, A alignment)
|
|
{
|
|
return (value % alignment == 0) ? value : value + alignment - (value % alignment);
|
|
}
|
|
|
|
class Core;
|
|
class Watermark;
|
|
class WatermarkManager;
|
|
#ifdef ULTIMATE
|
|
class LicensingManager;
|
|
class FileManager;
|
|
#endif
|
|
class Script;
|
|
class IFile;
|
|
class IArchitecture;
|
|
class IFunctionList;
|
|
class IFunction;
|
|
class ICommand;
|
|
class CommandBlock;
|
|
class IVirtualMachineList;
|
|
class MemoryManager;
|
|
class ILoadCommandList;
|
|
class ISectionList;
|
|
class IImport;
|
|
class IImportList;
|
|
class IExportList;
|
|
class IFixupList;
|
|
class ISEHandlerList;
|
|
class MapFunction;
|
|
class MapFunctionList;
|
|
class ReferenceList;
|
|
class Buffer;
|
|
class IRuntimeFunctionList;
|
|
class ValueCryptor;
|
|
class CRCValueCryptor;
|
|
class ISymbol;
|
|
|
|
class ILog : public IObject
|
|
{
|
|
public:
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") = 0;
|
|
virtual void StartProgress(const std::string &message, unsigned long long max) = 0;
|
|
virtual void StepProgress(unsigned long long value = 1, bool is_project = false) = 0;
|
|
virtual void EndProgress() = 0;
|
|
virtual void set_warnings_as_errors(bool value) = 0;
|
|
virtual void set_arch_name(const std::string &arch_name) = 0;
|
|
};
|
|
|
|
class ILoadCommand : public IObject
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual uint32_t size() const = 0;
|
|
virtual uint32_t type() const = 0;
|
|
virtual std::string name() const = 0;
|
|
virtual bool visible() const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual ILoadCommand *Clone(ILoadCommandList *owner) const = 0;
|
|
virtual OperandSize address_size() const = 0;
|
|
virtual ILoadCommandList *owner() const = 0;
|
|
};
|
|
|
|
class ILoadCommandList : public ObjectList<ILoadCommand>
|
|
{
|
|
public:
|
|
virtual ILoadCommand *GetCommandByType(uint32_t type) const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual IArchitecture *owner() const = 0;
|
|
};
|
|
|
|
class BaseLoadCommand : public ILoadCommand
|
|
{
|
|
public:
|
|
explicit BaseLoadCommand(ILoadCommandList *owner);
|
|
explicit BaseLoadCommand(ILoadCommandList *owner, const BaseLoadCommand &src);
|
|
~BaseLoadCommand();
|
|
virtual std::string name() const;
|
|
virtual bool visible() const { return true; }
|
|
virtual OperandSize address_size() const;
|
|
ILoadCommandList *owner() const { return owner_; }
|
|
private:
|
|
ILoadCommandList *owner_;
|
|
};
|
|
|
|
class BaseCommandList : public ILoadCommandList
|
|
{
|
|
public:
|
|
explicit BaseCommandList(IArchitecture *owner);
|
|
explicit BaseCommandList(IArchitecture *owner, const BaseCommandList &src);
|
|
virtual ILoadCommand *GetCommandByType(uint32_t type) const;
|
|
virtual void Rebase(uint64_t delta_base);
|
|
virtual IArchitecture *owner() const { return owner_; }
|
|
private:
|
|
IArchitecture *owner_;
|
|
};
|
|
|
|
enum MemoryTypeFlags
|
|
{
|
|
mtNone = 0x0,
|
|
mtReadable = 0x1,
|
|
mtExecutable = 0x2,
|
|
mtWritable = 0x4,
|
|
mtNotDiscardable = 0x8,
|
|
mtDiscardable = 0x10,
|
|
mtNotPaged = 0x20,
|
|
mtShared = 0x40,
|
|
mtSolid = 0x80
|
|
};
|
|
|
|
class ISection : public IObject
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual uint64_t size() const = 0;
|
|
virtual uint32_t physical_offset() const = 0;
|
|
virtual uint32_t physical_size() const = 0;
|
|
virtual std::string name() const = 0;
|
|
virtual uint32_t memory_type() const = 0;
|
|
virtual void include_write_type(uint32_t write_type) = 0;
|
|
virtual uint32_t write_type() const = 0;
|
|
virtual void update_type(uint32_t mt) = 0;
|
|
virtual ISection *parent() const = 0;
|
|
virtual uint32_t flags() const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual ISection *Clone(ISectionList *owner) const = 0;
|
|
virtual bool excluded_from_packing() const = 0;
|
|
virtual void set_excluded_from_packing(bool value) = 0;
|
|
virtual bool excluded_from_memory_protection() const = 0;
|
|
virtual void set_excluded_from_memory_protection(bool value) = 0;
|
|
virtual OperandSize address_size() const = 0;
|
|
virtual Data hash() const = 0;
|
|
virtual bool need_parse() const = 0;
|
|
virtual ISectionList *owner() const = 0;
|
|
};
|
|
|
|
class ISectionList : public ObjectList<ISection>
|
|
{
|
|
public:
|
|
virtual ISection *GetSectionByAddress(uint64_t address) const = 0;
|
|
virtual ISection *GetSectionByOffset(uint64_t offset) const = 0;
|
|
virtual ISection *GetSectionByName(const std::string &name) const = 0;
|
|
virtual ISection *GetSectionByName(ISection *segment, const std::string &name) const = 0;
|
|
virtual uint32_t GetMemoryTypeByAddress(uint64_t address) const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual IArchitecture *owner() const = 0;
|
|
};
|
|
|
|
class BaseSection : public ISection
|
|
{
|
|
public:
|
|
explicit BaseSection(ISectionList *owner);
|
|
explicit BaseSection(ISectionList *owner, const BaseSection &src);
|
|
~BaseSection();
|
|
virtual uint32_t write_type() const { return write_type_; }
|
|
virtual void include_write_type(uint32_t write_type) { write_type_ |= write_type; }
|
|
virtual ISection *parent() const { return NULL; }
|
|
virtual bool excluded_from_packing() const { return excluded_from_packing_; };
|
|
virtual void set_excluded_from_packing(bool value);
|
|
virtual bool excluded_from_memory_protection() const { return excluded_from_memory_protection_; };
|
|
virtual void set_excluded_from_memory_protection(bool value);
|
|
virtual OperandSize address_size() const;
|
|
virtual Data hash() const;
|
|
virtual bool need_parse() const { return need_parse_; }
|
|
void set_need_parse(bool value) { need_parse_ = value; }
|
|
virtual ISectionList *owner() const { return owner_; }
|
|
private:
|
|
void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
ISectionList *owner_;
|
|
uint32_t write_type_;
|
|
bool excluded_from_packing_;
|
|
bool excluded_from_memory_protection_;
|
|
bool need_parse_;
|
|
};
|
|
|
|
class BaseSectionList : public ISectionList
|
|
{
|
|
public:
|
|
explicit BaseSectionList(IArchitecture *owner);
|
|
explicit BaseSectionList(IArchitecture *owner, const BaseSectionList &src);
|
|
virtual ISection *GetSectionByAddress(uint64_t address) const;
|
|
virtual ISection *GetSectionByOffset(uint64_t offset) const;
|
|
virtual ISection *GetSectionByName(const std::string &name) const;
|
|
virtual ISection *GetSectionByName(ISection *segment, const std::string &name) const;
|
|
virtual uint32_t GetMemoryTypeByAddress(uint64_t address) const;
|
|
virtual void Rebase(uint64_t delta_base);
|
|
virtual IArchitecture *owner() const { return owner_; }
|
|
private:
|
|
IArchitecture *owner_;
|
|
};
|
|
|
|
enum APIType {
|
|
atNone,
|
|
atBegin,
|
|
atEnd,
|
|
atIsVirtualMachinePresent,
|
|
atIsDebuggerPresent,
|
|
atIsValidImageCRC,
|
|
atDecryptStringA,
|
|
atDecryptStringW,
|
|
atFreeString,
|
|
atActivateLicense,
|
|
atDeactivateLicense,
|
|
atGetOfflineActivationString,
|
|
atGetOfflineDeactivationString,
|
|
atSetSerialNumber,
|
|
atGetSerialNumberState,
|
|
atGetSerialNumberData,
|
|
atGetCurrentHWID,
|
|
atLoadResource,
|
|
atFindResourceA,
|
|
atFindResourceExA,
|
|
atFindResourceW,
|
|
atFindResourceExW,
|
|
atLoadStringA,
|
|
atLoadStringW,
|
|
atEnumResourceNamesA,
|
|
atEnumResourceNamesW,
|
|
atEnumResourceLanguagesA,
|
|
atEnumResourceLanguagesW,
|
|
atEnumResourceTypesA,
|
|
atEnumResourceTypesW,
|
|
atDecryptBuffer,
|
|
atRuntimeInit,
|
|
atLoaderData,
|
|
atIsProtected,
|
|
atSetupImage,
|
|
atFreeImage,
|
|
atCalcCRC,
|
|
atRandom,
|
|
atBoxPointer,
|
|
atUnboxPointer
|
|
};
|
|
|
|
enum ImportOption {
|
|
ioNone = 0x0000,
|
|
ioNoReturn = 0x0001,
|
|
ioHasDataReference = 0x0002,
|
|
ioNative = 0x0004,
|
|
ioHasCompilationType = 0x0008,
|
|
ioLockToKey = 0x0010,
|
|
ioFromRuntime = 0x0020,
|
|
ioNoReferences = 0x0040,
|
|
ioIsRelative = 0x0080,
|
|
ioHasDirectReference = 0x0100,
|
|
ioHasCallPrefix = 0x0200
|
|
};
|
|
|
|
enum RuntimeOptions {
|
|
roNone,
|
|
roHWID = 0x0001,
|
|
roKey = 0x0002,
|
|
roResources = 0x0004,
|
|
roStrings = 0x0008,
|
|
roBundler = 0x0010,
|
|
roRegistry = 0x0020,
|
|
roActivation = 0x0040,
|
|
roMemoryProtection = 0x0080
|
|
};
|
|
|
|
enum CompilationType : uint8_t {
|
|
ctVirtualization,
|
|
ctMutation,
|
|
ctUltra,
|
|
ctNone = 0xFF
|
|
};
|
|
|
|
class IImportFunction : public IObject
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual std::string name() const = 0;
|
|
virtual std::string full_name() const = 0;
|
|
virtual APIType type() const = 0;
|
|
virtual uint32_t options() const = 0;
|
|
virtual CompilationType compilation_type() const = 0;
|
|
virtual MapFunction *map_function() const = 0;
|
|
virtual void set_map_function(MapFunction *map_function) = 0;
|
|
virtual void set_type(APIType type) = 0;
|
|
virtual void include_option(ImportOption option) = 0;
|
|
virtual void exclude_option(ImportOption option) = 0;
|
|
virtual IImport *owner() const = 0;
|
|
virtual IImportFunction *Clone(IImport *owner) const = 0;
|
|
virtual uint32_t GetRuntimeOptions() const = 0;
|
|
virtual uint32_t GetSDKOptions() const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual std::string display_name(bool show_ret = true) const = 0;
|
|
virtual OperandSize address_size() const = 0;
|
|
};
|
|
|
|
class IImport : public ObjectList<IImportFunction>
|
|
{
|
|
public:
|
|
virtual std::string name() const = 0;
|
|
virtual bool is_sdk() const = 0;
|
|
virtual IImportFunction *GetFunctionByAddress(uint64_t address) const = 0;
|
|
virtual uint32_t GetRuntimeOptions() const = 0;
|
|
virtual uint32_t GetSDKOptions() const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual IImportFunction *Add(uint64_t address, APIType type, MapFunction *map_function) = 0;
|
|
virtual bool CompareName(const std::string &name) const = 0;
|
|
virtual IImport *Clone(IImportList *owner) const = 0;
|
|
virtual IImportList *owner() const = 0;
|
|
virtual bool excluded_from_import_protection() const = 0;
|
|
virtual void set_excluded_from_import_protection(bool value) = 0;
|
|
virtual Data hash() const = 0;
|
|
};
|
|
|
|
struct ImportInfo {
|
|
APIType type;
|
|
const char *name;
|
|
uint32_t options;
|
|
CompilationType compilation_type;
|
|
uint64_t encode() const
|
|
{
|
|
return (compilation_type << 16) | (options << 8) | type; //-V629
|
|
};
|
|
void decode(uint64_t value)
|
|
{
|
|
type = static_cast<APIType>(value & 0xff);
|
|
options = (value >> 8) & 0xff;
|
|
compilation_type = static_cast<CompilationType>((value >> 16) & 0xff);
|
|
};
|
|
};
|
|
|
|
class IImportList : public ObjectList<IImport>
|
|
{
|
|
public:
|
|
virtual IImportFunction *GetFunctionByAddress(uint64_t address) const = 0;
|
|
virtual uint32_t GetRuntimeOptions() const = 0;
|
|
virtual uint32_t GetSDKOptions() const = 0;
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file) = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual bool has_sdk() const = 0;
|
|
virtual IImport *GetImportByName(const std::string &name) const = 0;
|
|
virtual const ImportInfo *GetSDKInfo(const std::string &name) const = 0;
|
|
virtual IArchitecture *owner() const = 0;
|
|
protected:
|
|
virtual IImport *AddSDK() = 0;
|
|
};
|
|
|
|
class BaseImportFunction : public IImportFunction
|
|
{
|
|
public:
|
|
explicit BaseImportFunction(IImport *owner);
|
|
explicit BaseImportFunction(IImport *owner, const BaseImportFunction &src);
|
|
~BaseImportFunction();
|
|
virtual IImport *owner() const { return owner_; }
|
|
void set_owner(IImport *value);
|
|
virtual APIType type() const { return type_; }
|
|
virtual void set_type(APIType type) { type_ = type; }
|
|
virtual uint32_t GetRuntimeOptions() const;
|
|
virtual uint32_t GetSDKOptions() const;
|
|
virtual MapFunction *map_function() const { return map_function_; }
|
|
virtual void set_map_function(MapFunction *map_function) { map_function_ = map_function; }
|
|
virtual CompilationType compilation_type() const { return compilation_type_; }
|
|
virtual void set_compilation_type(CompilationType compilation_type) { compilation_type_ = compilation_type; }
|
|
virtual uint32_t options() const { return options_; }
|
|
virtual void include_option(ImportOption option) { options_ |= option; }
|
|
virtual void exclude_option(ImportOption option) { options_ &= ~option; }
|
|
virtual std::string full_name() const;
|
|
virtual OperandSize address_size() const;
|
|
private:
|
|
IImport *owner_;
|
|
APIType type_;
|
|
MapFunction *map_function_;
|
|
CompilationType compilation_type_;
|
|
uint32_t options_;
|
|
};
|
|
|
|
class BaseImport : public IImport
|
|
{
|
|
public:
|
|
explicit BaseImport(IImportList *owner);
|
|
explicit BaseImport(IImportList *owner, const BaseImport &src);
|
|
~BaseImport();
|
|
virtual void clear();
|
|
virtual IImportFunction *GetFunctionByAddress(uint64_t address) const;
|
|
virtual uint32_t GetRuntimeOptions() const;
|
|
virtual uint32_t GetSDKOptions() const;
|
|
virtual void Rebase(uint64_t delta_base);
|
|
virtual bool CompareName(const std::string &name) const;
|
|
virtual void AddObject(IImportFunction *obj);
|
|
virtual IImportList *owner() const { return owner_; }
|
|
virtual bool excluded_from_import_protection() const { return excluded_from_import_protection_; };
|
|
virtual void set_excluded_from_import_protection(bool value);
|
|
virtual Data hash() const;
|
|
private:
|
|
IImportList *owner_;
|
|
std::map<uint64_t, IImportFunction *> map_;
|
|
bool excluded_from_import_protection_;
|
|
};
|
|
|
|
class BaseImportList : public IImportList
|
|
{
|
|
public:
|
|
explicit BaseImportList(IArchitecture *owner);
|
|
explicit BaseImportList(IArchitecture *owner, const BaseImportList &src);
|
|
virtual IImportFunction *GetFunctionByAddress(uint64_t address) const;
|
|
virtual uint32_t GetRuntimeOptions() const;
|
|
virtual uint32_t GetSDKOptions() const;
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file);
|
|
virtual void Rebase(uint64_t delta_base);
|
|
virtual bool has_sdk() const;
|
|
virtual IImport *GetImportByName(const std::string &name) const;
|
|
virtual const ImportInfo *GetSDKInfo(const std::string &name) const;
|
|
virtual IArchitecture *owner() const { return owner_; }
|
|
private:
|
|
IArchitecture *owner_;
|
|
};
|
|
|
|
class IExport : public IObject
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual std::string name() const = 0;
|
|
virtual std::string forwarded_name() const = 0;
|
|
virtual std::string display_name(bool show_ret = true) const = 0;
|
|
virtual APIType type() const = 0;
|
|
virtual void set_type(APIType type) = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual IExport *Clone(IExportList *owner) const = 0;
|
|
virtual OperandSize address_size() const = 0;
|
|
virtual bool is_equal(const IExport &src) const = 0;
|
|
};
|
|
|
|
class IExportList : public ObjectList<IExport>
|
|
{
|
|
public:
|
|
virtual std::string name() const = 0;
|
|
virtual IExport *GetExportByAddress(uint64_t address) const = 0;
|
|
virtual uint64_t GetAddressByType(APIType type) const = 0;
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file) = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual IArchitecture *owner() const = 0;
|
|
virtual bool is_equal(const IExportList &src) const = 0;
|
|
protected:
|
|
virtual IExport *Add(uint64_t address) = 0;
|
|
};
|
|
|
|
class BaseExport : public IExport
|
|
{
|
|
public:
|
|
explicit BaseExport(IExportList *owner);
|
|
explicit BaseExport(IExportList *owner, const BaseExport &src);
|
|
~BaseExport();
|
|
virtual OperandSize address_size() const;
|
|
virtual bool is_equal(const IExport &src) const;
|
|
virtual APIType type() const { return type_; }
|
|
virtual void set_type(APIType type) { type_ = type; }
|
|
private:
|
|
IExportList *owner_;
|
|
APIType type_;
|
|
};
|
|
|
|
class BaseExportList : public IExportList
|
|
{
|
|
public:
|
|
explicit BaseExportList(IArchitecture *owner);
|
|
explicit BaseExportList(IArchitecture *owner, const BaseExportList &src);
|
|
virtual uint64_t GetAddressByType(APIType type) const;
|
|
IExport *GetExportByAddress(uint64_t address) const;
|
|
IExport *GetExportByName(const std::string &name) const;
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file);
|
|
virtual void Rebase(uint64_t delta_base);
|
|
virtual IArchitecture *owner() const { return owner_; }
|
|
virtual bool is_equal(const IExportList &src) const;
|
|
private:
|
|
IArchitecture *owner_;
|
|
};
|
|
|
|
#define NEED_FIXUP reinterpret_cast<IFixup *>(-1)
|
|
#define LARGE_VALUE reinterpret_cast<IFixup *>(-2)
|
|
|
|
enum FixupType
|
|
{
|
|
ftUnknown,
|
|
ftHigh,
|
|
ftLow,
|
|
ftHighLow
|
|
};
|
|
|
|
class IFixup : public IObject
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual uint64_t next_address() const = 0;
|
|
virtual FixupType type() const = 0;
|
|
virtual OperandSize size() const = 0;
|
|
virtual void set_address(uint64_t address) = 0;
|
|
virtual bool is_deleted() const = 0;
|
|
virtual void set_deleted(bool deleted) = 0;
|
|
virtual void Rebase(IArchitecture &file, uint64_t delta_base) = 0;
|
|
|
|
using IObject::CompareWith;
|
|
int CompareWith(const IFixup &obj) const
|
|
{
|
|
if (address() < obj.address())
|
|
return -1;
|
|
if (address() > obj.address())
|
|
return 1;
|
|
return 0;
|
|
}
|
|
virtual IFixup *Clone(IFixupList *owner) const = 0;
|
|
};
|
|
|
|
class BaseFixup : public IFixup
|
|
{
|
|
public:
|
|
explicit BaseFixup(IFixupList *owner);
|
|
explicit BaseFixup(IFixupList *owner, const BaseFixup &src);
|
|
~BaseFixup();
|
|
virtual uint64_t next_address() const { return address() + OperandSizeToValue(size()); }
|
|
virtual bool is_deleted() const { return deleted_; }
|
|
virtual void set_deleted(bool deleted) { deleted_ = deleted; }
|
|
private:
|
|
IFixupList *owner_;
|
|
bool deleted_;
|
|
};
|
|
|
|
class IFixupList : public ObjectList<IFixup>
|
|
{
|
|
public:
|
|
virtual IFixup *GetFixupByAddress(uint64_t address) const = 0;
|
|
virtual IFixup *GetFixupByNearAddress(uint64_t address) const = 0;
|
|
virtual IFixup *AddDefault(OperandSize cpu_address_size, bool is_code) = 0;
|
|
virtual void Rebase(IArchitecture &file, uint64_t delta_base) = 0;
|
|
};
|
|
|
|
class BaseFixupList : public IFixupList
|
|
{
|
|
public:
|
|
explicit BaseFixupList();
|
|
explicit BaseFixupList(const BaseFixupList &src);
|
|
virtual void clear();
|
|
virtual IFixup *GetFixupByAddress(uint64_t address) const;
|
|
virtual IFixup *GetFixupByNearAddress(uint64_t address) const;
|
|
virtual size_t Pack();
|
|
virtual void Rebase(IArchitecture &file, uint64_t delta_base);
|
|
virtual void AddObject(IFixup *obj);
|
|
private:
|
|
std::map<uint64_t, IFixup *> map_;
|
|
|
|
// no assignment op
|
|
BaseFixupList &operator =(const BaseFixupList &);
|
|
};
|
|
|
|
class IRelocationList;
|
|
|
|
class ISymbol : public IObject
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual std::string display_name(bool show_ret = true) const = 0;
|
|
};
|
|
|
|
class IRelocation : public IObject
|
|
{
|
|
public:
|
|
virtual IRelocation *Clone(IRelocationList *owner) const = 0;
|
|
virtual uint64_t address() const = 0;
|
|
virtual void set_address(uint64_t address) = 0;
|
|
virtual void Rebase(IArchitecture &file, uint64_t delta_base) = 0;
|
|
virtual ISymbol *symbol() const = 0;
|
|
};
|
|
|
|
class IRelocationList : public ObjectList<IRelocation>
|
|
{
|
|
public:
|
|
virtual IRelocation *GetRelocationByAddress(uint64_t address) const = 0;
|
|
};
|
|
|
|
class BaseRelocation : public IRelocation
|
|
{
|
|
public:
|
|
explicit BaseRelocation(IRelocationList *owner, uint64_t address, OperandSize size);
|
|
explicit BaseRelocation(IRelocationList *owner, const BaseRelocation &src);
|
|
~BaseRelocation();
|
|
uint64_t address() const { return address_; }
|
|
OperandSize size() const { return size_; }
|
|
void set_address(uint64_t address) { address_ = address; }
|
|
virtual void Rebase(IArchitecture &file, uint64_t delta_base) { address_ += delta_base; }
|
|
private:
|
|
IRelocationList *owner_;
|
|
uint64_t address_;
|
|
OperandSize size_;
|
|
};
|
|
|
|
class BaseRelocationList : public IRelocationList
|
|
{
|
|
public:
|
|
explicit BaseRelocationList();
|
|
explicit BaseRelocationList(const BaseRelocationList &src);
|
|
virtual void clear();
|
|
virtual IRelocation *GetRelocationByAddress(uint64_t address) const;
|
|
virtual void AddObject(IRelocation *relocation);
|
|
void Rebase(IArchitecture &file, uint64_t delta_base);
|
|
private:
|
|
std::map<uint64_t, IRelocation *> map_;
|
|
|
|
// no assignment op
|
|
BaseRelocationList &operator =(const BaseRelocationList &);
|
|
};
|
|
|
|
#define NEED_SEH_HANDLER reinterpret_cast<ISEHandler *>(-1)
|
|
|
|
class ISEHandler : public IObject
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual void set_address(uint64_t address) = 0;
|
|
virtual bool is_deleted() const = 0;
|
|
virtual void set_deleted(bool deleted) = 0;
|
|
|
|
using IObject::CompareWith;
|
|
int CompareWith(const ISEHandler &obj) const
|
|
{
|
|
if (address() < obj.address())
|
|
return -1;
|
|
if (address() > obj.address())
|
|
return 1;
|
|
return 0;
|
|
}
|
|
virtual ISEHandler *Clone(ISEHandlerList *owner) const = 0;
|
|
};
|
|
|
|
class BaseSEHandler : public ISEHandler
|
|
{
|
|
public:
|
|
explicit BaseSEHandler(ISEHandlerList *owner);
|
|
explicit BaseSEHandler(ISEHandlerList *owner, const BaseSEHandler &src);
|
|
~BaseSEHandler();
|
|
private:
|
|
ISEHandlerList *owner_;
|
|
};
|
|
|
|
class ISEHandlerList : public ObjectList<ISEHandler>
|
|
{
|
|
public:
|
|
virtual ISEHandler *GetHandlerByAddress(uint64_t address) const = 0;
|
|
virtual ISEHandler *Add(uint64_t address) = 0;
|
|
};
|
|
|
|
class BaseSEHandlerList : public ISEHandlerList
|
|
{
|
|
public:
|
|
explicit BaseSEHandlerList();
|
|
explicit BaseSEHandlerList(const BaseSEHandlerList &src);
|
|
virtual void clear();
|
|
ISEHandler *GetHandlerByAddress(uint64_t address) const;
|
|
virtual void AddObject(ISEHandler *handler);
|
|
private:
|
|
std::map<uint64_t, ISEHandler *> map_;
|
|
|
|
// no assignment op
|
|
BaseSEHandlerList &operator =(const BaseSEHandlerList &);
|
|
};
|
|
|
|
class Reference : public IObject
|
|
{
|
|
public:
|
|
explicit Reference(ReferenceList *owner, uint64_t address, uint64_t operand_address, size_t tag);
|
|
explicit Reference(ReferenceList *owner, const Reference &src);
|
|
~Reference();
|
|
uint64_t address() const { return address_; }
|
|
uint64_t operand_address() const { return operand_address_; }
|
|
virtual Reference *Clone(ReferenceList *owner) const;
|
|
void Rebase(uint64_t delta_base);
|
|
size_t tag() const { return tag_; }
|
|
ReferenceList *owner() const { return owner_; }
|
|
private:
|
|
ReferenceList *owner_;
|
|
uint64_t address_;
|
|
uint64_t operand_address_;
|
|
size_t tag_;
|
|
};
|
|
|
|
class ReferenceList : public ObjectList<Reference>
|
|
{
|
|
public:
|
|
explicit ReferenceList();
|
|
explicit ReferenceList(const ReferenceList &src);
|
|
virtual ReferenceList *Clone() const;
|
|
Reference *Add(uint64_t address, uint64_t operand_address, size_t tag = 0);
|
|
Reference *GetReferenceByAddress(uint64_t address) const;
|
|
void Rebase(uint64_t delta_base);
|
|
private:
|
|
// no assignment op
|
|
ReferenceList &operator =(const ReferenceList &);
|
|
};
|
|
|
|
enum ObjectType : uint8_t
|
|
{
|
|
otCode,
|
|
otData,
|
|
otExport,
|
|
otMarker,
|
|
otAPIMarker,
|
|
otImport,
|
|
otString,
|
|
otUnknown
|
|
};
|
|
|
|
struct MapFunctionHash {
|
|
std::string name;
|
|
ObjectType type;
|
|
MapFunctionHash(ObjectType type_, const std::string &name_) : type(type_), name(name_) {}
|
|
bool operator < (const MapFunctionHash &hash) const
|
|
{
|
|
int res = name.compare(hash.name);
|
|
return (res != 0) ? (res < 0) : (type < hash.type);
|
|
}
|
|
};
|
|
|
|
class MapFunction : public IObject
|
|
{
|
|
public:
|
|
explicit MapFunction(MapFunctionList *owner, uint64_t address, ObjectType type, const FunctionName &name);
|
|
explicit MapFunction(MapFunctionList *owner, const MapFunction &src);
|
|
virtual ~MapFunction();
|
|
virtual MapFunction *Clone(MapFunctionList *owner) const;
|
|
uint64_t address() const { return address_; }
|
|
ObjectType type() const { return type_; }
|
|
std::string name() const { return name_.name(); }
|
|
std::string display_name(bool show_ret = false) const { return name_.display_name(show_ret); }
|
|
uint64_t end_address() const { return end_address_; }
|
|
uint64_t name_address() const { return name_address_; }
|
|
size_t name_length() const { return name_length_; }
|
|
ReferenceList *reference_list() const { return reference_list_; }
|
|
ReferenceList *equal_address_list() const { return equal_address_list_; }
|
|
CompilationType compilation_type() const { return compilation_type_; }
|
|
bool lock_to_key() const { return lock_to_key_; }
|
|
void set_type(ObjectType type) { type_ = type; }
|
|
void set_end_address(uint64_t end_address) { end_address_ = end_address; }
|
|
void set_name(const FunctionName &name);
|
|
void set_name_address(uint64_t name_address) { name_address_ = name_address; }
|
|
void set_name_length(size_t name_length) { name_length_ = name_length; }
|
|
void set_compilation_type(CompilationType compilation_type) { compilation_type_ = compilation_type; }
|
|
void set_lock_to_key(bool lock_to_key) { lock_to_key_ = lock_to_key; }
|
|
void Rebase(uint64_t delta_base);
|
|
std::string display_address(const std::string &arch_name) const;
|
|
MapFunctionList *owner() const { return owner_; }
|
|
MapFunctionHash hash() const;
|
|
FunctionName full_name() const { return name_; }
|
|
bool is_code() const;
|
|
bool strings_protection() const { return strings_protection_; }
|
|
void set_strings_protection(bool value) { strings_protection_ = value; }
|
|
private:
|
|
MapFunctionList *owner_;
|
|
uint64_t address_;
|
|
ObjectType type_;
|
|
FunctionName name_;
|
|
uint64_t end_address_;
|
|
ReferenceList *reference_list_;
|
|
ReferenceList *equal_address_list_;
|
|
uint64_t name_address_;
|
|
size_t name_length_;
|
|
CompilationType compilation_type_;
|
|
bool lock_to_key_;
|
|
bool strings_protection_;
|
|
|
|
// no copy ctr or assignment op
|
|
MapFunction(const MapFunction &);
|
|
MapFunction &operator =(const MapFunction &);
|
|
};
|
|
|
|
class MapFunctionList : public ObjectList<MapFunction>
|
|
{
|
|
public:
|
|
explicit MapFunctionList(IArchitecture *owner);
|
|
explicit MapFunctionList(IArchitecture *owner, const MapFunctionList &src);
|
|
virtual void clear();
|
|
void RemoveObject(MapFunction *func);
|
|
virtual MapFunctionList *Clone(IArchitecture *owner) const;
|
|
void ReadFromFile(IArchitecture &file);
|
|
MapFunction *GetFunctionByAddress(uint64_t address) const;
|
|
MapFunction *GetFunctionByName(const std::string &name) const;
|
|
std::vector<uint64_t> GetAddressListByName(const std::string &name, bool code_only) const;
|
|
MapFunction *Add(uint64_t address, uint64_t end_address, ObjectType type, const FunctionName &name);
|
|
void Rebase(uint64_t delta_base);
|
|
void ReadFromBuffer(Buffer &buffer, IArchitecture &file);
|
|
virtual void AddObject(MapFunction *func);
|
|
IArchitecture *owner() const { return owner_; }
|
|
private:
|
|
IArchitecture *owner_;
|
|
std::map<uint64_t, MapFunction*> address_map_;
|
|
std::map<std::string, std::vector<MapFunction*> > name_map_;
|
|
};
|
|
|
|
class MapSection;
|
|
class IMapFile;
|
|
|
|
class MapObject : public IObject
|
|
{
|
|
public:
|
|
explicit MapObject(MapSection *owner, size_t segment, uint64_t address, uint64_t size, const std::string &name);
|
|
virtual ~MapObject();
|
|
size_t segment() const { return segment_; }
|
|
uint64_t address() const { return address_; }
|
|
uint64_t size() const { return size_; }
|
|
std::string name() const { return name_; }
|
|
private:
|
|
MapSection *owner_;
|
|
size_t segment_;
|
|
uint64_t address_;
|
|
uint64_t size_;
|
|
std::string name_;
|
|
};
|
|
|
|
enum MapSectionType {
|
|
msSections,
|
|
msFunctions
|
|
};
|
|
|
|
class MapSection : public ObjectList<MapObject>
|
|
{
|
|
public:
|
|
explicit MapSection(IMapFile *owner, MapSectionType type);
|
|
virtual ~MapSection();
|
|
MapSectionType type() const { return type_; }
|
|
void Add(size_t segment, uint64_t address, uint64_t size, const std::string &name);
|
|
private:
|
|
IMapFile *owner_;
|
|
MapSectionType type_;
|
|
};
|
|
|
|
class IMapFile : public ObjectList<MapSection>
|
|
{
|
|
public:
|
|
virtual MapSection *GetSectionByType(MapSectionType type) const = 0;
|
|
virtual bool Parse(const char *file_name, const std::vector<uint64_t> &segments) = 0;
|
|
virtual std::string file_name() const = 0;
|
|
virtual uint64_t time_stamp() const = 0;
|
|
};
|
|
|
|
class BaseMapFile : public IMapFile
|
|
{
|
|
public:
|
|
explicit BaseMapFile();
|
|
virtual MapSection *GetSectionByType(MapSectionType type) const;
|
|
protected:
|
|
MapSection *Add(MapSectionType type);
|
|
};
|
|
|
|
class MapFile : public BaseMapFile
|
|
{
|
|
public:
|
|
explicit MapFile();
|
|
virtual bool Parse(const char *file_name, const std::vector<uint64_t> &segments);
|
|
virtual std::string file_name() const { return file_name_; }
|
|
virtual uint64_t time_stamp() const { return time_stamp_; }
|
|
protected:
|
|
void set_time_stamp(uint64_t value) { time_stamp_ = value; }
|
|
private:
|
|
std::string file_name_;
|
|
uint64_t time_stamp_;
|
|
};
|
|
|
|
class MapFunctionBundle;
|
|
class MapFunctionBundleList;
|
|
|
|
class MapFunctionArch : public IObject
|
|
{
|
|
public:
|
|
explicit MapFunctionArch(MapFunctionBundle *owner, IArchitecture *arch, MapFunction *func);
|
|
~MapFunctionArch();
|
|
IArchitecture *arch() const { return arch_; }
|
|
MapFunction *func() const { return func_; }
|
|
private:
|
|
MapFunctionBundle *owner_;
|
|
IArchitecture *arch_;
|
|
MapFunction *func_;
|
|
};
|
|
|
|
class MapFunctionBundle : public ObjectList<MapFunctionArch>
|
|
{
|
|
public:
|
|
explicit MapFunctionBundle(MapFunctionBundleList *owner, ObjectType type, const FunctionName &name);
|
|
~MapFunctionBundle();
|
|
MapFunctionArch *Add(IArchitecture *arch, MapFunction *func);
|
|
MapFunctionHash hash() const { return MapFunctionHash(type_, name_.name()); }
|
|
ObjectType type() const { return type_; }
|
|
std::string name() const { return name_.name(); }
|
|
std::string display_name(bool show_ret = true) const { return name_.display_name(show_ret); }
|
|
MapFunction *GetFunctionByArch(IArchitecture *arch) const;
|
|
bool is_code() const;
|
|
std::string display_address() const;
|
|
MapFunctionBundleList *owner() const { return owner_; }
|
|
FunctionName full_name() const { return name_; }
|
|
private:
|
|
MapFunctionBundleList *owner_;
|
|
ObjectType type_;
|
|
FunctionName name_;
|
|
};
|
|
|
|
class MapFunctionBundleList : public ObjectList<MapFunctionBundle>
|
|
{
|
|
public:
|
|
explicit MapFunctionBundleList(IFile *owner);
|
|
void ReadFromFile(IFile &file);
|
|
virtual void AddObject(MapFunctionBundle *info);
|
|
MapFunctionBundle *GetFunctionByAddress(IArchitecture *arch, uint64_t address) const;
|
|
bool show_arch_name() const { return show_arch_name_; }
|
|
void set_show_arch_name(bool show_arch_name) { show_arch_name_ = show_arch_name; }
|
|
IFile *owner() const { return owner_; }
|
|
MapFunctionBundle *Add(IArchitecture *arch, MapFunction *func);
|
|
private:
|
|
MapFunctionBundle *GetFunctionByHash(const MapFunctionHash &hash) const;
|
|
IFile *owner_;
|
|
std::map<MapFunctionHash, MapFunctionBundle *> map_;
|
|
bool show_arch_name_;
|
|
};
|
|
|
|
class IResource : public ObjectList<IResource>
|
|
{
|
|
public:
|
|
virtual uint32_t type() const = 0;
|
|
virtual uint64_t address() const = 0;
|
|
virtual size_t size() const = 0;
|
|
virtual std::string name() const = 0;
|
|
virtual IResource *owner() const = 0;
|
|
virtual bool is_directory() const = 0;
|
|
virtual bool need_store() const = 0;
|
|
virtual IResource *Clone(IResource *owner) const = 0;
|
|
virtual IResource *GetResourceByName(const std::string &name) const = 0;
|
|
virtual IResource *GetResourceByType(uint32_t type) const = 0;
|
|
virtual IResource *GetResourceById(const std::string &id) const = 0;
|
|
virtual bool excluded_from_packing() const = 0;
|
|
virtual void set_excluded_from_packing(bool value) = 0;
|
|
virtual OperandSize address_size() const = 0;
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const = 0;
|
|
virtual std::string id() const = 0;
|
|
virtual Data hash() const = 0;
|
|
};
|
|
|
|
class IResourceList : public IResource
|
|
{
|
|
public:
|
|
virtual std::vector<IResource*> GetResourceList() const = 0;
|
|
};
|
|
|
|
class BaseResource : public IResource
|
|
{
|
|
public:
|
|
explicit BaseResource(IResource *owner);
|
|
explicit BaseResource(IResource *owner, const BaseResource &src);
|
|
~BaseResource();
|
|
virtual IResource *owner() const { return owner_; }
|
|
virtual IResource *GetResourceByName(const std::string &name) const;
|
|
virtual IResource *GetResourceByType(uint32_t type) const;
|
|
virtual IResource *GetResourceById(const std::string &id) const;
|
|
virtual bool excluded_from_packing() const { return excluded_from_packing_; }
|
|
virtual void set_excluded_from_packing(bool value);
|
|
virtual OperandSize address_size() const;
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
virtual Data hash() const;
|
|
private:
|
|
IResource *owner_;
|
|
bool excluded_from_packing_;
|
|
};
|
|
|
|
class BaseResourceList : public IResourceList
|
|
{
|
|
public:
|
|
explicit BaseResourceList(IArchitecture *owner);
|
|
explicit BaseResourceList(IArchitecture *owner, const BaseResourceList &src);
|
|
virtual uint32_t type() const { return (uint32_t)-1; }
|
|
virtual uint64_t address() const { return 0; }
|
|
virtual size_t size() const { return 0; }
|
|
virtual std::string name() const { return std::string(); }
|
|
virtual IResource *owner() const { return NULL; }
|
|
virtual bool is_directory() const { return true; }
|
|
virtual IResource *Clone(IResource * /*owner*/) const { return NULL; }
|
|
virtual IResource *GetResourceByName(const std::string &name) const;
|
|
virtual IResource *GetResourceByType(uint32_t type) const;
|
|
virtual IResource *GetResourceById(const std::string &id) const;
|
|
virtual bool excluded_from_packing() const { return false; }
|
|
virtual void set_excluded_from_packing(bool /*value*/) { }
|
|
virtual bool need_store() const { return true; }
|
|
virtual std::vector<IResource*> GetResourceList() const;
|
|
virtual std::string id() const { return std::string(); }
|
|
virtual OperandSize address_size() const;
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
virtual Data hash() const { return Data(); }
|
|
private:
|
|
IArchitecture *owner_;
|
|
};
|
|
|
|
enum CompilerFunctionType {
|
|
cfNone,
|
|
cfBaseRegistr,
|
|
cfGetBaseRegistr,
|
|
cfDllFunctionCall,
|
|
cfCxxSEH,
|
|
cfCxxSEH3,
|
|
cfCxxSEH4,
|
|
cfSEH4Prolog,
|
|
cfVB6SEH,
|
|
cfInitBCBSEH,
|
|
cfBCBSEH,
|
|
cfRelocatorMinGW,
|
|
cfPatchImport,
|
|
cfJmpFunction
|
|
};
|
|
|
|
enum CompilerFunctionOption {
|
|
coUsed = 1,
|
|
coNoReturn = 2,
|
|
};
|
|
|
|
class CompilerFunctionList;
|
|
|
|
class CompilerFunction : public IObject
|
|
{
|
|
public:
|
|
explicit CompilerFunction(CompilerFunctionList *owner, CompilerFunctionType type, uint64_t address);
|
|
explicit CompilerFunction(CompilerFunctionList *owner, const CompilerFunction &src);
|
|
~CompilerFunction();
|
|
CompilerFunctionType type() const { return type_; }
|
|
uint64_t address() const { return address_; }
|
|
uint64_t value(size_t index) const { return (index < value_list_.size()) ? value_list_[index] : 0; }
|
|
void add_value(uint64_t value) { value_list_.push_back(value); }
|
|
virtual CompilerFunction *Clone(CompilerFunctionList *owner) const;
|
|
uint32_t options() const { return options_; }
|
|
void include_option(CompilerFunctionOption option) { options_ |= option; }
|
|
size_t count() const { return value_list_.size(); }
|
|
void Rebase(uint64_t delta_base);
|
|
private:
|
|
CompilerFunctionList *owner_;
|
|
uint64_t address_;
|
|
CompilerFunctionType type_;
|
|
uint32_t options_;
|
|
std::vector<uint64_t> value_list_;
|
|
|
|
// not implemented
|
|
CompilerFunction(const CompilerFunction &);
|
|
CompilerFunction &operator =(const CompilerFunction &);
|
|
};
|
|
|
|
class CompilerFunctionList : public ObjectList<CompilerFunction>
|
|
{
|
|
public:
|
|
explicit CompilerFunctionList();
|
|
explicit CompilerFunctionList(const CompilerFunctionList &src);
|
|
CompilerFunction *Add(CompilerFunctionType type, uint64_t address);
|
|
virtual void AddObject(CompilerFunction *func);
|
|
CompilerFunction *GetFunctionByAddress(uint64_t address) const;
|
|
CompilerFunction *GetFunctionByLowerAddress(uint64_t address) const;
|
|
CompilerFunctionList *Clone() const;
|
|
uint64_t GetRegistrValue(uint64_t address, uint64_t registr) const;
|
|
uint32_t GetSDKOptions() const;
|
|
uint32_t GetRuntimeOptions() const;
|
|
void Rebase(uint64_t delta_base);
|
|
private:
|
|
std::map<uint64_t, CompilerFunction*> map_;
|
|
|
|
// no assignment op
|
|
CompilerFunctionList &operator =(const CompilerFunctionList &);
|
|
};
|
|
|
|
class IRuntimeFunction : public IObject
|
|
{
|
|
public:
|
|
virtual IRuntimeFunction *Clone(IRuntimeFunctionList *owner) const = 0;
|
|
virtual uint64_t address() const = 0;
|
|
virtual uint64_t begin() const = 0;
|
|
virtual uint64_t end() const = 0;
|
|
virtual uint64_t unwind_address() const = 0;
|
|
virtual void set_begin(uint64_t begin) = 0;
|
|
virtual void set_end(uint64_t end) = 0;
|
|
virtual void set_unwind_address(uint64_t unwind_address) = 0;
|
|
virtual void Parse(IArchitecture &file, IFunction &dest) = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
|
|
using IObject::CompareWith;
|
|
int CompareWith(const IRuntimeFunction &obj) const
|
|
{
|
|
if (begin() < obj.begin())
|
|
return -1;
|
|
if (begin() > obj.begin())
|
|
return 1;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
class IRuntimeFunctionList : public ObjectList<IRuntimeFunction>
|
|
{
|
|
public:
|
|
virtual IRuntimeFunction *GetFunctionByAddress(uint64_t address) const = 0;
|
|
virtual IRuntimeFunction *GetFunctionByUnwindAddress(uint64_t address) const = 0;
|
|
virtual IRuntimeFunction *Add(uint64_t address, uint64_t begin, uint64_t end, uint64_t unwind_address, IRuntimeFunction *source, const std::vector<uint8_t> &call_frame_instructions) = 0;
|
|
};
|
|
|
|
class BaseRuntimeFunction : public IRuntimeFunction
|
|
{
|
|
public:
|
|
explicit BaseRuntimeFunction(IRuntimeFunctionList *owner);
|
|
explicit BaseRuntimeFunction(IRuntimeFunctionList *owner, const BaseRuntimeFunction &src);
|
|
~BaseRuntimeFunction();
|
|
private:
|
|
IRuntimeFunctionList *owner_;
|
|
};
|
|
|
|
class BaseRuntimeFunctionList : public IRuntimeFunctionList
|
|
{
|
|
public:
|
|
explicit BaseRuntimeFunctionList();
|
|
explicit BaseRuntimeFunctionList(const BaseRuntimeFunctionList &src);
|
|
virtual void clear();
|
|
virtual IRuntimeFunction *GetFunctionByAddress(uint64_t address) const;
|
|
virtual IRuntimeFunction *GetFunctionByUnwindAddress(uint64_t address) const;
|
|
virtual void Rebase(uint64_t delta_base);
|
|
virtual void AddObject(IRuntimeFunction *obj);
|
|
private:
|
|
std::map<uint64_t, IRuntimeFunction *> map_;
|
|
std::map<uint64_t, IRuntimeFunction *> unwind_map_;
|
|
|
|
// not impl
|
|
BaseRuntimeFunctionList &operator =(const BaseRuntimeFunctionList &);
|
|
};
|
|
|
|
struct CompileOptions {
|
|
uint32_t flags;
|
|
uint32_t vm_flags;
|
|
uint32_t sdk_flags;
|
|
size_t vm_count;
|
|
std::string section_name;
|
|
std::string messages[MESSAGE_COUNT];
|
|
Watermark *watermark;
|
|
Script *script;
|
|
IArchitecture **architecture;
|
|
#ifdef ULTIMATE
|
|
std::string hwid;
|
|
LicensingManager *licensing_manager;
|
|
FileManager *file_manager;
|
|
#endif
|
|
CompileOptions() : flags(0), vm_flags(0), sdk_flags(0), vm_count(1), watermark(NULL), script(NULL), architecture(NULL)
|
|
#ifdef ULTIMATE
|
|
, licensing_manager(NULL), file_manager(NULL)
|
|
#endif
|
|
{}
|
|
};
|
|
|
|
class Folder : public ObjectList<Folder>
|
|
{
|
|
public:
|
|
explicit Folder(Folder *owner, const std::string &name);
|
|
explicit Folder(Folder *owner, const Folder &src);
|
|
virtual ~Folder();
|
|
Folder *Clone(Folder *owner) const;
|
|
Folder *Add(const std::string &name);
|
|
std::string name() const { return name_; }
|
|
Folder *owner() const { return owner_; }
|
|
void set_name(const std::string &name);
|
|
bool read_only() const { return read_only_; }
|
|
void set_read_only(bool read_only) { read_only_ = read_only; }
|
|
std::string id() const;
|
|
void set_owner(Folder *owner);
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
Folder *GetFolderById(const std::string &id) const;
|
|
private:
|
|
void changed();
|
|
Folder *owner_;
|
|
std::string name_;
|
|
bool read_only_;
|
|
};
|
|
|
|
class FunctionBundle;
|
|
class FunctionBundleList;
|
|
|
|
class FolderList : public Folder
|
|
{
|
|
public:
|
|
explicit FolderList(IFile *owner);
|
|
explicit FolderList(IFile *owner, const FolderList &src);
|
|
FolderList *Clone(IFile *owner) const;
|
|
std::vector<Folder*> GetFolderList(bool skip_read_only = false) const;
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
IFile *owner() const { return owner_; }
|
|
private:
|
|
IFile *owner_;
|
|
};
|
|
|
|
class FunctionArch : public IObject
|
|
{
|
|
public:
|
|
explicit FunctionArch(FunctionBundle *owner, IArchitecture *arch, IFunction *func);
|
|
~FunctionArch();
|
|
IArchitecture *arch() const { return arch_; }
|
|
IFunction *func() const { return func_; }
|
|
private:
|
|
FunctionBundle *owner_;
|
|
IArchitecture *arch_;
|
|
IFunction *func_;
|
|
};
|
|
|
|
struct FunctionBundleHash {
|
|
std::string name;
|
|
bool is_unknown;
|
|
FunctionBundleHash(const std::string &name_, bool is_unknown_) : name(name_), is_unknown(is_unknown_) {}
|
|
bool operator < (const FunctionBundleHash &hash) const
|
|
{
|
|
int res = name.compare(hash.name);
|
|
return (res != 0) ? (res < 0) : (is_unknown < hash.is_unknown);
|
|
}
|
|
};
|
|
|
|
class FunctionBundle : public ObjectList<FunctionArch>
|
|
{
|
|
public:
|
|
explicit FunctionBundle(FunctionBundleList *owner, const FunctionName &name, bool is_unknown);
|
|
~FunctionBundle();
|
|
FunctionArch *Add(IArchitecture *arch, IFunction *func);
|
|
std::string name() const { return name_.name(); }
|
|
bool is_unknown() const { return is_unknown_; }
|
|
std::string display_name() const { return name_.display_name(); }
|
|
bool need_compile() const;
|
|
void set_need_compile(bool need_compile);
|
|
CompilationType compilation_type() const;
|
|
CompilationType default_compilation_type() const;
|
|
void set_compilation_type(CompilationType compilation_type);
|
|
uint32_t compilation_options() const;
|
|
void set_compilation_options(uint32_t compilation_options);
|
|
Folder *folder() const;
|
|
void set_folder(Folder *folder);
|
|
ObjectType type() const;
|
|
std::string display_address() const;
|
|
std::string display_protection() const;
|
|
std::string id() const { return (type() == otUnknown) ? display_name() : display_address(); }
|
|
bool show_arch_name() const;
|
|
FunctionArch *GetArchByFunction(IFunction *func) const;
|
|
ICommand *GetCommandByAddress(IArchitecture *file, uint64_t address) const;
|
|
private:
|
|
FunctionBundleList *owner_;
|
|
FunctionName name_;
|
|
bool is_unknown_;
|
|
};
|
|
|
|
class FunctionBundleList : public ObjectList<FunctionBundle>
|
|
{
|
|
public:
|
|
explicit FunctionBundleList();
|
|
FunctionBundle *Add(IArchitecture *arch, IFunction *func);
|
|
virtual void AddObject(FunctionBundle *bundle);
|
|
virtual void RemoveObject(FunctionBundle *bundle);
|
|
FunctionBundle *GetFunctionByFunc(IFunction *func) const;
|
|
FunctionBundle *GetFunctionByAddress(IArchitecture *arch, uint64_t address) const;
|
|
FunctionBundle *GetFunctionById(const std::string &id) const;
|
|
FunctionBundle *GetFunctionByName(const std::string &name, bool need_unknown = false) const;
|
|
bool show_arch_name() const { return show_arch_name_; }
|
|
void set_show_arch_name(bool show_arch_name) { show_arch_name_ = show_arch_name; }
|
|
private:
|
|
std::map<FunctionBundleHash, FunctionBundle *> map_;
|
|
bool show_arch_name_;
|
|
};
|
|
|
|
enum OpenMode {
|
|
foRead = 0x01,
|
|
foWrite = 0x02,
|
|
foHeaderOnly = 0x04,
|
|
foCopyToTemp = 0x08
|
|
};
|
|
|
|
enum OpenStatus {
|
|
osSuccess,
|
|
osOpenError,
|
|
osUnknownFormat,
|
|
osInvalidFormat,
|
|
osUnsupportedCPU,
|
|
osUnsupportedSubsystem
|
|
};
|
|
|
|
class AbstractStream;
|
|
class ILog;
|
|
|
|
struct ResourceInfo {
|
|
const uint8_t *file;
|
|
size_t size;
|
|
const uint8_t *code;
|
|
};
|
|
|
|
class IFile : public ObjectList<IArchitecture>
|
|
{
|
|
public:
|
|
explicit IFile(ILog *log);
|
|
explicit IFile(const IFile &src, const char *file_name);
|
|
virtual ~IFile();
|
|
virtual std::string format_name() const { return std::string("Unknown"); }
|
|
virtual bool OpenResource(const void *resource, size_t size, bool is_enc);
|
|
virtual bool OpenModule(uint32_t process_id, HMODULE module);
|
|
virtual OpenStatus Open(const char *file_name, uint32_t open_mode, std::string *error = NULL);
|
|
virtual void Close();
|
|
virtual IFile *Clone(const char *file_name) const;
|
|
virtual std::string file_name(bool is_real = false) const { return (is_real && !file_name_tmp_.empty()) ? file_name_tmp_ : file_name_; };
|
|
virtual std::string version() const { return std::string(); };
|
|
virtual std::string exec_command() const { return std::string(); };
|
|
uint8_t ReadByte();
|
|
uint16_t ReadWord();
|
|
uint32_t ReadDWord();
|
|
uint64_t ReadQWord();
|
|
size_t Read(void *buffer, size_t count);
|
|
size_t Write(const void *buffer, size_t count);
|
|
void Flush();
|
|
std::string ReadString();
|
|
uint64_t Seek(uint64_t position);
|
|
uint64_t Tell();
|
|
uint64_t size() const;
|
|
uint64_t Resize(uint64_t size);
|
|
virtual bool Compile(CompileOptions &options);
|
|
virtual IFile *runtime() const { return NULL; }
|
|
uint64_t CopyFrom(IFile &source, uint64_t count);
|
|
void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
void StartProgress(const std::string &caption, unsigned long long max) const;
|
|
void StepProgress(unsigned long long value = 1ull) const;
|
|
void EndProgress() const;
|
|
void set_log(ILog *log) { log_ = log; }
|
|
std::map<Watermark *, size_t> SearchWatermarks(const WatermarkManager &watermark_list);
|
|
virtual bool is_executable() const { return false; }
|
|
size_t visible_count() const;
|
|
IArchitecture *GetArchitectureByType(uint32_t type) const;
|
|
IArchitecture *GetArchitectureByName(const std::string &name) const;
|
|
FolderList *folder_list() const { return folder_list_; }
|
|
MapFunctionBundleList *map_function_list() const { return map_function_list_; }
|
|
FunctionBundleList *function_list() const { return function_list_; }
|
|
virtual uint32_t disable_options() const { return 0; }
|
|
AbstractStream *stream() const { return stream_; }
|
|
protected:
|
|
AbstractStream *stream_;
|
|
void CloseStream();
|
|
virtual OpenStatus ReadHeader(uint32_t /*open_mode*/) { return osSuccess; }
|
|
private:
|
|
std::string file_name_, file_name_tmp_;
|
|
ILog *log_;
|
|
bool skip_change_notifications_;
|
|
FolderList *folder_list_;
|
|
MapFunctionBundleList *map_function_list_;
|
|
FunctionBundleList *function_list_;
|
|
|
|
// no copy ctr or assignment op
|
|
IFile(const IFile &);
|
|
IFile &operator =(const IFile &);
|
|
};
|
|
|
|
class MemoryManager;
|
|
|
|
class MemoryRegion: public IObject
|
|
{
|
|
public:
|
|
explicit MemoryRegion(MemoryManager *owner, uint64_t address, size_t size,
|
|
uint32_t type, IFunction *parent_function);
|
|
~MemoryRegion();
|
|
uint64_t address() const { return address_; }
|
|
uint64_t end_address() const { return end_address_; }
|
|
size_t size() const { return static_cast<size_t>(end_address_ - address_); }
|
|
uint32_t type() const { return type_; }
|
|
IFunction *parent_function() const { return parent_function_; }
|
|
uint64_t Alloc(uint64_t memory_size, uint32_t memory_type);
|
|
|
|
using IObject::CompareWith;
|
|
int CompareWith(const MemoryRegion &obj) const;
|
|
bool Merge(const MemoryRegion &src);
|
|
MemoryRegion *Subtract(uint64_t remove_address, size_t size);
|
|
void exclude_type(MemoryTypeFlags type) { type_ &= ~type; }
|
|
void set_owner(MemoryManager *owner) { owner_ = owner; }
|
|
private:
|
|
MemoryManager *owner_;
|
|
uint64_t address_;
|
|
uint64_t end_address_;
|
|
uint32_t type_;
|
|
IFunction *parent_function_;
|
|
};
|
|
|
|
class MemoryManager : public ObjectList<MemoryRegion>
|
|
{
|
|
public:
|
|
explicit MemoryManager(IArchitecture *owner);
|
|
uint64_t Alloc(size_t size, uint32_t memory_type, uint64_t address = 0, size_t alignment = 0);
|
|
MemoryRegion *GetRegionByAddress(uint64_t address) const;
|
|
void Add(uint64_t address, size_t size);
|
|
void Add(uint64_t address, size_t size, uint32_t type, IFunction *parent_function = NULL);
|
|
void Remove(uint64_t address, size_t size);
|
|
void Pack();
|
|
IArchitecture *owner() const { return owner_; }
|
|
private:
|
|
size_t IndexOfAddress(uint64_t address) const;
|
|
struct CompareHelper {
|
|
bool operator () (const MemoryRegion *region, uint64_t address) const
|
|
{
|
|
return (region->address() < address);
|
|
}
|
|
|
|
bool operator () (uint64_t address, const MemoryRegion *region) const
|
|
{
|
|
return (address < region->address());
|
|
}
|
|
};
|
|
|
|
IArchitecture *owner_;
|
|
};
|
|
|
|
struct CRCInfo {
|
|
struct POD {
|
|
uint32_t address;
|
|
uint32_t size;
|
|
uint32_t hash;
|
|
} pod;
|
|
|
|
CRCInfo()
|
|
{
|
|
pod.address = 0;
|
|
pod.size = 0;
|
|
pod.hash = 0;
|
|
}
|
|
|
|
CRCInfo(uint32_t address_, const std::vector<uint8_t> &dump);
|
|
};
|
|
|
|
class CRCTable
|
|
{
|
|
public:
|
|
CRCTable(ValueCryptor *cryptor, size_t max_size);
|
|
~CRCTable();
|
|
void Add(uint64_t address, size_t size);
|
|
void Remove(uint64_t address, size_t size);
|
|
size_t WriteToFile(IArchitecture &file, bool is_positions, uint32_t *hash = NULL);
|
|
private:
|
|
std::vector<CRCInfo> crc_info_list_;
|
|
MemoryManager *manager_;
|
|
CRCValueCryptor *cryptor_;
|
|
size_t max_size_;
|
|
|
|
// no copy ctr or assignment op
|
|
CRCTable(const CRCTable &);
|
|
CRCTable &operator =(const CRCTable &);
|
|
};
|
|
|
|
struct CompileContext {
|
|
CompileOptions options;
|
|
IArchitecture *file;
|
|
IArchitecture *runtime;
|
|
IArchitecture *vm_runtime;
|
|
MemoryManager *manager;
|
|
size_t runtime_var_index[VAR_COUNT];
|
|
size_t runtime_var_salt[VAR_COUNT];
|
|
CompileContext() : file(NULL), runtime(NULL), vm_runtime(NULL), manager(NULL)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i <= VAR_CPU_HASH; i++) {
|
|
runtime_var_index[i] = i;
|
|
runtime_var_salt[i] = static_cast<uint32_t>(rand());
|
|
}
|
|
for (i = 0; i <= VAR_CPU_HASH; i++) {
|
|
std::swap(runtime_var_index[i], runtime_var_index[rand() % (VAR_CPU_HASH + 1)]);
|
|
}
|
|
for (i = 0; i <= VAR_CPU_HASH; i++) {
|
|
if (runtime_var_index[i] > runtime_var_index[VAR_CPU_HASH])
|
|
runtime_var_index[i] += VAR_COUNT - VAR_CPU_HASH - 1;
|
|
}
|
|
for (i = VAR_CPU_HASH + 1; i < VAR_COUNT; i++) {
|
|
runtime_var_index[i] = runtime_var_index[VAR_CPU_HASH] + i - VAR_CPU_HASH;
|
|
runtime_var_salt[i] = runtime_var_salt[VAR_CPU_HASH];
|
|
}
|
|
}
|
|
};
|
|
|
|
class MarkerCommandList;
|
|
|
|
class MarkerCommand: public IObject
|
|
{
|
|
public:
|
|
explicit MarkerCommand(MarkerCommandList *owner, uint64_t address, uint64_t operand_address,
|
|
uint64_t name_reference, uint64_t name_address, ObjectType type);
|
|
explicit MarkerCommand(MarkerCommandList *owner, const MarkerCommand &src);
|
|
~MarkerCommand();
|
|
MarkerCommand *Clone(MarkerCommandList *owner) const;
|
|
uint64_t address() const { return address_; }
|
|
uint64_t operand_address() const { return operand_address_; }
|
|
uint64_t name_address() const { return name_address_; }
|
|
uint64_t name_reference() const { return name_reference_; }
|
|
ObjectType type() const { return type_; }
|
|
|
|
using IObject::CompareWith;
|
|
int CompareWith(const MarkerCommand &obj) const;
|
|
private:
|
|
MarkerCommandList *owner_;
|
|
uint64_t address_;
|
|
uint64_t operand_address_;
|
|
uint64_t name_address_;
|
|
uint64_t name_reference_;
|
|
ObjectType type_;
|
|
};
|
|
|
|
class MarkerCommandList : public ObjectList<MarkerCommand>
|
|
{
|
|
public:
|
|
explicit MarkerCommandList();
|
|
explicit MarkerCommandList(const MarkerCommandList &src);
|
|
MarkerCommandList *Clone() const;
|
|
MarkerCommand *Add(uint64_t address, uint64_t operand_address, uint64_t name_reference,
|
|
uint64_t name_address, ObjectType type = otUnknown);
|
|
private:
|
|
// no assignment op
|
|
MarkerCommandList &operator =(const MarkerCommandList &);
|
|
};
|
|
|
|
enum CallingConvention {
|
|
ccStdcall,
|
|
ccCdecl,
|
|
ccMSx64,
|
|
ccABIx64,
|
|
ccStdcallToMSx64
|
|
};
|
|
|
|
class IArchitecture : public IObject
|
|
{
|
|
public:
|
|
virtual std::string name() const = 0;
|
|
virtual uint32_t type() const = 0;
|
|
virtual OperandSize cpu_address_size() const = 0;
|
|
virtual uint64_t entry_point() const = 0;
|
|
virtual uint32_t segment_alignment() const = 0;
|
|
virtual ILoadCommandList *command_list() const = 0;
|
|
virtual ISectionList *segment_list() const = 0;
|
|
virtual ISectionList *section_list() const = 0;
|
|
virtual IImportList *import_list() const = 0;
|
|
virtual IExportList *export_list() const = 0;
|
|
virtual IFixupList *fixup_list() const = 0;
|
|
virtual IRelocationList *relocation_list() const = 0;
|
|
virtual IFunctionList *function_list() const = 0;
|
|
virtual IVirtualMachineList *virtual_machine_list() const = 0;
|
|
virtual IResourceList *resource_list() const = 0;
|
|
virtual ISEHandlerList *seh_handler_list() const = 0;
|
|
virtual std::string map_file_name() const = 0;
|
|
virtual MapFunctionList *map_function_list() const = 0;
|
|
virtual CompilerFunctionList *compiler_function_list() const = 0;
|
|
virtual IRuntimeFunctionList *runtime_function_list() const = 0;
|
|
virtual MarkerCommandList *end_marker_list() const = 0;
|
|
virtual bool visible() const = 0;
|
|
virtual uint8_t ReadByte() = 0;
|
|
virtual uint16_t ReadWord() = 0;
|
|
virtual uint32_t ReadDWord() = 0;
|
|
virtual uint64_t ReadQWord() = 0;
|
|
virtual size_t Read(void *buffer, size_t count) const = 0;
|
|
virtual size_t WriteByte(uint8_t value) = 0;
|
|
virtual size_t WriteWord(uint16_t value) = 0;
|
|
virtual size_t WriteDWord(uint32_t value) = 0;
|
|
virtual size_t WriteQWord(uint64_t value) = 0;
|
|
virtual size_t Write(const void *buffer, size_t count) = 0;
|
|
virtual std::string ReadString() = 0;
|
|
virtual std::string ReadString(uint64_t address) = 0;
|
|
virtual uint64_t Seek(uint64_t position) const = 0;
|
|
virtual uint64_t Tell() const = 0;
|
|
virtual uint64_t AddressTell() = 0;
|
|
virtual uint64_t Resize(uint64_t size) = 0;
|
|
virtual bool AddressSeek(uint64_t address) = 0;
|
|
virtual bool Compile(CompileOptions &options, IArchitecture *runtime) = 0;
|
|
virtual void Save(CompileContext &ctx) = 0;
|
|
virtual IFile *owner() const = 0;
|
|
virtual ISection *selected_segment() const = 0;
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const = 0;
|
|
virtual void StartProgress(const std::string &caption, unsigned long long max) const = 0;
|
|
virtual void StepProgress(unsigned long long value = 1ull) const = 0;
|
|
virtual void EndProgress() const = 0;
|
|
virtual const IArchitecture *source() const = 0;
|
|
virtual uint64_t offset() const = 0;
|
|
virtual uint64_t size() const = 0;
|
|
virtual uint64_t image_base() const = 0;
|
|
virtual CallingConvention calling_convention() const = 0;
|
|
virtual uint64_t CopyFrom(const IArchitecture &src, uint64_t count) = 0;
|
|
virtual void ReadFromBuffer(Buffer &buffer) = 0;
|
|
virtual bool WriteToFile() = 0;
|
|
virtual bool is_executable() const = 0;
|
|
virtual IArchitecture *Clone(IFile *owner) const = 0;
|
|
virtual std::string ANSIToUTF8(const std::string &str) const = 0;
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const = 0;
|
|
#endif
|
|
};
|
|
|
|
class BaseArchitecture : public IArchitecture
|
|
{
|
|
public:
|
|
explicit BaseArchitecture(IFile *owner, uint64_t offset, uint64_t size);
|
|
explicit BaseArchitecture(IFile *owner, const BaseArchitecture &src);
|
|
virtual ~BaseArchitecture();
|
|
virtual MapFunctionList *map_function_list() const { return map_function_list_; }
|
|
virtual CompilerFunctionList *compiler_function_list() const { return compiler_function_list_; }
|
|
virtual MarkerCommandList *end_marker_list() const { return end_marker_list_; }
|
|
virtual std::string map_file_name() const;
|
|
virtual uint8_t ReadByte() { return owner_->ReadByte(); }
|
|
virtual uint16_t ReadWord() { return owner_->ReadWord(); }
|
|
virtual uint32_t ReadDWord() { return owner_->ReadDWord(); }
|
|
virtual uint64_t ReadQWord() { return owner_->ReadQWord(); }
|
|
virtual size_t Read(void *buffer, size_t count) const { return owner_->Read(buffer, count); }
|
|
virtual size_t WriteByte(uint8_t value) { return Write(&value, sizeof(value)); }
|
|
virtual size_t WriteWord(uint16_t value) { return Write(&value, sizeof(value)); }
|
|
virtual size_t WriteDWord(uint32_t value) { return Write(&value, sizeof(value)); }
|
|
virtual size_t WriteQWord(uint64_t value) { return Write(&value, sizeof(value)); }
|
|
virtual size_t Write(const void *buffer, size_t count) { return owner_->Write(buffer, count); }
|
|
virtual std::string ReadString() { return owner_->ReadString(); }
|
|
virtual std::string ReadString(uint64_t address);
|
|
virtual uint64_t Seek(uint64_t position) const;
|
|
virtual uint64_t Tell() const;
|
|
virtual uint64_t Resize(uint64_t size);
|
|
virtual bool AddressSeek(uint64_t address);
|
|
virtual uint64_t AddressTell();
|
|
virtual bool visible() const { return (function_list() != NULL); }
|
|
virtual bool Compile(CompileOptions &options, IArchitecture *runtime);
|
|
virtual IFile *owner() const { return owner_; }
|
|
virtual ISection *selected_segment() const { return selected_segment_; }
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
virtual void StartProgress(const std::string &caption, unsigned long long max) const;
|
|
virtual void StepProgress(unsigned long long value = 1) const;
|
|
virtual void EndProgress() const;
|
|
virtual const IArchitecture *source() const { return source_; }
|
|
virtual uint64_t offset() const { return offset_; }
|
|
virtual uint64_t size() const { return append_mode_ ? owner_->size() - offset_ : size_; }
|
|
virtual void ReadFromBuffer(Buffer &buffer);
|
|
virtual uint64_t CopyFrom(const IArchitecture &src, uint64_t count);
|
|
virtual uint64_t time_stamp() const { return 0; }
|
|
virtual std::string ANSIToUTF8(const std::string &str) const { return str; }
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const;
|
|
#endif
|
|
protected:
|
|
MemoryManager *memory_manager() const { return memory_manager_; }
|
|
virtual bool Prepare(CompileContext &ctx);
|
|
virtual bool ReadMapFile(IMapFile &map_file);
|
|
void Rebase(uint64_t delta_base);
|
|
void set_append_mode(bool value) { append_mode_ = value; }
|
|
private:
|
|
std::string ReadANSIString(uint64_t address);
|
|
std::string ReadUnicodeString(uint64_t address);
|
|
std::string ReadANSIStringWithLength(uint64_t address);
|
|
IFile *owner_;
|
|
const IArchitecture *source_;
|
|
uint64_t offset_;
|
|
uint64_t size_;
|
|
MapFunctionList *map_function_list_;
|
|
CompilerFunctionList *compiler_function_list_;
|
|
MarkerCommandList *end_marker_list_;
|
|
MemoryManager *memory_manager_;
|
|
ISection *selected_segment_;
|
|
bool append_mode_;
|
|
|
|
// no copy ctr or assignment op
|
|
BaseArchitecture(const BaseArchitecture &);
|
|
BaseArchitecture &operator =(const BaseArchitecture &);
|
|
};
|
|
|
|
#endif |