Files
DroidDeck/tools/linuxfs/overlay/usr/local/bin/droiddeck-xbox
T
The412Banner 81e238b92e feat(xbox): Nexus backend 0.2.15, Nexus runtime 11.0-20261102 and DLC mounting (#2696)
Nexus moved its Xodus changes from patch files in xodus-nexus into a backend
fork (domsvoboda/nexus-backend, GPL-3.0). prepare.py now fetches that fork at
backend-v0.2.15 (e7884a27, same Xodus base 53ea781d, same Rust 1.99.0) and
applies the DroidDeck patches, rebased onto it:
- droiddeck-credentials, -launch-view, -library-subscriptions: same rebase as
  Bannerlator's 0.2.15 update (identical patches before and after).
- droiddeck-credential-fallback, -credential-diagnostics: applied unchanged.
- droiddeck-cloud-token: session::prepare now also returns the account
  snapshot; the ticket checks it like upstream's profile/social commands.
- droiddeck-licensing-device-ticket: upstream 0.2.15 already formats
  delegation-compact device tickets for Store license tokens (27c335e), so only
  the content licensing path is patched. Upstream now writes compact JWE
  delegation tickets as t=, so the d= prefix check is replaced by the token
  type, the same rule as upstream's store_license.rs.
droiddeck-xbox-ticket.patch is dropped: upstream sends compact JWE delegation
tickets to Xbox Live sign-in in a form it accepts, with tests.

Runtime: domsvoboda/nexus-runtime runtime-11.0-20261102-g76c6dd13 (was
xodus-nexus runtime-11.0-20261018). Same six modules at the same path;
xgameruntime.dll is the C++ implementation (nexus-xgameruntime 455b1ba9).
Archive sha512 from the release's .sha512sum, source sha256 from its
candidate.json, module sha256 from the extracted files. The PlayFab Game Saves
proxy is a newer build at the same path and still passes droiddeck-xbox's
export checks; its license moved to share/doc/nexus-runtime/.

DLC mounting: the C++ runtime mounts downloadable content only inside a
host-managed workspace named by XODUS_MOUNT_ROOT (src/System/Package/Mount.h
returns E_NOTIMPL without it). DroidDeck starts Wine itself
(droiddeck:prepare), so droiddeck-dlc-mount.patch (ported from Bannerlator)
creates the workspace in the launch directory for the prepare session and
reports it as mountRoot; XboxRuntime passes it in the xbox-prepare reply and
droiddeck-xbox sets XODUS_MOUNT_ROOT to its Z: path. XODUS_CONTENT_ROOTS is
unchanged and still read by the runtime.

Upstream fixes since the old pins include sign-in for some accounts, offline
play, cloud-save conflict handling, DLC mounting, duplicate token requests and
per-game fixes (Ori, AoE, MSFS, Forza Motorsport).
2026-11-15 20:55:42 -05:00

447 lines
20 KiB
Python
Executable File

#!/usr/bin/python3
import hmac
import json
import os
from pathlib import Path
import runpy
import secrets
import shutil
import socket
import subprocess
import sys
import tempfile
import threading
BIN = Path(__file__).resolve().parent
RUNTIME = Path('/usr/local/lib/droiddeck-xbox')
DLLS = ('xgameruntime.dll', 'winhttp.dll', 'windows.web.dll', 'twinapi.appcore.dll', 'wintypes.dll', 'libnghttp2.dll')
CLASSES = {
'twinapi.appcore.dll': ('Windows.ApplicationModel.DataTransfer.DataTransferManager',
'Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation',
'Windows.System.Profile.AnalyticsInfo', 'Windows.System.UserProfile.AdvertisingManager',
'Windows.UI.ViewManagement.ApplicationView'),
'windows.web.dll': ('Windows.Data.Json.JsonArray', 'Windows.Data.Json.JsonObject', 'Windows.Data.Json.JsonValue'),
'wintypes.dll': ('Windows.Foundation.PropertyValue', 'Windows.Foundation.Collections.PropertySet',
'Windows.Foundation.Metadata.ApiInformation', 'Windows.Storage.Streams.Buffer',
'Windows.Storage.Streams.DataWriter'),
}
CLASS_KEY = 'Software\\Microsoft\\WindowsRuntime\\ActivatableClassId\\'
VIEW_DRIVES = 'xwvutsrqponmlkjihgfe'
def bridge(upstream):
key = secrets.token_hex(32).encode('ascii')
server = socket.socket()
server.bind(('127.0.0.1', 0))
server.listen(16)
clients = set()
lock = threading.Lock()
stopped = threading.Event()
def forward(source, target):
try:
while not stopped.is_set():
data = source.recv(65536)
if not data:
break
target.sendall(data)
except OSError:
pass
finally:
try:
target.shutdown(socket.SHUT_WR)
except OSError:
pass
def connect(client):
remote = None
try:
client.settimeout(10)
supplied = b''
while len(supplied) < len(key):
part = client.recv(len(key) - len(supplied))
if not part:
return
supplied += part
if not hmac.compare_digest(supplied, key):
return
remote = socket.socket(socket.AF_UNIX)
remote.connect(upstream)
client.settimeout(None)
with lock:
clients.add(remote)
writer = threading.Thread(target=forward, args=(client, remote), daemon=True)
writer.start()
forward(remote, client)
writer.join(2)
except OSError:
pass
finally:
for sock in (client, remote):
if sock is not None:
with lock:
clients.discard(sock)
sock.close()
def accept():
while not stopped.is_set():
try:
client, _ = server.accept()
except OSError:
break
with lock:
if len(clients) >= 64:
client.close()
continue
clients.add(client)
threading.Thread(target=connect, args=(client,), daemon=True).start()
threading.Thread(target=accept, daemon=True).start()
def close():
stopped.set()
server.close()
with lock:
for client in clients:
try:
client.shutdown(socket.SHUT_RDWR)
except OSError:
pass
client.close()
clients.clear()
return server.getsockname()[1], key.decode('ascii'), close
def register_classes(proton, prefix, env):
try:
registry = (prefix / 'system.reg').read_text(encoding='utf-8', errors='replace')
except OSError:
return
missing = [(name, dll) for dll, names in CLASSES.items() for name in names
if '[%s]' % (CLASS_KEY + name).replace('\\', '\\\\') not in registry]
if not missing:
return
text = 'Windows Registry Editor Version 5.00\r\n\r\n' + ''.join(
'[HKEY_LOCAL_MACHINE\\%s%s]\r\n"DllPath"="C:\\\\windows\\\\system32\\\\%s"\r\n\r\n' % (CLASS_KEY, name, dll)
for name, dll in missing)
with tempfile.TemporaryDirectory(prefix='droiddeck-xbox-') as temporary:
source = Path(temporary) / 'classes.reg'
source.write_bytes(b'\xff\xfe' + text.encode('utf-16-le'))
try:
failed = subprocess.run([proton, 'run', 'reg.exe', 'import', 'Z:' + str(source).replace('/', '\\')],
stdout=sys.stderr, env=env, timeout=90).returncode != 0
except subprocess.TimeoutExpired:
failed = True
if failed:
print('droiddeck-xbox: Windows Runtime class registration failed; launching without it', file=sys.stderr)
def view_drive(prefix, exe):
path = Path(exe)
view = next((parent for parent in path.parents if parent.name.startswith('droiddeck-xbox-')), None)
if not path.is_absolute() or view is None:
return exe, None
devices = prefix / 'dosdevices'
for letter in VIEW_DRIVES:
link = devices / (letter + ':')
staged = devices / ('.%s-%s' % (letter, secrets.token_hex(4)))
try:
if os.path.lexists(link) and (os.path.exists(link) or not os.readlink(link).startswith(str(view.parent.parent) + '/')):
continue
devices.mkdir(parents=True, exist_ok=True)
staged.symlink_to(view.parent)
os.replace(staged, link)
except OSError:
if os.path.lexists(staged):
staged.unlink()
continue
return letter.upper() + ':\\' + str(path.relative_to(view.parent)).replace('/', '\\'), link
return exe, None
def wine(argv, source_env=None):
source_env = os.environ if source_env is None else source_env
with open(source_env['DROIDDECK_XBOX_COMMAND_FILE'], encoding='utf-8') as file:
command = json.load(file)
if len(command) < 3 or command[1] != 'waitforexitandrun' or len(argv) != 1:
raise ValueError('Invalid Xbox Proton invocation')
env = dict(source_env)
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
env.pop(name, None)
env.pop('DROIDDECK_XBOX_COMMAND_FILE', None)
prefix = Path(source_env['STEAM_COMPAT_DATA_PATH']) / 'pfx'
prefix.parent.mkdir(parents=True, exist_ok=True)
if not (prefix / 'system.reg').is_file():
result = subprocess.run([command[0], 'run', 'cmd', '/c', 'exit', '0'], stdout=sys.stderr, env=env)
if result.returncode:
return result.returncode
system = prefix / 'drive_c/windows/system32'
system.mkdir(parents=True, exist_ok=True)
for name in DLLS:
target = system / name
if target.is_symlink():
target.unlink()
shutil.copyfile(RUNTIME / 'windows' / name, target)
register_classes(command[0], prefix, env)
overrides = ';'.join(name[:-4] + '=n' for name in DLLS if name != 'libnghttp2.dll')
env['WINEDLLOVERRIDES'] = overrides + ';' + env.get('WINEDLLOVERRIDES', '')
exe, drive = view_drive(prefix, argv[0])
try:
return subprocess.call([*command[:2], exe, *command[3:]], env=env)
finally:
if drive is not None:
try:
drive.unlink()
except OSError:
pass
# PlayFab Game Saves picks its provider from the Gaming Runtime unless HKLM\SOFTWARE\Microsoft\GamingServices
# ForceUseInprocGameSaves is set, and its in-process provider needs a save folder the title never passes on Windows.
# The runtime has no GRTS saves, so titles such as Forza Horizon 6 stop with E:0-17. xodus-nexus ships a proxy
# (scripts/runtime-compat/playfab-save-folder.c, MIT) that keeps the title's own SDK as nexus_pgs_native.dll and
# supplies both; this stages it the same way.
PGS_PROXY = RUNTIME / 'compat' / 'PlayFabGameSave.dll'
PGS_NATIVE = 'nexus_pgs_native.dll'
PGS_EXPORTS = (
'PFGameSaveFilesAddUserWithUiAsync', 'PFGameSaveFilesAddUserWithUiResult', 'PFGameSaveFilesGetFolder',
'PFGameSaveFilesGetFolderSize', 'PFGameSaveFilesGetRemainingQuota', 'PFGameSaveFilesGetSaveDescriptionForDebug',
'PFGameSaveFilesGetSaveDescriptionSizeForDebug', 'PFGameSaveFilesGetStatsJsonForDebug',
'PFGameSaveFilesGetStatsJsonSizeForDebug', 'PFGameSaveFilesInitialize', 'PFGameSaveFilesIsConnectedToCloud',
'PFGameSaveFilesPauseUploadForDebug', 'PFGameSaveFilesResetCloudAsync', 'PFGameSaveFilesResetCloudResult',
'PFGameSaveFilesResumeUploadForDebug', 'PFGameSaveFilesSetActiveDeviceChangedCallback',
'PFGameSaveFilesSetActiveDevicePollForceChangeForDebug', 'PFGameSaveFilesSetActiveDevicePollIntervalForDebug',
'PFGameSaveFilesSetForceNullPendingManifestForDebug', 'PFGameSaveFilesSetForceOutOfStorageErrorForDebug',
'PFGameSaveFilesSetForceSyncFailedErrorForDebug', 'PFGameSaveFilesSetMockDataFolderForDebug',
'PFGameSaveFilesSetMockDeviceIdForDebug', 'PFGameSaveFilesSetMockForceOfflineForDebug',
'PFGameSaveFilesSetMockManifestOffsetForDebug', 'PFGameSaveFilesSetMockRootFolderForDebug',
'PFGameSaveFilesSetSaveDescriptionAsync', 'PFGameSaveFilesSetSaveDescriptionResult',
'PFGameSaveFilesSetUiActiveDeviceContentionResponse', 'PFGameSaveFilesSetUiCallbacks',
'PFGameSaveFilesSetUiConflictResponse', 'PFGameSaveFilesSetUiOutOfStorageResponse',
'PFGameSaveFilesSetUiProgressResponse', 'PFGameSaveFilesSetUiSyncFailedResponse',
'PFGameSaveFilesSetWriteManifestsToDiskForDebug', 'PFGameSaveFilesUiProgressGetProgress',
'PFGameSaveFilesUninitializeAsync', 'PFGameSaveFilesUninitializeResult', 'PFGameSaveFilesUploadWithUiAsync',
'PFGameSaveFilesUploadWithUiResult',
)
def pe_exports(data):
"""(export address table size, [(name, ordinal index, forwarder or None) for each named export]) of an x64
PE image, or None. The table size also counts exports that have no name."""
def u16(offset):
return int.from_bytes(data[offset:offset + 2], 'little')
def u32(offset):
return int.from_bytes(data[offset:offset + 4], 'little')
def string(offset):
end = data.find(b'\0', offset)
return None if offset is None or end < 0 else data[offset:end].decode('ascii', 'replace')
if len(data) < 256 or data[:2] != b'MZ':
return None
pe = u32(60)
if data[pe:pe + 4] != b'PE\0\0' or u16(pe + 4) != 0x8664:
return None
count, optional_size = u16(pe + 6), u16(pe + 20)
optional = pe + 24
if optional_size < 120 or u16(optional) != 0x20B or u32(optional + 108) < 1:
return None
sections = optional + optional_size
def offset_of(address):
for index in range(count):
section = sections + index * 40
start, size, raw = u32(section + 12), u32(section + 16), u32(section + 20)
if start <= address < start + size and raw + address - start < len(data):
return raw + address - start
return None
directory_rva, directory_size = u32(optional + 112), u32(optional + 116)
directory = offset_of(directory_rva)
if directory is None or u32(directory + 16) != 1:
return None
functions, names = u32(directory + 20), u32(directory + 24)
function_table, name_table, ordinal_table = (offset_of(u32(directory + 28)), offset_of(u32(directory + 32)),
offset_of(u32(directory + 36)))
if None in (function_table, name_table, ordinal_table):
return None
exports = []
for index in range(names):
name = string(offset_of(u32(name_table + 4 * index)))
ordinal = u16(ordinal_table + 2 * index)
address = u32(function_table + 4 * ordinal) if ordinal < functions else 0
if name is None or not address:
return None
forward = string(offset_of(address)) if directory_rva <= address < directory_rva + directory_size else None
exports.append((name, ordinal, forward))
return functions, exports
def playfab_sdk(data):
"""The PlayFab Game Saves SDK the proxy was written for: exactly its 40 exports, all named, none forwarded."""
parsed = pe_exports(data)
if parsed is None or parsed[0] != len(PGS_EXPORTS):
return False
exports = parsed[1]
return ([(name, ordinal) for name, ordinal, _ in exports] == list(zip(PGS_EXPORTS, range(len(PGS_EXPORTS))))
and all(forward is None for _, _, forward in exports))
def playfab_proxy(data):
"""A save-folder proxy (this one or an earlier build): the same 40 exports, forwarding into nexus_pgs_native."""
parsed = pe_exports(data)
if parsed is None or parsed[0] != len(PGS_EXPORTS):
return False
exports = parsed[1]
return ([name for name, _, _ in exports] == list(PGS_EXPORTS)
and any((forward or '').startswith(PGS_NATIVE[:-4] + '.') for _, _, forward in exports))
def kept_sdk(native):
"""True when nexus_pgs_native.dll is a regular file holding a recognised SDK."""
return not native.is_symlink() and native.is_file() and playfab_sdk(native.read_bytes())
def replace_file(directory, name, data):
descriptor, temporary = tempfile.mkstemp(prefix='.droiddeck-pgs-', dir=directory)
try:
with os.fdopen(descriptor, 'wb') as file:
file.write(data)
file.flush()
os.fsync(file.fileno())
os.chmod(temporary, 0o644)
os.replace(temporary, Path(directory) / name)
except BaseException:
try:
os.unlink(temporary)
except OSError:
pass
raise
def stage_playfab_proxy(folder):
"""Put the save-folder proxy in front of every PlayFab Game Saves SDK in the game folder. Returns how many."""
try:
proxy = PGS_PROXY.read_bytes()
except OSError:
return 0
staged = 0
for root, _, files in os.walk(folder):
directory = Path(root)
for name in files:
if name.lower() != 'playfabgamesave.dll':
continue
path = directory / name
native = directory / PGS_NATIVE
try:
if path.is_symlink():
continue
data = path.read_bytes()
if playfab_sdk(data):
# A first launch, or a game update that brought a new SDK: the update's copy becomes the native one,
# but only in place of nothing or of an earlier SDK copy, never over an unknown file or a link.
if os.path.lexists(native) and not kept_sdk(native):
print('droiddeck-xbox: unknown %s next to the PlayFab Game Saves SDK in %s; left unchanged'
% (PGS_NATIVE, directory), file=sys.stderr)
continue
replace_file(directory, PGS_NATIVE, data)
elif not playfab_proxy(data):
print('droiddeck-xbox: PlayFab Game Saves SDK with unknown exports in %s; left unchanged' % directory,
file=sys.stderr)
continue
elif not kept_sdk(native):
print('droiddeck-xbox: PlayFab save proxy without its SDK in %s; left unchanged' % directory,
file=sys.stderr)
continue
if data != proxy:
replace_file(directory, name, proxy)
staged += 1
except OSError as error:
print('droiddeck-xbox: PlayFab save proxy not staged in %s (%s)' % (directory, error), file=sys.stderr)
return staged
def renew_lease(ask, channel, product, lease, stopped):
while not stopped.wait(15):
response = ask(channel, {'op': 'xbox-renew', 'id': product, 'lease': lease}, timeout=10)
if response is not None and response.get('ok') is False:
return
def launch(command, env):
if len(command) < 3 or command[1] != 'waitforexitandrun' or env.get('DROIDDECK_XBOX_ACTIVE') == '1':
return None
try:
store = runpy.run_path(str(BIN / 'droiddeck-store-launch'))
except Exception as error:
print('droiddeck-xbox: store detection unavailable (%s); stock launch' % error, file=sys.stderr)
return None
found = store['find_store_game'](command[2:])
if found is None or found[1].get('store') != 'xbox':
return None
folder, sidecar = found
for name in DLLS:
if not (RUNTIME / 'windows' / name).is_file():
raise RuntimeError('Xbox Windows runtime is missing; update the Linux runtime')
launch_dir = env.get('BL_LAUNCH_DIR')
if not launch_dir:
raise RuntimeError('No Xbox account channel; start the game from DroidDeck')
reply = store['ask'](Path(launch_dir) / 'stores', {'op': 'xbox-prepare', 'id': sidecar['id']}, timeout=190)
if not reply or not reply.get('ok'):
raise RuntimeError('Xbox account service is unavailable; sign in again and retry')
stopped = threading.Event()
close = lambda: None
try:
port, key, close = bridge(reply['socket'])
threading.Thread(target=renew_lease, args=(store['ask'], Path(launch_dir) / 'stores',
sidecar['id'], reply['lease'], stopped), daemon=True).start()
with tempfile.TemporaryDirectory(prefix='droiddeck-xbox-') as temporary:
context = Path(temporary) / 'command.json'
context.write_text(json.dumps(command), encoding='utf-8')
context.chmod(0o600)
owned_env = dict(env, DROIDDECK_XBOX_ACTIVE='1', DROIDDECK_XBOX_COMMAND_FILE=str(context),
XODUS_SOCKET=reply['socket'], XODUS_BRIDGE_PORT=str(port), XODUS_BRIDGE_KEY=key,
XODUS_LOG='off', RUST_LOG='off', XODUS_SAVE_SYNC='auto' if sidecar.get('cloud', True) else 'off')
for name in ('DROIDDECK_XBOX_CREDENTIAL_SOCKET', 'DROIDDECK_XBOX_CREDENTIAL_PORT', 'DROIDDECK_XBOX_CREDENTIAL_KEY'):
owned_env.pop(name, None)
if reply.get('playfab'):
owned_env['XODUS_XSTS_PLAYFAB'] = reply['playfab']
# The runtime mounts DLC only inside this backend-owned workspace (E_NOTIMPL without it).
mount_root = reply.get('mountRoot')
if isinstance(mount_root, str) and mount_root.startswith('/'):
owned_env['XODUS_MOUNT_ROOT'] = 'Z:' + mount_root.replace('/', '\\')
content = folder / '.xbox-content'
roots = []
if content.is_dir():
for entry in content.iterdir():
try:
marker = json.loads((entry / '.droiddeck-content.json').read_text())
if marker.get('parent') == sidecar['id'] and marker.get('productId') == entry.name and not entry.is_symlink():
roots.append('Z:' + str(entry).replace('/', '\\'))
except (OSError, ValueError, TypeError):
pass
if roots:
owned_env['XODUS_CONTENT_ROOTS'] = ';'.join(roots)
# No DLL override for the proxy or the kept SDK: Wine has no builtin of either, so both load from the
# game folder as they are. Forcing them native-only (as Nexus does) made Forza Horizon 6 fail with E:0-0-4.
try:
stage_playfab_proxy(folder)
except Exception as error:
print('droiddeck-xbox: PlayFab save proxy skipped (%s)' % error, file=sys.stderr)
return wine([reply['exe']], owned_env)
finally:
stopped.set()
close()
store['ask'](Path(launch_dir) / 'stores', {'op': 'xbox-released', 'lease': reply['lease']})
if __name__ == '__main__':
try:
sys.exit(wine(sys.argv[1:]))
except (OSError, ValueError, KeyError, RuntimeError):
print('droiddeck-xbox: Xbox launch failed; check your account, runtime and package.', file=sys.stderr)
sys.exit(1)