From 4f2352361a2d4a7d94c70841aa208094cc1a86df Mon Sep 17 00:00:00 2001 From: MrTheShy <49885496+MrTheShy@users.noreply.github.com> Date: Mon, 23 Mar 2026 01:14:23 +0100 Subject: [PATCH] Add Mojang/Ely.by/offline authentication system MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The old Windows64 port had no real player identity — it used hardcoded fake XUIDs, so anyone could impersonate anyone. This replaces that with proper auth supporting Mojang, Ely.by, and offline accounts. MCAuth library (new, MCAuth/): Mojang auth via MSA device code flow (XBL, SISU, MC services), Ely.by via Yggdrasil with 2FA, offline UUID generation matching Java Edition (MD5 v3 from "OfflinePlayer:"). Multi-account manager with background token refresh, per-slot sessions, and on-disk token persistence. Server-side session verification via Mojang/Ely.by hasJoined API. Skin fetching and PNG validation from texture servers. Network protocol (version bumped to 80): Three new packets (AuthScheme, AuthResponse, AuthResult) implement a server-driven auth handshake before login completes. Player identity migrated from 64-bit XUID to 128-bit GameUUID backed by two uint64 fields (hi/lo). readPlayerUID/writePlayerUID now serialize 16 bytes on the wire. Old and new clients cannot connect to each other — version mismatch is rejected at PreLogin. Save migration: Map data mappings auto-migrate from old format: the old 64-bit XUID is placed in hi, lo is set to 0 as a sentinel. On first access by the real player, the sentinel entry is upgraded in-place to the full 128-bit UUID. Format detection is by file size (2080, 2112, or 4160 bytes). Player .dat filenames inside saveData.ms change from decimal XUID to dashed UUID — old saves need manual entry renaming in the archive. UI: NativeUIRenderer: immediate-mode drawing system (quads, text, 9-slice panels, scrollbars, focus lists) for rendering auth screens without Flash/Scaleform. UIScene_MSAuth handles device code display, Ely.by credential input with 2FA, per-account skin head preview, and multi-account add/remove/switch. Server: online-mode and auth-provider (mojang/elyby) in server.properties. Whitelist and ban checks validate against the server-verified UUID. Incompatible auth scheme logs which provider the server expects vs what the client is using. Also fixes a pre-existing exploit where any client could send a DebugOptionsPacket to grant themselves CraftAnything and other debug privileges on any server — now requires OP status server-side. --- CMakeLists.txt | 2 + MCAuth/CMakeLists.txt | 40 + MCAuth/MCAuth.vcxproj | 156 ++ MCAuth/include/MCAuth.h | 230 ++ MCAuth/include/MCAuthManager.h | 211 ++ MCAuth/src/MCAuthCrypto.cpp | 398 ++++ MCAuth/src/MCAuthCrypto.h | 70 + MCAuth/src/MCAuthElyby.cpp | 169 ++ MCAuth/src/MCAuthHttp.cpp | 221 ++ MCAuth/src/MCAuthHttp.h | 22 + MCAuth/src/MCAuthInternal.h | 205 ++ MCAuth/src/MCAuthJava.cpp | 453 ++++ MCAuth/src/MCAuthManager.cpp | 986 ++++++++ MCAuth/src/MCAuthSession.cpp | 476 ++++ Minecraft.Client/CMakeLists.txt | 1 + Minecraft.Client/ClientConnection.cpp | 478 +++- Minecraft.Client/ClientConnection.h | 12 + Minecraft.Client/Common/Consoles_App.cpp | 39 +- Minecraft.Client/Common/Consoles_App.h | 6 +- .../Common/Media/platformskin.swf | Bin 0 -> 2333333 bytes .../Common/Media/platformskinHD.swf | Bin 0 -> 1967994 bytes .../Common/Network/GameNetworkManager.cpp | 8 +- .../Common/Network/GameNetworkManager.h | 2 +- .../Network/PlatformNetworkManagerInterface.h | 4 +- .../Network/PlatformNetworkManagerStub.cpp | 33 +- .../Network/PlatformNetworkManagerStub.h | 4 +- .../Sony/PlatformNetworkManagerSony.cpp | 4 +- .../Network/Sony/PlatformNetworkManagerSony.h | 4 +- .../Common/UI/IUIScene_PauseMenu.cpp | 4 + .../Common/UI/NativeUIRenderer.cpp | 2030 +++++++++++++++++ Minecraft.Client/Common/UI/NativeUIRenderer.h | 346 +++ Minecraft.Client/Common/UI/UI.h | 3 + Minecraft.Client/Common/UI/UIController.cpp | 21 + Minecraft.Client/Common/UI/UIEnums.h | 1 + Minecraft.Client/Common/UI/UILayer.cpp | 5 + Minecraft.Client/Common/UI/UIScene.cpp | 61 +- .../Common/UI/UIScene_CreateWorldMenu.cpp | 18 + .../Common/UI/UIScene_DLCMainMenu.cpp | 99 +- .../Common/UI/UIScene_DLCMainMenu.h | 12 +- Minecraft.Client/Common/UI/UIScene_HUD.cpp | 8 +- .../Common/UI/UIScene_LoadMenu.cpp | 50 +- Minecraft.Client/Common/UI/UIScene_MSAuth.cpp | 1712 ++++++++++++++ Minecraft.Client/Common/UI/UIScene_MSAuth.h | 158 ++ .../Common/UI/UIScene_MainMenu.cpp | 25 +- .../Common/UI/UIScene_QuadrantSignin.cpp | 20 + .../Common/UI/UIScene_SkinSelectMenu.cpp | 75 +- .../Network/PlatformNetworkManagerDurango.cpp | 4 +- .../Network/PlatformNetworkManagerDurango.h | 4 +- .../Durango/XML/xmlFilesCallback.h | 10 +- Minecraft.Client/Extrax64Stubs.cpp | 98 +- Minecraft.Client/Font.h | 26 + Minecraft.Client/LocalPlayer.cpp | 2 +- Minecraft.Client/Minecraft.cpp | 210 +- Minecraft.Client/Minecraft.h | 24 +- Minecraft.Client/MinecraftServer.cpp | 51 +- Minecraft.Client/MinecraftServer.h | 1 + Minecraft.Client/PS3/XML/xmlFilesCallback.h | 10 +- Minecraft.Client/PendingConnection.cpp | 576 ++++- Minecraft.Client/PendingConnection.h | 32 + Minecraft.Client/PlayerConnection.cpp | 10 +- Minecraft.Client/PlayerConnection.h | 3 +- Minecraft.Client/PlayerList.cpp | 65 +- Minecraft.Client/PlayerList.h | 5 +- Minecraft.Client/ServerConnection.cpp | 17 + Minecraft.Client/ServerConnection.h | 1 + Minecraft.Client/Textures.h | 4 +- Minecraft.Client/TrackedEntity.cpp | 10 +- Minecraft.Client/Windows64/Windows64_App.cpp | 21 +- .../Windows64/Windows64_Minecraft.cpp | 65 +- .../Windows64/Windows64_UIController.cpp | 2 + Minecraft.Client/Windows64/Windows64_Uuid.h | 42 + Minecraft.Client/Windows64/Windows64_Xuid.h | 237 -- .../Network/PlatformNetworkManagerXbox.cpp | 4 +- .../Xbox/Network/PlatformNetworkManagerXbox.h | 4 +- Minecraft.Client/Xbox/XML/xmlFilesCallback.h | 11 +- Minecraft.Client/cmake/sources/Windows.cmake | 5 + Minecraft.Server/Access/Access.cpp | 26 +- Minecraft.Server/CMakeLists.txt | 1 + Minecraft.Server/Common/AccessStorageUtils.h | 23 +- .../Console/commands/ban/CliCommandBan.cpp | 2 - .../commands/pardon/CliCommandPardon.cpp | 4 - Minecraft.Server/ServerProperties.cpp | 15 +- Minecraft.Server/ServerProperties.h | 5 + Minecraft.Server/Windows64/ServerMain.cpp | 4 +- Minecraft.World/AddPlayerPacket.cpp | 17 +- Minecraft.World/AddPlayerPacket.h | 3 +- Minecraft.World/AuthResponsePacket.cpp | 54 + Minecraft.World/AuthResponsePacket.h | 22 + Minecraft.World/AuthResultPacket.cpp | 76 + Minecraft.World/AuthResultPacket.h | 28 + Minecraft.World/AuthSchemePacket.cpp | 56 + Minecraft.World/AuthSchemePacket.h | 22 + Minecraft.World/Connection.cpp | 88 +- Minecraft.World/DataInput.h | 2 +- Minecraft.World/DataInputStream.cpp | 51 +- Minecraft.World/DataInputStream.h | 2 +- Minecraft.World/DataOutput.h | 2 +- Minecraft.World/DataOutputStream.cpp | 18 +- Minecraft.World/Definitions.h | 1 + Minecraft.World/DirectoryLevelStorage.cpp | 111 +- Minecraft.World/DirectoryLevelStorage.h | 21 +- Minecraft.World/DisconnectPacket.h | 23 +- Minecraft.World/GameUUID.cpp | 243 ++ Minecraft.World/GameUUID.h | 58 + Minecraft.World/LevelData.h | 3 +- Minecraft.World/LoginPacket.cpp | 36 +- Minecraft.World/LoginPacket.h | 26 +- Minecraft.World/Packet.cpp | 73 +- Minecraft.World/PacketListener.cpp | 17 + Minecraft.World/PacketListener.h | 10 + Minecraft.World/Player.cpp | 32 +- Minecraft.World/Player.h | 10 +- Minecraft.World/PlayerIO.h | 4 +- Minecraft.World/PreLoginPacket.cpp | 8 +- Minecraft.World/SharedConstants.h | 2 +- Minecraft.World/cmake/sources/Common.cmake | 9 + .../net.minecraft.network.packet.h | 5 + Minecraft.World/resource.h | 14 + Minecraft.World/x64headers/extraX64.h | 13 +- cmake/CopyAssets.cmake | 2 +- cmake/CopyFileScript.cmake | 2 + docs/auth-system.md | 359 +++ include/Common/BuildVer.h | 4 +- 123 files changed, 11017 insertions(+), 1026 deletions(-) create mode 100644 MCAuth/CMakeLists.txt create mode 100644 MCAuth/MCAuth.vcxproj create mode 100644 MCAuth/include/MCAuth.h create mode 100644 MCAuth/include/MCAuthManager.h create mode 100644 MCAuth/src/MCAuthCrypto.cpp create mode 100644 MCAuth/src/MCAuthCrypto.h create mode 100644 MCAuth/src/MCAuthElyby.cpp create mode 100644 MCAuth/src/MCAuthHttp.cpp create mode 100644 MCAuth/src/MCAuthHttp.h create mode 100644 MCAuth/src/MCAuthInternal.h create mode 100644 MCAuth/src/MCAuthJava.cpp create mode 100644 MCAuth/src/MCAuthManager.cpp create mode 100644 MCAuth/src/MCAuthSession.cpp create mode 100644 Minecraft.Client/Common/Media/platformskin.swf create mode 100644 Minecraft.Client/Common/Media/platformskinHD.swf create mode 100644 Minecraft.Client/Common/UI/NativeUIRenderer.cpp create mode 100644 Minecraft.Client/Common/UI/NativeUIRenderer.h create mode 100644 Minecraft.Client/Common/UI/UIScene_MSAuth.cpp create mode 100644 Minecraft.Client/Common/UI/UIScene_MSAuth.h create mode 100644 Minecraft.Client/Windows64/Windows64_Uuid.h delete mode 100644 Minecraft.Client/Windows64/Windows64_Xuid.h create mode 100644 Minecraft.World/AuthResponsePacket.cpp create mode 100644 Minecraft.World/AuthResponsePacket.h create mode 100644 Minecraft.World/AuthResultPacket.cpp create mode 100644 Minecraft.World/AuthResultPacket.h create mode 100644 Minecraft.World/AuthSchemePacket.cpp create mode 100644 Minecraft.World/AuthSchemePacket.h create mode 100644 Minecraft.World/GameUUID.cpp create mode 100644 Minecraft.World/GameUUID.h create mode 100644 Minecraft.World/resource.h create mode 100644 docs/auth-system.md diff --git a/CMakeLists.txt b/CMakeLists.txt index 63071a0ed7..d35b7e6150 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -76,6 +76,7 @@ list(APPEND MINECRAFT_SHARED_DEFINES ${PLATFORM_DEFINES}) # --- # Sources # --- +add_subdirectory(MCAuth) add_subdirectory(Minecraft.World) add_subdirectory(Minecraft.Client) if(PLATFORM_NAME STREQUAL "Windows64") # Server is only supported on Windows for now @@ -111,3 +112,4 @@ set_property(DIRECTORY PROPERTY VS_STARTUP_PROJECT Minecraft.Client) # Setup folders for Visual Studio, just hides the build targets under a sub folder set_property(GLOBAL PROPERTY USE_FOLDERS ON) set_property(TARGET GenerateBuildVer PROPERTY FOLDER "Build") +set_property(TARGET MCAuth PROPERTY FOLDER "Libraries") diff --git a/MCAuth/CMakeLists.txt b/MCAuth/CMakeLists.txt new file mode 100644 index 0000000000..47589ca1a5 --- /dev/null +++ b/MCAuth/CMakeLists.txt @@ -0,0 +1,40 @@ +set(MCAUTH_SOURCES + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthCrypto.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthCrypto.h" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthHttp.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthHttp.h" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthInternal.h" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthJava.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthManager.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthElyby.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/MCAuthSession.cpp" +) +source_group("src" FILES ${MCAUTH_SOURCES}) + +set(MCAUTH_HEADERS + "${CMAKE_CURRENT_SOURCE_DIR}/include/MCAuth.h" + "${CMAKE_CURRENT_SOURCE_DIR}/include/MCAuthManager.h" +) +source_group("include" FILES ${MCAUTH_HEADERS}) + +add_library(MCAuth STATIC ${MCAUTH_SOURCES} ${MCAUTH_HEADERS}) + +target_include_directories(MCAuth + PUBLIC + "${CMAKE_CURRENT_SOURCE_DIR}/include" + PRIVATE + "${CMAKE_CURRENT_SOURCE_DIR}/src" +) + +target_compile_definitions(MCAuth PRIVATE + _LIB + $<$:_DEBUG> + _CRT_SECURE_NO_WARNINGS +) + +configure_compiler_target(MCAuth) + +target_link_libraries(MCAuth PRIVATE + winhttp + bcrypt +) diff --git a/MCAuth/MCAuth.vcxproj b/MCAuth/MCAuth.vcxproj new file mode 100644 index 0000000000..f700df8b70 --- /dev/null +++ b/MCAuth/MCAuth.vcxproj @@ -0,0 +1,156 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + {A1B2C3D4-E5F6-7890-ABCD-EF1234567890} + Win32Proj + MCAuth + 10.0 + + + + + + StaticLibrary + true + v143 + Unicode + + + StaticLibrary + false + v143 + Unicode + + + StaticLibrary + true + v143 + Unicode + + + StaticLibrary + false + v143 + Unicode + + + + + + $(SolutionDir)bin\$(Configuration)\$(Platform)\ + $(SolutionDir)obj\$(ProjectName)\$(Configuration)\$(Platform)\ + + + $(SolutionDir)bin\$(Configuration)\$(Platform)\ + $(SolutionDir)obj\$(ProjectName)\$(Configuration)\$(Platform)\ + + + $(SolutionDir)bin\$(Configuration)\$(Platform)\ + $(SolutionDir)obj\$(ProjectName)\$(Configuration)\$(Platform)\ + + + $(SolutionDir)bin\$(Configuration)\$(Platform)\ + $(SolutionDir)obj\$(ProjectName)\$(Configuration)\$(Platform)\ + + + + + Level3 + true + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + stdcpp17 + $(ProjectDir)include;%(AdditionalIncludeDirectories) + Disabled + MultiThreadedDebug + + + $(OutDir)MCAuth.lib + + + + + + Level3 + true + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + stdcpp17 + $(ProjectDir)include;%(AdditionalIncludeDirectories) + MaxSpeed + true + true + MultiThreaded + + + $(OutDir)MCAuth.lib + + + + + + Level3 + true + WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions) + stdcpp17 + $(ProjectDir)include;%(AdditionalIncludeDirectories) + Disabled + MultiThreadedDebug + + + $(OutDir)MCAuth.lib + + + + + + Level3 + true + WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions) + stdcpp17 + $(ProjectDir)include;%(AdditionalIncludeDirectories) + MaxSpeed + true + true + MultiThreaded + + + $(OutDir)MCAuth.lib + + + + + + + + + + + + + + + + + + + + + diff --git a/MCAuth/include/MCAuth.h b/MCAuth/include/MCAuth.h new file mode 100644 index 0000000000..c2055799a7 --- /dev/null +++ b/MCAuth/include/MCAuth.h @@ -0,0 +1,230 @@ +#pragma once +/* + * MCAuth - Microsoft/Xbox Live Authentication library for Minecraft Java Edition + * C++ port of the MinecraftAuth Java library by RaphiMC + * + * Usage: + * MCAuth::JavaAuthManager auth; + * MCAuth::JavaSession session; + * std::string error; + * + * bool ok = auth.Login( + * [](const MCAuth::DeviceCodeInfo& dc) { + * // Show dc.userCode and dc.directUri to the user + * }, + * session, error + * ); + */ + +#include +#include +#include +#include +#include + +namespace MCAuth { + +// ----- Error codes ----- + +enum class AuthErrorCode { + None = 0, + NetworkTimeout, // connection timed out or DNS failure + NetworkError, // general HTTP/TLS failure (send/receive) + HttpError, // unexpected HTTP status code + InvalidCredentials, // wrong token, expired refresh token, account not authorised + TokenExpired, // access token expired (needs refresh) + ServerUnavailable, // Mojang/MS service returned 5xx + RateLimited, // HTTP 429 + ProfileNotOwned, // MS account exists but doesn't own MC Java Edition + Cancelled, // operation was cancelled (e.g. device code timeout) + InternalError, // unexpected exception / crypto failure +}; + +struct AuthError { + AuthErrorCode code = AuthErrorCode::None; + std::string message; + int httpStatus = 0; // 0 if not applicable + + bool ok() const { return code == AuthErrorCode::None; } + explicit operator bool() const { return !ok(); } // true means error +}; + +// ----- Constants ---- + +// Java Edition title ID (Win32, used for SISU auth flow) +static constexpr const char* JAVA_CLIENT_ID = "00000000402b5328"; + +static constexpr const char* MSA_SCOPE = "service::user.auth.xboxlive.com::MBI_SSL"; + +// ----- Public data types ----- + +struct DeviceCodeInfo { + std::string userCode; // e.g. "ABCD1234" + std::string verificationUri; // e.g. "https://www.microsoft.com/link" + std::string directUri; // verificationUri + "?otc=" + userCode + std::string deviceCode; // internal polling token + int64_t expiresMs; // absolute timestamp (ms since epoch) + int64_t intervalMs; // polling interval in ms +}; + +using DeviceCodeCallback = std::function; + +struct JavaSession { + std::string username; // Minecraft username (from /minecraft/profile) + std::string uuid; // Player UUID (dashed, e.g. "069a79f4-44e9-4726-a5be-fca90e38aaf5") + std::string accessToken; // Full Authorization header value ("Bearer ") + int64_t expireMs; // When the access token expires (ms since epoch) +}; + +// ----- Java Edition auth manager ----- + +class JavaAuthManager { +public: + JavaAuthManager(); + ~JavaAuthManager(); + + JavaAuthManager(const JavaAuthManager&) = delete; + JavaAuthManager& operator=(const JavaAuthManager&) = delete; + + // Synchronous device-code login (blocks until complete or timeout). + bool Login(DeviceCodeCallback onDeviceCode, + JavaSession& outSession, + std::string& error, + int timeoutSeconds = 300); + + // Refresh using the saved MSA refresh token. + bool Refresh(JavaSession& outSession, std::string& error); + + bool IsLoggedIn() const; + void Logout(); + + // Signal a blocking Login() to abort as soon as possible. + // Thread-safe — can be called from any thread while Login() is running. + void RequestCancel(); + + bool SaveTokens(const std::string& filePath) const; + bool LoadTokens(const std::string& filePath); + +private: + struct Impl; + std::unique_ptr m_impl; +}; + +// ----- Ely.by Yggdrasil auth (free functions, no class) ----- + +struct ElybyTokens { + std::string accessToken; + std::string clientToken; + std::string uuid; // undashed + std::string username; +}; + +// POST https://authserver.ely.by/auth/authenticate +// On 2FA requirement, error is set to "elyby_2fa_required"; caller retries with password = "pass:totp_code" +bool ElybyLogin(const std::string& username, const std::string& password, + ElybyTokens& outTokens, std::string& error); + +// POST https://authserver.ely.by/auth/refresh +bool ElybyRefresh(ElybyTokens& tokens, std::string& error); + +// POST https://authserver.ely.by/auth/validate +bool ElybyValidate(const std::string& accessToken, std::string& error); + +// Token persistence — simple JSON: {accessToken, clientToken, uuid, username} +bool ElybyLoadTokens(const std::string& path, ElybyTokens& out); +bool ElybySaveTokens(const std::string& path, const ElybyTokens& tokens); + +// ----- Skin key utility ----- + +// Build the canonical memory-texture key for a Mojang skin. +// uuid can be dashed or undashed — dashes are stripped automatically. +// Returns e.g. "mojang_skin_069a79f444e94726a5befca90e38aaf5.png" +std::string MakeSkinKey(const std::string& uuid); + +// ----- UUID utilities ----- + +// Remove dashes from a UUID string: "069a79f4-44e9-..." → "069a79f444e9..." +std::string UndashUuid(const std::string& dashed); + +// Insert dashes into a 32-char hex UUID: "069a79f444e9..." → "069a79f4-44e9-..." +std::string DashUuid(const std::string& undashed); + +// Generate a Minecraft-compatible offline UUID (UUID v3, namespace "OfflinePlayer:" + username). +// Returns dashed format. +std::string GenerateOfflineUuid(const std::string& username); + +// Parse a dashed UUID into two 64-bit halves (big-endian). +struct Uuid128 { + uint64_t hi = 0; + uint64_t lo = 0; + bool isValid() const { return hi != 0 || lo != 0; } +}; +Uuid128 ParseUuid128(const std::string& dashed); + +// ----- Session verification (Mojang sessionserver) ----- + +// Client-side: call BEFORE connecting to an online-mode server. +// Posts to sessionserver.mojang.com/session/minecraft/join. +// accessToken = raw token (without "Bearer " prefix). +// undashedUuid = 32-char hex UUID of the player. +// serverId = the server's challenge string. +// Returns true on success (HTTP 204). +bool JoinServer(const std::string& accessToken, + const std::string& undashedUuid, + const std::string& serverId, + std::string& error); + +// Server-side result from HasJoined verification. +struct HasJoinedResult { + bool success = false; + AuthError error; // structured error (code + message + httpStatus) + std::string username; // verified username from Mojang + std::string uuid; // undashed UUID + std::string skinUrl; // Mojang skin texture URL (from base64 properties) + std::string capeUrl; // Mojang cape texture URL (from base64 properties) +}; + +// Server-side: verify that a player has called /join. +// GETs sessionserver.mojang.com/session/minecraft/hasJoined?username=X&serverId=Y. +// Returns success=true with username+uuid on HTTP 200, success=false on 204 (not joined). +HasJoinedResult HasJoined(const std::string& username, + const std::string& serverId, + std::string& error); + +// Download a skin/cape PNG from a URL. +// Returns the raw PNG bytes, or empty vector on failure. +std::vector FetchSkinPng(const std::string& url, std::string& error); + +// Fetch the skin URL for a player UUID from Mojang's session server. +// uuid can be dashed or undashed. +// Returns the skin texture URL, or empty string on failure. +std::string FetchProfileSkinUrl(const std::string& uuid, std::string& error); + +// Download a skin PNG and return the raw bytes WITHOUT cropping to 64x32. +// Use this when you need the full 64x64 texture (e.g. for rendering the head). +std::vector FetchSkinPngRaw(const std::string& url, std::string& error); + +// ----- Ely.by session functions (same Yggdrasil protocol, different URLs) ----- + +bool ElybyJoinServer(const std::string& accessToken, + const std::string& undashedUuid, + const std::string& serverId, + std::string& error); + +HasJoinedResult ElybyHasJoined(const std::string& username, + const std::string& serverId, + std::string& error); + +std::string ElybyFetchProfileSkinUrl(const std::string& uuid, std::string& error); + +std::string MakeElybySkinKey(const std::string& uuid); + +// ----- Skin validation ----- + +// Maximum allowed skin PNG size in bytes (32KB — a 64x64 RGBA PNG is ~4KB compressed) +static constexpr size_t kMaxSkinBytes = 32768; + +// Check PNG magic, size cap, and 64x32 or 64x64 dimensions. +bool ValidateSkinPng(const uint8_t* data, size_t size); + +} // namespace MCAuth diff --git a/MCAuth/include/MCAuthManager.h b/MCAuth/include/MCAuthManager.h new file mode 100644 index 0000000000..8075556538 --- /dev/null +++ b/MCAuth/include/MCAuthManager.h @@ -0,0 +1,211 @@ +#pragma once +/* + * MCAuthManager - Thread-safe singleton that wraps JavaAuthManager with + * multi-account and per-slot session support (for splitscreen). + * + * Architecture: + * + * - Account list (m_javaAccounts) is SHARED — one global list of saved accounts. + * - Each player slot (0..XUSER_MAX_COUNT-1) has its own AuthSlot containing: + * - A shared_ptr (ownership shared with background worker) + * - Its own session, mutex, generation counter + * - Slot 0 is the primary player. Slots 1-3 are splitscreen. + * + * Thread model (fire-and-forget): + * - Background workers are detached threads that capture a shared_ptr copy + * of the auth engine they operate on. + * - To cancel: increment generation + RequestCancel on the old auth engine, + * then create a fresh shared_ptr for the slot. + * - The old thread runs to completion harmlessly — generation mismatch causes + * it to discard results, and the old auth engine is freed when the thread + * exits (shared_ptr ref-count drops to zero). + * - The main thread NEVER calls join(). No blocking. Ever. + * + * Usage: + * auto& mgr = MCAuthManager::Get(); + * mgr.LoadJavaAccountIndex(); + * mgr.TryRestoreActiveJavaAccount(); // restore slot 0 + * + * mgr.SetAccountForSlot(0, accountIndex); // switch slot 0's account + * auto session = mgr.GetSlotSession(0); // get slot 0's session + */ + +#include "MCAuth.h" +#include +#include +#include +#include +#include +#include +#include + +#ifndef XUSER_MAX_COUNT +#define XUSER_MAX_COUNT 4 +#endif + +class MCAuthManager { +public: + enum class State { + Idle, + WaitingForCode, // device code displayed, waiting for user + Authenticating, // polling / running auth chain + Success, + Failed, + }; + + // Per-account info stored in the index. + struct JavaAccountInfo { + std::string username; // Minecraft username + std::string uuid; // Player UUID (dashed) + std::string tokenFile; // e.g. "java_auth_0.json" (empty for offline) + bool isOffline = false; + std::string authProvider; // "mojang", "elyby", "offline" (default: "mojang") + }; + + // Per-player-slot auth state. Each slot has its own auth engine + session. + struct AuthSlot { + // Auth engine is heap-allocated and shared with background worker threads. + // When we cancel, we abandon the old shared_ptr and create a fresh one. + // The old thread's copy prevents use-after-free; it finishes harmlessly. + std::shared_ptr auth; + + MCAuth::ElybyTokens elybyTokens; // Ely.by tokens (no engine class needed) + MCAuth::JavaSession session; // current session data + std::atomic accountIndex{-1}; // index into m_javaAccounts (-1 = none) + mutable std::mutex mutex; + std::atomic generation{0}; // invalidates stale workers + std::atomic state{State::Idle}; + mutable std::condition_variable cv; // signals when state changes + std::string lastError; + + // No std::thread member — workers are detached (fire-and-forget). + + bool hasSession() const { return !session.uuid.empty(); } + + AuthSlot() : auth(std::make_shared()) {} + }; + + using DeviceCodeCb = MCAuth::DeviceCodeCallback; + using JavaCompleteCb = std::function; + + static MCAuthManager& Get(); + + MCAuthManager(const MCAuthManager&) = delete; + MCAuthManager& operator=(const MCAuthManager&) = delete; + + // ---- Java Edition — Account Index ---- + + bool LoadJavaAccountIndex(); + bool SaveJavaAccountIndex() const; + + std::vector GetJavaAccounts() const; + + // ---- Java Edition — Per-Slot Session Management ---- + + // Get the auth slot for a player index (0 = primary, 1-3 = splitscreen). + const AuthSlot& GetSlot(int slot) const; + + // Set which account a slot uses. Loads tokens + refreshes in background. + // The old session remains valid until the new one is ready (no empty window). + bool SetAccountForSlot(int slot, int accountIndex); + + // Clear a slot (e.g. when a splitscreen player leaves). + void ClearSlot(int slot); + + // Get the session for a specific slot. + MCAuth::JavaSession GetSlotSession(int slot) const; + + // Check if a slot has a valid logged-in session. + bool IsSlotLoggedIn(int slot) const; + + // Check if the slot's token is expiring soon (within 60s). + bool IsTokenExpiringSoon(int slot) const; + + // Proactively refresh a slot's token in the background. + void RefreshSlot(int slot); + + // Block until a slot's auth settles (state leaves Authenticating/WaitingForCode). + // Returns true if login succeeded, false on timeout or failure. + bool WaitForSlotReady(int slot, int timeoutMs = 15000) const; + + // Check if an online account is already assigned to another slot. + bool IsAccountInUseByOtherSlot(int slot, int accountIndex) const; + + // ---- Java Edition — Slot 0 Convenience (backward compat) ---- + + int GetActiveJavaAccountIndex() const; + bool SetActiveJavaAccount(int index) { return SetAccountForSlot(0, index); } + MCAuth::JavaSession GetJavaSession() const; + bool IsJavaLoggedIn() const; + State GetState() const { return m_slots[0].state.load(); } + State GetSlotState(int slot) const { + if (slot < 0 || slot >= XUSER_MAX_COUNT) slot = 0; + return m_slots[slot].state.load(); + } + bool WaitForAuthReady(int timeoutMs = 15000) const { return WaitForSlotReady(0, timeoutMs); } + + // ---- Java Edition — Account Management ---- + + // Add a new account via device code flow (background thread on slot 0). + void BeginAddJavaAccount(DeviceCodeCb onDeviceCode, JavaCompleteCb onComplete, + int timeoutSeconds = 300); + + // Add an Ely.by account via username+password. + using ElybyCompleteCb = std::function; + using Elyby2FACb = std::function; + void BeginAddElybyAccount(const std::string& username, const std::string& password, + ElybyCompleteCb onComplete, Elyby2FACb on2FA = nullptr); + + // Add an offline account. Returns new account index or -1. + int AddOfflineJavaAccount(const std::string& username); + + // Remove an account by index. Deletes its token file. + bool RemoveJavaAccount(int index); + + // Restore the active account from disk at startup (slot 0). + void TryRestoreActiveJavaAccount(); + + // ---- Device code info (valid during add-account flow) ---- + + std::string GetJavaDeviceCode() const; + std::string GetJavaDirectUri() const; + std::string GetLastError() const; + + // File paths + static constexpr const char* kJavaAccountsFile = "java_accounts.json"; + +private: + MCAuthManager(); + ~MCAuthManager(); + + // Generate a unique token filename for a new account. + std::string AllocTokenFile(const std::string& uuid) const; + + // Synthesize an offline session from account info. + static MCAuth::JavaSession SynthesizeOfflineSession(const JavaAccountInfo& acct); + + // Abandon the current auth engine for a slot and create a fresh one. + // Calls RequestCancel on the old engine so its worker exits promptly. + // Returns the fresh shared_ptr for capturing in the new worker lambda. + std::shared_ptr ResetSlotAuth(AuthSlot& s); + + // Shared Ely.by refresh logic used by RefreshSlot and SetAccountForSlot. + // If failOpen is true, sets state to Success even when refresh fails (fail-open). + // If alwaysSaveIndex is true, calls SaveJavaAccountIndex even on failure. + void RunElybyRefresh(int slot, uint32_t gen, const std::string& tokenFile, + bool failOpen, bool alwaysSaveIndex); + + // Per-slot auth state + AuthSlot m_slots[XUSER_MAX_COUNT]; + + // Shared account list (protected by m_accountsMutex) + mutable std::mutex m_accountsMutex; + std::vector m_javaAccounts; + + // Device code state (for BeginAddJavaAccount, always on slot 0) + mutable std::mutex m_deviceCodeMutex; + std::string m_javaDeviceCode; + std::string m_javaDirectUri; + + bool m_javaRestoreAttempted = false; +}; diff --git a/MCAuth/src/MCAuthCrypto.cpp b/MCAuth/src/MCAuthCrypto.cpp new file mode 100644 index 0000000000..71dda6236b --- /dev/null +++ b/MCAuth/src/MCAuthCrypto.cpp @@ -0,0 +1,398 @@ +#include "MCAuthCrypto.h" + +#define WIN32_LEAN_AND_MEAN +#include +#include +#pragma comment(lib, "bcrypt.lib") + +#include +#include +#include +#include +#include + +namespace MCAuth { + +static void ThrowIfFailed(NTSTATUS status, const char* ctx) { + if (!BCRYPT_SUCCESS(status)) { + char buf[128]; + snprintf(buf, sizeof(buf), "BCrypt error 0x%08X in %s", (unsigned)status, ctx); + throw std::runtime_error(buf); + } +} + +// Build SubjectPublicKeyInfo DER for an EC public key. +// Hardcoded for P-256 and P-384 (the only two we use). +std::vector BuildSubjectPublicKeyInfoDER( + int bitSize, + const std::vector& x, + const std::vector& y) +{ + // OIDs + // ecPublicKey: 1.2.840.10045.2.1 -> 2a 86 48 ce 3d 02 01 (7 bytes) + static const uint8_t OID_EC_PUBLIC_KEY[] = { 0x2a,0x86,0x48,0xce,0x3d,0x02,0x01 }; + // secp256r1 : 1.2.840.10045.3.1.7 -> 2a 86 48 ce 3d 03 01 07 (8 bytes) + static const uint8_t OID_P256[] = { 0x2a,0x86,0x48,0xce,0x3d,0x03,0x01,0x07 }; + // secp384r1 : 1.3.132.0.34 -> 2b 81 04 00 22 (5 bytes) + static const uint8_t OID_P384[] = { 0x2b,0x81,0x04,0x00,0x22 }; + + size_t coordSize = (bitSize == 256) ? 32 : 48; + const uint8_t* curveOid = (bitSize == 256) ? OID_P256 : OID_P384; + size_t curveOidLen = (bitSize == 256) ? 8 : 5; + + // AlgorithmIdentifier SEQUENCE: + // 06 07 + // 06 + size_t algIdInnerLen = 2 + sizeof(OID_EC_PUBLIC_KEY) + 2 + curveOidLen; + + // BIT STRING content: 00 04 X Y + size_t bitStringContent = 1 + 1 + coordSize + coordSize; // 00 04 X Y + size_t bitStringLen = bitStringContent; + + // Outer SEQUENCE content + size_t outerContent = (2 + algIdInnerLen) + (2 + bitStringLen); + + // Single-byte DER lengths suffice for P-256 (89 bytes) and P-384 (118 bytes) + + std::vector der; + auto appendLen = [&](size_t len) { + if (len < 128) { + der.push_back((uint8_t)len); + } else { + der.push_back(0x82); + der.push_back((uint8_t)(len >> 8)); + der.push_back((uint8_t)(len & 0xFF)); + } + }; + + // Outer SEQUENCE + der.push_back(0x30); + appendLen(outerContent); + + // AlgorithmIdentifier SEQUENCE + der.push_back(0x30); + appendLen(algIdInnerLen); + der.push_back(0x06); der.push_back((uint8_t)sizeof(OID_EC_PUBLIC_KEY)); + der.insert(der.end(), OID_EC_PUBLIC_KEY, OID_EC_PUBLIC_KEY + sizeof(OID_EC_PUBLIC_KEY)); + der.push_back(0x06); der.push_back((uint8_t)curveOidLen); + der.insert(der.end(), curveOid, curveOid + curveOidLen); + + // BIT STRING + der.push_back(0x03); + appendLen(bitStringLen + 1); // +1 for the "unused bits" byte + der.push_back(0x00); // 0 unused bits + der.push_back(0x04); // uncompressed point + der.insert(der.end(), x.begin(), x.end()); + der.insert(der.end(), y.begin(), y.end()); + + return der; +} + +// Generate a key pair using BCrypt. +static ECKeyPair GenerateKeyPair(int bitSize) { + LPCWSTR algId = (bitSize == 256) ? BCRYPT_ECDSA_P256_ALGORITHM + : BCRYPT_ECDSA_P384_ALGORITHM; + + BCRYPT_ALG_HANDLE hAlg = nullptr; + BCRYPT_KEY_HANDLE hKey = nullptr; + + try { + ThrowIfFailed(BCryptOpenAlgorithmProvider(&hAlg, algId, nullptr, 0), "OpenAlgProvider"); + + ThrowIfFailed(BCryptGenerateKeyPair(hAlg, &hKey, bitSize, 0), "GenerateKeyPair"); + ThrowIfFailed(BCryptFinalizeKeyPair(hKey, 0), "FinalizeKeyPair"); + + // Export private blob + ULONG privBlobLen = 0; + ThrowIfFailed(BCryptExportKey(hKey, nullptr, BCRYPT_ECCPRIVATE_BLOB, nullptr, 0, &privBlobLen, 0), "ExportPriv(len)"); + std::vector privBlob(privBlobLen); + ThrowIfFailed(BCryptExportKey(hKey, nullptr, BCRYPT_ECCPRIVATE_BLOB, privBlob.data(), privBlobLen, &privBlobLen, 0), "ExportPriv"); + + // Export public blob + ULONG pubBlobLen = 0; + ThrowIfFailed(BCryptExportKey(hKey, nullptr, BCRYPT_ECCPUBLIC_BLOB, nullptr, 0, &pubBlobLen, 0), "ExportPub(len)"); + std::vector pubBlob(pubBlobLen); + ThrowIfFailed(BCryptExportKey(hKey, nullptr, BCRYPT_ECCPUBLIC_BLOB, pubBlob.data(), pubBlobLen, &pubBlobLen, 0), "ExportPub"); + + BCryptDestroyKey(hKey); + BCryptCloseAlgorithmProvider(hAlg, 0); + + // BCRYPT_ECCKEY_BLOB header: 4-byte Magic + 4-byte cbKey + // Public blob: [8-byte header] [X:cbKey bytes] [Y:cbKey bytes] + const BCRYPT_ECCKEY_BLOB* hdr = reinterpret_cast(pubBlob.data()); + ULONG cbKey = hdr->cbKey; + + std::vector x(pubBlob.begin() + 8, pubBlob.begin() + 8 + cbKey); + std::vector y(pubBlob.begin() + 8 + cbKey, pubBlob.begin() + 8 + cbKey * 2); + + ECKeyPair kp; + kp.bitSize = bitSize; + kp.privateBlob = std::move(privBlob); + kp.publicBlob = std::move(pubBlob); + kp.x = x; + kp.y = y; + kp.publicKeyDER = BuildSubjectPublicKeyInfoDER(bitSize, x, y); + return kp; + + } catch (...) { + if (hKey) BCryptDestroyKey(hKey); + if (hAlg) BCryptCloseAlgorithmProvider(hAlg, 0); + throw; + } +} + +ECKeyPair GenerateP256KeyPair() { return GenerateKeyPair(256); } +ECKeyPair GenerateP384KeyPair() { return GenerateKeyPair(384); } + +std::vector SignSHA256P256(const ECKeyPair& kp, + const uint8_t* data, + size_t len) +{ + if (kp.bitSize != 256) + throw std::runtime_error("SignSHA256P256: key is not P-256"); + + BCRYPT_ALG_HANDLE hAlg = nullptr; + BCRYPT_KEY_HANDLE hKey = nullptr; + BCRYPT_ALG_HANDLE hHashAlg = nullptr; + BCRYPT_HASH_HANDLE hHash = nullptr; + + try { + ThrowIfFailed(BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_ECDSA_P256_ALGORITHM, nullptr, 0), "Sign/OpenAlg"); + + // Import private key + ThrowIfFailed(BCryptImportKeyPair(hAlg, nullptr, BCRYPT_ECCPRIVATE_BLOB, + &hKey, + const_cast(kp.privateBlob.data()), + (ULONG)kp.privateBlob.size(), 0), "Sign/ImportKey"); + + // Hash the data with SHA-256 + ThrowIfFailed(BCryptOpenAlgorithmProvider(&hHashAlg, BCRYPT_SHA256_ALGORITHM, nullptr, 0), "Sign/OpenHashAlg"); + + ThrowIfFailed(BCryptCreateHash(hHashAlg, &hHash, nullptr, 0, nullptr, 0, 0), "Sign/CreateHash"); + ThrowIfFailed(BCryptHashData(hHash, const_cast(data), (ULONG)len, 0), "Sign/HashData"); + + uint8_t digest[32]; + ThrowIfFailed(BCryptFinishHash(hHash, digest, sizeof(digest), 0), "Sign/FinishHash"); + BCryptDestroyHash(hHash); hHash = nullptr; + BCryptCloseAlgorithmProvider(hHashAlg, 0); hHashAlg = nullptr; + + // Sign the hash + ULONG sigLen = 0; + ThrowIfFailed(BCryptSignHash(hKey, nullptr, digest, sizeof(digest), nullptr, 0, &sigLen, 0), "Sign/GetSigLen"); + std::vector sig(sigLen); + ThrowIfFailed(BCryptSignHash(hKey, nullptr, digest, sizeof(digest), sig.data(), sigLen, &sigLen, 0), "Sign/SignHash"); + + BCryptDestroyKey(hKey); + BCryptCloseAlgorithmProvider(hAlg, 0); + + sig.resize(sigLen); + return sig; + + } catch (...) { + if (hHash) BCryptDestroyHash(hHash); + if (hHashAlg) BCryptCloseAlgorithmProvider(hHashAlg, 0); + if (hKey) BCryptDestroyKey(hKey); + if (hAlg) BCryptCloseAlgorithmProvider(hAlg, 0); + throw; + } +} + +static const char kB64Chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +static const char kB64UrlChars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; + +static std::string Base64EncodeInternal(const uint8_t* data, size_t len, const char* alpha, bool pad) { + std::string out; + out.reserve(((len + 2) / 3) * 4); + for (size_t i = 0; i < len; i += 3) { + uint32_t v = (uint32_t)data[i] << 16; + if (i + 1 < len) v |= (uint32_t)data[i + 1] << 8; + if (i + 2 < len) v |= (uint32_t)data[i + 2]; + + out += alpha[(v >> 18) & 0x3F]; + out += alpha[(v >> 12) & 0x3F]; + out += (i + 1 < len) ? alpha[(v >> 6) & 0x3F] : (pad ? '=' : '\0'); + out += (i + 2 < len) ? alpha[(v >> 0) & 0x3F] : (pad ? '=' : '\0'); + } + // Remove trailing null chars (only happens for url encode without pad) + while (!out.empty() && out.back() == '\0') out.pop_back(); + return out; +} + +std::string Base64Encode(const uint8_t* data, size_t len) { + return Base64EncodeInternal(data, len, kB64Chars, true); +} +std::string Base64Encode(const std::vector& data) { + return Base64Encode(data.data(), data.size()); +} +std::string Base64UrlEncode(const uint8_t* data, size_t len) { + return Base64EncodeInternal(data, len, kB64UrlChars, false); +} +std::string Base64UrlEncode(const std::vector& data) { + return Base64UrlEncode(data.data(), data.size()); +} + +std::string BuildProofKeyJson(const ECKeyPair& p256) { + std::string xEnc = Base64UrlEncode(p256.x); + std::string yEnc = Base64UrlEncode(p256.y); + return "{\"kty\":\"EC\",\"alg\":\"ES256\",\"crv\":\"P-256\",\"use\":\"sig\"," + "\"x\":\"" + xEnc + "\",\"y\":\"" + yEnc + "\"}"; +} + +// XBL Signature header +// Payload to sign (all fields big-endian where integer): +// INT32 policy_version = 1 +// BYTE 0x00 +// INT64 windows_timestamp +// BYTE 0x00 +// BYTES method (e.g. "POST") +// BYTE 0x00 +// BYTES url_path_and_query +// BYTE 0x00 +// BYTES authorization_header (empty string if none) +// BYTE 0x00 +// BYTES request_body +// BYTE 0x00 +// +// Signature header value (base64 of): +// INT32 policy_version = 1 +// INT64 windows_timestamp +// BYTES 64-byte P1363 ECDSA-SHA256 signature + +static void AppendBE32(std::vector& buf, uint32_t v) { + buf.push_back((uint8_t)(v >> 24)); + buf.push_back((uint8_t)(v >> 16)); + buf.push_back((uint8_t)(v >> 8)); + buf.push_back((uint8_t)(v )); +} +static void AppendBE64(std::vector& buf, uint64_t v) { + buf.push_back((uint8_t)(v >> 56)); + buf.push_back((uint8_t)(v >> 48)); + buf.push_back((uint8_t)(v >> 40)); + buf.push_back((uint8_t)(v >> 32)); + buf.push_back((uint8_t)(v >> 24)); + buf.push_back((uint8_t)(v >> 16)); + buf.push_back((uint8_t)(v >> 8)); + buf.push_back((uint8_t)(v )); +} + +std::string BuildXblSignatureHeader(const ECKeyPair& p256, + const std::string& method, + const std::string& urlPath, + const std::string& body, + const std::string& authHdr) +{ + // Windows timestamp: (unix_seconds + 11644473600) * 10_000_000 + using namespace std::chrono; + int64_t epochSec = duration_cast( + system_clock::now().time_since_epoch()).count(); + uint64_t winTs = (uint64_t)(epochSec + 11644473600LL) * 10000000ULL; + + // Build the content to sign + std::vector content; + content.reserve(512); + + AppendBE32(content, 1); // policy version + content.push_back(0x00); + AppendBE64(content, winTs); // timestamp + content.push_back(0x00); + content.insert(content.end(), method.begin(), method.end()); + content.push_back(0x00); + content.insert(content.end(), urlPath.begin(), urlPath.end()); + content.push_back(0x00); + content.insert(content.end(), authHdr.begin(), authHdr.end()); + content.push_back(0x00); + content.insert(content.end(), body.begin(), body.end()); + content.push_back(0x00); + + // Sign + std::vector sig = SignSHA256P256(p256, content.data(), content.size()); + + // Build header blob + std::vector hdrBlob; + hdrBlob.reserve(4 + 8 + sig.size()); + AppendBE32(hdrBlob, 1); + AppendBE64(hdrBlob, winTs); + hdrBlob.insert(hdrBlob.end(), sig.begin(), sig.end()); + + return Base64Encode(hdrBlob); +} + +std::string GenerateUUID() { + uint8_t bytes[16]; + NTSTATUS st = BCryptGenRandom(nullptr, bytes, sizeof(bytes), BCRYPT_USE_SYSTEM_PREFERRED_RNG); + if (!BCRYPT_SUCCESS(st)) { + // fallback to rand (not cryptographic, but OK for device ID purposes) + for (auto& b : bytes) b = (uint8_t)(rand() & 0xFF); + } + // Set version 4 and variant bits + bytes[6] = (bytes[6] & 0x0F) | 0x40; + bytes[8] = (bytes[8] & 0x3F) | 0x80; + + char buf[37]; + snprintf(buf, sizeof(buf), + "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x", + bytes[0], bytes[1], bytes[2], bytes[3], + bytes[4], bytes[5], + bytes[6], bytes[7], + bytes[8], bytes[9], + bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]); + return buf; +} + +std::vector Base64Decode(const std::string& s) { + static const int kInv[256] = { + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63, + 52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1, + -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14, + 15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1, + -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40, + 41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, + }; + std::vector out; + int buf = 0, bits = 0; + for (unsigned char c : s) { + if (c == '=' || kInv[c] < 0) continue; + buf = (buf << 6) | kInv[c]; + bits += 6; + if (bits >= 8) { + bits -= 8; + out.push_back((uint8_t)(buf >> bits)); + buf &= (1 << bits) - 1; + } + } + return out; +} + +std::string Base64DecodeStr(const std::string& encoded) { + auto bytes = Base64Decode(encoded); + return std::string(bytes.begin(), bytes.end()); +} + +std::vector ComputeMD5(const void* data, size_t len) { + std::vector result(16, 0); + BCRYPT_ALG_HANDLE hAlg = nullptr; + BCRYPT_HASH_HANDLE hHash = nullptr; + + if (BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_MD5_ALGORITHM, nullptr, 0) == 0) { + if (BCryptCreateHash(hAlg, &hHash, nullptr, 0, nullptr, 0, 0) == 0) { + if (BCryptHashData(hHash, (PUCHAR)data, (ULONG)len, 0) == 0) { + BCryptFinishHash(hHash, result.data(), 16, 0); + } + BCryptDestroyHash(hHash); + } + BCryptCloseAlgorithmProvider(hAlg, 0); + } + return result; +} + +} // namespace MCAuth diff --git a/MCAuth/src/MCAuthCrypto.h b/MCAuth/src/MCAuthCrypto.h new file mode 100644 index 0000000000..85d071ff4b --- /dev/null +++ b/MCAuth/src/MCAuthCrypto.h @@ -0,0 +1,70 @@ +#pragma once +#include +#include +#include + +namespace MCAuth { + +// Raw ECDSA key pair stored as BCrypt key blobs. +struct ECKeyPair { + int bitSize; // 256 or 384 + std::vector privateBlob; // BCRYPT_ECCPRIVATE_BLOB + std::vector publicBlob; // BCRYPT_ECCPUBLIC_BLOB + // Raw coordinates extracted from publicBlob (each cbKey bytes, big-endian) + std::vector x; + std::vector y; + // SubjectPublicKeyInfo DER encoding of the public key (base64 for MC APIs) + std::vector publicKeyDER; +}; + +// Generate fresh key pairs +ECKeyPair GenerateP256KeyPair(); +ECKeyPair GenerateP384KeyPair(); + +// ECDSA-SHA256 over `data`, returns 64-byte P1363 signature (r||s) +std::vector SignSHA256P256(const ECKeyPair& kp, + const uint8_t* data, + size_t len); + +// Base64 (standard alphabet, with padding) +std::string Base64Encode(const uint8_t* data, size_t len); +std::string Base64Encode(const std::vector& data); + +// Base64url (no padding, url-safe alphabet) +std::string Base64UrlEncode(const uint8_t* data, size_t len); +std::string Base64UrlEncode(const std::vector& data); + +// Build the JWK ProofKey JSON fragment for a P-256 key: +// {"kty":"EC","alg":"ES256","crv":"P-256","use":"sig","x":"...","y":"..."} +std::string BuildProofKeyJson(const ECKeyPair& p256); + +// Build the XBL "Signature" header value. +// Constructs the signed payload, signs it with the P-256 device key, +// and returns the Base64-encoded header blob. +// method : "POST" +// urlPath : "/device/authenticate" (path + query if any) +// body : raw request body bytes +// authHdr : value of Authorization header (empty string if none) +std::string BuildXblSignatureHeader(const ECKeyPair& p256, + const std::string& method, + const std::string& urlPath, + const std::string& body, + const std::string& authHdr = ""); + +// Random UUID v4 string (lowercase, dashed) +std::string GenerateUUID(); + +// Base64 decode (standard alphabet) +std::vector Base64Decode(const std::string& b64); +std::string Base64DecodeStr(const std::string& b64); + +// MD5 hash using Windows BCrypt +std::vector ComputeMD5(const void* data, size_t len); + +// Build SubjectPublicKeyInfo DER for an EC public key (P-256 or P-384) +std::vector BuildSubjectPublicKeyInfoDER( + int bitSize, + const std::vector& x, + const std::vector& y); + +} // namespace MCAuth diff --git a/MCAuth/src/MCAuthElyby.cpp b/MCAuth/src/MCAuthElyby.cpp new file mode 100644 index 0000000000..78c5fafcad --- /dev/null +++ b/MCAuth/src/MCAuthElyby.cpp @@ -0,0 +1,169 @@ +/* + * MCAuthElyby.cpp — Ely.by Yggdrasil authentication + * + * Stateless free functions for username+password → accessToken flow. + * Uses the same HTTP/JSON helpers as the rest of MCAuth. + */ + +#include "../include/MCAuth.h" +#include "MCAuthCrypto.h" +#include "MCAuthHttp.h" +#include "MCAuthInternal.h" + +#include +#include + +namespace MCAuth { + +using namespace mcauth; + +// --------------------------------------------------------------------------- +// ElybyLogin — POST /auth/authenticate +// --------------------------------------------------------------------------- +bool ElybyLogin(const std::string& username, const std::string& password, + ElybyTokens& outTokens, std::string& error) +{ + // Generate clientToken if not already set + std::string clientToken = outTokens.clientToken; + if (clientToken.empty()) + clientToken = GenerateUUID(); + + std::string body = "{\"agent\":{\"name\":\"Minecraft\",\"version\":1}" + ",\"username\":" + JsonStr(username) + + ",\"password\":" + JsonStr(password) + + ",\"clientToken\":" + JsonStr(clientToken) + "}"; + + try { + auto resp = HttpPost("https://authserver.ely.by/auth/authenticate", + body, "application/json"); + + if (resp.statusCode == 200 && !resp.body.empty()) { + outTokens.accessToken = JsonGetString(resp.body, "accessToken"); + outTokens.clientToken = JsonGetString(resp.body, "clientToken"); + + // selectedProfile contains id and name + std::string profile = JsonRawValue(resp.body, "selectedProfile"); + if (!profile.empty()) { + outTokens.uuid = JsonGetString(profile, "id"); + outTokens.username = JsonGetString(profile, "name"); + } + + if (outTokens.accessToken.empty()) { + error = "ElybyLogin: empty accessToken in response"; + return false; + } + return true; + } + + // Check for 2FA requirement + if (resp.statusCode == 401) { + std::string errMsg = JsonGetString(resp.body, "errorMessage"); + if (errMsg.find("two factor auth") != std::string::npos || + errMsg.find("Account protected with two factor auth") != std::string::npos) { + error = "elyby_2fa_required"; + return false; + } + error = "ElybyLogin: invalid credentials"; + if (!errMsg.empty()) error += " (" + errMsg + ")"; + return false; + } + + error = "ElybyLogin HTTP " + std::to_string(resp.statusCode); + if (!resp.body.empty()) { + std::string msg = JsonGetString(resp.body, "errorMessage"); + if (!msg.empty()) error += ": " + msg; + } + } catch (const std::exception& e) { + error = std::string("ElybyLogin network error: ") + e.what(); + } + return false; +} + +// --------------------------------------------------------------------------- +// ElybyRefresh — POST /auth/refresh +// --------------------------------------------------------------------------- +bool ElybyRefresh(ElybyTokens& tokens, std::string& error) +{ + std::string body = "{\"accessToken\":" + JsonStr(tokens.accessToken) + + ",\"clientToken\":" + JsonStr(tokens.clientToken) + "}"; + + try { + auto resp = HttpPost("https://authserver.ely.by/auth/refresh", + body, "application/json"); + + if (resp.statusCode == 200 && !resp.body.empty()) { + tokens.accessToken = JsonGetString(resp.body, "accessToken"); + tokens.clientToken = JsonGetString(resp.body, "clientToken"); + + std::string profile = JsonRawValue(resp.body, "selectedProfile"); + if (!profile.empty()) { + tokens.uuid = JsonGetString(profile, "id"); + tokens.username = JsonGetString(profile, "name"); + } + return true; + } + + error = "ElybyRefresh HTTP " + std::to_string(resp.statusCode); + if (!resp.body.empty()) { + std::string msg = JsonGetString(resp.body, "errorMessage"); + if (!msg.empty()) error += ": " + msg; + } + } catch (const std::exception& e) { + error = std::string("ElybyRefresh network error: ") + e.what(); + } + return false; +} + +// --------------------------------------------------------------------------- +// ElybyValidate — POST /auth/validate +// --------------------------------------------------------------------------- +bool ElybyValidate(const std::string& accessToken, std::string& error) +{ + std::string body = "{\"accessToken\":" + JsonStr(accessToken) + "}"; + + try { + auto resp = HttpPost("https://authserver.ely.by/auth/validate", + body, "application/json"); + // 204 = valid, anything else = invalid + return (resp.statusCode == 204 || resp.statusCode == 200); + } catch (const std::exception& e) { + error = std::string("ElybyValidate network error: ") + e.what(); + } + return false; +} + +// --------------------------------------------------------------------------- +// Token persistence — simple JSON file +// --------------------------------------------------------------------------- +bool ElybyLoadTokens(const std::string& path, ElybyTokens& out) +{ + std::ifstream f(path); + if (!f) return false; + std::string content((std::istreambuf_iterator(f)), + std::istreambuf_iterator()); + if (content.empty()) return false; + + out.accessToken = JsonGetString(content, "accessToken"); + out.clientToken = JsonGetString(content, "clientToken"); + out.uuid = JsonGetString(content, "uuid"); + out.username = JsonGetString(content, "username"); + return !out.accessToken.empty(); +} + +bool ElybySaveTokens(const std::string& path, const ElybyTokens& tokens) +{ + std::ostringstream o; + o << "{\n"; + o << "\"accessToken\":" << JsonStr(tokens.accessToken) << ",\n"; + o << "\"clientToken\":" << JsonStr(tokens.clientToken) << ",\n"; + o << "\"uuid\":" << JsonStr(tokens.uuid) << ",\n"; + o << "\"username\":" << JsonStr(tokens.username) << "\n"; + o << "}"; + + std::ofstream f(path); + if (!f) return false; + f << o.str(); + return f.good(); +} + +} // namespace MCAuth diff --git a/MCAuth/src/MCAuthHttp.cpp b/MCAuth/src/MCAuthHttp.cpp new file mode 100644 index 0000000000..c8ad1c3471 --- /dev/null +++ b/MCAuth/src/MCAuthHttp.cpp @@ -0,0 +1,221 @@ +#include "MCAuthHttp.h" + +#define WIN32_LEAN_AND_MEAN +#include +#include +#pragma comment(lib, "winhttp.lib") + +#include +#include + +namespace MCAuth { + +// Internal URL parser + +struct ParsedUrl { + std::wstring scheme; // L"https" + std::wstring host; + INTERNET_PORT port; + std::wstring path; // includes query string +}; + +static std::wstring Utf8ToWide(const std::string& s) { + if (s.empty()) return {}; + int len = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), nullptr, 0); + std::wstring w(len, L'\0'); + MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), w.data(), len); + return w; +} + +static std::string WideToUtf8(const std::wstring& w) { + if (w.empty()) return {}; + int len = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), (int)w.size(), nullptr, 0, nullptr, nullptr); + std::string s(len, '\0'); + WideCharToMultiByte(CP_UTF8, 0, w.c_str(), (int)w.size(), s.data(), len, nullptr, nullptr); + return s; +} + +static ParsedUrl ParseUrl(const std::string& url) { + std::wstring wurl = Utf8ToWide(url); + + URL_COMPONENTS uc = {}; + uc.dwStructSize = sizeof(uc); + + wchar_t scheme[16] = {}, host[256] = {}, path[2048] = {}; + uc.lpszScheme = scheme; uc.dwSchemeLength = _countof(scheme); + uc.lpszHostName = host; uc.dwHostNameLength = _countof(host); + uc.lpszUrlPath = path; uc.dwUrlPathLength = _countof(path); + + if (!WinHttpCrackUrl(wurl.c_str(), (DWORD)wurl.size(), 0, &uc)) + throw std::runtime_error("ParseUrl: WinHttpCrackUrl failed for: " + url); + + ParsedUrl p; + p.scheme = scheme; + p.host = host; + p.port = uc.nPort; + p.path = path; + if (p.path.empty()) p.path = L"/"; + return p; +} + +HttpResponse HttpPost(const std::string& url, + const std::string& body, + const std::string& contentType, + const std::map& headers) +{ + ParsedUrl parsed = ParseUrl(url); + bool isHttps = (parsed.scheme == L"https"); + + HINTERNET hSession = WinHttpOpen( + L"MCAuth/1.0", + WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, + WINHTTP_NO_PROXY_NAME, + WINHTTP_NO_PROXY_BYPASS, + 0); + if (!hSession) + throw std::runtime_error("HttpPost: WinHttpOpen failed"); + + // Set explicit timeouts to avoid blocking the caller indefinitely + // (DNS resolve=10s, connect=10s, send=10s, receive=15s) + WinHttpSetTimeouts(hSession, 10000, 10000, 10000, 15000); + + HINTERNET hConnect = WinHttpConnect(hSession, parsed.host.c_str(), parsed.port, 0); + if (!hConnect) { + WinHttpCloseHandle(hSession); + throw std::runtime_error("HttpPost: WinHttpConnect failed for host: " + WideToUtf8(parsed.host)); + } + + DWORD flags = isHttps ? WINHTTP_FLAG_SECURE : 0; + HINTERNET hRequest = WinHttpOpenRequest( + hConnect, + L"POST", + parsed.path.c_str(), + nullptr, + WINHTTP_NO_REFERER, + WINHTTP_DEFAULT_ACCEPT_TYPES, + flags); + if (!hRequest) { + WinHttpCloseHandle(hConnect); + WinHttpCloseHandle(hSession); + throw std::runtime_error("HttpPost: WinHttpOpenRequest failed"); + } + + // Add Content-Type + std::wstring ct = L"Content-Type: " + Utf8ToWide(contentType); + WinHttpAddRequestHeaders(hRequest, ct.c_str(), (DWORD)-1, WINHTTP_ADDREQ_FLAG_ADD); + + // Add extra headers + for (auto& kv : headers) { + std::wstring h = Utf8ToWide(kv.first) + L": " + Utf8ToWide(kv.second); + WinHttpAddRequestHeaders(hRequest, h.c_str(), (DWORD)-1, WINHTTP_ADDREQ_FLAG_ADD); + } + + BOOL sent = WinHttpSendRequest( + hRequest, + WINHTTP_NO_ADDITIONAL_HEADERS, 0, + const_cast(body.c_str()), (DWORD)body.size(), + (DWORD)body.size(), + 0); + + if (!sent || !WinHttpReceiveResponse(hRequest, nullptr)) { + WinHttpCloseHandle(hRequest); + WinHttpCloseHandle(hConnect); + WinHttpCloseHandle(hSession); + throw std::runtime_error("HttpPost: request failed for: " + url); + } + + // Read status code + DWORD statusCode = 0; + DWORD statusLen = sizeof(statusCode); + WinHttpQueryHeaders(hRequest, + WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + WINHTTP_HEADER_NAME_BY_INDEX, + &statusCode, &statusLen, WINHTTP_NO_HEADER_INDEX); + + // Read body + std::string responseBody; + DWORD bytesAvailable = 0; + while (WinHttpQueryDataAvailable(hRequest, &bytesAvailable) && bytesAvailable > 0) { + std::string chunk(bytesAvailable, '\0'); + DWORD bytesRead = 0; + WinHttpReadData(hRequest, chunk.data(), bytesAvailable, &bytesRead); + responseBody.append(chunk.data(), bytesRead); + } + + WinHttpCloseHandle(hRequest); + WinHttpCloseHandle(hConnect); + WinHttpCloseHandle(hSession); + + return { (int)statusCode, std::move(responseBody) }; +} + +HttpResponse HttpGet(const std::string& url, + const std::map& headers) +{ + ParsedUrl parsed = ParseUrl(url); + bool isHttps = (parsed.scheme == L"https"); + + HINTERNET hSession = WinHttpOpen(L"MCAuth/1.0", + WINHTTP_ACCESS_TYPE_DEFAULT_PROXY, + WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0); + if (!hSession) + throw std::runtime_error("HttpGet: WinHttpOpen failed"); + + // Set explicit timeouts to avoid blocking the caller indefinitely + // (DNS resolve=10s, connect=10s, send=10s, receive=15s) + WinHttpSetTimeouts(hSession, 10000, 10000, 10000, 15000); + + HINTERNET hConnect = WinHttpConnect(hSession, parsed.host.c_str(), parsed.port, 0); + if (!hConnect) { + WinHttpCloseHandle(hSession); + throw std::runtime_error("HttpGet: WinHttpConnect failed"); + } + + DWORD flags = isHttps ? WINHTTP_FLAG_SECURE : 0; + HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", + parsed.path.c_str(), nullptr, + WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, flags); + if (!hRequest) { + WinHttpCloseHandle(hConnect); + WinHttpCloseHandle(hSession); + throw std::runtime_error("HttpGet: WinHttpOpenRequest failed"); + } + + for (auto& kv : headers) { + std::wstring h = Utf8ToWide(kv.first) + L": " + Utf8ToWide(kv.second); + WinHttpAddRequestHeaders(hRequest, h.c_str(), (DWORD)-1, WINHTTP_ADDREQ_FLAG_ADD); + } + + if (!WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, + WINHTTP_NO_REQUEST_DATA, 0, 0, 0) || + !WinHttpReceiveResponse(hRequest, nullptr)) + { + WinHttpCloseHandle(hRequest); + WinHttpCloseHandle(hConnect); + WinHttpCloseHandle(hSession); + throw std::runtime_error("HttpGet: request failed for: " + url); + } + + DWORD statusCode = 0, statusLen = sizeof(statusCode); + WinHttpQueryHeaders(hRequest, + WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER, + WINHTTP_HEADER_NAME_BY_INDEX, + &statusCode, &statusLen, WINHTTP_NO_HEADER_INDEX); + + std::string responseBody; + DWORD bytesAvailable = 0; + while (WinHttpQueryDataAvailable(hRequest, &bytesAvailable) && bytesAvailable > 0) { + std::string chunk(bytesAvailable, '\0'); + DWORD bytesRead = 0; + WinHttpReadData(hRequest, chunk.data(), bytesAvailable, &bytesRead); + responseBody.append(chunk.data(), bytesRead); + } + + WinHttpCloseHandle(hRequest); + WinHttpCloseHandle(hConnect); + WinHttpCloseHandle(hSession); + + return { (int)statusCode, std::move(responseBody) }; +} + +} // namespace MCAuth diff --git a/MCAuth/src/MCAuthHttp.h b/MCAuth/src/MCAuthHttp.h new file mode 100644 index 0000000000..35eaafdebe --- /dev/null +++ b/MCAuth/src/MCAuthHttp.h @@ -0,0 +1,22 @@ +#pragma once +#include +#include + +namespace MCAuth { + +struct HttpResponse { + int statusCode; + std::string body; +}; + +// HTTPS POST +HttpResponse HttpPost(const std::string& url, + const std::string& body, + const std::string& contentType, + const std::map& headers = {}); + +// HTTPS GET +HttpResponse HttpGet(const std::string& url, + const std::map& headers = {}); + +} // namespace MCAuth diff --git a/MCAuth/src/MCAuthInternal.h b/MCAuth/src/MCAuthInternal.h new file mode 100644 index 0000000000..9d5dbcf8c3 --- /dev/null +++ b/MCAuth/src/MCAuthInternal.h @@ -0,0 +1,205 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +namespace mcauth { + +inline std::string JsonRawValue(const std::string& json, const std::string& key) { + std::string search = "\"" + key + "\""; + size_t pos = 0; + while ((pos = json.find(search, pos)) != std::string::npos) { + size_t colon = json.find_first_not_of(" \t\r\n", pos + search.size()); + if (colon == std::string::npos || json[colon] != ':') { pos++; continue; } + size_t vstart = json.find_first_not_of(" \t\r\n", colon + 1); + if (vstart == std::string::npos) return ""; + char c = json[vstart]; + if (c == '"') { + size_t end = vstart + 1; + while (end < json.size()) { + if (json[end] == '\\') { end += 2; continue; } + if (json[end] == '"') { end++; break; } + end++; + } + return json.substr(vstart, end - vstart); + } else if (c == '{' || c == '[') { + char open = c, close = (c == '{') ? '}' : ']'; + int depth = 1; + size_t end = vstart + 1; + while (end < json.size() && depth > 0) { + if (json[end] == open) depth++; + else if (json[end] == close) depth--; + else if (json[end] == '"') { + end++; + while (end < json.size() && json[end] != '"') { + if (json[end] == '\\') end++; + end++; + } + } + end++; + } + return json.substr(vstart, end - vstart); + } else { + size_t end = json.find_first_of(",}\r\n", vstart); + if (end == std::string::npos) end = json.size(); + std::string v = json.substr(vstart, end - vstart); + while (!v.empty() && isspace((unsigned char)v.back())) v.pop_back(); + return v; + } + } + return ""; +} + +inline std::string JsonUnquote(const std::string& s) { + if (s.size() >= 2 && s.front() == '"' && s.back() == '"') + return s.substr(1, s.size() - 2); + return s; +} + +inline std::string JsonGetString(const std::string& json, const std::string& key) { + return JsonUnquote(JsonRawValue(json, key)); +} + +inline int64_t JsonGetInt(const std::string& json, const std::string& key) { + auto s = JsonUnquote(JsonRawValue(json, key)); + if (s.empty()) return 0; + try { return std::stoll(s); } catch (...) { return 0; } +} + +inline std::string JsonFirstArrayObject(const std::string& arrStr) { + size_t pos = arrStr.find('['); + if (pos == std::string::npos) return ""; + pos = arrStr.find_first_not_of(" \t\r\n", pos + 1); + if (pos == std::string::npos || arrStr[pos] == ']') return ""; + if (arrStr[pos] != '{') return ""; + int depth = 1; + size_t end = pos + 1; + while (end < arrStr.size() && depth > 0) { + if (arrStr[end] == '{') depth++; + else if (arrStr[end] == '}') depth--; + else if (arrStr[end] == '"') { + end++; + while (end < arrStr.size() && arrStr[end] != '"') { + if (arrStr[end] == '\\') end++; + end++; + } + } + end++; + } + return arrStr.substr(pos, end - pos); +} + +inline std::string JsonNthArrayString(const std::string& arrStr, int n) { + size_t pos = arrStr.find('['); + if (pos == std::string::npos) return ""; + pos++; + int idx = 0; + while (pos < arrStr.size()) { + pos = arrStr.find_first_not_of(" \t\r\n,", pos); + if (pos == std::string::npos || arrStr[pos] == ']') break; + if (arrStr[pos] == '"') { + size_t end = pos + 1; + while (end < arrStr.size()) { + if (arrStr[end] == '\\') { end += 2; continue; } + if (arrStr[end] == '"') { end++; break; } + end++; + } + if (idx == n) return arrStr.substr(pos + 1, end - pos - 2); + pos = end; + idx++; + } else { + pos++; + } + } + return ""; +} + +inline std::vector JsonArrayObjects(const std::string& json) { + std::vector result; + size_t pos = json.find('['); + if (pos == std::string::npos) return result; + ++pos; + while (pos < json.size()) { + pos = json.find('{', pos); + if (pos == std::string::npos) break; + int depth = 0; + size_t start = pos; + for (; pos < json.size(); ++pos) { + if (json[pos] == '{') ++depth; + else if (json[pos] == '}') { --depth; if (depth == 0) { ++pos; break; } } + } + result.push_back(json.substr(start, pos - start)); + } + return result; +} + +inline std::string UrlEncode(const std::string& s) { + std::string out; + out.reserve(s.size() * 3); + for (unsigned char c : s) { + if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') { + out += c; + } else { + char buf[4]; + snprintf(buf, sizeof(buf), "%%%02X", c); + out += buf; + } + } + return out; +} + +inline int64_t NowMs() { + using namespace std::chrono; + return duration_cast(system_clock::now().time_since_epoch()).count(); +} + +inline std::string BuildFormBody(const std::map& params) { + std::string body; + for (auto& kv : params) { + if (!body.empty()) body += '&'; + body += UrlEncode(kv.first) + '=' + UrlEncode(kv.second); + } + return body; +} + +inline std::string JsonEscape(const std::string& s) { + std::string out; + for (char c : s) { + if (c == '"') out += "\\\""; + else if (c == '\\') out += "\\\\"; + else if (c == '\n') out += "\\n"; + else if (c == '\r') out += "\\r"; + else out += c; + } + return out; +} + +inline std::string JsonStr(const std::string& s) { + return "\"" + JsonEscape(s) + "\""; +} + +inline int64_t ParseIso8601Ms(const std::string& s) { + int Y=0, M=0, D=0, h=0, m=0; + double sec=0.0; + if (sscanf_s(s.c_str(), "%d-%d-%dT%d:%d:%lf", &Y, &M, &D, &h, &m, &sec) < 6) + return 0; + struct tm t = {}; + t.tm_year = Y - 1900; + t.tm_mon = M - 1; + t.tm_mday = D; + t.tm_hour = h; + t.tm_min = m; + t.tm_sec = (int)sec; + t.tm_isdst = 0; + time_t epoch = _mkgmtime(&t); + if (epoch == (time_t)-1) return 0; + int ms = (int)((sec - (int)sec) * 1000.0); + return (int64_t)epoch * 1000LL + ms; +} + +} // namespace mcauth diff --git a/MCAuth/src/MCAuthJava.cpp b/MCAuth/src/MCAuthJava.cpp new file mode 100644 index 0000000000..4eeff4a84c --- /dev/null +++ b/MCAuth/src/MCAuthJava.cpp @@ -0,0 +1,453 @@ +/* + * MCAuthJava.cpp — Minecraft Java Edition authentication chain + * + * Chain (using Java Win32 Title ID "00000000402b5328" via SISU): + * + * 1. MSA Device Code → POST login.live.com/oauth20_connect.srf + * 2. MSA Token → poll login.live.com/oauth20_token.srf + * 3. XBL Device Auth → POST device.auth.xboxlive.com (signed P-256) + * 4. SISU Authorize → POST sisu.xboxlive.com (signed P-256) + * RelyingParty = "rp://api.minecraftservices.com/" + * → JavaXstsToken {token, uhs} + * 5. Launcher Login → POST api.minecraftservices.com/launcher/login + * xtoken = "XBL3.0 x=;" + * → access_token, token_type, expires_in + * 6. Profile → GET api.minecraftservices.com/minecraft/profile + * Authorization: + * → id (undashed UUID), name + */ + +#include "../include/MCAuth.h" +#include "MCAuthCrypto.h" +#include "MCAuthHttp.h" +#include "MCAuthInternal.h" + +#define WIN32_LEAN_AND_MEAN +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace MCAuth { + +using namespace mcauth; + +struct JavaAuthManager::Impl { + + // Persistent + struct MsaState { + std::string accessToken, refreshToken; + int64_t expireMs = 0; + bool IsExpired() const { return NowMs() >= expireMs - 60000; } + } msa; + + ECKeyPair deviceKeyP256; + std::string deviceId; + + // Derived / cached + struct XblDeviceState { + std::string token, did; + int64_t expireMs = 0; + bool IsExpired() const { return NowMs() >= expireMs - 60000; } + } xblDevice; + + struct JavaXstsState { + std::string token, uhs; + int64_t expireMs = 0; + bool IsExpired() const { return NowMs() >= expireMs - 60000; } + } javaXsts; + + struct MinecraftTokenState { + std::string tokenType, accessToken; + int64_t expireMs = 0; + std::string AuthHeader() const { return tokenType + " " + accessToken; } + bool IsExpired() const { return NowMs() >= expireMs - 60000; } + } mcToken; + + std::atomic loggedIn{false}; + + // Cancellation: condition_variable for instant wakeup from poll sleep + std::atomic cancelRequested{false}; + std::mutex cancelMutex; + std::condition_variable cancelCv; + + // Waitable sleep that returns immediately on cancel. + // Returns true if cancel was requested. + bool SleepOrCancel(int64_t ms) { + std::unique_lock lock(cancelMutex); + return cancelCv.wait_for(lock, std::chrono::milliseconds(ms), [this] { + return cancelRequested.load(std::memory_order_relaxed); + }); + } + + Impl() { + deviceKeyP256 = GenerateP256KeyPair(); + deviceId = GenerateUUID(); + } + + // Step 1: Request MSA device code + struct DevCodeState { + std::string deviceCode, userCode, verificationUri; + int64_t expiresMs, intervalMs; + }; + + DevCodeState RequestDeviceCode() { + auto resp = HttpPost( + "https://login.live.com/oauth20_connect.srf", + BuildFormBody({{"client_id", JAVA_CLIENT_ID}, + {"scope", MSA_SCOPE}, // same scope as Bedrock + {"response_type", "device_code"}}), + "application/x-www-form-urlencoded"); + + if (resp.statusCode != 200) + throw std::runtime_error("Java DeviceCode HTTP " + + std::to_string(resp.statusCode) + ": " + resp.body); + + DevCodeState dc; + dc.deviceCode = JsonGetString(resp.body, "device_code"); + dc.userCode = JsonGetString(resp.body, "user_code"); + dc.verificationUri = JsonGetString(resp.body, "verification_uri"); + if (dc.deviceCode.empty() || dc.userCode.empty() || dc.verificationUri.empty()) + throw std::runtime_error("Java DeviceCode: missing required fields in response"); + int64_t expiresIn = JsonGetInt(resp.body, "expires_in"); + int64_t intervalIn = JsonGetInt(resp.body, "interval"); + dc.expiresMs = NowMs() + (expiresIn > 0 ? expiresIn : 300) * 1000; + dc.intervalMs = (intervalIn > 0 ? intervalIn : 5) * 1000; + return dc; + } + + // Step 2: Poll for MSA token + bool PollMsaToken(const DevCodeState& dc, int timeoutSec, std::string& error) { + int64_t deadline = NowMs() + (int64_t)timeoutSec * 1000; + int64_t intervalMs = dc.intervalMs > 0 ? dc.intervalMs : 5000; + while (NowMs() < deadline && NowMs() < dc.expiresMs) { + if (SleepOrCancel(intervalMs)) { + error = "cancelled"; + return false; + } + + HttpResponse resp; + try { + resp = HttpPost( + "https://login.live.com/oauth20_token.srf", + BuildFormBody({{"client_id", JAVA_CLIENT_ID}, + {"scope", MSA_SCOPE}, + {"grant_type", "device_code"}, + {"device_code", dc.deviceCode}}), + "application/x-www-form-urlencoded"); + } catch (const std::exception& ex) { + error = std::string("MSA poll network error: ") + ex.what(); + return false; + } + + if (resp.statusCode == 200) { + msa.accessToken = JsonGetString(resp.body, "access_token"); + msa.refreshToken = JsonGetString(resp.body, "refresh_token"); + msa.expireMs = NowMs() + JsonGetInt(resp.body, "expires_in") * 1000; + return true; + } + std::string err = JsonGetString(resp.body, "error"); + if (err == "authorization_pending") continue; + if (err == "slow_down") { intervalMs += 5000; continue; } + error = "MSA poll error: " + err; + return false; + } + error = "MSA device code login timed out"; + return false; + } + + // Step 2b: Refresh MSA token + bool RefreshMsaToken(std::string& error) { + if (msa.refreshToken.empty()) { error = "No refresh token"; return false; } + HttpResponse resp; + try { + resp = HttpPost( + "https://login.live.com/oauth20_token.srf", + BuildFormBody({{"client_id", JAVA_CLIENT_ID}, + {"scope", MSA_SCOPE}, + {"grant_type", "refresh_token"}, + {"refresh_token", msa.refreshToken}}), + "application/x-www-form-urlencoded"); + } catch (const std::exception& ex) { + error = std::string("MSA refresh network error: ") + ex.what(); + return false; + } + + if (resp.statusCode != 200) { + error = "MSA refresh HTTP " + std::to_string(resp.statusCode); + return false; + } + msa.accessToken = JsonGetString(resp.body, "access_token"); + std::string nr = JsonGetString(resp.body, "refresh_token"); + if (!nr.empty()) msa.refreshToken = nr; + msa.expireMs = NowMs() + JsonGetInt(resp.body, "expires_in") * 1000; + return true; + } + + // Step 3: XBL Device Authentication + bool AuthXblDevice(std::string& error) { + std::string proofKey = BuildProofKeyJson(deviceKeyP256); + std::string bodyJson = + "{\"Properties\":{" + "\"DeviceType\":\"Win32\"," + "\"Id\":\"{" + deviceId + "}\"," + "\"AuthMethod\":\"ProofOfPossession\"," + "\"ProofKey\":" + proofKey + + "},\"RelyingParty\":\"http://auth.xboxlive.com\"," + "\"TokenType\":\"JWT\"}"; + + std::string sig = BuildXblSignatureHeader( + deviceKeyP256, "POST", "/device/authenticate", bodyJson); + + auto resp = HttpPost( + "https://device.auth.xboxlive.com/device/authenticate", + bodyJson, "application/json", + {{"x-xbl-contract-version","1"},{"Signature", sig}}); + + if (resp.statusCode != 200) { + error = "XBL device auth HTTP " + std::to_string(resp.statusCode); + return false; + } + xblDevice.token = JsonGetString(resp.body, "Token"); + xblDevice.expireMs = ParseIso8601Ms(JsonGetString(resp.body, "NotAfter")); + std::string xdi = JsonRawValue(JsonRawValue(resp.body, "DisplayClaims"), "xdi"); + xblDevice.did = JsonGetString(xdi, "did"); + return true; + } + + // Step 4: SISU Authorize — Java relying party + bool AuthSisu(std::string& error) { + std::string proofKey = BuildProofKeyJson(deviceKeyP256); + std::string bodyJson = + "{\"Sandbox\":\"RETAIL\"," + "\"UseModernGamertag\":true," + "\"AppId\":\"" + std::string(JAVA_CLIENT_ID) + "\"," + "\"AccessToken\":\"t=" + msa.accessToken + "\"," + "\"DeviceToken\":\"" + xblDevice.token + "\"," + "\"ProofKey\":" + proofKey + "," + // Java Edition relying party + "\"RelyingParty\":\"rp://api.minecraftservices.com/\"}"; + + std::string sig = BuildXblSignatureHeader( + deviceKeyP256, "POST", "/authorize", bodyJson); + + auto resp = HttpPost( + "https://sisu.xboxlive.com/authorize", + bodyJson, "application/json", {{"Signature", sig}}); + + if (resp.statusCode != 200) { + error = "SISU authorize HTTP " + std::to_string(resp.statusCode) + + ": " + resp.body; + return false; + } + + // AuthorizationToken → JavaXstsToken + std::string authObj = JsonRawValue(resp.body, "AuthorizationToken"); + javaXsts.token = JsonGetString(authObj, "Token"); + javaXsts.expireMs = ParseIso8601Ms(JsonGetString(authObj, "NotAfter")); + + std::string disp = JsonRawValue(authObj, "DisplayClaims"); + std::string xui = JsonRawValue(disp, "xui"); + std::string xui0 = JsonFirstArrayObject(xui); + javaXsts.uhs = JsonGetString(xui0, "uhs"); + if (javaXsts.token.empty() || javaXsts.uhs.empty()) { + error = "SISU response missing XSTS token or uhs"; + return false; + } + return true; + } + + // Step 5: Minecraft Launcher Login + bool AuthMcLauncherLogin(std::string& error) { + std::string xtoken = "XBL3.0 x=" + javaXsts.uhs + ";" + javaXsts.token; + std::string bodyJson = + "{\"platform\":\"PC_LAUNCHER\"," + "\"xtoken\":\"" + xtoken + "\"}"; + + auto resp = HttpPost( + "https://api.minecraftservices.com/launcher/login", + bodyJson, "application/json"); + + if (resp.statusCode != 200) { + error = "Launcher login HTTP " + std::to_string(resp.statusCode) + + ": " + resp.body; + return false; + } + + mcToken.tokenType = JsonGetString(resp.body, "token_type"); + mcToken.accessToken = JsonGetString(resp.body, "access_token"); + mcToken.expireMs = NowMs() + JsonGetInt(resp.body, "expires_in") * 1000; + return true; + } + + // Step 6: Minecraft Profile + bool FetchProfile(JavaSession& out, std::string& error) { + auto resp = HttpGet( + "https://api.minecraftservices.com/minecraft/profile", + {{"Authorization", mcToken.AuthHeader()}}); + + if (resp.statusCode == 404) { + // Account exists but doesn't own Minecraft Java Edition + error = "This Microsoft account does not own Minecraft Java Edition"; + return false; + } + if (resp.statusCode != 200) { + error = "Profile HTTP " + std::to_string(resp.statusCode) + + ": " + resp.body; + return false; + } + + std::string rawId = JsonGetString(resp.body, "id"); + out.uuid = DashUuid(rawId); + out.username = JsonGetString(resp.body, "name"); + out.accessToken = mcToken.AuthHeader(); + out.expireMs = mcToken.expireMs; + if (out.uuid.empty() || out.username.empty()) { + error = "Minecraft profile response missing uuid or username"; + return false; + } + return true; + } + + // Full login chain + bool DoFullAuth(DeviceCodeCallback onDeviceCode, + JavaSession& out, std::string& error, int timeoutSec) { + cancelRequested.store(false, std::memory_order_relaxed); + DevCodeState dc; + try { dc = RequestDeviceCode(); } + catch (const std::exception& ex) { + error = std::string("DeviceCode network error: ") + ex.what(); + return false; + } + + DeviceCodeInfo info; + info.userCode = dc.userCode; + info.verificationUri = dc.verificationUri; + info.directUri = dc.verificationUri + "?otc=" + dc.userCode; + info.deviceCode = dc.deviceCode; + info.expiresMs = dc.expiresMs; + info.intervalMs = dc.intervalMs; + onDeviceCode(info); + + if (!PollMsaToken(dc, timeoutSec, error)) return false; + return DoAuthChain(out, error); + } + + bool DoAuthChain(JavaSession& out, std::string& error) { + try { + if (!AuthXblDevice(error)) return false; + if (!AuthSisu(error)) return false; + if (!AuthMcLauncherLogin(error)) return false; + if (!FetchProfile(out, error)) return false; + } catch (const std::runtime_error& ex) { + // Network/crypto exceptions carry context; propagate as-is + error = ex.what(); + return false; + } catch (const std::exception& ex) { + error = std::string("Unexpected auth error: ") + ex.what(); + return false; + } catch (...) { + error = "Unknown internal error during auth chain"; + return false; + } + loggedIn = true; + return true; + } + + // Serialisation helpers + std::string Serialise() const { + std::ostringstream o; + o << "{\n" + << "\"msaAccessToken\":" << mcauth::JsonStr(msa.accessToken) << ",\n" + << "\"msaRefreshToken\":" << mcauth::JsonStr(msa.refreshToken) << ",\n" + << "\"msaExpireMs\":" << msa.expireMs << ",\n" + << "\"deviceId\":" << mcauth::JsonStr(deviceId) << ",\n" + << "\"deviceKeyPriv\":" << mcauth::JsonStr(Base64Encode(deviceKeyP256.privateBlob)) << ",\n" + << "\"deviceKeyPub\":" << mcauth::JsonStr(Base64Encode(deviceKeyP256.publicBlob)) << "\n" + << "}"; + return o.str(); + } + + static ECKeyPair RebuildP256(const std::vector& priv, + const std::vector& pub) { + if (pub.size() < sizeof(BCRYPT_ECCKEY_BLOB)) return {}; + const BCRYPT_ECCKEY_BLOB* hdr = + reinterpret_cast(pub.data()); + ULONG cbKey = hdr->cbKey; + if (pub.size() < 8 + (size_t)cbKey * 2) return {}; + std::vector x(pub.begin()+8, pub.begin()+8+cbKey); + std::vector y(pub.begin()+8+cbKey, pub.begin()+8+cbKey*2); + + ECKeyPair kp; + kp.bitSize = 256; kp.privateBlob = priv; kp.publicBlob = pub; + kp.x = x; kp.y = y; + kp.publicKeyDER = BuildSubjectPublicKeyInfoDER(256, x, y); + return kp; + } + + bool Deserialise(const std::string& json) { + msa.accessToken = JsonGetString(json, "msaAccessToken"); + msa.refreshToken = JsonGetString(json, "msaRefreshToken"); + msa.expireMs = JsonGetInt(json, "msaExpireMs"); + deviceId = JsonGetString(json, "deviceId"); + auto priv = Base64Decode(JsonGetString(json, "deviceKeyPriv")); + auto pub = Base64Decode(JsonGetString(json, "deviceKeyPub")); + if (priv.empty() || pub.empty()) return false; + deviceKeyP256 = RebuildP256(priv, pub); + return true; + } +}; + +JavaAuthManager::JavaAuthManager() : m_impl(std::make_unique()) {} +JavaAuthManager::~JavaAuthManager() = default; + +bool JavaAuthManager::Login(DeviceCodeCallback onDeviceCode, + JavaSession& out, std::string& error, int timeoutSec) +{ + return m_impl->DoFullAuth(onDeviceCode, out, error, timeoutSec); +} + +bool JavaAuthManager::Refresh(JavaSession& out, std::string& error) { + m_impl->cancelRequested.store(false, std::memory_order_relaxed); + if (!m_impl->RefreshMsaToken(error)) return false; + return m_impl->DoAuthChain(out, error); +} + +bool JavaAuthManager::IsLoggedIn() const { return m_impl->loggedIn; } + +void JavaAuthManager::Logout() { + m_impl->msa = {}; + m_impl->javaXsts = {}; + m_impl->mcToken = {}; + m_impl->loggedIn = false; +} + +void JavaAuthManager::RequestCancel() { + m_impl->cancelRequested.store(true, std::memory_order_release); + m_impl->cancelCv.notify_all(); +} + +bool JavaAuthManager::SaveTokens(const std::string& path) const { + std::ofstream f(path); + if (!f) return false; + f << m_impl->Serialise(); + return f.good(); +} + +bool JavaAuthManager::LoadTokens(const std::string& path) { + std::ifstream f(path); + if (!f) return false; + std::string content((std::istreambuf_iterator(f)), + std::istreambuf_iterator()); + return m_impl->Deserialise(content); +} + +} // namespace MCAuth diff --git a/MCAuth/src/MCAuthManager.cpp b/MCAuth/src/MCAuthManager.cpp new file mode 100644 index 0000000000..8faca1d7f2 --- /dev/null +++ b/MCAuth/src/MCAuthManager.cpp @@ -0,0 +1,986 @@ +#define _CRT_SECURE_NO_WARNINGS +#include "../include/MCAuthManager.h" +#include "MCAuthInternal.h" +#include +#include +#include +#include +#include + +#ifdef _WIN32 +#include +#endif +static void AuthLogImpl(const char* fmt, ...) { + char buf[512]; + va_list ap; + va_start(ap, fmt); + vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); +#ifdef _WIN32 + OutputDebugStringA(buf); +#endif + // Use _fsopen with _SH_DENYWR so only this process can write + FILE* f = _fsopen("mcauth_debug.log", "a", _SH_DENYWR); + if (f) { fputs(buf, f); fclose(f); } +} +#define AUTH_LOG(msg, ...) AuthLogImpl("[MCAuth] " msg "\n", ##__VA_ARGS__) + +using namespace mcauth; + +MCAuthManager& MCAuthManager::Get() { + static MCAuthManager instance; + return instance; +} + +MCAuthManager::MCAuthManager() = default; + +MCAuthManager::~MCAuthManager() { + // Cancel all in-flight workers so detached threads exit promptly. + for (int i = 0; i < XUSER_MAX_COUNT; ++i) { + ++m_slots[i].generation; + if (m_slots[i].auth) + m_slots[i].auth->RequestCancel(); + } +} + +std::shared_ptr MCAuthManager::ResetSlotAuth(AuthSlot& s) { + // Cancel the old engine's blocking operations + if (s.auth) + s.auth->RequestCancel(); + + // Create a fresh engine — old threads still hold their shared_ptr copy + auto fresh = std::make_shared(); + s.auth = fresh; + return fresh; +} + +MCAuth::JavaSession MCAuthManager::SynthesizeOfflineSession(const JavaAccountInfo& acct) { + MCAuth::JavaSession s; + s.username = acct.username; + s.uuid = acct.uuid; + s.accessToken = ""; + s.expireMs = 0; + return s; +} + +bool MCAuthManager::LoadJavaAccountIndex() { + std::ifstream f(kJavaAccountsFile); + if (!f) { + AUTH_LOG("LoadJavaAccountIndex: file '%s' not found", kJavaAccountsFile); + return false; + } + std::string content((std::istreambuf_iterator(f)), + std::istreambuf_iterator()); + + std::lock_guard lock(m_accountsMutex); + m_javaAccounts.clear(); + + int activeIndex = (int)JsonGetInt(content, "activeIndex"); + + // Parse accounts array + std::vector objects; + { + size_t pos = content.find("\"accounts\""); + if (pos != std::string::npos) { + pos = content.find('[', pos); + if (pos != std::string::npos) { + int depth = 0; size_t start = pos; + for (; pos < content.size(); ++pos) { + if (content[pos] == '[') ++depth; + else if (content[pos] == ']') { --depth; if (depth == 0) { ++pos; break; } } + } + std::string arr = content.substr(start, pos - start); + objects = JsonArrayObjects(arr); + } + } + } + + for (auto& obj : objects) { + JavaAccountInfo info; + info.username = JsonGetString(obj, "username"); + info.uuid = JsonGetString(obj, "uuid"); + info.tokenFile = JsonGetString(obj, "tokenFile"); + info.isOffline = (JsonRawValue(obj, "isOffline") == "true"); + info.authProvider = JsonGetString(obj, "authProvider"); + if (info.authProvider.empty()) + info.authProvider = info.isOffline ? "offline" : "mojang"; + if (!info.tokenFile.empty() || info.isOffline) + m_javaAccounts.push_back(std::move(info)); + } + + // Set slot 0's active account from saved index + if (activeIndex >= 0 && activeIndex < (int)m_javaAccounts.size()) + m_slots[0].accountIndex = activeIndex; + else + m_slots[0].accountIndex = m_javaAccounts.empty() ? -1 : 0; + + AUTH_LOG("LoadJavaAccountIndex: loaded %d accounts, active=%d", + (int)m_javaAccounts.size(), m_slots[0].accountIndex.load()); + return true; +} + +bool MCAuthManager::SaveJavaAccountIndex() const { + std::lock_guard lock(m_accountsMutex); + + std::ostringstream o; + o << "{\n"; + o << "\"activeIndex\":" << m_slots[0].accountIndex.load() << ",\n"; + o << "\"accounts\":[\n"; + for (size_t i = 0; i < m_javaAccounts.size(); ++i) { + auto& a = m_javaAccounts[i]; + o << " {\"username\":" << JsonStr(a.username) + << ",\"uuid\":" << JsonStr(a.uuid) + << ",\"tokenFile\":" << JsonStr(a.tokenFile) + << ",\"isOffline\":" << (a.isOffline ? "true" : "false") + << ",\"authProvider\":" << JsonStr(a.authProvider.empty() ? "mojang" : a.authProvider) << "}"; + if (i + 1 < m_javaAccounts.size()) o << ","; + o << "\n"; + } + o << "]\n}"; + + std::ofstream f(kJavaAccountsFile); + if (!f) return false; + f << o.str(); + AUTH_LOG("SaveJavaAccountIndex: saved %d accounts, active=%d", + (int)m_javaAccounts.size(), m_slots[0].accountIndex.load()); + return f.good(); +} + +std::vector MCAuthManager::GetJavaAccounts() const { + std::lock_guard lock(m_accountsMutex); + return m_javaAccounts; +} + +std::string MCAuthManager::AllocTokenFile(const std::string& uuid) const { + if (!uuid.empty()) + return uuid + ".json"; + for (int i = 0; ; ++i) { + char buf[64]; + snprintf(buf, sizeof(buf), "java_auth_%d.json", i); + std::string name(buf); + bool taken = false; + for (auto& a : m_javaAccounts) { + if (a.tokenFile == name) { taken = true; break; } + } + if (!taken) return name; + } +} + +const MCAuthManager::AuthSlot& MCAuthManager::GetSlot(int slot) const { + if (slot < 0 || slot >= XUSER_MAX_COUNT) slot = 0; + return m_slots[slot]; +} + +MCAuth::JavaSession MCAuthManager::GetSlotSession(int slot) const { + if (slot < 0 || slot >= XUSER_MAX_COUNT) slot = 0; + auto& s = m_slots[slot]; + + // Check offline status first (accounts mutex), then get session (slot mutex). + { + std::lock_guard alock(m_accountsMutex); + if (s.accountIndex >= 0 && s.accountIndex < (int)m_javaAccounts.size() + && m_javaAccounts[s.accountIndex].isOffline) + return SynthesizeOfflineSession(m_javaAccounts[s.accountIndex]); + } + std::lock_guard lock(s.mutex); + return s.session; +} + +bool MCAuthManager::IsSlotLoggedIn(int slot) const { + if (slot < 0 || slot >= XUSER_MAX_COUNT) return false; + auto& s = m_slots[slot]; + + { + std::lock_guard alock(m_accountsMutex); + if (s.accountIndex >= 0 && s.accountIndex < (int)m_javaAccounts.size()) { + if (m_javaAccounts[s.accountIndex].isOffline) + return true; + if (m_javaAccounts[s.accountIndex].authProvider == "elyby") { + std::lock_guard slock(s.mutex); + return !s.elybyTokens.accessToken.empty(); + } + } + } + + return s.auth && s.auth->IsLoggedIn(); +} + +bool MCAuthManager::IsTokenExpiringSoon(int slot) const { + if (slot < 0 || slot >= XUSER_MAX_COUNT) return false; + auto& s = m_slots[slot]; + std::lock_guard lock(s.mutex); + if (s.session.expireMs <= 0) return false; + return NowMs() > s.session.expireMs - 60000; // within 60s of expiry +} + +bool MCAuthManager::IsAccountInUseByOtherSlot(int slot, int accountIndex) const { + std::lock_guard alock(m_accountsMutex); + if (accountIndex < 0 || accountIndex >= (int)m_javaAccounts.size()) return false; + + for (int i = 0; i < XUSER_MAX_COUNT; ++i) { + if (i == slot) continue; + if (m_slots[i].accountIndex == accountIndex) return true; + } + return false; +} + +void MCAuthManager::RunElybyRefresh(int slot, uint32_t gen, const std::string& tokenFile, + bool failOpen, bool alwaysSaveIndex) { + auto& s = m_slots[slot]; + std::string error; + MCAuth::ElybyTokens tokens; + { + std::lock_guard lock(s.mutex); + tokens = s.elybyTokens; + } + bool ok = MCAuth::ElybyRefresh(tokens, error); + if (s.generation != gen) return; + + { + std::lock_guard lock(s.mutex); + if (ok) { + s.elybyTokens = tokens; + s.session.username = tokens.username; + s.session.uuid = MCAuth::DashUuid(tokens.uuid); + s.session.accessToken = tokens.accessToken; + s.lastError.clear(); + s.state = State::Success; + } else { + s.lastError = error; + s.state = failOpen ? State::Success : State::Failed; + } + s.cv.notify_all(); + } + if (ok) { + if (!tokenFile.empty()) + MCAuth::ElybySaveTokens(tokenFile, tokens); + { + std::lock_guard alock(m_accountsMutex); + if (s.accountIndex >= 0 && s.accountIndex < (int)m_javaAccounts.size()) { + m_javaAccounts[s.accountIndex].username = tokens.username; + m_javaAccounts[s.accountIndex].uuid = MCAuth::DashUuid(tokens.uuid); + } + } + } + if (ok || alwaysSaveIndex) + SaveJavaAccountIndex(); +} + +void MCAuthManager::RefreshSlot(int slot) { + if (slot < 0 || slot >= XUSER_MAX_COUNT) return; + auto& s = m_slots[slot]; + + // Check if this is an ely.by account — if so, use ely.by refresh + std::string provider; + std::string elyTokenFile; + { + std::lock_guard alock(m_accountsMutex); + if (s.accountIndex >= 0 && s.accountIndex < (int)m_javaAccounts.size()) { + provider = m_javaAccounts[s.accountIndex].authProvider; + elyTokenFile = m_javaAccounts[s.accountIndex].tokenFile; + } + } + + if (provider == "elyby") { + uint32_t gen = ++s.generation; + { + std::lock_guard lock(s.mutex); + s.state = State::Authenticating; + s.cv.notify_all(); + } + std::thread([this, slot, gen, elyTokenFile]() { + RunElybyRefresh(slot, gen, elyTokenFile, /*failOpen=*/false, /*alwaysSaveIndex=*/false); + }).detach(); + return; + } + + // Increment generation to invalidate any in-flight work + uint32_t gen = ++s.generation; + + { + std::lock_guard lock(s.mutex); + s.state = State::Authenticating; + s.cv.notify_all(); + } + + // Capture auth engine by shared_ptr so it stays alive if replaced. + auto authCopy = s.auth; + + std::thread([this, slot, gen, authCopy]() { + auto& s = m_slots[slot]; + std::string error; + MCAuth::JavaSession session; + bool ok = false; + try { + ok = authCopy->Refresh(session, error); + } catch (const std::exception& ex) { + error = std::string("RefreshSlot network error: ") + ex.what(); + } catch (...) { + error = "RefreshSlot unknown error"; + } + + // Stale check: if a newer operation started, discard silently + if (s.generation != gen) { + AUTH_LOG("RefreshSlot(%d): generation mismatch (%u vs %u), discarding", + slot, gen, s.generation.load()); + return; + } + + std::string tokenFile; + { + std::lock_guard lock(s.mutex); + if (ok) { + s.session = session; + s.lastError.clear(); + s.state = State::Success; + } else { + s.lastError = error; + s.state = State::Failed; + } + s.cv.notify_all(); + } + + // Update account info outside slot mutex (consistent lock order) + if (ok) { + std::lock_guard alock(m_accountsMutex); + if (s.accountIndex >= 0 && s.accountIndex < (int)m_javaAccounts.size()) { + m_javaAccounts[s.accountIndex].username = session.username; + m_javaAccounts[s.accountIndex].uuid = session.uuid; + tokenFile = m_javaAccounts[s.accountIndex].tokenFile; + } + } + + AUTH_LOG("RefreshSlot(%d): ok=%d, username='%s', error='%s'", + slot, (int)ok, ok ? session.username.c_str() : "", error.c_str()); + + // File I/O outside all mutexes + if (ok && !tokenFile.empty()) { + authCopy->SaveTokens(tokenFile); + SaveJavaAccountIndex(); + } + }).detach(); +} + +bool MCAuthManager::SetAccountForSlot(int slot, int accountIndex) { + if (slot < 0 || slot >= XUSER_MAX_COUNT) return false; + auto& s = m_slots[slot]; + + bool isOffline = false; + bool isElyby = false; + std::string tokenFile; + { + std::lock_guard alock(m_accountsMutex); + if (accountIndex < 0 || accountIndex >= (int)m_javaAccounts.size()) return false; + isOffline = m_javaAccounts[accountIndex].isOffline; + isElyby = (m_javaAccounts[accountIndex].authProvider == "elyby"); + tokenFile = m_javaAccounts[accountIndex].tokenFile; + } + + // Invalidate any in-flight work for this slot + uint32_t gen = ++s.generation; + + if (isOffline) { + // Offline: set session immediately, no background work. + MCAuth::JavaSession offlineSession; + std::string offlineName; + { + std::lock_guard alock(m_accountsMutex); + offlineSession = SynthesizeOfflineSession(m_javaAccounts[accountIndex]); + offlineName = m_javaAccounts[accountIndex].username; + } + { + std::lock_guard lock(s.mutex); + s.accountIndex = accountIndex; + s.session = offlineSession; + s.state = State::Success; + s.cv.notify_all(); + } + AUTH_LOG("SetAccountForSlot(%d): switched to offline account %d '%s'", + slot, accountIndex, offlineName.c_str()); + (void)gen; + } else if (isElyby) { + // Ely.by: load tokens from file, build session, refresh in background + { + std::lock_guard lock(s.mutex); + s.accountIndex = accountIndex; + } + + AUTH_LOG("SetAccountForSlot(%d): switching to elyby account %d, tokenFile='%s'", + slot, accountIndex, tokenFile.c_str()); + + MCAuth::ElybyTokens elyTokens; + if (!MCAuth::ElybyLoadTokens(tokenFile, elyTokens)) { + AUTH_LOG("SetAccountForSlot(%d): ElybyLoadTokens failed", slot); + std::lock_guard lock(s.mutex); + s.state = State::Failed; + s.cv.notify_all(); + return false; + } + + // Store tokens and build session + { + std::lock_guard lock(s.mutex); + s.elybyTokens = elyTokens; + s.session.username = elyTokens.username; + s.session.uuid = MCAuth::DashUuid(elyTokens.uuid); + s.session.accessToken = elyTokens.accessToken; + s.session.expireMs = 0; // Ely.by tokens don't have a fixed expiry + s.state = State::Authenticating; + s.cv.notify_all(); + } + + // Refresh in background + uint32_t elyGen = ++s.generation; + std::thread([this, slot, elyGen, tokenFile]() { + RunElybyRefresh(slot, elyGen, tokenFile, /*failOpen=*/true, /*alwaysSaveIndex=*/true); + }).detach(); + } else { + // Online (Mojang/Microsoft): create a fresh auth engine, load tokens, refresh in background + { + std::lock_guard lock(s.mutex); + s.accountIndex = accountIndex; + } + + AUTH_LOG("SetAccountForSlot(%d): switching to online account %d, tokenFile='%s'", + slot, accountIndex, tokenFile.c_str()); + + auto freshAuth = ResetSlotAuth(s); + + if (!freshAuth->LoadTokens(tokenFile)) { + AUTH_LOG("SetAccountForSlot(%d): LoadTokens failed", slot); + std::lock_guard lock(s.mutex); + s.state = State::Failed; + s.cv.notify_all(); + return false; + } + + // Refresh in background (uses the fresh auth engine via s.auth) + RefreshSlot(slot); + } + + SaveJavaAccountIndex(); + return true; +} + +void MCAuthManager::ClearSlot(int slot) { + if (slot < 0 || slot >= XUSER_MAX_COUNT) return; + auto& s = m_slots[slot]; + + ++s.generation; // invalidate in-flight work + + ResetSlotAuth(s); + + std::lock_guard lock(s.mutex); + s.session = {}; + s.accountIndex = -1; + s.state = State::Idle; + s.lastError.clear(); + s.cv.notify_all(); +} + +bool MCAuthManager::WaitForSlotReady(int slot, int timeoutMs) const { + if (slot < 0 || slot >= XUSER_MAX_COUNT) return false; + auto& s = m_slots[slot]; + std::unique_lock lock(s.mutex); + bool ok = s.cv.wait_for(lock, std::chrono::milliseconds(timeoutMs), [&] { + State st = s.state.load(); + return st != State::Authenticating && st != State::WaitingForCode; + }); + return ok && (s.state == State::Success); +} + +int MCAuthManager::GetActiveJavaAccountIndex() const { + return m_slots[0].accountIndex; +} + +MCAuth::JavaSession MCAuthManager::GetJavaSession() const { + return GetSlotSession(0); +} + +bool MCAuthManager::IsJavaLoggedIn() const { + return IsSlotLoggedIn(0); +} + +int MCAuthManager::AddOfflineJavaAccount(const std::string& username) { + if (username.empty()) return -1; + + std::string uuid = MCAuth::GenerateOfflineUuid(username); + if (uuid.empty()) return -1; + + std::lock_guard alock(m_accountsMutex); + + // Check if this offline account already exists (by UUID) + for (int i = 0; i < (int)m_javaAccounts.size(); ++i) { + if (m_javaAccounts[i].uuid == uuid) { + m_javaAccounts[i].username = username; + + // Set slot 0 to this account + { + std::lock_guard lock(m_slots[0].mutex); + m_slots[0].accountIndex = i; + m_slots[0].session = SynthesizeOfflineSession(m_javaAccounts[i]); + m_slots[0].state = State::Success; + m_slots[0].cv.notify_all(); + } + + AUTH_LOG("AddOfflineJavaAccount: updated existing offline account idx=%d '%s'", + i, username.c_str()); + return i; + } + } + + JavaAccountInfo info; + info.username = username; + info.uuid = uuid; + info.tokenFile = ""; + info.isOffline = true; + info.authProvider = "offline"; + m_javaAccounts.push_back(std::move(info)); + int idx = (int)m_javaAccounts.size() - 1; + + // Set slot 0 to this account + { + std::lock_guard lock(m_slots[0].mutex); + m_slots[0].accountIndex = idx; + m_slots[0].session = SynthesizeOfflineSession(m_javaAccounts[idx]); + m_slots[0].state = State::Success; + m_slots[0].cv.notify_all(); + } + + AUTH_LOG("AddOfflineJavaAccount: added new offline account idx=%d '%s' uuid='%s'", + idx, username.c_str(), uuid.c_str()); + return idx; +} + +void MCAuthManager::BeginAddJavaAccount(DeviceCodeCb onDeviceCode, + JavaCompleteCb onComplete, + int timeoutSeconds) +{ + auto& s = m_slots[0]; + + // Invalidate any in-flight work on slot 0 + uint32_t gen = ++s.generation; + + // Clear stale device code + { + std::lock_guard lock(m_deviceCodeMutex); + m_javaDeviceCode.clear(); + m_javaDirectUri.clear(); + } + + { + std::lock_guard lock(s.mutex); + s.state = State::WaitingForCode; + s.cv.notify_all(); + } + + auto freshAuth = ResetSlotAuth(s); + + std::thread([this, freshAuth, onDeviceCode, onComplete, timeoutSeconds, gen]() { + try { + auto& s = m_slots[0]; + + MCAuth::JavaSession session; + std::string error; + + bool ok = freshAuth->Login( + [&](const MCAuth::DeviceCodeInfo& dc) { + // If a newer flow started, don't overwrite its device code + if (s.generation != gen) return; + + { + std::lock_guard lock(s.mutex); + s.state = State::WaitingForCode; + s.cv.notify_all(); + } + { + std::lock_guard lock(m_deviceCodeMutex); + m_javaDeviceCode = dc.userCode; + m_javaDirectUri = dc.directUri; + } + if (onDeviceCode) onDeviceCode(dc); + { + std::lock_guard lock(s.mutex); + s.state = State::Authenticating; + s.cv.notify_all(); + } + }, + session, error, timeoutSeconds); + + // ---- STALE CHECK (under mutex for correctness) ---- + // If a newer operation has started, discard results silently. + { + std::lock_guard lock(s.mutex); + if (s.generation != gen) { + AUTH_LOG("BeginAddJavaAccount: gen %u stale (current %u), discarding", + gen, s.generation.load()); + if (onComplete) onComplete(false, {}, "cancelled"); + return; + } + } + + if (ok) { + std::string tokenFile; + { + std::lock_guard alock(m_accountsMutex); + + // Check if this account already exists (by UUID) + int existingIdx = -1; + for (int i = 0; i < (int)m_javaAccounts.size(); ++i) { + if (m_javaAccounts[i].uuid == session.uuid) { + existingIdx = i; + break; + } + } + + if (existingIdx >= 0) { + m_javaAccounts[existingIdx].username = session.username; + tokenFile = m_javaAccounts[existingIdx].tokenFile; + s.accountIndex = existingIdx; + AUTH_LOG("BeginAddJavaAccount: updated existing account idx=%d '%s'", + existingIdx, session.username.c_str()); + } else { + JavaAccountInfo info; + info.username = session.username; + info.uuid = session.uuid; + info.tokenFile = AllocTokenFile(session.uuid); + info.authProvider = "mojang"; + tokenFile = info.tokenFile; + m_javaAccounts.push_back(std::move(info)); + s.accountIndex = (int)m_javaAccounts.size() - 1; + AUTH_LOG("BeginAddJavaAccount: added new account idx=%d '%s' file='%s'", + s.accountIndex.load(), session.username.c_str(), + m_javaAccounts.back().tokenFile.c_str()); + } + } + + // File I/O outside all mutexes + if (!tokenFile.empty()) + freshAuth->SaveTokens(tokenFile); + + { + std::lock_guard lock(s.mutex); + s.session = session; + s.lastError.clear(); + s.state = State::Success; + s.cv.notify_all(); + } + + SaveJavaAccountIndex(); + } else { + { + std::lock_guard lock(s.mutex); + s.lastError = error; + s.state = State::Failed; + s.cv.notify_all(); + } + + // If we had an active account, reload it into the current auth engine + std::string reloadFile; + { + std::lock_guard alock(m_accountsMutex); + if (s.accountIndex >= 0 && s.accountIndex < (int)m_javaAccounts.size()) + reloadFile = m_javaAccounts[s.accountIndex].tokenFile; + } + if (!reloadFile.empty()) + freshAuth->LoadTokens(reloadFile); + } + + if (onComplete) onComplete(ok, session, error); + } catch (const std::exception& ex) { + AUTH_LOG("BeginAddJavaAccount: uncaught exception: %s", ex.what()); + auto& s = m_slots[0]; + { + std::lock_guard lock(s.mutex); + s.lastError = std::string("Auth network error: ") + ex.what(); + s.state = State::Failed; + s.cv.notify_all(); + } + if (onComplete) onComplete(false, {}, s.lastError); + } catch (...) { + AUTH_LOG("BeginAddJavaAccount: unknown uncaught exception"); + auto& s = m_slots[0]; + { + std::lock_guard lock(s.mutex); + s.lastError = "Unknown auth error"; + s.state = State::Failed; + s.cv.notify_all(); + } + if (onComplete) onComplete(false, {}, "Unknown auth error"); + } + }).detach(); +} + +void MCAuthManager::BeginAddElybyAccount(const std::string& username, const std::string& password, + ElybyCompleteCb onComplete, Elyby2FACb on2FA) +{ + auto& s = m_slots[0]; + uint32_t gen = ++s.generation; + + { + std::lock_guard lock(s.mutex); + s.state = State::Authenticating; + s.cv.notify_all(); + } + + std::thread([this, username, password, onComplete, on2FA, gen]() { + try { + auto& s = m_slots[0]; + MCAuth::ElybyTokens tokens; + std::string error; + + bool ok = MCAuth::ElybyLogin(username, password, tokens, error); + + if (!ok && error == "elyby_2fa_required") { + // Signal caller that 2FA is needed + { + std::lock_guard lock(s.mutex); + s.state = State::WaitingForCode; // repurpose: waiting for 2FA input + s.cv.notify_all(); + } + if (on2FA) on2FA(); + if (onComplete) onComplete(false, {}, "elyby_2fa_required"); + return; + } + + { + std::lock_guard lock(s.mutex); + if (s.generation != gen) { + if (onComplete) onComplete(false, {}, "cancelled"); + return; + } + } + + if (ok) { + std::string dashedUuid = MCAuth::DashUuid(tokens.uuid); + std::string tokenFile; + { + std::lock_guard alock(m_accountsMutex); + + int existingIdx = -1; + for (int i = 0; i < (int)m_javaAccounts.size(); ++i) { + if (m_javaAccounts[i].uuid == dashedUuid) { + existingIdx = i; + break; + } + } + + if (existingIdx >= 0) { + m_javaAccounts[existingIdx].username = tokens.username; + m_javaAccounts[existingIdx].authProvider = "elyby"; + tokenFile = m_javaAccounts[existingIdx].tokenFile; + s.accountIndex = existingIdx; + } else { + JavaAccountInfo info; + info.username = tokens.username; + info.uuid = dashedUuid; + info.tokenFile = AllocTokenFile(dashedUuid); + info.isOffline = false; + info.authProvider = "elyby"; + tokenFile = info.tokenFile; + m_javaAccounts.push_back(std::move(info)); + s.accountIndex = (int)m_javaAccounts.size() - 1; + } + } + + if (!tokenFile.empty()) + MCAuth::ElybySaveTokens(tokenFile, tokens); + + MCAuth::JavaSession session; + session.username = tokens.username; + session.uuid = dashedUuid; + session.accessToken = tokens.accessToken; + session.expireMs = 0; + + { + std::lock_guard lock(s.mutex); + s.elybyTokens = tokens; + s.session = session; + s.lastError.clear(); + s.state = State::Success; + s.cv.notify_all(); + } + + SaveJavaAccountIndex(); + if (onComplete) onComplete(true, session, ""); + } else { + { + std::lock_guard lock(s.mutex); + s.lastError = error; + s.state = State::Failed; + s.cv.notify_all(); + } + if (onComplete) onComplete(false, {}, error); + } + } catch (const std::exception& ex) { + auto& s = m_slots[0]; + { + std::lock_guard lock(s.mutex); + s.lastError = std::string("Elyby auth error: ") + ex.what(); + s.state = State::Failed; + s.cv.notify_all(); + } + if (onComplete) onComplete(false, {}, s.lastError); + } catch (...) { + auto& s = m_slots[0]; + { + std::lock_guard lock(s.mutex); + s.lastError = "Unknown elyby auth error"; + s.state = State::Failed; + s.cv.notify_all(); + } + if (onComplete) onComplete(false, {}, "Unknown elyby auth error"); + } + }).detach(); +} + +bool MCAuthManager::RemoveJavaAccount(int index) { + std::lock_guard alock(m_accountsMutex); + if (index < 0 || index >= (int)m_javaAccounts.size()) return false; + + AUTH_LOG("RemoveJavaAccount: removing index %d ('%s')", + index, m_javaAccounts[index].username.c_str()); + + std::remove(m_javaAccounts[index].tokenFile.c_str()); + m_javaAccounts.erase(m_javaAccounts.begin() + index); + + // Adjust all slots' account indices + for (int i = 0; i < XUSER_MAX_COUNT; ++i) { + auto& s = m_slots[i]; + if (s.accountIndex == index) { + // This slot was using the removed account + if (m_javaAccounts.empty()) { + s.accountIndex = -1; + std::lock_guard lock(s.mutex); + s.session = {}; + s.state = State::Idle; + s.cv.notify_all(); + } else { + s.accountIndex = 0; + // Caller should call SetAccountForSlot to reload + } + } else if (s.accountIndex > index) { + --s.accountIndex; + } + } + + return true; // caller must call SaveJavaAccountIndex() after +} + +void MCAuthManager::TryRestoreActiveJavaAccount() { + AUTH_LOG("TryRestoreActiveJavaAccount called (already attempted=%d)", + (int)m_javaRestoreAttempted); + + if (m_javaRestoreAttempted) return; + m_javaRestoreAttempted = true; + + if (!LoadJavaAccountIndex()) { + // Try legacy single-file migration + auto& s = m_slots[0]; + if (s.auth->LoadTokens("java_auth.json")) { + AUTH_LOG("TryRestoreActiveJavaAccount: migrating legacy java_auth.json"); + std::lock_guard alock(m_accountsMutex); + JavaAccountInfo info; + info.username = ""; + info.uuid = ""; + info.tokenFile = "legacy_migrated.json"; + s.auth->SaveTokens(info.tokenFile); + m_javaAccounts.push_back(std::move(info)); + s.accountIndex = 0; + std::remove("java_auth.json"); + } else { + AUTH_LOG("TryRestoreActiveJavaAccount: no accounts found"); + return; + } + } + + auto& s = m_slots[0]; + int activeIdx = s.accountIndex; + + std::string tokenFile; + bool isOffline = false; + bool isElyby = false; + { + std::lock_guard alock(m_accountsMutex); + if (activeIdx < 0 || activeIdx >= (int)m_javaAccounts.size()) { + AUTH_LOG("TryRestoreActiveJavaAccount: no active account"); + return; + } + isOffline = m_javaAccounts[activeIdx].isOffline; + isElyby = (m_javaAccounts[activeIdx].authProvider == "elyby"); + tokenFile = m_javaAccounts[activeIdx].tokenFile; + } + + if (isElyby) { + AUTH_LOG("TryRestoreActiveJavaAccount: elyby account %d, loading tokens from '%s'", + activeIdx, tokenFile.c_str()); + MCAuth::ElybyTokens elyTokens; + if (!MCAuth::ElybyLoadTokens(tokenFile, elyTokens)) { + AUTH_LOG("TryRestoreActiveJavaAccount: ElybyLoadTokens failed for '%s'", tokenFile.c_str()); + std::lock_guard lock(s.mutex); + s.state = State::Failed; + s.lastError = "Failed to load ely.by token file: " + tokenFile; + s.cv.notify_all(); + return; + } + { + std::lock_guard lock(s.mutex); + s.elybyTokens = elyTokens; + s.session.username = elyTokens.username; + s.session.uuid = MCAuth::DashUuid(elyTokens.uuid); + s.session.accessToken = elyTokens.accessToken; + s.session.expireMs = 0; + s.state = State::Success; + s.cv.notify_all(); + } + // Refresh in background + RefreshSlot(0); + return; + } + + if (isOffline) { + AUTH_LOG("TryRestoreActiveJavaAccount: offline account %d, no refresh needed", activeIdx); + MCAuth::JavaSession offlineSession; + { + std::lock_guard alock(m_accountsMutex); + offlineSession = SynthesizeOfflineSession(m_javaAccounts[activeIdx]); + } + { + std::lock_guard lock(s.mutex); + s.session = offlineSession; + s.state = State::Success; + s.cv.notify_all(); + } + return; + } + + AUTH_LOG("TryRestoreActiveJavaAccount: loading tokenFile='%s' for account %d", + tokenFile.c_str(), activeIdx); + + if (!s.auth->LoadTokens(tokenFile)) { + AUTH_LOG("TryRestoreActiveJavaAccount: LoadTokens failed for '%s'", tokenFile.c_str()); + std::lock_guard lock(s.mutex); + s.state = State::Failed; + s.lastError = "Failed to load token file: " + tokenFile; + s.cv.notify_all(); + return; + } + + RefreshSlot(0); +} + +std::string MCAuthManager::GetJavaDeviceCode() const { + std::lock_guard lock(m_deviceCodeMutex); + return m_javaDeviceCode; +} + +std::string MCAuthManager::GetJavaDirectUri() const { + std::lock_guard lock(m_deviceCodeMutex); + return m_javaDirectUri; +} + +std::string MCAuthManager::GetLastError() const { + auto& s = m_slots[0]; + std::lock_guard lock(s.mutex); + return s.lastError; +} diff --git a/MCAuth/src/MCAuthSession.cpp b/MCAuth/src/MCAuthSession.cpp new file mode 100644 index 0000000000..637eb28715 --- /dev/null +++ b/MCAuth/src/MCAuthSession.cpp @@ -0,0 +1,476 @@ +/* + * MCAuthSession.cpp — UUID utilities and Mojang session verification + * + * UUID v3 generation uses MD5 with the "OfflinePlayer:" namespace, + * matching vanilla Minecraft's offline UUID derivation. + * + * Session verification: + * - JoinServer() — client calls before connecting (POST /session/minecraft/join) + * - HasJoined() — server verifies after receiving auth response (GET /session/minecraft/hasJoined) + */ + +#include "../include/MCAuth.h" +#include "MCAuthCrypto.h" +#include "MCAuthHttp.h" +#include "MCAuthInternal.h" + +#define WIN32_LEAN_AND_MEAN +#include +#include +#include + +#include +#include +#include +#include + +#pragma comment(lib, "bcrypt.lib") +#pragma comment(lib, "windowscodecs.lib") +#pragma comment(lib, "ole32.lib") + +namespace MCAuth { + +using namespace mcauth; + +std::string MakeSkinKey(const std::string& uuid) { + return "mojang_skin_" + UndashUuid(uuid) + ".png"; +} + +std::string UndashUuid(const std::string& dashed) { + std::string out; + out.reserve(32); + for (char c : dashed) { + if (c != '-') out += c; + } + return out; +} + +std::string DashUuid(const std::string& u) { + if (u.size() != 32) return u; + // 8-4-4-4-12 + return u.substr(0, 8) + "-" + u.substr(8, 4) + "-" + u.substr(12, 4) + + "-" + u.substr(16, 4) + "-" + u.substr(20); +} + +std::string GenerateOfflineUuid(const std::string& username) { + std::string input = "OfflinePlayer:" + username; + auto md5 = ComputeMD5(input.data(), input.size()); + if (md5.size() < 16) return ""; + uint8_t hash[16]; + memcpy(hash, md5.data(), 16); + + // Set version to 3 (byte 6, high nibble) + hash[6] = (hash[6] & 0x0F) | 0x30; + // Set variant to RFC 4122 (byte 8, high 2 bits = 10) + hash[8] = (hash[8] & 0x3F) | 0x80; + + // Convert to hex string + char hex[33]; + for (int i = 0; i < 16; i++) + snprintf(hex + i * 2, 3, "%02x", hash[i]); + hex[32] = '\0'; + + return DashUuid(std::string(hex, 32)); +} + +static uint8_t HexNibble(char c) { + if (c >= '0' && c <= '9') return (uint8_t)(c - '0'); + if (c >= 'a' && c <= 'f') return (uint8_t)(c - 'a' + 10); + if (c >= 'A' && c <= 'F') return (uint8_t)(c - 'A' + 10); + return 0; +} + +Uuid128 ParseUuid128(const std::string& dashed) { + std::string hex = UndashUuid(dashed); + if (hex.size() != 32) return {}; + + Uuid128 result; + result.hi = 0; + result.lo = 0; + for (int i = 0; i < 16; i++) { + uint8_t byte = (HexNibble(hex[i * 2]) << 4) | HexNibble(hex[i * 2 + 1]); + if (i < 8) + result.hi = (result.hi << 8) | byte; + else + result.lo = (result.lo << 8) | byte; + } + return result; +} + +// Classify an HTTP status code into an AuthErrorCode +static AuthErrorCode ClassifyHttpStatus(int status) { + if (status == 401 || status == 403) return AuthErrorCode::InvalidCredentials; + if (status == 429) return AuthErrorCode::RateLimited; + if (status >= 500 && status < 600) return AuthErrorCode::ServerUnavailable; + return AuthErrorCode::HttpError; +} + +static bool JoinServerImpl(const std::string& url, + const std::string& accessToken, + const std::string& undashedUuid, + const std::string& serverId, + const std::string& errorPrefix, + std::string& error) +{ + std::string body = "{\"accessToken\":\"" + JsonEscape(accessToken) + + "\",\"selectedProfile\":\"" + JsonEscape(undashedUuid) + + "\",\"serverId\":\"" + JsonEscape(serverId) + "\"}"; + + try { + auto resp = HttpPost(url, body, "application/json"); + + if (resp.statusCode == 204 || resp.statusCode == 200) + return true; + + error = errorPrefix + " HTTP " + std::to_string(resp.statusCode); + if (!resp.body.empty()) { + std::string msg = JsonGetString(resp.body, "errorMessage"); + if (!msg.empty()) error += ": " + msg; + else error += " body: " + resp.body.substr(0, 200); + } + } catch (const std::exception& e) { + error = errorPrefix + " network error: " + e.what(); + } + return false; +} + +bool JoinServer(const std::string& accessToken, + const std::string& undashedUuid, + const std::string& serverId, + std::string& error) +{ + return JoinServerImpl( + "https://sessionserver.mojang.com/session/minecraft/join", + accessToken, undashedUuid, serverId, "JoinServer", error); +} + +// Extract texture URLs from HasJoined response body. +// The "properties" array contains a "textures" entry whose value is base64-encoded JSON. +static void ParseTextureProperties(const std::string& body, std::string& skinUrl, std::string& capeUrl) { + // Find the "properties" array, then find the entry with name "textures" + size_t propsPos = body.find("\"properties\""); + if (propsPos == std::string::npos) return; + + // Find "textures" name entry + size_t texNamePos = body.find("\"textures\"", propsPos); + if (texNamePos == std::string::npos) return; + + // Find the "value" field after "textures" + std::string b64Value = JsonGetString(body.substr(texNamePos), "value"); + if (b64Value.empty()) return; + + std::string decoded = Base64DecodeStr(b64Value); + if (decoded.empty()) return; + + // Parse the decoded JSON for SKIN and CAPE urls + // Structure: {"textures":{"SKIN":{"url":"...","metadata":{...}},"CAPE":{"url":"..."}}} + // Use JsonRawValue for proper brace-depth tracking (SKIN may contain nested "metadata") + std::string skinObj = JsonRawValue(decoded, "SKIN"); + if (!skinObj.empty()) + skinUrl = JsonGetString(skinObj, "url"); + + std::string capeObj = JsonRawValue(decoded, "CAPE"); + if (!capeObj.empty()) + capeUrl = JsonGetString(capeObj, "url"); +} + +static HasJoinedResult HasJoinedImpl(const std::string& baseUrl, + const std::string& username, + const std::string& serverId, + const std::string& errorPrefix, + std::string& error) +{ + std::string url = baseUrl + "?username=" + + UrlEncode(username) + "&serverId=" + UrlEncode(serverId); + + HasJoinedResult result; + + try { + auto resp = HttpGet(url); + + if (resp.statusCode == 200 && !resp.body.empty()) { + result.success = true; + result.uuid = JsonGetString(resp.body, "id"); + result.username = JsonGetString(resp.body, "name"); + ParseTextureProperties(resp.body, result.skinUrl, result.capeUrl); + return result; + } + + result.success = false; + if (resp.statusCode == 204) { + error = "Player has not joined (session not found)"; + result.error = { AuthErrorCode::InvalidCredentials, error, 204 }; + } else { + error = errorPrefix + " HTTP " + std::to_string(resp.statusCode); + result.error = { ClassifyHttpStatus(resp.statusCode), error, resp.statusCode }; + } + } catch (const std::exception& e) { + error = errorPrefix + " network error: " + e.what(); + result.success = false; + result.error = { AuthErrorCode::NetworkError, error, 0 }; + } + return result; +} + +HasJoinedResult HasJoined(const std::string& username, + const std::string& serverId, + std::string& error) +{ + return HasJoinedImpl( + "https://sessionserver.mojang.com/session/minecraft/hasJoined", + username, serverId, "HasJoined", error); +} + +// CropSkinTo64x32 — convert 64x64 Java Edition skin to 64x32 LCE format. +// Uses WIC for PNG decode/encode. Returns original data unchanged if not 64x64. +static std::vector CropSkinTo64x32(const std::vector& pngData) { + // Guard against exceptions in WIC/COM — this runs in a detached thread + // (PendingConnection auth verification) where unhandled exceptions crash the process. + try { + HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED); + bool needUninit = SUCCEEDED(hr); + + IWICImagingFactory* factory = nullptr; + IWICStream* stream = nullptr; + IWICBitmapDecoder* decoder = nullptr; + IWICBitmapFrameDecode*frame = nullptr; + IWICFormatConverter* converter = nullptr; + IWICStream* outStream = nullptr; + IStream* memStream = nullptr; + IWICBitmapEncoder* encoder = nullptr; + IWICBitmapFrameEncode*outFrame = nullptr; + + // Lambda-based cleanup — captures pointers by reference so it always + // releases whatever was allocated up to the point of the call. + auto cleanup = [&]() { + if (outFrame) outFrame->Release(); + if (encoder) encoder->Release(); + if (outStream) outStream->Release(); + if (memStream) memStream->Release(); + if (converter) converter->Release(); + if (frame) frame->Release(); + if (decoder) decoder->Release(); + if (stream) stream->Release(); + if (factory) factory->Release(); + if (needUninit) CoUninitialize(); + }; + + hr = CoCreateInstance(CLSID_WICImagingFactory, nullptr, CLSCTX_INPROC_SERVER, + IID_PPV_ARGS(&factory)); + if (FAILED(hr)) { cleanup(); return pngData; } + + // Macro for concise HRESULT checking — on failure, clean up and return + // the original PNG (graceful fallback: skin displayed uncropped). + #define WIC_CHECK(expr) do { hr = (expr); if (FAILED(hr)) { cleanup(); return pngData; } } while(0) + + // Decode the PNG from memory + WIC_CHECK(factory->CreateStream(&stream)); + WIC_CHECK(stream->InitializeFromMemory((BYTE*)pngData.data(), (DWORD)pngData.size())); + + WIC_CHECK(factory->CreateDecoderFromStream(stream, nullptr, WICDecodeMetadataCacheOnDemand, &decoder)); + + WIC_CHECK(decoder->GetFrame(0, &frame)); + + UINT width = 0, height = 0; + WIC_CHECK(frame->GetSize(&width, &height)); + + // Only crop if the skin is 64x64 (Java Edition format) + if (width != 64 || height != 64) { cleanup(); return pngData; } + + // Convert to 32bpp BGRA + WIC_CHECK(factory->CreateFormatConverter(&converter)); + WIC_CHECK(converter->Initialize(frame, GUID_WICPixelFormat32bppBGRA, + WICBitmapDitherTypeNone, nullptr, 0.0, WICBitmapPaletteTypeCustom)); + + // Copy the top 32 rows (64x32 crop) + const UINT cropW = 64, cropH = 32; + const UINT stride = cropW * 4; + std::vector pixels(stride * cropH); + + WICRect cropRect = { 0, 0, (INT)cropW, (INT)cropH }; + WIC_CHECK(converter->CopyPixels(&cropRect, stride, (UINT)pixels.size(), pixels.data())); + + // Encode the cropped image back to PNG + WIC_CHECK(factory->CreateStream(&outStream)); + hr = CreateStreamOnHGlobal(nullptr, TRUE, &memStream); + if (FAILED(hr)) { cleanup(); return pngData; } + WIC_CHECK(outStream->InitializeFromIStream(memStream)); + + WIC_CHECK(factory->CreateEncoder(GUID_ContainerFormatPng, nullptr, &encoder)); + WIC_CHECK(encoder->Initialize(outStream, WICBitmapEncoderNoCache)); + + WIC_CHECK(encoder->CreateNewFrame(&outFrame, nullptr)); + WIC_CHECK(outFrame->Initialize(nullptr)); + WIC_CHECK(outFrame->SetSize(cropW, cropH)); + + WICPixelFormatGUID pixFmt = GUID_WICPixelFormat32bppBGRA; + WIC_CHECK(outFrame->SetPixelFormat(&pixFmt)); + WIC_CHECK(outFrame->WritePixels(cropH, stride, (UINT)pixels.size(), pixels.data())); + WIC_CHECK(outFrame->Commit()); + WIC_CHECK(encoder->Commit()); + + // Read the encoded PNG from the IStream + STATSTG stat = {}; + WIC_CHECK(memStream->Stat(&stat, STATFLAG_NONAME)); + ULONG pngSize = (ULONG)stat.cbSize.QuadPart; + + #undef WIC_CHECK + + std::vector result(pngSize); + LARGE_INTEGER zero = {}; + memStream->Seek(zero, STREAM_SEEK_SET, nullptr); + memStream->Read(result.data(), pngSize, nullptr); + + cleanup(); + return result; + + } catch (...) { + // WIC/COM failure — return original data rather than crashing the detached thread + return pngData; + } +} + +bool ValidateSkinPng(const uint8_t* data, size_t size) { + // PNG magic: 89 50 4E 47 0D 0A 1A 0A + static const uint8_t kPngMagic[8] = { 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }; + + if (data == nullptr || size < 24) // PNG header + IHDR minimum + return false; + if (size > kMaxSkinBytes) + return false; + if (memcmp(data, kPngMagic, 8) != 0) + return false; + + // Read IHDR dimensions (bytes 16-23 in a PNG: 4 bytes width + 4 bytes height, big-endian) + uint32_t width = ((uint32_t)data[16] << 24) | ((uint32_t)data[17] << 16) | + ((uint32_t)data[18] << 8) | (uint32_t)data[19]; + uint32_t height = ((uint32_t)data[20] << 24) | ((uint32_t)data[21] << 16) | + ((uint32_t)data[22] << 8) | (uint32_t)data[23]; + + // Minecraft skins are 64x32 (legacy) or 64x64 (modern) + if (width != 64) + return false; + if (height != 32 && height != 64) + return false; + + return true; +} + +std::vector FetchSkinPng(const std::string& url, std::string& error) { + if (url.empty()) { + error = "Empty skin URL"; + return {}; + } + + try { + auto resp = HttpGet(url); + if (resp.statusCode == 200 && !resp.body.empty()) { + auto rawPng = std::vector(resp.body.begin(), resp.body.end()); + // Validate before processing — reject non-PNG or wrong dimensions + if (!ValidateSkinPng(rawPng.data(), rawPng.size())) { + error = "FetchSkinPng: invalid PNG data (" + std::to_string(rawPng.size()) + " bytes)"; + return {}; + } + // Convert 64x64 Java skin to 64x32 LCE format + return CropSkinTo64x32(rawPng); + } + error = "FetchSkinPng HTTP " + std::to_string(resp.statusCode); + } catch (const std::exception& e) { + error = std::string("FetchSkinPng exception: ") + e.what(); + } + return {}; +} + +std::vector FetchSkinPngRaw(const std::string& url, std::string& error) { + if (url.empty()) { + error = "Empty skin URL"; + return {}; + } + + try { + auto resp = HttpGet(url); + if (resp.statusCode == 200 && !resp.body.empty()) { + auto rawPng = std::vector(resp.body.begin(), resp.body.end()); + if (!ValidateSkinPng(rawPng.data(), rawPng.size())) { + error = "FetchSkinPngRaw: invalid PNG data"; + return {}; + } + return rawPng; // Return original RGBA PNG — game's LoadTextureData handles format + } + error = "FetchSkinPngRaw HTTP " + std::to_string(resp.statusCode); + } catch (const std::exception& e) { + error = std::string("FetchSkinPngRaw exception: ") + e.what(); + } + return {}; +} + +static std::string FetchProfileSkinUrlImpl(const std::string& baseUrl, + const std::string& uuid, + const std::string& errorPrefix, + const std::string& noSkinMsg, + std::string& error) +{ + std::string undashed = UndashUuid(uuid); + if (undashed.empty()) { + error = "Empty UUID"; + return ""; + } + + std::string url = baseUrl + undashed; + + try { + auto resp = HttpGet(url); + if (resp.statusCode != 200 || resp.body.empty()) { + error = errorPrefix + " HTTP " + std::to_string(resp.statusCode); + return ""; + } + + std::string skinUrl, capeUrl; + ParseTextureProperties(resp.body, skinUrl, capeUrl); + if (skinUrl.empty()) + error = noSkinMsg; + return skinUrl; + } catch (const std::exception& e) { + error = errorPrefix + " exception: " + e.what(); + return ""; + } +} + +std::string FetchProfileSkinUrl(const std::string& uuid, std::string& error) { + return FetchProfileSkinUrlImpl( + "https://sessionserver.mojang.com/session/minecraft/profile/", + uuid, "Profile", "No skin in profile", error); +} + +// Ely.by session functions — same Yggdrasil protocol, different base URLs + +std::string MakeElybySkinKey(const std::string& uuid) { + return "elyby_skin_" + UndashUuid(uuid) + ".png"; +} + +bool ElybyJoinServer(const std::string& accessToken, + const std::string& undashedUuid, + const std::string& serverId, + std::string& error) +{ + return JoinServerImpl( + "https://authserver.ely.by/session/join", + accessToken, undashedUuid, serverId, "ElybyJoinServer", error); +} + +HasJoinedResult ElybyHasJoined(const std::string& username, + const std::string& serverId, + std::string& error) +{ + return HasJoinedImpl( + "https://authserver.ely.by/session/hasJoined", + username, serverId, "ElybyHasJoined", error); +} + +std::string ElybyFetchProfileSkinUrl(const std::string& uuid, std::string& error) { + return FetchProfileSkinUrlImpl( + "https://authserver.ely.by/session/profile/", + uuid, "ElybyProfile", "No skin in ely.by profile", error); +} + +} // namespace MCAuth diff --git a/Minecraft.Client/CMakeLists.txt b/Minecraft.Client/CMakeLists.txt index 9f75efd219..9e97dbafa9 100644 --- a/Minecraft.Client/CMakeLists.txt +++ b/Minecraft.Client/CMakeLists.txt @@ -51,6 +51,7 @@ set_target_properties(Minecraft.Client PROPERTIES target_link_libraries(Minecraft.Client PRIVATE Minecraft.World + MCAuth d3d11 d3dcompiler XInput9_1_0 diff --git a/Minecraft.Client/ClientConnection.cpp b/Minecraft.Client/ClientConnection.cpp index 325e949bbf..eb7b2d97ce 100644 --- a/Minecraft.Client/ClientConnection.cpp +++ b/Minecraft.Client/ClientConnection.cpp @@ -28,6 +28,11 @@ #include "..\Minecraft.World\net.minecraft.world.level.tile.h" #include "..\Minecraft.World\net.minecraft.world.inventory.h" #include "..\Minecraft.World\net.minecraft.world.h" +#ifdef _WINDOWS64 +#include "..\..\MCAuth\include\MCAuth.h" +#include "..\..\MCAuth\include\MCAuthManager.h" +#include "..\Minecraft.World\GameUUID.h" +#endif #include "..\Minecraft.World\net.minecraft.world.level.saveddata.h" #include "..\Minecraft.World\net.minecraft.world.level.dimension.h" #include "..\Minecraft.World\net.minecraft.world.effect.h" @@ -365,7 +370,14 @@ void ClientConnection::handleLogin(shared_ptr packet) } minecraft->player->setPlayerIndex( packet->m_playerIndex ); - minecraft->player->setCustomSkin( app.GetPlayerSkinId(m_userIndex) ); + if (!m_mojangSkinUrl.empty()) + { + minecraft->player->customTextureUrl = m_mojangSkinUrl; + } + else + { + minecraft->player->setCustomSkin( app.GetPlayerSkinId(m_userIndex) ); + } minecraft->player->setCustomCape( app.GetPlayerCapeId(m_userIndex) ); @@ -441,7 +453,14 @@ void ClientConnection::handleLogin(shared_ptr packet) player->entityId = packet->clientVersion; player->setPlayerIndex( packet->m_playerIndex ); - player->setCustomSkin( app.GetPlayerSkinId(m_userIndex) ); + if (!m_mojangSkinUrl.empty()) + { + player->customTextureUrl = m_mojangSkinUrl; + } + else + { + player->setCustomSkin( app.GetPlayerSkinId(m_userIndex) ); + } player->setCustomCape( app.GetPlayerCapeId(m_userIndex) ); @@ -840,22 +859,42 @@ void ClientConnection::handleAddPlayer(shared_ptr packet) return; } } -#endif -/*#ifdef _WINDOWS64 - // On Windows64 all XUIDs are INVALID_XUID so the XUID check above never fires. - // packet->m_playerIndex is the server-assigned sequential index (set via LoginPacket), - // NOT the controller slot — so we must scan all local player slots and match by - // their stored server index rather than using it directly as an array subscript. - for(unsigned int idx = 0; idx < XUSER_MAX_COUNT; ++idx) + + // Additional check: compare against MCAuth session UUIDs for all slots. + // This catches the case where the AddPlayerPacket arrives BEFORE the local player + // entity is created (race condition during splitscreen join), preventing ghost entities. { - if(minecraft->localplayers[idx] != nullptr && - minecraft->localplayers[idx]->getPlayerIndex() == packet->m_playerIndex) + auto& mgr = MCAuthManager::Get(); + for (int slot = 0; slot < XUSER_MAX_COUNT; ++slot) { - app.DebugPrintf("AddPlayerPacket received for local player (controller %d, server index %d), skipping RemotePlayer creation\n", idx, packet->m_playerIndex); - return; + if (!mgr.IsSlotLoggedIn(slot)) continue; + auto session = mgr.GetSlotSession(slot); + if (session.uuid.empty()) continue; + PlayerUID authXuid = GameUUID::fromDashed(session.uuid); + if (authXuid != INVALID_XUID && authXuid == packet->xuid) + { + app.DebugPrintf("AddPlayerPacket for local auth slot %d ('%s'), skipping RemotePlayer creation\n", + slot, session.username.c_str()); + return; + } } } -#endif*/ + + // Also check by local player entity XUID (set during createExtraLocalPlayer) + for (unsigned int idx = 0; idx < XUSER_MAX_COUNT; ++idx) + { + if (minecraft->localplayers[idx] != nullptr) + { + PlayerUID localXuid = minecraft->localplayers[idx]->getXuid(); + if (localXuid != INVALID_XUID && localXuid == packet->xuid) + { + app.DebugPrintf("AddPlayerPacket matched local player %ls by XUID, skipping\n", + minecraft->localplayers[idx]->name.c_str()); + return; + } + } + } +#endif double x = packet->x / 32.0; double y = packet->y / 32.0; @@ -884,21 +923,8 @@ void ClientConnection::handleAddPlayer(shared_ptr packet) { IQNetPlayer* matchedQNetPlayer = nullptr; PlayerUID pktXuid = player->getXuid(); - const PlayerUID WIN64_XUID_BASE = (PlayerUID)0xe000d45248242f2e; - // Legacy compatibility path for peers still using embedded smallId XUIDs. - if (pktXuid >= WIN64_XUID_BASE && pktXuid < WIN64_XUID_BASE + MINECRAFT_NET_MAX_PLAYERS) - { - BYTE smallId = (BYTE)(pktXuid - WIN64_XUID_BASE); - INetworkPlayer* np = g_NetworkManager.GetPlayerBySmallId(smallId); - if (np != nullptr) - { - NetworkPlayerXbox* npx = (NetworkPlayerXbox*)np; - matchedQNetPlayer = npx->GetQNetPlayer(); - } - } - // Current Win64 path: identify QNet player by name and attach packet XUID. - if (matchedQNetPlayer == nullptr) + // Identify QNet player by name and attach packet XUID. { for (int i = 0; i < MINECRAFT_NET_MAX_PLAYERS; ++i) { @@ -919,8 +945,7 @@ void ClientConnection::handleAddPlayer(shared_ptr packet) if (matchedQNetPlayer != nullptr) { - // Store packet-authoritative XUID on this network slot so later lookups by XUID - // (e.g. remove player, display mapping) work for both legacy and uid.dat clients. + // Store packet-authoritative UUID on this network slot so later lookups work. matchedQNetPlayer->m_resolvedXuid = pktXuid; if (matchedQNetPlayer->m_gamertag[0] == 0) { @@ -997,6 +1022,13 @@ void ClientConnection::handleAddPlayer(shared_ptr packet) player->getEntityData()->assignValues(unpackedData); } + // Retry any SetEntityLinkPackets that were waiting for this player to be added. + // Critical for splitscreen: when player 2 joins, the server may broadcast a + // SetEntityLinkPacket for player 1 (e.g. riding a horse) before player 2's + // connection has received the AddPlayerPacket for player 1. Without this call, + // the deferred packet would never be resolved and the riding state would be lost + // (the original code only called this from handleAddEntity, not handleAddPlayer). + checkDeferredEntityLinkPackets(packet->id); } void ClientConnection::handleTeleportEntity(shared_ptr packet) @@ -1403,6 +1435,7 @@ void ClientConnection::handleTileUpdate(shared_ptr packet) void ClientConnection::handleDisconnect(shared_ptr packet) { + app.DebugPrintf("[Auth-Client] Received DisconnectPacket: reason=%d\n", (int)packet->reason); connection->close(DisconnectPacket::eDisconnect_Kicked); done = true; @@ -1418,6 +1451,7 @@ void ClientConnection::handleDisconnect(shared_ptr packet) void ClientConnection::onDisconnect(DisconnectPacket::eDisconnectReason reason, void *reasonObjects) { + app.DebugPrintf("[Auth-Client] onDisconnect called: reason=%d, done=%d\n", (int)reason, (int)done); if (done) return; done = true; @@ -2417,39 +2451,18 @@ void ClientConnection::handlePreLogin(shared_ptr packet) { Minecraft::GetInstance()->progressRenderer->progressStagePercentage((eCCPreLoginReceived * 100)/ (eCCConnected)); } - // need to use the XUID here - PlayerUID offlineXUID = INVALID_XUID; - PlayerUID onlineXUID = INVALID_XUID; - if( ProfileManager.IsSignedInLive(m_userIndex) ) - { - // Guest don't have an offline XUID as they cannot play offline, so use their online one - ProfileManager.GetXUID(m_userIndex,&onlineXUID,true); - } -#ifdef __PSVITA__ - if(CGameNetworkManager::usingAdhocMode() && onlineXUID.getOnlineID()[0] == 0) - { - // player doesn't have an online UID, set it from the player name - onlineXUID.setForAdhoc(); - } -#endif + // Cache ugcPlayersVersion for later LoginPacket + m_cachedUgcPlayersVersion = packet->m_ugcPlayersVersion; - // On PS3, all non-signed in players (even guests) can get a useful offlineXUID -#if !(defined __PS3__ || defined _DURANGO ) - if( !ProfileManager.IsGuest( m_userIndex ) ) -#endif - { - // All other players we use their offline XUID so that they can play the game offline - ProfileManager.GetXUID(m_userIndex,&offlineXUID,false); - } - BOOL allAllowed, friendsAllowed; - ProfileManager.AllowedPlayerCreatedContent(m_userIndex,true,&allAllowed,&friendsAllowed); - send(std::make_shared(minecraft->user->name, SharedConstants::NETWORK_PROTOCOL_VERSION, offlineXUID, onlineXUID, (allAllowed != TRUE && friendsAllowed == TRUE), - packet->m_ugcPlayersVersion, app.GetPlayerSkinId(m_userIndex), app.GetPlayerCapeId(m_userIndex), ProfileManager.IsGuest(m_userIndex))); - - if(!g_NetworkManager.IsHost() ) + // If auth already completed (e.g., UGC version mismatch re-send from server), + // re-send LoginPacket immediately instead of waiting for AuthSchemePacket. + if (!m_assignedUuid.empty()) { - Minecraft::GetInstance()->progressRenderer->progressStagePercentage((eCCLoginSent * 100)/ (eCCConnected)); + app.DebugPrintf("[Auth-Client] Auth already completed, re-sending LoginPacket (UGC resync)\n"); + sendLoginPacketAfterAuth(); + return; } + // LoginPacket sent after auth completes in sendLoginPacketAfterAuth() } #else // 4J - removed @@ -2486,6 +2499,261 @@ void ClientConnection::close() connection->close(DisconnectPacket::eDisconnect_Closed); } +void ClientConnection::disconnectWithReason(DisconnectPacket::eDisconnectReason reason) +{ + if (done) return; + connection->close(reason); + done = true; + + Minecraft *pMinecraft = Minecraft::GetInstance(); + pMinecraft->connectionDisconnected(m_userIndex, reason); + app.SetDisconnectReason(reason); + app.SetAction(m_userIndex, eAppAction_ExitWorld, (void *)TRUE); +} + +void ClientConnection::handleAuthScheme(shared_ptr packet) +{ +#ifdef _WINDOWS64 + auto& mgr = MCAuthManager::Get(); + + // Safety net: primary gate is in StartGameFromSave; this 10s wait should rarely trigger + if (mgr.GetSlotState(m_userIndex) == MCAuthManager::State::Authenticating) + { + app.DebugPrintf("[Auth-Client] Token refresh still in progress, waiting (max 10s)...\n"); + mgr.WaitForSlotReady(m_userIndex, 10000); + app.DebugPrintf("[Auth-Client] Auth settled, state=%d\n", (int)mgr.GetSlotState(m_userIndex)); + } + + auto session = mgr.GetSlotSession(m_userIndex); + bool isLoggedIn = mgr.IsSlotLoggedIn(m_userIndex); + bool hasToken = !session.accessToken.empty(); + bool tokenExpired = mgr.IsTokenExpiringSoon(m_userIndex); + bool hasOnlineAccount = isLoggedIn && hasToken && !tokenExpired; + + string serverId(packet->serverId.begin(), packet->serverId.end()); + + app.DebugPrintf("[Auth-Client] Received AuthSchemePacket: serverId='%s'\n", serverId.c_str()); + app.DebugPrintf("[Auth-Client] Session: username='%s', uuid='%s'\n", + session.username.c_str(), session.uuid.c_str()); + + bool serverHasMojang = false, serverHasOffline = false, serverHasElyby = false; + for (auto& s : packet->schemes) + { + if (s == L"mojang") serverHasMojang = true; + if (s == L"offline") serverHasOffline = true; + if (s == L"elyby") serverHasElyby = true; + } + + // Determine account's auth provider + std::string provider = "mojang"; + { + int acctIdx = mgr.GetSlot(m_userIndex).accountIndex.load(); + if (acctIdx >= 0) { + auto accounts = mgr.GetJavaAccounts(); + if (acctIdx < (int)accounts.size()) + provider = accounts[acctIdx].authProvider; + } + } + + app.DebugPrintf("[Auth-Client] Server offers: mojang=%d, offline=%d, elyby=%d (account provider=%s)\n", + (int)serverHasMojang, (int)serverHasOffline, (int)serverHasElyby, provider.c_str()); + + // Block connection if no account is configured at all (empty username/uuid). + // The player should sign in or create an offline account first. + if (session.username.empty() || session.uuid.empty()) + { + app.DebugPrintf("[Auth-Client] REJECTED: No account configured (username/uuid empty). Player must sign in first.\n"); + disconnectWithReason(DisconnectPacket::eDisconnect_AuthFailed); + return; + } + + wstring wUuid(session.uuid.begin(), session.uuid.end()); + wstring wName(session.username.begin(), session.username.end()); + + if (hasOnlineAccount && provider == "mojang" && serverHasMojang) + { + app.DebugPrintf("[Auth-Client] Choosing 'mojang' auth scheme\n"); + string token = session.accessToken; + if (token.size() > 7 && token.substr(0, 7) == "Bearer ") token = token.substr(7); + string uuid = MCAuth::UndashUuid(session.uuid); + + app.DebugPrintf("[Auth-Client] Calling JoinServer for uuid='%s'...\n", uuid.c_str()); + string error; + bool ok = MCAuth::JoinServer(token, uuid, serverId, error); + if (!ok) + { + app.DebugPrintf("[Auth-Client] JoinServer FAILED: %s\n", error.c_str()); + disconnectWithReason(DisconnectPacket::eDisconnect_AuthFailed); + return; + } + app.DebugPrintf("[Auth-Client] JoinServer succeeded, sending AuthResponse(mojang)\n"); + + send(make_shared(L"mojang", wUuid, wName)); + } + else if (hasOnlineAccount && provider == "elyby" && serverHasElyby) + { + app.DebugPrintf("[Auth-Client] Choosing 'elyby' auth scheme\n"); + string token = session.accessToken; + string uuid = MCAuth::UndashUuid(session.uuid); + + string error; + bool ok = MCAuth::ElybyJoinServer(token, uuid, serverId, error); + if (!ok) + { + app.DebugPrintf("[Auth-Client] ElybyJoinServer FAILED: %s\n", error.c_str()); + disconnectWithReason(DisconnectPacket::eDisconnect_AuthFailed); + return; + } + app.DebugPrintf("[Auth-Client] ElybyJoinServer succeeded, sending AuthResponse(elyby)\n"); + + send(make_shared(L"elyby", wUuid, wName)); + } + else if (serverHasOffline) + { + app.DebugPrintf("[Auth-Client] Choosing 'offline' auth scheme\n"); + send(make_shared(L"offline", wUuid, wName)); + } + else + { + app.DebugPrintf("[Auth-Client] No compatible auth scheme. Your account uses '%s' but the server requires%s%s%s. Switch account or ask the server admin to enable your provider.\n", + provider.c_str(), + serverHasMojang ? " mojang" : "", + serverHasElyby ? " elyby" : "", + serverHasOffline ? " offline" : ""); + disconnectWithReason(DisconnectPacket::eDisconnect_AuthFailed); + return; + } +#else + // Non-Windows64 platforms: MCAuth not available, try offline scheme only + bool serverHasOffline = false; + for (auto& s : packet->schemes) + { + if (s == L"offline") serverHasOffline = true; + } + + if (serverHasOffline) + { + wstring wName = minecraft->user->name; + send(make_shared(L"offline", L"", wName)); + } + else + { + disconnectWithReason(DisconnectPacket::eDisconnect_AuthFailed); + return; + } +#endif +} + + +void ClientConnection::handleAuthResult(shared_ptr packet) +{ + app.DebugPrintf("[Auth-Client] Received AuthResultPacket: success=%d\n", (int)packet->success); + + if (!packet->success) + { + string err(packet->errorMessage.begin(), packet->errorMessage.end()); + app.DebugPrintf("[Auth-Client] Auth REJECTED by server: '%s'\n", err.c_str()); + disconnectWithReason(DisconnectPacket::eDisconnect_AuthFailed); + return; + } + + m_assignedUuid = string(packet->assignedUuid.begin(), packet->assignedUuid.end()); + m_assignedUsername = string(packet->assignedUsername.begin(), packet->assignedUsername.end()); + app.DebugPrintf("[Auth-Client] Auth SUCCESS: assigned username='%s', uuid='%s'\n", + m_assignedUsername.c_str(), m_assignedUuid.c_str()); + + // Update the IQNet gamertag for THIS connection's slot so the TAB player list + // shows the auth-verified name. Each slot writes to its OWN m_player entry. + // user->name is only updated for the primary player (slot 0) since it's a + // shared global — splitscreen players must not clobber it. + if (!m_assignedUsername.empty()) + { + wstring wName(m_assignedUsername.begin(), m_assignedUsername.end()); + if (m_userIndex < MINECRAFT_NET_MAX_PLAYERS) + wcsncpy_s(IQNet::m_player[m_userIndex].m_gamertag, 32, wName.c_str(), _TRUNCATE); + if (m_userIndex == 0) + minecraft->user->name = wName; + } + +#ifdef _WINDOWS64 + // Store the Mojang skin received inline from the server (no separate download needed) + if (!packet->skinKey.empty() && !packet->skinData.empty() && + MCAuth::ValidateSkinPng(packet->skinData.data(), packet->skinData.size())) + { + m_mojangSkinUrl = packet->skinKey; + if (m_userIndex < XUSER_MAX_COUNT) + app.m_mojangSkinKey[m_userIndex] = m_mojangSkinUrl; + + DWORD skinSize = (DWORD)packet->skinData.size(); + PBYTE skinBuf = new BYTE[skinSize]; + memcpy(skinBuf, packet->skinData.data(), skinSize); + app.AddMemoryTextureFile(m_mojangSkinUrl, skinBuf, skinSize); + app.DebugPrintf("Client received Mojang skin inline: %zu bytes\n", packet->skinData.size()); + } + else if (!packet->skinData.empty()) + { + app.DebugPrintf("[Auth-Client] Rejected invalid skin data (%zu bytes)\n", packet->skinData.size()); + } +#endif + + // Send LoginPacket immediately — it serves as the auth handshake acknowledgement + sendLoginPacketAfterAuth(); +} + +void ClientConnection::sendLoginPacketAfterAuth() +{ + // Priority: auth-assigned > MCAuth session > user->name (shared global, always player 1 in splitscreen) + wstring loginName; + if (!m_assignedUsername.empty()) + { + loginName = wstring(m_assignedUsername.begin(), m_assignedUsername.end()); + } +#ifdef _WINDOWS64 + else + { + auto& mgr = MCAuthManager::Get(); + if (mgr.IsSlotLoggedIn(m_userIndex)) + { + auto session = mgr.GetSlotSession(m_userIndex); + if (!session.username.empty()) + loginName = wstring(session.username.begin(), session.username.end()); + } + } +#endif + if (loginName.empty()) + { + loginName = minecraft->user->name; + } + + PlayerUID loginUuid = INVALID_XUID; + if (!m_assignedUuid.empty()) + { + loginUuid = GameUUID::fromDashed(m_assignedUuid); + } + if (!loginUuid.isValid()) + { + loginUuid = GameUUID::generateOffline(std::string(loginName.begin(), loginName.end())); + } + + BOOL allAllowed, friendsAllowed; + ProfileManager.AllowedPlayerCreatedContent(m_userIndex,true,&allAllowed,&friendsAllowed); + + auto loginPacket = std::make_shared(loginName, SharedConstants::NETWORK_PROTOCOL_VERSION, loginUuid, (allAllowed != TRUE && friendsAllowed == TRUE), + m_cachedUgcPlayersVersion, app.GetPlayerSkinId(m_userIndex), app.GetPlayerCapeId(m_userIndex), ProfileManager.IsGuest(m_userIndex)); + + if (!m_assignedUuid.empty()) + { + loginPacket->m_mojangUuid = wstring(m_assignedUuid.begin(), m_assignedUuid.end()); + } + + send(loginPacket); + + if(!g_NetworkManager.IsHost() ) + { + Minecraft::GetInstance()->progressRenderer->progressStagePercentage((eCCLoginSent * 100)/ (eCCConnected)); + } +} + void ClientConnection::handleAddMob(shared_ptr packet) { double x = packet->x / 32.0; @@ -2536,6 +2804,12 @@ void ClientConnection::handleAddMob(shared_ptr packet) shared_ptr slime = dynamic_pointer_cast(mob); slime->setSize( slime->getSize() ); } + + // Retry any SetEntityLinkPackets that were waiting for this mob to be added. + // Without this, a deferred link where this mob is the source or dest would + // never be resolved (the original code only called this from handleAddEntity, + // missing mobs added via AddMobPacket). + checkDeferredEntityLinkPackets(packet->id); } void ClientConnection::handleSetTime(shared_ptr packet) @@ -2557,13 +2831,31 @@ void ClientConnection::handleEntityLinkPacket(shared_ptr pa shared_ptr sourceEntity = getEntity(packet->sourceId); shared_ptr destEntity = getEntity(packet->destId); - // 4J: If the destination entity couldn't be found, defer handling of this packet - // This was added to support leashing (the entity link packet is sent before the add entity packet) - if (destEntity == nullptr && packet->destId >= 0) + // 4J: If either entity couldn't be found, defer handling of this packet. + // + // With real TCP splitscreen connections, the server's EntityTracker can send + // a SetEntityLinkPacket (e.g. villager riding a boat, player on a horse) + // BEFORE the AddEntityPacket/AddMobPacket/AddPlayerPacket for one of the + // linked entities has been received by this connection. This happens because: + // - TrackedEntity::tick() broadcasts riding state every 3 seconds to all + // connections currently tracking the entity. + // - TrackedEntity::updatePlayer() sends AddEntity then SetEntityLink, but + // processes entities in arbitrary order, so entity A's link to entity B + // can arrive before entity B's AddEntity. + // - A dead splitscreen player's connection may have stale entity tracking + // state, causing gaps when entity updates resume. + // + // Original 4J code only deferred when destEntity was missing (for leashing). + // Extended to also defer when sourceEntity is missing, since the same race + // occurs for the source (observed crash during splitscreen with a dead player + // and AFK player in a village — villager/mob entity link arrived before the + // source entity was added to this connection's world). + // + // The deferred packet is retried when the missing entity arrives + // (see checkDeferredEntityLinkPackets), or dropped after 1000ms timeout. + if ((destEntity == nullptr && packet->destId >= 0) || + (sourceEntity == nullptr && packet->sourceId >= 0)) { - // We don't handle missing source entities because it shouldn't happen - assert(!(sourceEntity == nullptr && packet->sourceId >= 0)); - deferredEntityLinkPackets.push_back(DeferredEntityLinkPacket(packet)); return; } @@ -2728,6 +3020,16 @@ void ClientConnection::handleTextureAndGeometry(shared_ptrtextureName.c_str()); #endif + // Validate mojang skin PNGs before loading into memory + bool isMojangSkin = (packet->textureName.length() > 6 && + packet->textureName.substr(0, 6) == L"mojang"); + if (isMojangSkin && !MCAuth::ValidateSkinPng(packet->pbData, packet->dwTextureBytes)) + { + app.DebugPrintf("Rejected invalid mojang skin texture %ls (%u bytes)\n", + packet->textureName.c_str(), packet->dwTextureBytes); + return; + } + // Add the texture data app.AddMemoryTextureFile(packet->textureName,packet->pbData,packet->dwTextureBytes); // Add the geometry data @@ -2824,6 +3126,12 @@ void ClientConnection::handleTextureAndGeometryChange(shared_ptrsetCustomSkin( app.getSkinIdFromPath( packet->path ) ); + // Override customTextureUrl for Mojang skins (setCustomSkin resolves to a DLC path) + if (!packet->path.empty() && packet->path.substr(0, 3).compare(L"def") != 0) + { + player->customTextureUrl = packet->path; + } + #ifndef _CONTENT_PACKAGE wprintf(L"Skin for remote player %ls has changed to %ls (%d)\n", player->name.c_str(), player->customTextureUrl.c_str(), player->getPlayerDefaultSkin() ); #endif @@ -4090,31 +4398,48 @@ void ClientConnection::handleUpdateAttributes(shared_ptr } } -// 4J: Check for deferred entity link packets related to this entity ID and handle them +// Called when a new entity is added to the world (from handleAddEntity, +// handleAddMob, or handleAddPlayer). Checks whether any previously deferred +// SetEntityLinkPackets were waiting for this entity and retries them. +// +// Original 4J code only matched on destId (the destination/mount entity). +// Extended to also match sourceId so that packets deferred because the +// *source* entity was missing (e.g. a player not yet added during splitscreen +// join) are also retried when that entity arrives. +// +// Snapshot vector size before iterating -- handleEntityLinkPacket may re-defer (push_back). +// Without the snapshot limit we would process the newly pushed entry in the +// same pass, match it again on the same newEntityId, and loop forever. +// Newly deferred entries will be picked up on the next entity arrival. void ClientConnection::checkDeferredEntityLinkPackets(int newEntityId) { if (deferredEntityLinkPackets.empty()) return; - for (size_t i = 0; i < deferredEntityLinkPackets.size(); i++) - { - DeferredEntityLinkPacket *deferred = &deferredEntityLinkPackets[i]; + size_t originalCount = deferredEntityLinkPackets.size(); + for (size_t i = 0; i < originalCount; i++) + { bool remove = false; - // Only consider recently deferred packets - int tickInterval = GetTickCount() - deferred->m_recievedTick; + // Only consider recently deferred packets (within 1000ms) + int tickInterval = GetTickCount() - deferredEntityLinkPackets[i].m_recievedTick; if (tickInterval < MAX_ENTITY_LINK_DEFERRAL_INTERVAL) { - // Note: we assume it's the destination entity - if (deferred->m_packet->destId == newEntityId) + // Match on both source and dest — either could be the newly arrived entity + shared_ptr pkt = deferredEntityLinkPackets[i].m_packet; + if (pkt->destId == newEntityId || pkt->sourceId == newEntityId) { - handleEntityLinkPacket(deferred->m_packet); + // Retry the packet. If the OTHER entity is still missing, + // handleEntityLinkPacket will re-defer it (appended past + // originalCount, so we won't re-process it in this pass). + handleEntityLinkPacket(pkt); remove = true; } } else { - // This is an old packet, remove (shouldn't really come up but seems prudent) + // Timed out — drop the packet. The entity link will be corrected + // by the server's periodic 3-second riding/leash broadcast. remove = true; } @@ -4122,6 +4447,7 @@ void ClientConnection::checkDeferredEntityLinkPackets(int newEntityId) { deferredEntityLinkPackets.erase(deferredEntityLinkPackets.begin() + i); i--; + originalCount--; // the range we're iterating over just shrunk } } } diff --git a/Minecraft.Client/ClientConnection.h b/Minecraft.Client/ClientConnection.h index 3448496d07..f4f636c743 100644 --- a/Minecraft.Client/ClientConnection.h +++ b/Minecraft.Client/ClientConnection.h @@ -101,6 +101,7 @@ class ClientConnection : public PacketListener virtual void handleEntityActionAtPosition(shared_ptr packet); virtual void handlePreLogin(shared_ptr packet); void close(); + void disconnectWithReason(DisconnectPacket::eDisconnectReason reason); virtual void handleAddMob(shared_ptr packet); virtual void handleSetTime(shared_ptr packet); virtual void handleSetSpawn(shared_ptr packet); @@ -155,6 +156,10 @@ class ClientConnection : public PacketListener virtual void handleUpdateGameRuleProgressPacket(shared_ptr packet); virtual void handleXZ(shared_ptr packet); + // Auth handshake + virtual void handleAuthScheme(shared_ptr packet); + virtual void handleAuthResult(shared_ptr packet); + void displayPrivilegeChanges(shared_ptr player, unsigned int oldPrivileges); virtual void handleAddObjective(shared_ptr packet); @@ -179,4 +184,11 @@ class ClientConnection : public PacketListener static const int MAX_ENTITY_LINK_DEFERRAL_INTERVAL = 1000; void checkDeferredEntityLinkPackets(int newEntityId); + + // Auth handshake state + std::string m_assignedUuid; // UUID assigned by server after auth + std::string m_assignedUsername; // username assigned by server + wstring m_mojangSkinUrl; // Mojang skin key from server (e.g. "mojang_skin_{uuid}.png") + DWORD m_cachedUgcPlayersVersion = 0; // stored from PreLoginPacket for later LoginPacket + void sendLoginPacketAfterAuth(); }; \ No newline at end of file diff --git a/Minecraft.Client/Common/Consoles_App.cpp b/Minecraft.Client/Common/Consoles_App.cpp index 0a2fd159a4..51773329ae 100644 --- a/Minecraft.Client/Common/Consoles_App.cpp +++ b/Minecraft.Client/Common/Consoles_App.cpp @@ -32,6 +32,9 @@ #include "..\Xbox\XML\xmlFilesCallback.h" #endif #include "Minecraft_Macros.h" +#ifdef _WINDOWS64 +#include "..\..\MCAuth\include\MCAuthManager.h" +#endif #include "..\PlayerList.h" #include "..\ServerPlayer.h" #include "GameRules\ConsoleGameRules.h" @@ -153,8 +156,6 @@ CMinecraftApp::CMinecraftApp() //ZeroMemory(m_PreviewBuffer,sizeof(XSOCIAL_PREVIEWIMAGE)*XUSER_MAX_COUNT); - m_xuidNotch = INVALID_XUID; - ZeroMemory(&m_InviteData,sizeof(JoinFromInviteData) ); // m_bRead_TMS_XUIDS_XML=false; @@ -258,6 +259,7 @@ void CMinecraftApp::DebugPrintf(const char *szFormat, ...) vsnprintf(buf, sizeof(buf), szFormat, ap); va_end(ap); OutputDebugStringA(buf); + fputs(buf, stdout); #endif } @@ -1640,6 +1642,18 @@ void CMinecraftApp::SetPlayerSkin(int iPad,DWORD dwSkinId) } +void CMinecraftApp::SetPlayerMojangSkin(int iPad) +{ + SetPlayerSkin(iPad, (DWORD)eDefaultSkins_MojangSkin); + + // Override customTextureUrl to point to this player's Mojang memory texture + if (iPad >= 0 && iPad < XUSER_MAX_COUNT && + !m_mojangSkinKey[iPad].empty() && Minecraft::GetInstance()->localplayers[iPad] != nullptr) + { + Minecraft::GetInstance()->localplayers[iPad]->customTextureUrl = m_mojangSkinKey[iPad]; + } +} + wstring CMinecraftApp::GetPlayerSkinName(int iPad) { return app.getSkinPathFromId(GameSettingsA[iPad]->dwSelectedSkin); @@ -3298,6 +3312,14 @@ void CMinecraftApp::HandleXuiActions(void) // 4J Stu - Fix for #13257 - CRASH: Gameplay: Title crashed after exiting the tutorial // It doesn't matter if they were in the tutorial already pMinecraft->playerLeftTutorial( idx ); + +#ifdef _WINDOWS64 + // Clear splitscreen auth slots when leaving the world so the + // account picker doesn't show stale "Player N" badges in the + // main menu. Keep slot 0 (primary player) intact. + if (idx != (unsigned int)ProfileManager.GetPrimaryPad()) + MCAuthManager::Get().ClearSlot(idx); +#endif } LoadingInputParams *loadingParams = new LoadingInputParams(); @@ -4560,6 +4582,8 @@ int CMinecraftApp::SignoutExitWorldThreadProc( void* lpParameter ) int exitReasonStringId = -1; bool saveStats = false; + app.DebugPrintf("[Auth-Client] ExitWorld: isClientSide=%d, IsInSession=%d, lpParameter=%p, disconnectReason=%d\n", + (int)pMinecraft->isClientSide(), (int)g_NetworkManager.IsInSession(), lpParameter, (int)app.GetDisconnectReason()); if (pMinecraft->isClientSide() || g_NetworkManager.IsInSession() ) { if(lpParameter != nullptr ) @@ -4592,6 +4616,7 @@ int CMinecraftApp::SignoutExitWorldThreadProc( void* lpParameter ) default: exitReasonStringId = IDS_DISCONNECTED; } + app.DebugPrintf("[Auth-Client] ExitWorld: showing exitReasonStringId=%d\n", exitReasonStringId); pMinecraft->progressRenderer->progressStartNoAbort( exitReasonStringId ); // 4J - Force a disconnection, this handles the situation that the server has already disconnected if( pMinecraft->levels[0] != nullptr ) pMinecraft->levels[0]->disconnect(false); @@ -4599,6 +4624,7 @@ int CMinecraftApp::SignoutExitWorldThreadProc( void* lpParameter ) } else { + app.DebugPrintf("[Auth-Client] ExitWorld: lpParameter=null, showing IDS_EXITING_GAME\n"); exitReasonStringId = IDS_EXITING_GAME; pMinecraft->progressRenderer->progressStartNoAbort( IDS_EXITING_GAME ); @@ -4649,6 +4675,7 @@ int CMinecraftApp::SignoutExitWorldThreadProc( void* lpParameter ) break; case DisconnectPacket::eDisconnect_OutdatedClient: exitReasonStringId = IDS_DISCONNECTED_CLIENT_OLD; + break; default: exitReasonStringId = IDS_DISCONNECTED; } @@ -5694,14 +5721,6 @@ void CMinecraftApp::UpdateTime() m_Time.fAppTime = m_Time.fSecsPerTick * static_cast(m_Time.qwAppTime.QuadPart); } -bool CMinecraftApp::isXuidNotch(PlayerUID xuid) -{ - if(m_xuidNotch != INVALID_XUID && xuid != INVALID_XUID) - { - return ProfileManager.AreXUIDSEqual(xuid, m_xuidNotch) == TRUE; - } - return false; -} bool CMinecraftApp::isXuidDeadmau5(PlayerUID xuid) { diff --git a/Minecraft.Client/Common/Consoles_App.h b/Minecraft.Client/Common/Consoles_App.h index 0c1c261efd..9ce2f1de4b 100644 --- a/Minecraft.Client/Common/Consoles_App.h +++ b/Minecraft.Client/Common/Consoles_App.h @@ -349,7 +349,6 @@ class CMinecraftApp virtual void StoreLaunchData(); virtual void ExitGame(); - bool isXuidNotch(PlayerUID xuid); bool isXuidDeadmau5(PlayerUID xuid); void AddMemoryTextureFile(const wstring &wName, PBYTE pbData, DWORD dwBytes); @@ -357,6 +356,10 @@ class CMinecraftApp void GetMemFileDetails(const wstring &wName,PBYTE *ppbData,DWORD *pdwBytes); bool IsFileInMemoryTextures(const wstring &wName); + // Mojang skin key per player slot (set after auth, e.g. "mojang_skin_{uuid}.png") + wstring m_mojangSkinKey[XUSER_MAX_COUNT]; + void SetPlayerMojangSkin(int iPad); + // Texture Pack Data files (icon, banner, comparison shot & text) void AddMemoryTPDFile(int iConfig,PBYTE pbData,DWORD dwBytes); void RemoveMemoryTPDFile(int iConfig); @@ -378,7 +381,6 @@ class CMinecraftApp void AddCreditText(LPCWSTR lpStr); private: - PlayerUID m_xuidNotch; #ifdef _DURANGO unordered_map m_GTS_Files; #else diff --git a/Minecraft.Client/Common/Media/platformskin.swf b/Minecraft.Client/Common/Media/platformskin.swf new file mode 100644 index 0000000000000000000000000000000000000000..f7c64ef0d89dcd61b60c0fe9172de30b6311ab09 GIT binary patch literal 2333333 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%0D_4)^HIhr`stJj^EKM~_8}i*{{i_zK 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