feat(stores): add Rockstar store and classic GTA launches

This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-11-12 20:24:13 -05:00
1 parent 9cc37d0a12
commit b841b232b4
42 files changed
+2708 -22

No files matched your search

@@ -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))
@@ -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("<!DOCTYPE Response SYSTEM 'https://example.invalid/external'><Response />")
}
}
}
@@ -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 = """<?xml version="1.0" encoding="utf-8"?>
<Response xmlns="GetAppsAndPackages"><Status>1</Status><Result><Apps>
<App Id="2" Name="launcher" TitleId="21" IsReleased="true"><Branches>
<Branch Id="4" Name="default" BuildId="1311" IsDefault="true" AppId="2"><AccessToken>BRANCHACCESS token="L"</AccessToken></Branch>
</Branches></App>
<App Id="3" Name="gta5" TitleId="11" IsReleased="true"><Branches /></App>
<App Id="10" Name="rdr2" TitleId="13" IsReleased="true"><Branches /></App>
<App Id="15" Name="rdr2_sp_steam" TitleId="13" IsReleased="false"><Branches>
<Branch Id="23" Name="default" BuildId="-1" IsDefault="true" AppId="15"><AccessToken>BRANCHACCESS token="S"</AccessToken></Branch>
</Branches></App>
<App Id="11" Name="gta4" TitleId="1" IsReleased="true"><Branches>
<Branch Id="30" Name="beta" BuildId="7" IsDefault="false" AppId="11"><AccessToken>BRANCHACCESS token="B"</AccessToken></Branch>
<Branch Id="31" Name="default" BuildId="8" IsDefault="true" AppId="11"><AccessToken>BRANCHACCESS token="D"</AccessToken></Branch>
</Branches></App>
<App Id="20" Name="gtatrilogy" TitleId="18" IsReleased="true"><Branches /></App>
</Apps><RglUiPackages>
<Package><PackageJson>{"title":"gta4","isFeatured":false,"packageType":"title"}</PackageJson></Package>
<Package><PackageJson>{"title":"rdr2","isFeatured":false,"packageType":"title"}</PackageJson></Package>
<Package><PackageJson>{"title":"gtatrilogy","isFeatured":true,"packageType":"bundle"}</PackageJson></Package>
<Package><PackageJson>{"title":"gta5","isFeatured":false,"packageType":"title"}</PackageJson></Package>
</RglUiPackages></Result></Response>"""
private fun account(xml: String = apps) = RockstarRos.parse(xml).let { RockstarAccountApps(RockstarApps.parse(it), RockstarApps.packages(it)) }
private val manifest = """<?xml version="1.0" encoding="utf-8"?>
<Response xmlns="GetBuildManifestFull"><Status>1</Status>
<Result BuildId="1311" VersionNumber="1.0.110.3150"><FileManifest>
<FileDetails FileEntryId="973" FileEntryVersionId="25837" FileSize="30">
<RelativePath>Launcher.exe</RelativePath>
<FileChunks><Chunk FileChunkId="46859" SHA256Hash="AB" StartByteOffset="0" Size="20" /><Chunk FileChunkId="46860" SHA256Hash="cd" StartByteOffset="20" Size="10" /></FileChunks>
<SHA256Hash>FF</SHA256Hash>
</FileDetails>
<FileDetails FileEntryId="981" FileEntryVersionId="2" FileSize="4">
<RelativePath>ThirdParty\Steam\steam_api64.dll</RelativePath>
<FileChunks><Chunk FileChunkId="1" SHA256Hash="ee" StartByteOffset="0" Size="4" /></FileChunks>
<SHA256Hash>ee</SHA256Hash>
</FileDetails>
</FileManifest><IsPreload>false</IsPreload></Result></Response>"""
@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("<Response><Status>0</Status><Error Code=\"AuthenticationFailed\" CodeEx=\"Ticket\"/></Response>")
assertEquals("AuthenticationFailed", RockstarRos.first(root, "Error")!!.getAttribute("Code"))
}
@Test fun ticketAnswerGivesTheAccountAndExpiry() {
val root = RockstarRos.parse("""<Response xmlns="CreateTicketResponse"><Status>1</Status><Ticket>T</Ticket><SessionKey>K</SessionKey>
<SessionTicket>S</SessionTicket><SecsUntilExpiration>86399</SecsUntilExpiration>
<RockstarAccount><RockstarId>42</RockstarId><Nickname>player</Nickname></RockstarAccount></Response>""")
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"))
}
}