# Классы

Встроенный скриптовый язык LUA программы VMProtect является объектно-ориентированным: по синтаксису, идеалогии и реализации он во многом похож на JavaScript. В состав скриптового языка входят как стандартные классы, обеспечивающие базовую функциональность, так и специализированные классы, предоставляющие доступ к функционалу защиты приложения.

### Иерархия классов

- Core
  - Watermarks
    - Watermark
  - Licenses
    - License
  - Files
    - File
  - Folders
    - Folder
  - PEFile
    - PEFormat
    - PEArchitecture
      - PESegments
        - PESegment
      - PESections
        - PESection
      - PEDirectories
        - PEDirectory
      - PEImports
        - PEImport
      - PEExports
        - PEExport
      - PEResources
        - PEResource
      - PEFixups
        - PEFixup
  - MacFile
    - MacFormat
    - MacArchitecture
      - MacSegments
        - MacSegment
      - MacSections
        - MacSection
      - MacCommands
        - MacCommand
      - MacSymbols
        - MacSymbol
      - MacImports
        - MacImport
      - MacExports
        - MacExport
      - MacFixups
        - MacFixup
  - MapFunctions
    - MapFunction
      - References
        - Reference
  - IntelFunctions
    - IntelFunction
      - IntelSegment
        - IntelRegistr
        - IntelCommandType
        - IntelFlag
        - IntelCommand
          - OperandType
            - IntelOperand
      - CommandLinks
        - LinkType
          - CommandLink
- FFILibrary
  - FFIFunction

### Ядро

Опции проекта:

    enum ProjectOption {
    	None,
    	Pack,
    	ImportProtection,
    	MemoryProtection,
    	ResourceProtection,
    	CheckDebugger,
    	CheckKernelDebugger,
    	CheckVirtualMachine,
    	StripFixups,
    	StripDebugInfo,
    	DebugMode
    }

Класс для работы с ядром VMProtect:

    class Core {
    public:
    	string projectFileName(); // возращает имя проекта
    	void saveProject(); // сохраняет проект
    	string inputFileName(); // возвращает имя исходного файла для текущего проекта
    	string outputFileName(); // возращает имя выходного файла для текущего проекта
    	void setOutputFileName(string name); // устанавливает имя выходного файла для текущего проекта
    	string watermarkName(); // возвращает имя водяного знака из текущего проекта
    	void setWatermarkName(string name); // устанавливает имя водяного знака для текущего проекта
    	int options(); // возвращает опции для текущего проекта
    	void setOptions(int options); // устанавливает опции для текущего проекта
    	string vmSectionName(); // возвращает имя сегмента ВМ для текущего проекта
    	void setVMSectionName(); // устанавливает имя сегмента ВМ для текущего проекта
    	Licenses licenses(); // возвращает список лицензий для текущего проекта
    	Files files(); // возвращает список файлов для текущего проекта
    	Watermarks watermarks(); // возвращает список водяных знаков
    	PEFile/MacFile inputFile(); // возвращает исходный файл
    	PEFile/MacFile outputFile(); // возвращает выходной файл
    	PEArchitecture/MacArchitecture inputArchitecture(); // возвращает исходную архитектуру
    	PEArchitecture/MacArchitecture outputArchitecture(); // возвращает выходную архитектуру
    };

### Водяные знаки

Класс для работы со списком водяных знаков:

    class Watermarks {
    public:
    	Watermark item(int index); // возвращает водяной знак с индексом index
    	int count(); // возвращает количество водяных знаков в списке
    	Watermark itemByName(string name); // возвращает водяной знак с именем name
    	Watermark add(string name, string value); // добавляет водяной знак с именем name и значением value
    }

Класс для работы с водяным знаком:

    class Watermark {
    public:
    	string name(); // возвращает имя водяного знака
    	string value(); // возвращает значение водяного знака
    	bool blocked(); // возвращает признак "Заблокирован"
    	void setBlocked(bool value); // устанавливает признак "Заблокирован"
    }

### Лицензии

Класс для работы со списком лицензий:

    class Licenses {
    public:
    	int keyLength(); // возвращает размер ключа
    	string publicExp(); // возвращает публичную экспоненту
    	string privateExp(); // возвращает приватную экспоненту
    	string modulus(); // возвращает модулус
    	License item(int index); // возвращает лицензию с индексом index
    	int count(); // возвращает количество лицензий в списке
    }

Класс для работы с лицензией:

    class License {
    public:
    	string date(string format = "%c"); // возвращает дату лицензии
    	string customerName(); // возвращает имя владельца лицензии
    	string customerEmail(); // возвращает адрес электронной почты владельца лицензии
    	string orderRef(); // возвращает номер заказа, по которому приобретена лицензия
    	string comments(); // возвращает комментарии к лицензии
    	string serialNumber(); // возвращает серийный номер лицензии
    	bool blocked(); // возвращает признак "Заблокирован"
    	void setBlocked(bool value); // устанавливает признак "Заблокирован"
    }

### Файлы

Класс для работы со списком файлов:

    class Files {
    public:
    	File item(int index); // возвращает файл с индексом index
    	int count(); // возвращает количество файлов в списке
    }

Класс для работы с файлом:

    class File {
    public:
    	string name(); // возвращает название файла
    	string fileName(); // возвращает имя файла
    	int options(); // возвращает опции
    	void setName(string name); // устанавливает название файла
    	void setFileName(string name); // устанавливает имя файла
    	void setOptions(); // устанавлиает опции
    }

### Папки

Класс для работы с пользовательскими папками:

    class Folders {
    public:
    	int count(); // возвращает количество папок в списке
    	Folder item(int index); // возвращает папку с индексом index
    	Folder add(string name); // добавляет новую папку
    	void clear(); // очищает список
    };

Класс для работы с пользовательской папкой:

    class Folder {
    public:
    	int count(); // возвращает количество подпапок
    	Folder item(int index); // возвращает подпапку с индексом index
    	Folder add(string name); // добавляет новую подпапку
    	string name(); // возвращает имя папки
    	void clear(); // очищает список подпапок
    	void destroy(); // уничтожает папку и все дочерние подпапки
    };

### PE файлы

Константы для работы с PE форматом:

    enum PEFormat {
    	// Directory Entries
    	IMAGE_DIRECTORY_ENTRY_EXPORT,
    	IMAGE_DIRECTORY_ENTRY_IMPORT,
    	IMAGE_DIRECTORY_ENTRY_RESOURCE,
    	IMAGE_DIRECTORY_ENTRY_EXCEPTION,
    	IMAGE_DIRECTORY_ENTRY_SECURITY,
    	IMAGE_DIRECTORY_ENTRY_BASERELOC,
    	IMAGE_DIRECTORY_ENTRY_DEBUG,
    	IMAGE_DIRECTORY_ENTRY_ARCHITECTURE,
    	IMAGE_DIRECTORY_ENTRY_TLS,
    	IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG,
    	IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT,
    	IMAGE_DIRECTORY_ENTRY_IAT,
    	IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT,
    	IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR,
    	// Section characteristics
    	IMAGE_SCN_CNT_CODE,
    	IMAGE_SCN_CNT_INITIALIZED_DATA,
    	IMAGE_SCN_CNT_UNINITIALIZED_DATA,
    	IMAGE_SCN_MEM_DISCARDABLE,
    	IMAGE_SCN_MEM_NOT_CACHED,
    	IMAGE_SCN_MEM_NOT_PAGED,
    	IMAGE_SCN_MEM_SHARED,
    	IMAGE_SCN_MEM_EXECUTE,
    	IMAGE_SCN_MEM_READ,
    	IMAGE_SCN_MEM_WRITE,
    	// Resource types
    	RT_CURSOR,
    	RT_BITMAP,
    	RT_ICON,
    	RT_MENU,
    	RT_DIALOG,
    	RT_STRING,
    	RT_FONTDIR,
    	RT_FONT,
    	RT_ACCELERATOR,
    	RT_RCDATA,
    	RT_MESSAGETABLE,
    	RT_GROUP_CURSOR,
    	RT_GROUP_ICON,
    	RT_VERSION,
    	RT_DLGINCLUDE,
    	RT_PLUGPLAY,
    	RT_VXD,
    	RT_ANICURSOR,
    	RT_ANIICON,
    	RT_HTML,
    	RT_MANIFEST,
    	RT_DLGINIT,
    	RT_TOOLBAR
    };

Класс для работы с PE файлом:

    class PEFile {
    public:
    	string name(); // возвращает имя файла
    	string format(); // возвращает имя формата "PE"
    	uint64 size(); // возвращает размер файла
    	int count(); // возвращает количество архитектур в списке
    	PEArchitecture item(int index); // возвращает архитектуру с индексом index
    	uint64 seek(uint64 offset); // устанавливает файловую позицию
    	uint64 tell(); // возвращает файловую позицию
    	int write(string buffer); // записывает буфер в файл
    };

Класс для работы с PE архитектурой:

    class PEArchitecture {
    public:
    	string name(); // возвращает имя архитектуры
    	PEFile file(); // возвращает родительский файл
    	uint64 entryPoint(); // возвращает стартовый адрес
    	uint64 imageBase(); // возвращает стартовый адрес
    	OperandSize cpuAddressSize(); // возвращает битность архитектуры
    	uint64 size(); // возвращает размер архитектуры
    	PESegments segments(); // возвращает список сегментов
    	PESections sections(); // возвращает список секций
    	PEDirectories directories(); // возвращает список директорий
    	PEImports imports(); // возвращает список импортируемых библиотек
    	PEExports exports(); // возвращает список экспортируемых функций
    	PEResources resources(); // возвращает список ресурсов
    	PEFixups fixups(); // возвращает список настраиваемых элементов
    	MapFunctions mapFunctions(); // возвращает список доступных для защиты функций
    	IntelFunctions functions(); // возвращает список защищаемых функций
    	bool addressSeek(uint64 address); // устанавливает файловую позицию
    	uint64 seek(uint64 offset); // устанавливает файловую позицию
    	uint64 tell(); // возвращает файловую позицию
    	int write(string buffer); // записывает буфер в файл
    };

Класс для работы cо списком сегментов для PE архитектуры:

    class PESegments {
    public:
    	PESegment item(int index); // возвращает сегмент с индексом index
    	int count(); // возвращает количество сегментов в списке
    	PESegment itemByAddress(uint64 address); // возвращает сегмент с адресом address
    };

Класс для работы c сегментом для PE архитектуры:

    class PESegment {
    public:
    	uint64 address(); // возвращает адрес сегмента
    	string name(); // возвращает имя сегмента
    	uint64 size(); // возвращает размер сегмента
    	int physicalOffset(); // возвращает файловую позицию сегмента
    	int physicalSize(); // возвращает файловый размер сегмента
    	int flags(); // возвращает флаги сегмента
    	bool excludedFromPacking(); // возвращает признак "Исключен из упаковки"
    	void setName(string name); // устанавливает имя сегмента
    };

Класс для работы cо списком секций для PE архитектуры:

    class PESections {
    public:
    	PESection item(int index); // возвращает секцию с индексом index
    	int count(); // возвращает количество секций в списке
    	PESection itemByAddress(uint64 address); // возвращает секцию с адресом address
    };

Класс для работы с секцией для PE архитектуры:

    class PESection {
    public:
    	uint64 address(); // возвращает адрес секции
    	string name(); // возвращает имя секции
    	uint64 size(); // возвращает размер секции
    	int offset(); // возвращает файловую позицию секции
    	PESegment segment(); // возвращает родительский сегмент
    };

Класс для работы с директориями для PE архитектуры:

    class PEDirectories {
    public:
    	PEDirectory item(int index); // возвращает директорию с индексом index
    	int count(); // возвращает количество директорий в списке
    	PEDirectory itemByType(int type); // возвращает директорию с типом type
    };

Класс для работы с директорией для PE архитектуры:

    class PEDirectory {
    public:
    	uint64 address(); // возвращает адрес директории
    	string name(); // возвращает имя директории
    	uint64 size(); // возвращает размер директории
    	int type(); // возвращает тип директории
    	void setAddress(uint64 address); // устанавливает адрес директории
    	void setSize(int size); // устанавливает размер директории
    	void clear(); // очищает адрес и размер директории
    };

Класс для работы со списком импортируемых библиотек для PE архитектуры:

    class PEImports {
    public:
    	PEImport item(int index); // возвращает библиотеку с индексом index
    	int count(); // возвращает количество библиотек в списке
    	PEImport itemByName(string name); // возвращает библиотеку с именем name
    };

Класс для работы с импортируемой библиотекой для PE архитектуры:

    class PEImport {
    public:
    	string name(); // возвращает имя библиотеки
    	PEImportFunction item(int index); // возвращает импортируемую функцию с индексом index
    	int count(); // возвращает количество импортируемых функций
    	void setName(string name); // устанавливает имя библиотеки
    };

Класс для работы с импортируемой функцией для PE архитектуры:

    class PEImportFunction {
    public:
    	uint64 address(); // возвращает адрес ячейки, в которую записывается адрес импортируемой функции
    	string name();  // возвращает имя импортируемой функции
    };

Класс для работы со списком экспортируемых функций для PE архитектуры:

    class PEExports {
    public:
    	string name(); // возвращает имя библиотеки
    	void setName(string name); // устанавливает имя библиотеки
    	PEExport item(int index); // возвращает экспортируемую функцию с индексом index
    	int count(); // возвращает количество экспортируемых функций в списке
    	void clear(); // очищает список
    	PEExport itemByAddress(uint64 address); // возвращает экспортируемую функцию с адресом address
    	PEExport itemByName(string name); // возвращает экспортируемую функцию с именем name
    };

Класс для работы с экспортируемой функцией для PE архитектуры:

    class PEExport {
    public:
    	uint64 address(); // возвращает адрес экспортируемой функции
    	string name(); // возвращает имя экспортируемой функции
    	void setName(string name); // устанавливает имя экспортируемой функции
    	int ordinal();  // возвращает ординал экспортируемой функции
    	string forwardedName(); // возвращает имя функции, на которую перенаправлена экспортируемая функция
    	void destroy(); // уничтожает экспортируемую функцию
    };

Класс для работы со списком ресурсов для PE архитектуры:

    class PEResources {
    public:
    	PEResource item(int index); // возвращает ресурс с индексом index
    	int count(); // возвращает количество ресурсов в списке
    	void clear(); // очищает список
    	PEResource itemByType(int type); // возвращает ресурс с типом type
    	PEResource itemByName(string name); // возвращает ресурс с именем name
    };

Класс для работы с ресурсом для PE архитектуры:

    class PEResource {
    public:
    	PEResource item(int index); // возвращает ресурс с индексом index
    	int count(); // возвращает количество ресурсов в списке
    	void clear(); // очищает список
    	uint64 address(); // возвращает адрес ресурса
    	int size(); // возвращает размер ресурса
    	string name(); // возвращает имя ресурса
    	int type(); // возвращает тип ресурса
    	bool isDirectory(); // возвращает признак "Директория"
    	void destroy(); // уничтожает ресурс
    	PEResource itemByName(string name); // возвращает ресурс с именем name
    	bool excludedFromPacking(); // возвращает признак "Исключен из упаковки"
    };

Класс для работы со списком настраиваемых элементов для PE архитектуры:

    class PEFixups {
    public:
    	PEFixup item(int index); // возвращает элемент с индексом index
    	int count(); // возвращает количество элементов в списке
    	PEFixup itemByAddress(uint64 address); // возвращает элемент с адресом address
    };

Класс для работы с настраиваемым элементом для PE архитектуры:

    class PEFixup {
    public:
    	uint64 address(); // возвращает адрес элемента
    };

### Mach-O файлы

Константы для работы с Mach-O форматом:

    enum MacFormat {
    	// Load Command Types
    	LC_SEGMENT,
    	LC_SYMTAB,
    	LC_SYMSEG,
    	LC_THREAD,
    	LC_UNIXTHREAD,
    	LC_LOADFVMLIB,
    	LC_IDFVMLIB,
    	LC_IDENT,
    	LC_FVMFILE,
    	LC_PREPAGE,
    	LC_DYSYMTAB,
    	LC_LOAD_DYLIB,
    	LC_ID_DYLIB,
    	LC_LOAD_DYLINKER,
    	LC_PREBOUND_DYLIB,
    	LC_ROUTINES,
    	LC_SUB_FRAMEWORK,
    	LC_SUB_UMBRELLA,
    	LC_SUB_CLIENT,
    	LC_SUB_LIBRARY,
    	LC_TWOLEVEL_HINTS,
    	LC_PREBIND_CKSUM,
    	LC_LOAD_WEAK_DYLIB,
    	LC_SEGMENT_64,
    	LC_ROUTINES_64,
    	LC_UUID,
    	LC_RPATH,
    	LC_CODE_SIGNATURE,
    	LC_SEGMENT_SPLIT_INFO,
    	LC_REEXPORT_DYLIB,
    	LC_LAZY_LOAD_DYLIB,
    	LC_ENCRYPTION_INFO,
    	LC_DYLD_INFO,
    	LC_DYLD_INFO_ONLY,
    	LC_LOAD_UPWARD_DYLIB,
    	LC_VERSION_MIN_MACOSX,
    	// Section Types
    	SECTION_TYPE,
    	SECTION_ATTRIBUTES,
    	S_REGULAR,
    	S_ZEROFILL,
    	S_CSTRING_LITERALS,
    	S_4BYTE_LITERALS,
    	S_8BYTE_LITERALS,
    	S_LITERAL_POINTERS,
    	S_NON_LAZY_SYMBOL_POINTERS,
    	S_LAZY_SYMBOL_POINTERS,
    	S_SYMBOL_STUBS,
    	S_MOD_INIT_FUNC_POINTERS,
    	S_MOD_TERM_FUNC_POINTERS,
    	S_COALESCED,
    	S_GB_ZEROFILL,
    	S_INTERPOSING,
    	S_16BYTE_LITERALS,
    	S_DTRACE_DOF,
    	S_LAZY_DYLIB_SYMBOL_POINTERS,
    	SECTION_ATTRIBUTES_USR,
    	S_ATTR_PURE_INSTRUCTIONS,
    	S_ATTR_NO_TOC,
    	S_ATTR_STRIP_STATIC_SYMS,
    	S_ATTR_NO_DEAD_STRIP,
    	S_ATTR_LIVE_SUPPORT,
    	S_ATTR_SELF_MODIFYING_CODE,
    	S_ATTR_DEBUG,
    	SECTION_ATTRIBUTES_SYS,
    	S_ATTR_SOME_INSTRUCTIONS,
    	S_ATTR_EXT_RELOC,
    	S_ATTR_LOC_RELOC
    };

Класс для работы с Mach-O файлом:

    class MacFile {
    public:
    	string name(); // возвращает имя файла
    	string format(); // возвращает имя формата "Mach-O"
    	uint64 size(); // возвращает размер файла
    	int count(); // возвращает количество архитектур в списке
    	MacArchitecture item(int index); // возвращает архитектуру с индексом index
    	uint64 seek(uint64 offset); // устанавливает файловую позицию
    	uint64 tell(); // возвращает файловую позицию
    	int write(string buffer); // записывает буфер в файл
    };

Класс для работы с Mach-O архитектурой:

    class MacArchitecture {
    public:
    	string name(); // возвращает имя архитектуры
    	MacFile file(); // возвращает родительский файл
    	uint64 entryPoint(); // возвращает стартовый адрес
    	OperandSize cpuAddressSize(); // возвращает битность архитектуры
    	uint64 size(); // возвращает размер архитектуры
    	MacSegments segments(); // возвращает список сегментов
    	MacSections sections(); // возвращает список секций
    	MacCommands commands(); // возвращает список загрузочных команд
    	MacSymbols symbols(); // возвращает список символов
    	MacImports imports(); // возвращает список импортируемых библиотек
    	MacExports exports(); // возвращает список экспортируемых функций
    	MacFixups fixups(); // возвращает список настраиваемых элементов
    	MapFunctions mapFunctions(); // возвращает список доступных для защиты функций
    	IntelFunctions functions(); // возвращает список защищаемых функций
    	bool addressSeek(uint64 address); // устанавливает файловую позицию
    	uint64 seek(uint64 offset); // устанавливает файловую позицию
    	uint64 tell(); // возвращает файловую позицию
    	int write(string buffer); // записывает буфер в файл
    };

Класс для работы cо списком сегментов для Mach-O архитектуры:

    class MacSegments {
    public:
    	MacSegment item(int index); // возвращает сегмент с индексом index
    	int count(); // возвращает количество сегментов в списке
    	MacSegment itemByAddress(); // возвращает сегмент с адресом address
    };

Класс для работы c сегментом для Mach-O архитектуры:

    class MacSegment {
    public:
    	uint64 address(); // возвращает адрес сегмента
    	string name(); // возвращает имя сегмента
    	uint64 size(); // возвращает размер сегмента
    	int physicalOffset(); // возвращает файловую позицию сегмента
    	int physicalSize(); // возвращает файловый размер сегмента
    	int flags(); // возвращает флаги сегмента
    	bool excludedFromPacking(); // возвращает признак "Исключен из упаковки"
    };

Класс для работы cо списком секций для Mach-O архитектуры:

    class MacSections {
    public:
    	MacSection item(int index); // возвращает секцию с индексом index
    	int count(); // возвращает количество секций в списке
    	MacSection itemByAddress(uint64 address); // возвращает секцию с адресом address
    };

Класс для работы c секцией для Mach-O архитектуры:

    class MacSection {
    public:
    	uint64 address(); // возвращает адрес секции
    	string name(); // возвращает имя секции
    	uint64 size(); // возвращает размер секции
    	int offset(); // возвращает файловую позицию секции
    	MacSegment segment(); // возвращает родительский сегмент
    };

Класс для работы cо списком загрузочных команд для Mach-O архитектуры:

    class MacCommands {
    public:
    	MacCommand item(int index); // возвращает команду с индексом index
    	int count(); // возвращает количество команд в списке
    	MacCommand itemByType(int type); // возвращает команду с типом type
    };

Класс для работы c загрузочной командой для Mach-O архитектуры:

    class MacCommand {
    public:
    	uint64 address(); // возвращает адрес команды
    	int type(); // возвращает тип команды
    	string name(); // возвращает имя команды
    	int size(); // возвращает размер команды
    };

Класс для работы cо списком символов для Mach-O архитектуры:

    class MacSymbols {
    public:
    	MacSymbol item(int index); // возвращает символ с индексом index
    	int count(); // возвращает количество символов в списке
    };

Класс для работы c символом для Mach-O архитектуры:

    class MacSymbol {
    public:
    	uint64 value(); // возвращает значение символа
    	string name(); // возвращает имя символа
    };

Класс для работы со списком импортируемых библиотек для Mach-O архитектуры:

    class MacImports {
    public:
    	MacImport item(int index); // возвращает импортируемую библиотеку с индексом index
    	int count(); // возвращает количество импортируемых библиотек в списке
    	MacImport itemByName(string name); // возвращает импортируемую библиотеку с именем name
    };

Класс для работы с импортируемой библиотекой для Mach-O архитектуры:

    class MacImport {
    public:
    	string name(); // возвращает имя импортируемой библиотеки
    	MacImportFunction item(int index); // возвращает импортируемую функцию с индексом index
    	int count(); // возвращает количество импортируемых функций в списке
    	void setName(string name); // устанавливает имя импортируемой библиотеки
    };

Класс для работы с импортируемой функцией для Mach-O архитектуры:

    class MacImportFunction {
    public:
    	uint64 address(); // возвращает адрес ячейки, в которую записывается адрес импортируемой функции
    	string name(); // возвращает имя импортируемой функции
    };

Класс для работы со списком экспортируемых функций для Mach-O архитектуры:

    class MacExports {
    public:
    	string name(); // возвращает имя библиотеки
    	MacExport item(); // возвращает экспортируемую функцию с индексом index
    	int count(); // возвращает количество экспортируемых функций в списке
    	void clear(); // очищает список
    	MacExport itemByAddress(uint64 address); // возвращает экспортируемую функцию с адресом address
    	MacExport itemByName(string name); // возвращает экспортируемую функцию с именем name
    };

Класс для работы с экспортируемой функцией для Mach-O архитектуры:

    class MacExport {
    public:
    	uint64 address(); // возвращает адрес экспортируемой функции
    	string name(); // возвращает имя экспортируемой функции
    	string forwardedName(); // возвращает имя функции, на которую перенаправлена экспортируемая функция
    	void destroy(); // уничтожает экспортируемую функцию
    };

Класс для работы со списком настраиваемых элементов для Mach-O архитектуры:

    class MacFixups {
    public:
    	MacFixup item(int index); // возвращает элемент с индексом index
    	int count(); // возвращает количество элементов в списке
    	MacFixup itemByAddress(uint64 address); // возвращает элемент с адресом address
    };

Класс для работы с настраиваемым элементом для Mach-O архитектуры:

    class MacFixup {
    public:
    	uint64 address(); // возвращает адрес элемента
    };

### Функции

Класс для работы со списком функций:

    class MapFunctions {
    public:
    	MapFunction item(int index); // возвращает функцию с индексом index
    	int count(); // возвращает количество функций в списке
    	MapFunction itemByAddress(uint64 address); // возвращает функцию с адресом address
    	MapFunction itemByName(string name); // возвращает функцию с именем name
    };

Типы функций:

    enum ObjectType {
    	Unknown,
    	Code,
    	Data,
    	Export,
    	Marker,
    	APIMarker,
    	Import,
    	String
    };

Класс для работы с функцией:

    class MapFunction {
    public:
    	uint64 address(); // возвращает адрес функции
    	string name(); // возвращает имя функции
    	ObjectType type(); // возвращает тип функции
    	References references(); // возвращает список ссылок
    };

Класс для работы со списком ссылок:

    class References {
    public:
    	Reference item(int index); // возвращает ссылку с индексом index
    	int count(); // возвращает количество ссылок в списке
    };

Класс для работы с ссылкой:

    class Reference {
    public:
    	uint64 address(); // возвращает адрес команды
    	uint64 operandAddress(); // возвращает адрес ссылки
    };

### Функции Intel

Класс для работы со списком функций Intel:

    class IntelFunctions {
    public:
    	IntelFunction item(int index); // возвращает функцию с индексом index
    	int count(); // возвращает количество функций в списке
    	void clear(); // очищает список
    	IntelFunction itemByAddress(uint64 address); // возвращает функцию с адресом address
    	IntelFunction itemByName(string name); // возвращает функцию с именем name
    	IntelFunction addByAddress(uint64 address, CompilationType type = ctVirtualization);
    		// добавляет новую функцию с адресом address и типом компиляции type
    };

Типы компиляции:

    enum CompilationType {
    	None,
    	Virtualization,
    	Mutation,
    	Ultra
    };

Класс для работы с функцией Intel:

    class IntelFunction {
    public:
    	uint64 address(); // возвращает адрес функции
    	string name(); // возвращает имя функции
    	ObjectType type(); // возвращает тип функции
    	IntelCommand item(int index); // возвращает команду с индексом index
    	int count(); // возвращает количество команд в списке
    	CompilationType compilationType(); // возвращает тип компиляции
    	void setCompilationType(CompilationType value); // устанавливает тип компиляции
    	CommandLinks links(); // возвращает список связей
    	IntelCommand itemByAddress(uint64 address); // возвращает команду с адресом address
    	void destroy(); // уничтожает функцию
    	Folder folder(); // возвращает пользовательскую папку
    	void setFolder(Folder folder); // устанавливает пользовательскую папку
    };

Типы команд Intel:

    enum IntelCommandType {
    	Unknown, Push, Pop, Mov, Add, Xor, Test, Lea, Ud0, Ret, Ssh, Crc, Call, Jmp,
    	Fstsw, Fsqrt, Fchs, Fstcw, Fldcw, Fild, Fist, Fistp, Fld, Fstp, Fst, Fadd,
    	Fsub, Fsubr, Fisub, Fisubr, Fdiv, Fcomp, Fmul, Repe, Repne, Rep, DB, DW, DD, DQ,
    	Movs, Cmps, Scas, Movzx, Movsx, Inc, Dec, Les, Lds, Lfs, Lgs, Lss, Xadd, Bswap,
    	Jxx, And, Sub, Stos, Lods, Nop, Xchg, Pushf, Popf, Sahf, Lahf, Shl, Shr, Sal,
    	Sar, Rcl, Rcr, Rol, Ror, Shld, Shrd, Loope, Loopne, Loop, Jcxz, In, Ins, Out,
    	Outs, Wait, Cbw, Cwde, Cdqe, Cwd, Cdq, Cqo, Clc, Stc, Cli, Sti, Cld, Std, Not,
    	Neg, Div, Imul, Idiv, Mul, Or, Adc, Cmp, Sbb, Pusha, Popa, Clflush, Pause,
    	Bound, Arpl, Daa, Das, Aaa, Aam, Aad, Aas, Enter, Leave, Int, Into, Iret, Set,
    	Cmov, Addpd, Addps, Addsd, Addss, Andpd, Andps, Andnpd, Andnps, Cmppd, Cmpps,
    	Cmpsd, Cmpss, Comisd, Comiss, Cvtdq2ps, Cvtpd2dq, Cvtdq2pd, Cvtpd2pi, Cvtps2pi,
    	Cvtpd2ps, Cvtps2pd, Cvtpi2pd, Cvtpi2ps, Cvtps2dq, Cvtsd2si, Cvtss2si, Cvtsd2ss,
    	Cvtss2sd, Cvttpd2pi, Cvttps2pi, Cvttpd2dq, Cvttps2dq, Cvttsd2si, Cvttss2si,
    	Divpd, Divps, Divsd, Divss, Maxpd, Maxps, Maxsd, Maxss, Minpd, Minps, Minsd,
    	Minss, Mulpd, Mulps, Mulsd, Mulss, Orpd, Orps, Movd, Movq, Movntq, Movapd, Movaps,
    	Movdqa, Movdqu, Movdq2q, Movq2dq, Movhlps, Movhpd, Movhps, Movlhps, Movlpd,
    	Movlps, Movmskpd, Movmskps, Movnti, Movntpd, Movntps, Movsd, Movss, Movupd,
    	Movups, Pmovmskb, Psadbw, Pshufw, Pshufd, Pshuflw, Pshufhw, Psubb, Psubw, Psubd,
    	Psubq, Psubsb, Psubsw, Psubusb, Psubusw, Paddb, Paddw, Paddd, Paddq, Paddsb,
    	Paddsw, Paddusb, Paddusw, Pavgb, Pavgw, Pinsrw, Pextrw, Pmaxsw, Pmaxub, Pminsw,
    	Pminub, Pmulhuw, Pmulhw, Pmullw, Pmuludq, Psllw, Pslld, Psllq, Pslldq, Psraw,
    	Psrad, Psrlw, Psrld, Psrlq, Psrldq, Punpcklbw, Punpcklwd, Punpckldq, Punpcklqdq,
    	Punpckhqdq, Packusdw, Pcmpgtb, Pcmpgtw, Pcmpgtd, Pcmpeqb, Pcmpeqw, Pcmpeqd,
    	Emms, Packsswb, Packuswb, Punpckhbw, Punpckhwd, Punpckhdq, Packssdw, Pand,
    	Pandn, Por, Pxor, Pmaddwd, Rcpps, Rcpss, Rsqrtss, Movsxd, Shufps, Shufpd, Sqrtpd,
    	Sqrtps, Sqrtsd, Sqrtss, Subpd, Subps, Subsd, Subss, Ucomisd, Ucomiss, Unpckhpd,
    	Unpckhps, Unpcklpd, Unpcklps, Xorpd, Xorps, Bt, Bts, Btr, Btc, Xlat, Cpuid,
    	Rsm, Bsf, Bsr, Cmpxchg, Cmpxchg8b, Hlt, Cmc, Lgdt, Sgdt, Lidt, Sidt, Smsw, Lmsw,
    	Invlpg, Lar, Lsl, Clts, Invd, Wbinvd, Ud2, Wrmsr, Rdtsc, Rdmsr, Rdpmc, Fcom,
    	Fdivr, Fiadd, Fimul, Ficom, Ficomp, Fidiv, Fidivr, Faddp, Fmulp, Fsubp, Fsubrp,
    	Fdivp, Fdivrp, Fbld, Fbstp, Ffree, Frstor, Fsave, Fucom, Fucomp, Fldenv, Fstenvm,
    	Fxch, Fabs, Fxam, Fld1, Fldl2t, Fldl2e, Fldpi, Fldlg2, Fldln2, Fldz, Fyl2x,
    	Fptan, Fpatan, Fxtract, Fprem1, Fdecstp, Fincstp, Fprem, Fyl2xp1, Fsincos, Frndint,
    	Fscale, Fsin, Fcos, Ftst, Fstenv, F2xm1, Fnop, Finit, Fclex, Fcompp, Sysenter,
    	Sysexit, Sldt, Str, Lldt, Ltr, Verr, Verw, Sfence, Lfence, Mfence, Prefetchnta,
    	Prefetcht0, Prefetcht1, Prefetcht2, Prefetch, Prefetchw, Fxrstor, Fxsave, Ldmxcsr,
    	Stmxcsr, Fcmovb, Fcmove, Fcmovbe, Fcmovu, Fcmovnb, Fcmovne, Fcmovnbe, Fcmovnu,
    	Fucomi, Fcomi, Fucomip, Fcomip, Fucompp, Vmcall, Vmlaunch, Vmresume, Vmxoff,
    	Monitor, Mwait, Xgetbv, Xsetbv, Vmrun, Vmmcall, Vmload, Vmsave, Stgi, Clgi,
    	Skinit, Invlpga, Swapgs, Rdtscp, Syscall, Sysret, Femms, Getsec, Pshufb, Phaddw,
    	Phaddd, Phaddsw, Pmaddubsw, Phsubw, Phsubd, Phsubsw, Psignb, Psignw, Psignd,
    	Pmulhrsw, Pabsb, Pabsw, Pabsd, Movbe, Palignr, Rsqrtps, Vmread, Vmwrite, Svldt,
    	Rsldt, Svts, Rsts, Xsave, Xrstor, Vmptrld, Vmptrst, Maskmovq, Fnstenv, Fnstcw,
    	Fstp1, Fneni, Fndisi, Fnclex, Fninit, Fsetpm, Fisttp, Fnsave, Fnstsw, Fxch4,
    	Fcomp5, Ffreep, Fxch7, Fstp8, Fstp9, Haddpd, Hsubpd, Addsubpd, Addsubps, Movntdq,
    	Fcom2, Fcomp3, Haddps, Hsubps, Movddup, Movsldup, Cvtsi2sd, Cvtsi2ss, Movntsd,
    	Movntss, Lddqu, Movshdup, Popcnt, Tzcnt, Lzcnt, Pblendvb, Pblendps, Pblendpd,
    	Ptest, Movsxbw, Movsxbd, Movsxbq, Movsxwd, Movsxwq, Movsxdq, Muldq, Pcmpeqq,
    	Movntdqa, Xsaveopt, Maskmovdqu, Ud1, Pcmpgtq, Movzxbw, Movzxbd, Movzxbq, Movzxwd,
    	Movzxwq, Movzxdq
    };

Сегменты Intel:

    enum IntelSegment {
    	None,
    	es,
    	cs,
    	ss,
    	ds,
    	fs,
    	gs
    };

Флаги Intel:

    enum IntelFlag {
    	C,
    	P,
    	A,
    	Z,
    	S,
    	T,
    	I,
    	D,
    	O
    };

Регистры Intel:

    enum IntelRegistr {
    	eax,
    	ecx,
    	edx,
    	ebx,
    	esp,
    	ebp,
    	esi,
    	edi,
    	r8,
    	r9,
    	r10,
    	r11,
    	r12,
    	r13,
    	r14,
    	r15
    };

Класс для работы с командой Intel:

    class IntelCommand {
    public:
    	uint64 address(); // возвращает адрес команды
    	IntelCommandType type(); // возвращает тип команды
    	string text(); // возвращает текстовое представление
    	int size(); // возвращает размер команды
    	int dump(int index); // возвращает данные команды по индексу index
    	CommandLink link(); // возвращает связь команды
    	int flags(); // возвращает флаги команды
    	IntelSegment baseSegment(); // возвращает базовый сегмент
    	IntelCommandType preffix(); // возвращает тип преффиксной команды
    	IntelOperand operand(int index); // возвращает операнд с индексом index
    };

Типы операндов:

    enum OperandType {
    	None,
    	Value,
    	Registr,
    	Memory,
    	SegmentRegistr,
    	ControlRegistr,
    	DebugRegistr,
    	FPURegistr,
    	HiPartRegistr,
    	BaseRegistr,
    	MMXRegistr,
    	XMMRegistr
    };

Размеры операндов:

    enum OperandSize {
    	Byte,
    	Word,
    	DWord,
    	QWord,
    	TByte,
    	OWord,
    	FWord
    };

Класс для работы с операндом команды Intel:

    class IntelOperand {
    public:
    	int type(); // возвращает тип операнда
    	OperandSize size(); // возвращает размер операнда
    	int registr(); // возвращает регистр
    	int baseRegistr(); // возвращает базовый регистр
    	int scale(); // возвращает коэффициент
    	uint64 value(); // возвращает значение
    };

Класс для работы со списком связей:

    class CommandLinks {
    public:
    	CommandLink item(int index); // возвращает связь с индексом index
    	int count(); // возвращает количество связей в списке
    };

Типы связей:

    enum LinkType {
    	None,
    	SEHBlock,
    	FinallyBlock,
    	DualSEHBlock,
    	FilterSEHBlock,
    	Jmp,
    	JmpWithFlag,
    	JmpWithFlagNSFS,
    	JmpWithFlagNSNA,
    	JmpWithFlagNSNS,
    	Call,
    	Case,
    	Switch,
    	Native,
    	Offset,
    	GateOffset,
    	ExtSEHBlock,
    	MemSEHBlock,
    	ExtSEHHandler,
    	VBMemSEHBlock
    };

Класс для работы со связью команды:

    class CommandLink {
    public:
    	uint64 toAddress(); // возвращает адрес, на который ссылается связь
    	LinkType type(); // возвращает тип связи
    	IntelCommand from(); // возвращает родительскую команду
    };

Класс для работы с библиотекой:

    enum ParamType {
    	"void",
    	"byte",
    	"char",
    	"short",
    	"ushort",
    	"int",
    	"uint",
    	"long",
    	"ulong",
    	"size_t",
    	"float",
    	"double",
    	"string",
    	"pointer"
    };

    enum CallType {
    	"default",
    	"cdecl",
    	"stdcall"
    };

    class FFILibrary {
    public:
    	string name(); // возвращает имя
    	uint64 address(); // возвращает адрес в памяти
    	void close();
    	FFIFunction getFunction(string name, ParamType ret, ParamType param1, ...); // возвращает функцию
    	FFIFunction getFunction(string name, table (ParamType ret, CallType abi, ParamType, ...)); // возвращает функцию
    };

Класс для работы с внешней функцией:

    class FFIFunction {
    	string name(); // возвращает имя
    	uint64 address(); // возвращает адрес в памяти
    };

© 2006-2015 Copyright VMProtect Software