react-native-security-suite 0.6.5 → 0.6.7

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

@@ -0,0 +1,202 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import android.text.SpannableStringBuilder
+import android.text.Spanned
+import android.text.style.ForegroundColorSpan
+import androidx.core.content.ContextCompat
+import com.securitysuite.R
+
+public class SpanTextUtil(context: Context) {
+    private val jsonKeyColor: Int
+    private val jsonValueColor: Int
+    private val jsonDigitsAndNullValueColor: Int
+    private val jsonSignElementsColor: Int
+    private val jsonBooleanColor: Int
+
+    private companion object {
+        // corresponds to length of word 'true'
+        private const val BOOLEAN_TRUE_INDEX_OFFSET = 4
+
+        // corresponds to length of word 'false'
+        private const val BOOLEAN_FALSE_INDEX_OFFSET = 5
+    }
+
+    init {
+        jsonKeyColor = ContextCompat.getColor(context, R.color.chucker_json_key_color)
+        jsonValueColor = ContextCompat.getColor(context, R.color.chucker_json_value_color)
+        jsonDigitsAndNullValueColor =
+            ContextCompat.getColor(context, R.color.chucker_json_digit_and_null_value_color)
+        jsonSignElementsColor = ContextCompat.getColor(context, R.color.chucker_json_elements_color)
+        jsonBooleanColor = ContextCompat.getColor(context, R.color.chucker_json_boolean_color)
+    }
+
+    private enum class TokenType(val delimiters: Set<String>) {
+        STRING(setOf("\"")),
+        ARRAY(setOf("[", "]")),
+        OBJECT(setOf("{", "}")),
+        KEY_SEPARATOR(setOf(":")),
+        VALUE_SEPARATOR(setOf(",")),
+        BOOLEAN(setOf("true", "false")),
+        NONE(setOf()),
+        ;
+
+        companion object {
+            val allPossibleTokens = values().map { it.delimiters }.flatten().toSet()
+        }
+    }
+
+    private fun CharSequence.indexOfNextToken(startIndex: Int = 0): Pair<Int, TokenType> {
+        val (index, matched) =
+            findAnyOf(
+                strings = TokenType.allPossibleTokens,
+                startIndex = startIndex,
+                ignoreCase = true,
+            ) ?: return -1 to TokenType.NONE
+        val tokenType =
+            when (matched) {
+                in TokenType.ARRAY.delimiters -> TokenType.ARRAY
+                in TokenType.OBJECT.delimiters -> TokenType.OBJECT
+                in TokenType.KEY_SEPARATOR.delimiters -> TokenType.KEY_SEPARATOR
+                in TokenType.VALUE_SEPARATOR.delimiters -> TokenType.VALUE_SEPARATOR
+                in TokenType.STRING.delimiters -> TokenType.STRING
+                in TokenType.BOOLEAN.delimiters -> TokenType.BOOLEAN
+                else -> null
+            }
+        tokenType?.let {
+            return index to it
+        }
+        return -1 to TokenType.NONE
+    }
+
+    private fun CharSequence.indexOfNextUnescapedQuote(startIndex: Int = 0): Int {
+        var index = indexOf('"', startIndex)
+        while (index < length) {
+            if (this[index] == '"' && (index == 0 || this[index - 1] != '\\')) {
+                return index
+            }
+            index = indexOf('"', index + 1)
+        }
+        return -1
+    }
+
+    public fun spanJson(input: CharSequence): SpannableStringBuilder {
+        // First handle the pretty printing step via gson built-in support
+        val prettyPrintedInput = FormatUtils.formatJson(input.toString())
+
+        var lastTokenType: TokenType? = null
+        var index = 0
+
+        val sb = SpannableStringBuilder(prettyPrintedInput)
+        // First we set a span for all text to match the digits and null value color since other
+        // cases will be overridden below
+        sb.setColor(0, prettyPrintedInput.length, jsonDigitsAndNullValueColor)
+        while (index < prettyPrintedInput.length) {
+            val (tokenIndex, tokenType) = prettyPrintedInput.indexOfNextToken(startIndex = index)
+            when (tokenType) {
+                TokenType.BOOLEAN ->
+                    sb.setBooleanColor(tokenIndex).also { endIndex ->
+                        index = endIndex
+                    }
+                TokenType.ARRAY,
+                TokenType.OBJECT,
+                TokenType.KEY_SEPARATOR,
+                TokenType.VALUE_SEPARATOR,
+                -> {
+                    sb.setColor(
+                        start = tokenIndex,
+                        end = tokenIndex + 1,
+                        color = jsonSignElementsColor,
+                    )
+                    index = tokenIndex + 1
+                }
+                TokenType.STRING ->
+                    sb.setStringColor(tokenIndex, lastTokenType)?.also { endIndex ->
+                        index = endIndex + 1
+                    } ?: return sb
+                TokenType.NONE -> return sb
+            }
+            lastTokenType = tokenType
+        }
+        return sb
+    }
+
+    private fun SpannableStringBuilder.setColor(
+        start: Int,
+        end: Int,
+        color: Int,
+    ): SpannableStringBuilder {
+        this.setSpan(
+            ChuckerForegroundColorSpan(color),
+            start,
+            end,
+            Spanned.SPAN_INCLUSIVE_INCLUSIVE,
+        )
+        return this
+    }
+
+    /**
+     * Given the tokenIndex, attempt to format the boolean value by first checking to see if the
+     * token starts with a 't' for true or not.
+     *
+     * Returns the index of the end of the spanned boolean value
+     */
+    private fun SpannableStringBuilder.setBooleanColor(tokenIndex: Int): Int {
+        val endIndex =
+            if (this[tokenIndex].equals('t', ignoreCase = true)) {
+                tokenIndex + BOOLEAN_TRUE_INDEX_OFFSET
+            } else {
+                tokenIndex + BOOLEAN_FALSE_INDEX_OFFSET
+            }
+        setColor(
+            start = tokenIndex,
+            end = endIndex,
+            color = jsonBooleanColor,
+        )
+        return endIndex
+    }
+
+    /**
+     * Given the tokenIndex and lastTokenType, attempt to format the color string by searching for
+     * the next unescaped quote mark in the string. If none is found, we return null immediately
+     * which should signal that the JSON string is incomplete and all further formatting should stop.
+     *
+     * Otherwise, we will return the index of the end of the spanned string
+     */
+    private fun SpannableStringBuilder.setStringColor(
+        tokenIndex: Int,
+        lastTokenType: TokenType? = null,
+    ): Int? {
+        val color =
+            when (lastTokenType) {
+                TokenType.ARRAY,
+                TokenType.OBJECT,
+                TokenType.VALUE_SEPARATOR,
+                TokenType.NONE,
+                null,
+                -> {
+                    jsonKeyColor
+                }
+                else -> {
+                    jsonValueColor
+                }
+            }
+
+        @Suppress("TooGenericExceptionCaught", "SwallowedException")
+        val endIndex =
+            try {
+                this.indexOfNextUnescapedQuote(tokenIndex + 1)
+            } catch (e: Exception) {
+                -1
+            }
+        // if we somehow get an incomplete string, we lose the ability to parse any other
+        // tokens, so just return now
+        if (endIndex < tokenIndex) {
+            return null
+        }
+        setColor(start = tokenIndex, end = endIndex + 1, color)
+        return endIndex
+    }
+
+    public class ChuckerForegroundColorSpan(color: Int) : ForegroundColorSpan(color)
+}

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

@@ -0,0 +1,68 @@
+package com.securitysuite.internal.support
+
+import okio.Buffer
+import okio.Sink
+import okio.Source
+import okio.Timeout
+import java.io.IOException
+
+/**
+ * A source that acts as a tee operator - https://en.wikipedia.org/wiki/Tee_(command).
+ *
+ * It takes the input [upstream] and reads from it serving the bytes to the end consumer
+ * like a regular [Source]. While bytes are read from the [upstream] the are also copied
+ * to a [sideStream].
+ */
+internal class TeeSource(
+    private val upstream: Source,
+    private val sideStream: Sink,
+) : Source {
+    private val tempBuffer = Buffer()
+    private var isFailure = false
+
+    override fun read(
+        sink: Buffer,
+        byteCount: Long,
+    ): Long {
+        val bytesRead = upstream.read(sink, byteCount)
+
+        if (bytesRead == -1L) {
+            safeCloseSideStream()
+            return -1L
+        }
+
+        if (!isFailure) {
+            copyBytesToSideStream(sink, bytesRead)
+        }
+
+        return bytesRead
+    }
+
+    private fun copyBytesToSideStream(
+        sink: Buffer,
+        bytesRead: Long,
+    ) {
+        val offset = sink.size - bytesRead
+        sink.copyTo(tempBuffer, offset, bytesRead)
+        try {
+            sideStream.write(tempBuffer, bytesRead)
+        } catch (_: IOException) {
+            isFailure = true
+            safeCloseSideStream()
+        }
+    }
+
+    override fun close() {
+        safeCloseSideStream()
+        upstream.close()
+    }
+
+    private fun safeCloseSideStream() =
+        try {
+            sideStream.close()
+        } catch (_: IOException) {
+            isFailure = true
+        }
+
+    override fun timeout(): Timeout = upstream.timeout()
+}

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

@@ -0,0 +1,46 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import com.securitysuite.internal.data.entity.HttpHeader
+import com.securitysuite.internal.data.entity.HttpTransaction
+import okio.Buffer
+import okio.Source
+
+internal class TransactionCurlCommandSharable(
+    private val transaction: HttpTransaction,
+) : Sharable {
+    override fun toSharableContent(context: Context): Source =
+        Buffer().apply {
+            var compressed = false
+            writeUtf8("curl -X ${transaction.method}")
+            val headers = transaction.getParsedRequestHeaders()
+
+            headers?.forEach { header ->
+                if (isCompressed(header)) {
+                    compressed = true
+                }
+                val headerValue = escapeHeaderValue(header.value)
+                writeUtf8(" -H \"${header.name}: ${headerValue}\"")
+            }
+
+            val requestBody = transaction.requestBody
+            if (!requestBody.isNullOrEmpty()) {
+                // try to keep to a single line and use a subshell to preserve any line breaks
+                writeUtf8(" --data $'${requestBody.replace("\n", "\\n")}'")
+            }
+            writeUtf8((if (compressed) " --compressed " else " ") + transaction.getFormattedUrl(encode = false))
+        }
+
+    private fun isCompressed(header: HttpHeader): Boolean {
+        return (
+            "Accept-Encoding".equals(header.name, ignoreCase = true) &&
+                "gzip".contains(header.value, ignoreCase = true) ||
+                "br".contains(header.value, ignoreCase = true)
+        )
+    }
+
+    private fun escapeHeaderValue(value: String): String {
+        // escape double quotes from header value to prevent getting an invalid curl
+        return value.replace("\"", "\\\"")
+    }
+}

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

@@ -0,0 +1,11 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import okio.Buffer
+import okio.Source
+
+internal class TransactionDetailsHarSharable(
+    private val content: String,
+) : Sharable {
+    override fun toSharableContent(context: Context): Source = Buffer().writeUtf8("$content\n")
+}

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

@@ -0,0 +1,73 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import com.securitysuite.R
+import com.securitysuite.internal.data.entity.HttpTransaction
+import okio.Buffer
+import okio.Source
+
+internal class TransactionDetailsSharable(
+    private val transaction: HttpTransaction,
+    private val encodeUrls: Boolean,
+) : Sharable {
+    override fun toSharableContent(context: Context): Source =
+        Buffer().apply {
+            writeUtf8("${context.getString(R.string.chucker_url)}: ${transaction.getFormattedUrl(encodeUrls)}\n")
+            writeUtf8("${context.getString(R.string.chucker_method)}: ${transaction.method}\n")
+            writeUtf8("${context.getString(R.string.chucker_protocol)}: ${transaction.protocol}\n")
+            writeUtf8("${context.getString(R.string.chucker_status)}: ${transaction.status}\n")
+            writeUtf8("${context.getString(R.string.chucker_response)}: ${transaction.responseSummaryText}\n")
+            val isSsl = if (transaction.isSsl) R.string.chucker_yes else R.string.chucker_no
+            writeUtf8("${context.getString(R.string.chucker_ssl)}: ${context.getString(isSsl)}\n")
+            writeUtf8("\n")
+            writeUtf8("${context.getString(R.string.chucker_request_time)}: ${transaction.requestDateString}\n")
+            writeUtf8("${context.getString(R.string.chucker_response_time)}: ${transaction.responseDateString}\n")
+            writeUtf8("${context.getString(R.string.chucker_duration)}: ${transaction.durationString}\n")
+            writeUtf8("\n")
+            writeUtf8("${context.getString(R.string.chucker_request_size)}: ${transaction.requestSizeString}\n")
+            writeUtf8("${context.getString(R.string.chucker_response_size)}: ${transaction.responseSizeString}\n")
+            writeUtf8("${context.getString(R.string.chucker_total_size)}: ${transaction.totalSizeString}\n")
+            writeUtf8("\n")
+            writeUtf8("---------- ${context.getString(R.string.chucker_request)} ----------\n\n")
+            var headers = FormatUtils.formatHeaders(transaction.getParsedRequestHeaders(), false)
+            if (headers.isNotBlank()) {
+                writeUtf8(headers)
+                writeUtf8("\n")
+            }
+            writeUtf8(
+                if (transaction.requestBody.isNullOrBlank()) {
+                    val resId =
+                        if (transaction.isResponseBodyEncoded) {
+                            R.string.chucker_body_omitted
+                        } else {
+                            R.string.chucker_body_empty
+                        }
+                    context.getString(resId)
+                } else {
+                    transaction.getFormattedRequestBody()
+                },
+            )
+            writeUtf8("\n\n")
+            writeUtf8("---------- ${context.getString(R.string.chucker_response)} ----------\n\n")
+            headers = FormatUtils.formatHeaders(transaction.getParsedResponseHeaders(), false)
+
+            if (headers.isNotBlank()) {
+                writeUtf8(headers)
+                writeUtf8("\n")
+            }
+
+            writeUtf8(
+                if (transaction.responseBody.isNullOrBlank()) {
+                    val resId =
+                        if (transaction.isResponseBodyEncoded) {
+                            R.string.chucker_body_omitted
+                        } else {
+                            R.string.chucker_body_empty
+                        }
+                    context.getString(resId)
+                } else {
+                    transaction.getFormattedResponseBody()
+                },
+            )
+        }
+}

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

@@ -0,0 +1,26 @@
+package com.securitysuite.internal.support
+
+import androidx.recyclerview.widget.DiffUtil
+import com.securitysuite.internal.data.entity.HttpTransactionTuple
+
+internal object TransactionDiffCallback : DiffUtil.ItemCallback<HttpTransactionTuple>() {
+    override fun areItemsTheSame(
+        oldItem: HttpTransactionTuple,
+        newItem: HttpTransactionTuple,
+    ): Boolean {
+        return oldItem.id == newItem.id
+    }
+
+    override fun areContentsTheSame(
+        oldItem: HttpTransactionTuple,
+        newItem: HttpTransactionTuple,
+    ): Boolean {
+        return oldItem == newItem
+    }
+
+    // Overriding function is empty on purpose to avoid flickering by default animator
+    override fun getChangePayload(
+        oldItem: HttpTransactionTuple,
+        newItem: HttpTransactionTuple,
+    ) = Unit
+}

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

@@ -0,0 +1,23 @@
+package com.securitysuite.internal.support
+
+import android.content.Context
+import com.securitysuite.R.string
+import com.securitysuite.internal.data.entity.HttpTransaction
+import okio.Buffer
+import okio.Source
+
+internal class TransactionListDetailsSharable(
+    transactions: List<HttpTransaction>,
+    encodeUrls: Boolean,
+) : Sharable {
+    private val transactions = transactions.map { TransactionDetailsSharable(it, encodeUrls) }
+
+    override fun toSharableContent(context: Context): Source =
+        Buffer().writeUtf8(
+            transactions.joinToString(
+                separator = "\n${context.getString(string.chucker_export_separator)}\n",
+                prefix = "${context.getString(string.chucker_export_prefix)}\n",
+                postfix = "\n${context.getString(string.chucker_export_postfix)}\n",
+            ) { it.toSharableUtf8Content(context) },
+        )
+}

package/android/src/main/java/com/securitysuite/internal/ui/BaseChuckerActivity.kt

@@ -0,0 +1,35 @@
+package com.securitysuite.internal.ui
+
+import android.os.Bundle
+import android.widget.Toast
+import androidx.appcompat.app.AppCompatActivity
+import com.securitysuite.internal.data.repository.RepositoryProvider
+
+internal abstract class BaseChuckerActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        RepositoryProvider.initialize(applicationContext)
+    }
+
+    override fun onResume() {
+        super.onResume()
+        isInForeground = true
+    }
+
+    override fun onPause() {
+        super.onPause()
+        isInForeground = false
+    }
+
+    companion object {
+        var isInForeground: Boolean = false
+            private set
+    }
+
+    fun showToast(
+        message: String,
+        toastDuration: Int = Toast.LENGTH_SHORT,
+    ) {
+        Toast.makeText(this.applicationContext, message, toastDuration).show()
+    }
+}