mirror of
https://github.com/Alukym/VMProtect-Source.git
synced 2025-06-11 10:38:02 -05:00
Initial commit
This commit is contained in:
Alukym
598
core/core.h
Normal file
598
core/core.h
Normal file
@ -0,0 +1,598 @@
|
||||
#ifndef CORE_H
|
||||
#define CORE_H
|
||||
|
||||
#include "../runtime/common.h"
|
||||
|
||||
enum ProjectOption {
|
||||
cpDebugMode = 0x00000002,
|
||||
cpCryptValues = 0x00000008,
|
||||
cpIncludeWatermark = 0x00000020,
|
||||
cpRunnerCRC = 0x00000040,
|
||||
cpEncryptRegs = 0x00000080,
|
||||
cpStripFixups = 0x00008000,
|
||||
cpPack = 0x00000100,
|
||||
cpImportProtection = 0x00000200,
|
||||
cpCheckDebugger = 0x00000400,
|
||||
cpCheckVirtualMachine = 0x00000800,
|
||||
cpMemoryProtection = 0x00001000,
|
||||
cpResourceProtection = 0x00010000,
|
||||
cpCheckKernelDebugger = 0x00020000,
|
||||
cpStripDebugInfo = 0x00040000,
|
||||
|
||||
cpLoaderCRC = 0x10000000,
|
||||
#ifndef DEMO
|
||||
cpUnregisteredVersion = 0x40000000,
|
||||
#endif
|
||||
cpEncryptBytecode = 0x80000000,
|
||||
cpVirtualFiles = 0x08000000,
|
||||
cpInternalMemoryProtection = 0x04000000,
|
||||
cpLoader = 0x02000000,
|
||||
cpMaximumProtection = cpCryptValues | cpRunnerCRC | cpEncryptRegs | cpPack | cpImportProtection | cpMemoryProtection | cpResourceProtection | cpStripDebugInfo,
|
||||
cpUserOptionsMask = 0x00FFFFFF
|
||||
};
|
||||
|
||||
std::string VectorToBase64(const std::vector<uint8_t> &src);
|
||||
|
||||
static const VMP_CHAR *default_message[MESSAGE_COUNT] =
|
||||
{
|
||||
MESSAGE_DEBUGGER_FOUND_STR,
|
||||
MESSAGE_VIRTUAL_MACHINE_FOUND_STR,
|
||||
MESSAGE_FILE_CORRUPTED_STR,
|
||||
MESSAGE_SERIAL_NUMBER_REQUIRED_STR,
|
||||
MESSAGE_HWID_MISMATCHED_STR
|
||||
};
|
||||
|
||||
struct LicenseDate {
|
||||
uint16_t Year;
|
||||
uint8_t Month;
|
||||
uint8_t Day;
|
||||
LicenseDate(uint32_t value = 0)
|
||||
{
|
||||
Day = value & 0xff;
|
||||
Month = (value >> 8) & 0xff;
|
||||
Year = (value >> 16) & 0xffff;
|
||||
};
|
||||
LicenseDate(uint16_t year, uint8_t month, uint8_t day)
|
||||
: Year(year), Month(month), Day(day) {};
|
||||
uint32_t value() const { return (Year << 16) | (Month << 8) | Day; }
|
||||
};
|
||||
|
||||
class Core;
|
||||
class BigNumber;
|
||||
class ProjectTemplate;
|
||||
class ProjectTemplateManager;
|
||||
|
||||
class RSA
|
||||
{
|
||||
public:
|
||||
RSA();
|
||||
RSA(const std::vector<uint8_t> &public_exp, const std::vector<uint8_t> &private_exp, const std::vector<uint8_t> &modulus);
|
||||
~RSA();
|
||||
bool Encrypt(Data &data);
|
||||
bool Decrypt(Data &data);
|
||||
bool CreateKeyPair(size_t key_length);
|
||||
std::vector<uint8_t> public_exp() const;
|
||||
std::vector<uint8_t> private_exp() const;
|
||||
std::vector<uint8_t> modulus() const;
|
||||
private:
|
||||
BigNumber *private_exp_;
|
||||
BigNumber *public_exp_;
|
||||
BigNumber *modulus_;
|
||||
|
||||
// no copy ctr or assignment op
|
||||
RSA(const RSA &);
|
||||
RSA &operator =(const RSA &);
|
||||
};
|
||||
|
||||
#ifdef ULTIMATE
|
||||
class LicensingManager;
|
||||
|
||||
struct LicenseInfo {
|
||||
uint32_t Flags;
|
||||
std::string CustomerName;
|
||||
std::string CustomerEmail;
|
||||
LicenseDate ExpireDate;
|
||||
std::string HWID;
|
||||
uint8_t RunningTimeLimit;
|
||||
LicenseDate MaxBuildDate;
|
||||
std::string UserData;
|
||||
LicenseInfo() : Flags(0), RunningTimeLimit(0) {}
|
||||
};
|
||||
|
||||
class License: public IObject
|
||||
{
|
||||
public:
|
||||
explicit License(LicensingManager *owner, LicenseDate date, const std::string &customer_name, const std::string &customer_email, const std::string &order_ref,
|
||||
const std::string &comments, const std::string &serial_number, bool blocked);
|
||||
~License();
|
||||
std::string customer_name() const { return customer_name_; }
|
||||
std::string customer_email() const { return customer_email_; }
|
||||
std::string order_ref() const { return order_ref_; }
|
||||
std::string comments() const { return comments_; }
|
||||
std::string serial_number() const { return serial_number_; }
|
||||
bool blocked() const { return blocked_; }
|
||||
void GetHash(uint8_t hash[20]);
|
||||
LicenseDate date() const { return date_; }
|
||||
void set_customer_name(const std::string &value);
|
||||
void set_customer_email(const std::string &value);
|
||||
void set_order_ref(const std::string &value);
|
||||
void set_date(LicenseDate value);
|
||||
void set_comments(const std::string &value);
|
||||
void set_blocked( bool value);
|
||||
LicenseInfo *info();
|
||||
void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
private:
|
||||
LicensingManager *owner_;
|
||||
LicenseDate date_;
|
||||
std::string customer_name_;
|
||||
std::string customer_email_;
|
||||
std::string order_ref_;
|
||||
std::string comments_;
|
||||
std::string serial_number_;
|
||||
bool blocked_;
|
||||
LicenseInfo *info_;
|
||||
|
||||
// no copy ctr or assignment op
|
||||
License(const License &);
|
||||
License &operator =(const License &);
|
||||
};
|
||||
|
||||
enum Algorithm {
|
||||
alNone,
|
||||
alRSA
|
||||
};
|
||||
|
||||
enum SerialNumberFlags {
|
||||
HAS_USER_NAME = 0x0001,
|
||||
HAS_EMAIL = 0x0002,
|
||||
HAS_EXP_DATE = 0x0004,
|
||||
HAS_MAX_BUILD_DATE = 0x0008,
|
||||
HAS_TIME_LIMIT = 0x0010,
|
||||
HAS_HARDWARE_ID = 0x0020,
|
||||
HAS_USER_DATA = 0x0040,
|
||||
SN_FLAGS_PADDING = 0xFFFF
|
||||
};
|
||||
|
||||
class LicensingManager : public ObjectList<License>
|
||||
{
|
||||
public:
|
||||
explicit LicensingManager(Core *owner = NULL);
|
||||
virtual bool GetLicenseData(Data &data) const;
|
||||
virtual void clear();
|
||||
bool Open(const std::string &file_name);
|
||||
bool Save();
|
||||
bool SaveAs(const std::string &file_name);
|
||||
bool empty() const { return algorithm_ == alNone; }
|
||||
uint64_t product_code() const;
|
||||
bool Init(size_t key_len);
|
||||
Algorithm algorithm() const { return algorithm_; }
|
||||
uint16_t bits() const { return bits_; }
|
||||
std::vector<uint8_t> public_exp() const { return public_exp_; }
|
||||
std::vector<uint8_t> private_exp() const { return private_exp_; }
|
||||
std::vector<uint8_t> modulus() const { return modulus_; }
|
||||
std::vector<uint8_t> hash() const;
|
||||
std::string activation_server() const { return activation_server_; }
|
||||
void set_activation_server(const std::string &activation_server) { activation_server_ = activation_server; }
|
||||
void set_build_date(uint32_t build_date) { build_date_ = build_date; }
|
||||
std::string GenerateSerialNumber(const LicenseInfo &license_info);
|
||||
bool DecryptSerialNumber(const std::string &serial_number, LicenseInfo &license_info);
|
||||
License *Add(LicenseDate date, const std::string &customer_name, const std::string &customer_email, const std::string &order_ref,
|
||||
const std::string &comments, const std::string &serial_number, bool blocked);
|
||||
License *GetLicenseBySerialNumber(const std::string &serial_number);
|
||||
bool CompareParameters(const LicensingManager &manager) const;
|
||||
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
virtual void AddObject(License *license);
|
||||
virtual void RemoveObject(License *license);
|
||||
private:
|
||||
void changed();
|
||||
Core *owner_;
|
||||
std::string file_name_;
|
||||
Algorithm algorithm_;
|
||||
uint16_t bits_;
|
||||
std::vector<uint8_t> public_exp_;
|
||||
std::vector<uint8_t> private_exp_;
|
||||
std::vector<uint8_t> modulus_;
|
||||
std::vector<uint8_t> product_code_;
|
||||
std::string activation_server_;
|
||||
uint32_t build_date_;
|
||||
};
|
||||
|
||||
class FileManager;
|
||||
class IFunction;
|
||||
class FileStream;
|
||||
|
||||
class FileFolder : public ObjectList<FileFolder>
|
||||
{
|
||||
public:
|
||||
explicit FileFolder(FileFolder *owner, const std::string &name);
|
||||
explicit FileFolder(FileFolder *owner, const FileFolder &src);
|
||||
virtual ~FileFolder();
|
||||
FileFolder *Clone(FileFolder *owner) const;
|
||||
FileFolder *Add(const std::string &name);
|
||||
std::string name() const { return name_; }
|
||||
FileFolder *owner() const { return owner_; }
|
||||
void set_name(const std::string &name);
|
||||
void set_owner(FileFolder *owner);
|
||||
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
std::string id() const;
|
||||
FileFolder *GetFolderById(const std::string &id) const;
|
||||
void WriteEntry(IFunction &data);
|
||||
void WriteName(IFunction &data, uint64_t image_base, uint32_t key);
|
||||
using IObject::CompareWith;
|
||||
private:
|
||||
void changed();
|
||||
FileFolder *owner_;
|
||||
std::string name_;
|
||||
size_t entry_offset_;
|
||||
};
|
||||
|
||||
class FileFolderList : public FileFolder
|
||||
{
|
||||
public:
|
||||
explicit FileFolderList(FileManager *owner);
|
||||
explicit FileFolderList(FileManager *owner, const FileFolderList &src);
|
||||
FileFolderList *Clone(FileManager *owner) const;
|
||||
std::vector<FileFolder*> GetFolderList() const;
|
||||
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
FileManager *owner() const { return owner_; }
|
||||
private:
|
||||
FileManager *owner_;
|
||||
};
|
||||
|
||||
enum InternalFileAction {
|
||||
faNone,
|
||||
faLoad,
|
||||
faRegister,
|
||||
faInstall
|
||||
};
|
||||
|
||||
class InternalFile : public IObject
|
||||
{
|
||||
public:
|
||||
InternalFile(FileManager *owner, const std::string &name, const std::string &file_name, InternalFileAction action, FileFolder *folder);
|
||||
~InternalFile();
|
||||
std::string name() const { return name_; }
|
||||
std::string file_name() const { return file_name_; }
|
||||
std::string absolute_file_name() const;
|
||||
void set_name(const std::string &value);
|
||||
void set_file_name(const std::string &value);
|
||||
bool Open();
|
||||
void Close();
|
||||
virtual void WriteEntry(IFunction &func);
|
||||
virtual void WriteName(IFunction &func, uint64_t image_base, uint32_t key);
|
||||
virtual void WriteData(IFunction &func, uint64_t image_base, uint32_t key);
|
||||
void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
FileManager *owner() const { return owner_; }
|
||||
InternalFileAction action() const { return action_; }
|
||||
void set_action(InternalFileAction action);
|
||||
bool is_server() const { return (action_ == faRegister || action_ == faInstall); }
|
||||
FileFolder *folder() const { return folder_; }
|
||||
void set_folder(FileFolder *folder);
|
||||
size_t id() const;
|
||||
FileStream *stream() const { return stream_; }
|
||||
private:
|
||||
FileManager *owner_;
|
||||
std::string name_;
|
||||
std::string file_name_;
|
||||
InternalFileAction action_;
|
||||
FileStream *stream_;
|
||||
size_t entry_offset_;
|
||||
FileFolder *folder_;
|
||||
|
||||
// no copy ctr or assignment op
|
||||
InternalFile(const InternalFile &);
|
||||
InternalFile &operator =(const InternalFile &);
|
||||
};
|
||||
|
||||
class FileManager : public ObjectList<InternalFile>
|
||||
{
|
||||
public:
|
||||
FileManager(Core *owner);
|
||||
~FileManager();
|
||||
virtual void clear();
|
||||
bool need_compile() const { return need_compile_; }
|
||||
void set_need_compile(bool need_compile);
|
||||
InternalFile *Add(const std::string &name, const std::string &file_name, InternalFileAction action, FileFolder *folder);
|
||||
bool OpenFiles();
|
||||
void CloseFiles();
|
||||
void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
Core *owner() const { return owner_; }
|
||||
uint32_t GetRuntimeOptions() const;
|
||||
size_t server_count() const;
|
||||
FileFolderList *folder_list() const { return folder_list_; }
|
||||
private:
|
||||
Core *owner_;
|
||||
bool need_compile_;
|
||||
FileFolderList *folder_list_;
|
||||
|
||||
// no copy ctr or assignment op
|
||||
FileManager(const FileManager &);
|
||||
FileManager &operator =(const FileManager &);
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
class WatermarkManager;
|
||||
class IniFile;
|
||||
class SettingsFile;
|
||||
|
||||
class Watermark : public IObject
|
||||
{
|
||||
public:
|
||||
Watermark(WatermarkManager *owner);
|
||||
Watermark(WatermarkManager *owner, const std::string &name, const std::string &value, size_t use_count, bool enabled);
|
||||
~Watermark();
|
||||
size_t id() const { return id_; }
|
||||
std::string name() const { return name_; }
|
||||
bool enabled() const { return enabled_; }
|
||||
std::string value() const { return value_; }
|
||||
size_t use_count() const { return use_count_; }
|
||||
void set_name(const std::string &name);
|
||||
void set_value(const std::string &value);
|
||||
void set_enabled(bool value);
|
||||
void Compile();
|
||||
bool SearchByte(uint8_t value);
|
||||
std::vector<uint8_t> dump() const { return dump_; }
|
||||
void inc_use_count();
|
||||
void ReadFromIni(IniFile &file, size_t id);
|
||||
void ReadFromNode(TiXmlElement *node);
|
||||
void SaveToNode(TiXmlElement *node);
|
||||
void SaveToFile(SettingsFile &file);
|
||||
void DeleteFromFile(SettingsFile &file);
|
||||
void InitSearch() { pos_.clear(); }
|
||||
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
static bool AreSimilar(const std::string &v1, const std::string &v2);
|
||||
static bool SymbolsMatch(char v1, char v2);
|
||||
private:
|
||||
WatermarkManager *owner_;
|
||||
size_t id_;
|
||||
std::string name_;
|
||||
std::string value_;
|
||||
size_t use_count_;
|
||||
bool enabled_;
|
||||
std::vector<uint8_t> dump_;
|
||||
std::vector<uint8_t> mask_;
|
||||
std::vector<size_t> pos_;
|
||||
};
|
||||
|
||||
class WatermarkManager : public ObjectList<Watermark>
|
||||
{
|
||||
public:
|
||||
WatermarkManager(Core *owner);
|
||||
Watermark *Add(const std::string name, const std::string value, size_t use_count = 0, bool enabled = true);
|
||||
Watermark *GetWatermarkByName(const std::string &name);
|
||||
void InitSearch() const;
|
||||
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
void ReadFromFile(SettingsFile &file);
|
||||
virtual void RemoveObject(Watermark *watermark);
|
||||
void ReadFromIni(const std::string &file_name);
|
||||
void SaveToFile(SettingsFile &file);
|
||||
std::string CreateValue() const;
|
||||
Watermark *GetWatermarkByValue(const std::string &value) const;
|
||||
bool IsUniqueWatermark(const std::string &value) const;
|
||||
private:
|
||||
Core *owner_;
|
||||
};
|
||||
|
||||
enum VMProtectProductId
|
||||
{
|
||||
VPI_NOT_SPECIFIED, //0 legacy
|
||||
VPI_LITE_WIN_PERSONAL, //1 VMProtect Lite for Windows (Personal License)
|
||||
VPI_LITE_WIN_COMPANY, //2 VMProtect Lite for Windows (Company License)
|
||||
VPI_PROF_WIN_PERSONAL, //3 VMProtect Professional for Windows (Personal License)
|
||||
VPI_PROF_WIN_COMPANY, //4 VMProtect Professional for Windows (Company License)
|
||||
VPI_ULTM_WIN_PERSONAL, //5 VMProtect Ultimate for Windows (Personal License)
|
||||
VPI_ULTM_WIN_COMPANY, //6 VMProtect Ultimate for Windows (Company License)
|
||||
VPI_LITE_OSX_PERSONAL, //7 VMProtect Lite for Mac OS X (Personal License)
|
||||
VPI_LITE_OSX_COMPANY, //8 VMProtect Lite for Mac OS X (Company License)
|
||||
VPI_PROF_OSX_PERSONAL, //9 VMProtect Professional for Mac OS X (Personal License)
|
||||
VPI_PROF_OSX_COMPANY, //10 VMProtect Professional for Mac OS X (Company License)
|
||||
VPI_ULTM_OSX_PERSONAL, //11 VMProtect Ultimate for Mac OS X (Personal License)
|
||||
VPI_ULTM_OSX_COMPANY, //12 VMProtect Ultimate for Mac OS X (Company License)
|
||||
VPI_WLM_PERSONAL, //13 VMProtect Web License Manager (Personal License)
|
||||
VPI_WLM_COMPANY, //14 VMProtect Web License Manager (Company License)
|
||||
VPI_YEAR_PESONAL, //15 Yearly Subscription Plan (Personal License)
|
||||
VPI_YEAR_COMPANY, //16 Yearly Subscription Plan (Company License)
|
||||
VPI_SENS_WIN_PERSONAL, //17 VMProtect SE for Windows (Personal License)
|
||||
VPI_SENS_WIN_COMPANY, //18 VMProtect SE for Windows (Company License)
|
||||
VPI_LITE_LIN_PERSONAL, //19 VMProtect Lite for Linux (Personal License)
|
||||
VPI_LITE_LIN_COMPANY, //20 VMProtect Lite for Linux (Company License)
|
||||
VPI_PROF_LIN_PERSONAL, //21 VMProtect Professional for Linux (Personal License)
|
||||
VPI_PROF_LIN_COMPANY, //22 VMProtect Professional for Linux (Company License)
|
||||
VPI_ULTM_LIN_PERSONAL, //23 VMProtect Ultimate for Linux (Personal License)
|
||||
VPI_ULTM_LIN_COMPANY, //24 VMProtect Ultimate for Linux (Company License)
|
||||
#ifdef __unix__
|
||||
VPI_LITE_PERSONAL = VPI_LITE_LIN_PERSONAL,
|
||||
VPI_LITE_COMPANY = VPI_LITE_LIN_COMPANY,
|
||||
VPI_PROF_PERSONAL = VPI_PROF_LIN_PERSONAL,
|
||||
VPI_PROF_COMPANY = VPI_PROF_LIN_COMPANY,
|
||||
VPI_ULTM_PERSONAL = VPI_ULTM_LIN_PERSONAL,
|
||||
VPI_ULTM_COMPANY = VPI_ULTM_LIN_COMPANY,
|
||||
#elif defined(__APPLE__)
|
||||
VPI_LITE_PERSONAL = VPI_LITE_OSX_PERSONAL,
|
||||
VPI_LITE_COMPANY = VPI_LITE_OSX_COMPANY,
|
||||
VPI_PROF_PERSONAL = VPI_PROF_OSX_PERSONAL,
|
||||
VPI_PROF_COMPANY = VPI_PROF_OSX_COMPANY,
|
||||
VPI_ULTM_PERSONAL = VPI_ULTM_OSX_PERSONAL,
|
||||
VPI_ULTM_COMPANY = VPI_ULTM_OSX_COMPANY,
|
||||
#else
|
||||
VPI_LITE_PERSONAL = VPI_LITE_WIN_PERSONAL,
|
||||
VPI_LITE_COMPANY = VPI_LITE_WIN_COMPANY,
|
||||
VPI_PROF_PERSONAL = VPI_PROF_WIN_PERSONAL,
|
||||
VPI_PROF_COMPANY = VPI_PROF_WIN_COMPANY,
|
||||
VPI_ULTM_PERSONAL = VPI_ULTM_WIN_PERSONAL,
|
||||
VPI_ULTM_COMPANY = VPI_ULTM_WIN_COMPANY,
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(ULTIMATE)
|
||||
#define EDITION "Ultimate"
|
||||
#elif defined(LITE)
|
||||
#define EDITION "Lite"
|
||||
#else
|
||||
#define EDITION "Professional"
|
||||
#endif
|
||||
|
||||
#define STR_HELPER(x) #x
|
||||
#define STR(x) STR_HELPER(x)
|
||||
|
||||
#define STR_HELPERW(x) L ## #x
|
||||
#define STRW(x) STR_HELPERW(x)
|
||||
#define STR_HELPERWQ(x) L ## x
|
||||
#define STRWQ(x) STR_HELPERWQ(x)
|
||||
|
||||
class ProjectTemplate : public IObject
|
||||
{
|
||||
public:
|
||||
ProjectTemplate(ProjectTemplateManager *owner, const std::string &name, bool is_default = false);
|
||||
ProjectTemplate &operator =(const ProjectTemplate &);
|
||||
~ProjectTemplate();
|
||||
|
||||
void Reset();
|
||||
void ReadFromCore(const Core &core);
|
||||
void ReadFromNode(TiXmlElement *node);
|
||||
void SaveToNode(TiXmlElement *node) const;
|
||||
|
||||
bool is_default() const { return is_default_; }
|
||||
void set_is_default(bool is_default) { is_default_ = is_default; }
|
||||
std::string name() const { return name_; }
|
||||
std::string display_name() const;
|
||||
uint32_t options() const { return options_; }
|
||||
std::string vm_section_name() const { return vm_section_name_; }
|
||||
std::string message(size_t idx) const;
|
||||
void set_name(const std::string &name);
|
||||
static std::string default_name() { return "(default)"; }
|
||||
|
||||
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
bool operator ==(const ProjectTemplate &other) const;
|
||||
bool operator !=(const ProjectTemplate &other) const { return !operator==(other); }
|
||||
private:
|
||||
void Init();
|
||||
ProjectTemplateManager *owner_;
|
||||
bool is_default_;
|
||||
uint32_t options_;
|
||||
std::string name_, vm_section_name_;
|
||||
std::string messages_[MESSAGE_COUNT];
|
||||
|
||||
// no copy ctr or assignment op
|
||||
ProjectTemplate(const ProjectTemplate &);
|
||||
};
|
||||
|
||||
class ProjectTemplateManager : public ObjectList<ProjectTemplate>
|
||||
{
|
||||
public:
|
||||
ProjectTemplateManager(Core *owner);
|
||||
void ReadFromFile(SettingsFile &file);
|
||||
void SaveToFile(SettingsFile &file) const;
|
||||
void Add(const std::string &name, const Core &core);
|
||||
void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
||||
void RemoveObject(ProjectTemplate *pt);
|
||||
private:
|
||||
Core *owner_;
|
||||
|
||||
// no copy ctr or assignment op
|
||||
ProjectTemplateManager(const ProjectTemplateManager &);
|
||||
ProjectTemplateManager &operator =(const ProjectTemplateManager &);
|
||||
};
|
||||
|
||||
class Script;
|
||||
class ILog;
|
||||
class IFile;
|
||||
class IArchitecture;
|
||||
|
||||
class Core : public IObject
|
||||
{
|
||||
public:
|
||||
explicit Core(ILog *log = NULL);
|
||||
virtual ~Core();
|
||||
#ifdef ULTIMATE
|
||||
bool Open(const std::string &file_name, const std::string &user_project_file_name = "", const std::string &user_licensing_params_file_name = "");
|
||||
#else
|
||||
bool Open(const std::string &file_name, const std::string &user_project_file_name = "");
|
||||
#endif
|
||||
bool Save();
|
||||
bool SaveAs(const std::string &file_name);
|
||||
void Close();
|
||||
bool Compile();
|
||||
|
||||
uint32_t options() const { return options_; }
|
||||
std::string vm_section_name() const { return vm_section_name_; }
|
||||
std::string watermark_name() const { return watermark_name_; }
|
||||
IFile *input_file() const { return input_file_; }
|
||||
IFile *output_file() const { return output_file_; }
|
||||
ILog *log() const { return log_; }
|
||||
std::string input_file_name() const { return input_file_name_; }
|
||||
std::string output_file_name() const { return output_file_name_; }
|
||||
void set_options(uint32_t options);
|
||||
void include_option(ProjectOption option);
|
||||
void exclude_option(ProjectOption option);
|
||||
void set_vm_section_name(const std::string &vm_section_name);
|
||||
void set_watermark_name(const std::string &watermark_name);
|
||||
void set_output_file_name(const std::string &output_file_name);
|
||||
std::string message(size_t type) const { return messages_[type]; }
|
||||
void set_message(size_t type, const std::string &message);
|
||||
#ifdef ULTIMATE
|
||||
std::string hwid() const { return hwid_; }
|
||||
void set_hwid(const std::string &hwid);
|
||||
LicensingManager *licensing_manager() const { return licensing_manager_; }
|
||||
FileManager *file_manager() const { return file_manager_; }
|
||||
std::string license_data_file_name() const { return license_data_file_name_; }
|
||||
void set_license_data_file_name(const std::string &license_data_file_name);
|
||||
std::string activation_server() const { return licensing_manager_->activation_server(); }
|
||||
void set_activation_server(const std::string &activation_server);
|
||||
std::string default_license_data_file_name() const;
|
||||
#endif
|
||||
std::string project_path() const;
|
||||
void Notify(MessageType type, IObject *sender, const std::string &message = "");
|
||||
std::string absolute_output_file_name() const;
|
||||
std::string project_file_name() const { return project_file_name_; }
|
||||
WatermarkManager *watermark_manager() const { return watermark_manager_; }
|
||||
ProjectTemplateManager *template_manager() const { return template_manager_; }
|
||||
Script *script() const { return script_; }
|
||||
static const char *copyright() { return "Copyright 2003-2021 VMProtect Software"; }
|
||||
static const char *edition() { return "VMProtect " EDITION; }
|
||||
static const char *version();
|
||||
static const char *build();
|
||||
static bool check_license_edition(const VMProtectSerialNumberData &lic);
|
||||
IArchitecture *input_architecture() const;
|
||||
IArchitecture *output_architecture() const { return output_architecture_; }
|
||||
void LoadFromTemplate(const ProjectTemplate &pt);
|
||||
void SaveToTemplate(ProjectTemplate &pt);
|
||||
private:
|
||||
HANDLE BeginCompileTransaction();
|
||||
void EndCompileTransaction(HANDLE locked_file, bool commit);
|
||||
bool LoadFromXML(const char *project_file_name);
|
||||
bool LoadFromIni(const char *project_file_name);
|
||||
void LoadDefaultFunctions();
|
||||
std::string default_output_file_name() const;
|
||||
|
||||
std::string project_file_name_;
|
||||
bool modified_;
|
||||
IFile *input_file_;
|
||||
std::string input_file_name_;
|
||||
uint32_t options_;
|
||||
uint32_t vm_options_;
|
||||
std::string vm_section_name_;
|
||||
ProjectTemplateManager *template_manager_;
|
||||
std::string output_file_name_;
|
||||
std::string watermark_name_;
|
||||
std::string messages_[MESSAGE_COUNT];
|
||||
IFile *output_file_;
|
||||
ILog *log_;
|
||||
Watermark *watermark_;
|
||||
WatermarkManager *watermark_manager_;
|
||||
Script *script_;
|
||||
IArchitecture *output_architecture_;
|
||||
#ifdef ULTIMATE
|
||||
std::string hwid_;
|
||||
std::string license_data_file_name_;
|
||||
LicensingManager *licensing_manager_;
|
||||
FileManager *file_manager_;
|
||||
#endif
|
||||
|
||||
// no copy ctr or assignment op
|
||||
Core(const Core &);
|
||||
Core &operator =(const Core &);
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user