Sinker Runtime Library

class sinker::Action

Subclassed by sinker::ActionInstall, sinker::ActionUninstall

Public Functions

virtual void act() = 0

class sinker::ActionInstall : public sinker::Action 

Public Functions

inline ActionInstall(Installable *installable)

inline virtual void act() override

Private Members

Installable *installable = nullptr

class sinker::ActionUninstall : public sinker::Action 

Public Functions

inline ActionUninstall(Uninstallable *uninstallable)

inline virtual void act() override

Private Members

Uninstallable *uninstallable = nullptr

class sinker::Attributable

Subclassed by sinker::Module, sinker::Symbol

Public Functions

template<typename T> std::optional<T> get_attribute(std::string_view attribute_name) const

template<typename T> void set_attribute(std::string const &attribute_name, T value)

std::map<std::string, attribute_value_t, std::less<>> const &get_attributes() const

Private Members

std::map<std::string, attribute_value_t, std::less<>> attributes

class sinker::BinaryOperatorExpression : private sinker::Expression 

Public Functions

inline BinaryOperatorExpression(std::shared_ptr<Expression> lhs, std::shared_ptr<Expression> rhs, BinaryOperator binary_operator)

inline virtual std::optional<expression_value_t> calculate(Symbol *symbol) const override

inline virtual void dump(std::ostream &out) const override

Private Members

std::shared_ptr<Expression> lhs

std::shared_ptr<Expression> rhs

BinaryOperator binary_operator

class sinker::Context

Public Functions

inline Context()

Context(const Context&) = delete

Context &operator=(const Context&) = delete

inline std::vector<Module*> const &get_modules() const

Module *get_module(std::string_view module_name)

void emplace_module(std::string_view name, std::optional<std::string> lpModuleName)

void dump(std::ostream &out) const

void dump_def(std::ostream &out) const

bool interpret(std::istream &input_stream, Language language, std::string input_filename, bool debug = false)

bool interpret(const char *input, std::size_t size, Language language, std::string input_filename, bool debug = false)

bool interpret(const std::string &input, Language language, std::string input_filename, bool debug = false)

void add_module_tag(std::string const &tag)

void add_symbol_tag(std::string const &tag)

identifier_set_t const &get_symbol_tags() const

~Context()

Private Members

std::vector<Module*> modules

identifier_set_t module_tags

identifier_set_t symbol_tags

template<typename T> class sinker::Detour : public sinker::Installable, public sinker::Uninstallable 

Public Functions

inline Detour(T &real, T wrap)

inline virtual void install() override

inline virtual void uninstall() override

Private Members

T *real = {}

T wrap = {}

class sinker::Expression

Subclassed by sinker::BinaryOperatorExpression, sinker::GetProcAddressExpression, sinker::IntegerExpression, sinker::ModuleExpression, sinker::PatternMatchExpression, sinker::SymbolExpression, sinker::UnaryOperatorExpression

Public Functions

virtual std::optional<expression_value_t> calculate(Symbol *symbol) const = 0

virtual void dump(std::ostream &out) const = 0

inline virtual ~Expression()

class sinker::GetProcAddressExpression : private sinker::Expression 

Public Functions

inline GetProcAddressExpression(Module *module, std::string const &lpProcName)

inline virtual std::optional<expression_value_t> calculate(Symbol *symbol) const override

inline virtual void dump(std::ostream &out) const override

Private Members

Module *module

std::string lpProcName

class sinker::Installable

Subclassed by sinker::Detour< T >, sinker::Patch< T >, sinker::Patch< T[N]>

Public Functions

virtual void install() = 0

class sinker::IntegerExpression : private sinker::Expression 

Public Functions

inline IntegerExpression(expression_value_t value)

inline virtual std::optional<expression_value_t> calculate(Symbol *symbol) const override

inline virtual void dump(std::ostream &out) const override

Private Members

expression_value_t value

struct sinker::MaskedByte

Public Members

std::uint8_t value

std::uint8_t mask

class sinker::Module : public sinker::Attributable 

Public Functions

Module(const Module&) = delete

Module &operator=(const Module&) = delete

Module(Module&&) = default

Module &operator=(Module &&mE) = default

std::string const &get_name() const

std::string const &get_real_variant() const

Symbol *get_symbol(std::string_view symbol_name)

void emplace_symbol(std::string const &name, std::string const &type)

void add_variant(std::string const &name, std::string const &hash)

bool has_variant(std::string_view name) const

void dump(std::ostream &out) const

void dump_def(std::ostream &out) const

std::optional<expression_value_t> get_preferred_base_address() const

std::optional<expression_value_t> get_relocated_base_address() const

HMODULE get_hModule() const

void add_tag(std::string const &tag)

Context *get_context() const

bool concretize()

bool is_concrete() const

Private Functions

inline Module(std::string_view name, std::optional<std::string> lpModuleName, Context *context)

Private Members

Context *context

std::string name

std::optional<std::string> lpModuleName

std::optional<expression_value_t> preferred_base_address

std::optional<expression_value_t> relocated_base_address

std::vector<Symbol> symbols

std::map<std::string, std::string, std::less<>> variants

std::string real_variant

HMODULE hModule = 0

identifier_set_t tags

Friends

friend class Context

class sinker::ModuleExpression : private sinker::Expression 

Public Functions

inline ModuleExpression(Module *module)

inline virtual std::optional<expression_value_t> calculate(Symbol *symbol) const override

inline virtual void dump(std::ostream &out) const override

Private Members

Module *module

template<typename T> class sinker::Patch : public sinker::Installable, public sinker::Uninstallable 

Public Functions

inline Patch(T *dst, T *src)

inline virtual void install() override

inline virtual void uninstall() override

Private Members

T *dst = {}

T *src = {}

T backup = {}

template<typename T, std::size_t N> class sinker::Patch<T[N]> : public sinker::Installable, public sinker::Uninstallable 

Public Functions

inline Patch(T *dst, T *src)

inline virtual void install() override

inline virtual void uninstall() override

Private Members

T *dst = {}

T *src = {}

T backup[N] = {}

class sinker::PatternMatchExact : private sinker::PatternMatchFragment 

Public Functions

inline PatternMatchExact(const std::vector<std::uint8_t> &value)

inline virtual void *search(void *begin, void *end) const override

inline virtual bool begins_with(void *begin, void *end) const override

inline virtual std::size_t size() const override

inline virtual PatternMatchType type() const override

inline virtual bool collision(void *address) const

Private Members

std::vector<std::uint8_t> value

class sinker::PatternMatchExpression : private sinker::Expression 

Public Functions

inline PatternMatchExpression(std::vector<MaskedByte> const &needle, expression_value_t offset = 0, std::vector<PatternMatchFilter> const &filters = {})

inline virtual std::optional<expression_value_t> calculate(Symbol *symbol) const override

inline virtual void dump(std::ostream &out) const override

Private Members

std::vector<PatternMatchFilter> filters

std::vector<MaskedByte> needle

expression_value_t offset

class sinker::PatternMatchFilter

Public Functions

inline PatternMatchFilter(const Module *module = nullptr, std::optional<std::string> const &section_name = {})

inline const Module *get_module() const

inline std::optional<std::string> const &get_section_name() const

Private Members

const Module *module

std::optional<std::string> section_name

class sinker::PatternMatchFragment

Subclassed by sinker::PatternMatchExact, sinker::PatternMatchMask, sinker::PatternMatchWildcard

Public Functions

inline virtual ~PatternMatchFragment()

virtual void *search(void *begin, void *end) const = 0

virtual bool begins_with(void *begin, void *end) const = 0

virtual bool collision(void *address) const = 0

virtual std::size_t size() const = 0

virtual PatternMatchType type() const = 0

class sinker::PatternMatchMask : private sinker::PatternMatchFragment 

Public Functions

inline PatternMatchMask(std::vector<MaskedByte> const &value)

inline virtual void *search(void *begin, void *end) const override

inline virtual bool begins_with(void *begin, void *end) const override

inline virtual std::size_t size() const override

inline virtual PatternMatchType type() const override

inline virtual bool collision(void *address) const

Private Members

std::vector<MaskedByte> value

class sinker::PatternMatchNeedle

Public Functions

inline PatternMatchNeedle(std::vector<MaskedByte> const &needle)

inline void *search(void *begin, void *end) const

inline virtual bool collision(void *address) const

Private Members

std::vector<std::unique_ptr<PatternMatchFragment>> fragments = {}

std::size_t size = 0

std::size_t offset = 0

std::size_t index = 0

class sinker::PatternMatchWildcard : private sinker::PatternMatchFragment 

Public Functions

inline PatternMatchWildcard(std::size_t size)

inline virtual void *search(void *begin, void *end) const override

inline virtual bool begins_with(void *begin, void *end) const override

inline virtual std::size_t size() const override

inline virtual PatternMatchType type() const override

inline virtual bool collision(void *address) const

Private Members

std::size_t s

template<std::size_t S = 32, std::uint8_t C = 0xEF, bool D = true> class sinker::StackCheck

Public Functions

StackCheck()

bool good() const

~StackCheck()

Private Members

std::uint8_t buffer[S]

class sinker::Symbol : public sinker::Attributable 

Public Functions

Symbol(const Symbol&) = delete

Symbol &operator=(const Symbol&) = delete

Symbol(Symbol&&) = default

Symbol &operator=(Symbol &&mE) = default

inline std::string const &get_name() const

template<typename T> std::optional<T> calculate_address()

template<typename T> std::optional<T> get_cached_calculated_address() const

Module *get_module() const

void add_address(identifier_set_t const &variant_set, std::shared_ptr<Expression> expression)

void dump(std::ostream &out) const

void dump_def(std::ostream &out) const

void add_tag(std::string const &tag)

Private Functions

inline Symbol(std::string const &name, std::string const &type, Module *module)

Private Members

std::optional<expression_value_t> cached_calculated_address

std::string name

std::string type

Module *module

std::vector<std::pair<identifier_set_t, std::shared_ptr<Expression>>> addresses

identifier_set_t tags

Friends

friend class Module

class sinker::SymbolExpression : private sinker::Expression 

Public Functions

inline SymbolExpression(Symbol *symbol)

inline virtual std::optional<expression_value_t> calculate(Symbol *_symbol) const override

inline virtual void dump(std::ostream &out) const override

Private Members

Symbol *symbol

class sinker::Transaction

Public Functions

inline Transaction()

inline void add(Action *action)

inline long commit()

Private Members

std::vector<Action*> actions

class sinker::UnaryOperatorExpression : private sinker::Expression 

Public Functions

inline UnaryOperatorExpression(std::shared_ptr<Expression> expression, UnaryOperator unary_operator)

inline virtual std::optional<expression_value_t> calculate(Symbol *symbol) const override

inline virtual void dump(std::ostream &out) const override

Private Members

std::shared_ptr<Expression> expression

UnaryOperator unary_operator

class sinker::Uninstallable

Subclassed by sinker::Detour< T >, sinker::Patch< T >, sinker::Patch< T[N]>

Public Functions

virtual void uninstall() = 0

namespace sinker

Typedefs

typedef unsigned long long expression_value_t

typedef std::variant<expression_value_t, bool, std::string> attribute_value_t

typedef std::set<std::string> identifier_set_t

Enums

enum class Language

Values:

enumerator SINKER

enumerator SOURCE_CODE

enum class UnaryOperator

Values:

enumerator PARENTHESES

enumerator INDIRECTION

enumerator RELOCATION

enumerator BITWISE_NOT

enum class BinaryOperator

Values:

enumerator ADDITION

enumerator SUBTRACTION

enumerator MULTIPLICATION

enumerator INTEGER_DIVISION

enumerator MODULO

enumerator BITWISE_AND

enumerator BITWISE_OR

enumerator BITWISE_XOR

enumerator BITWISE_SHIFT_LEFT

enumerator BITWISE_SHIFT_RIGHT

enumerator ARRAY_SUBSCRIPT

enumerator POINTER_PATH

enum class PatternMatchType

Values:

enumerator EXACT

enumerator MASK

enumerator WILDCARD

enumerator COUNT

Functions

std::ostream &operator<<(std::ostream &out, attribute_value_t const &attribute_value)

std::ostream &operator<<(std::ostream &os, Expression const &expression)

std::ostream &operator<<(std::ostream &os, Context const &context)

std::ostream &operator<<(std::ostream &os, Symbol const &symbol)

std::ostream &operator<<(std::ostream &os, Module const &module)

inline std::optional<expression_value_t> CheckedDereference(expression_value_t value)

file sinker.hpp

#include <>

#include “”

Defines

PROPAGATE_UNRESOLVED(x)

dir /home/docs/checkouts/readthedocs.org/user_builds/sinker/checkouts/latest/sinker/include

dir /home/docs/checkouts/readthedocs.org/user_builds/sinker/checkouts/latest/sinker

dir /home/docs/checkouts/readthedocs.org/user_builds/sinker/checkouts/latest/sinker/include/sinker