Skip to content

Open-source Xbox-inspired desktop launcher for Xodus on Linux

TypeScript
17.3 KB
Raw Blame
/* Account-free privilege parser/provider contracts. The verifier substitution
 * exists in this standalone executable only, never in the shipped DLL. */
#define COBJMACROS
#define INITGUID
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <roapi.h>
#include <winstring.h>
#define WIDL_using_Windows_Data_Json
#include <windows.data.json.h>
#include "xtaskqueue.h"
#include "xasyncprovider.h"
#include "xuser.h"
#include "userprovider.h"
#include "xgameerr.h"
#include "xuser_privilege.h"

static LONG checks, failures;
#define CHECK(name, value) do { ++checks; if (!(value)) { ++failures; printf("FAIL %s line=%u\n", name, __LINE__); } } while (0)

/* Only the fields read by the compiled server adapter. Not a public user handle
 * and never passed to the production DLL's user APIs. All values synthetic. */
struct XUser {
    IUser IUser_iface;
    char *deviceToken, *userToken, *proofKey, *titleToken;
    UINT64 xuid;
};
static HRESULT adapter_transport_hr, adapter_init_hr;
static DWORD adapter_status;
static const char *adapter_response;
static UINT adapter_requests;
static struct XUser *impl_from_IUser(IUser *iface) { return (struct XUser *)iface; }
static HRESULT user_wait_init(XUserHandle user) { (void)user; return adapter_init_hr; }
static void auth_metadata(const char *phase, XUserHandle user, HRESULT hr, DWORD status, BOOL requested, BOOL actual) {
    (void)phase; (void)user; (void)hr; (void)status; (void)requested; (void)actual;
}
static HRESULT xsts_authorize_privilege(XUserHandle, const char *, BOOL, char **, XUserPrivilege, BOOLEAN *);
static HRESULT xuser_signed_request(XUserHandle user, const char *method, const char *url, const char *auth,
    const char *headers, const void *body, DWORD size, DWORD *status, BYTE **buffer, SIZE_T *length)
{
    const char *with_title = "{\"RelyingParty\":\"http://xboxlive.com\",\"TokenType\":\"JWT\",\"Properties\":{\"SandboxId\":\"RETAIL\",\"DeviceToken\":\"device\",\"TitleToken\":\"title\",\"UserTokens\":[\"user\"],\"ProofKey\":{\"kty\":\"EC\"}}}";
    const char *without_title = "{\"RelyingParty\":\"http://xboxlive.com\",\"TokenType\":\"JWT\",\"Properties\":{\"SandboxId\":\"RETAIL\",\"DeviceToken\":\"device\",\"UserTokens\":[\"user\"],\"ProofKey\":{\"kty\":\"EC\"}}}";
    (void)user;
    ++adapter_requests;
    CHECK("adapter-method-url", !strcmp(method,"POST") && !strcmp(url,"https://xsts.auth.xboxlive.com/xsts/authorize"));
    CHECK("adapter-no-fabricated-authorization", !auth);
    CHECK("adapter-contract-header", !strcmp(headers,"x-xbl-contract-version: 1\r\nContent-Type: application/json\r\n"));
    CHECK("adapter-accepted-request-shape", !strcmp(body,with_title) || !strcmp(body,without_title));
    CHECK("adapter-exact-body-size", size == strlen(body));
    if (FAILED(adapter_transport_hr)) return adapter_transport_hr;
    *status = adapter_status;
    *length = strlen(adapter_response);
    *buffer = malloc(*length + 1);
    if (!*buffer) return E_OUTOFMEMORY;
    memcpy(*buffer, adapter_response, *length + 1);
    return S_OK;
}
#define TRACE(...) ((void)0)
#define ERR(...) ((void)0)
#include "user-privilege-adapter.inc"

static void test_server_adapter(void)
{
    struct XUser user = { .deviceToken="device", .userToken="user", .proofKey="{\"kty\":\"EC\"}", .titleToken="title", .xuid=123 };
    const struct { const char *response; HRESULT hr; } cases[] = {
        {"{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[{\"uhs\":\"synthetic\",\"xid\":\"123\",\"prv\":\"185 254 252\"}]}}", S_OK},
        {"{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[{\"uhs\":\"synthetic\",\"xid\":\"123\",\"prv\":\"185 252\"}]}}", E_GAMEUSER_FAILED_TO_RESOLVE},
        {"{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[{\"uhs\":\"synthetic\",\"xid\":\"124\",\"prv\":\"254\"}]}}", E_GAMEUSER_NO_AUTH_USER},
    };
    const char *invalid[] = {
        "{}", "invalid", "{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[]}}",
        "{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[{\"uhs\":\"synthetic\",\"xid\":\"123\"}]}}",
        "{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[{\"uhs\":\"synthetic\",\"xid\":\"123\",\"prv\":[254]}]}}",
        "{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[{\"uhs\":\"synthetic\",\"xid\":\"123\",\"prv\":\"254bad\"}]}}",
    };
    UINT i, before;
    char *auth = NULL;
    adapter_status = 200;
    for (i=0; i<sizeof(cases)/sizeof(*cases); ++i) {
        adapter_response = cases[i].response;
        CHECK("adapter-real-verifier", user_verify_privilege(&user.IUser_iface,254) == cases[i].hr);
    }
    for (i=0; i<sizeof(invalid)/sizeof(*invalid); ++i) {
        adapter_response = invalid[i];
        CHECK("adapter-rejects-invalid-response", FAILED(user_verify_privilege(&user.IUser_iface,254)));
    }
    adapter_response = cases[0].response;
    adapter_status = 400;
    CHECK("adapter-http-400-not-granted", user_verify_privilege(&user.IUser_iface,254) == E_FAIL);
    adapter_status = 403;
    CHECK("adapter-http-403-not-granted", user_verify_privilege(&user.IUser_iface,254) == E_FAIL);
    adapter_status = 200; adapter_transport_hr = HRESULT_FROM_WIN32(ERROR_TIMEOUT);
    CHECK("adapter-network-failure", user_verify_privilege(&user.IUser_iface,254) == adapter_transport_hr);
    adapter_transport_hr = S_OK;
    user.titleToken = NULL;
    CHECK("adapter-no-title-token-path", user_verify_privilege(&user.IUser_iface,254) == S_OK);
    user.titleToken = "title";
    before = adapter_requests; user.userToken = NULL;
    CHECK("adapter-no-auth-user", user_verify_privilege(&user.IUser_iface,254) == E_GAMEUSER_NO_AUTH_USER && adapter_requests == before);
    user.userToken = "user"; adapter_init_hr = E_FAIL;
    CHECK("adapter-initialization-failure", user_verify_privilege(&user.IUser_iface,254) == E_FAIL && adapter_requests == before);
    adapter_init_hr = S_OK;
    /* Other token callers do not require privilege claims or change format. */
    adapter_response = "{\"Token\":\"synthetic\",\"DisplayClaims\":{\"xui\":[{\"uhs\":\"synthetic\"}]}}";
    CHECK("ordinary-auth-without-privileges", xsts_authorize(&user,"http://xboxlive.com",TRUE,&auth) == S_OK && auth && !strcmp(auth,"XBL3.0 x=synthetic;synthetic"));
    free(auth);
}
struct fixture_user
{
    IUser iface;
    LONG refs, calls;
    HANDLE entered, gate;
    DWORD thread;
    HRESULT result;
};
static ULONG WINAPI addref(IUser *iface) { return InterlockedIncrement(&((struct fixture_user *)iface)->refs); }
static ULONG WINAPI release(IUser *iface) { return InterlockedDecrement(&((struct fixture_user *)iface)->refs); }
static IUserVtbl user_vtbl = { .AddRef = addref, .Release = release };
static HRESULT verify(IUser *iface, XUserPrivilege privilege)
{
    struct fixture_user *user = (void *)iface;
    BOOLEAN granted;
    HRESULT hr;
    user->thread = GetCurrentThreadId();
    InterlockedIncrement(&user->calls);
    SetEvent(user->entered);
    WaitForSingleObject(user->gate, 4000);
    if (FAILED(user->result)) return user->result;
    hr = privilege_claim(L"123", 3, 123, L"185 254 252", 11, privilege, &granted);
    return FAILED(hr) ? hr : granted ? S_OK : E_GAMEUSER_FAILED_TO_RESOLVE;
}
static void test_claims(void)
{
    const struct { const WCHAR *prv; HRESULT hr; BOOLEAN granted; } cases[] = {
        {L"185 254 252", S_OK, TRUE}, {L"254", S_OK, TRUE},
        {L"  254   ", S_OK, TRUE}, {L"254 254", S_OK, TRUE},
        {L"0254", S_OK, TRUE}, {L"", S_OK, FALSE}, {L" ", S_OK, FALSE},
        {L"185 252", S_OK, FALSE}, {L"1254 2540 25 4", S_OK, FALSE},
        {L"4294967295 254", S_OK, TRUE},
        {L"254x", HRESULT_FROM_WIN32(ERROR_INVALID_DATA), FALSE},
        {L"254 -1", HRESULT_FROM_WIN32(ERROR_INVALID_DATA), FALSE},
        {L"254 4294967296", HRESULT_FROM_WIN32(ERROR_INVALID_DATA), FALSE},
        {L"+254", HRESULT_FROM_WIN32(ERROR_INVALID_DATA), FALSE},
        {L"254\t252", HRESULT_FROM_WIN32(ERROR_INVALID_DATA), FALSE},
        {L"254,252", HRESULT_FROM_WIN32(ERROR_INVALID_DATA), FALSE},
    };
    static const WCHAR *bad_xids[] = {L"", L"-123", L"123x", L"123 ", L"18446744073709551616"};
    BOOLEAN granted;
    UINT i;
    HRESULT hr;
    for (i = 0; i < sizeof(cases)/sizeof(*cases); ++i) {
        granted = 0x7f;
        hr = privilege_claim(L"123", 3, 123, cases[i].prv, wcslen(cases[i].prv), XUserPrivilege_Multiplayer, &granted);
        CHECK("claim-status", hr == cases[i].hr);
        CHECK("claim-grant", granted == cases[i].granted);
    }
    for (i = 0; i < sizeof(bad_xids)/sizeof(*bad_xids); ++i) {
        CHECK("bad-identity", FAILED(privilege_claim(bad_xids[i], wcslen(bad_xids[i]), 123, L"254", 3, 254, &granted)) && !granted);
    }
    CHECK("other-user", privilege_claim(L"124", 3, 123, L"254", 3, 254, &granted) == E_GAMEUSER_NO_AUTH_USER && !granted);
    CHECK("zero-user", FAILED(privilege_claim(L"0", 1, 0, L"254", 3, 254, &granted)) && !granted);
    CHECK("missing-claim", FAILED(privilege_claim(L"123", 3, 123, NULL, 0, 254, &granted)) && !granted);
    CHECK("embedded-nul", FAILED(privilege_claim(L"123", 3, 123, L"254\0 252", 8, 254, &granted)) && !granted);
    CHECK("oversized-claim", FAILED(privilege_claim(L"123", 3, 123, L"254", 16385, 254, &granted)) && !granted);
    CHECK("invalid-privilege", FAILED(privilege_claim(L"123", 3, 123, L"0", 1, 0, &granted)) && !granted);
    CHECK("max-xuid", privilege_claim(L"18446744073709551615", 20, ~(UINT64)0, L"254", 3, 254, &granted) == S_OK && granted);
    CHECK("null-output", privilege_claim(L"123", 3, 123, L"254", 3, 254, NULL) == E_INVALIDARG);
    for (i = 0; i < 512; ++i) CHECK("known-enum-only", privilege_valid((XUserPrivilege)i) ==
        (i == 185 || i == 188 || i == 189 || i == 190 || i == 196 || i == 198 || i == 203 || i == 207 || i == 208 || i == 209 || i == 220 || i == 247 || i == 252 || i == 254 || i == 255));
}
struct completion_context { LONG callbacks; HRESULT result; IXThreadingImpl *threads; BOOL dispose; };
static void WINAPI complete(XAsyncBlock *block)
{
    struct completion_context *context = block->context;
    context->result = privilege_result(context->threads, block);
    InterlockedIncrement(&context->callbacks);
    if (context->dispose) { memset(block, 0xdd, sizeof(*block)); free(block); }
}
static void drain(IXThreadingImpl *threads, XTaskQueueHandle queue, struct fixture_user *user, struct completion_context *context)
{
    ULONGLONG start = GetTickCount64();
    while ((user->refs != 1 || !context->callbacks) && GetTickCount64() - start < 5000) {
        IXThreadingImpl_XTaskQueueDispatch(threads, queue, XTaskQueuePort_Completion, 0); Sleep(1);
    }
}
static void test_async(IXThreadingImpl *threads, XTaskQueueDispatchMode mode, UINT test)
{
    struct fixture_user user = {0};
    struct completion_context context = {0};
    XTaskQueueHandle queue = NULL;
    XAsyncBlock block = {0};
    HRESULT expected = test == 1 ? E_GAMEUSER_FAILED_TO_RESOLVE : test == 2 ? E_FAIL : test == 3 ? E_GAMEUSER_NO_AUTH_USER : S_OK;
    BOOL manual = mode == XTaskQueueDispatchMode_Manual, canceled = test >= 4;
    ULONGLONG start;
    user.iface.lpVtbl = &user_vtbl; user.refs = 1;
    user.result = test == 2 ? E_FAIL : test == 3 ? E_GAMEUSER_NO_AUTH_USER : S_OK;
    user.entered = CreateEventA(NULL, TRUE, FALSE, NULL);
    user.gate = CreateEventA(NULL, TRUE, FALSE, NULL);
    context.threads = threads;
    CHECK("create-queue", IXThreadingImpl_XTaskQueueCreate(threads, mode, XTaskQueueDispatchMode_Manual, &queue) == S_OK);
    block.queue = queue; block.callback = complete; block.context = &context;
    CHECK("begin", privilege_begin(threads, &user.iface, test & 1 ? 1 : 0, test == 1 ? 247 : 254, &block, verify) == S_OK);
    CHECK("pending-result", privilege_result(threads, &block) == E_PENDING);
    CHECK("reject-pending-reuse", privilege_begin(threads, &user.iface, 0, 254, &block, verify) == E_INVALIDARG);
    if (test == 4 && manual) {
        IXThreadingImpl_XAsyncCancel(threads, &block);
    } else {
        start = GetTickCount64();
        if (manual) CHECK("manual-work", IXThreadingImpl_XTaskQueueDispatch(threads, queue, XTaskQueuePort_Work, 0));
        CHECK("dispatch-not-blocking", GetTickCount64() - start < 250);
        CHECK("verification-started", WaitForSingleObject(user.entered, 2500) == WAIT_OBJECT_0);
        CHECK("verification-not-caller-thread", user.thread != GetCurrentThreadId());
        CHECK("user-retained", user.refs == 2);
        if (canceled) IXThreadingImpl_XAsyncCancel(threads, &block);
    }
    if (canceled) {
        CHECK("abort-result", privilege_result(threads, &block) == E_ABORT);
        while (IXThreadingImpl_XTaskQueueDispatch(threads, queue, XTaskQueuePort_Completion, 0));
        if (!(test == 4 && manual)) CHECK("retained-until-worker-ends", user.refs == 2);
    }
    SetEvent(user.gate);
    if (test == 4 && manual) IXThreadingImpl_XTaskQueueDispatch(threads, queue, XTaskQueuePort_Work, 0);
    drain(threads, queue, &user, &context);
    CHECK("one-completion", context.callbacks == 1);
    CHECK("real-result", context.result == (canceled ? E_ABORT : expected));
    CHECK("poll-result", privilege_result(threads, &block) == context.result);
    CHECK("reference-balanced", user.refs == 1);
    CHECK("verify-once", user.calls == (test == 4 && manual ? 0 : 1));
    /* The same block can be reused after completion without inheriting a grant. */
    context.callbacks = 0; user.result = E_FAIL;
    CHECK("completed-reuse", privilege_begin(threads, &user.iface, 0, 254, &block, verify) == S_OK);
    if (manual) IXThreadingImpl_XTaskQueueDispatch(threads, queue, XTaskQueuePort_Work, 0);
    drain(threads, queue, &user, &context);
    CHECK("reuse-real-error", context.callbacks == 1 && context.result == E_FAIL && user.refs == 1);
    IXThreadingImpl_XTaskQueueCloseHandle(threads, queue);
    CloseHandle(user.entered); CloseHandle(user.gate);
}
static void test_lifetime(IXThreadingImpl *threads)
{
    UINT i;
    for (i = 0; i < 24; ++i) {
        struct fixture_user user = {0};
        struct completion_context context = {0};
        XTaskQueueHandle queue = NULL;
        XAsyncBlock *block = calloc(1, sizeof(*block));
        ULONGLONG start;
        user.iface.lpVtbl = &user_vtbl; user.refs = 1;
        user.entered = CreateEventA(NULL, TRUE, FALSE, NULL);
        user.gate = CreateEventA(NULL, TRUE, FALSE, NULL);
        context.threads = threads; context.dispose = TRUE;
        CHECK("immediate-queue", IXThreadingImpl_XTaskQueueCreate(threads,
            XTaskQueueDispatchMode_Immediate, XTaskQueueDispatchMode_Immediate, &queue) == S_OK);
        block->queue = queue; block->context = &context; block->callback = complete;
        CHECK("immediate-begin", privilege_begin(threads, &user.iface, 0, 254, block, verify) == S_OK);
        CHECK("immediate-worker-ready", WaitForSingleObject(user.entered, 2500) == WAIT_OBJECT_0);
        /* The operation must retain the queue after the caller closes it.
         * Completion consumes/frees the caller block while the worker lives. */
        IXThreadingImpl_XTaskQueueCloseHandle(threads, queue);
        if (i & 1) IXThreadingImpl_XAsyncCancel(threads, block);
        SetEvent(user.gate);
        start = GetTickCount64();
        while ((user.refs != 1 || !context.callbacks) && GetTickCount64() - start < 5000) Sleep(1);
        CHECK("closed-queue-completion", context.callbacks == 1 && context.result == (i & 1 ? E_ABORT : S_OK));
        CHECK("freed-caller-block-safe", user.refs == 1 && user.calls == 1);
        CloseHandle(user.entered); CloseHandle(user.gate);
    }
}
int main(void)
{
    HMODULE dll = LoadLibraryA("xgameruntime.dll");
    HRESULT (WINAPI *query)(const GUID *, REFIID, void **);
    IXThreadingImpl *threads;
    IXUserImpl *users;
    XAsyncBlock block = {0};
    struct fixture_user user = {0};
    UINT mode, test;
    if (!dll || !(query = (void *)GetProcAddress(dll, "QueryApiImpl")) ||
        FAILED(query(&CLSID_XThreadingImpl, &IID_IXThreadingImpl, (void **)&threads)) ||
        FAILED(query(&CLSID_XUserImpl, &IID_IXUserImpl, (void **)&users))) return 2;
    user.iface.lpVtbl = &user_vtbl; user.refs = 1;
    test_claims();
    test_server_adapter();
    CHECK("null-user", privilege_begin(threads, NULL, 0, 254, &block, verify) == E_INVALIDARG);
    CHECK("null-block", privilege_begin(threads, &user.iface, 0, 254, NULL, verify) == E_INVALIDARG);
    CHECK("bad-options", privilege_begin(threads, &user.iface, 2, 254, &block, verify) == E_INVALIDARG);
    CHECK("bad-privilege", privilege_begin(threads, &user.iface, 0, 0, &block, verify) == E_INVALIDARG);
    CHECK("missing-verifier", privilege_begin(threads, &user.iface, 0, 254, &block, NULL) == E_INVALIDARG);
    CHECK("no-retain-invalid", user.refs == 1);
    CHECK("uninitialized-result", privilege_result(threads, &block) == E_INVALIDARG);
    CHECK("null-result", privilege_result(threads, NULL) == E_INVALIDARG);
    CHECK("dll-null-user", IXUserImpl_XUserResolvePrivilegeWithUiAsync(users, NULL, 0, 254, &block) == E_INVALIDARG);
    CHECK("dll-foreign-user", IXUserImpl_XUserResolvePrivilegeWithUiAsync(users, (XUserHandle)&user, 0, 254, &block) == E_INVALIDARG);
    CHECK("dll-null-result", IXUserImpl_XUserResolvePrivilegeWithUiResult(users, NULL) == E_INVALIDARG);
    CHECK("dll-foreign-result", IXUserImpl_XUserResolvePrivilegeWithUiResult(users, &block) == E_INVALIDARG);
    for (mode = 0; mode < 4; ++mode) for (test = 0; test < 6; ++test)
        test_async(threads, (XTaskQueueDispatchMode)mode, test);
    test_lifetime(threads);
    IXUserImpl_Release(users); IXThreadingImpl_Release(threads);
    printf("CHECKS %ld FAILURES %ld\n", checks, failures);
    return failures ? 1 : 0;
}