├── .gitignore
├── include
    ├── win32
    │   ├── events
    │   │   └── events.h
    │   ├── patchresult.h
    │   ├── controls
    │   │   ├── label.h
    │   │   ├── statusbar.h
    │   │   ├── groupbox.h
    │   │   ├── button.h
    │   │   ├── checkbox.h
    │   │   ├── progress.h
    │   │   ├── editbox.h
    │   │   ├── control.h
    │   │   └── window.h
    │   ├── resources.h
    │   ├── unpatchertask.h
    │   ├── task.h
    │   ├── patchertask.h
    │   ├── downloadtoolstask.h
    │   └── mainwindow.h
    ├── logging
    │   ├── logstrategy.h
    │   ├── terminallogstrategy.h
    │   ├── streamlogstrategy.h
    │   ├── statusbarlogstrategy.h
    │   └── combinedlogstrategy.h
    ├── colors.h
    ├── archive.h
    ├── buildsparser.h
    ├── installinfo.h
    ├── ziparchive.h
    ├── toolsdownloader.h
    ├── unlocker_win.h
    ├── unlocker_lnx.h
    ├── patchversioner.h
    ├── winservices.h
    ├── debug.h
    ├── network.h
    ├── filesystem.hpp
    ├── patcher.h
    ├── tar.h
    ├── versionparser.h
    └── config.h
├── src
    ├── logging
    │   ├── logstrategy.cpp
    │   ├── terminallogstrategy.cpp
    │   ├── statusbarlogstrategy.cpp
    │   ├── streamlogstrategy.cpp
    │   └── combinedlogstrategy.cpp
    ├── win32
    │   ├── controls
    │   │   ├── groupbox.cpp
    │   │   ├── label.cpp
    │   │   ├── button.cpp
    │   │   ├── checkbox.cpp
    │   │   ├── statusbar.cpp
    │   │   ├── progress.cpp
    │   │   ├── editbox.cpp
    │   │   ├── control.cpp
    │   │   └── window.cpp
    │   ├── downloadtoolstask.cpp
    │   ├── unpatchertask.cpp
    │   ├── patchertask.cpp
    │   └── mainwindow.cpp
    ├── buildsparser.cpp
    ├── versionparser.cpp
    ├── archive.cpp
    ├── patchversioner.cpp
    ├── ziparchive.cpp
    ├── installinfo.cpp
    ├── debug.cpp
    ├── toolsdownloader.cpp
    ├── main.cpp
    ├── tar.cpp
    ├── network.cpp
    ├── unlocker_win.cpp
    ├── unlocker_lnx.cpp
    ├── winservices.cpp
    └── patcher.cpp
├── tests
    ├── test_zip.cpp
    ├── test_tar.cpp
    ├── test.h
    └── test_patch.cpp
├── modules
    └── FindLibZip.cmake
├── Makefile
├── Unlocker.exe.manifest
├── README.md
└── CMakeLists.txt


/.gitignore:
--------------------------------------------------------------------------------
 1 | /.vs
 2 | /exe
 3 | /out
 4 | CMakeSettings.json
 5 | /testing
 6 | /LIBS
 7 | /debug.log
 8 | /test.tar
 9 | /test.zip
10 | /testtar
11 | /tools
12 | 


--------------------------------------------------------------------------------
/include/win32/events/events.h:
--------------------------------------------------------------------------------
 1 | #ifndef EVENTS_H
 2 | #define EVENTS_H
 3 | 
 4 | #include <functional>
 5 | 
 6 | enum class EventType {
 7 | 	CLICK_EVENT
 8 | };
 9 | 
10 | using EventCallback = std::function<void(void)>;
11 | 
12 | #endif


--------------------------------------------------------------------------------
/include/win32/patchresult.h:
--------------------------------------------------------------------------------
 1 | #ifndef PATCHRESULT_H
 2 | #define PATCHRESULT_H
 3 | 
 4 | #include <string>
 5 | 
 6 | struct PatchResult
 7 | {
 8 | 	bool result;
 9 | 	std::string errorMessage;
10 | 	std::string logFilePath;
11 | };
12 | 
13 | #endif


--------------------------------------------------------------------------------
/include/win32/controls/label.h:
--------------------------------------------------------------------------------
 1 | #ifndef LABEL_H
 2 | #define LABEL_H
 3 | 
 4 | #include <Windows.h>
 5 | #include "win32\controls\control.h"
 6 | 
 7 | class Label : public Control
 8 | {
 9 | public:
10 | 	Label(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height);
11 | 
12 | private:
13 | };
14 | 
15 | #endif


--------------------------------------------------------------------------------
/include/logging/logstrategy.h:
--------------------------------------------------------------------------------
 1 | #ifndef LOGSTRATEGY_H
 2 | #define LOGSTRATEGY_H
 3 | 
 4 | class LogStrategy
 5 | {
 6 | public:
 7 | 	virtual void verbose(const char* message) = 0;
 8 | 	virtual void debug(const char* message) = 0;
 9 | 	virtual void info(const char* message) = 0;
10 | 	virtual void error(const char* message) = 0;
11 | };
12 | 
13 | #endif


--------------------------------------------------------------------------------
/include/win32/controls/statusbar.h:
--------------------------------------------------------------------------------
 1 | #ifndef STATUSBAR_H
 2 | #define STATUSBAR_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <CommCtrl.h>
 6 | #include "win32/controls/control.h"
 7 | 
 8 | class StatusBar : Control
 9 | {
10 | public:
11 | 	StatusBar(HWND parent, int menuId, LPCSTR text);
12 | 
13 | 	void setText(LPCSTR text);
14 | };
15 | 
16 | #endif


--------------------------------------------------------------------------------
/src/logging/logstrategy.cpp:
--------------------------------------------------------------------------------
 1 | #ifndef LOGSTRATEGY_H
 2 | #define LOGSTRATEGY_H
 3 | 
 4 | class LogStrategy
 5 | {
 6 | public:
 7 | 	virtual void verbose(const char* message) = 0;
 8 | 	virtual void debug(const char* message) = 0;
 9 | 	virtual void info(const char* message) = 0;
10 | 	virtual void error(const char* message) = 0;
11 | };
12 | 
13 | #endif


--------------------------------------------------------------------------------
/include/win32/controls/groupbox.h:
--------------------------------------------------------------------------------
 1 | #ifndef GROUPBOX_H
 2 | #define GROUPBOX_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <Uxtheme.h>
 6 | #include "win32/controls/control.h"
 7 | 
 8 | class GroupBox : public Control
 9 | {
10 | public:
11 | 	GroupBox(HWND parent, LPCSTR text, int x, int y, int width, int height);
12 | 
13 | private:
14 | };
15 | 
16 | #endif


--------------------------------------------------------------------------------
/include/colors.h:
--------------------------------------------------------------------------------
 1 | #ifndef COLORS_H
 2 | #define COLORS_H
 3 | 
 4 | #define ANSI_COLOR_RED     "\x1b[31m"
 5 | #define ANSI_COLOR_GREEN   "\x1b[32m"
 6 | #define ANSI_COLOR_YELLOW  "\x1b[33m"
 7 | #define ANSI_COLOR_BLUE    "\x1b[34m"
 8 | #define ANSI_COLOR_MAGENTA "\x1b[35m"
 9 | #define ANSI_COLOR_CYAN    "\x1b[36m"
10 | #define ANSI_COLOR_RESET   "\x1b[0m"
11 | 
12 | #endif // COLORS_H


--------------------------------------------------------------------------------
/include/win32/controls/button.h:
--------------------------------------------------------------------------------
 1 | #ifndef BUTTON_H
 2 | #define BUTTON_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <Uxtheme.h>
 6 | #include "win32/events/events.h"
 7 | #include "win32/controls/control.h"
 8 | 
 9 | class Button : public Control
10 | {
11 | public:
12 | 	Button(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height);
13 | 
14 | private:
15 | };
16 | 
17 | #endif


--------------------------------------------------------------------------------
/include/win32/controls/checkbox.h:
--------------------------------------------------------------------------------
 1 | #ifndef CHECKBOX_H
 2 | #define CHECKBOX_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <Uxtheme.h>
 6 | #include "win32/events/events.h"
 7 | #include "win32/controls/control.h"
 8 | 
 9 | class CheckBox : public Control
10 | {
11 | public:
12 | 	CheckBox(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height);
13 | 	void set(bool checked);
14 | 	bool isChecked();
15 | 
16 | private:
17 | };
18 | 
19 | #endif


--------------------------------------------------------------------------------
/src/win32/controls/groupbox.cpp:
--------------------------------------------------------------------------------
 1 | #include "..\..\..\include\win32\controls\groupbox.h"
 2 | 
 3 | GroupBox::GroupBox(HWND parent, LPCSTR text, int x, int y, int width, int height)
 4 | {
 5 | 	hWnd = CreateWindow(
 6 | 		"Button",
 7 | 		text,
 8 | 		WS_CHILD | WS_VISIBLE | BS_GROUPBOX,
 9 | 		x, y, width, height,
10 | 		parent,
11 | 		NULL,
12 | 		(HINSTANCE)GetWindowLongPtr(parent, GWLP_HINSTANCE),
13 | 		NULL
14 | 	);
15 | 
16 | 	applySystemFont();
17 | }
18 | 


--------------------------------------------------------------------------------
/include/win32/controls/progress.h:
--------------------------------------------------------------------------------
 1 | #ifndef PROGRESS_H
 2 | #define PROGRESS_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <CommCtrl.h>
 6 | #include "win32/controls/control.h"
 7 | 
 8 | class Progress : public Control 
 9 | {
10 | public:
11 | 	Progress(HWND parent, int menuId, int x, int y, int width, int height);
12 | 	void setRange(int range);
13 | 	void setStep(int step);
14 | 	void setProgress(int progress);
15 | 	void advance();
16 | 
17 | private:
18 | };
19 | 
20 | #endif


--------------------------------------------------------------------------------
/src/win32/controls/label.cpp:
--------------------------------------------------------------------------------
 1 | #include "..\..\..\include\win32\controls\label.h"
 2 | 
 3 | Label::Label(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height)
 4 | {
 5 | 	parentHwnd = parent;
 6 | 	hWnd = CreateWindow(
 7 | 		"STATIC",
 8 | 		text,
 9 | 		WS_VISIBLE | WS_CHILD,
10 | 		x, y, width, height,
11 | 		parent,
12 | 		(HMENU)menuId,
13 | 		(HINSTANCE)GetWindowLongPtr(parent, GWLP_HINSTANCE),
14 | 		NULL
15 | 	);
16 | 
17 | 	applySystemFont();
18 | }
19 | 


--------------------------------------------------------------------------------
/src/win32/controls/button.cpp:
--------------------------------------------------------------------------------
 1 | #include "win32\controls\button.h"
 2 | 
 3 | Button::Button(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height)
 4 | {
 5 | 	parentHwnd = parent;
 6 | 	hWnd = CreateWindow(
 7 | 		"BUTTON",
 8 | 		text,
 9 | 		WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_PUSHBUTTON | BS_FLAT,
10 | 		x, y, width, height,
11 | 		parent,
12 | 		(HMENU)menuId,
13 | 		(HINSTANCE)GetWindowLongPtr(parent, GWLP_HINSTANCE),
14 | 		NULL
15 | 	);
16 | 
17 | 	applySystemFont();
18 | }
19 | 


--------------------------------------------------------------------------------
/include/logging/terminallogstrategy.h:
--------------------------------------------------------------------------------
 1 | #ifndef TERMINALLOGSTRATEGY_H
 2 | #define TERMINALLOGSTRATEGY_H
 3 | 
 4 | #include <stdio.h>
 5 | #include "colors.h"
 6 | #include "logging/logstrategy.h"
 7 | 
 8 | class TerminalLogStrategy : public LogStrategy
 9 | {
10 | public:
11 | 	virtual void verbose(const char* message) override;
12 | 	virtual void debug(const char* message) override;
13 | 	virtual void info(const char* message) override;
14 | 	virtual void error(const char* message) override;
15 | };
16 | 
17 | #endif


--------------------------------------------------------------------------------
/include/win32/controls/editbox.h:
--------------------------------------------------------------------------------
 1 | #ifndef EDITBOX_H
 2 | #define EDITBOX_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <Uxtheme.h>
 6 | #include <string>
 7 | #include "win32/controls/control.h"
 8 | 
 9 | class EditBox : public Control 
10 | {
11 | public:
12 | 	EditBox(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height);
13 | 
14 | 	void setReadOnly(bool readOnly);
15 | 	bool isReadOnly() const;
16 | 	void setText(std::string text);
17 | 	std::string getText() const;
18 | private:
19 | };
20 | 
21 | #endif


--------------------------------------------------------------------------------
/include/archive.h:
--------------------------------------------------------------------------------
 1 | #ifndef ARCHIVEUTILS_H
 2 | #define ARCHIVEUTILS_H
 3 | 
 4 | #include "filesystem.hpp"
 5 | #ifdef __linux__
 6 | #include <cstring>
 7 | #endif
 8 | 
 9 | #include "ziparchive.h"
10 | #include "tar.h"
11 | #include "debug.h"
12 | #include <errno.h>
13 | 
14 | class Archive
15 | {
16 | public:
17 | 	static bool extractZip(fs::path from, std::string filename, fs::path to);
18 | 	static bool extractTar(fs::path from, std::string filename, fs::path to);
19 | 	static void extractionProgress(float progress);
20 | };
21 | 
22 | #endif // ARCHIVEUTILS_H
23 | 


--------------------------------------------------------------------------------
/include/logging/streamlogstrategy.h:
--------------------------------------------------------------------------------
 1 | #ifndef STREAMLOGSTRATEGY_H
 2 | #define STREAMLOGSTRATEGY_H
 3 | 
 4 | #include <fstream>
 5 | #include "logging/logstrategy.h"
 6 | 
 7 | class StreamLogStrategy : public LogStrategy
 8 | {
 9 | public:
10 | 	StreamLogStrategy(std::ostream& stream);
11 | 
12 | 	virtual void verbose(const char* message) override;
13 | 	virtual void debug(const char* message) override;
14 | 	virtual void info(const char* message) override;
15 | 	virtual void error(const char* message) override;
16 | private:
17 | 	std::ostream& stream;
18 | };
19 | 
20 | #endif


--------------------------------------------------------------------------------
/include/logging/statusbarlogstrategy.h:
--------------------------------------------------------------------------------
 1 | #ifndef STATUSBARLOGSTRATEGY_H
 2 | #define STATUSBARLOGSTRATEGY_H
 3 | 
 4 | #include "logging/logstrategy.h"
 5 | #include "win32/controls/statusbar.h"
 6 | 
 7 | class StatusBarLogStrategy : public LogStrategy
 8 | {
 9 | public:
10 | 	StatusBarLogStrategy(StatusBar* statusBar);
11 | 
12 | 	virtual void verbose(const char* message) override;
13 | 	virtual void debug(const char* message) override;
14 | 	virtual void info(const char* message) override;
15 | 	virtual void error(const char* message) override;
16 | private:
17 | 	StatusBar* statusBar;
18 | };
19 | 
20 | #endif


--------------------------------------------------------------------------------
/src/logging/terminallogstrategy.cpp:
--------------------------------------------------------------------------------
 1 | #include "logging/terminallogstrategy.h"
 2 | 
 3 | void TerminalLogStrategy::verbose(const char* message)
 4 | {
 5 | 	printf(ANSI_COLOR_BLUE "%s" ANSI_COLOR_RESET "\n", message);
 6 | }
 7 | 
 8 | void TerminalLogStrategy::debug(const char* message)
 9 | {
10 | 	printf(ANSI_COLOR_CYAN "%s" ANSI_COLOR_RESET "\n", message);
11 | }
12 | 
13 | void TerminalLogStrategy::info(const char* message)
14 | {
15 | 	printf("%s\n", message);
16 | }
17 | 
18 | void TerminalLogStrategy::error(const char* message)
19 | {
20 | 	fprintf(stderr, ANSI_COLOR_RED "%s" ANSI_COLOR_RESET "\n", message);
21 | }


--------------------------------------------------------------------------------
/include/logging/combinedlogstrategy.h:
--------------------------------------------------------------------------------
 1 | #ifndef COMBINEDLOGSTRATEGY_H
 2 | #define COMBINEDLOGSTRATEGY_H
 3 | 
 4 | #include <vector>
 5 | #include "logging/logstrategy.h"
 6 | 
 7 | class CombinedLogStrategy : public LogStrategy
 8 | {
 9 | public:
10 | 	CombinedLogStrategy() {};
11 | 
12 | 	void add(LogStrategy* strategy);
13 | 
14 | 	virtual void verbose(const char* message) override;
15 | 	virtual void debug(const char* message) override;
16 | 	virtual void info(const char* message) override;
17 | 	virtual void error(const char* message) override;
18 | private:
19 | 	std::vector<LogStrategy*> logStrategies;
20 | };
21 | 
22 | #endif


--------------------------------------------------------------------------------
/include/win32/controls/control.h:
--------------------------------------------------------------------------------
 1 | #ifndef CONTROL_H
 2 | #define CONTROL_H
 3 | 
 4 | #include <map>
 5 | #include <Windows.h>
 6 | #include "win32/events/events.h"
 7 | 
 8 | class Control
 9 | {
10 | public:
11 | 	Control();
12 | 
13 | 	void addEventListener(EventType eventType, EventCallback callback);
14 | 	void triggerEvent(EventType eventType);
15 | 
16 | 	void setEnabled(bool enabled);
17 | 	bool isEnabled();
18 | 
19 | 	HWND getHwnd() const;
20 | 
21 | protected:
22 | 	std::map<EventType, EventCallback> events;
23 | 	HWND hWnd = NULL;
24 | 	HWND parentHwnd = NULL;
25 | 
26 | 	void applySystemFont();
27 | };
28 | 
29 | #endif


--------------------------------------------------------------------------------
/src/logging/statusbarlogstrategy.cpp:
--------------------------------------------------------------------------------
 1 | #include "logging/statusbarlogstrategy.h"
 2 | 
 3 | StatusBarLogStrategy::StatusBarLogStrategy(StatusBar* statusBar)
 4 | 	: statusBar(statusBar)
 5 | {
 6 | 
 7 | }
 8 | 
 9 | void StatusBarLogStrategy::verbose(const char* message)
10 | {
11 | 	statusBar->setText(message);
12 | }
13 | 
14 | void StatusBarLogStrategy::debug(const char* message)
15 | {
16 | 	statusBar->setText(message);
17 | }
18 | 
19 | void StatusBarLogStrategy::info(const char* message)
20 | {
21 | 	statusBar->setText(message);
22 | }
23 | 
24 | void StatusBarLogStrategy::error(const char* message)
25 | {
26 | 	statusBar->setText(message);
27 | }


--------------------------------------------------------------------------------
/include/win32/resources.h:
--------------------------------------------------------------------------------
 1 | #ifndef RESOURCES_H
 2 | #define RESOURCES_H
 3 | 
 4 | #define IDC_PATH_EDITBOX 50
 5 | #define IDC_PATH_BROWSEBTN 51
 6 | #define IDC_PATH_EDITBOXX64 52
 7 | #define IDC_PATH_BROWSEBTNX64 53
 8 | #define IDC_BROWSELABEL 54
 9 | #define IDC_BROWSELABEL_X64 55
10 | #define IDC_TOOLS_GROUPBOX 56
11 | #define IDC_DOWNLOADTOOLS_CHECKBOX 57
12 | #define IDC_TOOLSPATH_LABEL 58
13 | #define IDC_TOOLSPATH_EDITBOX 59
14 | #define IDC_TOOLSPATH_BROWSE_BTN 60
15 | #define IDC_PATCH_BTN 61
16 | #define IDC_REVERT_PATCH_BTN 62
17 | #define IDC_PROGRESSBAR 63
18 | #define IDC_STATUSBAR 64
19 | #define IDC_TOOLS_DOWNLOAD_BTN 65
20 | 
21 | #endif


--------------------------------------------------------------------------------
/src/logging/streamlogstrategy.cpp:
--------------------------------------------------------------------------------
 1 | #include "logging/streamlogstrategy.h"
 2 | 
 3 | StreamLogStrategy::StreamLogStrategy(std::ostream& stream)
 4 | 	: stream(stream)
 5 | {
 6 | }
 7 | 
 8 | void StreamLogStrategy::verbose(const char* message)
 9 | {
10 | 	stream << "::VERBOSE " << message << std::endl;
11 | }
12 | 
13 | void StreamLogStrategy::debug(const char* message)
14 | {
15 | 	stream << "::DEBUG " << message << std::endl;
16 | }
17 | 
18 | void StreamLogStrategy::info(const char* message)
19 | {
20 | 	stream << "::INFO " << message << std::endl;
21 | }
22 | 
23 | void StreamLogStrategy::error(const char* message)
24 | {
25 | 	stream << "::ERROR " << message << std::endl;
26 | }


--------------------------------------------------------------------------------
/include/buildsparser.h:
--------------------------------------------------------------------------------
 1 | #ifndef BUILDSPARSER_H
 2 | #define BUILDSPARSER_H
 3 | 
 4 | #include <string>
 5 | #include <regex>
 6 | #include <list>
 7 | #include <sstream>
 8 | 
 9 | #include "config.h"
10 | 
11 | class BuildsParser
12 | {
13 | public:
14 | 	BuildsParser(const std::string& buildshtmltext);
15 | 	const std::string& getLatest() const;
16 | 	std::list<std::string>::const_iterator cbegin() const;
17 | 	std::list<std::string>::const_iterator cend() const;
18 | 	int size() const;
19 | private:
20 | 	std::string htmltext;
21 | 	std::list<std::string> builds;
22 | 	std::regex pattern = std::regex(VERSION_REGEX_PATTERN, std::regex::icase);
23 | };
24 | 
25 | #endif // BUILDSPARSER_H
26 | 


--------------------------------------------------------------------------------
/include/installinfo.h:
--------------------------------------------------------------------------------
 1 | #ifndef INSTALLINFOUTILS_H
 2 | #define INSTALLINFOUTILS_H
 3 | 
 4 | #include <string>
 5 | #include <stdexcept>
 6 | 
 7 | #include "config.h"
 8 | 
 9 | class VMWareInfoException : public std::runtime_error
10 | {
11 | public:
12 | 	VMWareInfoException(const char* message) : std::runtime_error(message) {}
13 | 	VMWareInfoException(const std::string& message) : std::runtime_error(message) {}
14 | };
15 | 
16 | class VMWareInfoRetriever
17 | {
18 | public:
19 | 	VMWareInfoRetriever();
20 | 	std::string getInstallPath();
21 | 	std::string getInstallPath64();
22 | 	std::string getProductVersion();
23 | 
24 | private:
25 | 	std::string installPath, installPath64, prodVersion;
26 | };
27 | 
28 | #endif // INSTALLINFOUTILS_H
29 | 


--------------------------------------------------------------------------------
/src/win32/controls/checkbox.cpp:
--------------------------------------------------------------------------------
 1 | #include "..\..\..\include\win32\controls\checkbox.h"
 2 | 
 3 | CheckBox::CheckBox(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height)
 4 | {
 5 | 	hWnd = CreateWindow(
 6 | 		"BUTTON",
 7 | 		text,
 8 | 		WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_AUTOCHECKBOX,
 9 | 		x, y, width, height,
10 | 		parent,
11 | 		(HMENU)menuId,
12 | 		(HINSTANCE)GetWindowLongPtr(parent, GWLP_HINSTANCE),
13 | 		NULL
14 | 	);
15 | 
16 | 	applySystemFont();
17 | }
18 | 
19 | void CheckBox::set(bool checked)
20 | {
21 | 	SendMessage(hWnd, BM_SETCHECK, checked ? BST_CHECKED : BST_UNCHECKED, 0);
22 | }
23 | 
24 | bool CheckBox::isChecked()
25 | {
26 | 	HRESULT res = SendMessageA(hWnd, BM_GETCHECK, 0, 0);
27 | 	return res == BST_CHECKED;
28 | }
29 | 


--------------------------------------------------------------------------------
/include/ziparchive.h:
--------------------------------------------------------------------------------
 1 | #ifndef UNLOCKER_ZIP_H
 2 | #define UNLOCKER_ZIP_H
 3 | 
 4 | #include <string>
 5 | #include <stdexcept>
 6 | #include <array>
 7 | 
 8 | #define LIBZIP_STATIC
 9 | 
10 | #include <zipconf.h>
11 | #include <zip.h>
12 | 
13 | class ZipException : public std::runtime_error
14 | {
15 | public:
16 | 	ZipException(const char* message) : std::runtime_error(message) {}
17 | 	ZipException(const std::string& message) : std::runtime_error(message) {}
18 | };
19 | 
20 | class Zip {
21 | public:
22 | 	Zip(const std::string& zipFile);
23 | 	~Zip();
24 | 	bool extract(const std::string& fileName, const std::string& to, void(*progressCallback)(float) = nullptr);
25 | private:
26 | 	static constexpr size_t AR_BUFFER_SIZE = 1024*16;
27 | 	zip_t* zip_archive = nullptr;
28 | };
29 | 
30 | 
31 | #endif // UNLOCKER_ZIP_H


--------------------------------------------------------------------------------
/include/toolsdownloader.h:
--------------------------------------------------------------------------------
 1 | #ifndef TOOLSDOWNLOADER_H
 2 | #define TOOLSDOWNLOADER_H
 3 | 
 4 | #include <string>
 5 | #include "filesystem.hpp"
 6 | #include "network.h"
 7 | #include "archive.h"
 8 | #include "buildsparser.h"
 9 | #include "debug.h"
10 | 
11 | class ToolsDownloaderException : public std::runtime_error
12 | {
13 | public:
14 | 	ToolsDownloaderException(const char* message) : std::runtime_error(message) {}
15 | 	ToolsDownloaderException(const std::string& message) : std::runtime_error(message) {}
16 | };
17 | 
18 | class ToolsDownloader
19 | {
20 | public:
21 | 	ToolsDownloader(Network& network);
22 | 	bool download(const fs::path& to);
23 | private:
24 | 	Network& network;
25 | 
26 | 	bool downloadFromCore(const fs::path& to);
27 | 	bool downloadDirectly(const fs::path& to);
28 | };
29 | 
30 | #endif // TOOLSDOWNLOADER_H


--------------------------------------------------------------------------------
/src/win32/controls/statusbar.cpp:
--------------------------------------------------------------------------------
 1 | #include "win32\controls\statusbar.h"
 2 | 
 3 | StatusBar::StatusBar(HWND parent, int menuId, LPCSTR text)
 4 | {
 5 |     hWnd = CreateWindowEx(
 6 |         0,                       // no extended styles
 7 |         STATUSCLASSNAME,         // name of status bar class
 8 |         text,           
 9 |         WS_CHILD | WS_VISIBLE,   // creates a visible child window
10 |         0, 0, 0, 0,              // ignores size and position
11 |         parent,                 // handle to parent window
12 |         (HMENU)menuId,          // child window identifier
13 |         (HINSTANCE)GetWindowLongPtr(parent, GWLP_HINSTANCE),                   // handle to application instance
14 |         NULL);
15 | }
16 | 
17 | void StatusBar::setText(LPCSTR text)
18 | {
19 |     SetWindowText(hWnd, text);
20 | }
21 | 


--------------------------------------------------------------------------------
/src/logging/combinedlogstrategy.cpp:
--------------------------------------------------------------------------------
 1 | #include "logging/combinedlogstrategy.h"
 2 | 
 3 | void CombinedLogStrategy::add(LogStrategy* strategy)
 4 | {
 5 | 	logStrategies.emplace_back(strategy);
 6 | }
 7 | 
 8 | void CombinedLogStrategy::verbose(const char* message)
 9 | {
10 | 	for (LogStrategy* strategy : logStrategies) {
11 | 		strategy->verbose(message);
12 | 	}
13 | }
14 | 
15 | void CombinedLogStrategy::debug(const char* message)
16 | {
17 | 	for (LogStrategy* strategy : logStrategies) {
18 | 		strategy->debug(message);
19 | 	}
20 | }
21 | 
22 | void CombinedLogStrategy::info(const char* message)
23 | {
24 | 	for (LogStrategy* strategy : logStrategies) {
25 | 		strategy->info(message);
26 | 	}
27 | }
28 | 
29 | void CombinedLogStrategy::error(const char* message)
30 | {
31 | 	for (LogStrategy* strategy : logStrategies) {
32 | 		strategy->error(message);
33 | 	}
34 | }


--------------------------------------------------------------------------------
/tests/test_zip.cpp:
--------------------------------------------------------------------------------
 1 | #include "ziparchive.h"
 2 | #include "test.h"
 3 | 
 4 | void zip_extraction();
 5 | 
 6 | int main(int argc, char** argv) {
 7 | 	test_info("Running TEST: Zip Extraction");
 8 | 
 9 | 	zip_extraction();
10 | 
11 | #ifdef WIN32
12 | 	system("pause");
13 | #endif
14 | 	return 0;
15 | }
16 | 
17 | void zip_extraction() {
18 | 	BEGIN_TEST("Testing ZIP Extraction");
19 | 
20 | 	test_status("CWD is: %s", getCwd().c_str());
21 | 
22 | 	if (!fileExists("./test.zip"))
23 | 	{
24 | 		TEST_ERROR("File test.zip does not exist in current directory");
25 | 	}
26 | 
27 | 	try {
28 | 		Zip testZip("./test.zip");
29 | 
30 | 		printf("\n");
31 | 		testZip.extract("test.file", "./test.file", updateProgress);
32 | 		printf("\n");
33 | 
34 | 		remove("./test.file");
35 | 
36 | 		TEST_SUCCESS();
37 | 	}
38 | 	catch (const std::exception& exc) {
39 | 		TEST_ERROR(exc.what());
40 | 	}
41 | }


--------------------------------------------------------------------------------
/src/win32/controls/progress.cpp:
--------------------------------------------------------------------------------
 1 | #include "win32\controls\progress.h"
 2 | 
 3 | 
 4 | Progress::Progress(HWND parent, int menuId, int x, int y, int width, int height)
 5 | {
 6 | 	hWnd = CreateWindow(
 7 | 		PROGRESS_CLASS,
 8 | 		"",
 9 | 		WS_CHILD | WS_VISIBLE,
10 | 		x, y, width, height,
11 | 		parent,
12 | 		(HMENU)menuId,
13 | 		(HINSTANCE)GetWindowLongPtr(parent, GWLP_HINSTANCE),
14 | 		NULL
15 | 	);
16 | 
17 | 	applySystemFont();
18 | }
19 | 
20 | void Progress::setRange(int range)
21 | {
22 | 	SendMessage(hWnd, PBM_SETRANGE, 0, MAKELPARAM(0, range));
23 | }
24 | 
25 | void Progress::setStep(int step)
26 | {
27 | 	SendMessage(hWnd, PBM_SETSTEP, (WPARAM)step, 0);
28 | }
29 | 
30 | void Progress::setProgress(int progress)
31 | {
32 | 	SendMessage(hWnd, PBM_SETPOS, (WPARAM)progress, 0);
33 | }
34 | 
35 | void Progress::advance()
36 | {
37 | 	SendMessage(hWnd, PBM_STEPIT, 0, 0);
38 | }
39 | 


--------------------------------------------------------------------------------
/include/win32/unpatchertask.h:
--------------------------------------------------------------------------------
 1 | #ifndef UNPATCHERTASK_H
 2 | #define UNPATCHERTASK_H
 3 | 
 4 | #include <functional>
 5 | #include "win32/task.h"
 6 | #include "win32/patchresult.h"
 7 | #include "unlocker_win.h"
 8 | 
 9 | class MainWindow;
10 | 
11 | class UnpatcherTask : public Task<void, float, PatchResult>
12 | {
13 | public:
14 | 	UnpatcherTask(MainWindow& mainWindow);
15 | 	void setOnCompleteCallback(std::function<void(PatchResult)> completeCallback);
16 | 	void setOnProgressCallback(std::function<void(float)> progressCallback);
17 | protected:
18 | 	void onProgressUpdate(float progress) override;
19 | 	PatchResult doInBackground(void* arg) override;
20 | 	void onPostExecute(PatchResult result) override;
21 | private:
22 | 	MainWindow& mainWindow;
23 | 
24 | 	std::function<void(PatchResult)> onCompleteCallback = nullptr;
25 | 	std::function<void(float)> onProgressCallback = nullptr;
26 | };
27 | 
28 | #endif


--------------------------------------------------------------------------------
/include/unlocker_win.h:
--------------------------------------------------------------------------------
 1 | #ifndef UNLOCKERWIN_H
 2 | #define UNLOCKERWIN_H
 3 | 
 4 | #include <string>
 5 | #include "filesystem.hpp"
 6 | #include <map>
 7 | #include <stdexcept>
 8 | 
 9 | #include <curl/curl.h>
10 | 
11 | #include "config.h"
12 | #include "network.h"
13 | #include "versionparser.h"
14 | #include "debug.h"
15 | #include "toolsdownloader.h"
16 | #include "installinfo.h"
17 | #include "winservices.h"
18 | #include "patcher.h"
19 | #include "patchversioner.h"
20 | 
21 | #include <stdio.h>
22 | 
23 | bool downloadTools(fs::path path, std::function<void(double, double, double, double)> progressCallback = nullptr);
24 | void copyTools(fs::path toolspath, fs::path copyTo);
25 | 
26 | void preparePatchWin(fs::path backupPath, fs::path vmInstallPath);
27 | void applyPatchWin(const fs::path& vmwareInstallPath, const fs::path& vmwareInstallPath64);
28 | void stopServices();
29 | void restartServices();
30 | 
31 | #endif // UNLOCKERWIN_H


--------------------------------------------------------------------------------
/src/buildsparser.cpp:
--------------------------------------------------------------------------------
 1 | #include "buildsparser.h"
 2 | 
 3 | BuildsParser::BuildsParser(const std::string& buildshtmltext)
 4 | 	:	htmltext(buildshtmltext)
 5 | {
 6 | 	std::istringstream iss(htmltext);
 7 | 
 8 | 	std::string line;
 9 | 	while (std::getline(iss, line))
10 | 	{
11 | 		std::smatch vmatch;
12 | 		if (std::regex_match(line, vmatch, pattern))
13 | 		{
14 | 			builds.emplace_back(vmatch.str(1));
15 | 		}
16 | 	}
17 | }
18 | 
19 | const std::string& BuildsParser::getLatest() const
20 | {
21 | 	if (builds.size() == 0)
22 | 		throw std::runtime_error("No elements in the list");
23 | 
24 | 	return *builds.cbegin();
25 | }
26 | 
27 | std::list<std::string>::const_iterator BuildsParser::cbegin() const
28 | {
29 | 	return builds.cbegin();
30 | }
31 | 
32 | std::list<std::string>::const_iterator BuildsParser::cend() const
33 | {
34 | 	return builds.end();
35 | }
36 | 
37 | int BuildsParser::size() const
38 | {
39 | 	return builds.size();
40 | }
41 | 


--------------------------------------------------------------------------------
/include/unlocker_lnx.h:
--------------------------------------------------------------------------------
 1 | #ifndef UNLOCKERLNX_H
 2 | #define UNLOCKERLNX_H
 3 | 
 4 | #include <string>
 5 | #include "filesystem.hpp"
 6 | #include <map>
 7 | #include <stdexcept>
 8 | 
 9 | #include <curl/curl.h>
10 | 
11 | #include "config.h"
12 | #include "network.h"
13 | #include "versionparser.h"
14 | #include "debug.h"
15 | #include "toolsdownloader.h"
16 | #include "installinfo.h"
17 | #include "patcher.h"
18 | 
19 | #include <unistd.h>
20 | #include <strings.h>
21 | 
22 | #include "patchversioner.h"
23 | 
24 | #define stricmp(a, b) strcasecmp(a, b)
25 | 
26 | #include <stdio.h>
27 | 
28 | #define CHECKRES(x) try{ (x); } catch (const PatchException& exc) { Logger::error(exc.what()); }
29 | #define KILL(x) (x); exit(1);
30 | 
31 | bool downloadTools(fs::path path);
32 | void copyTools(fs::path toolspath);
33 | 
34 | void installLnx();
35 | void preparePatchLnx(fs::path backupPath);
36 | void applyPatchLnx();
37 | void uninstallLnx();
38 | 
39 | #endif // UNLOKERLNX_H


--------------------------------------------------------------------------------
/src/win32/controls/editbox.cpp:
--------------------------------------------------------------------------------
 1 | #include "win32\controls\editbox.h"
 2 | 
 3 | EditBox::EditBox(HWND parent, int menuId, LPCSTR text, int x, int y, int width, int height)
 4 | {
 5 | 	hWnd = CreateWindow(
 6 | 		"Edit",
 7 | 		text,
 8 | 		WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT | ES_AUTOHSCROLL,
 9 | 		x, y, width, height,
10 | 		parent,
11 | 		(HMENU)menuId,
12 | 		(HINSTANCE)GetWindowLongPtr(parent, GWLP_HINSTANCE),
13 | 		NULL
14 | 	);
15 | 
16 | 	applySystemFont();
17 | }
18 | 
19 | void EditBox::setReadOnly(bool readOnly)
20 | {
21 | 	SendMessage(hWnd, EM_SETREADONLY, readOnly, 0);
22 | }
23 | 
24 | bool EditBox::isReadOnly() const
25 | {
26 | 	return GetWindowLongPtr(hWnd, GWL_STYLE) & ES_READONLY;
27 | }
28 | 
29 | void EditBox::setText(std::string text)
30 | {
31 | 	SetWindowText(hWnd, text.c_str());
32 | }
33 | 
34 | std::string EditBox::getText() const
35 | {
36 | 	char buffer[4096];
37 | 	GetWindowText(hWnd, buffer, 4096);
38 | 	return std::string(buffer);
39 | }
40 | 


--------------------------------------------------------------------------------
/include/patchversioner.h:
--------------------------------------------------------------------------------
 1 | #ifndef PATCHVERSIONER_H
 2 | #define PATCHVERSIONER_H
 3 | 
 4 | #ifdef _WIN32
 5 | #include <Windows.h>
 6 | #endif
 7 | 
 8 | #include <stdexcept>
 9 | #include <cstdio>
10 | #include <string>
11 | #include <cstring>
12 | 
13 | #include "filesystem.hpp"
14 | #include "config.h"
15 | 
16 | class PatchVersionerException : public std::runtime_error
17 | {
18 | public:
19 | 	PatchVersionerException(const char* msg) : std::runtime_error(msg) {}
20 | 	PatchVersionerException(const std::string& msg) : std::runtime_error(msg) {}
21 | };
22 | 
23 | class PatchVersioner
24 | {
25 | public:
26 | 	PatchVersioner(const fs::path& installPath);
27 | 	time_t getPatchTime() const;
28 | 	std::string getPatchVersion() const;
29 | 	void writePatchData();
30 | 	void removePatchVersion();
31 | 	bool hasPatch() const;
32 | 
33 | private:
34 | 	typedef struct _patch_version_t {
35 | 		char timestamp[256];
36 | 		char version[256];
37 | 	} patch_version_t;
38 | 
39 | 	std::string versionFile;
40 | 	bool haspatch = false;
41 | 	patch_version_t vData = {};
42 | };
43 | 
44 | #endif


--------------------------------------------------------------------------------
/include/win32/controls/window.h:
--------------------------------------------------------------------------------
 1 | #ifndef WINDOW_H
 2 | #define WINDOW_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <string>
 6 | #include <memory>
 7 | #include <stdexcept>
 8 | #include <map>
 9 | #include "debug.h"
10 | #include "win32/controls/control.h"
11 | #include "win32/events/events.h"
12 | 
13 | class Window : public Control
14 | {
15 | public:
16 | 	Window(HINSTANCE hInstance, int nCmdShow, const std::string& className, const std::string& title, int x = CW_USEDEFAULT, int y = CW_USEDEFAULT, int width = CW_USEDEFAULT, int height = CW_USEDEFAULT);
17 | 	~Window();
18 | 	// Override to setup buttons, controls, etc.
19 | 	virtual void onCreate(HWND hWnd) {};
20 | 	void show();
21 | 	void registerControl(int menuId, Control* control);
22 | protected:
23 | 	std::string className;
24 | 	std::string title;
25 | 	HINSTANCE hInstance = NULL;
26 | 	int nCmdShow,
27 | 		x,
28 | 		y,
29 | 		width,
30 | 		height;
31 | 
32 | private:
33 | 	static LRESULT CALLBACK WindowProc(HWND hWnd, UINT uMSG, WPARAM wParam, LPARAM lParam);
34 | 	std::map<int, Control*> controls;
35 | 
36 | 	void messageLoop();
37 | };
38 | 
39 | #endif


--------------------------------------------------------------------------------
/include/winservices.h:
--------------------------------------------------------------------------------
 1 | #ifndef SERVICESTOPUTILS_H
 2 | #define SERVICESTOPUTILS_H
 3 | 
 4 | #include <string>
 5 | #include <stdarg.h>
 6 | 
 7 | #include "Windows.h"
 8 | 
 9 | class ServiceStopper
10 | {
11 | public:
12 | 	class ServiceStopException : public std::exception
13 | 	{
14 | 	public:
15 | 		ServiceStopException(const char* msg, ...) {
16 | 			char formatted[512];
17 | 			va_list args;
18 | 			va_start(args, msg);
19 | 			vsprintf(formatted, msg, args);
20 | 			va_end(args);
21 | 			sprintf(message, "Error: %s", formatted);
22 | 		}
23 | 		const char* what() const noexcept { return message; }
24 | 	private:
25 | 		char message[1024];
26 | 	};
27 | 
28 | 	// TODO: check if linux needs these functions and if so reimplement them
29 | 	//		 or alternatively wrap them in ifdef if it doesn't need them
30 | 	static void StopService_s(std::string serviceName);
31 | 	static bool StopDependantServices(SC_HANDLE schService, SC_HANDLE schSCManager);
32 | 
33 | 	static bool StartService_s(std::string serviceName);
34 | 
35 | 	static bool KillProcess(std::string procName);
36 | };
37 | 
38 | #endif // SERVICESTOPUTILS_H
39 | 


--------------------------------------------------------------------------------
/src/win32/controls/control.cpp:
--------------------------------------------------------------------------------
 1 | #include "win32\controls\control.h"
 2 | 
 3 | Control::Control()
 4 | {
 5 | }
 6 | 
 7 | void Control::addEventListener(EventType eventType, EventCallback callback)
 8 | {
 9 | 	events[eventType] = callback;
10 | }
11 | 
12 | void Control::triggerEvent(EventType eventType)
13 | {
14 | 	std::map<EventType, EventCallback>::iterator e;
15 | 	if ((e = events.find(eventType)) != events.end()) {
16 | 		e->second();
17 | 	}
18 | }
19 | 
20 | void Control::setEnabled(bool enabled)
21 | {
22 | 	//SendMessage(hWnd, WM_ENABLE, enabled ? TRUE : FALSE, 0);
23 | 	EnableWindow(hWnd, enabled);
24 | }
25 | 
26 | bool Control::isEnabled()
27 | {
28 | 	return IsWindowEnabled(hWnd);
29 | }
30 | 
31 | HWND Control::getHwnd() const
32 | {
33 | 	return hWnd;
34 | }
35 | 
36 | void Control::applySystemFont()
37 | {
38 | 	// Set system font
39 | 	NONCLIENTMETRICS metrics;
40 | 	metrics.cbSize = sizeof(metrics);
41 | 	SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(metrics), &metrics, 0);
42 | 	HFONT sysFont = CreateFontIndirect(&metrics.lfMessageFont);
43 | 	SendMessage(hWnd, WM_SETFONT, (WPARAM)sysFont, MAKELPARAM(TRUE, 0));
44 | }
45 | 


--------------------------------------------------------------------------------
/modules/FindLibZip.cmake:
--------------------------------------------------------------------------------
 1 | FIND_PATH(LIBZIP_INCLUDE_DIR
 2 |   zip.h
 3 |   "$ENV{LIB_DIR}/include"
 4 |   "$ENV{INCLUDE}"
 5 |   /usr/local/include
 6 |   /usr/include
 7 | )
 8 | 
 9 | FIND_PATH(LIBZIP_CONF_INCLUDE_DIR
10 |   zipconf.h
11 |   "$ENV{LIB_DIR}/include"
12 |   "$ENV{LIB_DIR}/lib/libzip/include"
13 |   "$ENV{LIB}/lib/libzip/include"
14 |   /usr/local/lib/libzip/include
15 |   /usr/lib/libzip/include
16 |   /usr/local/include
17 |   /usr/include
18 |   "$ENV{INCLUDE}"
19 | )
20 | 
21 | FIND_LIBRARY(LIBZIP_LIBRARY NAMES zip PATHS "$ENV{LIB_DIR}/lib" "$ENV{LIB}" /usr/local/lib /usr/lib )
22 | 
23 | INCLUDE(FindPackageHandleStandardArgs)
24 | FIND_PACKAGE_HANDLE_STANDARD_ARGS(LibZip DEFAULT_MSG
25 |                                   LIBZIP_LIBRARY LIBZIP_INCLUDE_DIR LIBZIP_CONF_INCLUDE_DIR)
26 | 
27 | SET(LIBZIP_INCLUDE_DIRS ${LIBZIP_INCLUDE_DIR} ${LIBZIP_CONF_INCLUDE_DIR})
28 | MARK_AS_ADVANCED(LIBZIP_LIBRARY LIBZIP_INCLUDE_DIR LIBZIP_CONF_INCLUDE_DIR LIBZIP_INCLUDE_DIRS)
29 | 
30 | IF (LIBZIP_FOUND)
31 |   MESSAGE(STATUS "Found libzip: ${LIBZIP_LIBRARY}")
32 | ELSE (LIPZIP_FOUND)
33 |   MESSAGE(FATAL_ERROR "Could not find libzip")
34 | ENDIF (LIBZIP_FOUND)


--------------------------------------------------------------------------------
/include/debug.h:
--------------------------------------------------------------------------------
 1 | #ifndef DEBUGUTILS_H
 2 | #define DEBUGUTILS_H
 3 | 
 4 | #include "config.h"
 5 | #include <iostream>
 6 | #include <stdarg.h>
 7 | #include "colors.h"
 8 | #include "logging/logstrategy.h"
 9 | 
10 | #ifdef _WIN32
11 | #include <Windows.h>
12 | #include "win32/controls/statusbar.h"
13 | #endif
14 | 
15 | #define LOGLEVEL_VERBOSE 3
16 | #define LOGLEVEL_DEBUG 2
17 | #define LOGLEVEL_INFO 1
18 | #define LOGLEVEL_NONE 0
19 | 
20 | class Logger
21 | {
22 | public:
23 | 	static void init(LogStrategy* strategy);
24 | 	static void free();
25 | 
26 | 	static void verbose(std::string msg);
27 | 	static void verbose(const char* msg, ...);
28 | 
29 | 	static void debug(std::string msg);
30 | 	static void debug(const char* msg, ...);
31 | 
32 | 	static void info(std::string msg);
33 | 	static void info(const char* msg, ...);
34 | 
35 | 	static void error(std::string err);
36 | 	static void error(const char* err, ...);
37 | 
38 | #ifdef _WIN32
39 | 	static void printWinDebug(const char* fmt, ...);
40 | #endif
41 | private:
42 | 	Logger(LogStrategy* strategy);
43 | 
44 | 	static Logger* instance;
45 | 	LogStrategy* logStrategy;
46 | };
47 | 
48 | #endif // DEBUGUTILS_H
49 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | PREFIX = /usr
 2 | 
 3 | CXX	?= g++
 4 | 
 5 | src	= src/versionparser.cpp \
 6 | 	src/buildsparser.cpp \
 7 | 	src/archive.cpp \
 8 | 	src/network.cpp \
 9 | 	src/debug.cpp \
10 | 	src/installinfo.cpp \
11 | 	src/patcher.cpp \
12 | 	src/tar.cpp \
13 | 	src/main.cpp \
14 | 	src/ziparchive.cpp \
15 | 	src/toolsdownloader.cpp \
16 | 	src/logging/combinedlogstrategy.cpp \
17 | 	src/logging/terminallogstrategy.cpp \
18 | 	src/logging/streamlogstrategy.cpp \
19 | 	src/logging/logstrategy.cpp \
20 | 	src/patchversioner.cpp \
21 | 	src/unlocker_lnx.cpp
22 | 
23 | obj	= $(src:.cpp=.o)
24 | 
25 | INCLUDE		= -Iinclude
26 | CXXFLAGS	= -Wall -std=c++17 $(INCLUDE)
27 | 
28 | LIBS	+= -lcurl -lzip -lstdc++fs
29 | 
30 | auto-unlocker:	$(obj)
31 | 	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)
32 | 
33 | .PHONY: clean
34 | clean:
35 | 	rm -f $(obj) auto-unlocker
36 | 
37 | depend: $(src)
38 | 	makedepend -- $(INCLUDE) $^
39 | 
40 | .PHONY: install
41 | install: auto-unlocker
42 | 	install -D $< $(DESTDIR)$(PREFIX)/bin/auto-unlocker
43 | #	mkdir -p $(DESTDIR)$(PREFIX)/bin
44 | #	cp $< $(DESTDIR)$(PREFIX)/bin/auto-unlocker
45 | 
46 | .PHONY: uninstall
47 | uninstall: auto-unlocker
48 | 	-rm -f $(DESTDIR)$(PREFIX)/bin/auto-unlocker
49 | 


--------------------------------------------------------------------------------
/src/versionparser.cpp:
--------------------------------------------------------------------------------
 1 | #include "versionparser.h"
 2 | 
 3 | VersionParser::VersionParser(const std::string& versionhtmltext)
 4 | 	: htmltext(versionhtmltext)
 5 | {
 6 | 	std::istringstream iss(htmltext);
 7 | 
 8 | 	std::string line;
 9 | 	while (std::getline(iss, line))
10 | 	{
11 | 		try
12 | 		{
13 | 			std::smatch vmatch;
14 | 			if (std::regex_match(line, vmatch, pattern))
15 | 			{
16 | 				Version v(vmatch.str(1));
17 | 				versions.emplace_back(v);
18 | 			}
19 | 		}
20 | 		catch (const Version::VersionException & exc)
21 | 		{
22 | 			// Not a good version number
23 | 			// Could implement debug messages
24 | 		}
25 | 	}
26 | 
27 | 	// Sort by latest first
28 | 	versions.sort(std::greater<>());
29 | }
30 | 
31 | const Version& VersionParser::getLatest() const
32 | {
33 | 	if (versions.size() == 0)
34 | 		throw std::runtime_error("No elements in the list");
35 | 
36 | 	return *versions.cbegin();
37 | }
38 | 
39 | std::list<Version>::const_iterator VersionParser::cbegin() const
40 | {
41 | 	return versions.cbegin();
42 | }
43 | 
44 | std::list<Version>::const_iterator VersionParser::cend() const
45 | {
46 | 	return versions.cend();
47 | }
48 | 
49 | int VersionParser::size() const
50 | {
51 | 	return versions.size();
52 | }
53 | 


--------------------------------------------------------------------------------
/include/win32/task.h:
--------------------------------------------------------------------------------
 1 | #ifndef TASK_H
 2 | #define TASK_H
 3 | 
 4 | #include <Windows.h>
 5 | 
 6 | /**
 7 |  * @brief An imitation of the Android AsyncTask class
 8 |  * 
 9 |  * @tparam T The type of the argument passed to the task function
10 |  * @tparam E The type of the progress argument
11 |  * @tparam V The type of the result argument
12 | */
13 | template <typename T, typename E, typename V>
14 | class Task
15 | {
16 | public:
17 | 	Task() = default;
18 | 
19 | 	virtual void run(T* arg) final
20 | 	{
21 | 		pArg = arg;
22 | 		tHandle = CreateThread(
23 | 			NULL,
24 | 			0,
25 | 			&Task::threadFunction,
26 | 			this,
27 | 			0,
28 | 			&dwThreadId);
29 | 	}
30 | protected:
31 | 	virtual V doInBackground(T* arg) = 0;
32 | 	virtual void onProgressUpdate(E progress) {}
33 | 	virtual void onPostExecute(V result) {}
34 | 
35 | 	virtual void postProgress(E progress) final
36 | 	{
37 | 		onProgressUpdate(progress);
38 | 	}
39 | 
40 | 	DWORD dwThreadId;
41 | 	HANDLE tHandle;
42 | 
43 | private:
44 | 	T* pArg;
45 | 	static DWORD threadFunction(void* tParam)
46 | 	{
47 | 		Task* instance = reinterpret_cast<Task*>(tParam);
48 | 		V result = instance->doInBackground(instance->pArg);
49 | 		instance->onPostExecute(result);
50 | 
51 | 		return 0;
52 | 	}
53 | };
54 | 
55 | #endif


--------------------------------------------------------------------------------
/src/archive.cpp:
--------------------------------------------------------------------------------
 1 | #include "archive.h"
 2 | 
 3 | bool Archive::extractTar(fs::path from, std::string filename, fs::path to)
 4 | {
 5 | 	try
 6 | 	{
 7 | 		Tar tarfile(from.string());
 8 | 		if (!tarfile.extract(filename, to.string(), Archive::extractionProgress)) {
 9 | 			Logger::error("TAR: Error while extracting %s. Not in the archive", filename.c_str());
10 | 			return false;
11 | 		}
12 | 		printf("\n");
13 | 		return true;
14 | 	}
15 | 	catch (const std::exception& exc)
16 | 	{
17 | 		Logger::error("TAR: An error occurred while extracting %s. %s", from.string().c_str(), exc.what());
18 | 		return false;
19 | 	}
20 | }
21 | 
22 | bool Archive::extractZip(fs::path from, std::string filename, fs::path to)
23 | {
24 | 	try {
25 | 		Zip zip(from.string());
26 | 		if (!zip.extract(filename, to.string(), Archive::extractionProgress)) {
27 | 			Logger::error("ZIP: Error while extracting %s. Not in the archive", filename.c_str());
28 | 			return false;
29 | 		}
30 | 		printf("\n");
31 | 
32 | 		return true;
33 | 	}
34 | 	catch (const std::exception& exc) {
35 | 		Logger::error("ZIP: An error occurred while extracting %s. %s", from.string().c_str(), exc.what());
36 | 		return false;
37 | 	}
38 | }
39 | 
40 | void Archive::extractionProgress(float progress) {
41 | 	printf("Extraction progress: %.0f %%  \r", progress*100);
42 | 	fflush(stdout);
43 | }


--------------------------------------------------------------------------------
/include/win32/patchertask.h:
--------------------------------------------------------------------------------
 1 | #ifndef PATCHERTASK_H
 2 | #define PATCHERTASK_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <string>
 6 | #include <functional>
 7 | #include <chrono>
 8 | 
 9 | #include "win32/task.h"
10 | #include "win32/patchresult.h"
11 | #include "logging/streamlogstrategy.h"
12 | #include "logging/statusbarlogstrategy.h"
13 | #include "logging/combinedlogstrategy.h"
14 | #include "unlocker_win.h"
15 | 
16 | class MainWindow;
17 | 
18 | class PatcherTask : public Task<void, float, PatchResult>
19 | {
20 | public:
21 | 	PatcherTask(MainWindow& mainWindow);
22 | 	void setOnCompleteCallback(std::function<void(PatchResult)> completeCallback);
23 | 	void setOnProgressCallback(std::function<void(float)> progressCallback);
24 | protected:
25 | 	void onProgressUpdate(float progress) override;
26 | 	PatchResult doInBackground(void* arg) override;
27 | 	void onPostExecute(PatchResult result) override;
28 | private:
29 | 	static constexpr int PROG_PERIOD_MS = 200;
30 | 
31 | 	MainWindow& mainWindow;
32 | 
33 | 	std::function<void(PatchResult)> onCompleteCallback = nullptr;
34 | 	std::function<void(float)> onProgressCallback = nullptr;
35 | 
36 | 	std::chrono::milliseconds lastProgressUpdate = std::chrono::duration_cast<std::chrono::milliseconds>(
37 | 		std::chrono::system_clock::now().time_since_epoch()
38 | 		);
39 | 	double lastDlNow = 0.0;
40 | 
41 | 	void downloadProgress(double dltotal, double dlnow, double ultotal, double ulnow);
42 | };
43 | 
44 | #endif


--------------------------------------------------------------------------------
/include/win32/downloadtoolstask.h:
--------------------------------------------------------------------------------
 1 | #ifndef DOWNLOADTOOLSTASK_H
 2 | #define DOWNLOADTOOLSTASK_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <string>
 6 | #include <functional>
 7 | #include <chrono>
 8 | 
 9 | #include "win32/task.h"
10 | #include "win32/patchresult.h"
11 | #include "logging/streamlogstrategy.h"
12 | #include "logging/statusbarlogstrategy.h"
13 | #include "logging/combinedlogstrategy.h"
14 | #include "unlocker_win.h"
15 | 
16 | class MainWindow;
17 | 
18 | class DownloadToolsTask : public Task<void, float, PatchResult>
19 | {
20 | public:
21 | 	DownloadToolsTask(MainWindow& mainWindow);
22 | 	void setOnCompleteCallback(std::function<void(PatchResult)> completeCallback);
23 | 	void setOnProgressCallback(std::function<void(float)> progressCallback);
24 | protected:
25 | 	void onProgressUpdate(float progress) override;
26 | 	PatchResult doInBackground(void* arg) override;
27 | 	void onPostExecute(PatchResult result) override;
28 | private:
29 | 	static constexpr int PROG_PERIOD_MS = 200;
30 | 
31 | 	MainWindow& mainWindow;
32 | 
33 | 	std::function<void(PatchResult)> onCompleteCallback = nullptr;
34 | 	std::function<void(float)> onProgressCallback = nullptr;
35 | 
36 | 	void downloadProgress(double dltotal, double dlnow, double ultotal, double ulnow);
37 | 
38 | 	std::chrono::milliseconds lastProgressUpdate = std::chrono::duration_cast<std::chrono::milliseconds>(
39 | 		std::chrono::system_clock::now().time_since_epoch()
40 | 		);
41 | 	double lastDlNow = 0.0;
42 | };
43 | 
44 | #endif


--------------------------------------------------------------------------------
/src/patchversioner.cpp:
--------------------------------------------------------------------------------
 1 | #include "patchversioner.h"
 2 | 
 3 | PatchVersioner::PatchVersioner(const fs::path& installPath)
 4 | {
 5 | 	versionFile = (installPath / PATCH_VER_FILE).string();
 6 | 
 7 | 	FILE* vFile = fopen(versionFile.c_str(), "rb");
 8 | 
 9 | 	if (vFile != NULL)
10 | 	{
11 | 		vData = {};
12 | 
13 | 		fread(&vData, sizeof(patch_version_t), 1, vFile);
14 | 
15 | 		fclose(vFile);
16 | 
17 | 		haspatch = true;
18 | 	}
19 | }
20 | 
21 | time_t PatchVersioner::getPatchTime() const
22 | {
23 | 	time_t pTime;
24 | 	sscanf(vData.timestamp, "%lld", &pTime);
25 | 	return pTime;
26 | }
27 | 
28 | std::string PatchVersioner::getPatchVersion() const
29 | {
30 | 	return std::string(vData.version);
31 | }
32 | 
33 | void PatchVersioner::writePatchData()
34 | {
35 | 	FILE* vFile = fopen(versionFile.c_str(), "wb");
36 | 
37 | 	if (vFile == NULL)
38 | 	{
39 | 		throw PatchVersionerException("Can't open version file for writing at: " + versionFile);
40 | 	}
41 | 
42 | 	time_t pTime = time(NULL);
43 | 
44 | 	vData = {};
45 | 	sprintf(vData.timestamp, "%lld", pTime);
46 | 	strcpy(vData.version, PROG_VERSION);
47 | 
48 | 	fwrite(&vData, sizeof(patch_version_t), 1, vFile);
49 | 	fclose(vFile);
50 | 
51 | #ifdef _WIN32
52 | 	// Set file to hidden on Windows
53 | 	SetFileAttributes(versionFile.c_str(), FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY);
54 | #endif
55 | }
56 | 
57 | void PatchVersioner::removePatchVersion()
58 | {
59 | 	fs::remove(versionFile);
60 | }
61 | 
62 | bool PatchVersioner::hasPatch() const
63 | {
64 | 	return haspatch;
65 | }
66 | 


--------------------------------------------------------------------------------
/Unlocker.exe.manifest:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 |     <asmv1:assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"
 3 |      xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" 
 4 |      xmlns:asmv2="urn:schemas-microsoft-com:asm.v2" 
 5 |      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
 6 |         <assemblyIdentity version="1.0.0.0" name="paolo-projects.AutoUnlocker" />
 7 |         <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
 8 |             <security>
 9 |                 <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
10 |                     <requestedExecutionLevel level="requireAdministrator" 
11 |                      uiAccess="false" />
12 |                 </requestedPrivileges>
13 |                 <applicationRequestMinimum>
14 |                     <defaultAssemblyRequest permissionSetReference="Custom" />
15 |                     <PermissionSet class="System.Security.PermissionSet" 
16 |                      version="1" ID="Custom" SameSite="site" />
17 |                 </applicationRequestMinimum>
18 |             </security>
19 |         </trustInfo>
20 |         <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
21 |             <application>
22 |             </application>
23 |         </compatibility>
24 | 		<dependency>
25 | 			<dependentAssembly>
26 | 			    <assemblyIdentity
27 |                     type="win32"
28 |                     name="Microsoft.Windows.Common-Controls"
29 |                     version="6.0.0.0"
30 |                     processorArchitecture="amd64"
31 |                     publicKeyToken="6595b64144ccf1df"
32 |                     language="*" />
33 | 			</dependentAssembly>
34 | 		</dependency>
35 |     </asmv1:assembly>


--------------------------------------------------------------------------------
/include/network.h:
--------------------------------------------------------------------------------
 1 | #ifndef NETUTILS_H
 2 | #define NETUTILS_H
 3 | 
 4 | #include <curl/curl.h>
 5 | #include <fstream>
 6 | #include <sstream>
 7 | #include <string>
 8 | #include <iostream>
 9 | #include <iomanip>
10 | #include <algorithm>
11 | #include <chrono>
12 | #include <functional>
13 | #include "debug.h"
14 | 
15 | #define CURL_DEBUG false
16 | 
17 | class NetworkException : public std::runtime_error
18 | {
19 | public:
20 | 	NetworkException(const char* message, CURLcode code) : std::runtime_error(message), code(code) {}
21 | 	NetworkException(const std::string& message, CURLcode code) : std::runtime_error(message), code(code) {}
22 | 	CURLcode getCode() const { return code; }
23 | private:
24 | 	CURLcode code;
25 | };
26 | 
27 | struct NetworkProgress {
28 | 	double mBytesDownloadedLastTime = 0.0;
29 | 	long long lastProgressUpdateTime = 0;
30 | };
31 | 
32 | class Network
33 | {
34 | public:
35 | 	Network();
36 | 	~Network();
37 | 	void setProgressCallback(std::function<void(double, double, double, double)> progressCallback);
38 | 	void curlDownload(const std::string& url, const std::string& fileName);
39 | 	std::string curlGet(const std::string& url);
40 | private:
41 | 	static constexpr double mBytesProgressUpdateDelta = 0.1; // 0.1 MB
42 | 	static constexpr long long updatePeriodMs = 200; // update every 100ms
43 | 
44 | 	std::function<void(double, double, double, double)> progressCallback = nullptr;
45 | 
46 | 	NetworkProgress networkProgress = {};
47 | 	static size_t write_data_file(char* ptr, size_t size, size_t nmemb, void* stream);
48 | 	static int progress_callback(void* clientp, double dltotal, double dlnow, double ultotal, double ulnow);
49 | 	static int progress_callback_external(void* clientp, double dltotal, double dlnow, double ultotal, double ulnow);
50 | };
51 | 
52 | #endif // NETUTILS_H
53 | 


--------------------------------------------------------------------------------
/tests/test_tar.cpp:
--------------------------------------------------------------------------------
 1 | #include "tar.h"
 2 | #include "test.h"
 3 | 
 4 | void tar_extraction();
 5 | void testTarSearch();
 6 | 
 7 | int main(int argc, char** argv) {
 8 | 	test_info("Running TEST: Tar Extraction");
 9 | 
10 | 	tar_extraction();
11 | 	//testTarSearch();
12 | 
13 | #ifdef WIN32
14 | 	system("pause");
15 | #endif
16 | 	return 0;
17 | }
18 | 
19 | void tar_extraction() {
20 | 	BEGIN_TEST("Testing TAR Extraction");
21 | 
22 | 	test_status("CWD is: %s", getCwd().c_str());
23 | 
24 | 	if(!fileExists("./test.tar"))
25 | 	{
26 | 		TEST_ERROR("File test.tar does not exist in current directory");
27 | 	}
28 | 
29 | 	try {
30 | 		Tar testTar("./test.tar");
31 | 
32 | 		ASSERT_TRUE(testTar.contains("test.file"));
33 | 
34 | 		printf("\n");
35 | 		testTar.extract("test.file", "./test.file", updateProgress);
36 | 		printf("\n");
37 | 
38 | 		remove("./test.file");
39 | 
40 | 		TEST_SUCCESS();
41 | 	}
42 | 	catch (const std::exception& exc) {
43 | 		TEST_ERROR(exc.what());
44 | 	}
45 | }
46 | 
47 | void testTarSearch()
48 | {
49 | 	try {
50 | 		Tar testTar("./test.tar");
51 | 
52 | 		BEGIN_TEST("Testing Tar Search: test.file");
53 | 		auto res = testTar.search("test.file");
54 | 
55 | 		bool found = false;
56 | 		for (const Tar::File& f : res) {
57 | 			if (f.name == "test.file") {
58 | 				found = true;
59 | 				break;
60 | 			}
61 | 		}
62 | 		ASSERT_TRUE(res.size() == 1);
63 | 		ASSERT_TRUE(found);
64 | 		TEST_SUCCESS();
65 | 
66 | 		BEGIN_TEST("Testing Tar Search: fff");
67 | 		auto res2 = testTar.search("fff");
68 | 		found = false;
69 | 		for (const Tar::File& f : res2) {
70 | 			if (f.name == "test/fff.txt") {
71 | 				found = true;
72 | 				break;
73 | 			}
74 | 		}
75 | 		ASSERT_TRUE(res2.size() == 1);
76 | 		ASSERT_TRUE(found);
77 | 
78 | 		TEST_SUCCESS();
79 | 	}
80 | 	catch (const std::exception& exc) {
81 | 		TEST_ERROR(exc.what());
82 | 	}
83 | }


--------------------------------------------------------------------------------
/src/ziparchive.cpp:
--------------------------------------------------------------------------------
 1 | #include "ziparchive.h"
 2 | 
 3 | Zip::Zip(const std::string& zipFile)
 4 | {
 5 | 	// Open the zip file
 6 | 	const char* from_c = zipFile.c_str();
 7 | 	int zerr = ZIP_ER_OK;
 8 | 	zip_archive = zip_open(from_c, ZIP_RDONLY, &zerr);
 9 | 
10 | 	if (zerr != ZIP_ER_OK) {
11 | 		throw ZipException("Error while opening " + zipFile);
12 | 	}
13 | }
14 | 
15 | Zip::~Zip()
16 | {
17 | 	if (zip_archive != nullptr) {
18 | 		zip_close(zip_archive);
19 | 		zip_archive = nullptr;
20 | 	}
21 | }
22 | 
23 | bool Zip::extract(const std::string& fileName, const std::string& to, void(*progressCallback)(float))
24 | {
25 | 	const char* fileName_c = fileName.c_str(), * to_c = to.c_str();
26 | 
27 | 	// Get the size of the file to extract
28 | 	zip_stat_t target_file_stat;
29 | 	zip_stat_init(&target_file_stat);
30 | 	int res = zip_stat(zip_archive, fileName_c, 0, &target_file_stat);
31 | 
32 | 	if (res != 0)
33 | 	{
34 | 		return false;
35 | 	}
36 | 
37 | 	size_t target_fsize = target_file_stat.size;
38 | 
39 | 	// Open the file to extract
40 | 	zip_file_t* target_file = zip_fopen(zip_archive, fileName_c, 0);
41 | 
42 | 	if (target_file == NULL) {
43 | 		return false;
44 | 	}
45 | 
46 | 	// Open the output file
47 | 	FILE* out_f = fopen(to_c, "wb");
48 | 
49 | 	if (out_f == NULL) {
50 | 		throw ZipException("Can't open the file " + to + " for writing");
51 | 	}
52 | 
53 | 	size_t elapsed = 0;
54 | 
55 | 	// Extract the file, printing the progress through the function
56 | 	std::array<char, AR_BUFFER_SIZE> buffer;
57 | 	size_t sz = 0;
58 | 	while ((sz = zip_fread(target_file, buffer.data(), AR_BUFFER_SIZE)) > 0) {
59 | 		fwrite(buffer.data(), sizeof(char), sz, out_f);
60 | 		elapsed += sz;
61 | 		if (progressCallback != nullptr) {
62 | 			progressCallback(static_cast<float>(elapsed) / target_fsize);
63 | 		}
64 | 	}
65 | 
66 | 	fclose(out_f);
67 | 
68 | 	zip_fclose(target_file);
69 | 
70 | 	return true;
71 | }
72 | 


--------------------------------------------------------------------------------
/src/installinfo.cpp:
--------------------------------------------------------------------------------
 1 | #include "installinfo.h"
 2 | 
 3 | #ifdef _WIN32
 4 | #include "Windows.h"
 5 | #endif
 6 | 
 7 | VMWareInfoRetriever::VMWareInfoRetriever()
 8 | {
 9 | #ifdef _WIN32
10 | 	char regBuf[MAX_PATH];
11 | 	memset(regBuf, 0, MAX_PATH);
12 | 
13 | 	DWORD regSize = MAX_PATH;
14 | 	DWORD regType = 0;
15 | 
16 | 	HKEY hResult;
17 | 	LONG res = RegOpenKeyEx(HKEY_VMWARE, HKEY_SUBKEY_VMWARE, 0, KEY_QUERY_VALUE, &hResult);
18 | 
19 | 	if (res != ERROR_SUCCESS)
20 | 	{
21 | 		throw VMWareInfoException("Couldn't open VMWare registry key. Make sure VMWare is correctly installed");
22 | 	}
23 | 
24 | 	res = RegQueryValueEx(hResult, HKEY_QUERY_VALUE_INSTALLPATH, NULL, &regType, (LPBYTE)regBuf, &regSize);
25 | 
26 | 	if (res != ERROR_SUCCESS)
27 | 	{
28 | 		RegCloseKey(hResult);
29 | 		throw VMWareInfoException("Couldn't read VMWare InstallPath registry value. Make sure VMWare is correctly installed");
30 | 	}
31 | 
32 | 	installPath = std::string(reinterpret_cast<char*>(regBuf));
33 | 
34 | 	memset(regBuf, 0, MAX_PATH);
35 | 	regSize = MAX_PATH;
36 | 	res = RegQueryValueEx(hResult, HKEY_QUERY_VALUE_INSTALLPATH64, NULL, &regType, (LPBYTE)regBuf, &regSize);
37 | 
38 | 	if (res != ERROR_SUCCESS)
39 | 	{
40 | 		RegCloseKey(hResult);
41 | 		throw VMWareInfoException("Couldn't read VMWare InstallPath64 registry value. Make sure VMWare is correctly installed");
42 | 	}
43 | 
44 | 	installPath64 = std::string(regBuf);
45 | 
46 | 	memset(regBuf, 0, MAX_PATH);
47 | 	regSize = MAX_PATH;
48 | 	res = RegQueryValueEx(hResult, HKEY_QUERY_VALUE_PRODUCTVERSION, NULL, &regType, (LPBYTE)regBuf, &regSize);
49 | 
50 | 	if (res != ERROR_SUCCESS)
51 | 	{
52 | 		RegCloseKey(hResult);
53 | 		throw VMWareInfoException("Couldn't read VMWare ProductVersion registry value. Make sure VMWare is correctly installed");
54 | 	}
55 | 
56 | 	prodVersion = std::string(regBuf);
57 | 	
58 | 	RegCloseKey(hResult);
59 | #endif
60 | }
61 | 
62 | std::string VMWareInfoRetriever::getInstallPath()
63 | {
64 | 	return installPath;
65 | }
66 | 
67 | std::string VMWareInfoRetriever::getInstallPath64()
68 | {
69 | 	return installPath64;
70 | }
71 | 
72 | std::string VMWareInfoRetriever::getProductVersion()
73 | {
74 | 	return prodVersion;
75 | }
76 | 


--------------------------------------------------------------------------------
/tests/test.h:
--------------------------------------------------------------------------------
 1 | #ifndef TEST_H
 2 | #define TEST_H
 3 | 
 4 | #include <stdarg.h>
 5 | #include <stdio.h>
 6 | #include <cstring>
 7 | #include <string>
 8 | #include "colors.h"
 9 | 
10 | #include <sys/stat.h>
11 | #ifdef WIN32
12 | #include <Windows.h>
13 | #elif defined(__linux__)
14 | #include <unistd.h>
15 | #include <stdarg.h>
16 | #endif
17 | 
18 | void test_info(const char* message, ...) {
19 | 	va_list argp;
20 | 	va_start(argp, message);
21 | 	char msg[512] = ANSI_COLOR_BLUE;
22 | 	strcat(msg, message);
23 | 	strcat(msg, ANSI_COLOR_RESET "\n");
24 | 	vprintf(msg, argp);
25 | 	va_end(argp);
26 | }
27 | 
28 | void test_status(const char* message, ...) {
29 | 	va_list argp;
30 | 	va_start(argp, message);
31 | 	char msg[512] = ANSI_COLOR_YELLOW;
32 | 	strcat(msg, message);
33 | 	strcat(msg, ANSI_COLOR_RESET "\n");
34 | 	vprintf(msg, argp);
35 | 	va_end(argp);
36 | }
37 | 
38 | void test_error(const char* message, ...) {
39 | 	va_list argp;
40 | 	va_start(argp, message);
41 | 	char msg[512] = ANSI_COLOR_RED;
42 | 	strcat(msg, message);
43 | 	strcat(msg, ANSI_COLOR_RESET "\n");
44 | 	vprintf(msg, argp);
45 | 	va_end(argp);
46 | }
47 | 
48 | void test_success(const char* message, ...) {
49 | 	va_list argp;
50 | 	va_start(argp, message);
51 | 	char msg[512] = ANSI_COLOR_GREEN;
52 | 	strcat(msg, message);
53 | 	strcat(msg, ANSI_COLOR_RESET "\n");
54 | 	vprintf(msg, argp);
55 | 	va_end(argp);
56 | }
57 | 
58 | void updateProgress(float progress)
59 | {
60 | 	printf("Status: %.0f %%  \r", progress * 100);
61 | }
62 | 
63 | bool fileExists(const std::string& file)
64 | {
65 | #ifdef WIN32
66 | 	DWORD dwAttrib = GetFileAttributesA(file.c_str());
67 | 	return dwAttrib != INVALID_FILE_ATTRIBUTES;
68 | #elif defined(__linux__)
69 | 	return access("./test.tar", F_OK) == 0;
70 | #endif
71 | }
72 | 
73 | std::string getCwd()
74 | {
75 | 	char cwd[1024] = {};
76 | #ifdef WIN32
77 | 	GetCurrentDirectoryA(1024, cwd);
78 | #elif defined(__linux__)
79 | 	getcwd(cwd, 1024);
80 | #endif
81 | 	return std::string(cwd);
82 | }
83 | 
84 | #define TEST_ERROR(reason) test_error("Test failed: %s", reason); exit(1)
85 | #define TEST_SUCCESS() test_success("Test succeeded")
86 | 
87 | #define BEGIN_TEST(what) test_status("Testing: %s", what)
88 | #define ASSERT_TRUE(condition) if(!(condition)) { test_error("Test failed at condition: %s", #condition); exit(1); }
89 | 
90 | #endif // TEST_H


--------------------------------------------------------------------------------
/src/debug.cpp:
--------------------------------------------------------------------------------
  1 | #include "debug.h"
  2 | 
  3 | Logger* Logger::instance = nullptr;
  4 | 
  5 | void Logger::init(LogStrategy* strategy)
  6 | {
  7 | 	Logger::instance = new Logger(strategy);
  8 | }
  9 | 
 10 | void Logger::free()
 11 | {
 12 | 	delete Logger::instance;
 13 | }
 14 | 
 15 | void Logger::verbose(std::string msg)
 16 | {
 17 | #if LOGLEVEL >= LOGLEVEL_VERBOSE
 18 | 	Logger::instance->logStrategy->verbose(msg.c_str());
 19 | #endif
 20 | }
 21 | void Logger::verbose(const char* msg, ...)
 22 | {
 23 | #if LOGLEVEL >= LOGLEVEL_VERBOSE
 24 | 	va_list args;
 25 | 	va_start(args, msg);
 26 | 	char fmt[1024];
 27 | 	vsprintf(fmt, msg, args);
 28 | 
 29 | 	Logger::instance->logStrategy->verbose(fmt);
 30 | 
 31 | 	va_end(args);
 32 | #endif
 33 | }
 34 | 
 35 | void Logger::debug(std::string msg)
 36 | {
 37 | #if LOGLEVEL > LOGLEVEL_DEBUG
 38 | 	Logger::instance->logStrategy->debug(msg.c_str());
 39 | #endif
 40 | }
 41 | void Logger::debug(const char* msg, ...)
 42 | {
 43 | #if LOGLEVEL > LOGLEVEL_DEBUG
 44 | 	va_list args;
 45 | 	va_start(args, msg);
 46 | 	char fmt[1024];
 47 | 	vsprintf(fmt, msg, args);
 48 | 	
 49 | 	Logger::instance->logStrategy->debug(fmt);
 50 | 
 51 | 	va_end(args);
 52 | #endif
 53 | }
 54 | 
 55 | void Logger::info(std::string msg)
 56 | {
 57 | #if LOGLEVEL >= LOGLEVEL_INFO
 58 | 	Logger::instance->logStrategy->info(msg.c_str());
 59 | #endif
 60 | }
 61 | void Logger::info(const char* msg, ...)
 62 | {
 63 | #if LOGLEVEL >= LOGLEVEL_INFO
 64 | 	va_list args;
 65 | 	va_start(args, msg);
 66 | 	char fmt[1024];
 67 | 	vsprintf(fmt, msg, args);
 68 | 
 69 | 	Logger::instance->logStrategy->info(fmt);
 70 | 
 71 | 	va_end(args);
 72 | #endif
 73 | }
 74 | 
 75 | void Logger::error(std::string err)
 76 | {
 77 | 	Logger::instance->logStrategy->error(err.c_str());
 78 | }
 79 | void Logger::error(const char* msg, ...)
 80 | {
 81 | 	va_list args;
 82 | 	va_start(args, msg);
 83 | 	char fmt[1024];
 84 | 	vsprintf(fmt, msg, args);
 85 | 
 86 | 	Logger::instance->logStrategy->error(fmt);
 87 | 
 88 | 	va_end(args);
 89 | }
 90 | 
 91 | #ifdef _WIN32
 92 | void Logger::printWinDebug(const char* fmt, ...)
 93 | {
 94 | 	char message[2048];
 95 | 	va_list args;
 96 | 	va_start(args, fmt);
 97 | 	vsprintf(message, fmt, args);
 98 | 	va_end(args);
 99 | 
100 | 	OutputDebugStringA(message);
101 | }
102 | #endif
103 | 
104 | Logger::Logger(LogStrategy* strategy)
105 | 	: logStrategy(strategy)
106 | {
107 | 
108 | }
109 | 


--------------------------------------------------------------------------------
/src/win32/controls/window.cpp:
--------------------------------------------------------------------------------
  1 | #include "..\..\..\include\win32\controls\window.h"
  2 | 
  3 | Window::Window(HINSTANCE hInstance, int nCmdShow, const std::string& className, const std::string& title, int x, int y, int width, int height)
  4 | 	: hInstance(hInstance), nCmdShow(nCmdShow), className(className), x(x), y(y), width(width), height(height), title(title)
  5 | {
  6 | 	hWnd = NULL;
  7 | 	parentHwnd = NULL;
  8 | }
  9 | 
 10 | Window::~Window()
 11 | {
 12 | }
 13 | 
 14 | LRESULT Window::WindowProc(HWND hWnd, UINT uMSG, WPARAM wParam, LPARAM lParam)
 15 | {
 16 | 	Window* window = reinterpret_cast<Window*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
 17 | 
 18 | 	switch (uMSG)
 19 | 	{
 20 | 	case WM_NCCREATE:
 21 | 		SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)((CREATESTRUCT*)lParam)->lpCreateParams);
 22 | 		break;
 23 | 
 24 | 	case WM_DESTROY:
 25 | 		PostQuitMessage(0);
 26 | 		break;
 27 | 
 28 | 	case WM_CREATE:
 29 | 		window->onCreate(hWnd);
 30 | 		break;
 31 | 
 32 | 	/*case WM_PAINT:
 33 | 	{
 34 | 		PAINTSTRUCT ps;
 35 | 		HDC hdc = BeginPaint(hWnd, &ps);
 36 | 
 37 | 		FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_BTNFACE + 1));
 38 | 		EndPaint(hWnd, &ps);
 39 | 		break;
 40 | 	}*/
 41 | 	case WM_COMMAND:
 42 | 		switch (HIWORD(wParam)) {
 43 | 		case BN_CLICKED:
 44 | 			Logger::printWinDebug("Button click ID: %d\n", LOWORD(wParam));
 45 | 			for (const auto& val : window->controls) 
 46 | 			{
 47 | 				if (val.first == LOWORD(wParam) && val.second != nullptr) {
 48 | 					val.second->triggerEvent(EventType::CLICK_EVENT);
 49 | 					break;
 50 | 				}
 51 | 			}
 52 | 			break;
 53 | 		}
 54 | 		break;
 55 | 	}
 56 | 
 57 | 	return DefWindowProc(hWnd, uMSG, wParam, lParam);
 58 | }
 59 | 
 60 | void Window::show()
 61 | {
 62 | 	WNDCLASS wc = {};
 63 | 
 64 | 	wc.lpfnWndProc = Window::WindowProc;
 65 | 	wc.hInstance = hInstance;
 66 | 	wc.lpszClassName = className.c_str();
 67 | 	wc.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
 68 | 	wc.hCursor = LoadCursor(0, IDC_ARROW);
 69 | 
 70 | 	RegisterClass(&wc);
 71 | 
 72 | 	hWnd = CreateWindowEx(
 73 | 		0,
 74 | 		className.c_str(),
 75 | 		this->title.c_str(),
 76 | 		WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
 77 | 		x, y, width, height,
 78 | 		NULL,
 79 | 		NULL,
 80 | 		hInstance,
 81 | 		this
 82 | 	);
 83 | 
 84 | 	if (hWnd == NULL)
 85 | 	{
 86 | 		throw std::runtime_error("Couldn't initialize main window");
 87 | 	}
 88 | 
 89 | 	ShowWindow(hWnd, nCmdShow);
 90 | 
 91 | 	messageLoop();
 92 | }
 93 | 
 94 | void Window::registerControl(int menuId, Control* control)
 95 | {
 96 | 	controls[menuId] = control;
 97 | }
 98 | 
 99 | void Window::messageLoop()
100 | {
101 | 	MSG msg = {};
102 | 	while (GetMessage(&msg, NULL, 0, 0))
103 | 	{
104 | 		TranslateMessage(&msg);
105 | 		DispatchMessage(&msg);
106 | 	}
107 | }
108 | 


--------------------------------------------------------------------------------
/include/filesystem.hpp:
--------------------------------------------------------------------------------
 1 | // We haven't checked which filesystem to include yet
 2 | #ifndef INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
 3 | 
 4 | // Check for feature test macro for <filesystem>
 5 | #   if defined(__cpp_lib_filesystem)
 6 | #       define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 0
 7 | 
 8 | // Check for feature test macro for <experimental/filesystem>
 9 | #   elif defined(__cpp_lib_experimental_filesystem)
10 | #       define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
11 | 
12 | // We can't check if headers exist...
13 | // Let's assume experimental to be safe
14 | #   elif !defined(__has_include)
15 | #       define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
16 | 
17 | // Check if the header "<filesystem>" exists
18 | #   elif __has_include(<filesystem>)
19 | 
20 | // If we're compiling on Visual Studio and are not compiling with C++17, we need to use experimental
21 | #       ifdef _MSC_VER
22 | 
23 | // Check and include header that defines "_HAS_CXX17"
24 | #           if __has_include(<yvals_core.h>)
25 | #               include <yvals_core.h>
26 | 
27 | // Check for enabled C++17 support
28 | #               if defined(_HAS_CXX17) && _HAS_CXX17
29 | // We're using C++17, so let's use the normal version
30 | #                   define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 0
31 | #               endif
32 | #           endif
33 | 
34 | // If the marco isn't defined yet, that means any of the other VS specific checks failed, so we need to use experimental
35 | #           ifndef INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
36 | #               define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
37 | #           endif
38 | 
39 | // Not on Visual Studio. Let's use the normal version
40 | #       else // #ifdef _MSC_VER
41 | #           define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 0
42 | #       endif
43 | 
44 | // Check if the header "<filesystem>" exists
45 | #   elif __has_include(<experimental/filesystem>)
46 | #       define INCLUDE_STD_FILESYSTEM_EXPERIMENTAL 1
47 | 
48 | // Fail if neither header is available with a nice error message
49 | #   else
50 | #       error Could not find system header "<filesystem>" or "<experimental/filesystem>"
51 | #   endif
52 | 
53 | // We priously determined that we need the exprimental version
54 | #   if INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
55 | // Include it
56 | #       include <experimental/filesystem>
57 | 
58 | // We need the alias from std::experimental::filesystem to std::filesystem
59 | //namespace std {
60 | //    namespace filesystem = experimental::filesystem;
61 | //}
62 | 
63 | namespace fs = std::experimental::filesystem;
64 | 
65 | // We have a decent compiler and can use the normal version
66 | #   else
67 | // Include it
68 | #       include <filesystem>
69 | 	namespace fs = std::filesystem;
70 | 
71 | #   endif
72 | 
73 | #endif // #ifndef INCLUDE_STD_FILESYSTEM_EXPERIMENTAL
74 | 


--------------------------------------------------------------------------------
/include/win32/mainwindow.h:
--------------------------------------------------------------------------------
 1 | #ifndef MAINWINDOW_H
 2 | #define MAINWINDOW_H
 3 | 
 4 | #include <Windows.h>
 5 | #include <ShlObj.h>
 6 | #include <Shlwapi.h>
 7 | #include <stdexcept>
 8 | #include <memory>
 9 | #include <functional>
10 | #include "filesystem.hpp"
11 | 
12 | #include "config.h"
13 | #include "controls/button.h";
14 | #include "controls/editbox.h"
15 | #include "controls/label.h"
16 | #include "controls/window.h"
17 | #include "controls/progress.h"
18 | #include "controls/groupbox.h"
19 | #include "controls/checkbox.h"
20 | #include "controls/statusbar.h"
21 | #include "patchertask.h"
22 | #include "unpatchertask.h"
23 | #include "downloadtoolstask.h"
24 | #include "resources.h"
25 | 
26 | #include "installinfo.h"
27 | #include "unlocker_win.h"
28 | 
29 | struct DialogState
30 | {
31 | 	bool pathEnabled,
32 | 		path64Enabled,
33 | 		pathBrowseEnabled,
34 | 		path64BrowseEnabled,
35 | 		downloadToolsEnabled,
36 | 		downloadToolsChecked,
37 | 		toolsPathEnabled,
38 | 		toolsBrowseEnabled,
39 | 		downloadToolsBtnEnabled,
40 | 		patchEnabled,
41 | 		unpatchEnabled;
42 | };
43 | 
44 | class MainWindow : public Window
45 | {
46 | public:
47 | 	MainWindow(HINSTANCE hInstance, int nCmdShow);
48 | 	~MainWindow();
49 | 	virtual void onCreate(HWND hWnd) override;
50 | 
51 | 	std::unique_ptr<Label> browseLabel = nullptr;
52 | 	std::unique_ptr<Button> browseButton = nullptr;
53 | 	std::unique_ptr<EditBox> pathEditBox = nullptr;
54 | 	std::unique_ptr<Label> browseLabelX64 = nullptr;
55 | 	std::unique_ptr<Button> browseButtonX64 = nullptr;
56 | 	std::unique_ptr<EditBox> pathEditBoxX64 = nullptr;
57 | 	std::unique_ptr<Progress> progressBar = nullptr;
58 | 	std::unique_ptr<GroupBox> toolsGroup = nullptr;
59 | 	std::unique_ptr<CheckBox> downloadToolsChk = nullptr;
60 | 	std::unique_ptr<Label> toolsPathLabel = nullptr;
61 | 	std::unique_ptr<EditBox> toolsPathEditBox = nullptr;
62 | 	std::unique_ptr<Button> toolsBrowseBtn = nullptr;
63 | 	std::unique_ptr<Button> patchBtn = nullptr;
64 | 	std::unique_ptr<Button> revertPatchBtn = nullptr;
65 | 	std::unique_ptr<StatusBar> statusBar = nullptr;
66 | 	std::unique_ptr<Button> downloadToolsBtn = nullptr;
67 | 
68 | private:
69 | 	void browseButtonClick();
70 | 	void browseX64ButtonClick();
71 | 	void toolsBrowseButtonClick();
72 | 	void downloadToolsChkClick();
73 | 	void patchBtnClick();
74 | 	void revertPatchBtnClick();
75 | 	void downloadToolsBtnClick();
76 | 
77 | 	void disableAllInput();
78 | 	void restoreInput();
79 | 	void patchComplete(PatchResult result);
80 | 	void unpatchComplete(PatchResult result);
81 | 	void toolsDownloadComplete(PatchResult result);
82 | 	void patchProgress(float progress);
83 | 
84 | 	PatcherTask* patcherTask = nullptr;
85 | 	UnpatcherTask* unpatcherTask = nullptr;
86 | 	DownloadToolsTask* downloadToolsTask = nullptr;
87 | 
88 | 	DialogState dlgState;
89 | };
90 | 
91 | #endif // MAINWINDOW_H


--------------------------------------------------------------------------------
/include/patcher.h:
--------------------------------------------------------------------------------
 1 | #ifndef PATCHUTILS_H
 2 | #define PATCHUTILS_H
 3 | 
 4 | #include "filesystem.hpp"
 5 | #include <fstream>
 6 | #include <optional>
 7 | #include <sstream>
 8 | #include <regex>
 9 | #include <iomanip>
10 | #include <cstdarg>
11 | #include <array>
12 | #include <cstring>
13 | 
14 | #include "debug.h"
15 | #include "config.h"
16 | 
17 | class PatchException : public std::runtime_error
18 | {
19 | public:
20 | 	PatchException(const char* message)
21 | 		: std::runtime_error(message)
22 | 	{}
23 | 	PatchException(const std::string& message)
24 | 		: std::runtime_error(message)
25 | 	{}
26 | };
27 | 
28 | struct LLQQQQLLQQ // couldn't find a better name LOL
29 | {
30 | 	unsigned long l1;
31 | 	unsigned long l2;
32 | 	unsigned long long q1;
33 | 	unsigned long long q2;
34 | 	unsigned long long q3;
35 | 	unsigned long long q4;
36 | 	unsigned long l3;
37 | 	unsigned long l4;
38 | 	unsigned long long q5;
39 | 	unsigned long long q6;
40 | };
41 | 
42 | struct QQq // it's starting to feel awkward
43 | {
44 | 	unsigned long long Q1, Q2;
45 | 	long long q3;
46 | };
47 | 
48 | struct smc_key_struct
49 | {
50 | 	char s0[4];
51 | 	unsigned char B1;
52 | 	char s2[4];
53 | 	unsigned char B3;
54 | 	unsigned char padding[6];
55 | 	unsigned long long Q4;
56 | };
57 | 
58 | class Patcher {
59 | public:
60 | 	// Utils
61 | 	static std::string rot13(const std::string& in);
62 | 	static std::string hexRepresentation(long long bin);
63 | 	static std::vector<char> makeVector(const char* arr, size_t size);
64 | 	static std::string hexRepresentation(std::vector<char> bin);
65 | 	static std::string hexRepresentation(std::string bin);
66 | 	static std::optional<unsigned long long> searchForOffset(const std::vector<char>& memstream, const std::vector<char>& sequence, unsigned long long from = 0);
67 | 	static std::optional<unsigned long long> searchForLastOffset(const std::vector<char>& memstream, const std::vector<char>& sequence);
68 | 	static std::optional<unsigned long long> searchForOffset(std::fstream& stream, const std::vector<char>& sequence, unsigned long long from = 0);
69 | 	static std::optional<unsigned long long> searchForLastOffset(std::fstream& stream, const std::vector<char>& sequence);
70 | 	static std::vector<char> readFile(std::fstream& stream);
71 | 	static bool cmpcarr(const char* c1, const char* c2, size_t len);
72 | 	static void printkey(int i, unsigned long long offset, const smc_key_struct& smc_key, const std::vector<char>& smc_data);
73 | 
74 | 	// Core functions
75 | 	static void patchSMC(fs::path name, bool isSharedObj);
76 | 	static std::pair<unsigned long long, unsigned long long> patchKeys(std::fstream& file, long long key);
77 | 	static void patchBase(fs::path name);
78 | 	static void patchVmkctl(fs::path name);
79 | 	static void patchElf(std::fstream& file, long long oldoffset, long long newoffset);
80 | };
81 | 
82 | #endif // PATCHUTILS_H
83 | 


--------------------------------------------------------------------------------
/include/tar.h:
--------------------------------------------------------------------------------
 1 | #ifndef TAR_H
 2 | #define TAR_H
 3 | 
 4 | #include <string>
 5 | #include <vector>
 6 | #include <array>
 7 | #include <stdexcept>
 8 | #include <cmath>
 9 | #include <algorithm>
10 | #include <iterator>
11 | #include <functional>
12 | 
13 | #ifdef WIN32
14 | #define fseek_e64(f, p, t) _fseeki64(f, p, t);
15 | #else
16 | #define fseek_e64(f, p, t) fseeko(f, p, t);
17 | #endif
18 | 
19 | constexpr int TAR_BLOCK_SZ = 512;
20 | 
21 | enum tar_type_flag {
22 | 	REGTYPE = '0',		/* regular file */
23 | 	AREGTYPE = '\0',	/* regular file */
24 | 	LNKTYPE = '1',		/* link */
25 | 	SYMTYPE = '2',		/* reserved */
26 | 	CHRTYPE = '3',		/* character special */
27 | 	BLKTYPE = '4',		/* block special */
28 | 	DIRTYPE = '5',		/* directory */
29 | 	FIFOTYPE = '6',		/* FIFO special */
30 | 	CONTTYPE = '7',		/* reserved */
31 | 	XHDTYPE = 'x',		/* Extended header referring to the next file in the archive */
32 | 	XGLTYPE = 'g'		/* Global extended header */
33 | };
34 | 
35 | struct tar_posix_header
36 | {                              /* byte offset */
37 | 	char name[100];               /*   0 */
38 | 	char mode[8];                 /* 100 */
39 | 	char uid[8];                  /* 108 */
40 | 	char gid[8];                  /* 116 */
41 | 	char size[12];                /* 124 */
42 | 	char mtime[12];               /* 136 */
43 | 	char chksum[8];               /* 148 */
44 | 	char typeflag;                /* 156 */
45 | 	char linkname[100];           /* 157 */
46 | 	char magic[6];                /* 257 */
47 | 	char version[2];              /* 263 */
48 | 	char uname[32];               /* 265 */
49 | 	char gname[32];               /* 297 */
50 | 	char devmajor[8];             /* 329 */
51 | 	char devminor[8];             /* 337 */
52 | 	char prefix[155];             /* 345 */
53 | 	char pad[12];				  /* 500 */
54 | 								  /* 512 */
55 | };
56 | 
57 | class TarException : public std::runtime_error {
58 | public:
59 | 	TarException(const char* message) : std::runtime_error(message) {}
60 | 	TarException(const std::string& message) : std::runtime_error(message) {}
61 | };
62 | 
63 | class Tar
64 | {
65 | public:
66 | 
67 | 	struct File
68 | 	{
69 | 		std::string name;
70 | 		int mode;
71 | 		int ownerId;
72 | 		int groupId;
73 | 		size_t size;
74 | 		int lastModified;
75 | 		tar_type_flag typeflag;
76 | 		std::string linkedName;
77 | 		size_t position;
78 | 	};
79 | 
80 | 	Tar(std::string filename);
81 | 	~Tar();
82 | 	void extract(const File& file, std::string to, void(*progressCallback)(float) = nullptr);
83 | 	bool extract(std::string fileName, std::string to, void(*progressCallback)(float) = nullptr);
84 | 	const std::vector<File>& getFileList() const;
85 | 	bool contains(std::string fileName) const;
86 | 	std::vector<File> search(const std::string& term);
87 | private:
88 | 	void(*progressCallback)(float) = nullptr;
89 | 	FILE* tarfile = NULL;
90 | 	std::vector<File> fileList;
91 | 
92 | 	int octToInt(char* oct);
93 | 	size_t octToSz(char* oct);
94 | 
95 | 	static constexpr size_t EXTRACT_BUFFER_SZ = 1024 * 16;
96 | };
97 | 
98 | #endif // TAR_H


--------------------------------------------------------------------------------
/src/toolsdownloader.cpp:
--------------------------------------------------------------------------------
 1 | #include "toolsdownloader.h"
 2 | 
 3 | ToolsDownloader::ToolsDownloader(Network& network)
 4 | 	: network(network)
 5 | {
 6 | }
 7 | 
 8 | bool ToolsDownloader::download(const fs::path& to)
 9 | {
10 | 	return downloadDirectly(to);
11 | }
12 | 
13 | bool ToolsDownloader::downloadDirectly(const fs::path& to) {
14 | 	fs::create_directory(to);
15 | 
16 | 	std::string darwin_out = (to / TOOLS_DARWIN_NAME).string();
17 | 	std::string darwin_pre15_out = (to / TOOLS_DARWIN_PRE15_NAME).string();
18 | 
19 | 	try
20 | 	{
21 | 		Logger::info(std::string("Downloading ") + TOOLS_DARWIN_NAME + " from " + TOOLS_DARWIN_URL + " into " + darwin_out);
22 | 
23 | 		network.curlDownload(TOOLS_DARWIN_URL, darwin_out);
24 | 
25 | 		Logger::info(std::string("Downloading ") + TOOLS_DARWIN_PRE15_NAME + " from " + TOOLS_DARWIN_PRE15_URL + " into " + darwin_pre15_out);
26 | 
27 | 		network.curlDownload(TOOLS_DARWIN_PRE15_URL, darwin_pre15_out);
28 | 	}
29 | 	catch (const NetworkException& exc) {
30 | 		throw std::runtime_error(std::string(exc.what()));
31 | 	}
32 | 
33 | 	return true;
34 | }
35 | 
36 | /*
37 | bool ToolsDownloader::downloadFromCore(const fs::path& to)
38 | {
39 | 	fs::path temppath = fs::temp_directory_path();
40 | 
41 | 	// No tools available, try getting them from core fusion file
42 | 	std::string coreurl = buildurl + FUSION_DEF_CORE_LOC;
43 | 	std::string core_diskpath = (temppath / FUSION_DEF_CORE_NAME).string();
44 | 
45 | 	Logger::debug("Downloading core tar from " + coreurl);
46 | 
47 | 	try
48 | 	{
49 | 		network.curlDownload(coreurl, core_diskpath);
50 | 
51 | 		// If the core package was successfully downloaded, extract the tools from it
52 | 		Logger::debug("Extracting from .tar to temp folder ...");
53 | 
54 | 		fs::path temppath = fs::temp_directory_path();
55 | 
56 | 		bool success = Archive::extractTar(temppath / FUSION_DEF_CORE_NAME, FUSION_DEF_CORE_NAME_ZIP, temppath / FUSION_DEF_CORE_NAME_ZIP);
57 | 		if (!success) {
58 | 			Logger::error("Couldn't extract from the tar file");
59 | 			// Error in the tar file, try the next version number
60 | 			return false;
61 | 		}
62 | 
63 | 		Logger::debug("Extracting from .zip to destination folder ...");
64 | 
65 | 		success = Archive::extractZip(temppath / FUSION_DEF_CORE_NAME_ZIP, FUSION_ZIP_TOOLS_ISO, to / FUSION_ZIP_TOOLS_NAME);
66 | 		success &= Archive::extractZip(temppath / FUSION_DEF_CORE_NAME_ZIP, FUSION_ZIP_PRE15_TOOLS_ISO, to / FUSION_ZIP_PRE15_TOOLS_NAME);
67 | 
68 | 		// Cleanup zip file
69 | 		fs::remove(temppath / FUSION_DEF_CORE_NAME_ZIP);
70 | 
71 | 		if (!success) {
72 | 			Logger::error("Couldn't extract from the zip file"); // Error in the zip file, try the next version number
73 | 			return false;
74 | 		}
75 | 
76 | 		// Cleanup tar file
77 | 		fs::remove(temppath / FUSION_DEF_CORE_NAME);
78 | 	}
79 | 	catch (const NetworkException& exc) {
80 | 		if (exc.getCode() == CURLE_HTTP_RETURNED_ERROR) {
81 | 			Logger::debug("Couldn't download tools from this version number. Trying the next one");
82 | 			return false;
83 | 		}
84 | 		else {
85 | 			throw std::runtime_error(std::string(exc.what()));
86 | 		}
87 | 	}
88 | 
89 | 	return true;
90 | }
91 | */
92 | 


--------------------------------------------------------------------------------
/include/versionparser.h:
--------------------------------------------------------------------------------
  1 | #ifndef VERSIONPARSER_H
  2 | #define VERSIONPARSER_H
  3 | 
  4 | #include <string>
  5 | #include <regex>
  6 | #include <list>
  7 | #include <sstream>
  8 | 
  9 | #include "config.h"
 10 | 
 11 | // Auxiliary class for version comparation
 12 | class Version {
 13 | public:
 14 | 	// Version parse exception
 15 | 	class VersionException : public std::exception
 16 | 	{
 17 | 	public:
 18 | 		explicit VersionException(const char* message) :
 19 | 			msg_(message)
 20 | 		{
 21 | 		}
 22 | 		explicit VersionException(const std::string& message) :
 23 | 			msg_(message)
 24 | 		{}
 25 | 		virtual ~VersionException() throw () {}
 26 | 		virtual const char* what() const throw () {
 27 | 			return msg_.c_str();
 28 | 		}
 29 | 
 30 | 	protected:
 31 | 		std::string msg_;
 32 | 	};
 33 | 
 34 | 	enum VersionNumberType {
 35 | 		MAJOR,
 36 | 		MINOR,
 37 | 		REVISION
 38 | 	};
 39 | 
 40 | 	Version(std::string version)
 41 | 		: version(version)
 42 | 	{
 43 | 		std::smatch mres;
 44 | 		if (std::regex_match(version, mres, pattern)) {
 45 | 			major = std::stoi(mres.str(1));
 46 | 			minor = std::stoi(mres.str(2));
 47 | 			revision = std::stoi(mres.str(3));
 48 | 		}
 49 | 		else throw VersionException("Not a valid version string");
 50 | 	}
 51 | 
 52 | 	std::string getVersionText() const {
 53 | 		return version;
 54 | 	}
 55 | 
 56 | 	int getVersionNumber(VersionNumberType vnType = MAJOR) const {
 57 | 		switch (vnType) {
 58 | 		default:
 59 | 		case MAJOR:
 60 | 			return major;
 61 | 		case MINOR:
 62 | 			return minor;
 63 | 		case REVISION:
 64 | 			return revision;
 65 | 		}
 66 | 	}
 67 | 
 68 | 	bool operator== (const Version& v2) const {
 69 | 		return (major == v2.major &&
 70 | 			minor == v2.minor &&
 71 | 			revision == v2.revision
 72 | 			);
 73 | 	}
 74 | 
 75 | 	bool operator!= (const Version& v2) const {
 76 | 		return !(*this == v2);
 77 | 	}
 78 | 
 79 | 	bool operator> (const Version& v2) const {
 80 | 		if (major > v2.major)
 81 | 			return true;
 82 | 		if (major == v2.major)
 83 | 		{
 84 | 			if (minor > v2.minor)
 85 | 				return true;
 86 | 			if (minor == v2.minor)
 87 | 			{
 88 | 				if (revision > v2.revision)
 89 | 					return true;
 90 | 			}
 91 | 		}
 92 | 
 93 | 		return false;
 94 | 	}
 95 | 
 96 | 	bool operator< (const Version& v2) const {
 97 | 		return !(*this > v2) && *this != v2;
 98 | 	}
 99 | 
100 | 	bool operator>= (const Version& v2) const {
101 | 		return (*this > v2) || (*this == v2);
102 | 	}
103 | 
104 | 	bool operator<= (const Version& v2) const {
105 | 		return (*this < v2) || (*this == v2);
106 | 	}
107 | private:
108 | 	std::string version;
109 | 	std::regex pattern = std::regex("(\\d+)\\.(\\d+)\\.(\\d+)");
110 | 	int major = 0, minor = 0, revision = 0;
111 | };
112 | 
113 | class VersionParser
114 | {
115 | public:
116 | 	VersionParser(const std::string& versionhtmltext);
117 | 	const Version& getLatest() const;
118 | 	std::list<Version>::const_iterator cbegin() const;
119 | 	std::list<Version>::const_iterator cend() const;
120 | 	int size() const;
121 | private:
122 | 	std::string htmltext;
123 | 	std::list<Version> versions;
124 | 	std::regex pattern = std::regex(VERSION_REGEX_PATTERN, std::regex::icase);
125 | 
126 | };
127 | 
128 | #endif // VERSIONPARSER_H
129 | 


--------------------------------------------------------------------------------
/src/win32/downloadtoolstask.cpp:
--------------------------------------------------------------------------------
  1 | #include "win32\downloadtoolstask.h"
  2 | #include "win32\mainwindow.h"
  3 | 
  4 | DownloadToolsTask::DownloadToolsTask(MainWindow& mainWindow)
  5 | 	: mainWindow(mainWindow)
  6 | {
  7 | }
  8 | 
  9 | void DownloadToolsTask::setOnCompleteCallback(std::function<void(PatchResult)> completeCallback)
 10 | {
 11 | 	onCompleteCallback = completeCallback;
 12 | }
 13 | 
 14 | void DownloadToolsTask::setOnProgressCallback(std::function<void(float)> progressCallback)
 15 | {
 16 | 	onProgressCallback = progressCallback;
 17 | }
 18 | 
 19 | void DownloadToolsTask::onProgressUpdate(float progress)
 20 | {
 21 | 	if (onProgressCallback != nullptr) {
 22 | 		onProgressCallback(progress);
 23 | 	}
 24 | }
 25 | 
 26 | void DownloadToolsTask::downloadProgress(double dltotal, double dlnow, double ultotal, double ulnow)
 27 | {
 28 | 	static char statusBarProgress[1024];
 29 | 
 30 | 	using namespace std::chrono;
 31 | 	milliseconds tTime = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
 32 | 	long long tDelta = (tTime - lastProgressUpdate).count();
 33 | 
 34 | 	if (dltotal > 0 && tDelta > PROG_PERIOD_MS) {
 35 | 		double dlDelta = dlnow - lastDlNow;
 36 | 		float downloadPercent = dlnow / dltotal;
 37 | 
 38 | 		postProgress(downloadPercent);
 39 | 
 40 | 		sprintf(statusBarProgress, "Downloading: %.0f %%, %.3f MB/s", downloadPercent * 100, (dlDelta * 1000) / (tDelta * 1024 * 1024));
 41 | 		mainWindow.statusBar->setText(statusBarProgress);
 42 | 		lastProgressUpdate = tTime;
 43 | 		lastDlNow = dlnow;
 44 | 	}
 45 | }
 46 | 
 47 | PatchResult DownloadToolsTask::doInBackground(void* arg)
 48 | {
 49 | 	postProgress(0.f);
 50 | 
 51 | 	// Create a log file in the current directory named unlocker-download-{date}.log
 52 | 	char logFilePath[MAX_PATH];
 53 | 	GetCurrentDirectory(MAX_PATH, logFilePath);
 54 | 
 55 | 	auto t = std::time(nullptr);
 56 | 	auto tm = *std::localtime(&t);
 57 | 	std::ostringstream oss;
 58 | 	oss << "unlocker-download-" << std::put_time(&tm, "%d-%m-%Y.%H-%M-%S") << ".log";
 59 | 	auto str = oss.str();
 60 | 
 61 | 	PathAppend(logFilePath, str.c_str());
 62 | 
 63 | 	std::ofstream logStream(logFilePath);
 64 | 	StreamLogStrategy logStrategy(logStream);
 65 | 	StatusBarLogStrategy statusLogStrategy(mainWindow.statusBar.get());
 66 | 
 67 | 	CombinedLogStrategy multipleLogStrategy;
 68 | 	multipleLogStrategy.add(&logStrategy);
 69 | 	multipleLogStrategy.add(&statusLogStrategy);
 70 | 
 71 | 	Logger::init(&multipleLogStrategy);
 72 | 
 73 | 	try {
 74 | 		postProgress(0.f);
 75 | 
 76 | 		lastProgressUpdate = std::chrono::duration_cast<std::chrono::milliseconds>(
 77 | 			std::chrono::system_clock::now().time_since_epoch()
 78 | 			);
 79 | 		lastDlNow = 0.0;
 80 | 
 81 | 		fs::path toolsdirectory = fs::path(mainWindow.toolsPathEditBox->getText());
 82 | 		downloadTools(toolsdirectory, std::bind(&DownloadToolsTask::downloadProgress, this, std::placeholders::_1,
 83 | 			std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
 84 | 
 85 | 		postProgress(1.f);
 86 | 
 87 | 		Logger::info("Tools downloaded.");
 88 | 	}
 89 | 	catch (const std::runtime_error& exc)
 90 | 	{
 91 | 		Logger::error(exc.what());
 92 | 		Logger::free();
 93 | 		return PatchResult{ false, std::string(exc.what()), std::string(logFilePath) };
 94 | 	}
 95 | 
 96 | 	Logger::free();
 97 | 	return PatchResult{ true, "", std::string(logFilePath) };
 98 | }
 99 | 
100 | void DownloadToolsTask::onPostExecute(PatchResult result)
101 | {
102 | 	if (onCompleteCallback != nullptr)
103 | 	{
104 | 		onCompleteCallback(result);
105 | 	}
106 | }
107 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Auto-Unlocker
 2 | A one-click Unlocker for VMWare Player and Workstation.
 3 | 
 4 | **A C++ port of the [DrDonk Python Unlocker](https://github.com/DrDonk/unlocker)**
 5 | 
 6 | ## The tool
 7 | 
 8 | This project is born to provide a native solution, mainly on Windows, to the original Unlocker project. 
 9 | Since the original project requires python, and it's not installed by default on windows, this tool has 
10 | been coded to provide an all-in-one solution with no additional dependencies needed.
11 | 
12 | It relies on libcurl for the networking (get requests and file download) and libzip	for the zip extraction.
13 | The tar extraction, being relatively easy to implement, has been coded from	scratch. 
14 | The libraries are linked statically to provide one final executable for the sake of simplicity.
15 | 
16 | The Windows target features a GUI implemented throught the Win32 API.
17 | Although this solution brings more complexity than using one of the many GUI libraries out there,
18 | the resulting executable will be smaller and with better compatibility.
19 | 
20 | For the linux target, it is still shell-based, given the better-instructed user base running
21 | this tool on linux os-es.
22 | 
23 | ## DrDonk Unlocker
24 | 
25 | Unlocker 3 is designed for VMware Workstation 11-15 and Player 7-15.
26 | 
27 | The patch code carries out the following modifications dependent on the product
28 | being patched:
29 | 
30 | * Fix vmware-vmx and derivatives to allow macOS to boot
31 | * Fix vmwarebase .dll or .so to allow Apple to be selected during VM creation
32 | * Download a copy of the latest VMware Tools for macOS
33 | 
34 | Note that not all products recognise the darwin.iso via install tools menu item.
35 | You will have to manually mount the darwin.iso for example on Workstation 11 and Player 7.
36 | 
37 | In all cases make sure VMware is not running, and any background guests have
38 | been shutdown.
39 | 
40 | ## How to use
41 | 
42 | **Windows (GUI):** just download from the *releases* section, extract to a folder (store it if you want to be able to uninstall later) and run the executable.
43 | 
44 | **Linux (shell):** You need to compile the program first. After you compiled it, ```chmod +x``` if needed and run ```sudo ./auto-unlocker```. Refer to the next section for more info about compiling the tool.
45 | 
46 | **Command line options (linux):**
47 | 
48 | * ```--install``` *(Default behavior when called with no arguments)* Installs the patch.
49 | * ```--uninstall``` Uninstalls the patch. Works only if the patch was previously installed and the *backup* folder is intact
50 | * ```--download-tools``` Downloads the tools in the `tools` folder
51 | * ```--help``` Shows a list of the available options
52 | 
53 | ## Compile
54 | The program can be compiled on Windows with CMake, provided you get or compile the needed libraries first. Run CMake on the source dir and it will generate a ready to build project.
55 | 
56 | The program needs the following libraries:
57 | 
58 | * libcurl
59 | * libzip
60 | 
61 | The tar extraction is handled internally, while the zip decompression needs the `libzip` library. `libcurl` is used for downloading the tools.
62 | 
63 | **Windows:** 
64 | Run *CMake* on the source folder to generate a Visual Studio Project. The CMakeList is set up to compile with static libraries, if you have shared ones change *CMakeLists.txt* file accordingly (**UNLOCKER_STATIC_LIBS_WIN** variable). Point the CMake utility to the proper library/headers paths when prompted or add them to your PATH.
65 | 
66 | **Linux:**
67 | Use the embedded Makefile. Get needed libraries (or compile them and install) first, then run ```make```
68 | 
69 | On Ubuntu:
70 | 
71 | ```bash
72 | sudo apt-get install libcurl4-openssl-dev libzip-dev
73 | git clone https://github.com/paolo-projects/auto-unlocker
74 | cd auto-unlocker
75 | make
76 | chmod +x ./auto-unlocker
77 | sudo ./auto-unlocker
78 | ```


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
  1 | /************************************************************************************************
  2 | 	Unlocker - Patcher + Tools Downloader
  3 | 	Created by Paolo Infante - Based on "Unlocker" by DrDonk
  4 | 
  5 | 	This project is born to provide a native solution, mainly on Windows, to the original
  6 | 	Unlocker project. Since the original project requires python, and it's not installed
  7 | 	by default on windows, this tool has been coded to provide an all-in-one solution with
  8 | 	no additional dependencies needed.
  9 | 
 10 | 	It relies on libcurl for the networking (get requests and file download) and libzip
 11 | 	for the zip extraction. The tar extraction, being relatively easy to implement, has been coded from
 12 | 	scratch. The libraries are linked statically to provide one final executable for the sake
 13 | 	of simplicity.
 14 | 
 15 | 	The future of this project is to provide a GUI for the windows target using the Win32 API.
 16 | 	Although this solution brings more complexity than using one of the many GUI libraries out there
 17 | 	such as MFC, QT, GTK, wx, the resulting executable will be smaller and with better compatibility.
 18 | 
 19 | 	For the linux target, it will still be shell-based, given the better-instructed user base running
 20 | 	this tool on linux os-es.
 21 | 
 22 | *************************************************************************************************/
 23 | 
 24 | #ifdef _WIN32
 25 | #include <Windows.h>
 26 | #include "win32/mainwindow.h"
 27 | 
 28 | void loadVisualStyles();
 29 | bool registerControlStyles(DWORD style);
 30 | #endif
 31 | 
 32 | #include <iostream>
 33 | #include "config.h"
 34 | 
 35 | #ifdef __linux__
 36 | #include "unlocker_lnx.h"
 37 | #include "logging/terminallogstrategy.h"
 38 | 
 39 | void showhelp()
 40 | {
 41 | 	std::cout << "auto-unlocker " << PROG_VERSION << std::endl << std::endl
 42 | 		<< "Run the program with one of these options:" << std::endl
 43 | 		<< "	--install (default): install the patch" << std::endl
 44 | 		<< "	--uninstall: remove the patch" << std::endl
 45 | 		<< "	--download-tools: only download the tools" << std::endl
 46 | 		<< "	--help: show this help message" << std::endl;
 47 | }
 48 | 
 49 | int main(int argc, const char* argv[])
 50 | {
 51 | 	TerminalLogStrategy logStrategy;
 52 | 	Logger::init(&logStrategy);
 53 | 
 54 | 	std::cout << "auto-unlocker " << PROG_VERSION << std::endl
 55 | 		<< std::endl;
 56 | 
 57 | 	try {
 58 | #ifdef __linux__
 59 | 		if (geteuid() != 0)
 60 | 		{
 61 | 			// User not root and not elevated permissions
 62 | 			std::cout << "The program is not running as root, the patch may not work properly." << std::endl <<
 63 | 						"Running the program with sudo/as root is recommended, in most cases required... Do you want to continue? (y/n) ";
 64 | 			std::string c;
 65 | 			std::cin >> c;
 66 | 
 67 | 			if (c != "y" && c != "Y")
 68 | 			{
 69 | 				std::cout << "Aborting..." << std::endl;
 70 | 				exit(0);
 71 | 			}
 72 | 		}
 73 | #endif
 74 | 		if (argc > 1)
 75 | 		{
 76 | 			const char* arg = argv[1];
 77 | 
 78 | 			if (stricmp(arg, UNINSTALL_OPTION) == 0)
 79 | 				uninstallLnx();
 80 | 			else if (stricmp(arg, HELP_OPTION) == 0)
 81 | 				showhelp();
 82 | 			else if (stricmp(arg, INSTALL_OPTION) == 0)
 83 | 				installLnx();
 84 | 			else if (stricmp(arg, DOWNLOADONLY_OPTION) == 0)
 85 | 				downloadTools(fs::path(".") / TOOLS_DOWNLOAD_FOLDER);
 86 | 			else
 87 | 			{
 88 | 				std::cout << "Unrecognized command." << std::endl << std::endl;
 89 | 				showhelp();
 90 | 			}
 91 | 		}
 92 | 		else {
 93 | 			fs::path backupFolder = BACKUP_FOLDER;
 94 | 			if (fs::exists(backupFolder))
 95 | 			{
 96 | 				std::cout << "A backup folder has been found. Do you wish to uninstall the previous patch? Type y to uninstall, n to continue with installation." << std::endl
 97 | 					<< "(y/n) ";
 98 | 
 99 | 				std::string c;
100 | 				std::cin >> c;
101 | 
102 | 				if (c == "n" || c == "N")
103 | 					installLnx();
104 | 				else
105 | 					uninstallLnx();
106 | 			}
107 | 			else installLnx();
108 | 		}
109 | 	}
110 | 	catch (const std::exception& exc)
111 | 	{
112 | 		Logger::error(std::string(exc.what()));
113 | 	}
114 | 
115 | 	Logger::free();
116 | 	return 0;
117 | }
118 | #elif defined _WIN32
119 | 
120 | bool registerControlStyles(DWORD style)
121 | {
122 | 	INITCOMMONCONTROLSEX comButton = {};
123 | 	comButton.dwSize = sizeof(comButton);
124 | 	comButton.dwICC = style;
125 | 	return InitCommonControlsEx(&comButton);
126 | }
127 | 
128 | void loadVisualStyles()
129 | {
130 | 	std::vector<DWORD> styles = {
131 | 		ICC_WIN95_CLASSES,
132 | 		ICC_PROGRESS_CLASS
133 | 	};
134 | 
135 | 	for (DWORD style : styles)
136 | 	{
137 | 		registerControlStyles(style);
138 | 	}
139 | }
140 | 
141 | int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevINSTANCE, PSTR pCmdLine, int nCmdShow)
142 | {
143 | 	MainWindow mainWindow(hInstance, nCmdShow);
144 | 	mainWindow.show();
145 | }
146 | 
147 | #endif


--------------------------------------------------------------------------------
/src/win32/unpatchertask.cpp:
--------------------------------------------------------------------------------
  1 | #include "win32\unpatchertask.h"
  2 | #include "win32\mainwindow.h"
  3 | 
  4 | UnpatcherTask::UnpatcherTask(MainWindow& mainWindow)
  5 | 	:	mainWindow(mainWindow)
  6 | {
  7 | }
  8 | 
  9 | void UnpatcherTask::setOnCompleteCallback(std::function<void(PatchResult)> completeCallback)
 10 | {
 11 | 	onCompleteCallback = completeCallback;
 12 | }
 13 | 
 14 | void UnpatcherTask::setOnProgressCallback(std::function<void(float)> progressCallback)
 15 | {
 16 | 	onProgressCallback = progressCallback;
 17 | }
 18 | 
 19 | void UnpatcherTask::onProgressUpdate(float progress)
 20 | {
 21 | 	if (onProgressCallback != nullptr)
 22 | 	{
 23 | 		onProgressCallback(progress);
 24 | 	}
 25 | }
 26 | 
 27 | PatchResult UnpatcherTask::doInBackground(void* arg)
 28 | {
 29 | 	fs::path vmwareInstallDir = fs::path(mainWindow.pathEditBox->getText()),
 30 | 		vmwareInstallDir64 = fs::path(mainWindow.pathEditBoxX64->getText());
 31 | 
 32 | 	// Create a log file in the current directory named unlocker-uninstall-{date}.log
 33 | 	char logFilePath[MAX_PATH];
 34 | 	GetCurrentDirectory(MAX_PATH, logFilePath);
 35 | 
 36 | 	auto t = std::time(nullptr);
 37 | 	auto tm = *std::localtime(&t);
 38 | 	std::ostringstream oss;
 39 | 	oss << "unlocker-uninstall-" << std::put_time(&tm, "%d-%m-%Y.%H-%M-%S") << ".log";
 40 | 	auto str = oss.str();
 41 | 
 42 | 	PathAppend(logFilePath, str.c_str());
 43 | 
 44 | 	std::ofstream logStream(logFilePath);
 45 | 	StreamLogStrategy logStrategy(logStream);
 46 | 	StatusBarLogStrategy statusLogStrategy(mainWindow.statusBar.get());
 47 | 
 48 | 	CombinedLogStrategy multipleLogStrategy;
 49 | 	multipleLogStrategy.add(&logStrategy);
 50 | 	multipleLogStrategy.add(&statusLogStrategy);
 51 | 
 52 | 	Logger::init(&multipleLogStrategy);
 53 | 	try
 54 | 	{
 55 | 		postProgress(0.f); 
 56 | 		
 57 | 		PatchVersioner patchVersion(vmwareInstallDir);
 58 | 
 59 | 		if (!patchVersion.hasPatch())
 60 | 		{
 61 | 			throw std::runtime_error("The vmware installation you specified does not have a patch installed");
 62 | 		}
 63 | 
 64 | 		// Stop services
 65 | 		stopServices();
 66 | 
 67 | 		postProgress(0.2f);
 68 | 
 69 | 		// Default output path is ./tools/
 70 | 		fs::path toolsdirectory = fs::path(".") / TOOLS_DOWNLOAD_FOLDER;
 71 | 		// Default backup path is ./backup/
 72 | 		fs::path backup = fs::path(".") / BACKUP_FOLDER;
 73 | 
 74 | 		Logger::info("Restoring files...");
 75 | 		// Copy contents of backup/
 76 | 		if (fs::exists(backup))
 77 | 		{
 78 | 			for (const auto& file : fs::directory_iterator(backup))
 79 | 			{
 80 | 				if (fs::is_regular_file(file))
 81 | 				{
 82 | 					if (fs::copy_file(file.path(), vmwareInstallDir / file.path().filename(), fs::copy_options::overwrite_existing))
 83 | 					{
 84 | 						Logger::info("File \"" + file.path().string() + "\" restored successfully");
 85 | 					}
 86 | 					else
 87 | 					{
 88 | 						throw std::runtime_error("Couldn't restore file " + file.path().string());
 89 | 					}
 90 | 				}
 91 | 			}
 92 | 			// Copy contents of backup/x64/
 93 | 			for (const auto& file : fs::directory_iterator(backup / "x64"))
 94 | 			{
 95 | 				if (fs::is_regular_file(file))
 96 | 				{
 97 | 					if (fs::copy_file(file.path(), vmwareInstallDir64 / file.path().filename(), fs::copy_options::overwrite_existing))
 98 | 					{
 99 | 						Logger::info("File \"" + file.path().string() + "\" restored successfully");
100 | 					}
101 | 					else
102 | 					{
103 | 						throw std::runtime_error("Couldn't restore file " + file.path().string());
104 | 					}
105 | 				}
106 | 			}
107 | 		}
108 | 		else {
109 | 			throw std::runtime_error("Couldn't find backup files...");
110 | 		}
111 | 
112 | 		patchVersion.removePatchVersion();
113 | 
114 | 		postProgress(0.4f);
115 | 
116 | 		// Remove darwin*.* from InstallDir
117 | 		for (const auto& file : fs::directory_iterator(vmwareInstallDir))
118 | 		{
119 | 			if (fs::is_regular_file(file))
120 | 			{
121 | 				size_t is_drw = file.path().filename().string().find("darwin");
122 | 				if (is_drw != std::string::npos && is_drw == 0)
123 | 				{
124 | 					fs::remove(file);
125 | 				}
126 | 			}
127 | 		}
128 | 
129 | 		fs::remove_all(backup);
130 | 		fs::remove_all(toolsdirectory);
131 | 
132 | 		postProgress(0.6f);
133 | 
134 | 		// Restart services
135 | 		restartServices();
136 | 
137 | 		postProgress(0.8f);
138 | 
139 | 		Logger::info("Uninstall complete.");
140 | 
141 | 		postProgress(1.f);
142 | 	}
143 | 	catch (const std::runtime_error& exc)
144 | 	{
145 | 		Logger::error(exc.what());
146 | 		Logger::free();
147 | 		return PatchResult{
148 | 			false,
149 | 			std::string(exc.what()),
150 | 			std::string(logFilePath)
151 | 		};
152 | 	}
153 | 
154 | 	Logger::free();
155 | 	return PatchResult{
156 | 		true,
157 | 		"",
158 | 		std::string(logFilePath)
159 | 	};
160 | }
161 | 
162 | void UnpatcherTask::onPostExecute(PatchResult result)
163 | {
164 | 	if (onCompleteCallback != nullptr)
165 | 	{
166 | 		onCompleteCallback(result);
167 | 	}
168 | }
169 | 


--------------------------------------------------------------------------------
/src/tar.cpp:
--------------------------------------------------------------------------------
  1 | #include "tar.h"
  2 | 
  3 | Tar::Tar(std::string filename)
  4 | {
  5 | 	tarfile = fopen(filename.c_str(), "rb");
  6 | 
  7 | 	if (tarfile == NULL)
  8 | 	{
  9 | 		throw TarException("Couldn't open " + filename);
 10 | 	}
 11 | 
 12 | 	tar_posix_header fileheader = {};
 13 | 
 14 | 	int readsz = 0;
 15 | 	while ((readsz = fread(reinterpret_cast<char*>(&fileheader), 1, sizeof(fileheader), tarfile)) == TAR_BLOCK_SZ)
 16 | 	{
 17 | 		int checksum = 0;
 18 | 		char* header_data = reinterpret_cast<char*>(&fileheader);
 19 | 
 20 | 		for (int i = 0; i < sizeof(tar_posix_header); i++)
 21 | 			checksum += ((unsigned char*)(&(fileheader)))[i];
 22 | 		for (int i = 0; i < 8; i++)
 23 | 			checksum += (' ' - (unsigned char)fileheader.chksum[i]);
 24 | 
 25 | 		int header_checksum = octToInt(fileheader.chksum);
 26 | 
 27 | 		if (checksum != header_checksum) {
 28 | 			continue;
 29 | 		}
 30 | 
 31 | 		File file;
 32 | 		file.name = std::string(fileheader.name);
 33 | 
 34 | 		file.size = octToSz(fileheader.size);
 35 | 		file.groupId = octToInt(fileheader.gid);
 36 | 		file.mode = octToInt(fileheader.mode);
 37 | 		file.ownerId = octToInt(fileheader.uid);
 38 | 		file.lastModified = octToInt(fileheader.mtime);
 39 | 		file.position = ftell(tarfile);
 40 | 		file.typeflag = static_cast<tar_type_flag>(fileheader.typeflag);
 41 | 
 42 | 		fileList.emplace_back(file);
 43 | 
 44 | 		// Calculate the bytes to skip to reach the next file header location
 45 | 		// The count of bytes to skip is the file size fitted to the 512-block size
 46 | 		size_t toskip = (std::ceil(file.size / static_cast<double>(TAR_BLOCK_SZ)) * static_cast<size_t>(TAR_BLOCK_SZ));
 47 | 
 48 | 		// Using 64-bit data types and functions to support archives containing large files
 49 | 		// Otherwise, the first large file size (> ~2GB on Windows) would probably overflow the signed long and 
 50 | 		// break the 512 blocks succession. This is compiler dependent, though
 51 | 		// 64 bit long long instead supports files way beyond the tar individual file size limit
 52 | 		fseek_e64(tarfile, toskip, SEEK_CUR);
 53 | 	}
 54 | 
 55 | 	fseek(tarfile, 0, SEEK_SET);
 56 | }
 57 | 
 58 | Tar::~Tar()
 59 | {
 60 | 	if (tarfile != NULL) {
 61 | 		fclose(tarfile);
 62 | 		tarfile = NULL;
 63 | 	}
 64 | }
 65 | 
 66 | void Tar::extract(const File& file, std::string to, void(*progressCallback)(float))
 67 | {
 68 | 	// If the name ends with a / character then it's a directory and we don't support it (for now)
 69 | 	if (*(file.name.cend() - 1) == '/') {
 70 | 		throw TarException("Can't extract a directory. Operation not supported");
 71 | 	}
 72 | 
 73 | 	// Throw an exception if the file being extracted is not a regular file (symlink, directory, etc.)
 74 | 	if (file.typeflag != REGTYPE && file.typeflag != AREGTYPE) {
 75 | 		throw TarException("Can't extract this type of file. Only regular files supported");
 76 | 	}
 77 | 
 78 | 	// Set the file pointer to the beginning of the file being extracted
 79 | 	fseek_e64(tarfile, file.position, SEEK_SET);
 80 | 
 81 | 	size_t size, totalSize;
 82 | 	size = totalSize = file.size;
 83 | 
 84 | 	FILE* outfile = fopen(to.c_str(), "wb");
 85 | 
 86 | 	if (outfile != NULL) {
 87 | 		std::array<char, EXTRACT_BUFFER_SZ> buffer;
 88 | 
 89 | 		while (size > 0) {
 90 | 			int tocopy = std::min(EXTRACT_BUFFER_SZ, size);
 91 | 			fread(buffer.data(), 1, tocopy, tarfile);
 92 | 			fwrite(buffer.data(), 1, tocopy, outfile);
 93 | 
 94 | 			if (progressCallback != nullptr) {
 95 | 				progressCallback(float(totalSize - size) / totalSize);
 96 | 			}
 97 | 
 98 | 			size -= tocopy;
 99 | 		}
100 | 
101 | 		fclose(outfile);
102 | 	}
103 | 	else {
104 | 		throw TarException("Error while opening " + to + " for writing");
105 | 	}
106 | }
107 | 
108 | 
109 | bool Tar::extract(std::string fileName, std::string to, void(*progressCallback)(float))
110 | {
111 | 	for (const File& file : fileList) {
112 | 		if (file.name == fileName) {
113 | 			extract(file, to, progressCallback);
114 | 			return true;
115 | 		}
116 | 	}
117 | 	return false;
118 | }
119 | 
120 | const std::vector<Tar::File>& Tar::getFileList() const
121 | {
122 | 	return fileList;
123 | }
124 | 
125 | bool Tar::contains(std::string fileName) const
126 | {
127 | 	for (const File& f : fileList) {
128 | 		if (f.name == fileName) {
129 | 			return true;
130 | 		}
131 | 	}
132 | 	return false;
133 | }
134 | 
135 | std::vector<Tar::File> Tar::search(const std::string& term)
136 | {
137 | 	std::vector<File> results;
138 | 
139 | 	std::copy_if(fileList.begin(), fileList.end(), std::back_inserter(results), [&term](const File& file) {
140 | 		return file.name.find(term) != std::string::npos;
141 | 		});
142 | 
143 | 	return results;
144 | }
145 | 
146 | 
147 | int Tar::octToInt(char* oct)
148 | {
149 | 	int res;
150 | 	return sscanf(oct, "%o", &res) == 1 ? res : 0;
151 | }
152 | 
153 | size_t Tar::octToSz(char* oct)
154 | {
155 | 	if (*oct == 0xFF) {
156 | 		throw TarException("base-256 file size not supported.");
157 | 	}
158 | 	else if (*oct == 0x80) {
159 | 		throw TarException("base-256 file size not supported.");
160 | 	}
161 | 	else {
162 | 		size_t res;
163 | 		return sscanf(oct, "%zo", &res) == 1 ? res : 0;
164 | 	}
165 | }
166 | 


--------------------------------------------------------------------------------
/src/win32/patchertask.cpp:
--------------------------------------------------------------------------------
  1 | #include "win32\patchertask.h"
  2 | #include "win32\mainwindow.h"
  3 | 
  4 | PatcherTask::PatcherTask(MainWindow& mainWindow)
  5 | 	: mainWindow(mainWindow)
  6 | {
  7 | }
  8 | 
  9 | void PatcherTask::setOnCompleteCallback(std::function<void(PatchResult)> completeCallback)
 10 | {
 11 | 	onCompleteCallback = completeCallback;
 12 | }
 13 | 
 14 | void PatcherTask::setOnProgressCallback(std::function<void(float)> progressCallback)
 15 | {
 16 | 	onProgressCallback = progressCallback;
 17 | }
 18 | 
 19 | void PatcherTask::onProgressUpdate(float progress)
 20 | {
 21 | 	if (onProgressCallback != nullptr) {
 22 | 		onProgressCallback(progress);
 23 | 	}
 24 | }
 25 | 
 26 | void PatcherTask::downloadProgress(double dltotal, double dlnow, double ultotal, double ulnow)
 27 | {
 28 | 	static char statusBarProgress[1024];
 29 | 
 30 | 	using namespace std::chrono;
 31 | 	milliseconds tTime = duration_cast<milliseconds>(system_clock::now().time_since_epoch());
 32 | 	long long tDelta = (tTime - lastProgressUpdate).count();
 33 | 
 34 | 	if (dltotal > 0 && tDelta > PROG_PERIOD_MS) {
 35 | 		double dlDelta = dlnow - lastDlNow;
 36 | 		float downloadPercent = dlnow / dltotal;
 37 | 
 38 | 		postProgress(0.2f + downloadPercent * 0.6f);
 39 | 
 40 | 		sprintf(statusBarProgress, "Downloading: %.0f %%, %.3f MB/s", downloadPercent*100, (dlDelta*1000)/(tDelta*1024*1024));
 41 | 		mainWindow.statusBar->setText(statusBarProgress);
 42 | 		lastProgressUpdate = tTime;
 43 | 		lastDlNow = dlnow;
 44 | 	}
 45 | }
 46 | 
 47 | PatchResult PatcherTask::doInBackground(void* arg)
 48 | {
 49 | 	postProgress(0.f);
 50 | 
 51 | 	// If tools download is disabled check that the tools exist in the path provided through the GUI
 52 | 	if (!mainWindow.downloadToolsChk->isChecked() &&
 53 | 		!(fs::exists(fs::path(".") / TOOLS_DOWNLOAD_FOLDER / FUSION_ZIP_TOOLS_NAME) && fs::exists(fs::path(".") / TOOLS_DOWNLOAD_FOLDER / FUSION_ZIP_PRE15_TOOLS_NAME))
 54 | 		)
 55 | 	{
 56 | 		return PatchResult{ false, "Tools not found in the directory you provided. Check the folder path or enable the option to download them" };
 57 | 	}
 58 | 
 59 | 	// Create a log file in the current directory named unlocker-{date}.log
 60 | 	char logFilePath[MAX_PATH];
 61 | 	GetCurrentDirectory(MAX_PATH, logFilePath);
 62 | 
 63 | 	auto t = std::time(nullptr);
 64 | 	auto tm = *std::localtime(&t);
 65 | 	std::ostringstream oss;
 66 | 	oss << "unlocker-" << std::put_time(&tm, "%d-%m-%Y.%H-%M-%S") << ".log";
 67 | 	auto str = oss.str();
 68 | 
 69 | 	PathAppend(logFilePath, str.c_str());
 70 | 
 71 | 	std::ofstream logStream(logFilePath);
 72 | 	StreamLogStrategy logStrategy(logStream);
 73 | 	StatusBarLogStrategy statusLogStrategy(mainWindow.statusBar.get());
 74 | 
 75 | 	CombinedLogStrategy multipleLogStrategy;
 76 | 	multipleLogStrategy.add(&logStrategy);
 77 | 	multipleLogStrategy.add(&statusLogStrategy);
 78 | 
 79 | 	Logger::init(&multipleLogStrategy);
 80 | 
 81 | 	// Default backup path is ./backup/
 82 | 	fs::path backup = fs::path(".") / BACKUP_FOLDER;
 83 | 
 84 | 	fs::path vmwareInstallDir = fs::path(mainWindow.pathEditBox->getText()),
 85 | 		vmwareInstallDir64 = fs::path(mainWindow.pathEditBoxX64->getText());
 86 | 
 87 | 	try {
 88 | 		PatchVersioner patchVersion(vmwareInstallDir);
 89 | 
 90 | 		if (patchVersion.hasPatch())
 91 | 		{
 92 | 			throw std::runtime_error("The vmware installation you specified is already patched. Uninstall the previous patch first, or delete the .unlocker file (not suggested)");
 93 | 		}
 94 | 
 95 | 		Logger::info("Killing services and backing up files...");
 96 | 		preparePatchWin(backup, vmwareInstallDir);
 97 | 
 98 | 		postProgress(0.1f);
 99 | 
100 | 		Logger::info("Patching files...");
101 | 		applyPatchWin(vmwareInstallDir, vmwareInstallDir64);
102 | 
103 | 		patchVersion.writePatchData();
104 | 
105 | 		postProgress(0.2f);
106 | 
107 | 		// Default output path is ./tools/
108 | 		fs::path toolsdirectory = fs::path(".") / TOOLS_DOWNLOAD_FOLDER;
109 | 
110 | 		lastProgressUpdate = std::chrono::duration_cast<std::chrono::milliseconds>(
111 | 			std::chrono::system_clock::now().time_since_epoch()
112 | 			);
113 | 		lastDlNow = 0.0;
114 | 
115 | 		if (mainWindow.downloadToolsChk->isChecked())
116 | 		{
117 | 			Logger::info("Downloading tools into \"" + toolsdirectory.string() + "\" directory...");
118 | 			downloadTools(toolsdirectory, std::bind(&PatcherTask::downloadProgress, this, std::placeholders::_1, 
119 | 				std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
120 | 		}
121 | 		else {
122 | 			toolsdirectory = fs::path(mainWindow.toolsPathEditBox->getText());
123 | 		}
124 | 
125 | 		postProgress(0.8f);
126 | 
127 | 		Logger::info("Copying tools into program directory...");
128 | 		copyTools(toolsdirectory, vmwareInstallDir);
129 | 
130 | 		postProgress(0.9f);
131 | 
132 | 		restartServices();
133 | 
134 | 		postProgress(1.f);
135 | 
136 | 		Logger::info("Patch complete.");
137 | 	}
138 | 	catch (const std::runtime_error& exc)
139 | 	{
140 | 		Logger::error(exc.what());
141 | 		Logger::free();
142 | 		return PatchResult{ false, std::string(exc.what()), std::string(logFilePath) };
143 | 	}
144 | 
145 | 	Logger::free();
146 | 	return PatchResult{ true, "", std::string(logFilePath) };
147 | }
148 | 
149 | void PatcherTask::onPostExecute(PatchResult result)
150 | {
151 | 	if (onCompleteCallback != nullptr)
152 | 	{
153 | 		onCompleteCallback(result);
154 | 	}
155 | }
156 | 


--------------------------------------------------------------------------------
/src/network.cpp:
--------------------------------------------------------------------------------
  1 | #include "network.h"
  2 | 
  3 | Network::Network() {
  4 | 	CURLcode res = curl_global_init(CURL_GLOBAL_ALL);
  5 | 
  6 | 	if (res != CURLE_OK) {
  7 | 		throw NetworkException("Could not initialize CURL", res);
  8 | 	}
  9 | }
 10 | 
 11 | Network::~Network() {
 12 | 	curl_global_cleanup();
 13 | }
 14 | 
 15 | void Network::setProgressCallback(std::function<void(double, double, double, double)> progressCallback)
 16 | {
 17 | 	this->progressCallback = progressCallback;
 18 | }
 19 | 
 20 | /**
 21 | 	Writes data received from Curl to a stream
 22 | */
 23 | size_t Network::write_data_file(char* ptr, size_t size, size_t nmemb, void* stream)
 24 | {
 25 | 	std::iostream* fstr = static_cast<std::iostream*>(stream);
 26 | 	size_t bytes = size * nmemb;
 27 | 	fstr->write(ptr, bytes);
 28 | 	return bytes;
 29 | }
 30 | 
 31 | int Network::progress_callback(void* clientp, double dltotal, double dlnow, double ultotal, double ulnow)
 32 | {
 33 | 	NetworkProgress* networkProgress = reinterpret_cast<NetworkProgress*>(clientp);
 34 | 
 35 | 	if (dltotal > 0)
 36 | 	{
 37 | 		double mBytesTotal = dltotal / 1024 / 1024;
 38 | 		double mBytesNow = dlnow / 1024 / 1024;
 39 | 
 40 | 		long long nowTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
 41 | 		// Drop progress update if less than a set time has elapsed since the last one
 42 | 		if (nowTime - networkProgress->lastProgressUpdateTime < updatePeriodMs)
 43 | 		{
 44 | 			// Don't update too frequently.
 45 | 			return 0;
 46 | 		}
 47 | 
 48 | 		double mBytesDelta = mBytesNow - networkProgress->mBytesDownloadedLastTime;
 49 | 		long long timeDeltaMs = nowTime - networkProgress->lastProgressUpdateTime;
 50 | 		double downloadRate = mBytesDelta / (timeDeltaMs / 1000.);
 51 | 
 52 | 		printf("Download progress: %d %%, %.2f MB / %.2f MB, %.3f MB/s          \r",
 53 | 			(std::min)(100, (std::max)(0, int(dlnow * 100 / dltotal))),
 54 | 			mBytesNow, mBytesTotal, downloadRate);
 55 | 		fflush(stdout);
 56 | 
 57 | 		networkProgress->mBytesDownloadedLastTime = mBytesNow;
 58 | 		networkProgress->lastProgressUpdateTime = nowTime;
 59 | 	}
 60 | 	return 0;
 61 | }
 62 | 
 63 | int Network::progress_callback_external(void* clientp, double dltotal, double dlnow, double ultotal, double ulnow)
 64 | {
 65 | 	Network* instance = reinterpret_cast<Network*>(clientp);
 66 | 	instance->progressCallback(dltotal, dlnow, ultotal, ulnow);
 67 | 	return 0;
 68 | }
 69 | 
 70 | void Network::curlDownload(const std::string& url, const std::string& fileName)
 71 | {
 72 | 	CURL* curl = curl_easy_init();
 73 | 	if (curl)
 74 | 	{
 75 | 		std::fstream out_file(fileName, std::ios::out | std::ios::binary);
 76 | 		/* set URL to get here */
 77 | 		curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
 78 | 
 79 | #if CURL_DEBUG
 80 | 		curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 81 | 		/* disable progress meter, set to 0L to enable and disable debug output */
 82 | 		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
 83 | #endif
 84 | 
 85 | 		/* send all data to this function  */
 86 | 		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, Network::write_data_file);
 87 | 		/* write the page body to this ofstream */
 88 | 		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out_file);
 89 | 		/* if response is >400, return an error */
 90 | 		curl_easy_setopt(curl, CURLOPT_FAILONERROR, true);
 91 | 		/* progress monitoring function */
 92 | 		if (progressCallback != nullptr) 
 93 | 		{
 94 | 			curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, this);
 95 | 			curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, Network::progress_callback_external);
 96 | 		}
 97 | 		else 
 98 | 		{
 99 | 			curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, &networkProgress);
100 | 			curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, Network::progress_callback);
101 | 		}
102 | 		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
103 | 		/* get it! */
104 | 		networkProgress.mBytesDownloadedLastTime = 0.0;
105 | 		networkProgress.lastProgressUpdateTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
106 | 		CURLcode res = curl_easy_perform(curl);
107 | 		out_file.close();
108 | 
109 | 		printf("\n");
110 | 
111 | 		curl_easy_cleanup(curl);
112 | 
113 | 		if (res != CURLE_OK) {
114 | 			throw NetworkException("Error in CURL get request: " + std::string(curl_easy_strerror(res)), res);
115 | 		}
116 | 	}
117 | 	else throw std::runtime_error("Could not initialize CURL instance");
118 | }
119 | 
120 | std::string Network::curlGet(const std::string& url)
121 | {
122 | 	CURL* curl = curl_easy_init();
123 | 	if (curl)
124 | 	{
125 | 		std::stringstream sstream;
126 | 
127 | 		/* set URL to get here */
128 | 		curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
129 | 
130 | #if CURL_DEBUG
131 | 		curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
132 | 		/* disable progress meter, set to 0L to enable and disable debug output */
133 | 		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1L);
134 | #endif
135 | 
136 | 		/* send all data to this function  */
137 | 		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, Network::write_data_file);
138 | 		/* write the page body to the stringstream */
139 | 		curl_easy_setopt(curl, CURLOPT_WRITEDATA, &sstream);
140 | 		/* if response is >400, return an error */
141 | 		curl_easy_setopt(curl, CURLOPT_FAILONERROR, true);
142 | 		/* progress monitoring function */
143 | 		/*curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progress_callback);
144 | 		curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);*/
145 | 		/* get it! */
146 | 		CURLcode res = curl_easy_perform(curl);
147 | 
148 | 		curl_easy_cleanup(curl);
149 | 
150 | 		if (res != CURLE_OK)
151 | 		{
152 | 			throw NetworkException("Error in CURL get request: " + std::string(curl_easy_strerror(res)), res);
153 | 		}
154 | 
155 | 		return sstream.str();
156 | 	}
157 | 	else throw std::runtime_error("Could not initialize CURL instance");
158 | }
159 | 


--------------------------------------------------------------------------------
/src/unlocker_win.cpp:
--------------------------------------------------------------------------------
  1 | #include "unlocker_win.h"
  2 | 
  3 | void applyPatchWin(const fs::path& vmwareInstallPath, const fs::path& vmwareInstallPath64)
  4 | {
  5 | 	// Setup paths
  6 | 
  7 | 	std::string binList[] = VM_WIN_PATCH_FILES;
  8 | 
  9 | 	fs::path vmwarebase_path = vmwareInstallPath;//vmInfo.getInstallPath();
 10 | 	fs::path vmx_path = vmwareInstallPath64;//vmInfo.getInstallPath64();
 11 | 	fs::path vmx = vmx_path / binList[0];
 12 | 	fs::path vmx_debug = vmx_path / binList[1];
 13 | 	fs::path vmx_stats = vmx_path / binList[2];
 14 | 	fs::path vmwarebase = vmwarebase_path / binList[3];
 15 | 
 16 | 	if (!fs::exists(vmx))
 17 | 	{
 18 | 		throw std::runtime_error("Vmx file not found");
 19 | 	}
 20 | 	if (!fs::exists(vmx_debug))
 21 | 	{
 22 | 		throw std::runtime_error("Vmx-debug file not found");
 23 | 	}
 24 | 	if (!fs::exists(vmwarebase))
 25 | 	{
 26 | 		throw std::runtime_error("vmwarebase.dll file not found");
 27 | 	}
 28 | 
 29 | 	Logger::info("File: " + vmx.filename().string());
 30 | 	Patcher::patchSMC(vmx, false);
 31 | 
 32 | 	Logger::info("File: " + vmx_debug.filename().string());
 33 | 	Patcher::patchSMC(vmx_debug, false);
 34 | 
 35 | 	if (fs::exists(vmx_stats))
 36 | 	{
 37 | 		Logger::info("File: " + vmx_stats.filename().string());
 38 | 		Patcher::patchSMC(vmx_stats, false);
 39 | 	}
 40 | 
 41 | 	Logger::info("File: " + vmwarebase.filename().string());
 42 | 	Patcher::patchBase(vmwarebase);
 43 | }
 44 | 
 45 | void stopServices()
 46 | {
 47 | 	// Stop services
 48 | 	Logger::info("Stopping services...");
 49 | 	auto srvcList = std::list<std::string> VM_KILL_SERVICES;
 50 | 	for (auto service : srvcList)
 51 | 	{
 52 | 		try
 53 | 		{
 54 | 			ServiceStopper::StopService_s(service);
 55 | 			Logger::debug("Service \"" + service + "\" stopped successfully.");
 56 | 		}
 57 | 		catch (const ServiceStopper::ServiceStopException& ex)
 58 | 		{
 59 | 			// There is no need to inform the user that the service cannot be stopped if that service does not exist in the current version.
 60 | 			//logerr("Couldn't stop service \"" + service + "\", " + std::string(ex.what()));
 61 | 		}
 62 | 	}
 63 | 
 64 | 	auto procList = std::list<std::string> VM_KILL_PROCESSES;
 65 | 	for (auto process : procList)
 66 | 	{
 67 | 		try {
 68 | 			if (ServiceStopper::KillProcess(process))
 69 | 			{
 70 | 				Logger::debug("Process \"" + process + "\" killed successfully.");
 71 | 			}
 72 | 			else
 73 | 			{
 74 | 				Logger::error("Could not kill process \"" + process + "\".");
 75 | 			}
 76 | 		}
 77 | 		catch (const ServiceStopper::ServiceStopException& ex)
 78 | 		{
 79 | 			Logger::error(ex.what());
 80 | 		}
 81 | 	}
 82 | }
 83 | 
 84 | void restartServices()
 85 | {
 86 | 	Logger::info("Restarting services...");
 87 | 	std::vector<std::string> servicesToStart = VM_KILL_SERVICES;
 88 | 	for (auto it = servicesToStart.rbegin(); it != servicesToStart.rend(); it++)
 89 | 	{
 90 | 		try
 91 | 		{
 92 | 			ServiceStopper::StartService_s(*it);
 93 | 			Logger::debug("Service \"" + *it + "\" started successfully.");
 94 | 		}
 95 | 		catch (const ServiceStopper::ServiceStopException& ex)
 96 | 		{
 97 | 			// There is no need to inform the user that the service cannot be started if that service does not exist in the current version.
 98 | 			//logerr("Couldn't start service " + *it);
 99 | 		}
100 | 	}
101 | }
102 | 
103 | void preparePatchWin(fs::path backupPath, fs::path vmInstallPath)
104 | {
105 | 
106 | 	stopServices();
107 | 
108 | 	// Backup files
109 | 	auto filesToBackup = std::map<std::string, std::string> VM_WIN_BACKUP_FILES;
110 | 
111 | 	for (auto element : filesToBackup)
112 | 	{
113 | 		auto filen = element.first;
114 | 		fs::path fPath = vmInstallPath / filen;
115 | 		fs::path destpath = backupPath / element.second;
116 | 		if (!fs::exists(destpath))
117 | 		{
118 | 			fs::create_directory(destpath);
119 | 		}
120 | 
121 | 		try
122 | 		{
123 | 			if (fs::copy_file(fPath, destpath / fPath.filename(), fs::copy_options::overwrite_existing))
124 | 			{
125 | 				Logger::info("File \"" + fPath.string() + "\" backup done.");
126 | 			}
127 | 			else
128 | 			{
129 | 				Logger::error("File \"" + fPath.string() + "\" could not be copied for backup, patch uninstallation will not be possible.");
130 | 			}
131 | 		}
132 | 		catch (const std::exception& e)
133 | 		{
134 | 			Logger::error(std::string(e.what()) + ". Patch uninstallation will not be possible.");
135 | 		}
136 | 	}
137 | }
138 | 
139 | // Other methods
140 | 
141 | // Copy tools to VMWare directory
142 | void copyTools(fs::path toolspath, fs::path copyTo)
143 | {
144 | 	fs::path toolsfrom = toolspath;
145 | 
146 | 	try
147 | 	{
148 | 		if (fs::copy_file(toolsfrom / FUSION_ZIP_TOOLS_NAME, copyTo / FUSION_ZIP_TOOLS_NAME, fs::copy_options::overwrite_existing))
149 | 		{
150 | 			Logger::info("File \"" + (toolsfrom / FUSION_ZIP_TOOLS_NAME).string() + "\" copy done.");
151 | 		}
152 | 		else
153 | 		{
154 | 			Logger::error("File \"" + (toolsfrom / FUSION_ZIP_TOOLS_NAME).string() + "\" could not be copied.");
155 | 		}
156 | 	}
157 | 	catch (const std::exception& e)
158 | 	{
159 | 		Logger::error(e.what());
160 | 	}
161 | 
162 | 	try
163 | 	{
164 | 		if (fs::copy_file(toolsfrom / FUSION_ZIP_PRE15_TOOLS_NAME, copyTo / FUSION_ZIP_PRE15_TOOLS_NAME, fs::copy_options::overwrite_existing))
165 | 		{
166 | 			Logger::info("File \"" + (toolsfrom / FUSION_ZIP_PRE15_TOOLS_NAME).string() + "\" copy done.");
167 | 		}
168 | 		else
169 | 		{
170 | 			Logger::error("File \"" + (toolsfrom / FUSION_ZIP_PRE15_TOOLS_NAME).string() + "\" could not be copied.");
171 | 		}
172 | 	}
173 | 	catch (const std::exception& e)
174 | 	{
175 | 		Logger::error(e.what());
176 | 	}
177 | }
178 | 
179 | // Download tools into "path"
180 | bool downloadTools(fs::path path, std::function<void(double, double, double, double)> progressCallback)
181 | {
182 | 	Network network;
183 | 
184 | 	if (progressCallback != nullptr)
185 | 	{
186 | 		network.setProgressCallback(progressCallback);
187 | 	}
188 | 
189 | 	ToolsDownloader downloader(network);
190 | 
191 | 	bool success = downloader.download(path);
192 | 
193 | 	if (success) {
194 | 		Logger::info("Tools successfully downloaded!");
195 | 	}
196 | 	else {
197 | 		Logger::error("Couldn't find tools.");
198 | 	}
199 | 
200 | 	return success;
201 | }
202 | 


--------------------------------------------------------------------------------
/include/config.h:
--------------------------------------------------------------------------------
  1 | #ifndef CONFIG_H
  2 | #define CONFIG_H
  3 | 
  4 | /*
  5 | 	All the URLS, file names and patterns needed by the app
  6 | 	Grouped here to make it easy to fix something if they change some url or file names
  7 | */
  8 | 
  9 | // Program options
 10 | #define PROG_VERSION "v2.0.2"
 11 | 
 12 | // File used for checking if the patch has been applied
 13 | #define PATCH_VER_FILE ".unlocker"
 14 | #define LNX_PATCH_VER_PATH "/usr/lib/vmware"
 15 | 
 16 | // Log level
 17 | // 0 - none
 18 | // 1 - info (standard info, files being extracted, downloaded, etc.)
 19 | // 2 - debug (useful info for debugging the patch e.g. addresses, values)
 20 | // 3 - verbose (detailed info about the code)
 21 | #define LOGLEVEL 3
 22 | 
 23 | #define ARCH "x86_x64"
 24 | 
 25 | // Install - Default option
 26 | #define INSTALL_OPTION "--install" 
 27 | // Uninstall
 28 | #define UNINSTALL_OPTION "--uninstall"
 29 | // Only download tools
 30 | #define DOWNLOADONLY_OPTION "--download-tools"
 31 | // Show help message
 32 | #define HELP_OPTION "--help"
 33 | 
 34 | // Paths
 35 | #define TOOLS_DOWNLOAD_FOLDER "tools"
 36 | #define BACKUP_FOLDER "backup"
 37 | 
 38 | // DEPRECATED ----
 39 | // Base URL to parse for the tools
 40 | #define FUSION_BASE_URL "http://softwareupdate.vmware.com/cds/vmw-desktop/fusion/"
 41 | 
 42 | // Relative URLs and file names to be appended to version/build numbers
 43 | #define FUSION_DEF_CORE_LOC "/universal/core/com.vmware.fusion.zip.tar"
 44 | #define FUSION_DEF_CORE_NAME "com.vmware.fusion.zip.tar"
 45 | #define FUSION_DEF_CORE_NAME_ZIP "com.vmware.fusion.zip"
 46 | 
 47 | // Tools locations in the core TAR
 48 | #define FUSION_ZIP_TOOLS_ISO "payload/VMware Fusion.app/Contents/Library/isoimages/" ARCH "/darwin.iso"
 49 | #define FUSION_ZIP_TOOLS_NAME "darwin.iso"
 50 | 
 51 | #define FUSION_ZIP_PRE15_TOOLS_ISO "payload/VMware Fusion.app/Contents/Library/isoimages/" ARCH "/darwinPre15.iso"
 52 | #define FUSION_ZIP_PRE15_TOOLS_NAME "darwinPre15.iso"
 53 | // END DEPRECATED ----
 54 | 
 55 | #define TOOLS_DARWIN_URL "https://packages.vmware.com/tools/frozen/darwin/darwin.iso"
 56 | #define TOOLS_DARWIN_PRE15_URL "https://packages.vmware.com/tools/frozen/darwin/darwinPre15.iso"
 57 | 
 58 | #define TOOLS_DARWIN_NAME "darwin.iso"
 59 | #define TOOLS_DARWIN_PRE15_NAME "darwinPre15.iso"
 60 | 
 61 | // Pattern to parse the versions/builds
 62 | #define VERSION_REGEX_PATTERN "<li><a href=\"[^\"]+\">([^<]+)<\\/a><\\/li>"
 63 | 
 64 | // Windows registry configuration
 65 | #define HKEY_VMWARE HKEY_LOCAL_MACHINE
 66 | #define HKEY_SUBKEY_VMWARE "SOFTWARE\\Wow6432Node\\VMware, Inc.\\VMware Player"
 67 | #define HKEY_QUERY_VALUE_INSTALLPATH "InstallPath"
 68 | #define HKEY_QUERY_VALUE_INSTALLPATH64 "InstallPath64"
 69 | #define HKEY_QUERY_VALUE_PRODUCTVERSION "ProductVersion"
 70 | 
 71 | // Windows services to stop
 72 | #define VM_KILL_SERVICES {"vmware-view-usbd", "VMwareHostd", "VMAuthdService", "VMUSBArbService", "VMnetDHCP", "VMware NAT Service"}
 73 | #define VM_KILL_PROCESSES {"vmware-tray.exe"}
 74 | 
 75 | // Files to backup (win) { source, destination }
 76 | #define VM_WIN_BACKUP_FILES { \
 77 | 	{"x64\\vmware-vmx.exe", "x64"}, \
 78 | 	{"x64\\vmware-vmx-debug.exe", "x64"}, \
 79 | 	{"x64\\vmware-vmx-stats.exe", "x64"}, \
 80 | 	{"vmwarebase.dll", ""} \
 81 | 	}
 82 | 
 83 | // Files to backup (linux) { source, destination }
 84 | #define VM_LNX_BACKUP_FILES { \
 85 | 	"/usr/lib/vmware/bin/vmware-vmx", \
 86 | 	"/usr/lib/vmware/bin/vmware-vmx-debug", \
 87 | 	"/usr/lib/vmware/bin/vmware-vmx-stats", \
 88 | 	}
 89 | 
 90 | // Files to patch (have to keep the same order)
 91 | #define VM_WIN_PATCH_FILES { \
 92 | 	"vmware-vmx.exe", \
 93 | 	"vmware-vmx-debug.exe", \
 94 | 	"vmware-vmx-stats.exe", \
 95 | 	"vmwarebase.dll" \
 96 | 	}
 97 | 
 98 | // Linux paths and files
 99 | #define VM_LNX_PATH "/usr/lib/vmware/bin"
100 | #define VM_LNX_BINS { \
101 | 	"vmware-vmx", \
102 | 	"vmware-vmx-debug", \
103 | 	"vmware-vmx-stats", \
104 | 	}
105 | #define VM_LNX_LIB_CANDIDATES { \
106 | 	"/usr/lib/vmware/lib/libvmwarebase.so/libvmwarebase.so", \
107 | 	"/usr/lib/vmware/lib/libvmwarebase.so.0/libvmwarebase.so.0" \
108 | 	}
109 | #define VM_LNX_ISO_DESTPATH "/usr/lib/vmware/isoimages"
110 | 
111 | // Patch data
112 | #define SMC_HEADER_V0 "\xF2\x00\x00\x00\xF0\x00\x00\x00"
113 | #define SMC_HEADER_V0_SZ 8
114 | #define SMC_HEADER_V1 "\xB4\x01\x00\x00\xB0\x01\x00\x00"
115 | #define SMC_HEADER_V1_SZ 8
116 | #define KEY_KEY "\x59\x45\x4B\x23\x04\x32\x33\x69\x75"
117 | #define KEY_KEY_SZ 9
118 | #define ADR_KEY "\x72\x64\x41\x24\x04\x32\x33\x69\x75"
119 | #define ADR_KEY_SZ 9
120 | 
121 | #define DARWIN_REGEX "\\x10\\x00\\x00\\x00[\\x10|\\x20]\\x00\\x00\\x00[\\x01|\\x02]" \
122 | 					"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00" \
123 | 					"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00"
124 | 
125 | #define DARWIN_PATTERN_PERM_1 {'\x10', '\x00', '\x00', '\x00', '\x10', '\x00', '\x00', '\x00', '\x01', \
126 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',\
127 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', \
128 | 					}
129 | 
130 | #define DARWIN_PATTERN_PERM_2 {'\x10', '\x00', '\x00', '\x00', '\x20', '\x00', '\x00', '\x00', '\x01', \
131 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', \
132 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', \
133 | 					}
134 | 
135 | #define DARWIN_PATTERN_PERM_3 {'\x10', '\x00', '\x00', '\x00', '\x10', '\x00', '\x00', '\x00', '\x02', \
136 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', \
137 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', \
138 | 					}
139 | 
140 | #define DARWIN_PATTERN_PERM_4 {'\x10', '\x00', '\x00', '\x00', '\x20', '\x00', '\x00', '\x00', '\x02', \
141 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', \
142 | 					'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', \
143 | 					}
144 | 
145 | #define SMC_NEW_DATA "bheuneqjbexolgurfrjbeqfthneqrqcy"
146 | #define SMC_NEW_DATA2 "rnfrqbagfgrny(p)NccyrPbzchgreVap"
147 | 
148 | #define VMKCTL_FIND_STR "applesmc"
149 | #define VMKCTL_REPLACE_STR "vmkernel"
150 | 
151 | #endif // CONFIG_H
152 | 


--------------------------------------------------------------------------------
/tests/test_patch.cpp:
--------------------------------------------------------------------------------
  1 | 
  2 | /**
  3 |  * This test works by applying the patch to test files located in testing/orig directory.
  4 |  * The files are: vmwarebase.dll, vmware-vmx.exe, vmware-vmx-debug.exe
  5 |  * They are finally compared to the files in testing/good directory, which have to be patched
  6 |  * with a known working patch.
  7 |  * The files are not included for copyright reasons.
  8 |  */
  9 | 
 10 | #include "test.h"
 11 | #include "filesystem.hpp"
 12 | #include <iostream>
 13 | #include <string>
 14 | #include <fstream>
 15 | #include "filesystem.hpp"
 16 | #include "patcher.h"
 17 | #include "installinfo.h"
 18 | #include "tar.h"
 19 | #include "unlocker.h"
 20 | 
 21 | void test_tar();
 22 | void do_test_patch();
 23 | void test_failed(bool to_cleanup = true);
 24 | void test_equalness();
 25 | bool test_equal_file(fs::path file1, fs::path file2);
 26 | bool test_download_files();
 27 | void cleanup();
 28 | 
 29 | std::string basepath_str = "";
 30 | 
 31 | int main(int argc, char** argv)
 32 | {
 33 | 	//return test_download_files() ? 0 : 1;
 34 | 
 35 | 	if (argc > 1)
 36 | 	{
 37 | 		basepath_str = std::string(argv[1]);
 38 | 		test_info("Basepath for test files is: %s", argv[1]);
 39 | 	}
 40 | 	else {
 41 | 		std::string cwd = getCwd();
 42 | 		test_info("Basepath for test is the cwd: %s", cwd.c_str());
 43 | 	}
 44 | 
 45 | 	//test_tar();
 46 | 	do_test_patch();
 47 | 	test_equalness();
 48 | 	cleanup();
 49 | 
 50 | 	test_info("Done.");
 51 | 
 52 | 	return 0;
 53 | }
 54 | 
 55 | void test_tar()
 56 | {
 57 | 	Tar tarfile((fs::temp_directory_path() / "com.vmware.fusion.zip.tar").string());
 58 | 	tarfile.extract("com.vmware.fusion.zip", (fs::temp_directory_path() / "com.vmware.fusion.zip").string());
 59 | }
 60 | 
 61 | void do_test_patch()
 62 | {
 63 | 	BEGIN_TEST("the patch by comparing with a known working patch\n" \
 64 | 		"This test needs the following directories in the `testing` folder:\n" \
 65 | 		"\torig -> the original files\n" \
 66 | 		"\tgood -> the files patched with a known working patch\n" \
 67 | 		"In both folders the following files are needed (for Windows):\n" \
 68 | 		"\tvmwarebase.dll\n" \
 69 | 		"\tvmware-vmx.exe\n" \
 70 | 		"\tvmware-vmx-debug.exe");
 71 | 
 72 | #ifndef _WIN32
 73 | 	TEST_ERROR("This test is only for windows os");
 74 | #endif
 75 | 
 76 | 	fs::path basepath = ".";
 77 | 	if (basepath_str.length() > 0) {
 78 | 		basepath = basepath_str;
 79 | 	}
 80 | 
 81 | 	std::string binList[] = VM_WIN_PATCH_FILES;
 82 | 
 83 | 	fs::path orig_basedir = basepath / "testing" / "orig";
 84 | 	fs::path dest_basedir = basepath / "testing" / "dst";
 85 | 
 86 | 	test_info("Creating copies of test files into dst directory...");
 87 | 
 88 | 	// Copy original files to destination
 89 | 	for (const std::string& file : binList) {
 90 | 		// Skip this file as it's not provided in latest release
 91 | 		if (file != "vmware-vmx-stats.exe") {
 92 | 			try {
 93 | 				fs::copy_file(orig_basedir / file, dest_basedir / file, fs::copy_options::overwrite_existing);
 94 | 			}
 95 | 			catch (const std::exception& exc) {
 96 | 				test_error("Copy of file %s failed with error: %s", file.c_str(), exc.what());
 97 | 				test_failed(false);
 98 | 			}
 99 | 		}
100 | 	}
101 | 
102 | 	fs::path vmx = dest_basedir / binList[0];
103 | 	fs::path vmx_debug = dest_basedir / binList[1];
104 | 	//fs::path vmx_stats = vmx_path / binList[2];
105 | 	fs::path vmwarebase = dest_basedir / binList[3];
106 | 
107 | 	if (!fs::exists(vmx))
108 | 	{
109 | 		test_error("Vmx file not found");
110 | 		test_failed(false);
111 | 	}
112 | 	if (!fs::exists(vmx_debug))
113 | 	{
114 | 		test_error("Vmx-debug file not found");
115 | 		test_failed(false);
116 | 	}
117 | 	if (!fs::exists(vmwarebase))
118 | 	{
119 | 		test_error("vmwarebase.dll file not found\n");
120 | 		test_failed(false);
121 | 	}
122 | 
123 | 	test_info("File: %s", vmx.filename().string().c_str());
124 | 	Patcher::patchSMC(vmx, false);
125 | 
126 | 	test_info("File: %s", vmx_debug.filename().string().c_str());
127 | 	Patcher::patchSMC(vmx_debug, false);
128 | 
129 | 	test_info("File: %s", vmwarebase.filename().string().c_str());
130 | 	Patcher::patchBase(vmwarebase);
131 | }
132 | 
133 | void test_failed(bool to_cleanup)
134 | {
135 | 	if (to_cleanup)
136 | 		cleanup();
137 | 	exit(1);
138 | }
139 | 
140 | void test_equalness()
141 | {
142 | 	fs::path basepath = ".";
143 | 	if (basepath_str.length() > 0)
144 | 		basepath = basepath_str;
145 | 
146 | 	std::string binList[] = VM_WIN_PATCH_FILES;
147 | 
148 | 	fs::path dest_basedir = basepath / "testing" / "dst";
149 | 	fs::path good_basedir = basepath / "testing" / "good";
150 | 
151 | 	for (const std::string& file : binList) {
152 | 		// Skip this file as it's not provided in latest release
153 | 		if (file != "vmware-vmx-stats.exe") {
154 | 			if (!test_equal_file(dest_basedir / file, good_basedir / file)) {
155 | 				test_error("Test for file %s failed!", file.c_str());
156 | 				test_failed();
157 | 			}
158 | 			else {
159 | 				test_success("Test for file %s success!\n", file.c_str());
160 | 			}
161 | 		}
162 | 	}
163 | }
164 | 
165 | bool test_equal_file(fs::path file1, fs::path file2) {
166 | 	/*std::ifstream file1_i(file1, std::ios::binary);
167 | 	std::ifstream file2_i(file2, std::ios::binary);*/
168 | 	constexpr size_t FBUF_SIZE = 16 * 1024;
169 | 
170 | 	FILE* f1, * f2;
171 | 	f1 = fopen(file1.string().c_str(), "rb");
172 | 	f2 = fopen(file2.string().c_str(), "rb");
173 | 
174 | 	if (f1 == NULL || f2 == NULL) {
175 | 		return false;
176 | 	}
177 | 
178 | 	std::array<char, FBUF_SIZE> buffer1, buffer2;
179 | 	size_t read1, read2;
180 | 
181 | 	bool result = true;
182 | 
183 | 	while (!feof(f1) && !feof(f2)) {
184 | 		read1 = fread(buffer1.data(), 1, FBUF_SIZE, f1);
185 | 		read2 = fread(buffer2.data(), 1, FBUF_SIZE, f2);
186 | 
187 | 		if (read1 != read2 ||
188 | 			!std::equal(buffer1.begin(), buffer1.begin() + read1, buffer2.begin())) {
189 | 			result = false;
190 | 			break;
191 | 		}
192 | 	}
193 | 
194 | 	fclose(f1);
195 | 	fclose(f2);
196 | 	return result;
197 | }
198 | 
199 | bool test_download_files() {
200 | 	try {
201 | 		return downloadTools(fs::path("./tools"));
202 | 	}
203 | 	catch (const std::exception& exc) {
204 | 		fprintf(stderr, exc.what());
205 | 		return false;
206 | 	}
207 | }
208 | 
209 | void cleanup()
210 | {
211 | 	test_info("Cleaning up test files...");
212 | 
213 | 	fs::path basepath = ".";
214 | 	if (basepath_str.length() > 0)
215 | 		basepath = basepath_str;
216 | 
217 | 	std::string binList[] = VM_WIN_PATCH_FILES;
218 | 
219 | 	fs::path dest_basedir = basepath / "testing" / "dst";
220 | 
221 | 	for (const std::string& file : binList) {
222 | 		// Skip this file as it's not provided in latest release
223 | 		if (file != "vmware-vmx-stats.exe") {
224 | 			fs::remove(dest_basedir / file);
225 | 		}
226 | 	}
227 | }
228 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
  1 | cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
  2 | project (Unlocker)
  3 | 
  4 | set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/modules)
  5 | 
  6 | SET(UNLOCKER_STATIC_LIBS_WIN ON CACHE BOOL "Links statically") # Set to OFF for dynamic linking
  7 | 
  8 | IF (MSVC)
  9 | 	# prevent default manifest from being linked
 10 | 	set(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS} /MANIFEST:NO")
 11 | 	set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /MANIFEST:NO")
 12 | 	set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO")
 13 | ENDIF(MSVC)
 14 | 
 15 | find_package(ZLIB REQUIRED)
 16 | 
 17 | if(ZLIB_FOUND)
 18 | 	message (STATUS "ZLib found, version ${ZLIB_VERSION_STRING}")
 19 | endif()
 20 | 
 21 | 
 22 | find_package(CURL REQUIRED)
 23 | 
 24 | if(CURL_FOUND)
 25 | 	message (STATUS "Curl found, version ${CURL_VERSION_STRING}")
 26 | endif()
 27 | 
 28 | find_package(LibZip REQUIRED)
 29 | 
 30 | include_directories(${ZLIB_INCLUDE_DIRS})
 31 | include_directories(${CURL_INCLUDE_DIRS})
 32 | include_directories(${LIBZIP_INCLUDE_DIRS})
 33 | 
 34 | if(LIBZIP_FOUND)
 35 | 	message (STATUS "LibZip found")
 36 | endif()
 37 | 
 38 | # main include files
 39 | include_directories ("${PROJECT_SOURCE_DIR}/include")
 40 | 
 41 | # main source files
 42 | set (SOURCE_FILES /
 43 | 				src/versionparser.cpp /
 44 | 				src/buildsparser.cpp /
 45 | 				src/archive.cpp /
 46 | 				src/network.cpp /
 47 | 				src/debug.cpp /
 48 | 				src/installinfo.cpp /
 49 | 				src/patcher.cpp /
 50 | 				src/tar.cpp /
 51 | 				src/main.cpp /
 52 | 				src/ziparchive.cpp /
 53 | 				src/toolsdownloader.cpp /
 54 | 				src/logging/combinedlogstrategy.cpp /
 55 | 				src/logging/terminallogstrategy.cpp /
 56 | 				src/logging/streamlogstrategy.cpp /
 57 | 				src/logging/logstrategy.cpp /
 58 | 				src/patchversioner.cpp /
 59 | )
 60 | 
 61 | if(WIN32)
 62 | 	set (SOURCE_FILES ${SOURCE_FILES} /
 63 | 					src/unlocker_win.cpp /
 64 | 					src/winservices.cpp /
 65 | 					src/win32/mainwindow.cpp /
 66 | 					src/win32/controls/button.cpp /
 67 | 					src/win32/controls/editbox.cpp /
 68 | 					src/win32/controls/window.cpp /
 69 | 					src/win32/controls/control.cpp /
 70 | 					src/win32/controls/label.cpp /
 71 | 					src/win32/controls/progress.cpp /
 72 | 					src/win32/controls/groupbox.cpp /
 73 | 					src/win32/controls/checkbox.cpp /
 74 | 					src/win32/controls/statusbar.cpp /
 75 | 					src/win32/patchertask.cpp /
 76 | 					src/win32/unpatchertask.cpp /
 77 | 					src/win32/downloadtoolstask.cpp /
 78 | 					src/logging/statusbarlogstrategy.cpp /
 79 | 	)
 80 | else()
 81 | 	set (SOURCE_FILES ${SOURCE_FILES} /
 82 | 					src/unlocker_lnx.cpp /
 83 | 	)
 84 | endif()
 85 | 
 86 | IF (MSVC)
 87 | 	IF (UNLOCKER_STATIC_LIBS_WIN)
 88 | 		# Preprocessor definitions needed to avoid name mangling when statically importing libs on MSVC compiler
 89 | 		# Name mangling is needed if libraries are built dynamically with MSVC
 90 | 		# Should not be an issue with other compilers
 91 | 		add_compile_definitions( "CURL_STATICLIB" )
 92 | 	ENDIF()
 93 | ENDIF (MSVC)
 94 | 
 95 | if(WIN32)
 96 | 	add_executable(Unlocker WIN32 ${SOURCE_FILES})
 97 | else()
 98 | 	add_executable(Unlocker ${SOURCE_FILES})
 99 | endif()
100 | 
101 | # Support skipping file offsets when tar contains files larger than ~2 Gig
102 | target_compile_definitions(Unlocker PUBLIC _FILE_OFFSET_BITS=64)
103 | 
104 | set_target_properties(Unlocker PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS ON)
105 | 
106 | target_link_libraries (Unlocker ${ZLIB_LIBRARIES})
107 | target_link_libraries (Unlocker ${CURL_LIBRARIES})
108 | target_link_libraries (Unlocker ${LIBZIP_LIBRARY})
109 | 
110 | if(WIN32)
111 | 	target_link_libraries (Unlocker ws2_32 Wldap32 ComCtl32.lib Shlwapi.lib)
112 | endif()
113 | 
114 | # Amend manifest to tell Windows that the app needs admin privileges
115 | IF (MSVC)
116 | 	IF (CMAKE_MAJOR_VERSION LESS 3)
117 | 		MESSAGE(WARNING "CMake version 3.0 or newer is required use build variable TARGET_FILE")
118 | 	ELSE()
119 | 		ADD_CUSTOM_COMMAND(
120 | 			TARGET Unlocker
121 | 			POST_BUILD
122 | 			COMMAND "mt.exe" -manifest \"${PROJECT_SOURCE_DIR}/Unlocker.exe.manifest\" -outputresource:\"$<TARGET_FILE:Unlocker>\"\;\#1
123 | 			COMMENT "Embedding manifest..." 
124 | 		)
125 | 	ENDIF()
126 | ENDIF(MSVC)
127 | 
128 | # Main test
129 | # Tests need to be fixed to use the GUI-based functions
130 | #[[
131 | set (TEST_SOURCES tests/test_patch.cpp /
132 | 				src/debug.cpp /
133 | 				src/patcher.cpp /
134 | 				src/network.cpp /
135 | 				src/versionparser.cpp /
136 | 				src/buildsparser.cpp /
137 | 				src/archive.cpp /
138 | 				src/installinfo.cpp /
139 | 				src/winservices.cpp /
140 | 				src/tar.cpp /
141 | 				src/unlocker.cpp /
142 | 				src/ziparchive.cpp /
143 | 				src/toolsdownloader.cpp)
144 | 
145 | add_executable( TestPatch ${TEST_SOURCES})
146 | 
147 | target_compile_definitions(TestPatch PUBLIC _FILE_OFFSET_BITS=64)
148 | 
149 | include_directories(TestPatch ${ZLIB_INCLUDE_DIRS})
150 | include_directories(TestPatch ${CURL_INCLUDE_DIRS})
151 | include_directories(TestPatch ${LIBZIP_INCLUDE_DIRS})
152 | target_link_libraries (TestPatch ${ZLIB_LIBRARIES})
153 | target_link_libraries (TestPatch ${CURL_LIBRARIES})
154 | target_link_libraries (TestPatch ${LIBZIP_LIBRARY})
155 | 
156 | if(WIN32)
157 | 	target_link_libraries (TestPatch ws2_32 Wldap32)
158 | endif()
159 | 
160 | set_target_properties( TestPatch PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS ON)
161 | 
162 | enable_testing()
163 | add_test(NAME TestPatchTest COMMAND TestPatch "${PROJECT_SOURCE_DIR}")
164 | #]]
165 | 
166 | 
167 | # Tar test
168 | 
169 | set (TESTTAR_SOURCES tests/test_tar.cpp /
170 | 				src/debug.cpp /
171 | 				src/patcher.cpp /
172 | 				src/versionparser.cpp /
173 | 				src/buildsparser.cpp /
174 | 				src/archive.cpp /
175 | 				src/installinfo.cpp /
176 | 				src/network.cpp /
177 | 				src/tar.cpp /
178 | 				src/ziparchive.cpp)
179 | 
180 | add_executable( TestTar ${TESTTAR_SOURCES}  "include/unlocker_lnx.h")
181 | 
182 | target_compile_definitions(TestTar PUBLIC _FILE_OFFSET_BITS=64)
183 | 
184 | include_directories(TestTar ${ZLIB_INCLUDE_DIRS})
185 | include_directories(TestTar ${CURL_INCLUDE_DIRS})
186 | include_directories(TestTar ${LIBZIP_INCLUDE_DIRS})
187 | target_link_libraries (TestTar ${ZLIB_LIBRARIES})
188 | target_link_libraries (TestTar ${CURL_LIBRARIES})
189 | target_link_libraries (TestTar ${LIBZIP_LIBRARY})
190 | 
191 | if(WIN32)
192 | 	target_link_libraries (TestTar ws2_32 Wldap32)
193 | endif()
194 | 
195 | set_target_properties( TestTar PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS ON)
196 | 
197 | enable_testing()
198 | add_test(NAME TestTarTest COMMAND TestTar "${PROJECT_SOURCE_DIR}")
199 | 
200 | # Zip test
201 | 
202 | set (TESTZIP_SOURCES tests/test_zip.cpp /
203 | 				src/debug.cpp /
204 | 				src/patcher.cpp /
205 | 				src/versionparser.cpp /
206 | 				src/buildsparser.cpp /
207 | 				src/archive.cpp /
208 | 				src/installinfo.cpp /
209 | 				src/network.cpp /
210 | 				src/tar.cpp /
211 | 				src/ziparchive.cpp /
212 | 				src/toolsdownloader.cpp)
213 | 
214 | add_executable( TestZip ${TESTZIP_SOURCES}  "include/unlocker_lnx.h")
215 | 
216 | target_compile_definitions(TestZip PUBLIC _FILE_OFFSET_BITS=64)
217 | 
218 | include_directories(TestZip ${ZLIB_INCLUDE_DIRS})
219 | include_directories(TestZip ${CURL_INCLUDE_DIRS})
220 | include_directories(TestZip ${LIBZIP_INCLUDE_DIRS})
221 | target_link_libraries (TestZip ${ZLIB_LIBRARIES})
222 | target_link_libraries (TestZip ${CURL_LIBRARIES})
223 | target_link_libraries (TestZip ${LIBZIP_LIBRARY})
224 | 
225 | if(WIN32)
226 | 	target_link_libraries (TestZip ws2_32 Wldap32)
227 | endif()
228 | 
229 | set_target_properties( TestZip PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS ON)
230 | 
231 | enable_testing()
232 | add_test(NAME TestZipTest COMMAND TestZip "${PROJECT_SOURCE_DIR}")
233 | 


--------------------------------------------------------------------------------
/src/unlocker_lnx.cpp:
--------------------------------------------------------------------------------
  1 | #include "unlocker_lnx.h"
  2 | 
  3 | void installLnx()
  4 | {
  5 | 	PatchVersioner patchVersion(LNX_PATCH_VER_PATH);
  6 | 
  7 | 	if (patchVersion.hasPatch())
  8 | 	{
  9 | 		Logger::error("Patch is already installed. Uninstall it first before applying it again");
 10 | 		return;
 11 | 	}
 12 | 
 13 | 	// Default output path is ./tools/
 14 | 	fs::path toolsdirectory = fs::path(".") / TOOLS_DOWNLOAD_FOLDER;
 15 | 	// Default backup path is ./backup/
 16 | 	fs::path backup = fs::path(".") / BACKUP_FOLDER;
 17 | 
 18 | 	Logger::info("Killing services and backing up files...");
 19 | 	preparePatchLnx(backup);
 20 | 
 21 | 	Logger::info("Patching files...");
 22 | 
 23 | 	applyPatchLnx();
 24 | 
 25 | 	patchVersion.writePatchData();
 26 | 
 27 | 	Logger::verbose("Written version file at " + (fs::path(LNX_PATCH_VER_PATH) / PATCH_VER_FILE).string());
 28 | 
 29 | 	Logger::info("Downloading tools into \"" + toolsdirectory.string() + "\" directory...");
 30 | 
 31 | 	bool alreadyHasTools = fs::exists(fs::path(".") / TOOLS_DOWNLOAD_FOLDER / FUSION_ZIP_TOOLS_NAME) && fs::exists(fs::path(".") / TOOLS_DOWNLOAD_FOLDER / FUSION_ZIP_PRE15_TOOLS_NAME);
 32 | 
 33 | 	if (!alreadyHasTools)
 34 | 	{
 35 | 		downloadTools(toolsdirectory);
 36 | 	}
 37 | 	else {
 38 | 		Logger::info("Tools have been found in the `tools` folder. Using them...\n"
 39 | 			"Please check that the existing tools are working and are the most recent ones.");
 40 | 	}
 41 | 
 42 | 	Logger::info("Copying tools into program directory...");
 43 | 	copyTools(toolsdirectory);
 44 | 
 45 | 	Logger::info("Patch complete.");
 46 | }
 47 | 
 48 | void uninstallLnx()
 49 | {
 50 | 	PatchVersioner patchVersion(LNX_PATCH_VER_PATH);
 51 | 
 52 | 	if (!patchVersion.hasPatch())
 53 | 	{
 54 | 		Logger::error("Patch is not installed");
 55 | 		return;
 56 | 	}
 57 | 
 58 | 	// Default output path is ./tools/
 59 | 	fs::path toolsdirectory = fs::path(".") / TOOLS_DOWNLOAD_FOLDER;
 60 | 	// Default backup path is ./backup/
 61 | 	fs::path backup = fs::path(".") / BACKUP_FOLDER;
 62 | 
 63 | 	fs::path vmwareDir = VM_LNX_PATH;
 64 | 
 65 | 	Logger::info("Restoring files...");
 66 | 
 67 | 	// Copy contents of backup/
 68 | 	std::vector<std::string> lnxBins = VM_LNX_BINS;
 69 | 	for (const auto& file : lnxBins)
 70 | 	{
 71 | 		try
 72 | 		{
 73 | 			if (fs::copy_file(backup / file, vmwareDir / file, fs::copy_options::overwrite_existing))
 74 | 			{
 75 | 				Logger::info("File \"" + (backup / file).string() + "\" restored successfully");
 76 | 			}
 77 | 			else
 78 | 			{
 79 | 				Logger::error("Error while restoring \"" + (backup / file).string() + "\".");
 80 | 			}
 81 | 		}
 82 | 		catch (const fs::filesystem_error& ex)
 83 | 		{
 84 | 			Logger::error(ex.what());
 85 | 		}
 86 | 	}
 87 | 	std::vector<std::string> vmLibCandidates = VM_LNX_LIB_CANDIDATES;
 88 | 	for (const auto& lib : vmLibCandidates)
 89 | 	{
 90 | 		if (fs::exists(fs::path(lib).parent_path()))
 91 | 		{
 92 | 			try
 93 | 			{
 94 | 				if (fs::copy_file(backup / fs::path(lib).filename(), fs::path(lib), fs::copy_options::overwrite_existing))
 95 | 				{
 96 | 					Logger::info("File \"" + (backup / fs::path(lib).filename()).string() + "\" restored successfully");
 97 | 				}
 98 | 				else
 99 | 				{
100 | 					Logger::error("Error while restoring \"" + (backup / fs::path(lib).filename()).string() + "\".");
101 | 				}
102 | 			}
103 | 			catch (const fs::filesystem_error& ex)
104 | 			{
105 | 				Logger::error(ex.what());
106 | 			}
107 | 			break;
108 | 		}
109 | 	}
110 | 
111 | 	// Remove darwin*.* from InstallDir
112 | 	for (const auto& file : fs::directory_iterator(VM_LNX_ISO_DESTPATH))
113 | 	{
114 | 		if (fs::is_regular_file(file))
115 | 		{
116 | 			size_t is_drw = file.path().filename().string().find("darwin");
117 | 			if (is_drw != std::string::npos && is_drw == 0)
118 | 			{
119 | 				fs::remove(file);
120 | 			}
121 | 		}
122 | 	}
123 | 
124 | 	patchVersion.removePatchVersion();
125 | 	Logger::verbose("Removed version file from " + (fs::path(LNX_PATCH_VER_PATH) / PATCH_VER_FILE).string());
126 | 
127 | 	fs::remove_all(backup);
128 | 	fs::remove_all(toolsdirectory);
129 | 
130 | 	Logger::info("Uninstall complete.");
131 | }
132 | 
133 | void applyPatchLnx()
134 | {
135 | 	fs::path vmBinPath = VM_LNX_PATH;
136 | 
137 | 	std::string binList[] = VM_LNX_BINS;
138 | 
139 | 	fs::path vmx = vmBinPath / binList[0];
140 | 	fs::path vmx_debug = vmBinPath / binList[1];
141 | 	fs::path vmx_stats = vmBinPath / binList[2];
142 | 
143 | 	// See if first candidate is good else use second one
144 | 	std::string libCandidates[] = VM_LNX_LIB_CANDIDATES;
145 | 
146 | 	bool vmxso = true;
147 | 
148 | 	fs::path vmlib = libCandidates[0];
149 | 	if (!fs::exists(vmlib)) {
150 | 		vmlib = libCandidates[1];
151 | 		vmxso = false;
152 | 	}
153 | 
154 | 	if (!fs::exists(vmx))
155 | 	{
156 | 		throw std::runtime_error("Vmx file not found");
157 | 	}
158 | 	if (!fs::exists(vmx_debug))
159 | 	{
160 | 		throw std::runtime_error("Vmx-debug file not found");
161 | 	}
162 | 	if (!fs::exists(vmlib))
163 | 	{
164 | 		throw std::runtime_error("Vmlib file not found");
165 | 	}
166 | 
167 | 	Logger::info("File: " + vmx.filename().string());
168 | 	CHECKRES(Patcher::patchSMC(vmx, vmxso));
169 | 
170 | 	Logger::info("File: " + vmx_debug.filename().string());
171 | 	CHECKRES(Patcher::patchSMC(vmx_debug, vmxso));
172 | 
173 | 	if (fs::exists(vmx_stats))
174 | 	{
175 | 		Logger::info("File: " + vmx_stats.filename().string());
176 | 		CHECKRES(Patcher::patchSMC(vmx_stats, vmxso));
177 | 	}
178 | 
179 | 	Logger::info("File: " + vmlib.filename().string());
180 | 	CHECKRES(Patcher::patchBase(vmlib));
181 | }
182 | 
183 | void preparePatchLnx(fs::path backupPath)
184 | {
185 | 	// Backup files
186 | 	std::string filesToBackup[] = VM_LNX_BACKUP_FILES;
187 | 	fs::path destpath = backupPath;
188 | 
189 | 	for (auto element : filesToBackup)
190 | 	{
191 | 		fs::path fPath = element;
192 | 		if (!fs::exists(destpath))
193 | 			fs::create_directory(destpath);
194 | 
195 | 		try
196 | 		{
197 | 			if (fs::copy_file(fPath, destpath / fPath.filename(), fs::copy_options::overwrite_existing))
198 | 			{
199 | 				Logger::info("File \"" + fPath.string() + "\" backup done.");
200 | 			}
201 | 			else
202 | 			{
203 | 				Logger::error("File \"" + fPath.string() + "\" could not be copied.");
204 | 			}
205 | 		}
206 | 		catch (const std::exception& e)
207 | 		{
208 | 			Logger::error(e.what());
209 | 		}
210 | 	}
211 | 
212 | 	std::string libsAlternatives[] = VM_LNX_LIB_CANDIDATES;
213 | 
214 | 	for (auto lib : libsAlternatives)
215 | 	{
216 | 		fs::path libpath = lib;
217 | 		if (fs::exists(libpath.parent_path()))
218 | 		{
219 | 			try
220 | 			{
221 | 				if (fs::copy_file(libpath, destpath / libpath.filename(), fs::copy_options::overwrite_existing))
222 | 				{
223 | 					Logger::info("File \"" + libpath.string() + "\" backup done.");
224 | 				}
225 | 				else
226 | 				{
227 | 					Logger::error("File \"" + libpath.string() + "\" could not be copied.");
228 | 				}
229 | 
230 | 				break;
231 | 			}
232 | 			catch (const std::exception& e)
233 | 			{
234 | 				Logger::error(e.what());
235 | 			}
236 | 		}
237 | 	}
238 | }
239 | 
240 | // Other methods
241 | 
242 | // Copy tools to VMWare directory
243 | void copyTools(fs::path toolspath)
244 | {
245 | 	fs::path toolsfrom = toolspath;
246 | 	fs::path copyto = VM_LNX_ISO_DESTPATH;
247 | 
248 | 	try
249 | 	{
250 | 		if (fs::copy_file(toolsfrom / FUSION_ZIP_TOOLS_NAME, copyto / FUSION_ZIP_TOOLS_NAME, fs::copy_options::overwrite_existing))
251 | 		{
252 | 			Logger::info("File \"" + (toolsfrom / FUSION_ZIP_TOOLS_NAME).string() + "\" copy done.");
253 | 		}
254 | 		else
255 | 		{
256 | 			Logger::error("File \"" + (toolsfrom / FUSION_ZIP_TOOLS_NAME).string() + "\" could not be copied.");
257 | 		}
258 | 	}
259 | 	catch (const std::exception& e)
260 | 	{
261 | 		Logger::error(e.what());
262 | 	}
263 | 
264 | 	try
265 | 	{
266 | 		if (fs::copy_file(toolsfrom / FUSION_ZIP_PRE15_TOOLS_NAME, copyto / FUSION_ZIP_PRE15_TOOLS_NAME, fs::copy_options::overwrite_existing))
267 | 		{
268 | 			Logger::info("File \"" + (toolsfrom / FUSION_ZIP_PRE15_TOOLS_NAME).string() + "\" copy done.");
269 | 		}
270 | 		else
271 | 		{
272 | 			Logger::error("File \"" + (toolsfrom / FUSION_ZIP_PRE15_TOOLS_NAME).string() + "\" could not be copied.");
273 | 		}
274 | 	}
275 | 	catch (const std::exception& e)
276 | 	{
277 | 		Logger::error(e.what());
278 | 	}
279 | }
280 | 
281 | 
282 | // Download tools into "path"
283 | bool downloadTools(fs::path path)
284 | {
285 | 	Network network;
286 | 
287 | 	ToolsDownloader downloader(network);
288 | 
289 | 	bool success = downloader.download(path);
290 | 
291 | 	if (success) {
292 | 		Logger::info("Tools successfully downloaded!");
293 | 	}
294 | 	else {
295 | 		Logger::error("Couldn't find tools.");
296 | 	}
297 | 
298 | 	return success;
299 | }
300 | 


--------------------------------------------------------------------------------
/src/win32/mainwindow.cpp:
--------------------------------------------------------------------------------
  1 | #include "win32/mainwindow.h"
  2 | 
  3 | void MainWindow::onCreate(HWND hWnd)
  4 | {
  5 | 	std::string installPath = "",
  6 | 		installPathX64 = "";
  7 | 
  8 | 	try {
  9 | 		VMWareInfoRetriever vmwareInfo;
 10 | 		installPath = vmwareInfo.getInstallPath();
 11 | 		installPathX64 = vmwareInfo.getInstallPath64();
 12 | 	} catch(const std::exception& exc)
 13 | 	{ }
 14 | 
 15 | 	char backupPath[MAX_PATH], toolsPath[MAX_PATH];
 16 | 	GetCurrentDirectory(MAX_PATH, backupPath);
 17 | 	strcpy(toolsPath, backupPath);
 18 | 	PathAppend(toolsPath, "tools");
 19 | 	std::string toolsDefLoc(toolsPath);
 20 | 
 21 | 	PathAppend(backupPath, "backup");
 22 | 	DWORD dwBackupFolderAttrs = GetFileAttributes(backupPath);
 23 | 	bool backupExists = (dwBackupFolderAttrs != INVALID_FILE_ATTRIBUTES) && (dwBackupFolderAttrs & FILE_ATTRIBUTE_DIRECTORY);
 24 | 
 25 | 	// Add controls to the window
 26 | 	browseLabel = std::make_unique<Label>(hWnd, NULL, "VMWare install location", 10, 10, 430, 15);
 27 | 	pathEditBox = std::make_unique<EditBox>(hWnd, IDC_PATH_EDITBOX, installPath.c_str(), 10, 35, 300, 30);
 28 | 	browseButton = std::make_unique<Button>(hWnd, IDC_PATH_BROWSEBTN, "Browse", 320, 35, 100, 30);
 29 | 	browseLabelX64 = std::make_unique<Label>(hWnd, NULL, "VMWare X64 location", 10, 75, 430, 15);
 30 | 	pathEditBoxX64 = std::make_unique<EditBox>(hWnd, IDC_PATH_EDITBOXX64, installPathX64.c_str(), 10, 100, 300, 30);
 31 | 	browseButtonX64 = std::make_unique<Button>(hWnd, IDC_PATH_BROWSEBTNX64, "Browse", 320, 100, 100, 30);
 32 | 	toolsGroup = std::make_unique<GroupBox>(hWnd, "Tools", 10, 140, 410, 135);
 33 | 	downloadToolsChk = std::make_unique<CheckBox>(hWnd, IDC_DOWNLOADTOOLS_CHECKBOX, "Download tools", 20, 160, 400, 30);
 34 | 	toolsPathLabel = std::make_unique<Label>(hWnd, NULL, "Existing tools location:", 20, 200, 400, 15);
 35 | 	toolsPathEditBox = std::make_unique<EditBox>(hWnd, IDC_TOOLSPATH_EDITBOX, toolsDefLoc.c_str(), 20, 225, 255, 30);
 36 | 	toolsBrowseBtn = std::make_unique<Button>(hWnd, IDC_TOOLSPATH_BROWSE_BTN, "Browse", 280, 225, 60, 30);
 37 | 	downloadToolsBtn = std::make_unique<Button>(hWnd, IDC_TOOLS_DOWNLOAD_BTN, "Download", 340, 225, 70, 30);
 38 | 	patchBtn = std::make_unique<Button>(hWnd, IDC_PATCH_BTN, "Patch", 10, 285, 100, 30);
 39 | 	revertPatchBtn = std::make_unique<Button>(hWnd, IDC_REVERT_PATCH_BTN, "Uninstall patch", 115, 285, 100, 30);
 40 | 	progressBar = std::make_unique<Progress>(hWnd, IDC_PROGRESSBAR, 10, 325, 410, 25);
 41 | 	statusBar = std::make_unique<StatusBar>(hWnd, IDC_STATUSBAR, "Auto-Unlocker " PROG_VERSION);
 42 | 
 43 | 	// Initial controls setup
 44 | 	pathEditBox->setReadOnly(true);
 45 | 	pathEditBoxX64->setReadOnly(true);
 46 | 	toolsPathEditBox->setReadOnly(true);
 47 | 	downloadToolsChk->set(true);
 48 | 	toolsPathEditBox->setEnabled(false);
 49 | 	revertPatchBtn->setEnabled(backupExists);
 50 | 	progressBar->setRange(100);
 51 | 	progressBar->setProgress(0);
 52 | 
 53 | 	// Add listeners
 54 | 	browseButton->addEventListener(EventType::CLICK_EVENT, std::bind(&MainWindow::browseButtonClick, this));
 55 | 	browseButtonX64->addEventListener(EventType::CLICK_EVENT, std::bind(&MainWindow::browseX64ButtonClick, this));
 56 | 	downloadToolsChk->addEventListener(EventType::CLICK_EVENT, std::bind(&MainWindow::downloadToolsChkClick, this));
 57 | 	toolsBrowseBtn->addEventListener(EventType::CLICK_EVENT, std::bind(&MainWindow::toolsBrowseButtonClick, this));
 58 | 	patchBtn->addEventListener(EventType::CLICK_EVENT, std::bind(&MainWindow::patchBtnClick, this));
 59 | 	revertPatchBtn->addEventListener(EventType::CLICK_EVENT, std::bind(&MainWindow::revertPatchBtnClick, this));
 60 | 	downloadToolsBtn->addEventListener(EventType::CLICK_EVENT, std::bind(&MainWindow::downloadToolsBtnClick, this));
 61 | 
 62 | 	// Register controls for events dispatch
 63 | 	registerControl(IDC_BROWSELABEL, browseLabel.get());
 64 | 	registerControl(IDC_PATH_EDITBOX, pathEditBox.get());
 65 | 	registerControl(IDC_PATH_BROWSEBTN, browseButton.get());
 66 | 	registerControl(IDC_BROWSELABEL_X64, browseLabelX64.get());
 67 | 	registerControl(IDC_PATH_EDITBOXX64, pathEditBoxX64.get());
 68 | 	registerControl(IDC_PATH_BROWSEBTNX64, browseButtonX64.get());
 69 | 	registerControl(IDC_TOOLS_GROUPBOX, toolsGroup.get());
 70 | 	registerControl(IDC_DOWNLOADTOOLS_CHECKBOX, downloadToolsChk.get());
 71 | 	registerControl(IDC_TOOLSPATH_EDITBOX, toolsPathEditBox.get());
 72 | 	registerControl(IDC_TOOLSPATH_BROWSE_BTN, toolsBrowseBtn.get());
 73 | 	registerControl(IDC_PATCH_BTN, patchBtn.get());
 74 | 	registerControl(IDC_REVERT_PATCH_BTN, revertPatchBtn.get());
 75 | 	registerControl(IDC_TOOLS_DOWNLOAD_BTN, downloadToolsBtn.get());
 76 | }
 77 | 
 78 | void MainWindow::browseButtonClick()
 79 | {
 80 | 	char path[MAX_PATH];
 81 | 	BROWSEINFO bInfo = {};
 82 | 	bInfo.lpszTitle = "Select the VMWare install directory";
 83 | 	bInfo.hwndOwner = hWnd;
 84 | 	LPITEMIDLIST pIdl = SHBrowseForFolder(&bInfo);
 85 | 
 86 | 	if (pIdl != 0) {
 87 | 		SHGetPathFromIDList(pIdl, path);
 88 | 		pathEditBox->setText(std::string(path));
 89 | 	}
 90 | }
 91 | 
 92 | void MainWindow::browseX64ButtonClick()
 93 | {
 94 | 	char path[MAX_PATH];
 95 | 	BROWSEINFO bInfo = {};
 96 | 	bInfo.lpszTitle = "Select the VMWare x64 install directory";
 97 | 	bInfo.hwndOwner = hWnd;
 98 | 	LPITEMIDLIST pIdl = SHBrowseForFolder(&bInfo);
 99 | 
100 | 	if (pIdl != 0) {
101 | 		SHGetPathFromIDList(pIdl, path);
102 | 		pathEditBoxX64->setText(std::string(path));
103 | 	}
104 | }
105 | 
106 | void MainWindow::toolsBrowseButtonClick()
107 | {
108 | 	char path[MAX_PATH];
109 | 	BROWSEINFO bInfo = {};
110 | 	bInfo.lpszTitle = "Select the tools folder (or where you want to download them)";
111 | 	bInfo.hwndOwner = hWnd;
112 | 	LPITEMIDLIST pIdl = SHBrowseForFolder(&bInfo);
113 | 
114 | 	if (pIdl != 0) {
115 | 		SHGetPathFromIDList(pIdl, path);
116 | 		toolsPathEditBox->setText(std::string(path));
117 | 	}
118 | }
119 | 
120 | void MainWindow::downloadToolsChkClick()
121 | {
122 | 	bool isChecked = downloadToolsChk->isChecked();
123 | 
124 | 	toolsPathEditBox->setEnabled(!isChecked);
125 | }
126 | 
127 | void MainWindow::patchBtnClick()
128 | {
129 | 	disableAllInput();
130 | 
131 | 	patcherTask = new PatcherTask(*this);
132 | 
133 | 	patcherTask->setOnProgressCallback(std::bind(&MainWindow::patchProgress, this, std::placeholders::_1));
134 | 	patcherTask->setOnCompleteCallback(std::bind(&MainWindow::patchComplete, this, std::placeholders::_1));
135 | 
136 | 	patcherTask->run(nullptr);
137 | }
138 | 
139 | void MainWindow::revertPatchBtnClick()
140 | {
141 | 	disableAllInput();
142 | 
143 | 	unpatcherTask = new UnpatcherTask(*this);
144 | 
145 | 	unpatcherTask->setOnProgressCallback(std::bind(&MainWindow::patchProgress, this, std::placeholders::_1));
146 | 	unpatcherTask->setOnCompleteCallback(std::bind(&MainWindow::unpatchComplete, this, std::placeholders::_1));
147 | 
148 | 	unpatcherTask->run(nullptr);
149 | }
150 | 
151 | void MainWindow::downloadToolsBtnClick()
152 | {
153 | 	disableAllInput();
154 | 	
155 | 	downloadToolsTask = new DownloadToolsTask(*this);
156 | 
157 | 	downloadToolsTask->setOnProgressCallback(std::bind(&MainWindow::patchProgress, this, std::placeholders::_1));
158 | 	downloadToolsTask->setOnCompleteCallback(std::bind(&MainWindow::toolsDownloadComplete, this, std::placeholders::_1));
159 | 
160 | 	downloadToolsTask->run(nullptr);
161 | }
162 | 
163 | void MainWindow::disableAllInput()
164 | {
165 | 	dlgState.pathBrowseEnabled = browseButton->isEnabled();
166 | 	browseButton->setEnabled(false);
167 | 	dlgState.pathEnabled = pathEditBox->isEnabled();
168 | 	pathEditBox->setEnabled(false);
169 | 	dlgState.path64BrowseEnabled = browseButtonX64->isEnabled();
170 | 	browseButtonX64->setEnabled(false);
171 | 	dlgState.path64Enabled = pathEditBoxX64->isEnabled();
172 | 	pathEditBoxX64->setEnabled(false);
173 | 	dlgState.downloadToolsChecked = downloadToolsChk->isChecked();
174 | 	dlgState.downloadToolsEnabled = downloadToolsChk->isEnabled();
175 | 	downloadToolsChk->setEnabled(false);
176 | 	dlgState.toolsPathEnabled = toolsPathEditBox->isEnabled();
177 | 	toolsPathEditBox->setEnabled(false);
178 | 	dlgState.toolsBrowseEnabled = toolsBrowseBtn->isEnabled();
179 | 	toolsBrowseBtn->setEnabled(false);
180 | 	dlgState.downloadToolsBtnEnabled = downloadToolsBtn->isEnabled();
181 | 	downloadToolsBtn->setEnabled(false);
182 | 	dlgState.patchEnabled = patchBtn->isEnabled();
183 | 	patchBtn->setEnabled(false);
184 | 	dlgState.unpatchEnabled = revertPatchBtn->isEnabled();
185 | 	revertPatchBtn->setEnabled(false);
186 | }
187 | 
188 | void MainWindow::restoreInput()
189 | {
190 | 	browseButton->setEnabled(dlgState.pathBrowseEnabled);
191 | 	pathEditBox->setEnabled(dlgState.pathEnabled);
192 | 	browseButtonX64->setEnabled(dlgState.path64BrowseEnabled);
193 | 	pathEditBoxX64->setEnabled(dlgState.path64Enabled);
194 | 	downloadToolsChk->set(dlgState.downloadToolsChecked);
195 | 	downloadToolsChk->setEnabled(dlgState.downloadToolsEnabled);
196 | 	toolsPathEditBox->setEnabled(dlgState.toolsPathEnabled);
197 | 	toolsBrowseBtn->setEnabled(dlgState.toolsBrowseEnabled);
198 | 	downloadToolsBtn->setEnabled(dlgState.downloadToolsBtnEnabled);
199 | 	patchBtn->setEnabled(dlgState.patchEnabled);
200 | 	revertPatchBtn->setEnabled(dlgState.unpatchEnabled);
201 | 
202 | 	progressBar->setProgress(0);
203 | }
204 | 
205 | void MainWindow::patchComplete(PatchResult result)
206 | {
207 | 	if (result.result) {
208 | 		char msg[4096];
209 | 		sprintf(msg, "The patch has been installed successfully. Refer to the log file for detailed info:\n%s", result.logFilePath.c_str());
210 | 		MessageBox(hWnd, msg,
211 | 			"Success", MB_OK | MB_ICONINFORMATION);
212 | 	}
213 | 	else {
214 | 		char msg[4096];
215 | 		sprintf(msg, "An error occurred while applying the patch:\n%s\nCheck the log file for detailed info:\n%s", result.errorMessage.c_str(), result.logFilePath.c_str());
216 | 		MessageBox(hWnd, msg, "Error", MB_OK | MB_ICONERROR);
217 | 	}
218 | 
219 | 	if (patcherTask != nullptr)
220 | 	{
221 | 		delete patcherTask;
222 | 		patcherTask = nullptr;
223 | 	}
224 | 
225 | 	restoreInput();
226 | }
227 | 
228 | void MainWindow::unpatchComplete(PatchResult result)
229 | {
230 | 	if (result.result) {
231 | 		char msg[4096];
232 | 		sprintf(msg, "The patch has been uninstalled successfully. Refer to the log file for detailed info:\n%s", result.logFilePath.c_str());
233 | 		MessageBox(hWnd, msg,
234 | 			"Success", MB_OK | MB_ICONINFORMATION);
235 | 	}
236 | 	else {
237 | 		char msg[4096];
238 | 		sprintf(msg, "An error occurred while uninstalling the patch:\n%s\nCheck the log file for detailed info:\n%s", result.errorMessage.c_str(), result.logFilePath.c_str());
239 | 		MessageBox(hWnd, msg, "Error", MB_OK | MB_ICONERROR);
240 | 	}
241 | 
242 | 	if (unpatcherTask != nullptr)
243 | 	{
244 | 		delete unpatcherTask;
245 | 		unpatcherTask = nullptr;
246 | 	}
247 | 
248 | 	restoreInput();
249 | }
250 | 
251 | void MainWindow::toolsDownloadComplete(PatchResult result)
252 | {
253 | 	if (result.result) {
254 | 		char msg[4096];
255 | 		sprintf(msg, "The tools have been downloaded successfully. Refer to the log file for detailed info:\n%s", result.logFilePath.c_str());
256 | 		MessageBox(hWnd, msg,
257 | 			"Success", MB_OK | MB_ICONINFORMATION);
258 | 	}
259 | 	else {
260 | 		char msg[4096];
261 | 		sprintf(msg, "An error occurred while downloading the tools:\n%s\nCheck the log file for detailed info:\n%s", result.errorMessage.c_str(), result.logFilePath.c_str());
262 | 		MessageBox(hWnd, msg, "Error", MB_OK | MB_ICONERROR);
263 | 	}
264 | 
265 | 	if (downloadToolsTask != nullptr)
266 | 	{
267 | 		delete downloadToolsTask;
268 | 		downloadToolsTask = nullptr;
269 | 	}
270 | 
271 | 	restoreInput();
272 | }
273 | 
274 | void MainWindow::patchProgress(float progress)
275 | {
276 | 	progressBar->setProgress((int)(progress * 100));
277 | }
278 | 
279 | MainWindow::MainWindow(HINSTANCE hInstance, int nCmdShow)
280 | 	: Window(hInstance, nCmdShow, "auto-unlocker-mainwindow", "Auto-Unlocker " PROG_VERSION, CW_USEDEFAULT, CW_USEDEFAULT, 450, 420)
281 | {
282 | }
283 | 
284 | MainWindow::~MainWindow()
285 | {
286 | }
287 | 


--------------------------------------------------------------------------------
/src/winservices.cpp:
--------------------------------------------------------------------------------
  1 | #include "winservices.h"
  2 | 
  3 | #ifdef _WIN32
  4 | #include <process.h>
  5 | #include <Tlhelp32.h>
  6 | #include <winbase.h>
  7 | #endif
  8 | 
  9 | void ServiceStopper::StopService_s(std::string serviceName)
 10 | {
 11 | 	SERVICE_STATUS_PROCESS ssp;
 12 | 	ULONGLONG dwStartTime = GetTickCount64();
 13 | 	DWORD dwBytesNeeded;
 14 | 	ULONGLONG dwTimeout = 10000; // 30-second time-out
 15 | 	DWORD dwWaitTime;
 16 | 
 17 | 	// Get a handle to the SCM database. 
 18 | 
 19 | 	SC_HANDLE schSCManager = OpenSCManager(
 20 | 		NULL,                    // local computer
 21 | 		NULL,                    // ServicesActive database 
 22 | 		SC_MANAGER_ALL_ACCESS);  // full access rights 
 23 | 
 24 | 	if (NULL == schSCManager)
 25 | 	{
 26 | 		throw ServiceStopException("OpenSCManager failed (%d)", GetLastError());
 27 | 		return;
 28 | 	}
 29 | 
 30 | 	// Get a handle to the service.
 31 | 
 32 | 	SC_HANDLE schService = OpenService(
 33 | 		schSCManager,         // SCM database 
 34 | 		serviceName.c_str(),            // name of service 
 35 | 		SERVICE_STOP |
 36 | 		SERVICE_QUERY_STATUS |
 37 | 		SERVICE_ENUMERATE_DEPENDENTS);
 38 | 
 39 | 	if (schService == NULL)
 40 | 	{
 41 | 		CloseServiceHandle(schSCManager);
 42 | 		throw ServiceStopException("OpenService failed (%d)", GetLastError());
 43 | 		return;
 44 | 	}
 45 | 
 46 | 	// Make sure the service is not already stopped.
 47 | 
 48 | 	if (!QueryServiceStatusEx(
 49 | 		schService,
 50 | 		SC_STATUS_PROCESS_INFO,
 51 | 		(LPBYTE)&ssp,
 52 | 		sizeof(SERVICE_STATUS_PROCESS),
 53 | 		&dwBytesNeeded))
 54 | 	{
 55 | 		CloseServiceHandle(schService);
 56 | 		CloseServiceHandle(schSCManager);
 57 | 		throw ServiceStopException("QueryServiceStatusEx failed (%d)", GetLastError());
 58 | 	}
 59 | 
 60 | 	if (ssp.dwCurrentState == SERVICE_STOPPED)
 61 | 	{
 62 | 		CloseServiceHandle(schService);
 63 | 		CloseServiceHandle(schSCManager);
 64 | 		throw ServiceStopException("Service is already stopped.");
 65 | 	}
 66 | 
 67 | 	// If a stop is pending, wait for it.
 68 | 
 69 | 	while (ssp.dwCurrentState == SERVICE_STOP_PENDING)
 70 | 	{
 71 | 		// Do not wait longer than the wait hint. A good interval is 
 72 | 		// one-tenth of the wait hint but not less than 1 second  
 73 | 		// and not more than 10 seconds. 
 74 | 
 75 | 		dwWaitTime = ssp.dwWaitHint / 10;
 76 | 
 77 | 		if (dwWaitTime < 1000)
 78 | 			dwWaitTime = 1000;
 79 | 		else if (dwWaitTime > 10000)
 80 | 			dwWaitTime = 10000;
 81 | 
 82 | 		Sleep(dwWaitTime);
 83 | 
 84 | 		if (!QueryServiceStatusEx(
 85 | 			schService,
 86 | 			SC_STATUS_PROCESS_INFO,
 87 | 			(LPBYTE)&ssp,
 88 | 			sizeof(SERVICE_STATUS_PROCESS),
 89 | 			&dwBytesNeeded))
 90 | 		{
 91 | 			CloseServiceHandle(schService);
 92 | 			CloseServiceHandle(schSCManager);
 93 | 			throw ServiceStopException("QueryServiceStatusEx failed (%d)", GetLastError());
 94 | 		}
 95 | 
 96 | 		if (ssp.dwCurrentState == SERVICE_STOPPED)
 97 | 		{
 98 | 			CloseServiceHandle(schService);
 99 | 			CloseServiceHandle(schSCManager);
100 | 			throw ServiceStopException("Service stopped successfully.");
101 | 		}
102 | 
103 | 		if (GetTickCount64() - dwStartTime > dwTimeout)
104 | 		{
105 | 			CloseServiceHandle(schService);
106 | 			CloseServiceHandle(schSCManager);
107 | 			throw ServiceStopException("Service stop timed out.");
108 | 		}
109 | 	}
110 | 
111 | 	// If the service is running, dependencies must be stopped first.
112 | 
113 | 	StopDependantServices(schService, schSCManager);
114 | 
115 | 	// Send a stop code to the service.
116 | 
117 | 	if (!ControlService(
118 | 		schService,
119 | 		SERVICE_CONTROL_STOP,
120 | 		(LPSERVICE_STATUS)&ssp))
121 | 	{
122 | 		CloseServiceHandle(schService);
123 | 		CloseServiceHandle(schSCManager);
124 | 		throw ServiceStopException("ControlService failed (%d)", GetLastError());
125 | 	}
126 | 
127 | 	// Wait for the service to stop.
128 | 
129 | 	while (ssp.dwCurrentState != SERVICE_STOPPED)
130 | 	{
131 | 		Sleep(ssp.dwWaitHint);
132 | 		if (!QueryServiceStatusEx(
133 | 			schService,
134 | 			SC_STATUS_PROCESS_INFO,
135 | 			(LPBYTE)&ssp,
136 | 			sizeof(SERVICE_STATUS_PROCESS),
137 | 			&dwBytesNeeded))
138 | 		{
139 | 			CloseServiceHandle(schService);
140 | 			CloseServiceHandle(schSCManager);
141 | 			throw ServiceStopException("QueryServiceStatusEx failed (%d)", GetLastError());
142 | 		}
143 | 
144 | 		if (ssp.dwCurrentState == SERVICE_STOPPED)
145 | 			break;
146 | 
147 | 		if (GetTickCount64() - dwStartTime > dwTimeout)
148 | 		{
149 | 			CloseServiceHandle(schService);
150 | 			CloseServiceHandle(schSCManager);
151 | 			throw ServiceStopException("Wait timed out");
152 | 		}
153 | 	}
154 | 
155 | 	CloseServiceHandle(schService);
156 | 	CloseServiceHandle(schSCManager);
157 | }
158 | 
159 | bool ServiceStopper::StopDependantServices(SC_HANDLE schService, SC_HANDLE schSCManager)
160 | {
161 | 	DWORD i;
162 | 	DWORD dwBytesNeeded;
163 | 	DWORD dwCount;
164 | 
165 | 	LPENUM_SERVICE_STATUS   lpDependencies = NULL;
166 | 	ENUM_SERVICE_STATUS     ess;
167 | 	SC_HANDLE               hDepService;
168 | 	SERVICE_STATUS_PROCESS  ssp;
169 | 
170 | 	ULONGLONG dwStartTime = GetTickCount64();
171 | 	ULONGLONG dwTimeout = 10000; // 10-second time-out
172 | 
173 | 	bool success = true;
174 | 
175 | 	// Pass a zero-length buffer to get the required buffer size.
176 | 	if (EnumDependentServices(schService, SERVICE_ACTIVE,
177 | 		lpDependencies, 0, &dwBytesNeeded, &dwCount))
178 | 	{
179 | 		// If the Enum call succeeds, then there are no dependent
180 | 		// services, so do nothing.
181 | 		return success;
182 | 	}
183 | 	else
184 | 	{
185 | 		if (GetLastError() != ERROR_MORE_DATA)
186 | 			return false; // Unexpected error
187 | 
188 | 		// Allocate a buffer for the dependencies.
189 | 		lpDependencies = (LPENUM_SERVICE_STATUS)HeapAlloc(
190 | 			GetProcessHeap(), HEAP_ZERO_MEMORY, dwBytesNeeded);
191 | 
192 | 		if (!lpDependencies)
193 | 			return false;
194 | 
195 | 		__try {
196 | 			// Enumerate the dependencies.
197 | 			if (!EnumDependentServices(schService, SERVICE_ACTIVE,
198 | 				lpDependencies, dwBytesNeeded, &dwBytesNeeded,
199 | 				&dwCount))
200 | 			{
201 | 				success = false;
202 | 				__leave;
203 | 			}
204 | 
205 | 			for (i = 0; i < dwCount; i++)
206 | 			{
207 | 				ess = *(lpDependencies + i);
208 | 				// Open the service.
209 | 				hDepService = OpenService(schSCManager,
210 | 					ess.lpServiceName,
211 | 					SERVICE_STOP | SERVICE_QUERY_STATUS);
212 | 
213 | 				if (!hDepService)
214 | 				{
215 | 					success = false;
216 | 					__leave;
217 | 				}
218 | 
219 | 				__try {
220 | 					// Send a stop code.
221 | 					if (!ControlService(hDepService,
222 | 						SERVICE_CONTROL_STOP,
223 | 						(LPSERVICE_STATUS)&ssp))
224 | 					{
225 | 						success = false;
226 | 						__leave;
227 | 					}
228 | 
229 | 					// Wait for the service to stop.
230 | 					while (ssp.dwCurrentState != SERVICE_STOPPED)
231 | 					{
232 | 						Sleep(ssp.dwWaitHint);
233 | 						if (!QueryServiceStatusEx(
234 | 							hDepService,
235 | 							SC_STATUS_PROCESS_INFO,
236 | 							(LPBYTE)&ssp,
237 | 							sizeof(SERVICE_STATUS_PROCESS),
238 | 							&dwBytesNeeded))
239 | 						{
240 | 							success = false;
241 | 							__leave;
242 | 						}
243 | 
244 | 						if (ssp.dwCurrentState == SERVICE_STOPPED)
245 | 							break;
246 | 
247 | 						if (GetTickCount64() - dwStartTime > dwTimeout)
248 | 						{
249 | 							success = false;
250 | 							__leave;
251 | 						}
252 | 					}
253 | 				}
254 | 				__finally
255 | 				{
256 | 					// Always release the service handle.
257 | 					CloseServiceHandle(hDepService);
258 | 				}
259 | 			}
260 | 		}
261 | 		__finally
262 | 		{
263 | 			// Always free the enumeration buffer.
264 | 			HeapFree(GetProcessHeap(), 0, lpDependencies);
265 | 		}
266 | 	}
267 | 	return success;
268 | }
269 | 
270 | bool ServiceStopper::StartService_s(std::string serviceName)
271 | {
272 | 	SERVICE_STATUS_PROCESS ssStatus;
273 | 	DWORD dwOldCheckPoint;
274 | 	ULONGLONG dwStartTickCount;
275 | 	DWORD dwWaitTime;
276 | 	DWORD dwBytesNeeded;
277 | 
278 | 	// Get a handle to the SCM database. 
279 | 
280 | 	SC_HANDLE schSCManager = OpenSCManager(
281 | 		NULL,                    // local computer
282 | 		NULL,                    // servicesActive database 
283 | 		SC_MANAGER_ALL_ACCESS);  // full access rights 
284 | 
285 | 	if (NULL == schSCManager)
286 | 	{
287 | 		throw ServiceStopException("OpenSCManager failed (%d)", GetLastError());
288 | 	}
289 | 
290 | 	// Get a handle to the service.
291 | 
292 | 	SC_HANDLE schService = OpenService(
293 | 		schSCManager,         // SCM database 
294 | 		serviceName.c_str(),            // name of service 
295 | 		SERVICE_ALL_ACCESS);  // full access 
296 | 
297 | 	if (schService == NULL)
298 | 	{
299 | 		CloseServiceHandle(schSCManager);
300 | 		throw ServiceStopException("OpenService failed (%d)", GetLastError());
301 | 	}
302 | 
303 | 	// Check the status in case the service is not stopped. 
304 | 
305 | 	if (!QueryServiceStatusEx(
306 | 		schService,                     // handle to service 
307 | 		SC_STATUS_PROCESS_INFO,         // information level
308 | 		(LPBYTE)&ssStatus,             // address of structure
309 | 		sizeof(SERVICE_STATUS_PROCESS), // size of structure
310 | 		&dwBytesNeeded))              // size needed if buffer is too small
311 | 	{
312 | 		CloseServiceHandle(schService);
313 | 		CloseServiceHandle(schSCManager);
314 | 		throw ServiceStopException("QueryServiceStatusEx failed (%d)", GetLastError());
315 | 	}
316 | 
317 | 	// Check if the service is already running. It would be possible 
318 | 	// to stop the service here, but for simplicity this example just returns. 
319 | 
320 | 	if (ssStatus.dwCurrentState != SERVICE_STOPPED && ssStatus.dwCurrentState != SERVICE_STOP_PENDING)
321 | 	{
322 | 		CloseServiceHandle(schService);
323 | 		CloseServiceHandle(schSCManager);
324 | 		throw ServiceStopException("Cannot start the service because it is already running");
325 | 	}
326 | 
327 | 	// Save the tick count and initial checkpoint.
328 | 
329 | 	dwStartTickCount = GetTickCount64();
330 | 	dwOldCheckPoint = ssStatus.dwCheckPoint;
331 | 
332 | 	// Wait for the service to stop before attempting to start it.
333 | 
334 | 	while (ssStatus.dwCurrentState == SERVICE_STOP_PENDING)
335 | 	{
336 | 		// Do not wait longer than the wait hint. A good interval is 
337 | 		// one-tenth of the wait hint but not less than 1 second  
338 | 		// and not more than 10 seconds. 
339 | 
340 | 		dwWaitTime = ssStatus.dwWaitHint / 10;
341 | 
342 | 		if (dwWaitTime < 1000)
343 | 			dwWaitTime = 1000;
344 | 		else if (dwWaitTime > 10000)
345 | 			dwWaitTime = 10000;
346 | 
347 | 		Sleep(dwWaitTime);
348 | 
349 | 		// Check the status until the service is no longer stop pending. 
350 | 
351 | 		if (!QueryServiceStatusEx(
352 | 			schService,                     // handle to service 
353 | 			SC_STATUS_PROCESS_INFO,         // information level
354 | 			(LPBYTE)&ssStatus,             // address of structure
355 | 			sizeof(SERVICE_STATUS_PROCESS), // size of structure
356 | 			&dwBytesNeeded))              // size needed if buffer is too small
357 | 		{
358 | 			CloseServiceHandle(schService);
359 | 			CloseServiceHandle(schSCManager);
360 | 			throw ServiceStopException("QueryServiceStatusEx failed (%d)\n", GetLastError());
361 | 		}
362 | 
363 | 		if (ssStatus.dwCheckPoint > dwOldCheckPoint)
364 | 		{
365 | 			// Continue to wait and check.
366 | 
367 | 			dwStartTickCount = GetTickCount64();
368 | 			dwOldCheckPoint = ssStatus.dwCheckPoint;
369 | 		}
370 | 		else
371 | 		{
372 | 			if (GetTickCount64() - dwStartTickCount > ssStatus.dwWaitHint)
373 | 			{
374 | 				CloseServiceHandle(schService);
375 | 				CloseServiceHandle(schSCManager);
376 | 				throw ServiceStopException("Timeout waiting for service to stop\n");
377 | 			}
378 | 		}
379 | 	}
380 | 
381 | 	// Attempt to start the service.
382 | 
383 | 	if (!StartService(
384 | 		schService,  // handle to service 
385 | 		0,           // number of arguments 
386 | 		NULL))      // no arguments 
387 | 	{
388 | 		CloseServiceHandle(schService);
389 | 		CloseServiceHandle(schSCManager);
390 | 		throw ServiceStopException("StartService failed (%d)\n", GetLastError());
391 | 	}
392 | 
393 | 	// Check the status until the service is no longer start pending. 
394 | 
395 | 	if (!QueryServiceStatusEx(
396 | 		schService,                     // handle to service 
397 | 		SC_STATUS_PROCESS_INFO,         // info level
398 | 		(LPBYTE)&ssStatus,             // address of structure
399 | 		sizeof(SERVICE_STATUS_PROCESS), // size of structure
400 | 		&dwBytesNeeded))              // if buffer too small
401 | 	{
402 | 		CloseServiceHandle(schService);
403 | 		CloseServiceHandle(schSCManager);
404 | 		throw ServiceStopException("QueryServiceStatusEx failed (%d)\n", GetLastError());
405 | 	}
406 | 
407 | 	// Save the tick count and initial checkpoint.
408 | 
409 | 	dwStartTickCount = GetTickCount64();
410 | 	dwOldCheckPoint = ssStatus.dwCheckPoint;
411 | 
412 | 	while (ssStatus.dwCurrentState == SERVICE_START_PENDING)
413 | 	{
414 | 		// Do not wait longer than the wait hint. A good interval is 
415 | 		// one-tenth the wait hint, but no less than 1 second and no 
416 | 		// more than 10 seconds. 
417 | 
418 | 		dwWaitTime = ssStatus.dwWaitHint / 10;
419 | 
420 | 		if (dwWaitTime < 1000)
421 | 			dwWaitTime = 1000;
422 | 		else if (dwWaitTime > 10000)
423 | 			dwWaitTime = 10000;
424 | 
425 | 		Sleep(dwWaitTime);
426 | 
427 | 		// Check the status again. 
428 | 
429 | 		if (!QueryServiceStatusEx(
430 | 			schService,             // handle to service 
431 | 			SC_STATUS_PROCESS_INFO, // info level
432 | 			(LPBYTE)&ssStatus,             // address of structure
433 | 			sizeof(SERVICE_STATUS_PROCESS), // size of structure
434 | 			&dwBytesNeeded))              // if buffer too small
435 | 		{
436 | 			CloseServiceHandle(schService);
437 | 			CloseServiceHandle(schSCManager);
438 | 			throw ServiceStopException("QueryServiceStatusEx failed (%d)\n", GetLastError());
439 | 		}
440 | 
441 | 		if (ssStatus.dwCheckPoint > dwOldCheckPoint)
442 | 		{
443 | 			// Continue to wait and check.
444 | 
445 | 			dwStartTickCount = GetTickCount64();
446 | 			dwOldCheckPoint = ssStatus.dwCheckPoint;
447 | 		}
448 | 		else
449 | 		{
450 | 			if (GetTickCount64() - dwStartTickCount > ssStatus.dwWaitHint)
451 | 			{
452 | 				// No progress made within the wait hint.
453 | 				break;
454 | 			}
455 | 		}
456 | 	}
457 | 
458 | 	CloseServiceHandle(schService);
459 | 	CloseServiceHandle(schSCManager);
460 | 
461 | 	// Determine whether the service is running.
462 | 	return (ssStatus.dwCurrentState == SERVICE_RUNNING);
463 | }
464 | 
465 | bool ServiceStopper::KillProcess(std::string procName)
466 | {
467 | 	HANDLE hndl = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
468 | 	DWORD dwsma = GetLastError();
469 | 	DWORD dwExitCode = 0;
470 | 	PROCESSENTRY32  procEntry = { 0 };
471 | 	procEntry.dwSize = sizeof(PROCESSENTRY32);
472 | 
473 | 	bool found = false;
474 | 	Process32First(hndl, &procEntry);
475 | 	do
476 | 	{
477 | 		if (!strcmpi(procEntry.szExeFile, procName.c_str()))
478 | 		{
479 | 			found = true;
480 | 			break;
481 | 		}
482 | 		//cout<<"Running Process "<<"          "<<procEntry.szExeFile<<endl;
483 | 	} while (Process32Next(hndl, &procEntry));
484 | 
485 | 	if (found)
486 | 	{
487 | 		HANDLE hHandle;
488 | 		hHandle = ::OpenProcess(PROCESS_ALL_ACCESS, 0, procEntry.th32ProcessID);
489 | 
490 | 		::GetExitCodeProcess(hHandle, &dwExitCode);
491 | 		return ::TerminateProcess(hHandle, dwExitCode);
492 | 	}
493 | 	// There is no need to inform the user that the process cannot be killed if it is the VMware Player version or it not running.
494 | 	//else throw ServiceStopException("Couldn't kill %s, process not found.", procName.c_str());
495 | }
496 | 


--------------------------------------------------------------------------------
/src/patcher.cpp:
--------------------------------------------------------------------------------
  1 | #include "patcher.h"
  2 | 
  3 | // Settings for memory and IO related stuff
  4 | #define FREAD_BUF_SIZE 2048 // 2 kB
  5 | 
  6 | // Flags needed for ELF parsing
  7 | #define E_CLASS64 2
  8 | #define E_SHT_RELA 4
  9 | 
 10 | // Capital letters range from 0x41 to 0x5A
 11 | // other letters from 0x61 to 0x7A
 12 | // total is 26 -- double of 13
 13 | 
 14 | std::string Patcher::rot13(const std::string& in)
 15 | {
 16 | 	std::string out;
 17 | 	for (char c : in)
 18 | 	{
 19 | 		if (c >= 0x41 && c <= 0x5A)
 20 | 		{
 21 | 			// CAPITAL LETTER
 22 | 			out += (((c - 0x41) + 13) % 26) + 0x41;
 23 | 		}
 24 | 		else if (c >= 0x61 && c <= 0x7A)
 25 | 		{
 26 | 			// NON CAPITAL LETTER
 27 | 			out += (((c - 0x61) + 13) % 26) + 0x61;
 28 | 		}
 29 | 		else
 30 | 		{
 31 | 			// NUMBER/SYMBOL/OTHER STUFF
 32 | 			out += c;
 33 | 		}
 34 | 	}
 35 | 	return out;
 36 | }
 37 | 
 38 | std::vector<char> Patcher::makeVector(const char* arr, size_t size)
 39 | {
 40 | 	return std::vector<char>(arr, arr+size);
 41 | }
 42 | 
 43 | bool Patcher::cmpcarr(const char* c1, const char* c2, size_t len)
 44 | {
 45 | 	return std::equal(c1, c1+len, c2);
 46 | }
 47 | 
 48 | // Different implementations for reusing the same memory stream
 49 | std::optional<unsigned long long> Patcher::searchForOffset(const std::vector<char>& memstream, const std::vector<char>& sequence, unsigned long long from)
 50 | {
 51 | 	if (from >= memstream.size() - sequence.size())
 52 | 		return {};
 53 | 
 54 | 	auto sRes = std::search(memstream.begin()+from, memstream.end(), sequence.begin(), sequence.end());
 55 | 	if (sRes != memstream.end())
 56 | 		return (sRes - memstream.begin());
 57 | 	else
 58 | 		return {};
 59 | }
 60 | 
 61 | std::optional<unsigned long long> Patcher::searchForLastOffset(const std::vector<char>& memstream, const std::vector<char>& sequence)
 62 | {
 63 | 	auto sRes = std::find_end(memstream.begin(), memstream.end(), sequence.begin(), sequence.end());
 64 | 	if (sRes != memstream.end())
 65 | 		return (sRes - memstream.begin());
 66 | 	else
 67 | 		return {};
 68 | }
 69 | 
 70 | std::optional<unsigned long long> Patcher::searchForOffset(std::fstream& stream, const std::vector<char>& sequence, unsigned long long from)
 71 | {
 72 | 	std::vector<char> memFile = readFile(stream);
 73 | 
 74 | 	if (from >= memFile.size() - sequence.size())
 75 | 		return {};
 76 | 
 77 | 	auto sRes = std::search(memFile.begin()+from, memFile.end(), sequence.begin(), sequence.end());
 78 | 	if (sRes != memFile.end())
 79 | 		return (sRes - memFile.begin());
 80 | 	else
 81 | 		return {};
 82 | }
 83 | 
 84 | std::optional<unsigned long long> Patcher::searchForLastOffset(std::fstream& stream, const std::vector<char>& sequence)
 85 | {
 86 | 	std::vector<char> memFile = readFile(stream);
 87 | 
 88 | 	auto sRes = std::find_end(memFile.begin(), memFile.end(), sequence.begin(), sequence.end());
 89 | 	if (sRes != memFile.end())
 90 | 		return (sRes - memFile.begin());
 91 | 	else
 92 | 		return {};
 93 | }
 94 | 
 95 | std::vector<char> Patcher::readFile(std::fstream& stream)
 96 | {
 97 | 	std::vector<char> memFile;
 98 | 
 99 | 	stream.clear();
100 | 	stream.seekg(std::ios::beg);
101 | 
102 | 	std::array<char, FREAD_BUF_SIZE> buffer{};
103 | 	while (!stream.eof())
104 | 	{
105 | 		stream.read(buffer.data(), buffer.size());
106 | 		size_t readBytes = stream.gcount();
107 | 		memFile.insert(memFile.end(), buffer.begin(), buffer.begin()+readBytes);
108 | 	}
109 | 	
110 | 	return memFile;
111 | }
112 | 
113 | std::string Patcher::hexRepresentation(std::string bin)
114 | {
115 | 	std::stringstream out;
116 | 	for (char c : bin)
117 | 	{
118 | 		out << std::setfill('0') << std::setw(2) << std::hex << (int)c << " ";
119 | 	}
120 | 	return out.str();
121 | }
122 | 
123 | std::string Patcher::hexRepresentation(std::vector<char> bin)
124 | {
125 | 	std::stringstream out;
126 | 	for (char c : bin)
127 | 	{
128 | 		out << std::setfill('0') << std::setw(2) << std::hex << (int)c << " ";
129 | 	}
130 | 	return out.str();
131 | }
132 | 
133 | std::string Patcher::hexRepresentation(long long bin)
134 | {
135 | 	std::stringstream out;
136 | 
137 | 	out << "0x" << std::setfill('0') << std::setw(sizeof(long long)*2) << std::hex << bin;
138 | 	
139 | 	return out.str();
140 | }
141 | 
142 | void Patcher::printkey(int i, unsigned long long offset, const smc_key_struct& smc_key, const std::vector<char>& smc_data)
143 | {
144 | 	std::stringstream result;
145 | 	result << std::setfill('0') << std::setw(3) << (i + 1);
146 | 	result << " " << hexRepresentation(offset);
147 | 	{
148 | 		std::vector<char> arr( smc_key.s0, smc_key.s0 + 4);	// copy into new vector
149 | 		std::reverse(arr.begin(), arr.end()); // reverse -- as [::-1] does in python
150 | 		std::string arr_str(arr.begin(), arr.end());
151 | 		result << " " << arr_str;
152 | 	}
153 | 	{
154 | 		result << " " << std::setfill('0') << std::setw(2) << (int)smc_key.B1;
155 | 	}
156 | 	{
157 | 		std::vector<char> arr(smc_key.s2, smc_key.s2 + 4);	// copy into new vector
158 | 		std::reverse(arr.begin(), arr.end()); // reverse -- as [::-1] does in python
159 | 		std::replace(arr.begin(), arr.end(), char(0x00), ' '); // replace 0x0 with ' '
160 | 		std::string arr_str(arr.begin(), arr.end());
161 | 		result << " " << arr_str;
162 | 	}
163 | 	{
164 | 		result << " 0x" << std::setfill('0') << std::setw(2) << std::hex << (int)smc_key.B3;
165 | 	}
166 | 	{
167 | 		result << " " << hexRepresentation(smc_key.Q4);
168 | 	}
169 | 	result << " " << hexRepresentation(smc_data);
170 | 
171 | 	Logger::debug(result.str());
172 | }
173 | 
174 | void Patcher::patchSMC(fs::path name, bool isSharedObj)
175 | {
176 | 	std::fstream i_file(name, std::ios_base::binary | std::ios_base::out | std::ios_base::in);
177 | 	if (!i_file.good())
178 | 	{
179 | 		char msg[2048];
180 | 		sprintf(msg, "Couldn't open file %s", name.string().c_str());
181 | 		throw PatchException(msg);
182 | 	}
183 | 
184 | 	long smc_old_memptr = 0;
185 | 	long smc_new_memptr = 0;
186 | 
187 | 	// Read file into string variable
188 | 	//vmx = f.read();
189 | 
190 | 	Logger::debug("Patching file: " + name.filename().string());
191 | 
192 | 	// Setup hex string for vSMC headers
193 | 	// These are the private and public key counts
194 | 	char smc_header_v0[] = SMC_HEADER_V0;
195 | 	char smc_header_v1[] = SMC_HEADER_V1;
196 | 
197 | 	// Setup hex string for #KEY key
198 | 	char key_key[] = KEY_KEY;
199 | 
200 | 	// Setup hex string for $Adr key
201 | 	char adr_key[] = ADR_KEY;
202 | 
203 | 	// Load up whole file into memory
204 | 	std::vector<char> memFile = readFile(i_file);
205 | 
206 | 	// Find the vSMC headers
207 | 	auto res = searchForOffset(memFile, makeVector(smc_header_v0, SMC_HEADER_V0_SZ));
208 | 	if (!res.has_value())
209 | 		throw PatchException("Couldn't find smc_header_v0_offset");
210 | 
211 | 	unsigned long long smc_header_v0_offset = res.value() - 8;
212 | 
213 | 	res = searchForOffset(memFile, makeVector(smc_header_v1, SMC_HEADER_V1_SZ));
214 | 	if (!res.has_value())
215 | 		throw PatchException("Couldn't find smc_header_v1_offset");
216 | 	unsigned long long smc_header_v1_offset = res.value() -8;
217 | 
218 | 	// Find '#KEY' keys
219 | 	res = searchForOffset(memFile, makeVector(key_key, KEY_KEY_SZ)); //FIXME: doesn't work
220 | 	if (!res.has_value())
221 | 		throw PatchException("Couldn't find smc_key0 offset");
222 | 	unsigned long long smc_key0 = res.value();
223 | 
224 | 	res = searchForLastOffset(memFile, makeVector(key_key, KEY_KEY_SZ));
225 | 	if (!res.has_value())
226 | 		throw PatchException("Couldn't find smc_key1 offset");
227 | 	unsigned long long smc_key1 = res.value();
228 | 
229 | 	// Find '$Adr' key only V1 table
230 | 	res = searchForOffset(memFile, makeVector(adr_key, ADR_KEY_SZ));
231 | 	if (!res.has_value())
232 | 		throw PatchException("Couldn't find smc_adr offset");
233 | 	unsigned long long smc_adr = res.value();
234 | 
235 | 	memFile.clear();
236 | 
237 | 	// Print vSMC0 tables and keys
238 | 	Logger::debug("appleSMCTableV0 (smc.version = \"0\")");
239 | 	Logger::debug("appleSMCTableV0 Address      : " + hexRepresentation(smc_header_v0_offset));
240 | 	Logger::debug("appleSMCTableV0 Private Key #: 0xF2/242");
241 | 	Logger::debug("appleSMCTableV0 Public Key  #: 0xF0/240");
242 | 
243 | 	if ((smc_adr - smc_key0) != 72)
244 | 	{
245 | 		Logger::debug("appleSMCTableV0 Table        : " + hexRepresentation(smc_key0));
246 | 		auto res = patchKeys(i_file, smc_key0);
247 | 		smc_old_memptr = res.first;
248 | 		smc_new_memptr = res.second;
249 | 	}
250 | 	else if ((smc_adr - smc_key1) != 72)
251 | 	{
252 | 		Logger::debug("appleSMCTableV0 Table        : " + hexRepresentation(smc_key1));
253 | 		auto res = patchKeys(i_file, smc_key1);
254 | 		smc_old_memptr = res.first;
255 | 		smc_new_memptr = res.second;
256 | 	}
257 | 	Logger::debug("");
258 | 
259 | 	// Print vSMC1 tables and keys
260 | 	Logger::debug("appleSMCTableV1 (smc.version = \"1\")");
261 | 	Logger::debug("appleSMCTableV1 Address      : " + hexRepresentation(smc_header_v1_offset));
262 | 	Logger::debug("appleSMCTableV1 Private Key #: 0x01B4/436");
263 | 	Logger::debug("appleSMCTableV1 Public Key  #: 0x01B0/432");
264 | 	
265 | 	if ((smc_adr - smc_key0) == 72)
266 | 	{
267 | 		Logger::debug("appleSMCTableV1 Table        : " + hexRepresentation(smc_key0));
268 | 		auto res = patchKeys(i_file, smc_key0);
269 | 		smc_old_memptr = res.first, smc_new_memptr = res.second;
270 | 	}
271 | 	else if ((smc_adr - smc_key1) == 72)
272 | 	{
273 | 		Logger::debug("appleSMCTableV1 Table        : " + hexRepresentation(smc_key1));
274 | 		auto res = patchKeys(i_file, smc_key1);
275 | 		smc_old_memptr = res.first, smc_new_memptr = res.second;
276 | 	}
277 | 	Logger::debug("");
278 | 
279 | 	// Find matching RELA record in.rela.dyn in ESXi ELF files
280 | 	// This is temporary code until proper ELF parsing written
281 | 	if (isSharedObj)
282 | 	{
283 | 		Logger::debug("Modifying RELA records from: " + hexRepresentation(smc_old_memptr) + " to " + hexRepresentation(smc_new_memptr));
284 | 		patchElf(i_file, smc_old_memptr, smc_new_memptr);
285 | 	}
286 | 
287 | 	// Tidy up
288 | 	i_file.close();
289 | }
290 | 
291 | std::pair<unsigned long long, unsigned long long> Patcher::patchKeys(std::fstream& file, long long key)
292 | {
293 | 	// Setup struct pack string
294 | 	//std::string key_pack = "=4sB4sB6xQ";
295 | 		// smc_old_memptr = 0
296 | 	unsigned long long smc_new_memptr = 0;
297 | 
298 | 	// Do Until OSK1 read
299 | 	int	i = 0;
300 | 	while (true)
301 | 	{
302 | 		// Read key into struct strand data byte str
303 | 		long long offset = key + ((unsigned long long)i * 72);
304 | 		file.clear();
305 | 		file.seekg(offset);
306 | 		smc_key_struct smc_key = { 0 };
307 | 		file.read(reinterpret_cast<char*>(&smc_key), 24);
308 | 		//auto smc_key = structUnpack(key_pack, rr);
309 | 		std::vector<char> smc_data;
310 | 		auto sz = smc_key.B1;
311 | 		smc_data.resize(sz);
312 | 		file.read(smc_data.data(), sz );
313 | 
314 | 		// Reset pointer to beginning of key entry
315 | 		file.clear();
316 | 		file.seekg(offset);
317 | 		auto smc_key_0 = smc_key.s0;
318 | 		std::string cmp = "SKL+";
319 | 		std::string cmp1 = "0KSO";
320 | 		std::string cmp2 = "1KSO";
321 | 		if (cmpcarr(smc_key_0, cmp.data(), 4))
322 | 		{
323 | 			// Use the + LKS data routine for OSK0 / 1
324 | 			smc_new_memptr = smc_key.Q4;
325 | 			Logger::debug("+LKS Key: ");
326 | 			printkey(i, offset, smc_key, smc_data); // too lazy for this one - but I coded it eventually
327 | 		}
328 | 		else if (cmpcarr(smc_key_0, cmp1.data(), 4))
329 | 		{
330 | 			//Write new data routine pointer from + LKS
331 | 			Logger::debug("OSK0 Key Before:");
332 | 			printkey(i, offset, smc_key, smc_data);
333 | 			// smc_old_memptr = smc_key[4]
334 | 			file.clear();
335 | 			file.seekg(offset);
336 | 			smc_key_struct towrite = { 0 };
337 | 			memcpy(towrite.s0, smc_key.s0, 4);
338 | 			towrite.B1 = smc_key.B1;
339 | 			memcpy(towrite.s2, smc_key.s2, 4);
340 | 			towrite.B3 = smc_key.B3;
341 | 			towrite.Q4 = smc_new_memptr;
342 | 
343 | 			file.write(reinterpret_cast<char*>(&towrite), sizeof(smc_key_struct));
344 | 			file.flush();
345 | 
346 | 			// Write new data for key
347 | 			file.clear();
348 | 			file.seekg(offset + 24);
349 | 			std::string smc_new_data = rot13(SMC_NEW_DATA); // lulz
350 | 			file.write(smc_new_data.data(), smc_new_data.size());
351 | 				//f.write(smc_new_data.encode('UTF-8'))
352 | 			file.flush();
353 | 
354 | 			// Re - read and print key
355 | 			file.clear();
356 | 			file.seekg(offset);
357 | 			file.read(reinterpret_cast<char*>(&smc_key), 24);
358 | 			
359 | 			smc_data.clear();
360 | 			smc_data.resize(smc_key.B1);
361 | 			file.read(smc_data.data(), smc_key.B1);
362 | 			Logger::debug("OSK0 Key After:");
363 | 			printkey(i, offset, smc_key, smc_data);
364 | 		}
365 | 		else if (cmpcarr(smc_key.s0, cmp2.data(), 4))
366 | 		{
367 | 			// Write new data routine pointer from + LKS
368 | 			Logger::debug("OSK1 Key Before:");
369 | 			printkey(i, offset, smc_key, smc_data);
370 | 			unsigned long long smc_old_memptr = smc_key.Q4;
371 | 			
372 | 			file.clear();
373 | 			file.seekg(offset);
374 | 
375 | 			smc_key_struct towrite = { 0 };
376 | 			memcpy(towrite.s0, smc_key.s0, 4);
377 | 			towrite.B1 = smc_key.B1;
378 | 			memcpy(towrite.s2, smc_key.s2, 4);
379 | 			towrite.B3 = smc_key.B3;
380 | 			towrite.Q4 = smc_new_memptr;
381 | 
382 | 			file.write(reinterpret_cast<char*>(&towrite), sizeof(smc_key_struct));
383 | 			file.flush();
384 | 
385 | 			// Write new data for key
386 | 			file.clear();
387 | 			file.seekg(offset + 24);
388 | 			std::string smc_new_data = rot13(SMC_NEW_DATA2); // so funny
389 | 			file.write(smc_new_data.data(), smc_new_data.size());
390 | 
391 | 			file.flush();
392 | 
393 | 			// Re - read and print key
394 | 			file.clear();
395 | 			file.seekg(offset);
396 | 
397 | 			file.read(reinterpret_cast<char*>(&smc_key), 24);
398 | 			
399 | 			smc_data.clear();
400 | 			smc_data.resize(smc_key.B1);
401 | 			file.read(smc_data.data(), smc_key.B1);
402 | 
403 | 			Logger::debug("OSK1 Key After:");
404 | 			printkey(i, offset, smc_key, smc_data);
405 | 
406 | 			// Finished so get out of loop
407 | 
408 | 			return std::make_pair(smc_old_memptr, smc_new_memptr);
409 | 		}
410 | 
411 | 		i += 1;
412 | 	}
413 | }
414 | 
415 | void Patcher::patchBase(fs::path name)
416 | {
417 | 
418 | 	//Patch file
419 | 	Logger::debug("GOS Patching: " + name.filename().string());
420 | 	std::fstream file(name, std::ios_base::binary | std::ios_base::in | std::ios_base::out);
421 | 	if (!file.good())
422 | 	{
423 | 		char msg[2048];
424 | 		sprintf(msg, "Couldn't open file %s", name.string().c_str());
425 | 		throw PatchException(msg);
426 | 	}
427 | 
428 | 	// Entry to search for in GOS table
429 | 	// Should work for Workstation 12 - 15...
430 | 
431 | 	std::vector<char> memFile = readFile(file);
432 | 	// REGEX WAY --- Seems to not work 
433 | 
434 | 	Logger::verbose("Patching through REGEX");
435 | 	std::regex darwin = std::regex(DARWIN_REGEX);
436 | 	std::string buf;
437 | 	buf.resize(32);
438 | 
439 | 	// Loop through each entry and set top bit
440 | 	// 0xBE -- > 0xBF (WKS 12)
441 | 	// 0x3E -- > 0x3F (WKS 14)
442 | 
443 | 	unsigned int occurrences = 0;
444 | 	auto reg_iter = std::cregex_iterator(memFile.data(), memFile.data()+memFile.size(), darwin);
445 | 
446 | 	for (auto it = reg_iter; it != std::cregex_iterator(); it++)
447 | 	{
448 | 		std::cmatch match = *it;
449 | 		size_t pos = match.position();
450 | 
451 | 		file.clear();
452 | 		file.seekg(pos + 32);
453 | 
454 | 		char flag = file.get();
455 | 		flag = (flag | (1 << 0));
456 | 
457 | 		file.clear();
458 | 		file.seekg(pos + 32);
459 | 
460 | 		file.put(flag);
461 | 		Logger::debug("GOS Patched flag @: " + hexRepresentation(pos));
462 | 
463 | 		occurrences++;
464 | 	}
465 | 
466 | 	//Iterative way
467 | 	/*
468 | 	logv("Patching iteratively");
469 | 	std::vector<char> darwinPattern[4];
470 | 
471 | 	darwinPattern[0] = DARWIN_PATTERN_PERM_1;
472 | 	darwinPattern[1] = DARWIN_PATTERN_PERM_2;
473 | 	darwinPattern[2] = DARWIN_PATTERN_PERM_3;
474 | 	darwinPattern[3] = DARWIN_PATTERN_PERM_4;
475 | 	
476 | 	const size_t mStreamLen = memFile.size();
477 | 	
478 | 	for (int i = 0; i < 4; i++)
479 | 	{
480 | 		const std::vector<char>& darwinPatt = darwinPattern[i];
481 | 		std::optional<unsigned long long> val = 0;
482 | 		do
483 | 		{
484 | 			val = searchForOffset(memFile, darwinPatt, val.value());
485 | 			if (val.has_value())
486 | 			{
487 | 				auto pos = val.value();
488 | 				file.clear();
489 | 				file.seekg(pos + 32);
490 | 
491 | 				char flag = file.get();
492 | 				flag |= 1;
493 | 
494 | 				file.clear();
495 | 				file.seekg(pos + 32);
496 | 
497 | 				file.put(flag);
498 | 				logd("GOS Patched flag @: " + hexRepresentation(pos));
499 | 				val = val.value() + 40;
500 | 			}
501 | 		} while (val.has_value());
502 | 	}*/
503 | 
504 | 	file.flush();
505 | 	file.close();
506 | 
507 | 	Logger::debug("GOS Patched: " + name.filename().string());
508 | }
509 | 
510 | void Patcher::patchVmkctl(fs::path name)
511 | {	
512 | 	Logger::debug("smcPresent Patching: " + name.filename().string());
513 | 	std::fstream file(name, std::ios_base::in | std::ios_base::out);
514 | 	
515 | 	std::string find_str = VMKCTL_FIND_STR;
516 | 	std::vector<char> find_crs(find_str.begin(), find_str.end());
517 | 	auto offset = searchForOffset(file, find_crs);
518 | 
519 | 	if (offset.has_value())
520 | 	{
521 | 		std::string rep_str = VMKCTL_REPLACE_STR;
522 | 
523 | 		file.clear();
524 | 		file.seekg(offset.value());
525 | 		file.write(rep_str.data(), rep_str.size());
526 | 
527 | 		file.flush();
528 | 		file.close();
529 | 	}
530 | 	else {
531 | 		throw PatchException("Couldn't find Vmkctl offset");
532 | 	}
533 | }
534 | 
535 | void Patcher::patchElf(std::fstream& file, long long oldoffset, long long newoffset)
536 | {
537 | 	file.clear();
538 | 	file.seekg(std::ios_base::beg);
539 | 	char buf[5];
540 | 	memset(buf, 0, 5);
541 | 	file.read(buf, 4);
542 | 	if (strcmp(buf, "\x7f""ELF") != 0)
543 | 	{
544 | 		throw PatchException("Not an ELF binary.");
545 | 	}
546 | 	unsigned char u = file.get();
547 | 	if (u != E_CLASS64)
548 | 	{
549 | 		throw PatchException("Not a 64 bit binary.");
550 | 	}
551 | 	file.clear();
552 | 	file.seekg(40);
553 | 	unsigned long long e_shoff;
554 | 	file.read(reinterpret_cast<char*>(&e_shoff), sizeof(unsigned long long));
555 | 	
556 | 	file.clear();
557 | 	file.seekg(58);
558 | 	unsigned short e_shentsize, e_shnum, e_shstrndx;
559 | 	file.read(reinterpret_cast<char*>(&e_shentsize), sizeof(unsigned short));
560 | 	file.read(reinterpret_cast<char*>(&e_shnum), sizeof(unsigned short));
561 | 	file.read(reinterpret_cast<char*>(&e_shstrndx), sizeof(unsigned short));
562 | 
563 | 	Logger::debug("e_shoff: 0x%02llX e_shentsize: 0x%02X e_shnum:0x%02X e_shstrndx:0x%02X\n", e_shoff, e_shentsize,
564 | 		e_shnum, e_shstrndx);
565 | 
566 | 	for (unsigned short i = 0; i < e_shnum; i++)
567 | 	{
568 | 		file.clear();
569 | 		file.seekg(e_shoff + i * (unsigned long long)e_shentsize);
570 | 		LLQQQQLLQQ e_sh = { 0 };
571 | 		
572 | 		file.read(reinterpret_cast<char*>(&e_sh), e_shentsize);
573 | 		auto e_sh_type = e_sh.l2;
574 | 		auto e_sh_offset = e_sh.q3;
575 | 		auto e_sh_size = e_sh.q4;
576 | 		auto e_sh_entsize = e_sh.q6;
577 | 		if (e_sh_type == E_SHT_RELA)
578 | 		{
579 | 			auto e_sh_nument = int(e_sh_size / e_sh_entsize);
580 | 			for (int j = 0; j < e_sh_nument; j++)
581 | 			{
582 | 				file.clear();
583 | 				file.seekg(e_sh_offset + e_sh_entsize * j);
584 | 				QQq rela;
585 | 				file.read(reinterpret_cast<char*>(&rela), e_sh_entsize);
586 | 				auto r_offset = rela.Q1;
587 | 				auto r_info = rela.Q2;
588 | 				auto r_addend = rela.q3;
589 | 				if (r_addend == oldoffset)
590 | 				{
591 | 					r_addend = newoffset;
592 | 					file.clear();
593 | 					file.seekg(e_sh_offset + e_sh_entsize * j);
594 | 					QQq towr;
595 | 					towr.Q1 = r_offset;
596 | 					towr.Q2 = r_info;
597 | 					towr.q3 = r_addend;
598 | 					file.write(reinterpret_cast<char*>(&towr), sizeof(QQq));
599 | 					Logger::debug("Relocation modified at: " + hexRepresentation(e_sh_offset + e_sh_entsize * j));
600 | 				}
601 | 			}
602 | 		}
603 | 	}
604 | }
605 | 


--------------------------------------------------------------------------------