diff --git a/CHANGELOG.md b/CHANGELOG.md index b0876f5a..7e62a791 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,10 @@ +## 2023/12/21 + +* fixed print issues some places +* added option to auth with new Ticket! + +--- + * `settings_parser.cpp`: - cleanup the settings parser code by split it into functions - increase the buffer size for `account_name` to 100 chars diff --git a/dll/auth.cpp b/dll/auth.cpp new file mode 100644 index 00000000..bcf143de --- /dev/null +++ b/dll/auth.cpp @@ -0,0 +1,294 @@ +#include "auth.h" + +static void steam_auth_manager_ticket_callback(void *object, Common_Message *msg) +{ + PRINT_DEBUG("steam_auth_manager_ticket_callback\n"); + + Auth_Manager *auth_manager = (Auth_Manager *)object; + auth_manager->Callback(msg); +} + +Auth_Manager::Auth_Manager(class Settings *settings, class Networking *network, class SteamCallBacks *callbacks) { + this->network = network; + this->settings = settings; + this->callbacks = callbacks; + + this->network->setCallback(CALLBACK_ID_AUTH_TICKET, settings->get_local_steam_id(), &steam_auth_manager_ticket_callback, this); + this->network->setCallback(CALLBACK_ID_USER_STATUS, settings->get_local_steam_id(), &steam_auth_manager_ticket_callback, this); +} + +#define STEAM_TICKET_PROCESS_TIME 0.03 + +void Auth_Manager::launch_callback(CSteamID id, EAuthSessionResponse resp, double delay) +{ + ValidateAuthTicketResponse_t data; + data.m_SteamID = id; + data.m_eAuthSessionResponse = resp; + data.m_OwnerSteamID = id; + callbacks->addCBResult(data.k_iCallback, &data, sizeof(data), delay); +} + +void Auth_Manager::launch_callback_gs(CSteamID id, bool approved) +{ + if (approved) { + GSClientApprove_t data; + data.m_SteamID = data.m_OwnerSteamID = id; + callbacks->addCBResult(data.k_iCallback, &data, sizeof(data)); + } else { + GSClientDeny_t data; + data.m_SteamID = id; + data.m_eDenyReason = k_EDenyNotLoggedOn; //TODO: other reasons? + callbacks->addCBResult(data.k_iCallback, &data, sizeof(data)); + } +} + +#define STEAM_ID_OFFSET_TICKET (4 + 8) +#define STEAM_TICKET_MIN_SIZE (4 + 8 + 8) +#define STEAM_TICKET_MIN_SIZE_NEW 170 +Auth_Data Auth_Manager::getTicketData( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) +{ + Auth_Data ticket_data; + uint64 steam_id = settings->get_local_steam_id().ConvertToUint64(); + if (settings->enable_new_app_ticket) + { + ticket_data.id = settings->get_local_steam_id(); + ticket_data.number = generate_steam_ticket_id(); + ticket_data.Ticket.Version = 4; + ticket_data.Ticket.id = settings->get_local_steam_id(); + ticket_data.Ticket.AppId = settings->get_local_game_id().AppID(); + ticket_data.Ticket.ExternalIP = 16777343; //127.0.0.1 + ticket_data.Ticket.InternalIP = 16777343; //127.0.0.1 + ticket_data.Ticket.AlwaysZero = 0; + const auto curTime = std::chrono::system_clock::now(); + const auto GenDate = std::chrono::duration_cast(curTime.time_since_epoch()).count(); + ticket_data.Ticket.TicketGeneratedDate = GenDate; + uint32_t expTime = GenDate+100000; + ticket_data.Ticket.TicketGeneratedExpireDate = expTime; + ticket_data.Ticket.Licenses.resize(0); + ticket_data.Ticket.Licenses.push_back(0); + unsigned int dlcCount = settings->DLCCount(); + ticket_data.Ticket.DLCs.resize(0); //currently set to 0 + for (int i = 0; i <= dlcCount; ++i) + { + DLC dlc; + AppId_t appid; + bool available; + std::string name; + if (!settings->getDLC(i, appid, available, name)) break; + dlc.AppId = (uint32_t)appid; + dlc.Licenses.resize(0); + ticket_data.Ticket.DLCs.push_back(dlc); + } + ticket_data.HasGC = false; + if (settings->use_gc_token) + { + ticket_data.HasGC = true; + ticket_data.GC.GCToken = generate_random_int(); + ticket_data.GC.id = settings->get_local_steam_id(); + ticket_data.GC.ticketGenDate = GenDate; + ticket_data.GC.ExternalIP = 16777343; + ticket_data.GC.InternalIP = 16777343; + ticket_data.GC.TimeSinceStartup = generate_random_int(); + ticket_data.GC.TicketGeneratedCount = 1; + } + std::vector ser = ticket_data.Serialize(); + *pcbTicket = ser.size(); + memcpy(pTicket, ser.data(), ser.size()); + } + else + { + memset(pTicket, 123, cbMaxTicket); + ((char *)pTicket)[0] = 0x14; + ((char *)pTicket)[1] = 0; + ((char *)pTicket)[2] = 0; + ((char *)pTicket)[3] = 0; + memcpy((char *)pTicket + STEAM_ID_OFFSET_TICKET, &steam_id, sizeof(steam_id)); + *pcbTicket = cbMaxTicket; + + ticket_data.id = settings->get_local_steam_id(); + ticket_data.number = generate_steam_ticket_id(); + uint32 ttt = ticket_data.number; + + memcpy(((char *)pTicket) + sizeof(uint64), &ttt, sizeof(ttt)); + } + return ticket_data; +} +//Conan Exiles doesn't work with 512 or 128, 256 seems to be the good size +//Steam returns 234 +#define STEAM_AUTH_TICKET_SIZE 256 //234 + +uint32 Auth_Manager::getTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ) +{ + if (settings->enable_new_app_ticket) + { + if (cbMaxTicket < STEAM_TICKET_MIN_SIZE_NEW) return 0; + } + else + { + if (cbMaxTicket < STEAM_TICKET_MIN_SIZE) return 0; + if (cbMaxTicket > STEAM_AUTH_TICKET_SIZE) cbMaxTicket = STEAM_AUTH_TICKET_SIZE; + } + + Auth_Data ticket_data = getTicketData(pTicket, cbMaxTicket, pcbTicket ); + uint32 ttt = ticket_data.number; + GetAuthSessionTicketResponse_t data; + data.m_hAuthTicket = ttt; + data.m_eResult = k_EResultOK; + callbacks->addCBResult(data.k_iCallback, &data, sizeof(data), STEAM_TICKET_PROCESS_TIME); + + outbound.push_back(ticket_data); + + return ttt; +} + +uint32 Auth_Manager::getWebApiTicket( const char* pchIdentity ) +{ + // https://docs.unity.com/ugs/en-us/manual/authentication/manual/platform-signin-steam + GetTicketForWebApiResponse_t data{}; + uint32 cbTicket = 0; + Auth_Data ticket_data = getTicketData(data.m_rgubTicket, STEAM_AUTH_TICKET_SIZE, &cbTicket); + data.m_cubTicket = (int)cbTicket; + uint32 ttt = ticket_data.number; + data.m_hAuthTicket = ttt; + data.m_eResult = k_EResultOK; + callbacks->addCBResult(data.k_iCallback, &data, sizeof(data), STEAM_TICKET_PROCESS_TIME); + + outbound.push_back(ticket_data); + + return ttt; +} + +CSteamID Auth_Manager::fakeUser() +{ + Auth_Data data = {}; + data.id = generate_steam_anon_user(); + inbound.push_back(data); + return data.id; +} + +void Auth_Manager::cancelTicket(uint32 number) +{ + auto ticket = std::find_if(outbound.begin(), outbound.end(), [&number](Auth_Data const& item) { return item.number == number; }); + if (outbound.end() == ticket) + return; + + Auth_Ticket *auth_ticket = new Auth_Ticket(); + auth_ticket->set_number(number); + auth_ticket->set_type(Auth_Ticket::CANCEL); + Common_Message msg; + msg.set_source_id(settings->get_local_steam_id().ConvertToUint64()); + msg.set_allocated_auth_ticket(auth_ticket); + network->sendToAll(&msg, true); + + outbound.erase(ticket); +} + +bool Auth_Manager::SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ) +{ + if (cubAuthBlobSize < STEAM_TICKET_MIN_SIZE) return false; + + Auth_Data data; + uint64 id; + memcpy(&id, (char *)pvAuthBlob + STEAM_ID_OFFSET_TICKET, sizeof(id)); + uint32 number; + memcpy(&number, ((char *)pvAuthBlob) + sizeof(uint64), sizeof(number)); + data.id = CSteamID(id); + data.number = number; + if (pSteamIDUser) *pSteamIDUser = data.id; + + for (auto & t : inbound) { + if (t.id == data.id) { + //Should this return false? + launch_callback_gs(id, true); + return true; + } + } + + inbound.push_back(data); + launch_callback_gs(id, true); + return true; +} + +EBeginAuthSessionResult Auth_Manager::beginAuth(const void *pAuthTicket, int cbAuthTicket, CSteamID steamID ) +{ + if (cbAuthTicket < STEAM_TICKET_MIN_SIZE) return k_EBeginAuthSessionResultInvalidTicket; + + Auth_Data data; + uint64 id; + memcpy(&id, (char *)pAuthTicket + STEAM_ID_OFFSET_TICKET, sizeof(id)); + uint32 number; + memcpy(&number, ((char *)pAuthTicket) + sizeof(uint64), sizeof(number)); + data.id = CSteamID(id); + data.number = number; + data.created = std::chrono::high_resolution_clock::now(); + + for (auto & t : inbound) { + if (t.id == data.id && !check_timedout(t.created, STEAM_TICKET_PROCESS_TIME)) { + return k_EBeginAuthSessionResultDuplicateRequest; + } + } + + inbound.push_back(data); + launch_callback(steamID, k_EAuthSessionResponseOK, STEAM_TICKET_PROCESS_TIME); + return k_EBeginAuthSessionResultOK; +} + +uint32 Auth_Manager::countInboundAuth() +{ + return inbound.size(); +} + +bool Auth_Manager::endAuth(CSteamID id) +{ + bool erased = false; + auto t = std::begin(inbound); + while (t != std::end(inbound)) { + if (t->id == id) { + erased = true; + t = inbound.erase(t); + } else { + ++t; + } + } + + return erased; +} + +void Auth_Manager::Callback(Common_Message *msg) +{ + if (msg->has_low_level()) { + if (msg->low_level().type() == Low_Level::CONNECT) { + + } + + if (msg->low_level().type() == Low_Level::DISCONNECT) { + PRINT_DEBUG("TICKET DISCONNECT\n"); + auto t = std::begin(inbound); + while (t != std::end(inbound)) { + if (t->id.ConvertToUint64() == msg->source_id()) { + launch_callback(t->id, k_EAuthSessionResponseUserNotConnectedToSteam); + t = inbound.erase(t); + } else { + ++t; + } + } + } + } + + if (msg->has_auth_ticket()) { + if (msg->auth_ticket().type() == Auth_Ticket::CANCEL) { + PRINT_DEBUG("TICKET CANCEL %llu\n", msg->source_id()); + uint32 number = msg->auth_ticket().number(); + auto t = std::begin(inbound); + while (t != std::end(inbound)) { + if (t->id.ConvertToUint64() == msg->source_id() && t->number == number) { + PRINT_DEBUG("TICKET CANCELED\n"); + launch_callback(t->id, k_EAuthSessionResponseAuthTicketCanceled); + t = inbound.erase(t); + } else { + ++t; + } + } + } + } +} \ No newline at end of file diff --git a/dll/auth.h b/dll/auth.h new file mode 100644 index 00000000..7c9b88af --- /dev/null +++ b/dll/auth.h @@ -0,0 +1,182 @@ +#ifndef AUTH_INCLUDE +#define AUTH_INCLUDE + +#include "base.h" +//#include "common_includes.h" +#include "../sha/sha1.hpp" +#include +#include +#include +#include + +#define STEAM_APPTICKET_SIGLEN 128 +#define STEAM_APPTICKET_GCLen 20 +#define STEAM_APPTICKET_SESSIONLEN 24 + +struct DLC { + uint32_t AppId; + std::vector Licenses; +}; + +struct AppTicketGC { + uint64 GCToken; + CSteamID id; + uint32_t ticketGenDate; //epoch + uint32_t one = 1; + uint32_t two = 2; + uint32_t ExternalIP; + uint32_t InternalIP; + uint32_t TimeSinceStartup; + uint32_t TicketGeneratedCount; + + std::vector Serialize() + { + std::vector buffer; + uint8_t* pBuffer; + buffer.resize(52); + pBuffer = buffer.data(); + PRINT_DEBUG("AppTicketGC: Token: %I64u Startup: %u count: %u", GCToken, TimeSinceStartup, TicketGeneratedCount); + *reinterpret_cast(pBuffer) = STEAM_APPTICKET_GCLen; pBuffer += 4; + *reinterpret_cast(pBuffer) = GCToken; pBuffer += 8; + *reinterpret_cast(pBuffer) = id.ConvertToUint64(); pBuffer += 8; + *reinterpret_cast(pBuffer) = ticketGenDate; pBuffer += 4; + *reinterpret_cast(pBuffer) = STEAM_APPTICKET_SESSIONLEN; pBuffer += 4; + *reinterpret_cast(pBuffer) = one; pBuffer += 4; + *reinterpret_cast(pBuffer) = two; pBuffer += 4; + *reinterpret_cast(pBuffer) = ExternalIP; pBuffer += 4; + *reinterpret_cast(pBuffer) = InternalIP; pBuffer += 4; + *reinterpret_cast(pBuffer) = TimeSinceStartup; pBuffer += 4; + *reinterpret_cast(pBuffer) = TicketGeneratedCount; pBuffer += 4; + PRINT_DEBUG("AppTicketGC SER: %s\n",uint8_vector_to_hex_string(buffer).c_str()); + return buffer; + } +}; + +struct AppTicket { + uint32_t Version; + CSteamID id; + uint32_t AppId; + uint32_t ExternalIP; + uint32_t InternalIP; + uint32_t AlwaysZero = 0; //OwnershipFlags? + uint32_t TicketGeneratedDate; + uint32_t TicketGeneratedExpireDate; + std::vector Licenses; + std::vector DLCs; + + std::vector Serialize() + { + std::vector buffer; + uint8_t* pBuffer; + PRINT_DEBUG("AppTicket Licenses Size : %u, DLCs: %u\n",(uint16_t)Licenses.size(), (uint16_t)DLCs.size()); + uint32_t licSize = Licenses.size() * 4; + uint32_t dlcSize = 0; + for(DLC dlc_s : DLCs) + { + dlcSize += 4; + dlcSize += 2; + dlcSize += (uint32_t)dlc_s.Licenses.size() * 4; + } + PRINT_DEBUG("AppTicket Size: %i \n" + (42 + licSize + dlcSize)); + buffer.resize(42 + licSize+ dlcSize); + pBuffer = buffer.data(); + *reinterpret_cast(pBuffer) = Version; pBuffer += 4; + *reinterpret_cast(pBuffer) = id.ConvertToUint64(); pBuffer += 8; + *reinterpret_cast(pBuffer) = AppId; pBuffer += 4; + *reinterpret_cast(pBuffer) = ExternalIP; pBuffer += 4; + *reinterpret_cast(pBuffer) = InternalIP; pBuffer += 4; + *reinterpret_cast(pBuffer) = AlwaysZero; pBuffer += 4; + *reinterpret_cast(pBuffer) = TicketGeneratedDate; pBuffer += 4; + *reinterpret_cast(pBuffer) = TicketGeneratedExpireDate; pBuffer += 4; + PRINT_DEBUG("AppTicket SER (before): %s\n",uint8_vector_to_hex_string(buffer).c_str()); + *reinterpret_cast(pBuffer) = (uint16_t)Licenses.size(); pBuffer += 2; + + for(uint32_t license : Licenses) + { + *reinterpret_cast(pBuffer) = license; pBuffer += 4; + } + + *reinterpret_cast(pBuffer) = (uint16_t)DLCs.size(); pBuffer += 2; + + for(DLC dlc : DLCs) + { + *reinterpret_cast(pBuffer) = dlc.AppId; pBuffer += 4; + *reinterpret_cast(pBuffer) = (uint16_t)dlc.Licenses.size(); pBuffer += 2; + + for(uint32_t dlc_license : dlc.Licenses) + { + *reinterpret_cast(pBuffer) = dlc_license; pBuffer += 4; + } + } + + *reinterpret_cast(pBuffer) = (uint16_t)0; pBuffer += 2; //padding + PRINT_DEBUG("AppTicket SER : %s\n",uint8_vector_to_hex_string(buffer).c_str()); + return buffer; + } +}; +struct Auth_Data { + bool HasGC; + AppTicketGC GC; + AppTicket Ticket; + //old data + CSteamID id; + uint64 number; + std::chrono::high_resolution_clock::time_point created; + + std::vector Serialize() + { + std::vector buffer; + uint8_t* pBuffer; + + std::vector tickedData = Ticket.Serialize(); + uint32_t size = tickedData.size() + 4; + std::vector GCData; + if (HasGC) + { + GCData = GC.Serialize(); + size += GCData.size() + 4; + } + PRINT_DEBUG("Ticket Ser Size: %u\n", size); + buffer.resize(size+STEAM_APPTICKET_SIGLEN); + pBuffer = buffer.data(); + if (HasGC) + { + memcpy(pBuffer, GCData.data(), GCData.size()); + pBuffer+= GCData.size(); + *reinterpret_cast(pBuffer) = (128+tickedData.size()+4); pBuffer += 4; + } + + *reinterpret_cast(pBuffer) = (tickedData.size()+4); pBuffer += 4; + memcpy(pBuffer, tickedData.data(), tickedData.size()); + PRINT_DEBUG("Auth_Data SER : %s\n",uint8_vector_to_hex_string(buffer).c_str()); + //Todo make a signature + return buffer; + } +}; + + + +class Auth_Manager { + class Settings *settings; + class Networking *network; + class SteamCallBacks *callbacks; + + void launch_callback(CSteamID id, EAuthSessionResponse resp, double delay=0); + void launch_callback_gs(CSteamID id, bool approved); + std::vector inbound, outbound; +public: + Auth_Manager(class Settings *settings, class Networking *network, class SteamCallBacks *callbacks); + + void Callback(Common_Message *msg); + uint32 getTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ); + uint32 getWebApiTicket( const char *pchIdentity ); + void cancelTicket(uint32 number); + EBeginAuthSessionResult beginAuth(const void *pAuthTicket, int cbAuthTicket, CSteamID steamID); + bool endAuth(CSteamID id); + uint32 countInboundAuth(); + bool SendUserConnectAndAuthenticate( uint32 unIPClient, const void *pvAuthBlob, uint32 cubAuthBlobSize, CSteamID *pSteamIDUser ); + CSteamID fakeUser(); + Auth_Data getTicketData( void *pTicket, int cbMaxTicket, uint32 *pcbTicket ); +}; + +#endif \ No newline at end of file diff --git a/dll/base.cpp b/dll/base.cpp index d8902baf..ec299277 100644 --- a/dll/base.cpp +++ b/dll/base.cpp @@ -118,7 +118,7 @@ int generate_random_int() { return a; } -static uint32 generate_steam_ticket_id() { +uint32 generate_steam_ticket_id() { /* not random starts with 2? */ static uint32 a = 1; ++a; @@ -140,7 +140,7 @@ CSteamID generate_steam_id_user() return CSteamID(generate_account_id(), k_unSteamUserDefaultInstance, k_EUniversePublic, k_EAccountTypeIndividual); } -static CSteamID generate_steam_anon_user() +CSteamID generate_steam_anon_user() { return CSteamID(generate_account_id(), k_unSteamUserDefaultInstance, k_EUniversePublic, k_EAccountTypeAnonUser); } @@ -160,6 +160,22 @@ CSteamID generate_steam_id_lobby() return CSteamID(generate_account_id(), k_EChatInstanceFlagLobby | k_EChatInstanceFlagMMSLobby, k_EUniversePublic, k_EAccountTypeChat); } +std::string uint8_vector_to_hex_string(std::vector& v) +{ + std::string result; + result.reserve(v.size() * 2); // two digits per character + + static constexpr char hex[] = "0123456789ABCDEF"; + + for (uint8_t c : v) + { + result.push_back(hex[c / 16]); + result.push_back(hex[c % 16]); + } + + return result; +} + bool check_timedout(std::chrono::high_resolution_clock::time_point old, double timeout) { if (timeout == 0.0) return true; diff --git a/dll/base.h b/dll/base.h index d9fcbd0a..cb4707f4 100644 --- a/dll/base.h +++ b/dll/base.h @@ -94,12 +94,15 @@ struct Steam_Call_Result { int iCallback; }; +uint32 generate_steam_ticket_id(); int generate_random_int(); SteamAPICall_t generate_steam_api_call_id(); CSteamID generate_steam_id_user(); +CSteamID generate_steam_anon_user(); CSteamID generate_steam_id_server(); CSteamID generate_steam_id_anonserver(); CSteamID generate_steam_id_lobby(); +std::string uint8_vector_to_hex_string(std::vector& v); std::string get_full_lib_path(); std::string get_full_program_path(); std::string get_current_path(); diff --git a/dll/local_storage.cpp b/dll/local_storage.cpp index 82bf4605..dcd41a47 100644 --- a/dll/local_storage.cpp +++ b/dll/local_storage.cpp @@ -739,7 +739,7 @@ bool Local_Storage::load_json(std::string full_path, nlohmann::json& json) try { json = std::move(nlohmann::json::parse(buffer)); - PRINT_DEBUG("Loaded json \"%s\". Loaded %u items.\n", full_path.c_str(), json.size()); + PRINT_DEBUG("Loaded json \"%s\". Loaded %zu items.\n", full_path.c_str(), json.size()); return true; } catch (std::exception& e) { PRINT_DEBUG("Error while parsing \"%s\" json: %s\n", full_path.c_str(), e.what()); diff --git a/dll/network.cpp b/dll/network.cpp index cd7c6a42..7c681283 100644 --- a/dll/network.cpp +++ b/dll/network.cpp @@ -514,7 +514,7 @@ std::set Networking::resolve_ip(std::string dns) if (getaddrinfo(dns.c_str(), NULL, NULL, &result) == 0) { for (struct addrinfo *res = result; res != NULL; res = res->ai_next) { - PRINT_DEBUG("%u %u\n", res->ai_addrlen, res->ai_family); + PRINT_DEBUG("%zu %u\n", res->ai_addrlen, res->ai_family); if (res->ai_family == AF_INET) { struct sockaddr_in *ipv4 = (struct sockaddr_in *)res->ai_addr; uint32 ip; diff --git a/dll/settings.h b/dll/settings.h index 0c0f7924..30e95c6a 100644 --- a/dll/settings.h +++ b/dll/settings.h @@ -254,6 +254,12 @@ public: //steam deck flag bool steam_deck = false; + + // can use GC token for generation + bool use_gc_token = false; + + // use new app_ticket auth instead of old one + bool enable_new_app_ticket = false; }; #endif diff --git a/dll/settings_parser.cpp b/dll/settings_parser.cpp index b91a7c9a..58f931ab 100644 --- a/dll/settings_parser.cpp +++ b/dll/settings_parser.cpp @@ -264,7 +264,7 @@ static void load_gamecontroller_settings(Settings *settings) } settings->controller_settings.action_sets[action_set_name] = button_pairs; - PRINT_DEBUG("Added %u action names to %s\n", button_pairs.size(), action_set_name.c_str()); + PRINT_DEBUG("Added %zu action names to %s\n", button_pairs.size(), action_set_name.c_str()); } } @@ -993,6 +993,8 @@ uint32 create_localstorage_settings(Settings **settings_client_out, Settings **s bool disable_account_avatar = false; bool achievement_bypass = false; bool is_beta_branch = false; + bool use_gc_token = false; + bool enable_new_app_ticket = false; int build_id = 10; bool warn_forced = false; @@ -1040,6 +1042,10 @@ uint32 create_localstorage_settings(Settings **settings_client_out, Settings **s warn_forced = parse_force_listen_port(port, steam_settings_path); } else if (p == "build_id.txt") { parse_build_id(build_id, steam_settings_path); + } else if (p == "new_app_ticket.txt") { + enable_new_app_ticket = true; + } else if (p == "gc_token.txt") { + use_gc_token = true; } } } @@ -1082,6 +1088,10 @@ uint32 create_localstorage_settings(Settings **settings_client_out, Settings **s settings_server->achievement_bypass = achievement_bypass; settings_client->is_beta_branch = is_beta_branch; settings_server->is_beta_branch = is_beta_branch; + settings_client->enable_new_app_ticket = enable_new_app_ticket; + settings_server->enable_new_app_ticket = enable_new_app_ticket; + settings_client->use_gc_token = use_gc_token; + settings_server->use_gc_token = use_gc_token; if (local_save) { settings_client->local_save = save_path; diff --git a/dll/steam_gameserver.cpp b/dll/steam_gameserver.cpp index c680cc5f..aa2d5072 100644 --- a/dll/steam_gameserver.cpp +++ b/dll/steam_gameserver.cpp @@ -26,12 +26,12 @@ Steam_GameServer::Steam_GameServer(class Settings *settings, class Networking *n this->settings = settings; server_data.set_id(settings->get_local_steam_id().ConvertToUint64()); this->callbacks = callbacks; - ticket_manager = new Auth_Ticket_Manager(settings, network, callbacks); + auth_manager = new Auth_Manager(settings, network, callbacks); } Steam_GameServer::~Steam_GameServer() { - delete ticket_manager; + delete auth_manager; } std::vector>* Steam_GameServer::get_players() @@ -369,7 +369,7 @@ bool Steam_GameServer::SendUserConnectAndAuthenticate( uint32 unIPClient, const PRINT_DEBUG("SendUserConnectAndAuthenticate %u %u\n", unIPClient, cubAuthBlobSize); std::lock_guard lock(global_mutex); - bool res = ticket_manager->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser); + bool res = auth_manager->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser); if (res) { std::pair infos; @@ -397,7 +397,7 @@ CSteamID Steam_GameServer::CreateUnauthenticatedUserConnection() PRINT_DEBUG("CreateUnauthenticatedUserConnection\n"); std::lock_guard lock(global_mutex); - CSteamID bot_id = ticket_manager->fakeUser(); + CSteamID bot_id = auth_manager->fakeUser(); std::pair infos; infos.first = bot_id; infos.second.join_time = std::chrono::steady_clock::now(); @@ -427,7 +427,7 @@ void Steam_GameServer::SendUserDisconnect( CSteamID steamIDUser ) players.erase(player_it); } - ticket_manager->endAuth(steamIDUser); + auth_manager->endAuth(steamIDUser); } @@ -554,7 +554,7 @@ HAuthTicket Steam_GameServer::GetAuthSessionTicket( void *pTicket, int cbMaxTick PRINT_DEBUG("Steam_GameServer::GetAuthSessionTicket\n"); std::lock_guard lock(global_mutex); - return ticket_manager->getTicket(pTicket, cbMaxTicket, pcbTicket); + return auth_manager->getTicket(pTicket, cbMaxTicket, pcbTicket); } @@ -572,7 +572,7 @@ EBeginAuthSessionResult Steam_GameServer::BeginAuthSession( const void *pAuthTic infos.second.name = "unnamed"; players.emplace_back(std::move(infos)); - return ticket_manager->beginAuth(pAuthTicket, cbAuthTicket, steamID ); + return auth_manager->beginAuth(pAuthTicket, cbAuthTicket, steamID ); } @@ -592,7 +592,7 @@ void Steam_GameServer::EndAuthSession( CSteamID steamID ) players.erase(player_it); } - ticket_manager->endAuth(steamID); + auth_manager->endAuth(steamID); } @@ -602,7 +602,7 @@ void Steam_GameServer::CancelAuthTicket( HAuthTicket hAuthTicket ) PRINT_DEBUG("Steam_GameServer::CancelAuthTicket\n"); std::lock_guard lock(global_mutex); - ticket_manager->cancelTicket(hAuthTicket); + auth_manager->cancelTicket(hAuthTicket); } @@ -821,7 +821,7 @@ void Steam_GameServer::RunCallbacks() msg.set_source_id(settings->get_local_steam_id().ConvertToUint64()); server_data.set_appid(settings->get_local_game_id().AppID()); msg.set_allocated_gameserver(new Gameserver(server_data)); - msg.mutable_gameserver()->set_num_players(ticket_manager->countInboundAuth()); + msg.mutable_gameserver()->set_num_players(auth_manager->countInboundAuth()); network->sendToAllIndividuals(&msg, true); last_sent_server_info = std::chrono::high_resolution_clock::now(); } diff --git a/dll/steam_gameserver.h b/dll/steam_gameserver.h index 9a963264..04244485 100644 --- a/dll/steam_gameserver.h +++ b/dll/steam_gameserver.h @@ -16,7 +16,8 @@ . */ #include "base.h" - +#include "auth.h" + //----------------------------------------------------------------------------- // Purpose: Functions for authenticating users via Steam to play on a game server //----------------------------------------------------------------------------- @@ -62,7 +63,7 @@ public ISteamGameServer bool policy_response_called; std::chrono::high_resolution_clock::time_point last_sent_server_info; - Auth_Ticket_Manager *ticket_manager; + Auth_Manager *auth_manager; std::vector outgoing_packets; public: diff --git a/dll/steam_matchmaking_servers.cpp b/dll/steam_matchmaking_servers.cpp index 941fa058..12e52acc 100644 --- a/dll/steam_matchmaking_servers.cpp +++ b/dll/steam_matchmaking_servers.cpp @@ -508,7 +508,7 @@ gameserveritem_t *Steam_Matchmaking_Servers::GetServerDetails( HServerListReques PRINT_DEBUG("equal? %p %p\n", hRequest, g->id); if (g->id == hRequest) { gameservers_filtered = g->gameservers_filtered; - PRINT_DEBUG("found %u\n", gameservers_filtered.size()); + PRINT_DEBUG("found %zu\n", gameservers_filtered.size()); break; } diff --git a/dll/steam_networking_sockets.h b/dll/steam_networking_sockets.h index b19509ec..fb60b099 100644 --- a/dll/steam_networking_sockets.h +++ b/dll/steam_networking_sockets.h @@ -881,7 +881,7 @@ SteamNetworkingMessage_t *get_steam_message_connection(HSteamNetConnection hConn pMsg->m_pfnRelease = &delete_steam_message; pMsg->m_nChannel = 0; connect_socket->second.data.pop(); - PRINT_DEBUG("get_steam_message_connection %u %u, %u\n", hConn, size, pMsg->m_nMessageNumber); + PRINT_DEBUG("get_steam_message_connection %u %lu, %I64\n", hConn, size, pMsg->m_nMessageNumber); return pMsg; } @@ -2093,13 +2093,13 @@ void Callback(Common_Message *msg) auto connect_socket = s->connect_sockets.find(msg->networking_sockets().connection_id()); if (connect_socket != s->connect_sockets.end()) { if (connect_socket->second.remote_identity.GetSteamID64() == msg->source_id() && (connect_socket->second.status == CONNECT_SOCKET_CONNECTED)) { - PRINT_DEBUG("Steam_Networking_Sockets: got data len %u, num %u on connection %u\n", msg->networking_sockets().data().size(), msg->networking_sockets().message_number(), connect_socket->first); + PRINT_DEBUG("Steam_Networking_Sockets: got data len %zu, num %I64u on connection %u\n", msg->networking_sockets().data().size(), msg->networking_sockets().message_number(), connect_socket->first); connect_socket->second.data.push(msg->networking_sockets()); } } else { connect_socket = std::find_if(s->connect_sockets.begin(), s->connect_sockets.end(), [msg](const auto &in) {return in.second.remote_identity.GetSteamID64() == msg->source_id() && (in.second.status == CONNECT_SOCKET_NOT_ACCEPTED || in.second.status == CONNECT_SOCKET_CONNECTED) && in.second.remote_id == msg->networking_sockets().connection_id_from();}); if (connect_socket != s->connect_sockets.end()) { - PRINT_DEBUG("Steam_Networking_Sockets: got data len %u, num %u on not accepted connection %u\n", msg->networking_sockets().data().size(), msg->networking_sockets().message_number(), connect_socket->first); + PRINT_DEBUG("Steam_Networking_Sockets: got data len %zu, num %I64u on not accepted connection %u\n", msg->networking_sockets().data().size(), msg->networking_sockets().message_number(), connect_socket->first); connect_socket->second.data.push(msg->networking_sockets()); } } diff --git a/dll/steam_networking_utils.h b/dll/steam_networking_utils.h index 0e5388e3..4a0aa814 100644 --- a/dll/steam_networking_utils.h +++ b/dll/steam_networking_utils.h @@ -358,7 +358,7 @@ bool SetConnectionConfigValueString( HSteamNetConnection hConn, ESteamNetworking bool SetConfigValue( ESteamNetworkingConfigValue eValue, ESteamNetworkingConfigScope eScopeType, intptr_t scopeObj, ESteamNetworkingConfigDataType eDataType, const void *pArg ) { - PRINT_DEBUG("Steam_Networking_Utils::SetConfigValue %i %i %p %i %p\n", eValue, eScopeType, scopeObj, eDataType, pArg); + PRINT_DEBUG("Steam_Networking_Utils::SetConfigValue %i %i %tf %i %p\n", eValue, eScopeType, scopeObj, eDataType, pArg); return true; } diff --git a/dll/steam_user.h b/dll/steam_user.h index d634a9a6..f2678fe6 100644 --- a/dll/steam_user.h +++ b/dll/steam_user.h @@ -16,7 +16,7 @@ . */ #include "base.h" - +#include "auth.h" #include "appticket.h" class Steam_User : @@ -44,7 +44,7 @@ public ISteamUser bool recording = false; std::chrono::high_resolution_clock::time_point last_get_voice; std::string encrypted_app_ticket; - Auth_Ticket_Manager *ticket_manager; + Auth_Manager *auth_manager; public: @@ -56,12 +56,12 @@ Steam_User(Settings *settings, Local_Storage *local_storage, class Networking *n this->callbacks = callbacks; this->callback_results = callback_results; recording = false; - ticket_manager = new Auth_Ticket_Manager(settings, network, callbacks); + auth_manager = new Auth_Manager(settings, network, callbacks); } ~Steam_User() { - delete ticket_manager; + delete auth_manager; } // returns the HSteamUser this interface represents @@ -116,7 +116,7 @@ int InitiateGameConnection( void *pAuthBlob, int cbMaxAuthBlob, CSteamID steamID std::lock_guard lock(global_mutex); if (cbMaxAuthBlob < INITIATE_GAME_CONNECTION_TICKET_SIZE) return 0; uint32 out_size = INITIATE_GAME_CONNECTION_TICKET_SIZE; - ticket_manager->getTicketData(pAuthBlob, INITIATE_GAME_CONNECTION_TICKET_SIZE, &out_size); + auth_manager->getTicketData(pAuthBlob, INITIATE_GAME_CONNECTION_TICKET_SIZE, &out_size); return out_size; } @@ -311,7 +311,7 @@ HAuthTicket GetAuthSessionTicket( void *pTicket, int cbMaxTicket, uint32 *pcbTic PRINT_DEBUG("Steam_User::GetAuthSessionTicket %i\n", cbMaxTicket); std::lock_guard lock(global_mutex); - return ticket_manager->getTicket(pTicket, cbMaxTicket, pcbTicket); + return auth_manager->getTicket(pTicket, cbMaxTicket, pcbTicket); } // Request a ticket which will be used for webapi "ISteamUserAuth\AuthenticateUserTicket" @@ -322,7 +322,7 @@ HAuthTicket GetAuthTicketForWebApi( const char *pchIdentity ) PRINT_DEBUG("Steam_User::GetAuthTicketForWebApi %s\n", pchIdentity); std::lock_guard lock(global_mutex); - return ticket_manager->getWebApiTicket(pchIdentity); + return auth_manager->getWebApiTicket(pchIdentity); } // Authenticate ticket from entity steamID to be sure it is valid and isnt reused @@ -332,7 +332,7 @@ EBeginAuthSessionResult BeginAuthSession( const void *pAuthTicket, int cbAuthTic PRINT_DEBUG("Steam_User::BeginAuthSession %i %llu\n", cbAuthTicket, steamID.ConvertToUint64()); std::lock_guard lock(global_mutex); - return ticket_manager->beginAuth(pAuthTicket, cbAuthTicket, steamID); + return auth_manager->beginAuth(pAuthTicket, cbAuthTicket, steamID); } // Stop tracking started by BeginAuthSession - called when no longer playing game with this entity @@ -341,7 +341,7 @@ void EndAuthSession( CSteamID steamID ) PRINT_DEBUG("Steam_User::EndAuthSession\n"); std::lock_guard lock(global_mutex); - ticket_manager->endAuth(steamID); + auth_manager->endAuth(steamID); } // Cancel auth ticket from GetAuthSessionTicket, called when no longer playing game with the entity you gave the ticket to @@ -350,7 +350,7 @@ void CancelAuthTicket( HAuthTicket hAuthTicket ) PRINT_DEBUG("Steam_User::CancelAuthTicket\n"); std::lock_guard lock(global_mutex); - ticket_manager->cancelTicket(hAuthTicket); + auth_manager->cancelTicket(hAuthTicket); } // After receiving a user's authentication data, and passing it to BeginAuthSession, use this function diff --git a/files_example/steam_settings.EXAMPLE/gc_token.EXAMPLE.txt b/files_example/steam_settings.EXAMPLE/gc_token.EXAMPLE.txt new file mode 100644 index 00000000..0f5b9861 --- /dev/null +++ b/files_example/steam_settings.EXAMPLE/gc_token.EXAMPLE.txt @@ -0,0 +1 @@ +Rename this to: gc_token.txt to can generate GC inside new App Ticket \ No newline at end of file diff --git a/files_example/steam_settings.EXAMPLE/new_app_ticket.EXAMPLE.txt b/files_example/steam_settings.EXAMPLE/new_app_ticket.EXAMPLE.txt new file mode 100644 index 00000000..55687585 --- /dev/null +++ b/files_example/steam_settings.EXAMPLE/new_app_ticket.EXAMPLE.txt @@ -0,0 +1 @@ +Rename this to: new_app_ticket.txt to generate new app ticket \ No newline at end of file