Make some private cryptography methods suspend (#3040)

Author: Luna712

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

@@ -86,15 +86,15 @@ open class ByseSX : ExtractorApi() {
     }
 
     @OptIn(DelicateCryptographyApi::class)
-    private fun decryptPlayback(playback: Playback): String? {
+    private suspend fun decryptPlayback(playback: Playback): String? {
         val keyBytes = buildAesKey(playback)
         val ivBytes = b64UrlDecode(playback.iv)
         val cipherBytes = b64UrlDecode(playback.payload)
 
-        val aesKey = aesGcm.keyDecoder().decodeFromByteArrayBlocking(AES.Key.Format.RAW, keyBytes)
+        val aesKey = aesGcm.keyDecoder().decodeFromByteArray(AES.Key.Format.RAW, keyBytes)
         // 128-bit GCM tag (default)
         val cipher = aesKey.cipher()
-        val plainBytes = cipher.decryptWithIvBlocking(ivBytes, cipherBytes)
+        val plainBytes = cipher.decryptWithIv(ivBytes, cipherBytes)
 
         var jsonStr = plainBytes.decodeToString()
         if (jsonStr.startsWith("\uFEFF")) jsonStr = jsonStr.substring(1)

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

@@ -133,12 +133,12 @@ open class Rabbitstream : ExtractorApi() {
         return extractedKey to sources
     }
 
-    private inline fun <reified T> decryptMapped(input: String, key: String): T? {
+    private inline suspend fun <reified T> decryptMapped(input: String, key: String): T? {
         val decrypt = decrypt(input, key)
         return AppUtils.tryParseJson(decrypt)
     }
 
-    private fun decrypt(input: String, key: String): String {
+    private suspend fun decrypt(input: String, key: String): String {
         return decryptSourceUrl(
             generateKey(
                 salt = base64DecodeArray(input).copyOfRange(8, 16),
@@ -147,7 +147,7 @@ open class Rabbitstream : ExtractorApi() {
         )
     }
 
-    private fun generateKey(salt: ByteArray, secret: ByteArray): ByteArray {
+    private suspend fun generateKey(salt: ByteArray, secret: ByteArray): ByteArray {
         var key = md5(secret + salt)
         var currentKey = key
         while (currentKey.size < 48) {
@@ -157,18 +157,18 @@ open class Rabbitstream : ExtractorApi() {
         return currentKey
     }
 
-    private fun md5(input: ByteArray): ByteArray =
-        md5Hasher.hashBlocking(input)
+    private suspend fun md5(input: ByteArray): ByteArray =
+        md5Hasher.hash(input)
 
     @OptIn(DelicateCryptographyApi::class)
-    private fun decryptSourceUrl(decryptionKey: ByteArray, sourceUrl: String): String {
+    private suspend fun decryptSourceUrl(decryptionKey: ByteArray, sourceUrl: String): String {
         val cipherData = base64DecodeArray(sourceUrl)
         val encrypted = cipherData.copyOfRange(16, cipherData.size)
         val keyBytes = decryptionKey.copyOfRange(0, 32)
         val ivBytes = decryptionKey.copyOfRange(32, decryptionKey.size)
 
-        val aesKey = aesCbc.keyDecoder().decodeFromByteArrayBlocking(AES.Key.Format.RAW, keyBytes)
-        val decryptedData = aesKey.cipher(padding = true).decryptWithIvBlocking(ivBytes, encrypted)
+        val aesKey = aesCbc.keyDecoder().decodeFromByteArray(AES.Key.Format.RAW, keyBytes)
+        val decryptedData = aesKey.cipher(padding = true).decryptWithIv(ivBytes, encrypted)
         return decryptedData.decodeToString()
     }
 

library/src/commonMain/kotlin/com/lagradost/cloudstream3/extractors/helper/GogoHelper.kt

@@ -39,22 +39,22 @@ object GogoHelper {
     // https://github.com/saikou-app/saikou/blob/45d0a99b8a72665a29a1eadfb38c506b842a29d7/app/src/main/java/ani/saikou/parsers/anime/extractors/GogoCDN.kt#L97
     // No Licence on the function
     @OptIn(DelicateCryptographyApi::class)
-    private fun cryptoHandler(
+    private suspend fun cryptoHandler(
         string: String,
         iv: String,
         secretKeyString: String,
         encrypt: Boolean = true,
     ): String {
         val ivBytes = iv.encodeToByteArray()
         val keyBytes = secretKeyString.encodeToByteArray()
-        val aesKey = aesCbc.keyDecoder().decodeFromByteArrayBlocking(AES.Key.Format.RAW, keyBytes)
+        val aesKey = aesCbc.keyDecoder().decodeFromByteArray(AES.Key.Format.RAW, keyBytes)
         val cipher = aesKey.cipher(padding = true)
 
         return if (!encrypt) {
-            val plainBytes = cipher.decryptWithIvBlocking(ivBytes, base64DecodeArray(string))
+            val plainBytes = cipher.decryptWithIv(ivBytes, base64DecodeArray(string))
             plainBytes.decodeToString()
         } else {
-            base64Encode(cipher.encryptWithIvBlocking(ivBytes, string.encodeToByteArray()))
+            base64Encode(cipher.encryptWithIv(ivBytes, string.encodeToByteArray()))
         }
     }