updating vidplay encryption method (#1202)

library/src/commonMain/kotlin/com/lagradost/cloudstream3/extractors/VidSrcTo.kt

@@ -40,7 +40,7 @@ class VidSrcTo : ExtractorApi() {
                 val finalUrl = DecryptUrl(embedRes.result.encUrl)
                 if(finalUrl.equals(embedRes.result.encUrl)) return@amap
                 when (source.title) {
-                    "Vidplay" -> AnyVidplay(finalUrl.substringBefore("/e/")).getUrl(finalUrl, referer, subtitleCallback, callback)
+                    "F2Cloud" -> AnyVidplay(finalUrl.substringBefore("/e/")).getUrl(finalUrl, referer, subtitleCallback, callback)
                     "Filemoon" -> FileMoon().getUrl(finalUrl, referer, subtitleCallback, callback)
                 }
             } catch (e: Exception) {

library/src/commonMain/kotlin/com/lagradost/cloudstream3/extractors/Vidplay.kt

@@ -4,13 +4,14 @@ import com.fasterxml.jackson.annotation.JsonProperty
 import com.lagradost.cloudstream3.ErrorLoadingException
 import com.lagradost.cloudstream3.SubtitleFile
 import com.lagradost.cloudstream3.app
-import com.lagradost.cloudstream3.base64Encode
+import com.lagradost.cloudstream3.utils.AppUtils.tryParseJson
 import com.lagradost.cloudstream3.utils.ExtractorApi
 import com.lagradost.cloudstream3.utils.ExtractorLink
 import com.lagradost.cloudstream3.utils.M3u8Helper
+import java.net.URLDecoder
 import javax.crypto.Cipher
 import javax.crypto.spec.SecretKeySpec
-import kotlin.run
+import kotlin.io.encoding.Base64
 
 // Code found in https://github.com/KillerDogeEmpire/vidplay-keys
 // special credits to @KillerDogeEmpire for providing key
@@ -33,6 +34,7 @@ class VidplayOnline : Vidplay() {
     override val mainUrl = "https://vidplay.online"
 }
 
+@OptIn(kotlin.io.encoding.ExperimentalEncodingApi::class)
 open class Vidplay : ExtractorApi() {
     override val name = "Vidplay"
     override val mainUrl = "https://vidplay.site"
@@ -63,59 +65,43 @@ open class Vidplay : ExtractorApi() {
             subtitleCallback: (SubtitleFile) -> Unit,
             callback: (ExtractorLink) -> Unit
     ) {
+        val myKeys = getKeys()
+        val domain = url.substringBefore("/e/")
         val id = url.substringBefore("?").substringAfterLast("/")
-        val encodeId = encodeId(id, getKeys())
+        val encodedId = encode(id, myKeys.get(0))
-        val mediaUrl = callFutoken(encodeId, url)
+        val t = url.substringAfter("t=").substringBefore("&")
-        val res = app.get(
+        val h = encode(id, myKeys.get(1))
-            "$mediaUrl", headers = mapOf(
+        val mediaUrl = "$domain/mediainfo/$encodedId?t=$t&h=$h"
-                "Accept" to "application/json, text/javascript, */*; q=0.01",
+        val encodedRes =
-                "X-Requested-With" to "XMLHttpRequest",
+                app.get("$mediaUrl").parsedSafe<Response>()?.result
-            ), referer = url
+                        ?: throw Exception("Unable to fetch link")
-        ).parsedSafe<Response>()?.result
+        val decodedRes = decode(encodedRes, myKeys.get(2))
-
+        val res = tryParseJson<Result>(decodedRes)
         res?.sources?.map {
-            M3u8Helper.generateM3u8(
+            M3u8Helper.generateM3u8(this.name, it.file ?: return@map, "$mainUrl/").forEach(callback)
-                this.name,
-                it.file ?: return@map,
-                "$mainUrl/"
-            ).forEach(callback)
         }
 
         res?.tracks?.filter { it.kind == "captions" }?.map {
-            subtitleCallback.invoke(
+            subtitleCallback.invoke(SubtitleFile(it.label ?: return@map, it.file ?: return@map))
-                SubtitleFile(it.label ?: return@map, it.file ?: return@map)
+        }
-            )
     }
 
+    private fun encode(input: String, key: String): String {
+        val rc4Key = SecretKeySpec(key.toByteArray(Charsets.UTF_8), "RC4")
+        val cipher = Cipher.getInstance("RC4")
+        cipher.init(Cipher.ENCRYPT_MODE, rc4Key)
+        val encryptedBytes = cipher.doFinal(input.toByteArray(Charsets.UTF_8))
+        return Base64.UrlSafe.encode(encryptedBytes)
     }
 
-    private suspend fun callFutoken(id: String, url: String): String? {
+    fun decode(input: String, key: String): String {
-        val script = app.get("$mainUrl/futoken", referer = url).text
+        val decodedBytes = Base64.UrlSafe.decode(input)
-        val k = "k='(\\S+)'".toRegex().find(script)?.groupValues?.get(1) ?: return null
+        val rc4Key = SecretKeySpec(key.toByteArray(Charsets.UTF_8), "RC4")
-        val a = mutableListOf(k)
+        val cipher = Cipher.getInstance("RC4")
-        for (i in id.indices) {
+        cipher.init(Cipher.DECRYPT_MODE, rc4Key)
-            a.add((k[i % k.length].code + id[i].code).toString())
+        val decryptedBytes = cipher.doFinal(decodedBytes)
-        }
+        val decodedString = String(decryptedBytes, Charsets.UTF_8)
-        return "$mainUrl/mediainfo/${a.joinToString(",")}?${url.substringAfter("?")}"
+        return URLDecoder.decode(decodedString, "UTF-8")
-    }
-
-    private fun encodeId(id: String, keyList: List<String>): String {
-        val cipher1 = Cipher.getInstance("RC4")
-        val cipher2 = Cipher.getInstance("RC4")
-        cipher1.init(
-            Cipher.DECRYPT_MODE,
-            SecretKeySpec(keyList[0].toByteArray(), "RC4"),
-            cipher1.parameters
-        )
-        cipher2.init(
-            Cipher.DECRYPT_MODE,
-            SecretKeySpec(keyList[1].toByteArray(), "RC4"),
-            cipher2.parameters
-        )
-        var input = id.toByteArray()
-        input = cipher1.doFinal(input)
-        input = cipher2.doFinal(input)
-        return base64Encode(input).replace("/", "_")
     }
 
     data class Tracks(
@@ -133,8 +119,5 @@ open class Vidplay : ExtractorApi() {
             @JsonProperty("tracks") val tracks: ArrayList<Tracks>? = arrayListOf(),
     )
 
-    data class Response(
+    data class Response(@JsonProperty("result") val result: String? = null)
-        @JsonProperty("result") val result: Result? = null,
-    )
-
 }