react-native-security-suite 0.6.6 → 0.6.8

package/android/src/main/java/com/securitysuite/internal/support/ContextExt.kt

@@ -1,22 +0,0 @@
-package com.securitysuite.internal.support
-
-import android.content.Context
-import com.securitysuite.internal.data.model.DialogData
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-
-internal fun Context.showDialog(
-    dialogData: DialogData,
-    onPositiveClick: (() -> Unit)?,
-    onNegativeClick: (() -> Unit)?,
-) {
-    MaterialAlertDialogBuilder(this)
-        .setTitle(dialogData.title)
-        .setMessage(dialogData.message)
-        .setPositiveButton(dialogData.positiveButtonText) { _, _ ->
-            onPositiveClick?.invoke()
-        }
-        .setNegativeButton(dialogData.negativeButtonText) { _, _ ->
-            onNegativeClick?.invoke()
-        }
-        .show()
-}

package/android/src/main/java/com/securitysuite/internal/support/DepletingSource.kt

@@ -1,37 +0,0 @@
-package com.securitysuite.internal.support
-
-import okio.Buffer
-import okio.ForwardingSource
-import okio.Source
-import okio.blackholeSink
-import okio.buffer
-import java.io.IOException
-
-internal class DepletingSource(delegate: Source) : ForwardingSource(delegate) {
-    private var shouldDeplete = true
-
-    override fun read(
-        sink: Buffer,
-        byteCount: Long,
-    ) = try {
-        val bytesRead = super.read(sink, byteCount)
-        if (bytesRead == -1L) shouldDeplete = false
-        bytesRead
-    } catch (e: IOException) {
-        shouldDeplete = false
-        throw e
-    }
-
-    override fun close() {
-        if (shouldDeplete) {
-            try {
-                delegate.buffer().readAll(blackholeSink())
-            } catch (e: IOException) {
-                Logger.error("An error occurred while depleting the source", e)
-            }
-        }
-        shouldDeplete = false
-
-        super.close()
-    }
-}

package/android/src/main/java/com/securitysuite/internal/support/FileFactory.kt

@@ -1,30 +0,0 @@
-package com.securitysuite.internal.support
-
-import java.io.File
-import java.io.IOException
-import java.util.concurrent.atomic.AtomicLong
-
-internal object FileFactory {
-    private val uniqueIdGenerator = AtomicLong()
-
-    fun create(directory: File) = create(directory, fileName = "chucker-${uniqueIdGenerator.getAndIncrement()}")
-
-    fun create(
-        directory: File,
-        fileName: String,
-    ): File? =
-        try {
-            File(directory, fileName).apply {
-                if (exists() && !delete()) {
-                    throw IOException("Failed to delete file $this")
-                }
-                parentFile?.mkdirs()
-                if (!createNewFile()) {
-                    throw IOException("File $this already exists")
-                }
-            }
-        } catch (e: IOException) {
-            Logger.error("An error occurred while creating a file", e)
-            null
-        }
-}

package/android/src/main/java/com/securitysuite/internal/support/FileSaver.kt

@@ -1,41 +0,0 @@
-package com.securitysuite.internal.support
-
-import android.content.ContentResolver
-import android.net.Uri
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import okio.Source
-import okio.buffer
-import okio.sink
-
-/**
- * Utility class to save a file from a [Source] to a [Uri].
- */
-public object FileSaver {
-    /**
-     * Saves the data from the [source] to the file at the [uri] using the [contentResolver].
-     *
-     * @param source The source of the data to save.
-     * @param uri The URI of the file to save the data to.
-     * @param contentResolver The content resolver to use to save the data.
-     * @return `true` if the data was saved successfully, `false` otherwise.
-     */
-    public suspend fun saveFile(
-        source: Source,
-        uri: Uri,
-        contentResolver: ContentResolver,
-    ): Boolean =
-        withContext(Dispatchers.IO) {
-            runCatching {
-                contentResolver.openOutputStream(uri)?.use { outputStream ->
-                    outputStream.sink().buffer().use { sink ->
-                        sink.writeAll(source)
-                    }
-                }
-            }.onFailure {
-                Logger.error("Failed to save data to a file", it)
-                return@withContext false
-            }
-            return@withContext true
-        }
-}

package/android/src/main/java/com/securitysuite/internal/support/FormatUtils.kt

@@ -1,117 +0,0 @@
-package com.securitysuite.internal.support
-
-import com.securitysuite.internal.data.entity.HttpHeader
-import com.google.gson.JsonParseException
-import com.google.gson.JsonParser
-import org.w3c.dom.Document
-import org.xml.sax.InputSource
-import org.xml.sax.SAXParseException
-import java.io.ByteArrayInputStream
-import java.io.IOException
-import java.io.StringWriter
-import java.io.UnsupportedEncodingException
-import java.net.URLDecoder
-import java.nio.charset.Charset
-import java.util.Locale
-import javax.xml.XMLConstants
-import javax.xml.parsers.DocumentBuilder
-import javax.xml.parsers.DocumentBuilderFactory
-import javax.xml.transform.OutputKeys
-import javax.xml.transform.TransformerException
-import javax.xml.transform.TransformerFactory
-import javax.xml.transform.dom.DOMSource
-import javax.xml.transform.stream.StreamResult
-import kotlin.math.ln
-import kotlin.math.pow
-
-internal object FormatUtils {
-    private const val SI_MULTIPLE = 1000
-    private const val BASE_TWO_MULTIPLE = 1024
-
-    fun formatHeaders(
-        httpHeaders: List<HttpHeader>?,
-        withMarkup: Boolean,
-    ): String {
-        return httpHeaders?.joinToString(separator = "") { header ->
-            if (withMarkup) {
-                "<b> ${header.name}: </b>${header.value} <br />"
-            } else {
-                "${header.name}: ${header.value}\n"
-            }
-        } ?: ""
-    }
-
-    fun formatByteCount(
-        bytes: Long,
-        si: Boolean,
-    ): String {
-        val unit = if (si) SI_MULTIPLE else BASE_TWO_MULTIPLE
-
-        if (bytes < unit) {
-            return "$bytes B"
-        }
-
-        val exp = (ln(bytes.toDouble()) / ln(unit.toDouble())).toInt()
-        val pre = (if (si) "kMGTPE" else "KMGTPE")[exp - 1] + if (si) "" else "i"
-
-        return String.format(Locale.US, "%.1f %sB", bytes / unit.toDouble().pow(exp.toDouble()), pre)
-    }
-
-    fun formatJson(json: String): String {
-        return try {
-            val je = JsonParser.parseString(json)
-            JsonConverter.instance.toJson(je)
-        } catch (e: JsonParseException) {
-            json
-        }
-    }
-
-    fun formatXml(xml: String): String {
-        return try {
-            val documentFactory: DocumentBuilderFactory = DocumentBuilderFactory.newInstance()
-            // This flag is required for security reasons
-            documentFactory.isExpandEntityReferences = false
-
-            val documentBuilder: DocumentBuilder = documentFactory.newDocumentBuilder()
-            val inputSource = InputSource(ByteArrayInputStream(xml.toByteArray(Charset.defaultCharset())))
-            val document: Document = documentBuilder.parse(inputSource)
-
-            val domSource = DOMSource(document)
-            val writer = StringWriter()
-            val result = StreamResult(writer)
-
-            TransformerFactory.newInstance().apply {
-                setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true)
-            }.newTransformer().apply {
-                setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2")
-                setOutputProperty(OutputKeys.INDENT, "yes")
-                transform(domSource, result)
-            }
-            writer.toString()
-        } catch (ignore: SAXParseException) {
-            xml
-        } catch (ignore: IOException) {
-            xml
-        } catch (ignore: TransformerException) {
-            xml
-        }
-    }
-
-    fun formatUrlEncodedForm(form: String): String {
-        return try {
-            if (form.isBlank()) {
-                return form
-            }
-            form.split("&").joinToString(separator = "\n") { entry ->
-                val keyValue = entry.split("=")
-                val key = keyValue[0]
-                val value = if (keyValue.size > 1) URLDecoder.decode(keyValue[1], "UTF-8") else ""
-                "$key: $value"
-            }
-        } catch (ignore: IllegalArgumentException) {
-            form
-        } catch (ignore: UnsupportedEncodingException) {
-            form
-        }
-    }
-}

package/android/src/main/java/com/securitysuite/internal/support/FormattedUrl.kt

@@ -1,76 +0,0 @@
-package com.securitysuite.internal.support
-
-import okhttp3.HttpUrl
-
-internal class FormattedUrl private constructor(
-    val scheme: String,
-    val host: String,
-    val port: Int,
-    val path: String,
-    val query: String,
-) {
-    val pathWithQuery: String
-        get() =
-            if (query.isBlank()) {
-                path
-            } else {
-                "$path?$query"
-            }
-
-    val url: String
-        get() {
-            return if (shouldShowPort()) {
-                "$scheme://$host:$port$pathWithQuery"
-            } else {
-                "$scheme://$host$pathWithQuery"
-            }
-        }
-
-    private fun shouldShowPort(): Boolean {
-        if (scheme == "https" && port == HTTPS_PORT) {
-            return false
-        }
-        if (scheme == "http" && port == HTTP_PORT) {
-            return false
-        }
-        return true
-    }
-
-    companion object {
-        private const val HTTPS_PORT = 443
-        private const val HTTP_PORT = 80
-
-        fun fromHttpUrl(
-            httpUrl: HttpUrl,
-            encoded: Boolean,
-        ): FormattedUrl {
-            return if (encoded) {
-                encodedUrl(httpUrl)
-            } else {
-                decodedUrl(httpUrl)
-            }
-        }
-
-        private fun encodedUrl(httpUrl: HttpUrl): FormattedUrl {
-            val path = httpUrl.encodedPathSegments.joinToString("/")
-            return FormattedUrl(
-                httpUrl.scheme,
-                httpUrl.host,
-                httpUrl.port,
-                if (path.isNotBlank()) "/$path" else "",
-                httpUrl.encodedQuery.orEmpty(),
-            )
-        }
-
-        private fun decodedUrl(httpUrl: HttpUrl): FormattedUrl {
-            val path = httpUrl.pathSegments.joinToString("/")
-            return FormattedUrl(
-                httpUrl.scheme,
-                httpUrl.host,
-                httpUrl.port,
-                if (path.isNotBlank()) "/$path" else "",
-                httpUrl.query.orEmpty(),
-            )
-        }
-    }
-}

package/android/src/main/java/com/securitysuite/internal/support/HarUtils.kt

@@ -1,28 +0,0 @@
-package com.securitysuite.internal.support
-
-import com.securitysuite.internal.data.entity.HttpTransaction
-import com.securitysuite.internal.data.har.Har
-import com.securitysuite.internal.data.har.log.Creator
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-
-// http://www.softwareishard.com/blog/har-12-spec/
-// https://github.com/ahmadnassri/har-spec/blob/master/versions/1.2.md
-internal object HarUtils {
-    suspend fun harStringFromTransactions(
-        transactions: List<HttpTransaction>,
-        name: String,
-        version: String,
-    ): String =
-        withContext(Dispatchers.Default) {
-            JsonConverter.nonNullSerializerInstance
-                .toJson(fromHttpTransactions(transactions, Creator(name, version)))
-        }
-
-    internal fun fromHttpTransactions(
-        transactions: List<HttpTransaction>,
-        creator: Creator,
-    ): Har {
-        return Har(transactions, creator)
-    }
-}

package/android/src/main/java/com/securitysuite/internal/support/HttpUrlUtils.kt

@@ -1,11 +0,0 @@
-package com.securitysuite.internal.support
-
-import okhttp3.HttpUrl
-
-private const val PATH_SEGMENTS_DELIMITER = "/"
-
-public fun HttpUrl.Builder.addNonBlankPathSegments(candidatePath: String): HttpUrl.Builder =
-    apply {
-        candidatePath.split(PATH_SEGMENTS_DELIMITER).filter { it.isNotBlank() }
-            .forEach { item -> addPathSegment(item) }
-    }

package/android/src/main/java/com/securitysuite/internal/support/JsonConverter.kt

@@ -1,19 +0,0 @@
-package com.securitysuite.internal.support
-
-import com.google.gson.Gson
-import com.google.gson.GsonBuilder
-
-internal object JsonConverter {
-    val nonNullSerializerInstance: Gson by lazy {
-        GsonBuilder()
-            .disableHtmlEscaping()
-            .setPrettyPrinting()
-            .create()
-    }
-
-    val instance: Gson by lazy {
-        nonNullSerializerInstance.newBuilder()
-            .serializeNulls()
-            .create()
-    }
-}

package/android/src/main/java/com/securitysuite/internal/support/LimitingSource.kt

@@ -1,22 +0,0 @@
-package com.securitysuite.internal.support
-
-import okio.Buffer
-import okio.ForwardingSource
-import okio.Source
-
-internal class LimitingSource(
-    delegate: Source,
-    private val bytesCountThreshold: Long,
-) : ForwardingSource(delegate) {
-    private var bytesRead = 0L
-    val isThresholdReached get() = bytesRead >= bytesCountThreshold
-
-    override fun read(
-        sink: Buffer,
-        byteCount: Long,
-    ) = if (!isThresholdReached) {
-        super.read(sink, byteCount).also { bytesRead += it }
-    } else {
-        -1L
-    }
-}

package/android/src/main/java/com/securitysuite/internal/support/LiveDataUtils.kt

@@ -1,68 +0,0 @@
-package com.securitysuite.internal.support
-
-import android.annotation.SuppressLint
-import androidx.arch.core.executor.ArchTaskExecutor
-import androidx.lifecycle.LiveData
-import androidx.lifecycle.MediatorLiveData
-import java.util.concurrent.Executor
-
-internal fun <T1, T2, R> LiveData<T1>.combineLatest(
-    other: LiveData<T2>,
-    func: (T1, T2) -> R,
-): LiveData<R> {
-    return MediatorLiveData<R>().apply {
-        var lastA: T1? = null
-        var lastB: T2? = null
-
-        addSource(this@combineLatest) {
-            lastA = it
-            val observedB = lastB
-            if (it == null && value != null) {
-                value = null
-            } else if (it != null && observedB != null) {
-                value = func(it, observedB)
-            }
-        }
-
-        addSource(other) {
-            lastB = it
-            val observedA = lastA
-            if (it == null && value != null) {
-                value = null
-            } else if (observedA != null && it != null) {
-                value = func(observedA, it)
-            }
-        }
-    }
-}
-
-internal fun <T1, T2> LiveData<T1>.combineLatest(other: LiveData<T2>): LiveData<Pair<T1, T2>> {
-    return combineLatest(other) { a, b -> a to b }
-}
-
-// Unlike built-in extension operation is performed on a provided thread pool.
-// This is needed in our case since we compare requests and responses which can be big
-// and result in frame drops.
-internal fun <T> LiveData<T>.distinctUntilChanged(
-    executor: Executor = ioExecutor(),
-    areEqual: (old: T, new: T) -> Boolean = { old, new -> old == new },
-): LiveData<T> {
-    val distinctMediator = MediatorLiveData<T>()
-    var old = uninitializedToken
-    distinctMediator.addSource(this) { new ->
-        executor.execute {
-            @Suppress("UNCHECKED_CAST")
-            if (old === uninitializedToken || !areEqual(old as T, new)) {
-                old = new
-                distinctMediator.postValue(new)
-            }
-        }
-    }
-    return distinctMediator
-}
-
-private val uninitializedToken: Any? = Any()
-
-// It is lesser evil than providing a custom executor.
-@SuppressLint("RestrictedApi")
-private fun ioExecutor() = ArchTaskExecutor.getIOThreadExecutor()

package/android/src/main/java/com/securitysuite/internal/support/Logger.kt

@@ -1,43 +0,0 @@
-package com.securitysuite.internal.support
-
-import com.securitysuite.api.Chucker
-
-internal interface Logger {
-    fun info(
-        message: String,
-        throwable: Throwable? = null,
-    )
-
-    fun warn(
-        message: String,
-        throwable: Throwable? = null,
-    )
-
-    fun error(
-        message: String,
-        throwable: Throwable? = null,
-    )
-
-    companion object : Logger {
-        override fun info(
-            message: String,
-            throwable: Throwable?,
-        ) {
-            Chucker.logger.info(message, throwable)
-        }
-
-        override fun warn(
-            message: String,
-            throwable: Throwable?,
-        ) {
-            Chucker.logger.warn(message, throwable)
-        }
-
-        override fun error(
-            message: String,
-            throwable: Throwable?,
-        ) {
-            Chucker.logger.error(message, throwable)
-        }
-    }
-}

package/android/src/main/java/com/securitysuite/internal/support/NotificationHelper.kt

@@ -1,149 +0,0 @@
-package com.securitysuite.internal.support
-
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.os.Build
-import android.util.LongSparseArray
-import androidx.core.app.NotificationCompat
-import androidx.core.content.ContextCompat
-import com.securitysuite.R
-import com.securitysuite.api.Chucker
-import com.securitysuite.internal.data.entity.HttpTransaction
-import com.securitysuite.internal.ui.BaseChuckerActivity
-import java.util.HashSet
-
-internal class NotificationHelper(val context: Context) {
-    companion object {
-        private const val TRANSACTIONS_CHANNEL_ID = "chucker_transactions"
-
-        private const val TRANSACTION_NOTIFICATION_ID = 1138
-
-        private const val BUFFER_SIZE = 10
-        private const val INTENT_REQUEST_CODE = 11
-        private val transactionBuffer = LongSparseArray<HttpTransaction>()
-        private val transactionIdsSet = HashSet<Long>()
-
-        fun clearBuffer() {
-            synchronized(transactionBuffer) {
-                transactionBuffer.clear()
-                transactionIdsSet.clear()
-            }
-        }
-    }
-
-    private val notificationManager: NotificationManager =
-        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-    private val transactionsScreenIntent by lazy {
-        PendingIntent.getActivity(
-            context,
-            TRANSACTION_NOTIFICATION_ID,
-            Chucker.getLaunchIntent(context),
-            PendingIntent.FLAG_UPDATE_CURRENT or immutableFlag(),
-        )
-    }
-
-    init {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val transactionsChannel =
-                NotificationChannel(
-                    TRANSACTIONS_CHANNEL_ID,
-                    context.getString(R.string.chucker_network_notification_category),
-                    NotificationManager.IMPORTANCE_LOW,
-                )
-            notificationManager.createNotificationChannels(listOf(transactionsChannel))
-        }
-    }
-
-    private fun addToBuffer(transaction: HttpTransaction) {
-        if (transaction.id == 0L) {
-            // Don't store Transactions with an invalid ID (0).
-            // Transaction with an Invalid ID will be shown twice in the notification
-            // with both the invalid and the valid ID and we want to avoid this.
-            return
-        }
-        synchronized(transactionBuffer) {
-            transactionIdsSet.add(transaction.id)
-            transactionBuffer.put(transaction.id, transaction)
-            if (transactionBuffer.size() > BUFFER_SIZE) {
-                transactionBuffer.removeAt(0)
-            }
-        }
-    }
-
-    private fun canShowNotifications(): Boolean {
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-            notificationManager.areNotificationsEnabled()
-        } else {
-            true
-        }
-    }
-
-    fun show(transaction: HttpTransaction) {
-        addToBuffer(transaction)
-        if (!BaseChuckerActivity.isInForeground && canShowNotifications()) {
-            val builder =
-                NotificationCompat.Builder(context, TRANSACTIONS_CHANNEL_ID)
-                    .setContentIntent(transactionsScreenIntent)
-                    .setLocalOnly(true)
-                    .setSmallIcon(R.drawable.chucker_ic_transaction_notification)
-                    .setColor(ContextCompat.getColor(context, R.color.chucker_color_primary))
-                    .setContentTitle(context.getString(R.string.chucker_http_notification_title))
-                    .setAutoCancel(true)
-                    .addAction(createClearAction())
-            val inboxStyle = NotificationCompat.InboxStyle()
-            synchronized(transactionBuffer) {
-                var count = 0
-                for (i in transactionBuffer.size() - 1 downTo 0) {
-                    val bufferedTransaction = transactionBuffer.valueAt(i)
-                    if ((bufferedTransaction != null) && count < BUFFER_SIZE) {
-                        if (count == 0) {
-                            builder.setContentText(bufferedTransaction.notificationText)
-                        }
-                        inboxStyle.addLine(bufferedTransaction.notificationText)
-                    }
-                    count++
-                }
-                builder.setStyle(inboxStyle)
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                    builder.setSubText(transactionIdsSet.size.toString())
-                } else {
-                    builder.setNumber(transactionIdsSet.size)
-                }
-            }
-            notificationManager.notify(TRANSACTION_NOTIFICATION_ID, builder.build())
-        }
-    }
-
-    private fun createClearAction(): NotificationCompat.Action {
-        val clearTitle = context.getString(R.string.chucker_clear)
-        val clearTransactionsBroadcastIntent =
-            Intent(context, ClearDatabaseJobIntentServiceReceiver::class.java)
-        val pendingBroadcastIntent =
-            PendingIntent.getBroadcast(
-                context,
-                INTENT_REQUEST_CODE,
-                clearTransactionsBroadcastIntent,
-                PendingIntent.FLAG_ONE_SHOT or immutableFlag(),
-            )
-        return NotificationCompat.Action(
-            R.drawable.chucker_ic_delete_white,
-            clearTitle,
-            pendingBroadcastIntent,
-        )
-    }
-
-    fun dismissNotifications() {
-        notificationManager.cancel(TRANSACTION_NOTIFICATION_ID)
-    }
-
-    private fun immutableFlag() =
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            PendingIntent.FLAG_IMMUTABLE
-        } else {
-            0
-        }
-}