Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

fix: adapt PR235 Stalker sync hardening

David Nashash9c1f265bf5a1
diff --git a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
index 074a4345..e9973d1f 100644
--- a/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
+++ b/data/src/main/java/com/streamvault/data/local/dao/Daos.kt
@@ -3046,6 +3046,10 @@ interface CategoryDao {
@Query("UPDATE categories SET is_user_protected = :isProtected WHERE provider_id = :providerId AND category_id = :categoryId AND type = :type")
suspend fun updateProtectionStatus(providerId: Long, categoryId: Long, type: String, isProtected: Boolean)
+
+ /** Repairs a layout/type mismatch without forcing a catalog re-download. */
+ @Query("UPDATE categories SET type = :toType WHERE provider_id = :providerId AND type = :fromType")
+ suspend fun retargetType(providerId: Long, fromType: String, toType: String): Int
}
@Dao
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
index a52a97b9..c66083e1 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
@@ -96,6 +96,7 @@ class OkHttpStalkerApiService @Inject constructor(
private data class SessionScope(
val cookieJar: InMemoryStalkerCookieJar = InMemoryStalkerCookieJar(),
+ @Volatile var restoredCookieHeader: String = "",
@Volatile var macQueryRequired: Boolean = false,
@Volatile var lastAccessAt: Long = System.currentTimeMillis()
)
@@ -176,6 +177,7 @@ class OkHttpStalkerApiService @Inject constructor(
val attemptProfile = profile.withRecipe(recipe, effectiveAuthMode)
val sessionScope = sessionScopeFor(attemptProfile)
sessionScope.cookieJar.clear()
+ sessionScope.restoredCookieHeader = ""
val cookieJar = sessionScope.cookieJar
// Compatibility discovery is per authentication scope. A portal may
// change its request contract between profiles/endpoints, so do not
@@ -210,8 +212,20 @@ class OkHttpStalkerApiService @Inject constructor(
val token = handshakePayload.findString("token")
?.takeIf { it.isNotBlank() }
?: run {
- lastError = IOException("Portal handshake did not return a token.")
- continue
+ // A 200 without a token is a soft throttle. Stop discovery rather
+ // than firing more handshakes into the portal limiter.
+ val throttled = StalkerApiError.RateLimited(
+ message = "Portal handshake did not return a token.",
+ httpStatus = 200
+ )
+ StalkerTelemetry.authenticationAttempt(
+ profile.providerId,
+ recipe.compatibilityProfileId,
+ endpointFamily,
+ "HANDSHAKE",
+ authenticationFailureOutcome(throttled)
+ )
+ return Result.error(throttled.message.orEmpty(), throttled)
}
val handshakeRandom = handshakePayload.findString("random").orEmpty()
resolvedLoadUrl(loadUrl, attemptProfile)?.let { redirectedLoadUrl ->
@@ -1271,6 +1285,16 @@ class OkHttpStalkerApiService @Inject constructor(
.orEmpty()
.ifBlank { session.serverCookieHeader }
+ override fun restoreSession(session: StalkerSession, profile: StalkerDeviceProfile) {
+ val scopeKey = session.sessionScopeKey.takeIf { it.isNotBlank() } ?: sessionScopeKey(profile)
+ val scope = sessionScopes.computeIfAbsent(scopeKey) {
+ SessionScope(lastAccessAt = System.currentTimeMillis())
+ }
+ scope.lastAccessAt = System.currentTimeMillis()
+ scope.restoredCookieHeader = session.serverCookieHeader
+ scopeAliases[sessionScopeAliasKey(profile)] = scopeKey
+ }
+
override fun invalidateSessionScopes(providerId: Long) {
val prefix = "provider:$providerId|"
sessionScopes.keys.filter { it.startsWith(prefix) }.forEach { key ->
@@ -2721,13 +2745,19 @@ class OkHttpStalkerApiService @Inject constructor(
profile.macAddress.takeIf { it.isNotBlank() }?.let { cookies["mac"] = encode(it) }
profile.locale.takeIf { it.isNotBlank() }?.let { cookies["stb_lang"] = encode(it) }
profile.timezone.takeIf { it.isNotBlank() }?.let { cookies["timezone"] = encode(it) }
- cookieJarFor(profile).cookieHeaderFor(url).split(';')
- .mapNotNull { part ->
- val key = part.substringBefore('=', missingDelimiterValue = "").trim()
- val value = part.substringAfter('=', missingDelimiterValue = "").trim()
- key.takeIf { it.isNotBlank() && value.isNotBlank() }?.let { it to value }
- }.forEach { (key, value) ->
- cookies.putIfAbsent(key, value)
+ val sessionScope = sessionScopeFor(profile)
+ listOf(
+ sessionScope.cookieJar.cookieHeaderFor(url),
+ sessionScope.restoredCookieHeader
+ ).forEach { header ->
+ header.split(';')
+ .mapNotNull { part ->
+ val key = part.substringBefore('=', missingDelimiterValue = "").trim()
+ val value = part.substringAfter('=', missingDelimiterValue = "").trim()
+ key.takeIf { it.isNotBlank() && value.isNotBlank() }?.let { it to value }
+ }.forEach { (key, value) ->
+ cookies.putIfAbsent(key, value)
+ }
}
return cookies.entries.joinToString("; ") { (key, value) -> "$key=$value" }
}
@@ -2872,11 +2902,8 @@ class OkHttpStalkerApiService @Inject constructor(
private fun sessionScopeFor(profile: StalkerDeviceProfile): SessionScope {
val now = System.currentTimeMillis()
- val key = if (profile.authEpoch > 0L) {
- sessionScopeKey(profile)
- } else {
- scopeAliases[sessionScopeAliasKey(profile)] ?: sessionScopeKey(profile)
- }
+ val key = scopeAliases[sessionScopeAliasKey(profile)]
+ ?: sessionScopeKey(profile)
val scope = sessionScopes.computeIfAbsent(key) { SessionScope(lastAccessAt = now) }
scope.lastAccessAt = now
if (sessionScopes.size > MAX_SESSION_SCOPES) {
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiError.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiError.kt
index 5d6295f0..946c083d 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiError.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiError.kt
@@ -143,3 +143,7 @@ internal fun isStalkerAuthorizationFailure(message: String, error: Throwable?):
"http 403"
).any(normalized::contains)
}
+
+/** True when the portal is hard- or soft-throttling authentication attempts. */
+internal fun Throwable.isPortalThrottle(): Boolean =
+ generateSequence(this) { it.cause }.any { it is StalkerApiError.RateLimited }
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt
index 85d0c2ba..bb35c4f6 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerApiService.kt
@@ -300,6 +300,9 @@ interface StalkerApiService {
/** Removes all in-memory transport/session state owned by one provider. */
fun invalidateSessionScopes(providerId: Long) = Unit
+ /** Restores persisted session transport state before a resumed request. */
+ fun restoreSession(session: StalkerSession, profile: StalkerDeviceProfile) = Unit
+
suspend fun getLiveCategories(
session: StalkerSession,
profile: StalkerDeviceProfile
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt
index fe4bf868..32e2db12 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt
@@ -3,10 +3,12 @@ package com.streamvault.data.remote.stalker
import com.streamvault.data.local.dao.StalkerPortalStateDao
import com.streamvault.data.local.dao.ProviderSnapshotDao
import com.streamvault.data.local.entity.StalkerPortalStateEntity
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.StalkerCookieMode
import com.streamvault.domain.model.StalkerEndpointPreference
import com.streamvault.domain.model.StalkerPlaybackBackendHint
+import com.google.gson.Gson
import java.security.MessageDigest
import javax.inject.Inject
import javax.inject.Singleton
@@ -15,13 +17,18 @@ import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import kotlinx.serialization.json.longOrNull
@Singleton
class StalkerPortalStateStore @Inject constructor(
private val dao: StalkerPortalStateDao,
+ private val credentialCrypto: CredentialCrypto,
private val providerSnapshotDao: ProviderSnapshotDao? = null
) {
private val json = Json { ignoreUnknownKeys = true }
+ private val gson = Gson()
suspend fun getValidated(providerId: Long, now: Long = System.currentTimeMillis()): StalkerPortalStateEntity? =
dao.get(providerId)?.takeIf { state ->
@@ -30,6 +37,62 @@ class StalkerPortalStateStore @Inject constructor(
suspend fun get(providerId: Long): StalkerPortalStateEntity? = dao.get(providerId)
+ /**
+ * Durable session resurrected after a process restart. The session envelope is encrypted
+ * with the app's Keystore-backed credential crypto and is only reused for the same
+ * configuration generation inside the local session age cap.
+ */
+ data class ResumedStalkerAuth(
+ val session: StalkerSession,
+ val profile: StalkerProviderProfile
+ )
+
+ suspend fun resumableAuth(
+ providerId: Long,
+ configurationGeneration: Long,
+ now: Long = System.currentTimeMillis(),
+ maxAgeMillis: Long = STALKER_SESSION_MAX_AGE_MILLIS
+ ): ResumedStalkerAuth? {
+ if (providerId <= 0L) return null
+ val state = dao.get(providerId) ?: return null
+ if (state.configurationGeneration != configurationGeneration) return null
+ val learning = runCatching {
+ json.parseToJsonElement(state.learningJson.ifBlank { "{}" }).jsonObject
+ }.getOrNull() ?: return null
+ if (learning["configurationGeneration"]?.jsonPrimitive?.longOrNull != configurationGeneration) {
+ return null
+ }
+ val session = runCatching {
+ val encrypted = learning["resumableSession"]?.jsonPrimitive?.content ?: return@runCatching null
+ gson.fromJson(
+ credentialCrypto.decryptIfNeeded(encrypted),
+ StalkerSession::class.java
+ )
+ }.getOrNull() ?: return null
+ val profile = runCatching {
+ val encoded = learning["resumableProfile"]?.jsonPrimitive?.content ?: return@runCatching null
+ gson.fromJson(encoded, StalkerProviderProfile::class.java)
+ }.getOrNull() ?: return null
+ if (session.token.isBlank()) return null
+ if (profile.profileRevision != StalkerCompatibilityRegistry.REVISION) return null
+ if (now - session.authenticatedAtMillis > maxAgeMillis) return null
+ if (session.isExpired(now)) return null
+ if (profile.expirationDate?.let { it <= now } == true) return null
+ return ResumedStalkerAuth(session, profile)
+ }
+
+ /** Drops a persisted session after the portal rejects its token without touching hints. */
+ suspend fun clearResumableAuth(providerId: Long) {
+ if (providerId <= 0L) return
+ update(providerId) { state ->
+ val learning = mutableLearning(state.learningJson)
+ if (learning.remove("resumableSession") == null && learning.remove("resumableProfile") == null) {
+ return@update state
+ }
+ state.copy(learningJson = JsonObject(learning).toString())
+ }
+ }
+
suspend fun recordAuthentication(
providerId: Long,
session: StalkerSession,
@@ -358,6 +421,10 @@ class StalkerPortalStateStore @Inject constructor(
learning["protocolFamily"] = observationJson(profile.protocolFamily.name, generation, observedAt, "AUTHENTICATION")
learning["bootstrapRecipe"] = observationJson(profile.bootstrapRecipe.name, generation, observedAt, "AUTHENTICATION")
learning["workingEndpoint"] = observationJson(session.loadUrl, generation, observedAt, "AUTHENTICATION")
+ learning["resumableSession"] = JsonPrimitive(
+ credentialCrypto.encryptIfNeeded(gson.toJson(session))
+ )
+ learning["resumableProfile"] = JsonPrimitive(gson.toJson(profile))
return JsonObject(learning).toString()
}
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
index f4973d04..9d386397 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
@@ -140,6 +140,7 @@ internal companion object {
private const val FALLBACK_SURROGATE_FLOOR = 4_000_000_000L
const val CATALOG_LAYOUT_DETECTION_VERSION = 1
private val sharedAuthCache = ConcurrentHashMap<String, CachedAuth>()
+ private val sharedPortalAuthCache = ConcurrentHashMap<String, CachedAuth>()
private val sharedAuthFailureCache = ConcurrentHashMap<String, CachedAuthFailure>()
private val sharedAuthMutexes = KeyedMutexRegistry<String>()
private val resolvedStreamUrlCache = ConcurrentHashMap<String, CachedResolvedUrl>()
@@ -147,6 +148,7 @@ internal companion object {
fun clearSharedAuthCacheForTests() {
sharedAuthCache.clear()
+ sharedPortalAuthCache.clear()
sharedAuthFailureCache.clear()
}
@@ -159,6 +161,8 @@ internal companion object {
if (providerId <= 0L) return
val authPrefix = "provider:$providerId|"
sharedAuthCache.keys.filter { it.startsWith(authPrefix) }.forEach(sharedAuthCache::remove)
+ val portalPrefix = "portal:$providerId|"
+ sharedPortalAuthCache.keys.filter { it.startsWith(portalPrefix) }.forEach(sharedPortalAuthCache::remove)
sharedAuthFailureCache.keys.filter { it.startsWith(authPrefix) }.forEach(sharedAuthFailureCache::remove)
resolvedStreamUrlCache.keys
.filter { it.startsWith("$providerId|") }
@@ -168,6 +172,7 @@ internal companion object {
private fun trimSharedCaches() {
trimMap(sharedAuthCache, MAX_AUTH_CACHE_ENTRIES)
+ trimMap(sharedPortalAuthCache, MAX_AUTH_CACHE_ENTRIES)
trimMap(sharedAuthFailureCache, MAX_AUTH_CACHE_ENTRIES)
trimMap(resolvedStreamUrlCache, MAX_RESOLVED_URL_CACHE_ENTRIES)
while (missingVodClassificationLogged.size > MAX_MISSING_CLASSIFICATION_ENTRIES) {
@@ -225,7 +230,11 @@ internal companion object {
authFailureCache = null
categoryCache.clear()
sharedAuthCache.remove(authCacheKey())
+ if (providerId > 0L) {
+ sharedPortalAuthCache.remove(portalIdentityKey())
+ }
sharedAuthFailureCache.remove(authCacheKey())
+ portalStateStore?.clearResumableAuth(providerId)
clearResolvedStreamUrlCache()
api.invalidateSessionScopes(providerId)
}
@@ -1404,6 +1413,9 @@ is Result.Success -> {
sessionCache = null
accountProfileCache = null
sharedAuthCache.remove(authCacheKey())
+ if (providerId > 0L) {
+ sharedPortalAuthCache.remove(portalIdentityKey())
+ }
api.invalidateSessionScopes(providerId)
}
(authFailureCache ?: sharedAuthFailureCache[authCacheKey()])?.let { failure ->
@@ -1419,12 +1431,42 @@ is Result.Success -> {
) {
sessionCache = cachedAuth.session
accountProfileCache = cachedAuth.profile
+ api.restoreSession(cachedAuth.session, currentDeviceProfile())
return@withLock Result.success(cachedAuth.session to cachedAuth.profile)
}
sharedAuthCache.remove(authCacheKey(), cachedAuth)
api.invalidateSessionScopes(providerId)
}
+ if (providerId > 0L) {
+ sharedPortalAuthCache[portalIdentityKey()]?.let { cachedAuth ->
+ if (!cachedAuth.session.isExpired() &&
+ cachedAuth.profile.expirationDate?.let { it > System.currentTimeMillis() } != false
+ ) {
+ sessionCache = cachedAuth.session
+ accountProfileCache = cachedAuth.profile
+ sharedAuthCache[authCacheKey()] = cachedAuth
+ api.restoreSession(cachedAuth.session, currentDeviceProfile())
+ return@withLock Result.success(cachedAuth.session to cachedAuth.profile)
+ }
+ sharedPortalAuthCache.remove(portalIdentityKey(), cachedAuth)
+ api.invalidateSessionScopes(providerId)
+ }
+ }
+
+ if (providerId > 0L) {
+ portalStateStore?.resumableAuth(providerId, configurationGeneration)?.let { resumed ->
+ sessionCache = resumed.session
+ accountProfileCache = resumed.profile
+ val cachedAuth = CachedAuth(session = resumed.session, profile = resumed.profile)
+ sharedAuthCache[authCacheKey()] = cachedAuth
+ sharedPortalAuthCache[portalIdentityKey()] = cachedAuth
+ api.restoreSession(resumed.session, currentDeviceProfile())
+ StalkerTelemetry.strategySelected(providerId, "RESUMED_SESSION", "PERSISTED_TOKEN")
+ return@withLock Result.success(resumed.session to resumed.profile)
+ }
+ }
+
val persistedState = portalStateStore?.getValidated(providerId)
val hasPersistedAuthentication = persistedState?.let { state ->
!state.workingEndpoint.isNullOrBlank() || !state.bootstrapRecipe.isNullOrBlank()
@@ -1487,8 +1529,13 @@ is Result.Success -> {
onProgress = onProgress
).copy(providerId = providerId)
val initialAuthResult = discoveryCoordinator.authenticate(profile)
+ val initialAuthThrottled = (initialAuthResult as? Result.Error)?.exception?.isPortalThrottle() == true
val finalAuthResult = when {
initialAuthResult !is Result.Error -> initialAuthResult
+ initialAuthThrottled -> {
+ StalkerTelemetry.strategySelected(providerId, "AUTH_THROTTLE_BACKOFF", "THROTTLED_AUTH_RETRY_SKIPPED")
+ initialAuthResult
+ }
persistedEndpointUrl != null -> {
portalStateStore?.markEndpointUnhealthy(
providerId,
@@ -1534,6 +1581,12 @@ is Result.Success -> {
session = authResult.data.first,
profile = authResult.data.second
)
+ if (providerId > 0L) {
+ sharedPortalAuthCache[portalIdentityKey()] = CachedAuth(
+ session = authResult.data.first,
+ profile = authResult.data.second
+ )
+ }
trimSharedCaches()
portalStateStore?.recordAuthentication(
providerId = providerId,
@@ -2581,6 +2634,22 @@ private fun playbackTransportChallengeFor(url: String): StalkerTransportChalleng
return "provider:$providerId|$digest"
}
+ /** Stable portal identity used when learned hints differ between provider instances. */
+ private fun portalIdentityKey(): String {
+ val normalized = listOf(
+ providerId.toString(),
+ StalkerUrlFactory.normalizePortalUrl(portalUrl),
+ normalizedMacAddress(),
+ authMode.name,
+ normalizedUsername(),
+ normalizedPassword()
+ ).joinToString(separator = "\u001f")
+ val digest = MessageDigest.getInstance("SHA-256")
+ .digest(normalized.toByteArray(Charsets.UTF_8))
+ .joinToString("") { byte -> "%02x".format(byte.toInt() and 0xff) }
+ return "portal:$providerId|$digest"
+ }
+
private fun authMutexKey(): String = "provider:$providerId|auth"
private fun resolveProviderStatus(profile: StalkerProviderProfile): ProviderStatus {
diff --git a/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt
index ccd091a5..ba869208 100644
--- a/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt
+++ b/data/src/main/java/com/streamvault/data/sync/StalkerCatalogSyncExecutor.kt
@@ -145,6 +145,7 @@ internal class StalkerCatalogSyncExecutor(
}
}
readinessTracker.authenticated(provider.id)
+ reconcileStoredCategoryTypes(provider.id, effectiveCatalogLayout)
var metadata = syncMetadataRepository.getMetadata(provider.id) ?: SyncMetadata(provider.id)
val now = System.currentTimeMillis()
@@ -345,6 +346,33 @@ internal class StalkerCatalogSyncExecutor(
)
}
+ /** Relabels legacy VOD category rows when persisted layout and stored type disagree. */
+ private suspend fun reconcileStoredCategoryTypes(
+ providerId: Long,
+ effectiveCatalogLayout: CatalogLayout
+ ) {
+ if (effectiveCatalogLayout != CatalogLayout.UNIFIED_VOD &&
+ effectiveCatalogLayout != CatalogLayout.SPLIT
+ ) {
+ return
+ }
+ val (expectedType, legacyType) = if (effectiveCatalogLayout == CatalogLayout.UNIFIED_VOD) {
+ ContentType.VOD.name to ContentType.MOVIE.name
+ } else {
+ ContentType.MOVIE.name to ContentType.VOD.name
+ }
+ val expected = categoryDao.getByProviderAndTypeSync(providerId, expectedType)
+ if (expected.isNotEmpty()) return
+ val legacy = categoryDao.getByProviderAndTypeSync(providerId, legacyType)
+ if (legacy.isEmpty()) return
+ val relabeled = categoryDao.retargetType(providerId, legacyType, expectedType)
+ Log.i(
+ STALKER_EXECUTOR_TAG,
+ "Retargeted $relabeled $legacyType categories to $expectedType for provider $providerId " +
+ "to match $effectiveCatalogLayout without re-downloading items."
+ )
+ }
+
suspend fun syncLive(
provider: Provider,
onProgress: ((String) -> Unit)?
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
index 06c205a9..94b9fd82 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
@@ -2952,6 +2952,64 @@ class OkHttpStalkerApiServiceTest {
assertThat(requestedActions).containsExactly("handshake", "get_profile").inOrder()
}
+ @Test
+ fun authenticate_tokenlessHandshake_abortsAsRateLimitedWithoutFurtherHandshakes() = runTest {
+ val requestedActions = mutableListOf<String>()
+ val service = OkHttpStalkerApiService(
+ okHttpClient = OkHttpClient.Builder()
+ .addInterceptor { chain ->
+ val request = chain.request()
+ requestedActions += request.url.queryParameter("action").orEmpty()
+ Response.Builder()
+ .request(request)
+ .protocol(Protocol.HTTP_1_1)
+ .code(200)
+ .message("OK")
+ .body("""{"js":{}}""".toResponseBody("application/json".toMediaType()))
+ .build()
+ }
+ .build(),
+ json = Json { ignoreUnknownKeys = true }
+ )
+
+ val result = service.authenticate(stalkerProfile())
+
+ assertThat(result).isInstanceOf(Result.Error::class.java)
+ assertThat((result as Result.Error).exception).isInstanceOf(StalkerApiError.RateLimited::class.java)
+ assertThat(requestedActions).containsExactly("handshake")
+ }
+
+ @Test
+ fun restoreSession_rehydratesServerCookiesForNormalApiRequests() = runTest {
+ var requestCookie = ""
+ val service = OkHttpStalkerApiService(
+ okHttpClient = OkHttpClient.Builder()
+ .addInterceptor { chain ->
+ requestCookie = chain.request().header("Cookie").orEmpty()
+ Response.Builder()
+ .request(chain.request())
+ .protocol(Protocol.HTTP_1_1)
+ .code(200)
+ .message("OK")
+ .body("""{"js":[]}""".toResponseBody("application/json".toMediaType()))
+ .build()
+ }
+ .build(),
+ json = Json { ignoreUnknownKeys = true }
+ )
+ val session = stalkerSession().copy(
+ sessionScopeKey = "restored-scope",
+ serverCookieHeader = "sid=restored-cookie"
+ )
+ val profile = stalkerProfile()
+
+ service.restoreSession(session, profile)
+ val result = service.getVodCategories(session, profile)
+
+ assertThat(result).isInstanceOf(Result.Success::class.java)
+ assertThat(requestCookie).contains("sid=restored-cookie")
+ }
+
@Test
fun authenticate_classifies_status2_envelope_as_device_not_registered() = runTest {
val service = OkHttpStalkerApiService(
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt
index 9dae7a0d..2091f40c 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerPortalStateStoreTest.kt
@@ -3,6 +3,7 @@ package com.streamvault.data.remote.stalker
import com.google.common.truth.Truth.assertThat
import com.streamvault.data.local.dao.StalkerPortalStateDao
import com.streamvault.data.local.entity.StalkerPortalStateEntity
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.StalkerCookieMode
import com.streamvault.domain.model.StalkerEndpointPreference
@@ -13,12 +14,13 @@ import kotlinx.serialization.json.jsonObject
import kotlinx.serialization.json.jsonPrimitive
import kotlinx.serialization.json.long
import org.junit.Test
+import java.util.Base64
class StalkerPortalStateStoreTest {
@Test
fun `rate limit cooldown is persisted independently and can be cleared`() = runTest {
val dao = FakePortalStateDao()
- val store = StalkerPortalStateStore(dao)
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
store.recordRateLimitCooldown(9L, cooldownUntil = 61_000L, now = 1_000L)
val limited = requireNotNull(store.get(9L))
@@ -32,7 +34,7 @@ class StalkerPortalStateStoreTest {
@Test
fun `capabilities are validated for seven days and selectively invalidated`() = runTest {
val dao = FakePortalStateDao()
- val store = StalkerPortalStateStore(dao)
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
val now = 1_000L
store.recordBulkLive(1L, supported = false, now = now)
@@ -55,7 +57,7 @@ class StalkerPortalStateStoreTest {
@Test
fun `endpoint health is hashed bounded and expires independently`() = runTest {
val dao = FakePortalStateDao()
- val store = StalkerPortalStateStore(dao)
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
val now = 10_000L
val endpoint = "https://portal.example/stalker_portal/server/load.php"
@@ -76,7 +78,7 @@ class StalkerPortalStateStoreTest {
@Test
fun `healthy probe restores concurrency only after persisted cooldown`() = runTest {
val dao = FakePortalStateDao()
- val store = StalkerPortalStateStore(dao)
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
store.recordStressCooldown(3L, cooldownUntil = 2_000L, now = 1_000L)
store.recordHealthyMetadataProbe(3L, now = 1_999L)
@@ -90,7 +92,7 @@ class StalkerPortalStateStoreTest {
@Test
fun `failed authentication recipe cools down without invalidating endpoint`() = runTest {
val dao = FakePortalStateDao()
- val store = StalkerPortalStateStore(dao)
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
val now = 5_000L
dao.upsert(
StalkerPortalStateEntity(
@@ -112,7 +114,7 @@ class StalkerPortalStateStoreTest {
@Test
fun `authentication and playback observations share one generation-bound learning envelope`() = runTest {
val dao = FakePortalStateDao()
- val store = StalkerPortalStateStore(dao)
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
store.recordAuthentication(
providerId = 8L,
session = StalkerSession(
@@ -144,6 +146,41 @@ class StalkerPortalStateStoreTest {
.isEqualTo("https://portal.test/load.php")
}
+ @Test
+ fun `resumable session is encrypted and respects generation age and clearing`() = runTest {
+ val dao = FakePortalStateDao()
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
+ val session = StalkerSession(
+ loadUrl = "https://portal.test/load.php",
+ portalReferer = "https://portal.test/c/",
+ token = "tok123",
+ serverCookieHeader = "sid=secret-cookie"
+ ).copy(authenticatedAtMillis = 10_000L)
+
+ store.recordAuthentication(
+ providerId = 11L,
+ session = session,
+ profile = StalkerProviderProfile(accountName = "Room"),
+ now = 10_000L,
+ configurationGeneration = 7L
+ )
+
+ val learningJson = requireNotNull(store.get(11L)).learningJson
+ assertThat(learningJson).doesNotContain("tok123")
+ assertThat(learningJson).doesNotContain("secret-cookie")
+
+ val resumed = store.resumableAuth(providerId = 11L, configurationGeneration = 7L, now = 70_000L)
+ assertThat(resumed?.session?.token).isEqualTo("tok123")
+ assertThat(resumed?.session?.serverCookieHeader).isEqualTo("sid=secret-cookie")
+ assertThat(resumed?.profile?.accountName).isEqualTo("Room")
+
+ assertThat(store.resumableAuth(providerId = 11L, configurationGeneration = 8L, now = 70_000L)).isNull()
+ assertThat(store.resumableAuth(providerId = 11L, configurationGeneration = 7L, now = 10_000L + 31L * 60L * 1000L)).isNull()
+
+ store.clearResumableAuth(11L)
+ assertThat(store.resumableAuth(providerId = 11L, configurationGeneration = 7L, now = 70_000L)).isNull()
+ }
+
private class FakePortalStateDao : StalkerPortalStateDao {
private val rows = mutableMapOf<Long, StalkerPortalStateEntity>()
@@ -155,4 +192,12 @@ class StalkerPortalStateStoreTest {
override suspend fun invalidate(providerId: Long): Int = if (rows.remove(providerId) != null) 1 else 0
}
+
+ private class TestCredentialCrypto : CredentialCrypto {
+ override fun encryptIfNeeded(value: String): String =
+ "enc:test:" + Base64.getEncoder().encodeToString(value.toByteArray(Charsets.UTF_8))
+
+ override fun decryptIfNeeded(value: String): String =
+ String(Base64.getDecoder().decode(value.removePrefix("enc:test:")), Charsets.UTF_8)
+ }
}
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
index 10e0ea6f..a9cee49d 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
@@ -6,6 +6,7 @@ import com.streamvault.data.local.dao.StalkerPortalStateDao
import com.streamvault.data.local.dao.StalkerRemoteIdentityDao
import com.streamvault.data.local.entity.StalkerPortalStateEntity
import com.streamvault.data.local.entity.StalkerRemoteIdentityEntity
+import com.streamvault.data.security.CredentialCrypto
import com.streamvault.domain.model.ContentType
import com.streamvault.domain.model.CatalogLayout
import com.streamvault.domain.model.ProviderStatus
@@ -19,6 +20,7 @@ import java.time.Instant
import kotlinx.coroutines.test.runTest
import org.junit.Before
import org.junit.Test
+import java.util.Base64
class StalkerProviderTest {
@@ -333,7 +335,7 @@ class StalkerProviderTest {
@Test
fun authenticate_recovers_when_saved_endpoint_and_recipe_are_cooling_down() = runTest {
val dao = FakePortalStateDao()
- val stateStore = StalkerPortalStateStore(dao)
+ val stateStore = StalkerPortalStateStore(dao, TestCredentialCrypto())
dao.upsert(
StalkerPortalStateEntity(
providerId = 7L,
@@ -416,6 +418,116 @@ class StalkerProviderTest {
assertThat(api.authenticateCalls).isEqualTo(1)
}
+ @Test
+ fun authenticate_reusesSessionAcrossInstancesWithDifferentLearnedHints() = runTest {
+ val activationApi = FakeStalkerApiService(profile = StalkerProviderProfile(accountName = "Room"))
+ val syncApi = FakeStalkerApiService(profile = StalkerProviderProfile(accountName = "Room"))
+ val activation = StalkerProvider(
+ providerId = 21,
+ api = activationApi,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ )
+
+ assertThat(activation.authenticate()).isInstanceOf(Result.Success::class.java)
+
+ val sync = StalkerProvider(
+ providerId = 21,
+ api = syncApi,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ portalFingerprintHint = com.streamvault.domain.model.StalkerPortalFingerprint.STRICT_MAG,
+ magPresetHint = com.streamvault.domain.model.StalkerMagPreset.MAG254_STRICT,
+ bootstrapRecipeHint = StalkerBootstrapRecipe.STRICT_MAG,
+ endpointPreferenceHint = com.streamvault.domain.model.StalkerEndpointPreference.SERVER_LOAD,
+ cookieModeHint = com.streamvault.domain.model.StalkerCookieMode.BOTH,
+ deviceProfile = "MAG254",
+ timezone = "UTC",
+ locale = "en"
+ )
+
+ assertThat(sync.authenticate()).isInstanceOf(Result.Success::class.java)
+ assertThat(activationApi.authenticateCalls).isEqualTo(1)
+ assertThat(syncApi.authenticateCalls).isEqualTo(0)
+ assertThat(syncApi.restoreSessionCalls).isEqualTo(1)
+ }
+
+ @Test
+ fun authenticate_resumesPersistedSessionAfterProcessRestartWithoutHandshake() = runTest {
+ val dao = FakePortalStateDao()
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
+ val api = FakeStalkerApiService(profile = StalkerProviderProfile(accountName = "Room"))
+ val first = StalkerProvider(
+ providerId = 22,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en",
+ portalStateStore = store
+ )
+
+ assertThat(first.authenticate()).isInstanceOf(Result.Success::class.java)
+ assertThat(api.authenticateCalls).isEqualTo(1)
+
+ StalkerProvider.clearSharedAuthCacheForTests()
+ val restarted = StalkerProvider(
+ providerId = 22,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ portalFingerprintHint = com.streamvault.domain.model.StalkerPortalFingerprint.STRICT_MAG,
+ deviceProfile = "MAG254",
+ timezone = "UTC",
+ locale = "en",
+ portalStateStore = store
+ )
+
+ assertThat(restarted.authenticate()).isInstanceOf(Result.Success::class.java)
+ assertThat(api.authenticateCalls).isEqualTo(1)
+ assertThat(api.restoreSessionCalls).isEqualTo(1)
+ }
+
+ @Test
+ fun authenticate_skipsEndpointRepairRetryWhenThrottled() = runTest {
+ val dao = FakePortalStateDao()
+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())
+ store.recordAuthentication(
+ providerId = 23,
+ session = StalkerSession(
+ loadUrl = "https://portal.example.com/server/load.php",
+ portalReferer = "https://portal.example.com/c/",
+ token = "stale-token"
+ ),
+ profile = StalkerProviderProfile(accountName = "Room"),
+ configurationGeneration = 0L
+ )
+ store.clearResumableAuth(23)
+ val api = FakeStalkerApiService(
+ profile = StalkerProviderProfile(accountName = "Room"),
+ authenticationError = StalkerApiError.RateLimited()
+ )
+ val provider = StalkerProvider(
+ providerId = 23,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en",
+ portalStateStore = store
+ )
+
+ val result = provider.authenticate()
+
+ assertThat(result).isInstanceOf(Result.Error::class.java)
+ assertThat(api.authenticateCalls).isEqualTo(1)
+ }
+
@Test
fun invalidateAuthenticationClearsSharedSessionForEquivalentProviderInstances() = runTest {
val api = FakeStalkerApiService(profile = StalkerProviderProfile(accountName = "Room"))
@@ -1124,12 +1236,15 @@ class StalkerProviderTest {
private val seriesCategoriesResult: Result<List<StalkerCategoryRecord>>? = null,
private val vodPageItems: List<StalkerItemRecord> = emptyList(),
private val seriesPageItems: List<StalkerItemRecord> = emptyList(),
- private var authenticationFailuresBeforeSuccess: Int = 0
+ private var authenticationFailuresBeforeSuccess: Int = 0,
+ private val authenticationError: Throwable? = null
) : StalkerApiService {
var createLinkCalls: Int = 0
private set
var authenticateCalls: Int = 0
private set
+ var restoreSessionCalls: Int = 0
+ private set
var lastAuthenticateProfile: StalkerDeviceProfile? = null
private set
@@ -1140,6 +1255,9 @@ class StalkerProviderTest {
authenticationFailuresBeforeSuccess -= 1
return Result.error("authentication failed")
}
+ authenticationError?.let { error ->
+ return Result.error(error.message.orEmpty(), error)
+ }
return Result.success(
StalkerSession(
loadUrl = "https://portal.example.com/server/load.php",
@@ -1264,6 +1382,10 @@ class StalkerProviderTest {
}
override fun currentCookieHeader(session: StalkerSession): String = currentCookieHeader
+
+ override fun restoreSession(session: StalkerSession, profile: StalkerDeviceProfile) {
+ restoreSessionCalls += 1
+ }
}
private class FakePortalStateDao : StalkerPortalStateDao {
@@ -1278,6 +1400,14 @@ class StalkerProviderTest {
override suspend fun invalidate(providerId: Long): Int = if (rows.remove(providerId) != null) 1 else 0
}
+ private class TestCredentialCrypto : CredentialCrypto {
+ override fun encryptIfNeeded(value: String): String =
+ "enc:test:" + Base64.getEncoder().encodeToString(value.toByteArray(Charsets.UTF_8))
+
+ override fun decryptIfNeeded(value: String): String =
+ String(Base64.getDecoder().decode(value.removePrefix("enc:test:")), Charsets.UTF_8)
+ }
+
@Test
fun resolvePlaybackInfo_applies_accepted_http_only_to_the_granted_origin() = runTest {
val grant = StalkerTransportGrant(
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 6e4f1359..49dfab2a 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -20,6 +20,8 @@ All notable product changes are recorded in this document.
- Fixed grouped VOD browse pagination and infinite scroll by using cursor windows, deduplicating before offset/limit application, and handling zero-timestamp catalog entries consistently.
- Fixed provider configuration decoding after typed-provider migrations that omitted the embedded configuration type, preserving access to existing provider settings and credentials.
- Added measured frame-rate and stream-bitrate diagnostics for IPTV playback, including MPEG-TS streams that omit these values from their metadata.
+- Improved Stalker authentication resilience by stopping repeated handshakes after soft throttles, reusing short-lived encrypted sessions across provider instances and process restarts, and restoring session cookies for resumed API requests.
+- Fixed Stalker VOD category layout drift by retargeting stale stored category types before synchronization instead of forcing an unnecessary catalog re-download.
## [1.0.17]