diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 57a2075145..15f68eb87c 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -562,6 +562,12 @@ jobs: command -v x86_64-w64-mingw32-gcc >/dev/null || { sudo apt-get update -qq && sudo apt-get install -y -qq gcc-mingw-w64-x86-64; } bash tools/ubisoft-launcher/build.sh + - name: Rockstar launcher service (32-bit and 64-bit) + run: | + set -euo pipefail + command -v i686-w64-mingw32-gcc >/dev/null || { sudo apt-get update -qq && sudo apt-get install -y -qq gcc-mingw-w64-i686; } + bash tools/rockstar-launcher/build.sh + - uses: actions/download-artifact@v4 with: name: xbox-arm64 @@ -797,9 +803,11 @@ jobs: set -o pipefail cd app/src/main/rust/stores cargo test --locked 2>&1 | tail -60 - - name: Ubisoft launcher service host unit tests + - name: Windows launcher service host unit tests timeout-minutes: 10 - run: cargo test --locked --manifest-path tools/ubisoft-launcher/Cargo.toml + run: | + cargo test --locked --manifest-path tools/ubisoft-launcher/Cargo.toml + cargo test --locked --manifest-path tools/rockstar-launcher/Cargo.toml python-tests: name: Python and native regression tests diff --git a/.gitignore b/.gitignore index 0a404ef667..d0fe3ea9ea 100644 --- a/.gitignore +++ b/.gitignore @@ -36,3 +36,4 @@ __pycache__/ app/src/main/assets/directaudio/ app/src/main/assets/hybris/ /tools/vr/out/ +app/src/main/resources/rockstar/helpers/ diff --git a/app/src/main/java/com/droiddeck/launcher/App.kt b/app/src/main/java/com/droiddeck/launcher/App.kt index 9f74aa4e59..1801f34b5a 100644 --- a/app/src/main/java/com/droiddeck/launcher/App.kt +++ b/app/src/main/java/com/droiddeck/launcher/App.kt @@ -72,6 +72,7 @@ class App : Application() { com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.ubisoft.UbisoftBackend) com.droiddeck.launcher.stores.ea.EaBackend.app = this com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.ea.EaBackend) + com.droiddeck.launcher.stores.StoresState.register(com.droiddeck.launcher.stores.rockstar.RockstarBackend) } private fun prefetchAddonPacks() { diff --git a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt index 02edb1bcf8..d9db3374e9 100644 --- a/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt +++ b/app/src/main/java/com/droiddeck/launcher/frontend/AddedGames.kt @@ -418,6 +418,7 @@ object AddedGames { private fun scanGame(context: Context, folder: File, out: MutableList, single: AddedExes.Entry? = null, reuse: Boolean = false) { run { val sidecar = StoreGameSidecar.read(folder)?.let { com.droiddeck.launcher.stores.StoreLaunch.adopt(folder, it) } + if (sidecar?.store == Store.ROCKSTAR && (!com.droiddeck.launcher.stores.rockstar.RockstarLaunch.supports(sidecar.id) || sidecar.launcher != com.droiddeck.launcher.stores.StoreLaunch.LAUNCHER)) return sidecar?.takeIf { it.id.isNotEmpty() }?.let { SessionPrefs.followStoreGame(context, "${it.store.id}:${it.id}", folder.path) { old -> !File(old).exists() } } val ranking = rank(folder, reuse) val candidates = ranking.exes @@ -433,6 +434,7 @@ object AddedGames { val autoName = sidecar?.title ?: identifiedName(folder, found) ?: folder.name val crc = CRC32().apply { update(("\"${foundGuest.replaceFirst(Regex("^$LIBRARY/"), "$LEGACY_LIBRARY/")}\"" + autoName).toByteArray()) }.value val appId = SessionPrefs.addedGameAppId(context, folder.path, crc or 0x80000000L) + if (sidecar?.store == Store.ROCKSTAR) com.droiddeck.launcher.stores.rockstar.RockstarLaunch.applyDefaults(context, sidecar.id, appId) val config = accountConfig(SessionPrefs.activeSteamRoot(context)) val record = config?.let { shortcutRecord(it, appId) } val rev = record?.optInt("rev", 0) ?: 0 diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 8c5e7431b1..13348cef74 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -70,6 +70,8 @@ object SessionFiles { GameEnvironmentStore.publish(context) WinComponents.publish(context) val files = arrayOf( + "rockstar/helpers/Launcher32.exe" to "usr/local/lib/droiddeck-rockstar/Launcher32.exe", + "rockstar/helpers/Launcher64.exe" to "usr/local/lib/droiddeck-rockstar/Launcher64.exe", "usr/local/bin/droiddeck-game-env" to "usr/local/bin/droiddeck-game-env", "usr/local/bin/droiddeck-game-gpu" to "usr/local/bin/droiddeck-game-gpu", "usr/local/bin/droiddeck-diagnostic-inventory" to "usr/local/bin/droiddeck-diagnostic-inventory", @@ -241,7 +243,7 @@ object SessionFiles { var installed = false try { target.parentFile?.mkdirs() - context.assets.open("linuxfs/$asset").use { input -> + (if (asset.startsWith("rockstar/")) requireNotNull(javaClass.getResourceAsStream("/$asset")) else context.assets.open("linuxfs/$asset")).use { input -> staged.outputStream().use { output -> FileUtils.copy(input, output) } } installed = staged.setExecutable(true, false) && staged.renameTo(target) diff --git a/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt b/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt index f68ab0ce62..106719d559 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/CloudSaves.kt @@ -87,7 +87,7 @@ object CloudSaves { val item = sidecar.extra["catalogItemId"].orEmpty() if (ns.isEmpty() || item.isEmpty()) "" else EpicApiClient.getCustomAttribute(token, ns, item, "CloudSaveFolder") } - Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.EA, Store.UBISOFT -> "" + Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.EA, Store.UBISOFT, Store.ROCKSTAR -> "" } ?: return null p.edit() .putString("cloud_template_$id", fetched.ifEmpty { TEMPLATE_NONE }) @@ -148,7 +148,7 @@ object CloudSaves { val dir = when (store) { Store.GOG -> CloudSavePaths.gog(template, pfx, folder) Store.EPIC -> CloudSavePaths.epic(template, pfx, folder, EpicCredentialStore.load(context)?.accountId.orEmpty(), id) - Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.EA, Store.UBISOFT -> null + Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.EA, Store.UBISOFT, Store.ROCKSTAR -> null } return dir to (if (dir == null) "unresolved" else "ok") } @@ -173,7 +173,7 @@ object CloudSaves { val account = EpicCredentialStore.load(context)?.accountId.orEmpty() if (token == null || account.isEmpty()) null else EpicCloud(account, id, token) } - Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.EA, Store.UBISOFT -> null + Store.AMAZON, Store.ITCH, Store.GAMEJOLT, Store.XBOX, Store.BATTLENET, Store.EA, Store.UBISOFT, Store.ROCKSTAR -> null } private fun gogScopedToken(context: Context, id: String, clientId: String): String? { diff --git a/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt b/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt index 980f496b26..a1b54088eb 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/LoginFlows.kt @@ -15,6 +15,7 @@ internal object LoginFlows { Store.GAMEJOLT -> gameJoltFlow(browserUserAgent) Store.UBISOFT -> ubisoftFlow(browserUserAgent) Store.EA -> eaFlow(browserUserAgent) + Store.ROCKSTAR -> rockstarFlow(browserUserAgent) Store.ITCH, Store.XBOX, Store.BATTLENET -> null } @@ -22,6 +23,7 @@ internal object LoginFlows { @Volatile var amazonFlow: () -> StoreLoginActivity.Flow? = { null } @Volatile var ubisoftFlow: (String) -> StoreLoginActivity.Flow? = { null } @Volatile var eaFlow: (String) -> StoreLoginActivity.Flow? = { null } + @Volatile var rockstarFlow: (String) -> StoreLoginActivity.Flow? = { null } @Volatile var gameJoltFlow: (String) -> StoreLoginActivity.Flow? = { null } private class GogFlow(private val state: String, override val userAgent: String) : StoreLoginActivity.Flow { diff --git a/app/src/main/java/com/droiddeck/launcher/stores/Store.kt b/app/src/main/java/com/droiddeck/launcher/stores/Store.kt index b8a6e8931e..b48530fbea 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/Store.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/Store.kt @@ -9,7 +9,8 @@ enum class Store(val id: String, val label: String, val shortLabel: String) { GAMEJOLT("gamejolt", "Game Jolt", "Game Jolt"), BATTLENET("battlenet", "Battle.net", "Battle.net"), UBISOFT("ubisoft", "Ubisoft Connect", "Ubisoft"), - EA("ea", "EA", "EA"); + EA("ea", "EA", "EA"), + ROCKSTAR("rockstar", "Rockstar Games", "Rockstar"); val folder: String get() = if (this == ITCH) "itch" else shortLabel diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt index 5de9b5e1ab..5e30fb7a5d 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreAccounts.kt @@ -67,8 +67,8 @@ object StoreAccounts { fun write(context: Context, store: Store, json: JSONObject) { unavailable.remove(store) val f = credentialsFile(context, store) - if (seal(f, json, retry = store == Store.XBOX) == null) { - check(store != Store.XBOX) { "Android Keystore is unavailable for Xbox credentials" } + if (seal(f, json, retry = store == Store.XBOX || store == Store.ROCKSTAR) == null) { + check(store != Store.XBOX && store != Store.ROCKSTAR) { "Android Keystore is unavailable for ${store.label} credentials" } put(f, json.toString()) } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunch.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunch.kt index 222b53702e..37d731a2f7 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunch.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunch.kt @@ -18,8 +18,13 @@ object StoreLaunch { const val EA_ORIGIN = "C:\\Program Files (x86)\\Origin\\Origin.exe" fun writeLauncher(folder: File, sidecar: StoreGameSidecar): StoreGameSidecar { - val needs = sidecar.args.isNotEmpty() || sidecar.env.isNotEmpty() || sidecar.store == Store.EPIC || sidecar.store == Store.EA || sidecar.store == Store.UBISOFT + val needs = sidecar.args.isNotEmpty() || sidecar.env.isNotEmpty() || sidecar.store == Store.EPIC || sidecar.store == Store.EA || sidecar.store == Store.UBISOFT || sidecar.store == Store.ROCKSTAR val file = File(folder, LAUNCHER) + if (sidecar.store == Store.ROCKSTAR && java.nio.file.Files.isSymbolicLink(file.toPath())) return sidecar.copy(launcher = null) + if (sidecar.store == Store.ROCKSTAR && !com.droiddeck.launcher.stores.rockstar.RockstarLaunch.supports(sidecar.id)) { + file.delete() + return sidecar.copy(launcher = null) + } if (!needs) { file.delete(); return sidecar.copy(launcher = null) } file.writeText(launcherText(sidecar)) return sidecar.copy(launcher = LAUNCHER) @@ -32,7 +37,7 @@ object StoreLaunch { val lines = ArrayList() lines += "@echo off" lines += "setlocal" - lines += "rem Written by DroidDeck for ${sidecar.store.label}: ${sidecar.title}. Steam's shortcut runs this file." + if (sidecar.store != Store.ROCKSTAR) lines += "rem Written by DroidDeck for ${sidecar.store.label}: ${sidecar.title}. Steam's shortcut runs this file." lines += "cd /d \"%~dp0$dir\"" for ((k, v) in sidecar.env) if (ENV_NAME.matches(k)) lines += "set \"$k=${v.replace("\"", "")}\"" val args = sidecar.args.joinToString(" ") { quoteArg(it) } @@ -54,6 +59,9 @@ object StoreLaunch { lines += "del \"%~dp0$EPIC_ARGS\"" lines += "if exist \"%~dp0$EPIC_CODE\" del \"%~dp0$EPIC_CODE\"" lines += "set \"$CLIENT_VAR=\" & \"%~dp0$exe\" %$CLIENT_VAR%" + } else if (sidecar.store == Store.ROCKSTAR) { + lines += "\"C:\\Program Files\\Rockstar Games\\Launcher\\Launcher.exe\"" + lines += "exit /b %errorlevel%" } else if (sidecar.store == Store.UBISOFT) { lines += "if not exist \"%~dp0$UBISOFT_LAUNCH\" goto direct" lines += "if not exist \"$UBISOFT_SERVICE\" goto direct" @@ -93,11 +101,12 @@ object StoreLaunch { return Library.addedGame(context, game) } - /** Gives a Ubisoft game installed before it needed one the launcher that starts the launcher service. */ fun adopt(folder: File, sidecar: StoreGameSidecar): StoreGameSidecar { - if (sidecar.store != Store.UBISOFT || !sidecar.isInstalled) return sidecar + if (sidecar.store !in listOf(Store.UBISOFT, Store.ROCKSTAR) || !sidecar.isInstalled) return sidecar + if (sidecar.store == Store.ROCKSTAR && !com.droiddeck.launcher.stores.rockstar.RockstarLaunch.supports(sidecar.id)) return sidecar + if (sidecar.store == Store.ROCKSTAR && java.nio.file.Files.isSymbolicLink(File(folder, LAUNCHER).toPath())) return sidecar.copy(launcher = null) val wrongExe = !sidecar.exeFile(folder).isFile || sidecar.exe.contains("installer", ignoreCase = true) || sidecar.exe.contains("autorun", ignoreCase = true) - if (sidecar.launcher == LAUNCHER && !wrongExe) return sidecar + if (sidecar.store == Store.UBISOFT && sidecar.launcher == LAUNCHER && !wrongExe) return sidecar val exe = if (wrongExe) StoreExe.pick(folder, null, sidecar.title).ifEmpty { sidecar.exe } else sidecar.exe if (exe == sidecar.exe && sidecar.launcher == LAUNCHER && runCatching { File(folder, LAUNCHER).readText() }.getOrNull() == launcherText(sidecar)) return sidecar diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt index 18f5a161e3..c89ada3f93 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreLaunchRequests.kt @@ -76,6 +76,14 @@ object StoreLaunchRequests { JSONObject().put("ok", true).put("code", code.written).put("reason", code.reason) } } + "rockstar-launch" -> runCatching { + lastLaunched = Store.ROCKSTAR to request.optString("id") + com.droiddeck.launcher.stores.rockstar.RockstarLaunch.prepare(app, request.optString("id")) + }.getOrElse { JSONObject().put("ok", false).put("reason", "error-" + it.javaClass.simpleName) } + "rockstar-exited" -> { + if (lastLaunched == (Store.ROCKSTAR to request.optString("id"))) lastLaunched = null + JSONObject().put("ok", true) + } "ubisoft-launch" -> { val id = request.optString("id") if (id.isEmpty()) JSONObject().put("ok", false).put("reason", "no-id") diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreLoginActivity.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreLoginActivity.kt index a07e0be855..54571ab172 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreLoginActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreLoginActivity.kt @@ -66,6 +66,7 @@ class StoreLoginActivity : ComponentActivity() { val pageScript: String get() = "(function(){ try { return document.body.innerText; } catch(e){ return ''; } })()" fun pageReady(result: String): Boolean = true fun forgetSignIn(done: () -> Unit) = done() + fun pageFinished(view: WebView, url: String) {} } private var store: Store? = null @@ -283,6 +284,7 @@ class StoreLoginActivity : ComponentActivity() { } override fun onPageFinished(view: WebView?, url: String?) { + if (!isPopup && url != null && view != null) flow?.pageFinished(view, url) if (url != null && view != null && flow?.readsPage == true && flow?.isRedirect(url) == true) complete(view, url) } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt b/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt index b102c8114c..21969dfbe7 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/StoreSizes.kt @@ -56,7 +56,7 @@ object StoreSizes { Store.AMAZON -> AmazonPrefs.get(app).edit().putLong("size_${item.id}", it).apply() Store.ITCH, Store.GAMEJOLT -> {} Store.EA -> com.droiddeck.launcher.stores.ea.EaPrefs.get(app).edit().putLong("size_${item.id}", it).apply() - Store.GOG, Store.XBOX, Store.BATTLENET, Store.UBISOFT -> {} + Store.GOG, Store.XBOX, Store.BATTLENET, Store.UBISOFT, Store.ROCKSTAR -> {} } } }, pool).exceptionally { error -> @@ -132,7 +132,7 @@ object StoreSizes { AmazonManifest.parse(bytes).totalInstallSize } Store.EA -> com.droiddeck.launcher.stores.ea.EaSizes.size(context, item) - Store.GOG, Store.XBOX, Store.BATTLENET, Store.UBISOFT -> 0L + Store.GOG, Store.XBOX, Store.BATTLENET, Store.UBISOFT, Store.ROCKSTAR -> 0L Store.ITCH -> com.droiddeck.launcher.stores.itch.ItchLibrary.size(context, item) Store.GAMEJOLT -> com.droiddeck.launcher.stores.gamejolt.GameJoltBuilds.size(context, item) } } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarAuth.kt b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarAuth.kt new file mode 100644 index 0000000000..781eddbe3f --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarAuth.kt @@ -0,0 +1,198 @@ +package com.droiddeck.launcher.stores.rockstar + +import android.content.Context +import android.os.Build +import android.util.Log +import android.webkit.CookieManager +import com.droiddeck.launcher.stores.Store +import com.droiddeck.launcher.stores.StoreAccounts +import org.json.JSONObject +import java.net.HttpURLConnection +import java.net.URL +import java.net.URLEncoder +import java.security.SecureRandom + +object RockstarAuth { + private const val TAG = "RockstarAuth" + const val SIGN_IN_HOST = "https://signin.rockstargames.com" + private const val LAUNCHER_SITE = "https://rgl.rockstargames.com" + private const val GATEWAY = "$LAUNCHER_SITE/api/connect/gateway" + + const val START_URL = "$SIGN_IN_HOST/robots.txt" + + const val CODE_URL = "$SIGN_IN_HOST/droiddeck/auth-code" + val SIGN_IN_URLS = listOf(SIGN_IN_HOST, LAUNCHER_SITE, "https://www.rockstargames.com", "https://socialclub.rockstargames.com") + const val COOKIE_DOMAIN = ".rockstargames.com" + + const val USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36" + private const val PREFS = "stores.rockstar" + private const val TICKET_MARGIN_MS = 15 * 60 * 1000L + private val lock = Any() + + class Ticket(val ticket: String, val sessionKey: String, val sessionTicket: String, val rockstarId: String, val nickname: String, val expiresAt: Long) + + internal fun fingerprint(context: Context): JSONObject { + val p = context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE) + fun stable(key: String, bytes: Int): String = p.getString(key, null) ?: ByteArray(bytes).also { SecureRandom().nextBytes(it) } + .joinToString("") { "%02x".format(it) }.also { p.edit().putString(key, it).apply() } + val device = "DROIDDECK-" + (Build.MODEL ?: "ANDROID").uppercase().replace(Regex("[^A-Z0-9]"), "").take(12) + return fingerprintOf(device, stable("volume_serial", 4), stable("cpu_info", 8)) + } + + internal fun fingerprintOf(device: String, volume: String, cpu: String): JSONObject = JSONObject() + .put("device_name", device) + .put("machine_name", device) + .put("os_version", "10.0.19045") + .put("volume_serial", volume) + .put("cpu_info", cpu) + + internal fun state(fingerprint: JSONObject) = "{\"fp\": $fingerprint}" + + internal fun bridgeScript(fingerprint: JSONObject, title: String, codeUrl: String = CODE_URL): String = """ +(function(){ + if (window.__droiddeckRgsc) return 'again'; + window.__droiddeckRgsc = true; + var fp = $fingerprint, title = ${JSONObject.quote(title)}, back = ${JSONObject.quote(codeUrl)}, seq = 0; + function later(cb, v){ setTimeout(function(){ try { if (cb) cb(v); } catch (e) {} }, 0); } + var answers = { + GetWindowConfig: { serviceInfo: { rosPlatform: 'pc' }, platformInfo: {} }, + GetDeviceId: { fingerprintKvp: fp }, + GetVersionInfo: { isDebugSdk: false }, + GetProfileList: { profiles: [] }, + GetCommandLineArguments: { arguments: [] } + }; + window.rgscQueryCancel = function(){}; + window.rgscQuery = function(q){ + q = q || {}; + var p = q.params || {}; + if (q.method === 'CallAuthResult' && p.authCode) { + later(q.onSuccess, {}); + setTimeout(function(){ location.replace(back + '?code=' + encodeURIComponent(p.authCode)); }, 50); + } else if ((q.method === 'CallAuthResult' && p.result === 3) || (q.method === 'CallSetWindowState' && p.state === 3)) { + later(q.onSuccess, {}); + setTimeout(function(){ location.replace(back + '?cancel=1'); }, 50); + } else if (q.method === 'CallLaunchExternalBrowser' && p.url) { + window.open(p.url, '_blank'); + later(q.onSuccess, {}); + } else { + later(q.onSuccess, Object.prototype.hasOwnProperty.call(answers, q.method) ? answers[q.method] : {}); + } + return ++seq; + }; + window.rgscAddSubscription = function(s){ + s = s || {}; + if (s.method === 'OnStartAuth') later(s.onSuccess, { launchPlatform: 0, titleLaunchInfo: { activeTitleName: title, externalPlatformInfo: {} }, profile: null, errorMessage: null }); + return ++seq; + }; + var form = '/signin/user-form?cid=launcher&lang=en-US'; + fetch(form, { credentials: 'include' }) + .then(function(r){ return r.text(); }) + .then(function(h){ + history.replaceState(null, '', form); document.open(); document.write(h); document.close(); + var css = document.createElement('style'); + css.textContent = '[data-ui-name="launcherSettings"]{display:none!important}'; + (document.head || document.documentElement).appendChild(css); + }); + return 'ok'; +})() +""".trimIndent() + + fun isCodeUrl(url: String) = url.startsWith(CODE_URL) + + internal fun cancelled(url: String): Boolean = android.net.Uri.parse(url).getQueryParameter("cancel") == "1" + + internal fun codeFrom(url: String): String? = android.net.Uri.parse(url).getQueryParameter("code")?.takeIf { it.isNotBlank() } + + fun completeSignIn(context: Context, url: String): String? { + val code = codeFrom(url) ?: return "no auth code" + val fp = fingerprint(context) + val gateway = "$GATEWAY?code=" + URLEncoder.encode(code, "UTF-8") + "&fingerprint=" + URLEncoder.encode(state(fp), "UTF-8") + val c = URL(gateway).openConnection() as HttpURLConnection + c.connectTimeout = 20_000 + c.readTimeout = 25_000 + c.instanceFollowRedirects = false + c.setRequestProperty("User-Agent", USER_AGENT) + c.setRequestProperty("Accept", "application/json") + c.setRequestProperty("X-Requested-With", "XMLHttpRequest") + c.setRequestProperty("Origin", LAUNCHER_SITE) + c.setRequestProperty("Referer", "$LAUNCHER_SITE/") + runCatching { CookieManager.getInstance().getCookie(LAUNCHER_SITE) }.getOrNull()?.takeIf { it.isNotEmpty() }?.let { c.setRequestProperty("Cookie", it) } + val (status, body) = try { + val s = c.responseCode + s to ((if (s in 200..299) c.inputStream else c.errorStream)?.use { it.readBytes().toString(Charsets.UTF_8) }.orEmpty()) + } finally { + c.disconnect() + } + val o = runCatching { JSONObject(body) }.getOrNull() + val token = o?.optString("ScAuthToken")?.takeIf { it.isNotEmpty() && it != "null" } + if (token == null) { + Log.w(TAG, "gateway $status; fields ${o?.keys()?.asSequence()?.toList() ?: "not json"}") + return "gateway $status" + } + val account = JSONObject() + .put("access_token", token) + .put("remembered_machine_token", o.optString("RememberedMachineToken").takeIf { it != "null" }.orEmpty()) + .put("login_guid", o.optString("LoginGuid").takeIf { it != "null" }.orEmpty()) + .put("display_name", "Rockstar Games") + .put("signed_in_at", System.currentTimeMillis()) + StoreAccounts.write(context.applicationContext, Store.ROCKSTAR, account) + val t = runCatching { mint(context) }.onFailure { Log.w(TAG, "first ticket: ${it.message}") }.getOrNull() + if (t == null) { + StoreAccounts.clear(context.applicationContext, Store.ROCKSTAR) + return "ticket" + } + return null + } + + fun ticket(context: Context, fresh: Boolean = false): Ticket? = synchronized(lock) { + val o = StoreAccounts.read(context.applicationContext, Store.ROCKSTAR) ?: return null + if (!fresh) { + val current = stored(o) + if (com.droiddeck.launcher.session.SessionState.running && + com.droiddeck.launcher.stores.StoreLaunchRequests.lastLaunched?.first == Store.ROCKSTAR) { + return current?.takeIf { it.expiresAt > System.currentTimeMillis() } + } + current?.takeIf { it.expiresAt - System.currentTimeMillis() > TICKET_MARGIN_MS }?.let { return it } + } + runCatching { mint(context) }.onFailure { Log.w(TAG, "ticket: ${it.message}") }.getOrNull() + } + + private fun stored(o: JSONObject): Ticket? { + val t = o.optString("ticket").takeIf { it.isNotEmpty() } ?: return null + return Ticket(t, o.optString("session_key"), o.optString("session_ticket"), o.optString("rockstar_id"), o.optString("display_name"), o.optLong("ticket_expires_at")) + } + + private fun mint(context: Context): Ticket { + val app = context.applicationContext + val o = StoreAccounts.read(app, Store.ROCKSTAR) ?: throw IllegalStateException("not signed in") + val root = try { + RockstarRos.result("auth.asmx/CreateTicketScAuthToken2", listOf( + "ticket" to "", "platformName" to "pcros", "scAuthToken" to o.optString("access_token"), + "rememberedMachineToken" to o.optString("remembered_machine_token"), + ), headers = mapOf("SCS-MFAMachineFingerPrint" to state(fingerprint(app)))) + } catch (e: RockstarRos.RosException) { + if (e.code.startsWith("AuthenticationFailed")) com.droiddeck.launcher.stores.StoresState.markSignInExpired(Store.ROCKSTAR) + throw e + } + val t = parseTicket(root) ?: throw IllegalStateException("no ticket in the answer") + o.put("ticket", t.ticket).put("session_key", t.sessionKey).put("session_ticket", t.sessionTicket) + .put("rockstar_id", t.rockstarId).put("ticket_expires_at", t.expiresAt) + if (t.nickname.isNotEmpty()) o.put("display_name", t.nickname) + StoreAccounts.write(app, Store.ROCKSTAR, o) + return t + } + + internal fun parseTicket(root: org.w3c.dom.Element, now: Long = System.currentTimeMillis()): Ticket? { + val ticket = RockstarRos.text(root, "Ticket")?.takeIf { it.isNotEmpty() } ?: return null + val account = RockstarRos.first(root, "RockstarAccount") + val secs = RockstarRos.text(root, "SecsUntilExpiration")?.toLongOrNull() ?: 3600L + return Ticket( + ticket, RockstarRos.text(root, "SessionKey").orEmpty(), RockstarRos.text(root, "SessionTicket").orEmpty(), + (account?.let { RockstarRos.text(it, "RockstarId") } ?: RockstarRos.text(root, "RockstarId")).orEmpty(), + account?.let { RockstarRos.text(it, "Nickname") }.orEmpty(), + now + secs * 1000L, + ) + } + + fun signOut(context: Context) = synchronized(lock) { StoreAccounts.clear(context.applicationContext, Store.ROCKSTAR) } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarBackend.kt b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarBackend.kt new file mode 100644 index 0000000000..3e878d3290 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarBackend.kt @@ -0,0 +1,206 @@ +package com.droiddeck.launcher.stores.rockstar + +import android.content.Context +import android.content.Intent +import android.util.Log +import android.webkit.WebView +import com.droiddeck.launcher.R +import com.droiddeck.launcher.stores.CatalogItem +import com.droiddeck.launcher.stores.InstalledStoreGame +import com.droiddeck.launcher.stores.LoginFlows +import com.droiddeck.launcher.stores.Store +import com.droiddeck.launcher.stores.StoreBackend +import com.droiddeck.launcher.stores.StoreFront +import com.droiddeck.launcher.stores.StoreInstallRoot +import com.droiddeck.launcher.stores.StoreLoginActivity +import com.droiddeck.launcher.stores.StoreShelves +import com.droiddeck.launcher.stores.StoresState +import com.droiddeck.launcher.stores.WebCookies +import com.droiddeck.launcher.stores.download.DownloadEntry +import com.droiddeck.launcher.stores.download.DownloadQueue +import org.w3c.dom.Element + +object RockstarBackend : StoreBackend { + override val store: Store = Store.ROCKSTAR + + init { + LoginFlows.rockstarFlow = { ua -> RockstarLogin(ua) } + } + + override fun signIn(context: Context) { + context.startActivity( + Intent(context, StoreLoginActivity::class.java) + .putExtra(StoreLoginActivity.EXTRA_STORE, store.id) + .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK), + ) + } + + override fun signOut(context: Context) { + RockstarAuth.signOut(context.applicationContext) + RockstarLibrary.reset() + runCatching { WebCookies.expire(RockstarAuth.SIGN_IN_URLS, RockstarAuth.COOKIE_DOMAIN, listOf("/")) {} } + } + + override fun syncLibrary(context: Context, force: Boolean) { + val app = context.applicationContext + Thread({ RockstarLibrary.sync(app) }, "rockstar-sync").start() + } + + override fun loadShelves(context: Context, force: Boolean) { + StoresState.post { StoresState.shelves[store] = StoreFront.markOwned(RockstarCatalog.shelves(), StoresState.library[store], RockstarCatalog::sameGame) } + } + + override fun search(context: Context, query: String): List = + StoreFront.markOwned(RockstarCatalog.search(query), StoresState.library[store], RockstarCatalog::sameGame) + + override fun install(context: Context, item: CatalogItem, root: java.io.File) { + val app = context.applicationContext + val folder = StoreInstallRoot.folderFor(app, store, item.id, item.title, root) + val entry = DownloadEntry(store, item.id, item.title, cover = item.tallImageUrl ?: item.imageUrl, + bytesTotal = item.sizeBytes, location = StoreInstallRoot.labelFor(app, folder)) + DownloadQueue.enqueue(app, entry) { RockstarInstaller(app, item, folder) } + } + + override fun uninstall(context: Context, game: InstalledStoreGame) {} +} + +internal class RockstarLogin(override val userAgent: String) : StoreLoginActivity.Flow { + override val startUrl: String get() = RockstarAuth.START_URL + override fun isRedirect(url: String): Boolean = RockstarAuth.isCodeUrl(url) + + override fun pageFinished(view: WebView, url: String) { + if (!url.startsWith(RockstarAuth.START_URL)) return + val title = "launcher" + view.evaluateJavascript(RockstarAuth.bridgeScript(RockstarAuth.fingerprint(view.context), title)) { Log.d("RockstarLogin", "bridge: $it") } + } + + override fun forgetSignIn(done: () -> Unit) { + runCatching { WebCookies.expire(RockstarAuth.SIGN_IN_URLS, RockstarAuth.COOKIE_DOMAIN, listOf("/")) { done() } }.onFailure { done() } + } + + override fun finish(activity: StoreLoginActivity, view: WebView, url: String): String? = if (RockstarAuth.cancelled(url)) null else try { + RockstarAuth.completeSignIn(activity, url)?.let { + Log.w("RockstarLogin", "sign-in incomplete: $it") + activity.getString(R.string.stores_login_error_verification) + } + } catch (e: Exception) { + Log.w("RockstarLogin", "sign-in failed: ${e.javaClass.simpleName}") + activity.getString(R.string.stores_login_error_generic) + } +} + +internal data class RockstarApp(val id: String, val name: String, val titleId: String, val branches: List, val parent: String = "") + +internal data class RockstarBranch(val id: String, val name: String, val buildId: String, val isDefault: Boolean, val accessToken: String) { + val hasBuild: Boolean get() = (buildId.toLongOrNull() ?: 0L) > 0 && accessToken.isNotEmpty() +} + +internal data class RockstarPackage(val title: String, val featured: Boolean) + +internal class RockstarAccountApps(val apps: List, val packages: List) + +internal object RockstarApps { + fun parse(root: Element): List = RockstarRos.all(root, "App").map { a -> + val branches = RockstarRos.first(a, "Branches")?.let { RockstarRos.children(it, "Branch") }.orEmpty().map { b -> + RockstarBranch(b.getAttribute("Id"), b.getAttribute("Name"), b.getAttribute("BuildId"), + b.getAttribute("IsDefault").equals("true", true), RockstarRos.text(b, "AccessToken").orEmpty()) + } + val parent = (a.parentNode?.parentNode as? Element)?.takeIf { it.tagName == "App" }?.getAttribute("Name").orEmpty() + RockstarApp(a.getAttribute("Id"), a.getAttribute("Name"), a.getAttribute("TitleId"), branches, parent) + } + + fun packages(root: Element): List = RockstarRos.all(root, "PackageJson").mapNotNull { p -> + val o = runCatching { org.json.JSONObject(p.textContent) }.getOrNull() ?: return@mapNotNull null + o.optString("title").takeIf { it.isNotEmpty() }?.let { RockstarPackage(it, o.optBoolean("isFeatured")) } + } + + fun fetch(ticket: String, log: (String) -> Unit): RockstarAccountApps { + val root = RockstarRos.result("app.asmx/GetAppsAndPackages", listOf("ticket" to ticket)) + val out = RockstarAccountApps(parse(root), packages(root)) + log("Rockstar: packages " + out.packages.joinToString(", ") { it.title + if (it.featured) " (featured)" else "" }.ifEmpty { "none" } + + "; builds " + out.apps.filter { a -> a.branches.any { it.hasBuild } }.joinToString(", ") { it.name }.ifEmpty { "none" }) + return out + } + + fun branch(app: RockstarApp): RockstarBranch? = app.branches.firstOrNull { it.isDefault && it.hasBuild } ?: app.branches.firstOrNull { it.hasBuild } + + fun deliverer(apps: List, title: RockstarTitle): RockstarApp? = apps + .filter { RockstarTitles.byId(it.name) == title && !it.name.endsWith("_steam") && !it.name.endsWith("_epic") } + .sortedBy { if (it.name == title.id) 0 else 1 } + .firstOrNull { branch(it) != null } +} + +object RockstarLibrary { + private val generation = java.util.concurrent.atomic.AtomicInteger() + private val running = java.util.concurrent.atomic.AtomicReference(null) + + fun reset() { + generation.incrementAndGet() + StoresState.post { + StoresState.library.remove(Store.ROCKSTAR) + StoresState.shelves.remove(Store.ROCKSTAR) + } + } + + private fun post(gen: Int, block: () -> Unit) = StoresState.post { if (generation.get() == gen) block() } + + internal fun owned(account: RockstarAccountApps): List = + account.packages.filter { !it.featured }.flatMap { RockstarTitles.forName(it.title) }.distinct() + + internal fun games(account: RockstarAccountApps): List = owned(account).mapNotNull { t -> + RockstarApps.deliverer(account.apps, t)?.let { RockstarTitles.item(t, owned = true, extra = mapOf("app" to it.name, "appId" to it.id)) } + }.sortedBy { it.title.lowercase() } + + fun sync(app: Context) { + val gen = generation.get() + if (running.getAndSet(gen) == gen) return + try { + val t = RockstarAuth.ticket(app) + if (t == null) { + post(gen) { StoresState.status.remove(Store.ROCKSTAR); StoresState.problems[Store.ROCKSTAR] = app.getString(R.string.stores_sync_sign_in) } + return + } + if (StoresState.library[Store.ROCKSTAR].isNullOrEmpty()) post(gen) { StoresState.status[Store.ROCKSTAR] = app.getString(R.string.stores_sync_game_list) } + val account = RockstarApps.fetch(t.ticket) { StoresState.logLine(it) } + val games = games(account) + owned(account).filter { o -> games.none { it.id == o.id } }.takeIf { it.isNotEmpty() }?.let { elsewhere -> + StoresState.logLine("Rockstar: owned through another store, installs from there: " + elsewhere.joinToString(", ") { it.name }) + } + post(gen) { + StoresState.status.remove(Store.ROCKSTAR) + StoresState.problems.remove(Store.ROCKSTAR) + StoresState.library[Store.ROCKSTAR] = games + StoresState.shelves[Store.ROCKSTAR]?.let { StoresState.shelves[Store.ROCKSTAR] = StoreFront.markOwned(it, games, RockstarCatalog::sameGame) } + } + StoresState.logLine("Rockstar: ${games.size} owned games") + } catch (e: Exception) { + StoresState.logLine("Rockstar: library sync failed: ${e.javaClass.simpleName} ${e.message.orEmpty().take(300)}") + post(gen) { StoresState.status.remove(Store.ROCKSTAR); StoresState.problems[Store.ROCKSTAR] = app.getString(R.string.stores_sync_failed) } + } finally { + running.compareAndSet(gen, null) + } + } +} + +internal object RockstarCatalog { + fun all(): List = RockstarTitles.all.map { RockstarTitles.item(it) } + + fun shelves(): StoreShelves { + val all = all() + val newest = all.sortedByDescending { it.releaseDate } + val headline = listOf("gta5_gen9", "rdr2", "rdr", "gta4", "gtasaunreal", "lanoire", "mp3") + return StoreShelves( + whatsNew = newest, + trending = headline.mapNotNull { id -> all.firstOrNull { it.id == id } } + all.filter { it.id !in headline }, + art = all.mapNotNull { it.imageUrl }, + ) + } + + fun search(query: String): List { + val q = StoreFront.titleKey(query) + if (q.length < 2) return emptyList() + return all().filter { StoreFront.titleKey(it.title).contains(q) } + } + + fun sameGame(shelf: CatalogItem, owned: CatalogItem): Boolean = shelf.id == owned.id +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarInstaller.kt b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarInstaller.kt new file mode 100644 index 0000000000..ac039d95f9 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarInstaller.kt @@ -0,0 +1,263 @@ +package com.droiddeck.launcher.stores.rockstar + +import android.content.Context +import com.droiddeck.launcher.R +import com.droiddeck.launcher.stores.CatalogItem +import com.droiddeck.launcher.stores.Store +import com.droiddeck.launcher.stores.StoreExe +import com.droiddeck.launcher.stores.StoreGameSidecar +import com.droiddeck.launcher.stores.StoreInstalls +import com.droiddeck.launcher.stores.download.DownloadQueue +import com.droiddeck.launcher.stores.download.DownloadStage +import org.w3c.dom.Element +import java.io.File +import java.io.RandomAccessFile +import java.net.HttpURLConnection +import java.net.URL +import java.nio.file.Files +import java.security.MessageDigest +import java.util.concurrent.ConcurrentLinkedQueue +import java.util.concurrent.Executors +import java.util.concurrent.TimeUnit +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicLong +import java.util.concurrent.atomic.AtomicReference + +internal data class RockstarChunk(val fileEntryId: String, val chunkId: String, val sha256: String, val offset: Long, val size: Long) + +internal data class RockstarFile(val entryId: String, val versionId: String, val path: String, val size: Long, val sha256: String, val chunks: List) + +internal data class RockstarBuild(val buildId: String, val version: String, val preload: Boolean, val files: List) { + val bytes: Long get() = files.sumOf { it.size } +} + +internal object RockstarManifest { + fun inside(root: File, relative: String): File { + require(safePath(relative) == relative) { "Unsafe Rockstar install path" } + val base = root.canonicalFile + var target = base + for (part in relative.split('/')) { + target = File(target, part) + require(!Files.isSymbolicLink(target.toPath())) { "Rockstar install path is a symbolic link" } + } + require(target.canonicalFile.toPath().startsWith(base.toPath())) { "Rockstar install path leaves its folder" } + return target + } + + fun verified(target: File, chunk: RockstarChunk, cancelled: () -> Boolean = { false }): Boolean { + if (cancelled()) return false + if (!target.isFile || chunk.offset < 0 || chunk.size < 0 || chunk.offset > target.length() || chunk.size > target.length() - chunk.offset) return false + return RandomAccessFile(target, "r").use { input -> + input.seek(chunk.offset) + val digest = MessageDigest.getInstance("SHA-256") + val buffer = ByteArray(256 * 1024) + var remaining = chunk.size + while (remaining > 0) { + if (cancelled()) return false + val count = input.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt()) + if (count <= 0) return false + digest.update(buffer, 0, count) + remaining -= count + } + digest.digest().joinToString("") { "%02x".format(it) }.equals(chunk.sha256, true) + } + } + + fun safePath(raw: String): String? { + val parts = raw.replace('\\', '/').split('/').filter { it.isNotEmpty() && it != "." } + if (parts.isEmpty() || parts.any { it == ".." || it.contains(':') }) return null + return parts.joinToString("/") + } + + fun parse(root: Element): RockstarBuild { + val result = RockstarRos.first(root, "Result") ?: throw IllegalStateException("manifest without a result") + val files = RockstarRos.all(result, "FileDetails").map { f -> + val entry = f.getAttribute("FileEntryId") + val path = safePath(RockstarRos.text(f, "RelativePath").orEmpty()) ?: throw IllegalStateException("unsafe path in the manifest") + val chunks = RockstarRos.first(f, "FileChunks")?.let { RockstarRos.children(it, "Chunk") }.orEmpty().map { c -> + RockstarChunk(entry, c.getAttribute("FileChunkId"), c.getAttribute("SHA256Hash").lowercase(), + c.getAttribute("StartByteOffset").toLong(), c.getAttribute("Size").toLong()) + } + val whole = RockstarRos.children(f, "SHA256Hash").firstOrNull()?.textContent?.trim()?.lowercase().orEmpty() + RockstarFile(entry, f.getAttribute("FileEntryVersionId"), path, f.getAttribute("FileSize").toLong(), whole, chunks) + } + return RockstarBuild(result.getAttribute("BuildId"), result.getAttribute("VersionNumber"), + RockstarRos.text(result, "IsPreload").equals("true", true), files) + } + + fun batches(chunks: List, maxBytes: Long = 48L * 1024 * 1024, maxCount: Int = 16): List> { + val out = ArrayList>() + var cur = ArrayList() + var bytes = 0L + for (c in chunks) { + if (cur.isNotEmpty() && (bytes + c.size > maxBytes || cur.size >= maxCount)) { out += cur; cur = ArrayList(); bytes = 0 } + cur += c + bytes += c.size + } + if (cur.isNotEmpty()) out += cur + return out + } + + fun key(file: RockstarFile, chunk: RockstarChunk) = "${file.versionId}:${chunk.chunkId}" +} + +internal class RockstarInstaller( + private val app: Context, + private val item: CatalogItem, + private val folder: File, +) : DownloadQueue.DownloadJob { + private val cancelled = AtomicBoolean(false) + + override fun run(handle: DownloadQueue.JobHandle): String? { + handle.stage(DownloadStage.MANIFEST, app.getString(R.string.stores_sync_sign_in)) + val ticket = RockstarAuth.ticket(app)?.ticket ?: throw IllegalStateException("Not signed in to Rockstar Games") + val title = RockstarTitles.byId(item.id) ?: throw IllegalStateException("Rockstar has no PC build of ${item.title}") + val account = RockstarApps.fetch(ticket) { handle.log(it) } + if (title !in RockstarLibrary.owned(account)) throw IllegalStateException("${item.title} is not in this Rockstar account's library") + val owned = RockstarApps.deliverer(account.apps, title) + ?: throw IllegalStateException("${item.title} is owned through another store and installs from there") + val branch = RockstarApps.branch(owned)!! + handle.log("rockstar: ${owned.name} branch ${branch.name} build ${branch.buildId}") + val build = RockstarManifest.parse(RockstarRos.result("app.asmx/GetBuildManifestFull", listOf("ticket" to ticket, "branchAccessToken" to branch.accessToken))) + if (build.preload) throw IllegalStateException("${item.title} is a preload Rockstar has not unlocked yet") + handle.log("rockstar: build ${build.buildId} ${build.version}, ${build.files.size} files, ${build.bytes} bytes") + handle.diskSize(build.bytes) + val cover = item.tallImageUrl ?: item.imageUrl + StoreInstalls.begin(folder, Store.ROCKSTAR, item.id, item.title, cover, item.imageUrl) + if (cancelled.get()) return null + + val ledger = RockstarManifest.inside(folder, LEDGER) + val done = HashSet().apply { if (ledger.isFile) ledger.readLines().filterTo(this) { it.isNotBlank() } } + val pending = ArrayList>() + var have = 0L + for (f in build.files) { + if (cancelled.get()) return null + val target = RockstarManifest.inside(folder, f.path) + target.parentFile?.mkdirs() + for (c in f.chunks) { + if (cancelled.get()) return null + if (RockstarManifest.key(f, c) in done && RockstarManifest.verified(target, c, cancelled::get)) have += c.size else pending += f to c + } + if (cancelled.get()) return null + RandomAccessFile(target, "rw").use { if (it.length() != f.size) it.setLength(f.size) } + } + val fileOf = pending.associate { (f, c) -> "${c.fileEntryId}:${c.chunkId}" to f } + val total = build.bytes + val progress = AtomicLong(have) + handle.stage(DownloadStage.DOWNLOAD) + handle.progress(have, total, "Downloading (${build.files.size} files)") + + val queue = ConcurrentLinkedQueue(RockstarManifest.batches(pending.map { it.second })) + val failure = AtomicReference(null) + val pool = Executors.newFixedThreadPool(WORKERS, DownloadQueue.workerFactory("rockstar-dl")) + val ledgerLock = Any() + repeat(WORKERS) { + pool.execute { + while (!cancelled.get() && failure.get() == null) { + val batch = queue.poll() ?: break + try { + val urls = chunkUrls(ticket, branch.accessToken, batch) + for (c in batch) { + if (cancelled.get()) break + val f = fileOf.getValue("${c.fileEntryId}:${c.chunkId}") + fetch({ retry -> (if (retry) null else urls[c.chunkId]) ?: chunkUrls(ticket, branch.accessToken, listOf(c)).getValue(c.chunkId) }, RockstarManifest.inside(folder, f.path), c, progress) { + handle.progress(progress.get(), total, "Downloading (${build.files.size} files)") + } + synchronized(ledgerLock) { ledger.appendText(RockstarManifest.key(f, c) + "\n") } + } + } catch (t: Throwable) { + failure.compareAndSet(null, t) + } + } + } + } + pool.shutdown() + while (!pool.awaitTermination(250, TimeUnit.MILLISECONDS)) Unit + if (cancelled.get()) return null + failure.get()?.let { throw it } + + handle.interruptible(false) + handle.stage(DownloadStage.INSTALL, app.getString(R.string.stores_registering)) + val exe = resolve(folder, title.exe) ?: StoreExe.pick(folder, null, item.title).ifEmpty { title.exe.replace('\\', '/') } + handle.log("rockstar: exe=$exe") + val sidecar = StoreGameSidecar( + Store.ROCKSTAR, item.id, item.title, exe = exe, + installVersion = build.version.ifEmpty { build.buildId }, installedAt = System.currentTimeMillis(), + cover = cover, hero = item.imageUrl, cloud = false, + extra = mapOf("rosTitleId" to title.rosTitleId.toString(), "app" to owned.name, "buildId" to build.buildId, "platform" to title.platform), + ) + StoreInstalls.complete(app, folder, sidecar, onStep = { d, steps -> handle.stageProgress(d.toLong(), steps.toLong()) }) + ledger.delete() + return folder.path + } + + private fun chunkUrls(ticket: String, branchToken: String, batch: List): Map { + val csv = batch.joinToString(",") { "${it.fileEntryId}:${it.chunkId}" } + val root = RockstarRos.result("app.asmx/RetrieveFileChunkMulti", listOf("ticket" to ticket, "branchAccessToken" to branchToken, "fileEntryAndChunkIdCsv" to csv)) + return RockstarRos.all(root, "Chunk").mapNotNull { c -> RockstarRos.text(c, "RedirectUrl")?.let { c.getAttribute("FileChunkId") to it } }.toMap() + } + + private fun fetch(url: (Boolean) -> String, target: File, chunk: RockstarChunk, progress: AtomicLong, report: () -> Unit) { + var lastError: Exception? = null + for (attempt in 0 until 3) { + if (cancelled.get()) return + val written = AtomicLong(0) + try { + val c = URL(url(attempt > 0)).openConnection() as HttpURLConnection + c.connectTimeout = 20_000 + c.readTimeout = 60_000 + try { + if (c.responseCode != 200) throw java.io.IOException("chunk ${chunk.chunkId}: HTTP ${c.responseCode}") + val digest = MessageDigest.getInstance("SHA-256") + RandomAccessFile(target, "rw").use { out -> + out.seek(chunk.offset) + c.inputStream.use { input -> + val buf = ByteArray(256 * 1024) + var last = 0L + while (true) { + if (cancelled.get()) { progress.addAndGet(-written.get()); return } + val n = input.read(buf) + if (n < 0) break + if (written.get() + n > chunk.size) throw java.io.IOException("chunk ${chunk.chunkId} is longer than the manifest says") + out.write(buf, 0, n) + digest.update(buf, 0, n) + written.addAndGet(n.toLong()) + progress.addAndGet(n.toLong()) + val now = System.currentTimeMillis() + if (now - last > 400) { last = now; report() } + } + } + } + val hex = digest.digest().joinToString("") { "%02x".format(it) } + if (written.get() != chunk.size || hex != chunk.sha256) throw java.io.IOException("chunk ${chunk.chunkId} failed its check") + report() + return + } finally { + c.disconnect() + } + } catch (e: Exception) { + progress.addAndGet(-written.get()) + lastError = e + } + } + throw lastError ?: java.io.IOException("chunk ${chunk.chunkId} failed") + } + + override fun cancel(deleteFiles: Boolean) { + cancelled.set(true) + if (deleteFiles) StoreInstalls.discard(app, folder, emptyList()) + } + + internal companion object { + const val LEDGER = ".droiddeck-rockstar-chunks" + private const val WORKERS = 4 + + fun resolve(folder: File, configured: String): String? { + var at = folder + for (part in configured.replace('\\', '/').split('/').filter { it.isNotEmpty() }) { + at = at.listFiles()?.firstOrNull { it.name.equals(part, ignoreCase = true) } ?: return null + } + return if (at.isFile) at.relativeTo(folder).invariantSeparatorsPath else null + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunch.kt b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunch.kt new file mode 100644 index 0000000000..c83b6548d8 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunch.kt @@ -0,0 +1,56 @@ +package com.droiddeck.launcher.stores.rockstar + +import android.content.Context +import com.droiddeck.launcher.session.GameEnvironmentStore +import com.droiddeck.launcher.stores.Store +import com.droiddeck.launcher.stores.StoreGameSidecar +import com.droiddeck.launcher.stores.StoreInstallRoot +import org.json.JSONObject +import java.security.MessageDigest +import java.util.Base64 + +object RockstarLaunch { + internal val pipes = mapOf("gta3" to "GTA3_Pipe", "gtavc" to "GTA-VC_Pipe", "gtasa" to "GTA_SA_Pipe") + + fun supports(id: String?) = id != null && id in pipes + + fun applyDefaults(app: Context, id: String, appId: Long) { + val scope = (appId and 0xffffffffL).toString() + when (id) { + "gta3" -> GameEnvironmentStore.setDefault(app, scope, "FEX_X87REDUCEDPRECISION", "0") + "gtasa" -> GameEnvironmentStore.setDefault(app, scope, "PROTON_USE_WINED3D", "1") + } + } + + fun prepare(app: Context, id: String): JSONObject { + val pipe = pipes[id] ?: return failure("unsupported-title") + val title = RockstarTitles.byId(id) ?: return failure("unknown-title") + val folder = StoreInstallRoot.gameFolders(app).firstOrNull { folder -> + StoreGameSidecar.read(folder)?.let { it.store == Store.ROCKSTAR && it.id == id && it.isInstalled } == true + } ?: return failure("not-installed") + val installed = StoreGameSidecar.read(folder) ?: return failure("not-installed") + val exe = installed.exeFile(folder).canonicalFile + if (!exe.path.startsWith(folder.canonicalPath + java.io.File.separator) || !exe.isFile || + !java.io.File(folder, "MTLX.dll").isFile) return failure("missing-game-files") + var ticket = RockstarAuth.ticket(app) ?: RockstarAuth.ticket(app, fresh = true) ?: return failure("signed-out") + val account = try { + RockstarApps.fetch(ticket.ticket) {} + } catch (e: RockstarRos.RosException) { + if (!(e.code.contains("Ticket", true) || e.code.contains("Sign", true) || e.code.contains("Auth", true))) throw e + ticket = RockstarAuth.ticket(app, fresh = true) ?: return failure("signed-out") + RockstarApps.fetch(ticket.ticket) {} + } + if (RockstarLibrary.owned(account).none { it.id == id } || RockstarApps.deliverer(account.apps, title) == null) return failure("not-owned") + val tokenRoot = RockstarRos.result("app.asmx/GetTitleAccessToken2", listOf("ticket" to ticket.ticket, "titleId" to title.rosTitleId.toString(), "platformId" to "8")) + val token = RockstarRos.text(tokenRoot, "Result")?.takeIf { it.isNotEmpty() } ?: return failure("no-title-token") + val hash = MessageDigest.getInstance("SHA-256").digest(RockstarAuth.fingerprint(app).toString().toByteArray()).copyOf(16) + val launch = RockstarRos.result("app.asmx/GetTitleLaunchData", listOf("ticket" to ticket.ticket, "titleAccessToken" to token, + "machineHash" to Base64.getEncoder().encodeToString(hash))) + val encoded = RockstarRos.text(launch, "Data") ?: return failure("no-launch-data") + val iv = RockstarRos.text(launch, "EndpointIV") ?: return failure("no-launch-iv") + val material = RockstarLaunchCipher.decode(encoded, iv) + return JSONObject().put("ok", true).put("pipe", pipe).put("material", material).put("expiresAt", System.currentTimeMillis() + 90_000) + } + + private fun failure(reason: String) = JSONObject().put("ok", false).put("reason", reason) +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunchCipher.kt b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunchCipher.kt new file mode 100644 index 0000000000..dd65b40b7c --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunchCipher.kt @@ -0,0 +1,66 @@ +package com.droiddeck.launcher.stores.rockstar + +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.util.Base64 + +internal object RockstarLaunchCipher { + private val data by lazy { + val bytes = requireNotNull(javaClass.getResourceAsStream("/rockstar/legacy-cipher.bin")).use { it.readBytes() } + require(bytes.size == 86852 && bytes.copyOfRange(0, 8).contentEquals("DDRGLC01".toByteArray())) + bytes + } + private val tables by lazy { + ByteBuffer.wrap(data, 8, 86016).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().let { buffer -> IntArray(buffer.remaining()).also { buffer.get(it) } } + } + private val order = intArrayOf(0, 7, 10, 13, 1, 4, 11, 14, 2, 5, 8, 15, 3, 6, 9, 12) + + internal fun decrypt(cipher: ByteArray, iv: ByteArray, inner: Boolean): ByteArray { + require(cipher.isNotEmpty() && cipher.size <= 65536 && cipher.size % 16 == 0 && iv.size == 16) + val map = 86024 + val key = map + 272 + if (inner) 272 else 0 + val keys = ByteBuffer.wrap(data, key, 272).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().let { buffer -> IntArray(68).also { buffer.get(it) } } + val output = ByteArray(cipher.size) + var previous = iv + for (offset in cipher.indices step 16) { + var state = cipher.copyOfRange(offset, offset + 16) + for (round in 0..16) { + val next = ByteBuffer.allocate(16).order(ByteOrder.LITTLE_ENDIAN) + for (column in 0..3) { + var word = keys[round * 4 + column] + for (slot in column * 4 until column * 4 + 4) { + val index = if (round == 0 || round == 1 || round == 16) slot else order[slot] + val table = data[map + round * 16 + index].toInt() and 255 + require(table < 84) + word = word xor tables[table * 256 + (state[index].toInt() and 255)] + } + next.putInt(word) + } + state = next.array() + } + for (i in 0..15) output[offset + i] = (state[i].toInt() xor previous[i].toInt()).toByte() + previous = cipher.copyOfRange(offset, offset + 16) + } + val padding = output.last().toInt() and 255 + require(padding in 1..16 && output.takeLast(padding).all { (it.toInt() and 255) == padding }) + return output.copyOf(output.size - padding) + } + + fun decode(encoded: String, endpointIv: String): String { + require(encoded.length <= 90000 && endpointIv.length <= 32) + val clear = decrypt(Base64.getDecoder().decode(encoded), Base64.getDecoder().decode(endpointIv), false) + require(clear.size > 128) + val xml = clear.copyOf(clear.size - 128).toString(Charsets.UTF_8) + val root = RockstarRos.parse(xml) + require(root.tagName == "EncryptedResponse") + val date = requireNotNull(RockstarRos.text(root, "CreationDate")).toLong() + require(date in 0..0xffffffffL) + val text = requireNotNull(RockstarRos.text(root, "Data")) + require(text.length == 672 && text.all { it.digitToIntOrNull(16) != null }) + val cipher = ByteArray(text.length / 2) { i -> text.substring(i * 2, i * 2 + 2).toInt(16).toByte() } + val iv = ByteBuffer.allocate(16).order(ByteOrder.LITTLE_ENDIAN).put(data, data.size - 12, 12).putInt(date.toInt()).array() + val material = decrypt(cipher, iv, true) + require(material.size == 320) + return material.joinToString("") { "%02X".format(it) } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarRos.kt b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarRos.kt new file mode 100644 index 0000000000..88217aed08 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarRos.kt @@ -0,0 +1,96 @@ +package com.droiddeck.launcher.stores.rockstar + +import org.w3c.dom.Element +import java.io.ByteArrayInputStream +import java.net.HttpURLConnection +import java.net.URL +import java.net.URLEncoder +import javax.xml.XMLConstants +import javax.xml.parsers.DocumentBuilderFactory + +internal object RockstarRos { + const val HOST = "https://rgl-prod.ros.rockstargames.com" + const val PUBLIC_HOST = "https://prod.ros.rockstargames.com" + const val SERVICES = "/launcher/11/launcherservices/" + private const val MAX_BYTES = 32 * 1024 * 1024 + + class RosException(message: String, val code: String = "", val status: Int = 0) : Exception(message) + + class Reply(val status: Int, val body: String) + + fun form(fields: List>): String = + fields.joinToString("&") { (k, v) -> "$k=" + URLEncoder.encode(v, "UTF-8") } + + fun call(method: String, fields: List>, host: String = HOST, headers: Map = emptyMap()): Reply { + val c = URL(host + SERVICES + method).openConnection() as HttpURLConnection + c.requestMethod = "POST" + c.connectTimeout = 20_000 + c.readTimeout = 60_000 + c.instanceFollowRedirects = false + c.doOutput = true + c.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=utf-8") + c.setRequestProperty("User-Agent", RockstarAuth.USER_AGENT) + for ((k, v) in headers) c.setRequestProperty(k, v) + try { + c.outputStream.use { it.write(form(fields).toByteArray(Charsets.UTF_8)) } + val status = c.responseCode + val stream = (if (status in 200..299) c.inputStream else c.errorStream) + val bytes = stream?.use { input -> + val out = java.io.ByteArrayOutputStream() + val buf = ByteArray(64 * 1024) + while (true) { + val n = input.read(buf) + if (n < 0) break + out.write(buf, 0, n) + if (out.size() > MAX_BYTES) throw RosException("$method: answer too large", status = status) + } + out.toByteArray() + } ?: ByteArray(0) + return Reply(status, bytes.toString(Charsets.UTF_8)) + } finally { + c.disconnect() + } + } + + fun result(method: String, fields: List>, host: String = HOST, headers: Map = emptyMap()): Element { + val reply = call(method, fields, host, headers) + if (reply.status !in 200..299) throw RosException("$method: HTTP ${reply.status}", status = reply.status) + val root = runCatching { parse(reply.body) }.getOrNull() + ?: throw RosException("$method: HTTP ${reply.status} invalid response", status = reply.status) + if (text(root, "Status") != "1") { + val error = first(root, "Error") + val code = listOfNotNull(error?.getAttribute("Code")?.takeIf { it.isNotEmpty() }, error?.getAttribute("CodeEx")?.takeIf { it.isNotEmpty() }).joinToString("/") + throw RosException("$method: ${code.ifEmpty { "HTTP ${reply.status}" }}", code, reply.status) + } + return root + } + + fun parse(xml: String): Element { + require(!xml.contains(" 0) it.item(0) as Element else null } + + fun all(root: Element, tag: String): List = root.getElementsByTagName(tag).let { l -> (0 until l.length).map { l.item(it) as Element } } + + fun text(root: Element, tag: String): String? = first(root, tag)?.textContent?.trim() + + fun children(parent: Element, tag: String): List { + val out = ArrayList() + var n = parent.firstChild + while (n != null) { + if (n is Element && n.tagName == tag) out += n + n = n.nextSibling + } + return out + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarTitles.kt b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarTitles.kt new file mode 100644 index 0000000000..bbbc0e69dd --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/stores/rockstar/RockstarTitles.kt @@ -0,0 +1,84 @@ +package com.droiddeck.launcher.stores.rockstar + +import com.droiddeck.launcher.stores.CatalogItem +import com.droiddeck.launcher.stores.Store + +internal data class RockstarTitle( + val id: String, + val rosTitleId: Int, + val name: String, + val exe: String, + val registryKey: String, + val steamAppId: Int, + val released: String, + val platform: String = "pcros", + val description: String = "", + val page: String = "", +) + +internal object RockstarTitles { + private const val ART = "https://cdn.cloudflare.steamstatic.com/steam/apps/" + + val all = listOf( + RockstarTitle("gta5_gen9", 11, "Grand Theft Auto V Enhanced", "GTA5_Enhanced.exe", "Rockstar Games\\GTAV Enhanced", 3240220, "2025-03-04", platform = "pcrosalt", + description = "Story mode and GTA Online with ray-traced visuals, faster loading and DualSense support.", + page = "https://www.rockstargames.com/gta-v"), + RockstarTitle("gta5", 11, "Grand Theft Auto V Legacy", "GTA5.exe", "Rockstar Games\\Grand Theft Auto V", 271590, "2015-04-14", + description = "Three criminals, one city: the original PC release of Grand Theft Auto V.", + page = "https://www.rockstargames.com/gta-v"), + RockstarTitle("rdr2", 13, "Red Dead Redemption 2", "RDR2.exe", "Rockstar Games\\Red Dead Redemption 2", 1174180, "2019-11-05", + description = "Arthur Morgan and the Van der Linde gang on the run at the end of the outlaw era.", + page = "https://www.rockstargames.com/reddeadredemption2"), + RockstarTitle("rdr", 8, "Red Dead Redemption", "RDR.exe", "Rockstar Games\\Red Dead Redemption", 2668510, "2024-10-29", + description = "John Marston's story, with the Undead Nightmare expansion.", + page = "https://www.rockstargames.com/reddeadredemption"), + RockstarTitle("gta4", 1, "Grand Theft Auto IV: The Complete Edition", "GTAIV.exe", "Rockstar Games\\Grand Theft Auto IV", 12210, "2008-12-02", + description = "Niko Bellic's Liberty City, with The Lost and Damned and The Ballad of Gay Tony.", + page = "https://www.rockstargames.com/games/IV"), + RockstarTitle("lanoire", 9, "L.A. Noire", "LANoire.exe", "Rockstar Games\\LANoireMTL", 110800, "2011-11-08", + description = "A detective story in 1947 Los Angeles.", + page = "https://www.rockstargames.com/games/lanoire"), + RockstarTitle("lanoirevr", 24, "L.A. Noire: The VR Case Files", "LANoireVR.exe", "Rockstar Games\\LANoireVR", 722230, "2017-12-15", + description = "Seven cases from L.A. Noire rebuilt for virtual reality."), + RockstarTitle("mp3", 10, "Max Payne 3", "MaxPayne3.exe", "Rockstar Games\\MP3MTL", 204100, "2012-05-29", + description = "Max Payne, years after New York, working private security in São Paulo.", + page = "https://www.rockstargames.com/games/maxpayne3"), + RockstarTitle("bully", 23, "Bully: Scholarship Edition", "Bully.exe", "Rockstar Games\\Bully", 12200, "2008-10-21", + description = "Jimmy Hopkins against the bullies, teachers and cliques of Bullworth Academy.", page = "https://www.rockstargames.com/bully"), + RockstarTitle("gta3unreal", 28, "Grand Theft Auto III – The Definitive Edition", "Gameface\\Binaries\\Win64\\LibertyCity.exe", "Rockstar Games\\GTA III - DE", 1546970, "2021-11-11", + description = "Liberty City, remastered with new lighting, controls and visual detail."), + RockstarTitle("gtavcunreal", 29, "Grand Theft Auto: Vice City – The Definitive Edition", "Gameface\\Binaries\\Win64\\ViceCity.exe", "Rockstar Games\\GTA Vice City - DE", 1546990, "2021-11-11", + description = "Tommy Vercetti's 1980s Vice City, remastered with new lighting, controls and visual detail."), + RockstarTitle("gtasaunreal", 30, "Grand Theft Auto: San Andreas – The Definitive Edition", "Gameface\\Binaries\\Win64\\SanAndreas.exe", "Rockstar Games\\GTA San Andreas - DE", 1547000, "2021-11-11", + description = "CJ's return to San Andreas, remastered with new lighting, controls and visual detail."), + RockstarTitle("gtasa", 18, "Grand Theft Auto: San Andreas", "gta_sa.exe", "Rockstar Games\\GTA: San Andreas", 12120, "2005-06-07", + description = "Carl Johnson's return to Los Santos and the state of San Andreas.", page = "https://www.rockstargames.com/games/sanandreas"), + RockstarTitle("gtavc", 27, "Grand Theft Auto: Vice City", "gta-vc.exe", "Rockstar Games\\Grand Theft Auto: Vice City", 12110, "2003-05-12", + description = "Tommy Vercetti's rise through 1980s Vice City.", page = "https://www.rockstargames.com/games/vicecity"), + RockstarTitle("gta3", 26, "Grand Theft Auto III", "gta3.exe", "Rockstar Games\\Grand Theft Auto III", 12100, "2002-05-20", + description = "Claude's revenge in Liberty City, the game that took the series into 3D.", page = "https://www.rockstargames.com/games/grandtheftauto3"), + ) + + private val byId = all.associateBy { it.id } + + private val PARENTS = mapOf( + "rdr2_sp" to "rdr2", "rdr2_rdo" to "rdr2", "rdr2_sp_rgl" to "rdr2", "rdr2_sp_steam" to "rdr2", "rdr2_sp_epic" to "rdr2", + "gtatrilogy" to "gtasaunreal", + ) + + fun forName(name: String): List = + if (name.equals("gtatrilogy", true)) listOf("gta3unreal", "gtavcunreal", "gtasaunreal").mapNotNull { byId[it] } else listOfNotNull(byId(name)) + + fun byId(id: String?): RockstarTitle? = id?.lowercase()?.let { byId[it] ?: byId[PARENTS[it]] } + + fun cover(t: RockstarTitle) = "$ART${t.steamAppId}/library_600x900.jpg" + fun hero(t: RockstarTitle) = "$ART${t.steamAppId}/library_hero.jpg" + fun wide(t: RockstarTitle) = "$ART${t.steamAppId}/header.jpg" + + fun item(t: RockstarTitle, owned: Boolean = false, extra: Map = emptyMap()) = CatalogItem( + store = Store.ROCKSTAR, id = t.id, title = t.name, imageUrl = hero(t), tallImageUrl = cover(t), + storeUrl = t.page.ifEmpty { "https://store.rockstargames.com" }, developer = "Rockstar Games", publisher = "Rockstar Games", + releaseDate = t.released, description = t.description, owned = owned, mature = true, + extra = mapOf("rosTitleId" to t.rosTitleId.toString()) + extra, + ) +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt b/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt index bee82bbd2c..729fc5ad19 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GameDetail.kt @@ -400,6 +400,7 @@ internal fun GameActions( val failed = rawDownload?.takeIf { it.state == DownloadState.FAILED } val cloud = game?.library == Library.XBOX_CLOUD && installed == null val downloadBytes = catalogSize(item) + val launchSupported = store != Store.ROCKSTAR || com.droiddeck.launcher.stores.rockstar.RockstarLaunch.supports(id) Actions { when { s.shortcutPicker && game != null -> { @@ -411,8 +412,8 @@ internal fun GameActions( val xboxBusy = store == Store.XBOX && id != null && XboxContent.busy(id) val preparing = (game?.launchKey ?: storeKey)?.let { it in s.preparingGames } == true PrimaryButton( - stringResource(if (preparing) R.string.store_starting else R.string.stores_play), - enabled = !s.busy && !preparing && gone == null && download == null && !xboxBusy && (store != Store.GOG || installed?.sidecar?.isInstalled != false), + stringResource(if (!launchSupported) R.string.stores_rockstar_launch_unavailable else if (preparing) R.string.store_starting else R.string.stores_play), + enabled = launchSupported && !s.busy && !preparing && gone == null && download == null && !xboxBusy && (store != Store.GOG || installed?.sidecar?.isInstalled != false), main = true, icon = Icons.Filled.PlayArrow, modifier = leadOn, ) { if (game != null) a.onSteamGame(game) else if (store != null && id != null) launchStoreGame(store, id, s, a) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt index 2fea8fc891..f1afd42c0d 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoreChips.kt @@ -35,6 +35,7 @@ internal fun sourceColours(source: String): SourceColours = when (source) { Store.BATTLENET.id -> SourceColours(Color(0xFF0A2440), Color(0xFF9DD1FF), Color(0xFF148EFF)) Store.UBISOFT.id -> SourceColours(Color(0xFF0B1E44), Color(0xFFA8C6FF), Color(0xFF2E7DFF)) Store.EA.id -> SourceColours(Color(0xFF3A0E12), Color(0xFFFF9A9A), Color(0xFFFF4747)) + Store.ROCKSTAR.id -> SourceColours(Color(0xFF3A2A06), Color(0xFFFFD780), Color(0xFFFCAF17)) Library.SOURCE_STEAM -> SourceColours(Color(0xFF16293D), Color(0xFF7CC4FF), Color(0xFF1A9FFF)) FLATHUB -> SourceColours(Color(0xFF0B2E2B), Color(0xFF9FE3DD), FlathubTeal) else -> SourceColours(Color(0xFF1A1D22), Color(0xFF9AA3AF), Color(0xFF9AA3AF)) @@ -52,6 +53,7 @@ internal fun sourceLabel(source: String): String = when (source) { Store.BATTLENET.id -> Store.BATTLENET.label Store.UBISOFT.id -> Store.UBISOFT.shortLabel Store.EA.id -> Store.EA.label + Store.ROCKSTAR.id -> Store.ROCKSTAR.shortLabel else -> stringResource(R.string.source_added) } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt index 8988e16a17..d8daa53d58 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresDownloads.kt @@ -85,6 +85,7 @@ import com.droiddeck.launcher.R import com.droiddeck.launcher.session.SessionPrefs import com.droiddeck.launcher.stores.CatalogItem import com.droiddeck.launcher.stores.StoreLanguage +import com.droiddeck.launcher.stores.Store import com.droiddeck.launcher.stores.StoresState import com.droiddeck.launcher.stores.download.DownloadEntry import com.droiddeck.launcher.stores.download.DownloadQueue @@ -220,7 +221,7 @@ private fun FinishedRow(d: DownloadEntry, s: FrontEndState, a: FrontEndActions, val ctx = LocalContext.current ArtStrip(d.cover, d.name) { StripLabel(d.name, d.store.id, stringResource(if (d.state == DownloadState.INSTALLED) R.string.stores_installed_chip else R.string.stores_dl_cancelled), Color.White.copy(alpha = 0.72f)) - if (d.state == DownloadState.INSTALLED) Box(Modifier.bloomIn(bloom, GATHER_HOLD_MS + 150)) { + if (d.state == DownloadState.INSTALLED && (d.store != Store.ROCKSTAR || com.droiddeck.launcher.stores.rockstar.RockstarLaunch.supports(d.id))) Box(Modifier.bloomIn(bloom, GATHER_HOLD_MS + 150)) { RoundAction(Icons.Filled.PlayArrow, stringResource(R.string.stores_play), primary = true) { if (d.key == EpicClient.DOWNLOAD_KEY) a.onEpicLauncher() else if (d.key == com.droiddeck.launcher.stores.battlenet.BattleNetClient.DOWNLOAD_KEY) a.onBattleNet() else launchStoreGame(d.store, d.id, s, a) } } } @@ -373,7 +374,7 @@ private fun DownloadCard(d: DownloadEntry, s: FrontEndState, a: FrontEndActions) RoundAction(Icons.Filled.Refresh, stringResource(R.string.stores_dl_resume), primary = true) { DownloadQueue.retry(ctx, d.key) } CancelAction { DownloadQueue.clear(ctx, d.key) } } - DownloadState.INSTALLED -> Box(Modifier.bloomIn(true, 420)) { + DownloadState.INSTALLED -> if (d.store != Store.ROCKSTAR || com.droiddeck.launcher.stores.rockstar.RockstarLaunch.supports(d.id)) Box(Modifier.bloomIn(true, 420)) { RoundAction(Icons.Filled.PlayArrow, stringResource(R.string.stores_play), primary = true) { if (d.key == EpicClient.DOWNLOAD_KEY) a.onEpicLauncher() else if (d.key == com.droiddeck.launcher.stores.battlenet.BattleNetClient.DOWNLOAD_KEY) a.onBattleNet() else launchStoreGame(d.store, d.id, s, a) } } DownloadState.CANCELLED -> {} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt index 4e2c210b62..e5005a018e 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/StoresPage.kt @@ -1168,6 +1168,7 @@ internal fun storePalette(base: Palette, store: Store?): Palette { Store.BATTLENET -> Color(0xFF148EFF) to Color(0xFF0B6BD3) Store.UBISOFT -> Color(0xFF2E7DFF) to Color(0xFF1A5BD6) Store.EA -> Color(0xFFFF4747) to Color(0xFFE03030) + Store.ROCKSTAR -> Color(0xFFFCAF17) to Color(0xFFD98E00) null -> return base } val on = if (accent.luminance() > 0.18f) Color(0xFF0B0B0D) else Color.White diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 4d2e7cfe52..b543ff3d78 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -3998,5 +3998,6 @@ Scarlet Snow White surfaces with red accents. + Launch unavailable No web browser is available to open this link. diff --git a/app/src/main/resources/rockstar/legacy-cipher.bin b/app/src/main/resources/rockstar/legacy-cipher.bin new file mode 100644 index 0000000000..b70beb43ed Binary files /dev/null and b/app/src/main/resources/rockstar/legacy-cipher.bin differ diff --git a/app/src/test/java/com/droiddeck/launcher/stores/StoreAccountsCipherTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/StoreAccountsCipherTest.kt index cd14c66602..9924c2b50a 100644 --- a/app/src/test/java/com/droiddeck/launcher/stores/StoreAccountsCipherTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/stores/StoreAccountsCipherTest.kt @@ -132,6 +132,17 @@ class StoreAccountsCipherTest { assertEquals("test@example.test", StoreAccounts.signedInAs(app, Store.XBOX)) } + @Test fun rockstarNeverFallsBackToPlaintextWhenKeystoreFails() { + StoreAccounts.keys = broken + org.junit.Assert.assertThrows(IllegalStateException::class.java) { + StoreAccounts.write(app, Store.ROCKSTAR, JSONObject().put("access_token", "synthetic-secret")) + } + assertFalse(file(Store.ROCKSTAR).exists()) + StoreAccounts.keys = fake + StoreAccounts.write(app, Store.ROCKSTAR, creds) + assertTrue(CredentialCipher.isEnvelope(JSONObject(file(Store.ROCKSTAR).readText()))) + } + @Test fun xboxShowsTheGamertagElseAMaskedEmail() { StoreAccounts.write(app, Store.XBOX, JSONObject().put("username", "player@example.test")) assertEquals("p•••@example.test", StoreAccounts.displayName(app, Store.XBOX)) diff --git a/app/src/test/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunchCipherTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunchCipherTest.kt new file mode 100644 index 0000000000..39031e7c47 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/stores/rockstar/RockstarLaunchCipherTest.kt @@ -0,0 +1,35 @@ +package com.droiddeck.launcher.stores.rockstar + +import org.junit.Assert.assertArrayEquals +import org.junit.Assert.assertThrows +import org.junit.Test + +class RockstarLaunchCipherTest { + private fun bytes(hex: String) = ByteArray(hex.length / 2) { hex.substring(it * 2, it * 2 + 2).toInt(16).toByte() } + + @Test + fun decodesSyntheticCbcVectorsWithBothKeySchedules() { + val outer = bytes("f49a68fe243848826077b14d60b2f43c00000000000000000000000000000000") + val inner = bytes("864b81362b7d5bb23cd69b9bdb1980c500000000000000000000000000000000") + assertArrayEquals("launch-test-0000".toByteArray(), RockstarLaunchCipher.decrypt(outer, bytes("b804c12ac4af4d8962636fa63c00dda6"), false)) + assertArrayEquals("launch-test-0000".toByteArray(), RockstarLaunchCipher.decrypt(inner, bytes("50a6ad87e83fcde3593f86ae889cdaef"), true)) + } + + @Test + fun rejectsBadPaddingAndInvalidCipherSizes() { + val cipher = bytes("f49a68fe243848826077b14d60b2f43c00000000000000000000000000000000") + cipher[15] = (cipher[15].toInt() xor 1).toByte() + assertThrows(IllegalArgumentException::class.java) { RockstarLaunchCipher.decrypt(cipher, ByteArray(16), false) } + for (size in listOf(0, 15, 65552)) { + assertThrows(IllegalArgumentException::class.java) { RockstarLaunchCipher.decrypt(ByteArray(size), ByteArray(16), false) } + } + assertThrows(IllegalArgumentException::class.java) { RockstarLaunchCipher.decode("A".repeat(90001), "") } + } + + @Test + fun rejectsExternalDocumentTypesBeforeXmlParsing() { + assertThrows(IllegalArgumentException::class.java) { + RockstarRos.parse("") + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/stores/rockstar/RockstarTest.kt b/app/src/test/java/com/droiddeck/launcher/stores/rockstar/RockstarTest.kt new file mode 100644 index 0000000000..e356683511 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/stores/rockstar/RockstarTest.kt @@ -0,0 +1,299 @@ +package com.droiddeck.launcher.stores.rockstar + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33], application = android.app.Application::class) +class RockstarTest { + @Test fun launcherAdoptionDoesNotFollowSymbolicLinks() { + val folder = java.nio.file.Files.createTempDirectory("rockstar-launch-link").toFile() + val outside = java.io.File.createTempFile("rockstar-keep", ".txt").apply { writeText("keep") } + val link = java.io.File(folder, com.droiddeck.launcher.stores.StoreLaunch.LAUNCHER) + try { + try { + java.nio.file.Files.createSymbolicLink(link.toPath(), outside.toPath()) + } catch (e: java.nio.file.FileSystemException) { + org.junit.Assume.assumeNoException(e) + } + java.io.File(folder, "gta3.exe").writeText("game") + val game = com.droiddeck.launcher.stores.StoreGameSidecar(com.droiddeck.launcher.stores.Store.ROCKSTAR, "gta3", "GTA III", "gta3.exe", launcher = com.droiddeck.launcher.stores.StoreLaunch.LAUNCHER) + assertNull(com.droiddeck.launcher.stores.StoreLaunch.adopt(folder, game).launcher) + assertNull(com.droiddeck.launcher.stores.StoreLaunch.writeLauncher(folder, game).launcher) + assertEquals("keep", outside.readText()) + assertTrue(java.nio.file.Files.isSymbolicLink(link.toPath())) + } finally { + java.nio.file.Files.deleteIfExists(link.toPath()) + folder.deleteRecursively() + outside.delete() + } + } + + @Test fun resumeHashingStopsWhenCancelled() { + val file = java.io.File.createTempFile("rockstar-hash", ".bin") + try { + val bytes = ByteArray(1024 * 1024) + file.writeBytes(bytes) + val hash = java.security.MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) } + val chunk = RockstarChunk("1", "1", hash, 0, bytes.size.toLong()) + var checks = 0 + assertFalse(RockstarManifest.verified(file, chunk) { ++checks >= 3 }) + assertEquals(3, checks) + assertTrue(RockstarManifest.verified(file, chunk)) + } finally { + file.delete() + } + } + + @Test fun unsupportedGamesKeepTheirFilesWithoutRegisteringALauncher() { + val app = org.robolectric.RuntimeEnvironment.getApplication() + com.droiddeck.launcher.session.SessionPrefs.setGameStorage(app, com.droiddeck.launcher.session.SessionPrefs.GAME_STORAGE_OFF, "") + val folder = java.io.File(com.droiddeck.launcher.stores.StoreInstallRoot.storeDir(com.droiddeck.launcher.stores.StoreInstallRoot.installRoot(app), com.droiddeck.launcher.stores.Store.ROCKSTAR), "RDR2").apply { mkdirs() } + try { + val game = com.droiddeck.launcher.stores.StoreGameSidecar(com.droiddeck.launcher.stores.Store.ROCKSTAR, "rdr2", "RDR2", "RDR2.exe") + java.io.File(folder, game.exe).writeText("installed game") + val script = java.io.File(folder, com.droiddeck.launcher.stores.StoreLaunch.LAUNCHER) + script.writeText("old launcher") + val finished = com.droiddeck.launcher.stores.StoreLaunch.writeLauncher(folder, game) + finished.write(folder) + assertFalse(RockstarLaunch.supports(game.id)) + assertNull(finished.launcher) + assertFalse(script.exists()) + assertTrue(java.io.File(folder, game.exe).isFile) + assertNull(com.droiddeck.launcher.frontend.AddedGames.single(app, folder.path)) + } finally { + folder.deleteRecursively() + } + } + + @Test fun existingRockstarLaunchScriptsAreRefreshed() { + val folder = java.nio.file.Files.createTempDirectory("rockstar-launch").toFile() + try { + java.io.File(folder, "gta3.exe").writeBytes(byteArrayOf(1)) + val game = com.droiddeck.launcher.stores.StoreGameSidecar(com.droiddeck.launcher.stores.Store.ROCKSTAR, "gta3", "GTA III", "gta3.exe", launcher = com.droiddeck.launcher.stores.StoreLaunch.LAUNCHER) + val script = java.io.File(folder, com.droiddeck.launcher.stores.StoreLaunch.LAUNCHER) + script.writeText("old launch script") + com.droiddeck.launcher.stores.StoreLaunch.adopt(folder, game) + assertTrue(script.readText().contains("Rockstar Games\\Launcher\\Launcher.exe")) + assertFalse(script.readText().contains("old launch script")) + } finally { + folder.deleteRecursively() + } + } + + @Test + @Config(sdk = [28]) + fun classicLaunchDefaultsAreSetBeforeWineAndKeepExplicitSettings() { + val app = org.robolectric.RuntimeEnvironment.getApplication() + val explicit = com.droiddeck.launcher.core.GameEnvironment.Config(games = mapOf( + "100" to mapOf("FEX_X87REDUCEDPRECISION" to "1"), + "104" to mapOf("PROTON_USE_WINED3D" to "0"), + )) + com.droiddeck.launcher.session.GameEnvironmentStore.save(app, explicit) + RockstarLaunch.applyDefaults(app, "gta3", 100) + RockstarLaunch.applyDefaults(app, "gta3", 101) + RockstarLaunch.applyDefaults(app, "gtasa", 102) + RockstarLaunch.applyDefaults(app, "gtavc", 103) + RockstarLaunch.applyDefaults(app, "gtasa", 104) + val config = com.droiddeck.launcher.session.GameEnvironmentStore.read(app) + assertEquals("1", config.games["100"]?.get("FEX_X87REDUCEDPRECISION")) + assertEquals("0", config.games["101"]?.get("FEX_X87REDUCEDPRECISION")) + assertEquals(mapOf("PROTON_USE_WINED3D" to "1"), config.games["102"]) + assertEquals("0", config.games["104"]?.get("PROTON_USE_WINED3D")) + assertFalse(config.games.containsKey("103")) + } + + @Test fun classicTitlesUseTheirObservedPipeNames() { + assertEquals(mapOf("gta3" to "GTA3_Pipe", "gtavc" to "GTA-VC_Pipe", "gtasa" to "GTA_SA_Pipe"), RockstarLaunch.pipes) + } + + @Test fun signingOutClearsOwnedShelfCards() { + val store = com.droiddeck.launcher.stores.Store.ROCKSTAR + com.droiddeck.launcher.stores.StoresState.library[store] = emptyList() + com.droiddeck.launcher.stores.StoresState.shelves[store] = com.droiddeck.launcher.stores.StoreShelves() + RockstarLibrary.reset() + org.robolectric.shadows.ShadowLooper.idleMainLooper() + assertFalse(com.droiddeck.launcher.stores.StoresState.library.containsKey(store)) + assertFalse(com.droiddeck.launcher.stores.StoresState.shelves.containsKey(store)) + } + + @Test fun resumedChunksMustStillMatchTheirFiles() { + val folder = java.nio.file.Files.createTempDirectory("rockstar-resume").toFile() + try { + val file = java.io.File(folder, "game.bin") + val bytes = "verified chunk".toByteArray() + val hash = java.security.MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) } + val chunk = RockstarChunk("1", "2", hash, 2, bytes.size.toLong()) + assertFalse(RockstarManifest.verified(file, chunk)) + file.writeBytes(byteArrayOf(0, 0) + bytes) + assertTrue(RockstarManifest.verified(file, chunk)) + java.io.RandomAccessFile(file, "rw").use { it.setLength(4) } + assertFalse(RockstarManifest.verified(file, chunk)) + file.writeBytes(ByteArray(bytes.size + 2)) + assertFalse(RockstarManifest.verified(file, chunk)) + } finally { + folder.deleteRecursively() + } + } + + @Test fun manifestWritesRejectSymbolicLinks() { + val folder = java.nio.file.Files.createTempDirectory("rockstar-path").toFile() + val outside = java.nio.file.Files.createTempDirectory("rockstar-outside").toFile() + try { + val link = java.io.File(folder, "linked") + try { + java.nio.file.Files.createSymbolicLink(link.toPath(), outside.toPath()) + } catch (e: java.nio.file.FileSystemException) { + org.junit.Assume.assumeNoException(e) + } + assertTrue(runCatching { RockstarManifest.inside(folder, "linked/game.bin") }.isFailure) + assertEquals(java.io.File(folder.canonicalFile, "normal/game.bin"), RockstarManifest.inside(folder, "normal/game.bin")) + java.nio.file.Files.deleteIfExists(link.toPath()) + } finally { + folder.deleteRecursively() + outside.deleteRecursively() + } + } + + @Test + fun classicGamesStartTheirParentLauncherWithoutEmbeddingCredentials() { + val sidecar = com.droiddeck.launcher.stores.StoreGameSidecar( + com.droiddeck.launcher.stores.Store.ROCKSTAR, "gtavc", "Vice City", "gta-vc.exe", + ) + val text = com.droiddeck.launcher.stores.StoreLaunch.launcherText(sidecar) + assertTrue(text.contains("\"C:\\Program Files\\Rockstar Games\\Launcher\\Launcher.exe\"")) + assertTrue(text.contains("exit /b %errorlevel%")) + assertFalse(text.contains("gta-vc.exe")) + assertFalse(text.contains("ticket", true)) + assertFalse(text.contains("rem ", true)) + } + + private val apps = """ +1 + + BRANCHACCESS token="L" + + + + + BRANCHACCESS token="S" + + + BRANCHACCESS token="B" + BRANCHACCESS token="D" + + + + {"title":"gta4","isFeatured":false,"packageType":"title"} + {"title":"rdr2","isFeatured":false,"packageType":"title"} + {"title":"gtatrilogy","isFeatured":true,"packageType":"bundle"} + {"title":"gta5","isFeatured":false,"packageType":"title"} +""" + + private fun account(xml: String = apps) = RockstarRos.parse(xml).let { RockstarAccountApps(RockstarApps.parse(it), RockstarApps.packages(it)) } + + private val manifest = """ +1 + + + Launcher.exe + + FF + + + ThirdParty\Steam\steam_api64.dll + + ee + + false""" + + @Test fun branchesNeedARealBuild() { + val parsed = account().apps + val gta4 = parsed.first { it.name == "gta4" } + assertEquals("31", RockstarApps.branch(gta4)!!.id) + assertNull(RockstarApps.branch(parsed.first { it.name == "rdr2_sp_steam" })) + assertNull(RockstarApps.branch(parsed.first { it.name == "gta5" })) + } + + @Test fun ownedTitlesAreTheAccountsOwnPackagesNotTheFeaturedOnes() { + assertEquals(listOf("gta4", "rdr2", "gta5"), RockstarLibrary.owned(account()).map { it.id }) + } + + @Test fun libraryListsOnlyOwnedTitlesRockstarDelivers() { + val games = RockstarLibrary.games(account()) + assertEquals(listOf("gta4"), games.map { it.id }) + assertEquals("gta4", games[0].extra["app"]) + assertTrue(games.all { it.owned }) + } + + @Test fun anOwnedTrilogyBundleIsAllThreeDefinitiveEditions() { + val owned = RockstarLibrary.owned(account(apps.replace("\"isFeatured\":true,\"packageType\":\"bundle\"", "\"isFeatured\":false,\"packageType\":\"bundle\""))) + assertTrue(owned.map { it.id }.containsAll(listOf("gta3unreal", "gtavcunreal", "gtasaunreal"))) + } + + @Test fun manifestFilesCarryTheirChunksAndWindowsPathsBecomeRelative() { + val build = RockstarManifest.parse(RockstarRos.parse(manifest)) + assertEquals("1311", build.buildId) + assertFalse(build.preload) + assertEquals(34L, build.bytes) + val exe = build.files[0] + assertEquals(listOf("46859", "46860"), exe.chunks.map { it.chunkId }) + assertEquals("ab", exe.chunks[0].sha256) + assertEquals("ff", exe.sha256) + assertEquals("ThirdParty/Steam/steam_api64.dll", build.files[1].path) + } + + @Test fun pathsThatLeaveTheInstallAreRefused() { + assertNull(RockstarManifest.safePath("..\\..\\Windows\\x.dll")) + assertNull(RockstarManifest.safePath("C:\\x.dll")) + assertEquals("a/b.rpf", RockstarManifest.safePath("\\a\\.\\b.rpf")) + } + + @Test fun urlBatchesStayWithinTheirByteAndCountLimits() { + val chunks = (1..5).map { RockstarChunk("1", "$it", "", 0, if (it == 3) 100 else 10) } + val batches = RockstarManifest.batches(chunks, maxBytes = 30, maxCount = 2) + assertEquals(listOf(listOf("1", "2"), listOf("3"), listOf("4", "5")), batches.map { b -> b.map { it.chunkId } }) + } + + @Test fun rosErrorsNameTheirCode() { + val root = RockstarRos.parse("0") + assertEquals("AuthenticationFailed", RockstarRos.first(root, "Error")!!.getAttribute("Code")) + } + + @Test fun ticketAnswerGivesTheAccountAndExpiry() { + val root = RockstarRos.parse("""1TK + S86399 + 42player""") + val t = RockstarAuth.parseTicket(root, now = 1000L)!! + assertEquals("T", t.ticket) + assertEquals("42", t.rockstarId) + assertEquals("player", t.nickname) + assertEquals(1000L + 86_399_000L, t.expiresAt) + } + + @Test fun gatewayStateIsWrittenAsThePageWritesIt() { + val fp = RockstarAuth.fingerprintOf("DROIDDECK-DUO", "0a0b0c0d", "0011223344556677") + assertEquals("{\"fp\": {\"device_name\":\"DROIDDECK-DUO\",\"machine_name\":\"DROIDDECK-DUO\",\"os_version\":\"10.0.19045\",\"volume_serial\":\"0a0b0c0d\",\"cpu_info\":\"0011223344556677\"}}", + RockstarAuth.state(fp)) + } + + @Test fun bridgeAnswersTheLauncherQueriesAndHandsBackTheCode() { + val js = RockstarAuth.bridgeScript(RockstarAuth.fingerprintOf("D", "1", "2"), "launcher") + for (m in listOf("GetWindowConfig", "GetDeviceId", "GetVersionInfo", "GetProfileList", "OnStartAuth", "CallAuthResult", "rgscQueryCancel", "/signin/user-form?cid=launcher")) + assertTrue(m, m in js) + assertTrue(RockstarAuth.isCodeUrl(RockstarAuth.CODE_URL + "?code=abc")) + assertEquals("a+b/c", RockstarAuth.codeFrom(RockstarAuth.CODE_URL + "?code=a%2Bb%2Fc")) + } + + @Test fun subAppsResolveToTheirGame() { + assertEquals("rdr2", RockstarTitles.byId("rdr2_sp_rgl")!!.id) + assertEquals("gtasaunreal", RockstarTitles.byId("gtatrilogy")!!.id) + assertNull(RockstarTitles.byId("launcher")) + } +} diff --git a/tools/build_local.sh b/tools/build_local.sh index d564f1e3c0..ee891aee97 100755 --- a/tools/build_local.sh +++ b/tools/build_local.sh @@ -433,6 +433,13 @@ if [[ "${DROIDDECK_SKIP_RUST:-0}" != 1 ]]; then CARGO_TARGET_DIR="${cache_dir}/ubisoft-target" bash tools/ubisoft-launcher/build.sh "${upc_out}" save_step ubisoft "${upc_key}" "${upc_out}" fi + rockstar_out="${repo_root}/app/src/main/resources/rockstar/helpers" + rockstar_key=$(inputs_hash "windows-gnu" tools/rockstar-launcher/src tools/rockstar-launcher/Cargo.toml tools/rockstar-launcher/Cargo.lock tools/rockstar-launcher/build.sh) + if ! restore_step rockstar "${rockstar_key}" "${rockstar_out}"; then + command -v i686-w64-mingw32-gcc >/dev/null 2>&1 || { echo "i686-w64-mingw32-gcc is required for the Rockstar launcher service." >&2; exit 1; } + CARGO_TARGET_DIR="${cache_dir}/rockstar-target" bash tools/rockstar-launcher/build.sh "${rockstar_out}" + save_step rockstar "${rockstar_key}" "${rockstar_out}" + fi fi python3 tools/powervr/fetch.py bash tools/packs/build.sh app/build/packs diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch index 939504835c..ebb9718942 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-store-launch @@ -286,6 +286,12 @@ def cloud_on(sidecar): def exited(argv, code=0): found = find_store_game(argv) launch_dir = os.environ.get("BL_LAUNCH_DIR", "") + if found is not None and launch_dir and str(found[1].get("store")) == "rockstar": + ask(Path(launch_dir) / "stores", {"op": "rockstar-exited", "store": "rockstar", "id": str(found[1].get("id"))}, timeout=1.0) + compat_data = os.environ.get("STEAM_COMPAT_DATA_PATH") + if compat_data: + (Path(compat_data) / "pfx" / ROCKSTAR_FOLDER / "launch.json").unlink(missing_ok=True) + return 0 if found is not None and str(found[1].get("store")) == "epic" and os.environ.get(EPIC_HANDLED) != "1" \ and os.access(EPIC_CLIENT, os.X_OK): try: @@ -307,6 +313,104 @@ def exited(argv, code=0): UBISOFT_DIR = "drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher" UBISOFT_WINDOWS_DIR = "C:\\Program Files (x86)\\Ubisoft\\Ubisoft Game Launcher\\" UBISOFT_INSTALLER_URL = "https://static3.cdn.ubi.com/orbit/launcher_installer/UbisoftConnectInstaller.exe" +ROCKSTAR_SERVICE = Path("/usr/local/lib/droiddeck-rockstar") +ROCKSTAR_FOLDER = "drive_c/Program Files/Rockstar Games/Launcher" +ROCKSTAR_TITLES = {"gta3": "Grand Theft Auto III", "gtavc": "Grand Theft Auto: Vice City", "gtasa": "GTA: San Andreas"} + + +def rockstar_registry(folder, title, compat_data, proton): + pfx = Path(compat_data) / "pfx" + launcher = r"C:\Program Files\Rockstar Games\Launcher" + values = [(r"Rockstar Games\Launcher", launcher), ("Rockstar Games\\" + title, windows_path(str(folder)))] + entries = [("Software\\" + view + key, value) for view in ("", "Wow6432Node\\") for key, value in values] + reg = pfx / "system.reg" + if all(has_value(reg, "[" + key.replace("\\", "\\\\") + "]", "InstallFolder", value) for key, value in entries): + return True + if wait_for_server(pfx, 2): + return all(set_value(reg, "[" + key.replace("\\", "\\\\") + "]", "InstallFolder", value) for key, value in entries) + with tempfile.TemporaryDirectory(prefix="droiddeck-rockstar-") as temp: + path = Path(temp) / "install.reg" + text = "Windows Registry Editor Version 5.00\r\n\r\n" + text += "\r\n".join('[HKEY_LOCAL_MACHINE\\%s]\r\n"InstallFolder"="%s"\r\n' % (key, reg_escape(value)) for key, value in entries) + path.write_text(text, encoding="utf-16") + result = subprocess.run([proton, "run", "reg.exe", "import", windows_path(str(path))], + stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=45) + return result.returncode == 0 + + +def prepare_rockstar(folder, sidecar, compat_data, launch_dir, proton="", ask_app=None): + if not compat_data: + return "no-prefix" + target = Path(compat_data) / "pfx" / ROCKSTAR_FOLDER + config = target / "launch.json" + config.unlink(missing_ok=True) + title = ROCKSTAR_TITLES.get(str(sidecar.get("id"))) + if not title: + return "unsupported-title" + if not launch_dir: + return "no-channel" + root = folder.resolve() + exe = (folder / str(sidecar.get("exe") or "").replace("\\", "/")).resolve() + if not exe.is_relative_to(root): + return "invalid-game-path" + workdir = (folder / str(sidecar["workdir"])).resolve() if sidecar.get("workdir") is not None else exe.parent + if not workdir.is_relative_to(root) or not exe.is_file() or not (folder / "MTLX.dll").is_file(): + return "invalid-game-path" + args = sidecar.get("args") or [] + if not isinstance(args, list) or any(not isinstance(arg, str) or "\0" in arg for arg in args): + return "invalid-game-arguments" + with exe.open("rb") as source: + if source.read(2) != b"MZ": + return "invalid-game-exe" + source.seek(0x3c) + raw = source.read(4) + if len(raw) != 4: + return "invalid-game-exe" + source.seek(int.from_bytes(raw, "little")) + signature = source.read(6) + if len(signature) != 6 or signature[:4] != b"PE\0\0" or signature[4:] not in (b"\x4c\x01", b"\x64\x86"): + return "invalid-game-exe" + service = ROCKSTAR_SERVICE / ("Launcher32.exe" if signature[4:] == b"\x4c\x01" else "Launcher64.exe") + if not service.is_file(): + return "no-service" + made = "present" if (Path(compat_data) / "pfx/user.reg").is_file() else create_prefix(compat_data, proton) + if made not in ("created", "present"): + return "prefix-" + made + if not rockstar_registry(folder, title, compat_data, proton): + return "registry-unavailable" + target.mkdir(parents=True, exist_ok=True) + with tempfile.NamedTemporaryFile(prefix="Launcher-", suffix=".exe", dir=target, delete=False) as temporary: + temporary_path = Path(temporary.name) + try: + with service.open("rb") as source: + shutil.copyfileobj(source, temporary) + except BaseException: + temporary_path.unlink(missing_ok=True) + raise + os.replace(temporary_path, target / "Launcher.exe") + answer = (ask_app or ask)(Path(launch_dir) / "stores", {"op": "rockstar-launch", "store": "rockstar", "id": str(sidecar.get("id"))}, timeout=120.0) + if not isinstance(answer, dict) or not answer.get("ok"): + return "session-" + (str(answer.get("reason") or "refused") if isinstance(answer, dict) else "timeout") + if not isinstance(answer.get("material"), str) or not re.fullmatch(r"[0-9A-Fa-f]{640}", answer["material"]): + return "invalid-material" + expires = answer.get("expiresAt") + if not isinstance(expires, int) or not time.time() * 1000 < expires <= time.time() * 1000 + 120_000: + return "invalid-expiry" + launch = {"folder": windows_path(str(root)), "exe": windows_path(str(exe)), "workdir": windows_path(str(workdir)), + "args": args, "pipe": answer.get("pipe"), "material": answer["material"], "expiresAt": expires} + if len(json.dumps(launch).encode("utf-8")) > 16384: + return "handoff-too-large" + with tempfile.NamedTemporaryFile(mode="w", prefix="launch-", suffix=".json", dir=target, delete=False) as temporary: + temporary_path = Path(temporary.name) + try: + json.dump(launch, temporary) + except BaseException: + temporary_path.unlink(missing_ok=True) + raise + os.replace(temporary_path, config) + return "ready" + + UBISOFT_CACHE = Path("/root/.cache/droiddeck/ubisoft") UBISOFT_LAUNCH = ".droiddeck-ubisoft.json" UBISOFT_SERVICE = Path("/usr/local/lib/droiddeck-ubisoft/droiddeck-upc.exe") @@ -1341,6 +1445,15 @@ def main(argv): prepare_gog(sidecar, compat_data, launch_dir) log("gog registry: " + apply_gog_registry(folder, compat_data, os.environ.get("BL_STORE_PROTON", ""))) log("gog support data: " + gog_support_data(folder, compat_data, os.environ.get("BL_STORE_PROTON", ""))) + if store == "rockstar": + try: + state = prepare_rockstar(folder, sidecar, compat_data, launch_dir, os.environ.get("BL_STORE_PROTON", "")) + except (OSError, ValueError, subprocess.TimeoutExpired): + state = "preparation-failed" + log("rockstar %s: %s" % (game, state)) + if state != "ready" and launch_dir: + ask(Path(launch_dir) / "stores", {"op": "rockstar-exited", "store": "rockstar", "id": game}, timeout=1.0) + return STORE_GAME if state == "ready" else RAN_FAILED if store == "ubisoft": try: log("ubisoft %s: %s" % (game, prepare_ubisoft(folder, sidecar, compat_data, launch_dir, os.environ.get("BL_STORE_PROTON", "")))) diff --git a/tools/release/runtime_inputs.py b/tools/release/runtime_inputs.py index 57fe792465..12ac22eabb 100644 --- a/tools/release/runtime_inputs.py +++ b/tools/release/runtime_inputs.py @@ -23,11 +23,11 @@ PACK_NAMES = ['proot', 'directaudio', 'tracking', 'xbox', 'comet', 'butler', 'po SOURCE_PATHS = ['app/build.gradle', 'app/src/main/cpp/fakeinput_steam.cpp', 'app/src/main/assets/pulseaudio.tzst', 'tools/linuxfs', 'tools/proot', 'tools/aaudio-sink', 'tools/directaudio', 'tools/packs', 'tools/gamescope/release.env', 'tools/droiddeck-esync/release.env', - 'tools/mangoapp', 'tools/msitools', 'tools/pipewire', 'tools/comet', 'tools/xbox', 'tools/dirt-ws2', 'tools/ubisoft-launcher', 'tools/components', 'tools/ci', 'tools/build_local.sh', + 'tools/mangoapp', 'tools/msitools', 'tools/pipewire', 'tools/comet', 'tools/xbox', 'tools/dirt-ws2', 'tools/ubisoft-launcher', 'tools/rockstar-launcher', 'tools/components', 'tools/ci', 'tools/build_local.sh', 'tools/powervr', 'tools/hybris', 'tools/dxvk', 'tools/vulkan-wsi', 'tools/release/runtime_inputs.py', 'app/src/main/assets/desktop-removal', 'tools/quest', 'tools/vr/src', 'tools/vr/driver_droiddeck', 'tools/vr/layer', 'tools/vr/build.sh', - 'tools/gpuload', + 'tools/gpuload', 'app/src/main/resources/rockstar/legacy-cipher.bin', 'app/src/main/cpp/waylandcomp/src/headpose_shm.h', 'app/src/main/cpp/venc/venc_proto.h', 'app/src/main/cpp/waylandcomp/src/spatialpose_shm.h', diff --git a/tools/rockstar-launcher/.gitignore b/tools/rockstar-launcher/.gitignore new file mode 100644 index 0000000000..b83d22266a --- /dev/null +++ b/tools/rockstar-launcher/.gitignore @@ -0,0 +1 @@ +/target/ diff --git a/tools/rockstar-launcher/Cargo.lock b/tools/rockstar-launcher/Cargo.lock new file mode 100644 index 0000000000..f73866571d --- /dev/null +++ b/tools/rockstar-launcher/Cargo.lock @@ -0,0 +1,105 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "droiddeck-rockstar-launcher" +version = "0.1.0" +dependencies = [ + "serde_json", +] + +[[package]] +name = "itoa" +version = "1.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3bd1574e617a9a6c1f8f8181bd7e841e1f20e4277607ef28945765188d6284d4" + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "syn" +version = "3.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8593e8e72159ed2257d083c7a454a85cbf854f37a0966d8d483aff8c8a3ebcee" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.26" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d245f478577f809a851594d02313b640fb437e0bb33866753cff937863096954" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/tools/rockstar-launcher/Cargo.toml b/tools/rockstar-launcher/Cargo.toml new file mode 100644 index 0000000000..4b5ec1f37b --- /dev/null +++ b/tools/rockstar-launcher/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "droiddeck-rockstar-launcher" +version = "0.1.0" +edition = "2021" +license = "GPL-3.0-only" +publish = false + +[[bin]] +name = "Launcher" +path = "src/main.rs" + +[dependencies] +serde_json = "1" + +[profile.release] +opt-level = "s" +lto = true +panic = "abort" +strip = true diff --git a/tools/rockstar-launcher/README.md b/tools/rockstar-launcher/README.md new file mode 100644 index 0000000000..e22a4183c8 --- /dev/null +++ b/tools/rockstar-launcher/README.md @@ -0,0 +1,30 @@ +# Rockstar launcher service + +`Launcher.exe` starts the selected installed game and serves its launcher pipe. The Android app checks ownership and retrieves the launch response from Rockstar. Account credentials and ROS tickets stay in the app. + +The handoff is deleted before starting the game. It expires after 90 seconds. The pipe accepts the child process's greeting and returns the server-issued launch material. No game files are patched. + +GTA III defaults to full x87 precision for FEX before Wine starts, because reduced precision crashed new-game initialization on the test device. San Andreas defaults to WineD3D, because DXVK intermittently corrupted its textures; full precision and conservative memory ordering did not prevent that corruption. These defaults use DroidDeck's per-game settings and preserve explicit per-game overrides. + +`build.sh` builds 32-bit and 64-bit executables with the GNU Windows targets and stages them as APK resources. `legacy-cipher.bin` contains the fixed client protocol tables, not account credentials or APK signing keys. + +Run the protocol tests with: + +```sh +cargo test --locked --manifest-path tools/rockstar-launcher/Cargo.toml +``` + +The optional `capture` example records a first-party launcher reply to a new local file. Run it on Windows or Wine while launching the corresponding game in Rockstar's launcher: + +```powershell +cargo run --release --example capture --manifest-path tools/rockstar-launcher/Cargo.toml -- --pipe GTA-VC_Pipe --output 'C:\captures\reply.bin' +``` + +On Linux, cross-compile the example and run it in the same Wine prefix as Rockstar's launcher: + +```sh +cargo build --release --locked --example capture --target x86_64-pc-windows-gnu --manifest-path tools/rockstar-launcher/Cargo.toml +WINEPREFIX=/path/to/launcher-prefix wine tools/rockstar-launcher/target/x86_64-pc-windows-gnu/release/examples/capture.exe --pipe GTA-VC_Pipe --output 'Z:\tmp\reply.bin' +``` + +Captures contain live launch material. Keep them outside source control; the tool prints only the message tag and payload length. diff --git a/tools/rockstar-launcher/build.sh b/tools/rockstar-launcher/build.sh new file mode 100644 index 0000000000..1f7360f741 --- /dev/null +++ b/tools/rockstar-launcher/build.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash +set -euo pipefail +here=$(cd "$(dirname "$0")" && pwd) +out=${1:-"$here/../../app/src/main/resources/rockstar/helpers"} +mkdir -p "$out" +for target in i686-pc-windows-gnu x86_64-pc-windows-gnu; do + rustup target add "$target" >/dev/null 2>&1 || true + cargo build --manifest-path "$here/Cargo.toml" --release --locked --target "$target" + name=Launcher64.exe + [[ "$target" == i686-* ]] && name=Launcher32.exe + install -m644 "${CARGO_TARGET_DIR:-$here/target}/$target/release/Launcher.exe" "$out/$name" +done diff --git a/tools/rockstar-launcher/examples/capture.rs b/tools/rockstar-launcher/examples/capture.rs new file mode 100644 index 0000000000..8516cbca17 --- /dev/null +++ b/tools/rockstar-launcher/examples/capture.rs @@ -0,0 +1,65 @@ +#[cfg(windows)] +fn main() -> std::io::Result<()> { + use droiddeck_rockstar_launcher::{pipe::Pipe, Frame, Length}; + use std::fs::OpenOptions; + use std::io::{self, Read, Write}; + use std::time::Duration; + + struct Recording<'a> { + source: &'a mut Pipe, + output: &'a mut std::fs::File, + } + + impl Read for Recording<'_> { + fn read(&mut self, buffer: &mut [u8]) -> io::Result { + let size = self.source.read(buffer)?; + self.output.write_all(&buffer[..size])?; + Ok(size) + } + } + + let args: Vec<_> = std::env::args_os().collect(); + let output = args + .windows(2) + .find(|pair| pair[0] == "--output") + .map(|pair| pair[1].clone()) + .map(std::path::PathBuf::from) + .unwrap_or(std::env::current_exe()?.with_file_name("reference-reply.bin")); + let mut file = OpenOptions::new() + .create_new(true) + .write(true) + .open(output)?; + let pipe_name = args + .windows(2) + .find(|pair| pair[0] == "--pipe") + .map(|pair| pair[1].to_string_lossy().into_owned()) + .unwrap_or_else(|| "GTA-VC_Pipe".to_owned()); + let mut pipe = Pipe::connect(&pipe_name, Duration::from_secs(90))?; + Frame { + tag: *b"COLE", + payload: Vec::new(), + nul_terminated: true, + } + .write(&mut pipe, Length::Total)?; + let reply = Frame::read( + &mut Recording { + source: &mut pipe, + output: &mut file, + }, + Length::Body, + ); + file.sync_all()?; + let reply = reply?; + println!( + "Received {} ({} payload bytes)", + String::from_utf8_lossy(&reply.tag), + reply.payload.len() + ); + Ok(()) +} + +#[cfg(not(windows))] +fn main() { + eprintln!("The reference pipe client runs on Windows or Wine."); + std::process::exit(1); +} diff --git a/tools/rockstar-launcher/src/lib.rs b/tools/rockstar-launcher/src/lib.rs new file mode 100644 index 0000000000..e08b2bc92b --- /dev/null +++ b/tools/rockstar-launcher/src/lib.rs @@ -0,0 +1,333 @@ +use std::io::{self, Read, Write}; + +#[cfg(windows)] +pub mod pipe; + +pub const MAX_FRAME_BYTES: usize = 64 * 1024; +const OVERHEAD: usize = 4 + 4 + 1; + +pub fn wait_for_game( + child: &mut std::process::Child, + handshake: std::sync::mpsc::Receiver>, +) -> io::Result { + use std::sync::mpsc::RecvTimeoutError; + loop { + match handshake.recv_timeout(std::time::Duration::from_millis(10)) { + Ok(Ok(())) => return child.wait(), + result @ (Ok(Err(_)) | Err(RecvTimeoutError::Disconnected)) => { + let error = match result { + Ok(Err(error)) => error, + _ => io::Error::new( + io::ErrorKind::BrokenPipe, + "Rockstar handshake worker stopped", + ), + }; + let _ = child.kill(); + child.wait()?; + return Err(error); + } + Err(RecvTimeoutError::Timeout) => { + if let Some(status) = child.try_wait()? { + return Ok(status); + } + } + } + } +} + +#[derive(Clone, Copy)] +pub enum Length { + Total, + Body, +} + +impl Length { + fn header_bytes(self) -> usize { + match self { + Self::Total => 0, + Self::Body => 4, + } + } +} + +#[derive(Debug, PartialEq, Eq)] +pub struct Frame { + pub tag: [u8; 4], + pub payload: Vec, + pub nul_terminated: bool, +} + +fn invalid(message: &'static str) -> io::Error { + io::Error::new(io::ErrorKind::InvalidData, message) +} + +impl Frame { + pub fn read(reader: &mut impl Read, length: Length) -> io::Result { + let mut header = [0; 4]; + reader.read_exact(&mut header)?; + let size = (u32::from_le_bytes(header) as usize) + .checked_add(length.header_bytes()) + .ok_or_else(|| invalid("invalid Rockstar pipe frame length"))?; + if !(OVERHEAD..=MAX_FRAME_BYTES).contains(&size) { + return Err(invalid("invalid Rockstar pipe frame length")); + } + let mut body = vec![0; size - header.len()]; + reader.read_exact(&mut body)?; + let nul_terminated = body.last() == Some(&0); + let end = body.len() - usize::from(nul_terminated); + if body[4] != b':' || body[..4].contains(&b':') || body[..end].contains(&0) { + return Err(invalid("invalid Rockstar pipe frame envelope")); + } + Ok(Self { + tag: body[..4].try_into().unwrap(), + payload: body[5..end].to_vec(), + nul_terminated, + }) + } + + pub fn write(&self, writer: &mut impl Write, length: Length) -> io::Result<()> { + let size = self + .payload + .len() + .checked_add(OVERHEAD + usize::from(self.nul_terminated)) + .filter(|size| *size <= MAX_FRAME_BYTES) + .ok_or_else(|| invalid("Rockstar pipe frame exceeds size limit"))?; + if self.tag.contains(&0) || self.tag.contains(&b':') || self.payload.contains(&0) { + return Err(invalid("Rockstar pipe frame contains a delimiter")); + } + let mut encoded = Vec::with_capacity(size); + encoded.extend_from_slice(&((size - length.header_bytes()) as u32).to_le_bytes()); + encoded.extend_from_slice(&self.tag); + encoded.push(b':'); + encoded.extend_from_slice(&self.payload); + if self.nul_terminated { + encoded.push(0); + } + writer.write_all(&encoded)?; + writer.flush() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::Cursor; + + #[test] + #[ignore] + fn sleeping_game() { + std::thread::sleep(std::time::Duration::from_secs(30)); + } + + fn sleeping_child() -> std::process::Child { + std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", "tests::sleeping_game", "--ignored"]) + .stdout(std::process::Stdio::null()) + .stderr(std::process::Stdio::null()) + .spawn() + .unwrap() + } + + #[test] + fn failed_handshake_terminates_and_reaps_the_game() { + let mut child = sleeping_child(); + let (sender, receiver) = std::sync::mpsc::channel(); + sender + .send(Err(io::Error::new(io::ErrorKind::TimedOut, "test timeout"))) + .unwrap(); + let start = std::time::Instant::now(); + assert_eq!( + wait_for_game(&mut child, receiver).unwrap_err().kind(), + io::ErrorKind::TimedOut + ); + assert!(start.elapsed() < std::time::Duration::from_secs(3)); + assert!(child.try_wait().unwrap().is_some()); + } + + #[test] + fn stopped_handshake_worker_terminates_and_reaps_the_game() { + let mut child = sleeping_child(); + let (sender, receiver) = std::sync::mpsc::channel(); + drop(sender); + assert_eq!( + wait_for_game(&mut child, receiver).unwrap_err().kind(), + io::ErrorKind::BrokenPipe + ); + assert!(child.try_wait().unwrap().is_some()); + } + + #[test] + fn an_exited_game_does_not_wait_for_its_handshake() { + let mut child = std::process::Command::new(std::env::current_exe().unwrap()) + .args(["--exact", "no_test_with_this_name"]) + .stdout(std::process::Stdio::null()) + .stderr(std::process::Stdio::null()) + .spawn() + .unwrap(); + let (_sender, receiver) = std::sync::mpsc::channel(); + assert!(wait_for_game(&mut child, receiver).unwrap().success()); + } + + struct Fragmented(T); + + impl Read for Fragmented { + fn read(&mut self, buffer: &mut [u8]) -> io::Result { + let size = buffer.len().min(1); + self.0.read(&mut buffer[..size]) + } + } + + impl Write for Fragmented { + fn write(&mut self, buffer: &[u8]) -> io::Result { + self.0.write(&buffer[..buffer.len().min(1)]) + } + + fn flush(&mut self) -> io::Result<()> { + self.0.flush() + } + } + + #[test] + fn reads_observed_greeting_across_partial_reads() { + let bytes = b"\x0a\0\0\0COLE:\0"; + assert_eq!( + Frame::read(&mut Fragmented(&bytes[..]), Length::Total).unwrap(), + Frame { + tag: *b"COLE", + payload: Vec::new(), + nul_terminated: true, + } + ); + } + + #[test] + fn writes_the_observed_total_length_even_with_partial_writes() { + let mut bytes = Fragmented(Vec::new()); + Frame { + tag: *b"COLE", + payload: Vec::new(), + nul_terminated: true, + } + .write(&mut bytes, Length::Total) + .unwrap(); + assert_eq!(bytes.0, b"\x0a\0\0\0COLE:\0"); + } + + #[test] + fn keeps_colons_in_payload_and_leaves_the_next_frame_unread() { + let frame = Frame { + tag: *b"DUNN", + payload: b"one:two".to_vec(), + nul_terminated: false, + }; + let mut bytes = Vec::new(); + frame.write(&mut bytes, Length::Total).unwrap(); + bytes.extend_from_slice(b"\x0a\0\0\0COLE:\0"); + let mut reader = Cursor::new(bytes); + assert_eq!(Frame::read(&mut reader, Length::Total).unwrap(), frame); + assert_eq!( + Frame::read(&mut reader, Length::Total).unwrap().tag, + *b"COLE" + ); + } + + #[test] + fn rejects_invalid_lengths_before_reading_a_body() { + for size in [0u32, 4, 8, MAX_FRAME_BYTES as u32 + 1, u32::MAX] { + let mut reader = Cursor::new(size.to_le_bytes()); + assert_eq!( + Frame::read(&mut reader, Length::Total).unwrap_err().kind(), + io::ErrorKind::InvalidData + ); + assert_eq!(reader.position(), 4); + } + } + + #[test] + fn rejects_truncated_or_malformed_frames() { + for bytes in [&b"\x0a\0\0"[..], &b"\x0a\0\0\0COLE:"[..]] { + assert_eq!( + Frame::read(&mut &bytes[..], Length::Total) + .unwrap_err() + .kind(), + io::ErrorKind::UnexpectedEof + ); + } + for bytes in [ + b"\x0a\0\0\0COLE=\0", + b"\x0a\0\0\0CO:E:x", + b"\x0a\0\0\0CO\0E:\0", + ] { + assert_eq!( + Frame::read(&mut &bytes[..], Length::Total) + .unwrap_err() + .kind(), + io::ErrorKind::InvalidData + ); + } + } + + #[test] + fn rejects_invalid_output_before_writing_any_bytes() { + let mut bytes = Vec::new(); + for frame in [ + Frame { + tag: *b"DUNN", + payload: vec![b'x'; MAX_FRAME_BYTES], + nul_terminated: false, + }, + Frame { + tag: *b"DUNN", + payload: b"one\0two".to_vec(), + nul_terminated: false, + }, + Frame { + tag: *b"CO:E", + payload: Vec::new(), + nul_terminated: false, + }, + ] { + assert!(frame.write(&mut bytes, Length::Total).is_err()); + assert!(bytes.is_empty()); + } + } + + #[test] + fn accepts_the_observed_unterminated_launch_reply_shape() { + let payload = vec![b'A'; 640]; + let mut bytes = 645u32.to_le_bytes().to_vec(); + bytes.extend_from_slice(b"DUNN:"); + bytes.extend_from_slice(&payload); + let frame = Frame::read(&mut Fragmented(&bytes[..]), Length::Body).unwrap(); + assert_eq!(bytes.len(), 649); + assert_eq!(frame.tag, *b"DUNN"); + assert_eq!(frame.payload, payload); + assert!(!frame.nul_terminated); + let mut encoded = Vec::new(); + frame.write(&mut encoded, Length::Body).unwrap(); + assert_eq!(encoded, bytes); + } + + #[test] + fn presents_a_complete_reply_to_the_pipe_in_one_write() { + struct Writes(Vec); + impl Write for Writes { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.0.push(bytes.len()); + Ok(bytes.len()) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + let mut writer = Writes(Vec::new()); + Frame { + tag: *b"DUNN", + payload: vec![b'A'; 640], + nul_terminated: false, + } + .write(&mut writer, Length::Body) + .unwrap(); + assert_eq!(writer.0, vec![649]); + } +} diff --git a/tools/rockstar-launcher/src/main.rs b/tools/rockstar-launcher/src/main.rs new file mode 100644 index 0000000000..fe5923ab37 --- /dev/null +++ b/tools/rockstar-launcher/src/main.rs @@ -0,0 +1,152 @@ +#![cfg_attr(windows, windows_subsystem = "windows")] + +#[cfg(windows)] +fn log(message: &str) { + use std::io::Write; + let Ok(exe) = std::env::current_exe() else { + return; + }; + let path = exe.with_file_name("launcher.log"); + if let Ok(metadata) = std::fs::symlink_metadata(&path) { + if !metadata.is_file() || metadata.len() > 65536 { + return; + } + } + if let Ok(mut file) = std::fs::OpenOptions::new() + .create(true) + .append(true) + .open(path) + { + let _ = writeln!(file, "{message}"); + } +} + +#[cfg(windows)] +fn run() -> Result> { + use droiddeck_rockstar_launcher::{pipe::Listener, wait_for_game, Frame, Length}; + use std::io::Read; + use std::time::{Duration, SystemTime, UNIX_EPOCH}; + + let config_path = std::env::current_exe()?.with_file_name("launch.json"); + let mut data = Vec::new(); + std::fs::File::open(&config_path)? + .take(16385) + .read_to_end(&mut data)?; + std::fs::remove_file(&config_path)?; + if data.len() > 16384 { + return Err("launch handoff exceeds size limit".into()); + } + let config: serde_json::Value = serde_json::from_slice(&data)?; + let text = |key| { + config + .get(key) + .and_then(|value| value.as_str()) + .ok_or("missing launch field") + }; + let expires = config + .get("expiresAt") + .and_then(|value| value.as_u64()) + .ok_or("missing launch expiry")?; + let now = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis() as u64; + if expires <= now || expires - now > 120_000 { + return Err("launch handoff expired".into()); + } + let material = text("material")?.as_bytes().to_vec(); + if material.len() != 640 || !material.iter().all(u8::is_ascii_hexdigit) { + return Err("invalid launch material".into()); + } + let pipe_name = text("pipe")?.to_owned(); + if !matches!( + pipe_name.as_str(), + "GTA3_Pipe" | "GTA-VC_Pipe" | "GTA_SA_Pipe" + ) { + return Err("unsupported Rockstar launch pipe".into()); + } + let root = std::fs::canonicalize(text("folder")?)?; + let exe = std::fs::canonicalize(text("exe")?)?; + let workdir = std::fs::canonicalize(text("workdir")?)?; + if !exe.is_file() + || !exe.starts_with(&root) + || !workdir.starts_with(&root) + || !root.join("MTLX.dll").is_file() + { + return Err("invalid Rockstar game path".into()); + } + if let Some(index) = + std::env::args().position(|arg| arg.eq_ignore_ascii_case("-launchTitleInFolder")) + { + let folder = std::env::args() + .nth(index + 1) + .ok_or("missing game folder")?; + if std::fs::canonicalize(folder)? != root { + return Err("Rockstar launch folder mismatch".into()); + } + } + let args = config + .get("args") + .and_then(|value| value.as_array()) + .ok_or("missing game arguments")?; + let args: Result, _> = args + .iter() + .map(|value| value.as_str().ok_or("invalid game argument")) + .collect(); + log("launch handoff accepted"); + let listener = Listener::new(&pipe_name, Duration::from_secs(30))?; + log("launcher pipe created"); + let mut child = std::process::Command::new(exe) + .current_dir(workdir) + .args(args?) + .spawn()?; + let pid = child.id(); + log("game process started"); + let (result, handshake) = std::sync::mpsc::sync_channel(1); + std::thread::spawn(move || { + let serve = || -> std::io::Result<()> { + let mut pipe = listener.accept()?; + log("launcher pipe connected"); + if pipe.client_pid()? != pid { + return Err(std::io::Error::new( + std::io::ErrorKind::PermissionDenied, + "unexpected Rockstar pipe client", + )); + } + let request = Frame::read(&mut pipe, Length::Total)?; + log("game greeting received"); + if request.tag != *b"COLE" || !request.payload.is_empty() { + return Err(std::io::Error::new( + std::io::ErrorKind::InvalidData, + "unexpected Rockstar greeting", + )); + } + Frame { + tag: *b"DUNN", + payload: material, + nul_terminated: false, + } + .write(&mut pipe, Length::Body)?; + log("launcher handshake complete"); + Ok(()) + }; + let outcome = serve(); + if let Err(error) = &outcome { + log(&format!("launcher handshake failed: {error}")); + } + let _ = result.send(outcome); + }); + Ok(wait_for_game(&mut child, handshake)?.code().unwrap_or(1)) +} + +fn main() { + #[cfg(windows)] + let code = match run() { + Ok(code) => code, + Err(error) => { + log(&format!("launch failed: {error}")); + eprintln!("Rockstar launch failed: {error}"); + 1 + } + }; + #[cfg(not(windows))] + let code = 1; + std::process::exit(code); +} diff --git a/tools/rockstar-launcher/src/pipe.rs b/tools/rockstar-launcher/src/pipe.rs new file mode 100644 index 0000000000..79ab4d9e42 --- /dev/null +++ b/tools/rockstar-launcher/src/pipe.rs @@ -0,0 +1,403 @@ +use std::ffi::c_void; +use std::io::{self, Read, Write}; +use std::os::windows::ffi::OsStrExt; +use std::ptr::{null, null_mut}; +use std::time::{Duration, Instant}; + +type Handle = *mut c_void; +const INVALID_HANDLE: Handle = -1isize as Handle; +const ERROR_IO_PENDING: i32 = 997; +const ERROR_MORE_DATA: i32 = 234; + +#[repr(C)] +struct Overlapped { + internal: usize, + internal_high: usize, + offset: u32, + offset_high: u32, + event: Handle, +} + +#[link(name = "kernel32")] +extern "system" { + fn CreateNamedPipeW( + name: *const u16, + open: u32, + mode: u32, + max: u32, + output: u32, + input: u32, + timeout: u32, + security: *const c_void, + ) -> Handle; + fn ConnectNamedPipe(handle: Handle, overlapped: *mut Overlapped) -> i32; + fn GetNamedPipeClientProcessId(handle: Handle, pid: *mut u32) -> i32; + fn CreateFileW( + name: *const u16, + access: u32, + share: u32, + security: *const c_void, + creation: u32, + flags: u32, + template: Handle, + ) -> Handle; + fn WaitNamedPipeW(name: *const u16, timeout: u32) -> i32; + fn CreateEventW(security: *const c_void, manual: i32, initial: i32, name: *const u16) + -> Handle; + fn CloseHandle(handle: Handle) -> i32; + fn ReadFile( + handle: Handle, + buffer: *mut u8, + size: u32, + read: *mut u32, + overlapped: *mut Overlapped, + ) -> i32; + fn WriteFile( + handle: Handle, + buffer: *const u8, + size: u32, + written: *mut u32, + overlapped: *mut Overlapped, + ) -> i32; + fn WaitForSingleObject(handle: Handle, timeout: u32) -> u32; + fn CancelIoEx(handle: Handle, overlapped: *mut Overlapped) -> i32; + fn GetOverlappedResult( + handle: Handle, + overlapped: *mut Overlapped, + transferred: *mut u32, + wait: i32, + ) -> i32; +} + +struct OwnedHandle(Handle); + +unsafe impl Send for OwnedHandle {} + +impl Drop for OwnedHandle { + fn drop(&mut self) { + unsafe { + CloseHandle(self.0); + } + } +} + +pub struct Pipe { + handle: OwnedHandle, + timeout: Duration, +} + +pub struct Listener(Pipe); + +impl Listener { + pub fn new(name: &str, timeout: Duration) -> io::Result { + if name.is_empty() || name.contains(['\\', '/', '\0']) { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "invalid pipe name", + )); + } + let path = format!(r"\\.\pipe\{name}"); + let wide: Vec<_> = std::ffi::OsStr::new(&path) + .encode_wide() + .chain(Some(0)) + .collect(); + let handle = unsafe { + CreateNamedPipeW( + wide.as_ptr(), + 3 | 0x4000_0000 | 0x0008_0000, + 8, + 1, + 65536, + 65536, + 0, + null(), + ) + }; + if handle == INVALID_HANDLE { + return Err(io::Error::last_os_error()); + } + Ok(Self(Pipe { + handle: OwnedHandle(handle), + timeout, + })) + } + + pub fn accept(self) -> io::Result { + let event = unsafe { CreateEventW(null(), 1, 0, null()) }; + if event.is_null() { + return Err(io::Error::last_os_error()); + } + let event = OwnedHandle(event); + let mut overlapped = Overlapped { + internal: 0, + internal_high: 0, + offset: 0, + offset_high: 0, + event: event.0, + }; + if unsafe { ConnectNamedPipe(self.0.handle.0, &mut overlapped) } != 0 { + return Ok(self.0); + } + let error = io::Error::last_os_error(); + if error.raw_os_error() == Some(535) { + return Ok(self.0); + } + if error.raw_os_error() != Some(ERROR_IO_PENDING) { + return Err(error); + } + let wait = unsafe { + WaitForSingleObject( + event.0, + self.0.timeout.as_millis().min(u32::MAX as u128 - 1) as u32, + ) + }; + let mut transferred = 0; + if wait != 0 { + let error = if wait == 258 { + io::Error::new(io::ErrorKind::TimedOut, "waiting for Rockstar game") + } else { + io::Error::last_os_error() + }; + unsafe { + CancelIoEx(self.0.handle.0, &mut overlapped); + GetOverlappedResult(self.0.handle.0, &mut overlapped, &mut transferred, 1); + } + return Err(error); + } + if unsafe { GetOverlappedResult(self.0.handle.0, &mut overlapped, &mut transferred, 0) } + == 0 + { + return Err(io::Error::last_os_error()); + } + Ok(self.0) + } +} + +impl Pipe { + pub fn client_pid(&self) -> io::Result { + let mut pid = 0; + if unsafe { GetNamedPipeClientProcessId(self.handle.0, &mut pid) } == 0 || pid == 0 { + return Err(io::Error::last_os_error()); + } + Ok(pid) + } + pub fn connect(name: &str, timeout: Duration) -> io::Result { + if name.is_empty() || name.contains(['\\', '/', '\0']) { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "invalid pipe name", + )); + } + let path = format!(r"\\.\pipe\{name}"); + let wide: Vec<_> = std::ffi::OsStr::new(&path) + .encode_wide() + .chain(Some(0)) + .collect(); + let deadline = Instant::now() + timeout; + loop { + let handle = unsafe { + CreateFileW( + wide.as_ptr(), + 0xc000_0000, + 0, + null(), + 3, + 0x4000_0000, + null_mut(), + ) + }; + if handle != INVALID_HANDLE { + return Ok(Self { + handle: OwnedHandle(handle), + timeout, + }); + } + let error = io::Error::last_os_error(); + if !matches!(error.raw_os_error(), Some(2 | 231)) { + return Err(error); + } + let remaining = deadline.saturating_duration_since(Instant::now()); + if remaining.is_zero() { + return Err(io::Error::new( + io::ErrorKind::TimedOut, + "waiting for Rockstar pipe", + )); + } + unsafe { + WaitNamedPipeW(wide.as_ptr(), remaining.as_millis().min(50) as u32); + } + std::thread::sleep(remaining.min(Duration::from_millis(2))); + } + } + + fn transfer(&self, buffer: *mut u8, size: usize, writing: bool) -> io::Result { + if size == 0 { + return Ok(0); + } + let event = unsafe { CreateEventW(null(), 1, 0, null()) }; + if event.is_null() { + return Err(io::Error::last_os_error()); + } + let event = OwnedHandle(event); + let mut overlapped = Overlapped { + internal: 0, + internal_high: 0, + offset: 0, + offset_high: 0, + event: event.0, + }; + let mut transferred = 0; + let size = size.min(u32::MAX as usize) as u32; + let ok = unsafe { + if writing { + WriteFile( + self.handle.0, + buffer, + size, + &mut transferred, + &mut overlapped, + ) + } else { + ReadFile( + self.handle.0, + buffer, + size, + &mut transferred, + &mut overlapped, + ) + } + }; + if ok != 0 { + return Ok(transferred as usize); + } + let error = io::Error::last_os_error(); + if error.raw_os_error() == Some(ERROR_MORE_DATA) && !writing && transferred > 0 { + return Ok(transferred as usize); + } + if error.raw_os_error() != Some(ERROR_IO_PENDING) { + return Err(error); + } + let wait = unsafe { + WaitForSingleObject( + event.0, + self.timeout.as_millis().min(u32::MAX as u128 - 1) as u32, + ) + }; + if wait != 0 { + let error = if wait == 258 { + io::Error::new(io::ErrorKind::TimedOut, "Rockstar pipe operation timed out") + } else { + io::Error::last_os_error() + }; + unsafe { + CancelIoEx(self.handle.0, &mut overlapped); + GetOverlappedResult(self.handle.0, &mut overlapped, &mut transferred, 1); + } + return Err(error); + } + let ok = + unsafe { GetOverlappedResult(self.handle.0, &mut overlapped, &mut transferred, 0) }; + if ok != 0 { + return Ok(transferred as usize); + } + let error = io::Error::last_os_error(); + if error.raw_os_error() == Some(ERROR_MORE_DATA) && !writing && transferred > 0 { + return Ok(transferred as usize); + } + Err(error) + } +} + +impl Read for Pipe { + fn read(&mut self, buffer: &mut [u8]) -> io::Result { + self.transfer(buffer.as_mut_ptr(), buffer.len(), false) + } +} + +impl Write for Pipe { + fn write(&mut self, buffer: &[u8]) -> io::Result { + self.transfer(buffer.as_ptr() as *mut u8, buffer.len(), true) + } + + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{Frame, Length}; + use std::sync::mpsc; + use std::time::{SystemTime, UNIX_EPOCH}; + + fn name() -> String { + format!( + "dd-rockstar-test-{}-{}", + std::process::id(), + SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap() + .as_nanos() + ) + } + + #[test] + fn real_pipe_exchanges_both_framing_modes_and_identifies_the_client() { + let name = name(); + let listener = Listener::new(&name, Duration::from_secs(2)).unwrap(); + let worker = std::thread::spawn(move || { + let mut server = listener.accept().unwrap(); + assert_eq!(server.client_pid().unwrap(), std::process::id()); + assert_eq!( + Frame::read(&mut server, Length::Total).unwrap().tag, + *b"COLE" + ); + Frame { + tag: *b"DUNN", + payload: vec![b'A'; 640], + nul_terminated: false, + } + .write(&mut server, Length::Body) + .unwrap(); + }); + let mut client = Pipe::connect(&name, Duration::from_secs(2)).unwrap(); + Frame { + tag: *b"COLE", + payload: Vec::new(), + nul_terminated: true, + } + .write(&mut client, Length::Total) + .unwrap(); + let response = Frame::read(&mut client, Length::Body).unwrap(); + assert_eq!(response.payload.len(), 640); + assert!(!response.nul_terminated); + worker.join().unwrap(); + } + + #[test] + fn timed_out_accept_releases_the_first_pipe_instance() { + let name = name(); + let listener = Listener::new(&name, Duration::from_millis(20)).unwrap(); + assert!(matches!(listener.accept(), Err(error) if error.kind() == io::ErrorKind::TimedOut)); + assert!(Listener::new(&name, Duration::from_millis(20)).is_ok()); + } + + #[test] + fn timed_out_read_cancels_the_pending_operation() { + let name = name(); + let listener = Listener::new(&name, Duration::from_secs(2)).unwrap(); + let (done, wait) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _server = listener.accept().unwrap(); + wait.recv_timeout(Duration::from_secs(2)).unwrap(); + }); + let mut client = Pipe::connect(&name, Duration::from_millis(30)).unwrap(); + assert_eq!( + client.read(&mut [0u8; 4]).unwrap_err().kind(), + io::ErrorKind::TimedOut + ); + done.send(()).unwrap(); + worker.join().unwrap(); + } +} diff --git a/tools/tests/test_store_launch_rockstar.py b/tools/tests/test_store_launch_rockstar.py new file mode 100644 index 0000000000..68f4401544 --- /dev/null +++ b/tools/tests/test_store_launch_rockstar.py @@ -0,0 +1,90 @@ +import json +from pathlib import Path +import tempfile +import time +import unittest +from unittest.mock import patch + +from test_store_launch import store + + +class RockstarLaunch(unittest.TestCase): + def setup_game(self, root): + folder = Path(root) / 'game' + folder.mkdir() + exe = bytearray(128) + exe[:2] = b'MZ' + exe[0x3c:0x40] = (64).to_bytes(4, 'little') + exe[64:70] = b'PE\0\0\x4c\x01' + (folder / 'gta-vc.exe').write_bytes(exe) + (folder / 'MTLX.dll').write_bytes(b'vendor') + prefix = Path(root) / 'prefix' + (prefix / 'pfx').mkdir(parents=True) + (prefix / 'pfx/user.reg').write_text('WINE REGISTRY Version 2\n') + (prefix / 'pfx/system.reg').write_text('WINE REGISTRY Version 2\n') + service = Path(root) / 'service' + service.mkdir() + (service / 'Launcher32.exe').write_bytes(b'compiled-helper') + sidecar = {'store': 'rockstar', 'id': 'gtavc', 'exe': 'gta-vc.exe', 'args': ['one argument', '&literal']} + answer = {'ok': True, 'pipe': 'GTA-VC_Pipe', 'material': 'A' * 640, + 'expiresAt': int(time.time() * 1000) + 90000, 'ticket': 'must-not-be-exported'} + return folder, sidecar, prefix, service, answer + + def prepare(self, root, modify=lambda values: None): + values = self.setup_game(root) + modify(values) + folder, sidecar, prefix, service, answer = values + config = prefix / 'pfx' / store.ROCKSTAR_FOLDER / 'launch.json' + config.parent.mkdir(parents=True) + config.write_text('stale') + requests = [] + + def ask(channel, request, timeout): + requests.append(request) + return answer + + with patch.object(store, 'ROCKSTAR_SERVICE', service), patch.object(store, 'rockstar_registry', return_value=True): + result = store.prepare_rockstar(folder, sidecar, str(prefix), str(Path(root) / 'channel'), ask_app=ask) + return result, config, requests + + def test_handoff_contains_only_launch_fields_and_preserves_argument_boundaries(self): + with tempfile.TemporaryDirectory() as root: + result, path, requests = self.prepare(root) + self.assertEqual('ready', result) + data = json.loads(path.read_text()) + self.assertEqual({'folder', 'exe', 'workdir', 'args', 'pipe', 'material', 'expiresAt'}, set(data)) + self.assertEqual(['one argument', '&literal'], data['args']) + self.assertNotIn('must-not-be-exported', path.read_text()) + self.assertEqual('rockstar-launch', requests[0]['op']) + self.assertEqual(b'compiled-helper', path.with_name('Launcher.exe').read_bytes()) + + def test_rejected_or_expired_sessions_cannot_reuse_stale_material(self): + for update in ({'ok': False, 'reason': 'not-owned'}, {'material': 'A' * 641}, {'expiresAt': 1}): + with self.subTest(update=update), tempfile.TemporaryDirectory() as root: + result, config, _ = self.prepare(root, lambda values: values[4].update(update)) + self.assertNotEqual('ready', result) + self.assertFalse(config.exists()) + + def test_path_escape_does_not_request_account_data(self): + with tempfile.TemporaryDirectory() as root: + def change(values): + (Path(root) / 'outside.exe').write_bytes(b'MZ') + values[1]['exe'] = '../outside.exe' + result, config, requests = self.prepare(root, change) + self.assertEqual('invalid-game-path', result) + self.assertEqual([], requests) + self.assertFalse(config.exists()) + + def test_writes_both_registry_views_and_escapes_values(self): + with tempfile.TemporaryDirectory() as root: + folder, _, prefix, _, _ = self.setup_game(root) + with patch.object(store, 'wait_for_server', return_value=True): + self.assertTrue(store.rockstar_registry(folder, 'Grand Theft Auto: Vice City', prefix, '')) + text = (prefix / 'pfx/system.reg').read_text() + self.assertIn(r'[Software\\Rockstar Games\\Launcher]', text) + self.assertIn(r'[Software\\Wow6432Node\\Rockstar Games\\Launcher]', text) + self.assertIn('Grand Theft Auto: Vice City', text) + + +if __name__ == '__main__': + unittest.main()