updating vidplay encryption method

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

@@ -1,13 +1,16 @@
 package com.lagradost.cloudstream3.extractors
 
+import android.util.Base64
 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
@@ -63,59 +66,50 @@ 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/")
-                this.name,
+                    .forEach(callback)
-                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(), "RC4")
+        val cipher = Cipher.getInstance("RC4")
+        cipher.init(Cipher.DECRYPT_MODE, rc4Key, cipher.parameters)
+
+        var vrf = cipher.doFinal(input.toByteArray())
+        vrf = Base64.encode(vrf, Base64.URL_SAFE or Base64.NO_WRAP)
+        val stringVrf = java.net.URLEncoder.encode(vrf.toString(Charsets.UTF_8), "utf-8")
+
+        return stringVrf
     }
 
-    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
+        var vrf = input.toByteArray()
-        val k = "k='(\\S+)'".toRegex().find(script)?.groupValues?.get(1) ?: return null
+        vrf = Base64.decode(vrf, Base64.URL_SAFE)
-        val a = mutableListOf(k)
-        for (i in id.indices) {
-            a.add((k[i % k.length].code + id[i].code).toString())
-        }
-        return "$mainUrl/mediainfo/${a.joinToString(",")}?${url.substringAfter("?")}"
-    }
 
-    private fun encodeId(id: String, keyList: List<String>): String {
+        val rc4Key = SecretKeySpec(key.toByteArray(), "RC4")
-        val cipher1 = Cipher.getInstance("RC4")
+        val cipher = Cipher.getInstance("RC4")
-        val cipher2 = Cipher.getInstance("RC4")
+        cipher.init(Cipher.DECRYPT_MODE, rc4Key, cipher.parameters)
-        cipher1.init(
+        vrf = cipher.doFinal(vrf)
-            Cipher.DECRYPT_MODE,
+
-            SecretKeySpec(keyList[0].toByteArray(), "RC4"),
+        return URLDecoder.decode(vrf.toString(Charsets.UTF_8), "utf-8")
-            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 +127,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,
-    )
-
 }