VMProtect/core/core.h

#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