StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.
Kotlin iptv-player
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.ktindex 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}@Daodiff --git a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.ktindex 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 = nowif (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.ktindex 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.ktindex 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: StalkerDeviceProfilediff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerPortalStateStore.ktindex 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.stalkerimport com.streamvault.data.local.dao.StalkerPortalStateDaoimport com.streamvault.data.local.dao.ProviderSnapshotDaoimport com.streamvault.data.local.entity.StalkerPortalStateEntity+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.StalkerCookieModeimport com.streamvault.domain.model.StalkerEndpointPreferenceimport com.streamvault.domain.model.StalkerPlaybackBackendHint+import com.google.gson.Gsonimport java.security.MessageDigestimport javax.inject.Injectimport javax.inject.Singleton@@ -15,13 +17,18 @@ import kotlinx.serialization.json.Jsonimport kotlinx.serialization.json.JsonElementimport kotlinx.serialization.json.JsonObjectimport kotlinx.serialization.json.JsonPrimitive+import kotlinx.serialization.json.jsonObject+import kotlinx.serialization.json.jsonPrimitive+import kotlinx.serialization.json.longOrNull@Singletonclass 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.ktindex 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_000Lconst val CATALOG_LAYOUT_DETECTION_VERSION = 1private 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) returnval 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 = nullcategoryCache.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 = nullaccountProfileCache = nullsharedAuthCache.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.sessionaccountProfileCache = 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() == trueval 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): StalkerTransportChallengreturn "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.ktindex 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.ktindex 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")+ }+@Testfun 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.ktindex 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.stalkerimport com.google.common.truth.Truth.assertThatimport com.streamvault.data.local.dao.StalkerPortalStateDaoimport com.streamvault.data.local.entity.StalkerPortalStateEntity+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.StalkerCookieModeimport com.streamvault.domain.model.StalkerEndpointPreference@@ -13,12 +14,13 @@ import kotlinx.serialization.json.jsonObjectimport kotlinx.serialization.json.jsonPrimitiveimport kotlinx.serialization.json.longimport org.junit.Test+import java.util.Base64class StalkerPortalStateStoreTest {@Testfun `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 {@Testfun `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_000Lstore.recordBulkLive(1L, supported = false, now = now)@@ -55,7 +57,7 @@ class StalkerPortalStateStoreTest {@Testfun `endpoint health is hashed bounded and expires independently`() = runTest {val dao = FakePortalStateDao()- val store = StalkerPortalStateStore(dao)+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())val now = 10_000Lval endpoint = "https://portal.example/stalker_portal/server/load.php"@@ -76,7 +78,7 @@ class StalkerPortalStateStoreTest {@Testfun `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 {@Testfun `failed authentication recipe cools down without invalidating endpoint`() = runTest {val dao = FakePortalStateDao()- val store = StalkerPortalStateStore(dao)+ val store = StalkerPortalStateStore(dao, TestCredentialCrypto())val now = 5_000Ldao.upsert(StalkerPortalStateEntity(@@ -112,7 +114,7 @@ class StalkerPortalStateStoreTest {@Testfun `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.ktindex 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.StalkerPortalStateDaoimport com.streamvault.data.local.dao.StalkerRemoteIdentityDaoimport com.streamvault.data.local.entity.StalkerPortalStateEntityimport com.streamvault.data.local.entity.StalkerRemoteIdentityEntity+import com.streamvault.data.security.CredentialCryptoimport com.streamvault.domain.model.ContentTypeimport com.streamvault.domain.model.CatalogLayoutimport com.streamvault.domain.model.ProviderStatus@@ -19,6 +20,7 @@ import java.time.Instantimport kotlinx.coroutines.test.runTestimport org.junit.Beforeimport org.junit.Test+import java.util.Base64class StalkerProviderTest {@@ -333,7 +335,7 @@ class StalkerProviderTest {@Testfun 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)+ }+@Testfun 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 = 0private setvar authenticateCalls: Int = 0private set+ var restoreSessionCalls: Int = 0+ private setvar lastAuthenticateProfile: StalkerDeviceProfile? = nullprivate set@@ -1140,6 +1255,9 @@ class StalkerProviderTest {authenticationFailuresBeforeSuccess -= 1return 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)+ }+@Testfun resolvePlaybackInfo_applies_accepted_http_only_to_the_granted_origin() = runTest {val grant = StalkerTransportGrant(diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 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]