feat(core): Steam Authorization

Author: skuzzis

CHANGELOG.md

@@ -2,6 +2,13 @@
 
 Over here will be noted all the update change logs.
 
+## v1.6.12 - [Release](https://github.com/swiftly-solution/swiftly/releases/tag/v1.6.12)
+
+### Steam Authorization
+
+- Now in Scripting you can get both authorized and unauthorized SteamID64 / SteamID2, also you can get if the player is authorized.
+- There are also events triggered when a player is being authorized or not: [OnClientSteamAuthorize](https://swiftlycs2.net/plugin-docs/scripting/events/core/onclientsteamauthorize) and [OnClientSteamAuthorizeFail](https://swiftlycs2.net/plugin-docs/scripting/events/core/onclientsteamauthorizefail).
+
 ## v1.6.11 - [Release](https://github.com/swiftly-solution/swiftly/releases/tag/v1.6.11)
 
 ### Automation

plugin_files/configs/core.example.json

@@ -74,5 +74,9 @@
             "paddingX": 0.1,
             "paddingY": 0.1
         }
+    },
+    "steam_auth": {
+        "mode": "flexible",
+        "available_modes": ["flexible", "strict"]
     }
 }

src/core/entrypoint.cpp

@@ -205,6 +205,7 @@ bool SwiftlyS2::Load(PluginId id, ISmmAPI* ismm, char* error, size_t maxlen, boo
     {
         g_eventManager.RegisterGameEvents();
         g_SteamAPI.Init();
+        g_playerManager.SteamAPIServerActivated();
         if (!BeginCrashListener()) PRINTRET("Failed to setup crash listener.\n", false);
     }
 

src/scripting/player/player.cpp

@@ -245,6 +245,15 @@ LoadScriptingComponent(player, [](PluginObject plugin, EContext* ctx) -> void {
         context->SetReturn(player->GetSteamID());
     });
 
+    ADD_CLASS_FUNCTION("Player", "GetUnauthorizedSteamID", [](FunctionContext* context, ClassData* data) -> void {
+        int playerid = data->GetData<int>("playerid");
+
+        Player* player = g_playerManager.GetPlayer(playerid);
+        if (!player) return context->SetReturn(0);
+
+        context->SetReturn(player->GetUnauthorizedSteamID());
+    });
+
     ADD_CLASS_FUNCTION("Player", "GetSteamID2", [](FunctionContext* context, ClassData* data) -> void {
         int playerid = data->GetData<int>("playerid");
 
@@ -260,6 +269,30 @@ LoadScriptingComponent(player, [](PluginObject plugin, EContext* ctx) -> void {
         context->SetReturn(string_format("STEAM_0:%d:%llu", (steamid - base) & 1, (steamid - base) / 2));
     });
 
+    ADD_CLASS_FUNCTION("Player", "GetUnauthorizedSteamID2", [](FunctionContext* context, ClassData* data) -> void {
+        int playerid = data->GetData<int>("playerid");
+
+        Player* player = g_playerManager.GetPlayer(playerid);
+        if (!player) return context->SetReturn("STEAM_0:0:000000000");
+
+        uint64_t steamid = player->GetUnauthorizedSteamID();
+
+        if (steamid == 0)
+            return context->SetReturn("STEAM_0:0:000000000");
+
+        static const uint64_t base = 76561197960265728;
+        context->SetReturn(string_format("STEAM_0:%d:%llu", (steamid - base) & 1, (steamid - base) / 2));
+    });
+
+    ADD_CLASS_FUNCTION("Player", "IsAuthorized", [](FunctionContext* context, ClassData* data) -> void {
+        int playerid = data->GetData<int>("playerid");
+
+        Player* player = g_playerManager.GetPlayer(playerid);
+        if (!player) return context->SetReturn(false);
+
+        context->SetReturn(player->IsAuthorized());
+    });
+
     ADD_CLASS_FUNCTION("Player", "HideMenu", [](FunctionContext* context, ClassData* data) -> void {
         int playerid = data->GetData<int>("playerid");
 

src/server/configuration/configuration.cpp

@@ -498,6 +498,9 @@ bool Configuration::LoadConfiguration()
 
     RegisterConfiguration(wasEdited, coreConfigFile, "core", "core", "vgui.textBackground.textSize", 35);
 
+    RegisterConfiguration(wasEdited, coreConfigFile, "core", "core", "steam_auth.mode", "flexible");
+    RegisterConfigurationVector<std::string>(wasEdited, coreConfigFile, "core", "core", "steam_auth.available_modes", { "flexible", "strict" }, true, " ");
+
     if (wasEdited) {
         WriteJSONFile("addons/swiftly/configs/core.json", coreConfigFile);
     }

src/server/player/manager.cpp

@@ -155,4 +155,23 @@ void PlayerManager::ClientDisconnect(CPlayerSlot slot, ENetworkDisconnectionReas
         g_VGUI.Unregister(player);
         UnregisterPlayer(slot);
     }
+}
+
+void PlayerManager::SteamAPIServerActivated()
+{
+    m_CallbackValidateAuthTicketResponse.Register(this, &PlayerManager::OnValidateAuthTicket);
+}
+
+void PlayerManager::OnValidateAuthTicket(ValidateAuthTicketResponse_t* response)
+{
+    uint64_t steamid = response->m_SteamID.ConvertToUint64();
+
+    for (int i = 0; i < GetPlayerCap(); i++) {
+        auto player = GetPlayer(i);
+        if (!player) continue;
+        if (player->GetUnauthorizedSteamID() != steamid) continue;
+
+        player->SetAuthorized(response->m_eAuthSessionResponse == k_EAuthSessionResponseOK);
+        break;
+    }
 }

src/server/player/manager.h

@@ -5,6 +5,9 @@
 
 #include <core/entrypoint.h>
 #include <public/playerslot.h>
+#include <steam/steam_api_common.h>
+#include <steam/isteamuser.h>
+#include <steam/steamclientpublic.h>
 
 class PlayerManager
 {
@@ -29,6 +32,10 @@ class PlayerManager
     bool ClientConnect(CPlayerSlot slot, const char* pszName, uint64 xuid, const char* pszNetworkID, bool unk1, CBufferString* pRejectReason);
     void OnClientConnected(CPlayerSlot slot, const char* pszName, uint64 xuid, const char* pszNetworkID, const char* pszAddress, bool bFakePlayer);
     void ClientDisconnect(CPlayerSlot slot, ENetworkDisconnectionReason reason, const char* pszName, uint64 xuid, const char* pszNetworkID);
+
+    void SteamAPIServerActivated();
+
+    STEAM_GAMESERVER_CALLBACK_MANUAL(PlayerManager, OnValidateAuthTicket, ValidateAuthTicketResponse_t, m_CallbackValidateAuthTicketResponse);
 };
 
 extern PlayerManager g_playerManager;

src/server/player/player.cpp

@@ -210,13 +210,29 @@ const char* Player::GetName()
 }
 
 uint64_t Player::GetSteamID()
+{
+    if (authorized) {
+        if (IsFakeClient()) return 0;
+
+        auto steamid = engine->GetClientSteamID(CPlayerSlot(slot));
+        if (!steamid) return 0;
+
+        return steamid->ConvertToUint64();
+    }
+    else if (g_Config.FetchValue<std::string>("core.steam_auth.mode") == "flexible") {
+        return GetUnauthorizedSteamID();
+    }
+    else return 0;
+}
+
+uint64_t Player::GetUnauthorizedSteamID()
 {
     if (IsFakeClient()) return 0;
 
-    auto controller = GetController();
-    if (!controller) return xuid;
+    auto steamid = engine->GetClientSteamID(CPlayerSlot(slot));
+    if (!steamid) return xuid;
 
-    return schema::GetProp<uint64_t>(controller, "CBasePlayerController", "m_steamID");
+    return steamid->ConvertToUint64();
 }
 
 void Player::SendMsg(int dest, const char* msg, ...)
@@ -511,4 +527,21 @@ ClassData* Player::GetPlayerObject()
 {
     if (playerObject == nullptr) playerObject = new ClassData({ { "playerid", GetSlot() } }, "Player", nullptr);
     return playerObject;
+}
+
+void Player::SetAuthorized(bool state)
+{
+    authorized = state;
+
+    if (state) {
+        g_pluginManager.ExecuteEvent("core", "OnClientSteamAuthorize", { slot }, {});
+    }
+    else {
+        g_pluginManager.ExecuteEvent("core", "OnClientSteamAuthorizeFail", { slot }, {});
+    }
+}
+
+bool Player::IsAuthorized()
+{
+    return authorized;
 }

src/server/player/player.h

@@ -39,6 +39,7 @@ class Player
     std::string centerMessageText;
 
     uint64_t buttons;
+    bool authorized = false;
 
 public:
     MenuRenderer* menu_renderer = nullptr;
@@ -54,6 +55,8 @@ class Player
     void SendMsg(int dest, const char* msg, ...);
 
     const char* GetName();
+
+    uint64_t GetUnauthorizedSteamID();
     uint64_t GetSteamID();
 
     void* GetController();
@@ -89,6 +92,9 @@ class Player
 
     void SetButtons(uint64_t button);
 
+    void SetAuthorized(bool state);
+    bool IsAuthorized();
+
     CPlayerBitVec m_selfMutes[64] = {};
 };