Merge pull request #15 from AceSLS/dev

Update to latest dev branch

Author: AceSLS

README.md

@@ -107,6 +107,9 @@ Afterwards run the installer again if that's what you've been using to launch SL
 
 ## Credits
 
+- Special thanks to all the staff members of the Anti Denuvo Sanctuary
+  for all the hard work they do. They also found a way to use SLSsteam
+  I didn't even intend to, so shoutout to them
 - [DeveloperMikey](https://github.com/DeveloperMikey): Added Nix support 
 - Riku_Wayfinder: Being extremely supportive and lightening my workload by a lot.
   So show him some love my guys <3

src/config.cpp

@@ -1,5 +1,6 @@
 #include "config.hpp"
 
+#include "log.hpp"
 #include "yaml-cpp/yaml.h"
 
 #include <cmath>
@@ -21,6 +22,11 @@ static const char* defaultConfig =
 "#  AppId:\n"
 "#    FirstDlcAppId: \"Dlc Name\"\n"
 "#    SecondDlcAppId: \"Dlc Name\"\n\n"
+"#Example of DenuvoGames:\n"
+"#DenuvoGames:\n"
+"#  SteamId:\n"
+"#    -  AppId1\n"
+"#    -  AppId2\n\n"
 "#Disables Family Share license locking for self and others\n"
 "DisableFamilyShareLock: yes\n\n"
 "#Switches to whitelist instead of the default blacklist\n"
@@ -37,12 +43,20 @@ static const char* defaultConfig =
 "#Extra Data for Dlcs belonging to a specific AppId. Only needed\n"
 "#when the App you're playing is hit by Steams 64 DLC limit\n"
 "DlcData:\n\n"
+"#Blocks games from unlocking on wrong accounts\n"
+"DenuvoGames:\n\n"
+"#Spoof Denuvo Games owner instead of blocking them\n"
+"DenuvoSpoof: no\n\n"
 "#Automatically disable SLSsteam when steamclient.so does not match a predefined file hash that is known to work\n"
 "#You should enable this if you're planing to use SLSsteam with Steam Deck's gamemode\n"
 "SafeMode: no\n\n"
+"#Toggles notifications via notify-send\n"
+"Notifications: yes\n\n"
 "#Warn user via notification when steamclient.so hash differs from known safe hash\n"
 "#Mostly useful for development so I don't accidentally miss an update\n"
 "WarnHashMissmatch: no\n\n"
+"#Notify when SLSsteam is done initializing\n"
+"NotifyInit: yes\n\n"
 "#Logs all calls to Steamworks (this makes the logfile huge! Only useful for debugging/analyzing\n"
 "ExtendedLogging: no";
 
@@ -129,17 +143,23 @@ bool CConfig::loadSettings()
 	automaticFilter = getSetting<bool>(node, "AutoFilterList", true);
 	playNotOwnedGames = getSetting<bool>(node, "PlayNotOwnedGames", false);
 	safeMode = getSetting<bool>(node, "SafeMode", false);
+	notifications = getSetting<bool>(node, "Notifications", true);
 	warnHashMissmatch = getSetting<bool>(node, "WarnHashMissmatch", false);
+	notifyInit = getSetting<bool>(node, "NotifyInit", true);
 	extendedLogging = getSetting<bool>(node, "ExtendedLogging", false);
+	denuvoSpoof = getSetting<bool>(node, "DenuvoSpoof", false);
 
 	//TODO: Create smart logging function to log them automatically via getSetting
 	g_pLog->info("DisableFamilyShareLock: %i\n", disableFamilyLock);
 	g_pLog->info("UseWhitelist: %i\n", useWhiteList);
 	g_pLog->info("AutoFilterList: %i\n", automaticFilter);
 	g_pLog->info("PlayNotOwnedGames: %i\n", playNotOwnedGames);
 	g_pLog->info("SafeMode: %i\n", safeMode);
+	g_pLog->info("Notifications: %i\n", notifications);
 	g_pLog->info("WarnHashMissmatch: %i\n", warnHashMissmatch);
+	g_pLog->info("NotifyInit: %i\n", notifyInit);
 	g_pLog->info("ExtendedLogging: %i\n", extendedLogging);
+	g_pLog->info("DenuvoSpoof: %i\n", denuvoSpoof);
 
 	//TODO: Create function to parse these kinda nodes, instead of c+p them
 	const auto appIdsNode = node["AppIds"];
@@ -220,7 +240,37 @@ bool CConfig::loadSettings()
 	}
 	else
 	{
-		g_pLog->notify("Missing DlcData entry in config!\n");
+		g_pLog->notify("Missing DlcData entry in config!");
+	}
+
+	const auto denuvoGamesNode = node["DenuvoGames"];
+	if (denuvoGamesNode)
+	{
+		for (auto& steamIdNode : denuvoGamesNode)
+		{
+			try
+			{
+				const uint32_t steamId = steamIdNode.first.as<uint32_t>();
+				denuvoGames[steamId] = std::unordered_set<uint32_t>();
+
+				for (auto& appIdNode : steamIdNode.second)
+				{
+					const uint32_t appId = appIdNode.as<uint32_t>();
+					denuvoGames[steamId].emplace(appId);
+
+					//Again, not loggin SteamId because of privacy
+					g_pLog->debug("Added DenuvoGame %u\n", appId, steamId);
+				}
+			}
+			catch (...)
+			{
+				g_pLog->notify("Failed to parse DenuvoGames!");
+			}
+		}
+	}
+	else
+	{
+		g_pLog->notify("Missing DenuvoGames entry in config!");
 	}
 
 	return true;
@@ -260,4 +310,18 @@ bool CConfig::shouldExcludeAppId(uint32_t appId)
 	return exclude;
 }
 
+uint32_t CConfig::getDenuvoGameOwner(uint32_t appId)
+{
+	for(const auto& tpl : denuvoGames)
+	{
+		if (tpl.second.contains(appId))
+		{
+			//g_pLog->once("%u is DenuvoGame\n", appId);
+			return tpl.first;
+		}
+	}
+
+	return 0;
+}
+
 CConfig g_config = CConfig();

src/config.hpp

@@ -26,13 +26,18 @@ class CConfig {
 	std::unordered_set<uint32_t> appIds;
 	std::unordered_set<uint32_t> addedAppIds;
 	std::unordered_map<uint32_t, CDlcData> dlcData;
+	//SteamId, AppIds tuple
+	std::unordered_map<uint32_t, std::unordered_set<uint32_t>> denuvoGames;
+	bool denuvoSpoof;
 
 	bool disableFamilyLock;
 	bool useWhiteList;
 	bool automaticFilter;
 	bool playNotOwnedGames;
 	bool safeMode;
+	bool notifications;
 	bool warnHashMissmatch;
+	bool notifyInit;
 	bool extendedLogging;
 
 	std::string getDir();
@@ -64,6 +69,7 @@ class CConfig {
 	bool addAdditionalAppId(uint32_t appId);
 
 	bool shouldExcludeAppId(uint32_t appId);
+	uint32_t getDenuvoGameOwner(uint32_t appId);
 };
 
 extern CConfig g_config;

src/hooks.cpp

@@ -4,6 +4,7 @@
 #include "log.hpp"
 #include "memhlp.hpp"
 #include "patterns.hpp"
+#include "sdk/IClientUser.hpp"
 #include "vftableinfo.hpp"
 
 #include "libmem/libmem.h"
@@ -43,11 +44,11 @@ VFTHook<T>::VFTHook(const char* name) : Hook<T>::Hook(name)
 }
 
 template<typename T>
-bool DetourHook<T>::setup(const char* pattern, const MemHlp::SigFollowMode followMode, T hookFn)
+bool DetourHook<T>::setup(const char* pattern, const MemHlp::SigFollowMode followMode, lm_byte_t* extraData, lm_size_t extraDataSize, T hookFn)
 {
 	//Hardcoding g_modSteamClient here is definitely bad design, but we can easily change that
 	//in case we ever need to
-	lm_address_t oFn = MemHlp::searchSignature(this->name.c_str(), pattern, g_modSteamClient, followMode);
+	lm_address_t oFn = MemHlp::searchSignature(this->name.c_str(), pattern, g_modSteamClient, followMode, extraData, extraDataSize);
 	if (oFn == LM_ADDRESS_BAD)
 	{
 		return false;
@@ -59,6 +60,12 @@ bool DetourHook<T>::setup(const char* pattern, const MemHlp::SigFollowMode follo
 	return true;
 }
 
+template<typename T>
+bool DetourHook<T>::setup(const char* pattern, const MemHlp::SigFollowMode followMode, T hookFn)
+{
+	return setup(pattern, followMode, nullptr, 0, hookFn);
+}
+
 template<typename T>
 void DetourHook<T>::place()
 {
@@ -159,15 +166,32 @@ static bool hkCheckAppOwnership(void* a0, uint32_t appId, CAppOwnershipInfo* pOw
 		return ret;
 	}
 
+	const u_int32_t denuvoOwner = g_config.getDenuvoGameOwner(appId);
+	//Do not modify Denuvo enabled Games
+	if (!g_config.denuvoSpoof && denuvoOwner && denuvoOwner != g_currentSteamId)
+	{
+		//Would love to log the SteamId, but for users anonymity I won't
+		g_pLog->once("Skipping %u because it's a Denuvo game from someone else\n", appId);
+		return ret;
+	}
+
 	if (g_config.isAddedAppId(appId) || (g_config.playNotOwnedGames && !pOwnershipInfo->purchased))
 	{
-		//Changing the purchased field is enough, but just for nicety in the Steamclient UI we change the owner too
-		pOwnershipInfo->ownerSteamId = g_currentSteamId;
-		pOwnershipInfo->purchased = true;
+		if (!denuvoOwner || denuvoOwner == g_currentSteamId)
+		{
+			//Changing the purchased field is enough, but just for nicety in the Steamclient UI we change the owner too
+			pOwnershipInfo->ownerSteamId = g_currentSteamId;
+			pOwnershipInfo->familyShared = false;
+		}
+		else if (denuvoOwner)
+		{
+			pOwnershipInfo->ownerSteamId = denuvoOwner;
+			pOwnershipInfo->familyShared = true;
+		}
 
+		pOwnershipInfo->purchased = true;
 		//Unnessecary but whatever
 		pOwnershipInfo->permanent = true;
-		pOwnershipInfo->familyShared = false;
 
 		//Found in backtrace
 		pOwnershipInfo->releaseState = 4;
@@ -180,7 +204,7 @@ static bool hkCheckAppOwnership(void* a0, uint32_t appId, CAppOwnershipInfo* pOw
 
 	//Doing that might be not worth it since this will most likely be easier to mantain
 	//TODO: Backtrace those 4 calls and only patch the really necessary ones since this might be prone to breakage
-	if (g_config.disableFamilyLock && appIdOwnerOverride.count(appId) && appIdOwnerOverride.at(appId) < 4)
+	if (!denuvoOwner && g_config.disableFamilyLock && appIdOwnerOverride.count(appId) && appIdOwnerOverride.at(appId) < 4)
 	{
 		pOwnershipInfo->ownerSteamId = 1; //Setting to "arbitrary" steam Id instead of own, otherwise bypass won't work for own games
 		//Unnessecarry again, but whatever
@@ -384,6 +408,20 @@ static uint32_t hkClientUser_GetSubscribedApps(void* pClientUser, uint32_t* pApp
 	return count;
 }
 
+static bool hkClientUser_RequiresLegacyCDKey(void* pClientUser, uint32_t appId, uint32_t* a2)
+{
+	const bool requiresKey = Hooks::IClientUser_RequiresLegacyCDKey.tramp.fn(pClientUser, appId, a2);
+	g_pLog->once("IClientUser::RequiresLegacyCDKey(%p, %u, %u) -> %i\n", pClientUser, appId, a2, requiresKey);
+		
+	if (requiresKey && g_config.isAddedAppId(appId))
+	{
+		g_pLog->once("Disable CD Key for %u\n", appId);
+		return false;
+	}
+
+	return requiresKey;
+}
+
 static void patchRetn(lm_address_t address)
 {
 	constexpr lm_byte_t retn = 0xC3;
@@ -480,6 +518,7 @@ namespace Hooks
 	DetourHook<IClientApps_PipeLoop_t> IClientApps_PipeLoop("IClientApps::PipeLoop");
 	DetourHook<IClientUser_BIsSubscribedApp_t> IClientUser_BIsSubscribedApp("IClientUser::BIsSubscribedApp");
 	DetourHook<IClientUser_GetSubscribedApps_t> IClientUser_GetSubscribedApps("IClientUser::GetSubscribedApps");
+	DetourHook<IClientUser_RequiresLegacyCDKey_t> IClientUser_RequiresLegacyCDKey("IClientUser::RequiresLegacyCDKey");
 
 	VFTHook<IClientAppManager_BIsDlcEnabled_t> IClientAppManager_BIsDlcEnabled("IClientAppManager::BIsDlcEnabled");
 	VFTHook<IClientAppManager_LaunchApp_t> IClientAppManager_LaunchApp("IClientAppManager::LaunchApp");
@@ -496,8 +535,33 @@ bool Hooks::setup()
 
 	IClientUser_GetSteamId = MemHlp::searchSignature("IClientUser::GetSteamId", Patterns::GetSteamId, g_modSteamClient, MemHlp::SigFollowMode::Relative);
 
-	lm_address_t runningApp = MemHlp::searchSignature("RunningApp", Patterns::FamilyGroupRunningApp, g_modSteamClient, MemHlp::SigFollowMode::Relative);
-	lm_address_t stopPlayingBorrowedApp = MemHlp::searchSignature("StopPlayingBorrowedApp", Patterns::StopPlayingBorrowedApp, g_modSteamClient, MemHlp::SigFollowMode::PrologueUpwards);
+	lm_address_t runningApp = MemHlp::searchSignature("RnningApp", Patterns::FamilyGroupRunningApp, g_modSteamClient, MemHlp::SigFollowMode::Relative);
+
+	auto prologue = std::vector<lm_byte_t>({
+		0x56, 0x57, 0xe5, 0x89, 0x55
+	});
+	lm_address_t stopPlayingBorrowedApp = MemHlp::searchSignature
+	(
+		"StopPlayingBorrowedApp",
+		Patterns::StopPlayingBorrowedApp,
+		g_modSteamClient,
+		MemHlp::SigFollowMode::PrologueUpwards,
+		&prologue[0],
+		prologue.size()
+	);
+
+	//TODO: Make this shit less verbose in case I fail my reversing & refactor for all this crap
+	prologue = std::vector<lm_byte_t>({
+		0x53, 0x56, 0x57, 0x55
+	});
+	bool requiresLegacyCDKey = IClientUser_RequiresLegacyCDKey.setup
+	(
+		Patterns::RequiresLegacyCDKey,
+		MemHlp::SigFollowMode::PrologueUpwards,
+		&prologue[0],
+		prologue.size(),
+		&hkClientUser_RequiresLegacyCDKey
+	);
 
 	bool succeeded =
 		CheckAppOwnership.setup(Patterns::CheckAppOwnership, MemHlp::SigFollowMode::Relative, &hkCheckAppOwnership)
@@ -509,7 +573,9 @@ bool Hooks::setup()
 
 		&& runningApp != LM_ADDRESS_BAD
 		&& stopPlayingBorrowedApp != LM_ADDRESS_BAD
-		&& IClientUser_GetSteamId != LM_ADDRESS_BAD;
+		&& IClientUser_GetSteamId != LM_ADDRESS_BAD
+
+		&& requiresLegacyCDKey;
 
 	if (!succeeded)
 	{
@@ -538,6 +604,7 @@ void Hooks::place()
 	IClientAppManager_PipeLoop.place();
 	IClientUser_BIsSubscribedApp.place();
 	IClientUser_GetSubscribedApps.place();
+	IClientUser_RequiresLegacyCDKey.place();
 
 	createAndPlaceSteamIdHook();
 }
@@ -551,6 +618,7 @@ void Hooks::remove()
 	IClientAppManager_PipeLoop.remove();
 	IClientUser_BIsSubscribedApp.remove();
 	IClientUser_GetSubscribedApps.remove();
+	IClientUser_RequiresLegacyCDKey.remove();
 
 	//VFT Hooks
 	IClientAppManager_BIsDlcEnabled.remove();

src/hooks.hpp

@@ -44,6 +44,7 @@ class DetourHook : public Hook<T>
 	virtual void place();
 	virtual void remove();
 
+	bool setup(const char* pattern, const MemHlp::SigFollowMode followMode, lm_byte_t* extraData, lm_size_t extraDataSize, T hookFn);
 	bool setup(const char* pattern, const MemHlp::SigFollowMode followMode, T hookFn);
 };
 
@@ -71,13 +72,15 @@ namespace Hooks
 	typedef void(*IClientApps_PipeLoop_t)(void*, void*, void*, void*);
 	typedef bool(*IClientUser_BIsSubscribedApp_t)(void*, uint32_t);
 	typedef uint32_t(*IClientUser_GetSubscribedApps_t)(void*, uint32_t*, size_t, bool);
+	typedef bool(*IClientUser_RequiresLegacyCDKey_t)(void*, uint32_t, uint32_t*);
 
 	extern DetourHook<LogSteamPipeCall_t> LogSteamPipeCall;
 	extern DetourHook<CheckAppOwnership_t> CheckAppOwnership;
 	extern DetourHook<IClientAppManager_PipeLoop_t> IClientAppManager_PipeLoop;
 	extern DetourHook<IClientApps_PipeLoop_t> IClientApps_PipeLoop;
 	extern DetourHook<IClientUser_BIsSubscribedApp_t> IClientUser_BIsSubscribedApp;
 	extern DetourHook<IClientUser_GetSubscribedApps_t> IClientUser_GetSubscribedApps;
+	extern DetourHook<IClientUser_RequiresLegacyCDKey_t> IClientUser_RequiresLegacyCDKey;
 
 	typedef bool(*IClientAppManager_BIsDlcEnabled_t)(void*, uint32_t, uint32_t, void*);
 	typedef void*(*IClientAppManager_LaunchApp_t)(void*, uint32_t*, void*, void*, void*);

src/log.cpp

@@ -1,4 +1,6 @@
 #include "log.hpp"
+#include "config.hpp"
+
 #include <cstdlib>
 #include <memory>
 
@@ -24,6 +26,12 @@ CLog::~CLog()
 	}
 }
 
+//Dirty workaround for not being able to access g_config from __log
+bool CLog::shouldNotify()
+{
+	return g_config.notifications;
+}
+
 CLog* CLog::createDefaultLog()
 {
 	const char* home = getenv("HOME");

src/log.hpp

@@ -153,6 +153,8 @@ class CLog
 		__log(LogLevel::Warn, msg, args...);
 	}
 
+	//Do not include config.hpp in this header, otherwise things will break :) (proly due to recursive inclusion)
+	static bool shouldNotify();
 	static CLog* createDefaultLog();
 };