react-native-security-suite 0.6.7 → 0.7.0

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

@@ -1,86 +0,0 @@
-package com.securitysuite.internal.support
-
-import okhttp3.Headers
-import okhttp3.Response
-import okio.Source
-import okio.buffer
-import okio.gzip
-import okio.source
-import org.brotli.dec.BrotliInputStream
-import java.net.HttpURLConnection.HTTP_NOT_MODIFIED
-import java.net.HttpURLConnection.HTTP_NO_CONTENT
-import java.net.HttpURLConnection.HTTP_OK
-import java.util.Locale
-
-private const val HTTP_CONTINUE = 100
-
-/** Returns true if the response must have a (possibly 0-length) body. See RFC 7231.  */
-internal fun Response.hasBody(): Boolean {
-    // HEAD requests never yield a body regardless of the response headers.
-    if (request.method == "HEAD") {
-        return false
-    }
-
-    val responseCode = code
-    if ((responseCode < HTTP_CONTINUE || responseCode >= HTTP_OK) &&
-        (responseCode != HTTP_NO_CONTENT) &&
-        (responseCode != HTTP_NOT_MODIFIED)
-    ) {
-        return true
-    }
-
-    // If the Content-Length or Transfer-Encoding headers disagree with the response code, the
-    // response is malformed. For best compatibility, we honor the headers.
-    return ((contentLength > 0) || isChunked)
-}
-
-private val Response.contentLength: Long
-    get() {
-        return this.header("Content-Length")?.toLongOrNull() ?: -1L
-    }
-
-internal val Response.isChunked: Boolean
-    get() {
-        return this.header("Transfer-Encoding").equals("chunked", ignoreCase = true)
-    }
-
-internal val Response.contentType: String?
-    get() {
-        return this.header("Content-Type")
-    }
-
-private val Headers.containsGzip: Boolean
-    get() {
-        return this["Content-Encoding"].equals("gzip", ignoreCase = true)
-    }
-
-private val Headers.containsBrotli: Boolean
-    get() {
-        return this["Content-Encoding"].equals("br", ignoreCase = true)
-    }
-
-private val supportedEncodings = listOf("identity", "gzip", "br")
-
-internal val Headers.hasSupportedContentEncoding: Boolean
-    get() =
-        get("Content-Encoding")
-            ?.takeIf { it.isNotEmpty() }
-            ?.let { it.lowercase(Locale.ROOT) in supportedEncodings }
-            ?: true
-
-internal fun Source.uncompress(headers: Headers) =
-    when {
-        headers.containsGzip -> gzip()
-        headers.containsBrotli -> BrotliInputStream(this.buffer().inputStream()).source()
-        else -> this
-    }
-
-internal fun Headers.redact(names: Iterable<String>): Headers {
-    val builder = newBuilder()
-    for (name in names()) {
-        if (names.any { userHeader -> userHeader.equals(name, ignoreCase = true) }) {
-            builder[name] = "**"
-        }
-    }
-    return builder.build()
-}

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

@@ -1,34 +0,0 @@
-package com.securitysuite.internal.support
-
-import okio.Buffer
-import okio.ByteString
-import java.io.EOFException
-import kotlin.math.min
-
-private const val MAX_PREFIX_SIZE = 64L
-private const val CODE_POINT_SIZE = 16
-
-/**
- * Returns true if the [Buffer] contains human readable text. Uses a small sample
- * of code points to detect unicode control characters commonly used in binary file signatures.
- */
-internal val Buffer.isProbablyPlainText
-    get() =
-        try {
-            val prefix = Buffer()
-            val byteCount = min(size, MAX_PREFIX_SIZE)
-            copyTo(prefix, 0, byteCount)
-            sequence { while (!prefix.exhausted()) yield(prefix.readUtf8CodePoint()) }
-                .take(CODE_POINT_SIZE)
-                .all { codePoint -> codePoint.isPlainTextChar() }
-        } catch (_: EOFException) {
-            false // Truncated UTF-8 sequence
-        }
-
-internal val ByteString.isProbablyPlainText: Boolean
-    get() {
-        val byteCount = min(size, MAX_PREFIX_SIZE.toInt())
-        return Buffer().write(this, offset = 0, byteCount).isProbablyPlainText
-    }
-
-private fun Int.isPlainTextChar() = Character.isWhitespace(this) || !Character.isISOControl(this)

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

@@ -1,30 +0,0 @@
-package com.securitysuite.internal.support
-
-import com.securitysuite.api.BodyDecoder
-import okhttp3.Headers
-import okhttp3.MediaType
-import okhttp3.Request
-import okhttp3.Response
-import okio.ByteString
-import kotlin.text.Charsets.UTF_8
-
-internal object PlainTextDecoder : BodyDecoder {
-    override fun decodeRequest(
-        request: Request,
-        body: ByteString,
-    ) = body.tryDecodeAsPlainText(request.headers, request.body?.contentType())
-
-    override fun decodeResponse(
-        response: Response,
-        body: ByteString,
-    ) = body.tryDecodeAsPlainText(response.headers, response.body?.contentType())
-
-    private fun ByteString.tryDecodeAsPlainText(
-        headers: Headers,
-        contentType: MediaType?,
-    ) = if (headers.hasSupportedContentEncoding && isProbablyPlainText) {
-        string(contentType?.charset() ?: UTF_8)
-    } else {
-        null
-    }
-}

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

@@ -1,114 +0,0 @@
-package com.securitysuite.internal.support
-
-import okio.Buffer
-import okio.Sink
-import okio.Timeout
-import okio.sink
-import java.io.File
-import java.io.IOException
-
-/**
- * A sink that reports result of writing to it via [callback].
- *
- * Takes an input [downstreamFile] and writes bytes from a source into this input. Amount of bytes
- * to copy can be limited with [writeByteLimit]. Results are reported back to a client
- * when sink is closed or when an exception occurs while creating a downstream sink or while
- * writing bytes.
- */
-internal class ReportingSink(
-    private val downstreamFile: File?,
-    private val callback: Callback,
-    private val writeByteLimit: Long = Long.MAX_VALUE,
-) : Sink {
-    private var totalByteCount = 0L
-    private var isFailure = false
-    private var isClosed = false
-    private var downstream =
-        try {
-            downstreamFile?.sink()
-        } catch (e: IOException) {
-            callDownstreamFailure(IOException("Failed to use file $downstreamFile by Chucker", e))
-            null
-        }
-
-    override fun write(
-        source: Buffer,
-        byteCount: Long,
-    ) {
-        val previousTotalByteCount = totalByteCount
-        totalByteCount += byteCount
-        if (isFailure || previousTotalByteCount >= writeByteLimit) return
-
-        val bytesToWrite =
-            if (previousTotalByteCount + byteCount <= writeByteLimit) {
-                byteCount
-            } else {
-                writeByteLimit - previousTotalByteCount
-            }
-
-        if (bytesToWrite == 0L) return
-
-        try {
-            downstream?.write(source, bytesToWrite)
-        } catch (e: IOException) {
-            callDownstreamFailure(e)
-        }
-    }
-
-    override fun flush() {
-        if (isFailure) return
-        try {
-            downstream?.flush()
-        } catch (e: IOException) {
-            callDownstreamFailure(e)
-        }
-    }
-
-    override fun close() {
-        if (isClosed) return
-        isClosed = true
-        safeCloseDownstream()
-        callback.onClosed(downstreamFile, totalByteCount)
-    }
-
-    override fun timeout(): Timeout = downstream?.timeout() ?: Timeout.NONE
-
-    private fun callDownstreamFailure(exception: IOException) {
-        if (!isFailure) {
-            isFailure = true
-            safeCloseDownstream()
-            callback.onFailure(downstreamFile, exception)
-        }
-    }
-
-    private fun safeCloseDownstream() =
-        try {
-            downstream?.close()
-        } catch (e: IOException) {
-            callDownstreamFailure(e)
-        }
-
-    interface Callback {
-        /**
-         * Called when the sink is closed. All written bytes are copied to the [file].
-         * This does not mean that the content of the [file] is valid. Only that the client
-         * is done with the writing process.
-         *
-         * [sourceByteCount] is the exact amount of bytes that the were read from upstream even if
-         * the [file] is corrupted or does not exist. It is not limited by [writeByteLimit].
-         */
-        fun onClosed(
-            file: File?,
-            sourceByteCount: Long,
-        )
-
-        /**
-         * Called when an [exception] was thrown while processing data.
-         * Any written bytes are available in a [file].
-         */
-        fun onFailure(
-            file: File?,
-            exception: IOException,
-        )
-    }
-}

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

@@ -1,102 +0,0 @@
-package com.securitysuite.internal.support
-
-import android.content.Context
-import com.securitysuite.R
-import com.securitysuite.api.BodyDecoder
-import com.securitysuite.api.ChuckerCollector
-import com.securitysuite.internal.data.entity.HttpTransaction
-import okhttp3.Request
-import okio.Buffer
-import okio.ByteString
-import okio.IOException
-
-internal class RequestProcessor(
-    private val context: Context,
-    private val collector: ChuckerCollector,
-    private val maxContentLength: Long,
-    private val headersToRedact: Set<String>,
-    private val bodyDecoders: List<BodyDecoder>,
-) {
-    fun process(
-        request: Request,
-        transaction: HttpTransaction,
-    ) {
-        processMetadata(request, transaction)
-        processPayload(request, transaction)
-        collector.onRequestSent(transaction)
-    }
-
-    private fun processMetadata(
-        request: Request,
-        transaction: HttpTransaction,
-    ) {
-        transaction.apply {
-            requestHeadersSize = request.headers.byteCount()
-            request.headers.redact(headersToRedact).let {
-                setRequestHeaders(it)
-                setGraphQlOperationName(it)
-            }
-            populateUrl(request.url)
-            graphQlDetected = isGraphQLRequest(this.graphQlOperationName, request)
-
-            requestDate = System.currentTimeMillis()
-            method = request.method
-            requestContentType = request.body?.contentType()?.toString()
-            requestPayloadSize = request.body?.contentLength()
-        }
-    }
-
-    private fun processPayload(
-        request: Request,
-        transaction: HttpTransaction,
-    ) {
-        val body = request.body ?: return
-        if (body.isOneShot()) {
-            Logger.info("Skipping one shot request body")
-            return
-        }
-        if (body.isDuplex()) {
-            Logger.info("Skipping duplex request body")
-            return
-        }
-
-        val requestSource =
-            try {
-                Buffer().apply { body.writeTo(this) }
-            } catch (e: IOException) {
-                Logger.error("Failed to read request payload", e)
-                return
-            }
-        val limitingSource = LimitingSource(requestSource.uncompress(request.headers), maxContentLength)
-
-        val contentBuffer = Buffer().apply { limitingSource.use { writeAll(it) } }
-
-        val decodedContent = decodePayload(request, contentBuffer.readByteString())
-        transaction.requestBody = decodedContent
-        transaction.isRequestBodyEncoded = decodedContent == null
-        if (decodedContent != null && limitingSource.isThresholdReached) {
-            transaction.requestBody += context.getString(R.string.chucker_body_content_truncated)
-        }
-    }
-
-    private fun decodePayload(
-        request: Request,
-        body: ByteString,
-    ) = bodyDecoders.asSequence()
-        .mapNotNull { decoder ->
-            try {
-                Logger.info("Decoding with: $decoder")
-                decoder.decodeRequest(request, body)
-            } catch (e: IOException) {
-                Logger.warn("Decoder $decoder failed to process request payload", e)
-                null
-            }
-        }.firstOrNull()
-
-    private fun isGraphQLRequest(
-        graphQLOperationName: String?,
-        request: Request,
-    ) = graphQLOperationName != null ||
-        request.url.pathSegments.contains("graphql") ||
-        request.url.host.contains("graphql")
-}

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

@@ -1,170 +0,0 @@
-package com.securitysuite.internal.support
-
-import com.securitysuite.api.BodyDecoder
-import com.securitysuite.api.ChuckerCollector
-import com.securitysuite.internal.data.entity.HttpTransaction
-import okhttp3.Response
-import okhttp3.ResponseBody.Companion.asResponseBody
-import okio.Buffer
-import okio.ByteString
-import okio.IOException
-import okio.Source
-import okio.buffer
-import okio.source
-import java.io.File
-
-internal class ResponseProcessor(
-    private val collector: ChuckerCollector,
-    private val cacheDirectoryProvider: CacheDirectoryProvider,
-    private val maxContentLength: Long,
-    private val headersToRedact: Set<String>,
-    private val alwaysReadResponseBody: Boolean,
-    private val bodyDecoders: List<BodyDecoder>,
-) {
-    fun process(
-        response: Response,
-        transaction: HttpTransaction,
-    ): Response {
-        processResponseMetadata(response, transaction)
-        return multiCastResponse(response, transaction)
-    }
-
-    private fun processResponseMetadata(
-        response: Response,
-        transaction: HttpTransaction,
-    ) {
-        transaction.apply {
-            // includes headers added later in the chain
-            requestHeadersSize = response.request.headers.byteCount()
-            setRequestHeaders(response.request.headers.redact(headersToRedact))
-            responseHeadersSize = response.headers.byteCount()
-            setResponseHeaders(response.headers.redact(headersToRedact))
-
-            requestDate = response.sentRequestAtMillis
-            responseDate = response.receivedResponseAtMillis
-            protocol = response.protocol.toString()
-            responseCode = response.code
-            responseMessage = response.message
-
-            response.handshake?.let { handshake ->
-                responseTlsVersion = handshake.tlsVersion.javaName
-                responseCipherSuite = handshake.cipherSuite.javaName
-            }
-
-            responseContentType = response.contentType
-
-            tookMs = (response.receivedResponseAtMillis - response.sentRequestAtMillis)
-        }
-    }
-
-    private fun multiCastResponse(
-        response: Response,
-        transaction: HttpTransaction,
-    ): Response {
-        val responseBody = response.body
-        if (!response.hasBody() || responseBody == null) {
-            collector.onResponseReceived(transaction)
-            return response
-        }
-
-        val contentType = responseBody.contentType()
-        val contentLength = responseBody.contentLength()
-
-        val sideStream =
-            ReportingSink(
-                createTempTransactionFile(),
-                ResponseReportingSinkCallback(response, transaction),
-                maxContentLength,
-            )
-        var upstream: Source = TeeSource(responseBody.source(), sideStream)
-        if (alwaysReadResponseBody) upstream = DepletingSource(upstream)
-
-        return response.newBuilder()
-            .body(upstream.buffer().asResponseBody(contentType, contentLength))
-            .build()
-    }
-
-    private fun createTempTransactionFile(): File? {
-        val cache = cacheDirectoryProvider.provide()
-        return if (cache == null) {
-            Logger.warn("Failed to obtain a valid cache directory for transaction files")
-            null
-        } else {
-            FileFactory.create(cache)
-        }
-    }
-
-    private fun processPayload(
-        response: Response,
-        payload: Buffer,
-        transaction: HttpTransaction,
-    ) {
-        val responseBody = response.body ?: return
-
-        val contentType = responseBody.contentType()
-
-        val isImageContentType = contentType?.toString()?.contains(CONTENT_TYPE_IMAGE, ignoreCase = true) == true
-        if (isImageContentType) {
-            if (payload.size < MAX_BLOB_SIZE) {
-                transaction.responseImageData = payload.readByteArray()
-            }
-        } else if (payload.size != 0L) {
-            val decodedContent = decodePayload(response, payload.readByteString())
-            transaction.responseBody = decodedContent
-            transaction.isResponseBodyEncoded = decodedContent == null
-        }
-    }
-
-    private fun decodePayload(
-        response: Response,
-        body: ByteString,
-    ) = bodyDecoders.asSequence()
-        .mapNotNull { decoder ->
-            try {
-                decoder.decodeResponse(response, body)
-            } catch (e: IOException) {
-                Logger.warn("Decoder $decoder failed to process response payload", e)
-                null
-            }
-        }.firstOrNull()
-
-    private inner class ResponseReportingSinkCallback(
-        private val response: Response,
-        private val transaction: HttpTransaction,
-    ) : ReportingSink.Callback {
-        override fun onClosed(
-            file: File?,
-            sourceByteCount: Long,
-        ) {
-            file?.readResponsePayload()?.let { payload ->
-                processPayload(response, payload, transaction)
-            }
-            transaction.responsePayloadSize = sourceByteCount
-            collector.onResponseReceived(transaction)
-            file?.delete()
-        }
-
-        override fun onFailure(
-            file: File?,
-            exception: java.io.IOException,
-        ) {
-            Logger.error("Failed to read response payload", exception)
-        }
-
-        private fun File.readResponsePayload() =
-            try {
-                source().uncompress(response.headers).use { source ->
-                    Buffer().apply { writeAll(source) }
-                }
-            } catch (e: java.io.IOException) {
-                Logger.error("Response payload couldn't be processed", e)
-                null
-            }
-    }
-
-    private companion object {
-        const val MAX_BLOB_SIZE = 1_000_000L
-
-        const val CONTENT_TYPE_IMAGE = "image"
-    }
-}

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

@@ -1,80 +0,0 @@
-package com.securitysuite.internal.support
-
-import android.text.SpannableStringBuilder
-import android.text.Spanned
-import android.text.style.BackgroundColorSpan
-import android.text.style.ForegroundColorSpan
-import android.text.style.UnderlineSpan
-import java.util.regex.Pattern
-
-/**
- * Highlight parts of the String when it matches the search.
- *
- * @param search the text to highlight
- */
-internal fun SpannableStringBuilder.highlightWithDefinedColors(
-    search: String,
-    startIndices: List<Int>,
-    backgroundColor: Int,
-    foregroundColor: Int,
-): SpannableStringBuilder {
-    return applyColoredSpannable(this, startIndices, search.length, backgroundColor, foregroundColor)
-}
-
-internal fun CharSequence.indicesOf(input: String): List<Int> =
-    Pattern.compile(input, Pattern.CASE_INSENSITIVE).toRegex()
-        .findAll(this)
-        .map { it.range.first }
-        .toCollection(mutableListOf())
-
-internal fun SpannableStringBuilder.highlightWithDefinedColorsSubstring(
-    search: String,
-    startIndex: Int,
-    backgroundColor: Int,
-    foregroundColor: Int,
-): SpannableStringBuilder {
-    return applyColoredSpannableSubstring(this, startIndex, search.length, backgroundColor, foregroundColor)
-}
-
-private fun applyColoredSpannableSubstring(
-    text: SpannableStringBuilder,
-    subStringStartPosition: Int,
-    subStringLength: Int,
-    backgroundColor: Int,
-    foregroundColor: Int,
-): SpannableStringBuilder {
-    return text.apply {
-        setSpan(
-            UnderlineSpan(),
-            subStringStartPosition,
-            subStringStartPosition + subStringLength,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-        setSpan(
-            ForegroundColorSpan(foregroundColor),
-            subStringStartPosition,
-            subStringStartPosition + subStringLength,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-        setSpan(
-            BackgroundColorSpan(backgroundColor),
-            subStringStartPosition,
-            subStringStartPosition + subStringLength,
-            Spanned.SPAN_EXCLUSIVE_EXCLUSIVE,
-        )
-    }
-}
-
-private fun applyColoredSpannable(
-    text: SpannableStringBuilder,
-    indexes: List<Int>,
-    length: Int,
-    backgroundColor: Int,
-    foregroundColor: Int,
-): SpannableStringBuilder {
-    return text.apply {
-        indexes.forEach {
-            applyColoredSpannableSubstring(text, it, length, backgroundColor, foregroundColor)
-        }
-    }
-}

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

@@ -1,86 +0,0 @@
-package com.securitysuite.internal.support
-
-import android.app.Activity
-import android.content.ClipData
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
-import androidx.core.app.ShareCompat
-import androidx.core.content.FileProvider
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import okio.BufferedSource
-import okio.Source
-import okio.buffer
-import okio.sink
-
-internal interface Sharable {
-    fun toSharableContent(context: Context): Source
-}
-
-internal fun Sharable.toSharableUtf8Content(context: Context) =
-    toSharableContent(context)
-        .buffer()
-        .use(BufferedSource::readUtf8)
-
-internal suspend fun Sharable.shareAsUtf8Text(
-    activity: Activity,
-    intentTitle: String,
-    intentSubject: String,
-): Intent {
-    val content = withContext(Dispatchers.Default) { toSharableUtf8Content(activity) }
-    return ShareCompat.IntentBuilder(activity)
-        .setType("text/plain")
-        .setChooserTitle(intentTitle)
-        .setSubject(intentSubject)
-        .setText(content)
-        .createChooserIntent()
-}
-
-internal fun Sharable.writeToFile(
-    context: Context,
-    fileName: String,
-): Uri? {
-    val cache = context.cacheDir
-    if (cache == null) {
-        Logger.warn("Failed to obtain a valid cache directory for file export")
-        return null
-    }
-
-    val file = FileFactory.create(cache, fileName)
-    if (file == null) {
-        Logger.warn("Failed to create an export file")
-        return null
-    }
-
-    val fileContent = toSharableContent(context)
-    file.sink().buffer().use { it.writeAll(fileContent) }
-
-    return FileProvider.getUriForFile(
-        context,
-        "${context.packageName}.com.securitysuite.provider",
-        file,
-    )
-}
-
-internal fun Sharable.shareAsFile(
-    activity: Activity,
-    fileName: String,
-    intentTitle: String,
-    intentSubject: String,
-    clipDataLabel: String,
-): Intent? {
-    val uri = writeToFile(activity, fileName) ?: return null
-    val shareIntent =
-        ShareCompat.IntentBuilder(activity)
-            .setType(activity.contentResolver.getType(uri))
-            .setChooserTitle(intentTitle)
-            .setSubject(intentSubject)
-            .setStream(uri)
-            .intent
-    shareIntent.apply {
-        clipData = ClipData.newRawUri(clipDataLabel, uri)
-        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-    }
-    return Intent.createChooser(shareIntent, intentTitle)
-}