react-native-audio-browser 0.1.1 → 0.2.0-next.10

package/android/src/main/java/com/audiobrowser/player/VolumeFader.kt

@@ -0,0 +1,81 @@
+package com.audiobrowser.player
+
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+
+/**
+ * Ramps the player volume down over a duration (sleep-timer fade). The gain follows a squared
+ * curve: loudness perception is logarithmic, so a linear gain ramp sounds like a late cutoff rather
+ * than a fade.
+ */
+class VolumeFader(private val getVolume: () -> Float, private val setVolume: (Float) -> Unit) {
+  private val handler = Handler(Looper.getMainLooper())
+  private var stepRunnable: Runnable? = null
+
+  /**
+   * Volume captured when the fade started; restored after the fade resolves. Non-null from fade
+   * start until cancel/completion, even once the ramp has reached silence.
+   */
+  var originalVolume: Float? = null
+    private set
+
+  val isActive: Boolean
+    get() = originalVolume != null
+
+  fun start(durationSeconds: Double) {
+    // If a fade is already running, keep its captured volume as the baseline — the current
+    // (partially faded) volume is not the value to restore.
+    val baseVolume = originalVolume ?: getVolume()
+    cancel(restoreVolume = false)
+    originalVolume = baseVolume
+    if (durationSeconds <= 0) return
+
+    val startTime = SystemClock.uptimeMillis()
+    val durationMs = durationSeconds * 1000
+    val runnable =
+      object : Runnable {
+        override fun run() {
+          val progress = ((SystemClock.uptimeMillis() - startTime) / durationMs).coerceAtMost(1.0)
+          val remaining = (1 - progress).toFloat()
+          setVolume(baseVolume * remaining * remaining)
+          if (progress < 1.0) {
+            handler.postDelayed(this, STEP_INTERVAL_MS)
+          } else {
+            stepRunnable = null
+          }
+        }
+      }
+    stepRunnable = runnable
+    handler.post(runnable)
+  }
+
+  /**
+   * Stops the ramp. With [restoreVolume] the pre-fade volume is put back immediately
+   * (cancellation); without it the caller restores after pausing (completion path — restoring first
+   * would let full-volume audio slip out).
+   */
+  fun cancel(restoreVolume: Boolean) {
+    stepRunnable?.let { handler.removeCallbacks(it) }
+    stepRunnable = null
+    val original = originalVolume ?: return
+    originalVolume = null
+    if (restoreVolume) setVolume(original)
+  }
+
+  /**
+   * Resolves the fade around a halting action: stops the ramp, runs [halt], then restores the
+   * pre-fade volume — in that order, because restoring before halting would let full-volume audio
+   * slip out. The restore is skipped when no fade was running.
+   */
+  fun resolve(halt: () -> Unit) {
+    val preFadeVolume = originalVolume
+    cancel(restoreVolume = false)
+    halt()
+    preFadeVolume?.let { setVolume(it) }
+  }
+
+  companion object {
+    private const val STEP_INTERVAL_MS = 50L
+  }
+}

package/android/src/main/java/com/audiobrowser/tls/AiaCertChaser.kt

@@ -0,0 +1,156 @@
+package com.audiobrowser.tls
+
+import java.security.cert.X509Certificate
+
+/**
+ * Fills in missing intermediate CA certificates by following the Authority Information Access (AIA)
+ * "CA Issuers" pointer in a certificate, the way Apple's Secure Transport does automatically but
+ * Android's default trust manager does not.
+ *
+ * Many servers (a common misconfiguration) present only their leaf certificate and omit the
+ * intermediate(s) needed to chain up to a trusted root. Browsers and iOS fetch the missing
+ * intermediate from the URL in the leaf's AIA extension; Android's `X509TrustManager` validates
+ * only what the server sent, so such streams fail with "Trust anchor for certification path not
+ * found".
+ */
+object AiaCertChaser {
+  /** Authority Information Access extension. */
+  private const val AIA_OID = "1.3.6.1.5.5.7.1.1"
+
+  /** DER-encoded OID value of id-ad-caIssuers (1.3.6.1.5.5.7.48.2). */
+  private val CA_ISSUERS_OID = byteArrayOf(0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x30, 0x02)
+
+  private const val TAG_SEQUENCE = 0x30
+  private const val TAG_OID = 0x06
+  private const val TAG_OCTET_STRING = 0x04
+
+  /**
+   * GeneralName.uniformResourceIdentifier = [6] IMPLICIT IA5String (context-specific, primitive).
+   */
+  private const val TAG_URI = 0x86
+
+  /**
+   * Returns the "CA Issuers" URLs from the certificate's AIA extension (the locations from which
+   * the issuing CA certificate can be fetched), or an empty list if the extension is absent or
+   * unparseable.
+   */
+  fun extractCaIssuerUrls(cert: X509Certificate): List<String> {
+    val raw = cert.getExtensionValue(AIA_OID) ?: return emptyList()
+    return try {
+      // getExtensionValue() returns the extension value wrapped in an OCTET STRING.
+      val wrapper = DerReader(raw).read()
+      if (wrapper.tag != TAG_OCTET_STRING) return emptyList()
+
+      // AuthorityInfoAccessSyntax ::= SEQUENCE OF AccessDescription
+      val aiaSeq = DerReader(wrapper.content()).read()
+      if (aiaSeq.tag != TAG_SEQUENCE) return emptyList()
+
+      val urls = mutableListOf<String>()
+      val descriptions = DerReader(aiaSeq.content())
+      while (descriptions.hasNext()) {
+        // AccessDescription ::= SEQUENCE { accessMethod OID, accessLocation GeneralName }
+        val desc = descriptions.read()
+        if (desc.tag != TAG_SEQUENCE) continue
+        val fields = DerReader(desc.content())
+        val method = fields.read()
+        if (method.tag != TAG_OID || !method.content().contentEquals(CA_ISSUERS_OID)) continue
+        if (!fields.hasNext()) continue
+        val location = fields.read()
+        if (location.tag == TAG_URI) {
+          urls.add(String(location.content(), Charsets.US_ASCII))
+        }
+      }
+      urls
+    } catch (e: Exception) {
+      // Malformed DER: treat as "no AIA" rather than crashing the handshake.
+      emptyList()
+    }
+  }
+
+  /**
+   * Walks up from the presented chain, fetching each missing issuer via its predecessor's AIA "CA
+   * Issuers" pointer, until it reaches a self-signed certificate, an issuer that cannot be fetched,
+   * or [maxIntermediates] additions. Returns the (possibly extended) chain.
+   *
+   * Only ever *adds* certificates — the caller is still responsible for validating the completed
+   * chain against the system trust anchors, so this can never cause an untrusted chain to be
+   * accepted. From each URL's candidates the genuine issuer of the preceding certificate is
+   * selected (defends against an AIA pointer to an unrelated certificate, and picks the right one
+   * out of a multi-certificate PKCS#7 bundle).
+   *
+   * @param fetch resolves a CA-Issuers URL to its candidate certificates (e.g. every certificate in
+   *   a PKCS#7 bundle); empty if nothing could be retrieved.
+   */
+  fun completeChain(
+    presented: List<X509Certificate>,
+    maxIntermediates: Int = 5,
+    fetch: (url: String) -> List<X509Certificate>,
+  ): List<X509Certificate> {
+    if (presented.isEmpty()) return presented
+    val chain = presented.toMutableList()
+    val seen = HashSet(chain)
+    var added = 0
+    while (added < maxIntermediates) {
+      val last = chain.last()
+      if (last.subjectX500Principal == last.issuerX500Principal) break // self-signed root
+      val issuer =
+        extractCaIssuerUrls(last)
+          .asSequence()
+          .flatMap { url -> runCatching { fetch(url) }.getOrElse { emptyList() } }
+          .firstOrNull { it.subjectX500Principal == last.issuerX500Principal } ?: break
+      if (!seen.add(issuer)) break // cycle guard
+      chain.add(issuer)
+      added++
+    }
+    return chain
+  }
+
+  /**
+   * Minimal DER TLV reader over a byte buffer. Malformed input throws [IllegalArgumentException],
+   * which the callers above expect and turn into "no AIA".
+   *
+   * Every read is bounds-checked, and a declared length is rejected unless it is non-negative and
+   * within the buffer. Both matter: the extension bytes come from a server-presented certificate,
+   * so a length that shifts into a negative Int would rewind `pos` and spin [extractCaIssuerUrls]'s
+   * loop forever on the handshake thread rather than failing.
+   */
+  private class DerReader(private val buf: ByteArray) {
+    private var pos = 0
+
+    fun hasNext(): Boolean = pos < buf.size
+
+    fun read(): Tlv {
+      val tag = readByte()
+      var len = readByte()
+      if (len and 0x80 != 0) {
+        // Long form: the low bits give the number of length bytes. Four already covers any
+        // buffer that fits in memory; more would overflow the Int we shift them into. The
+        // indefinite form (0x80, i.e. zero length bytes) is not valid DER.
+        val numBytes = len and 0x7F
+        require(numBytes in 1..4) { "unsupported DER length form: $numBytes length bytes" }
+        len = 0
+        repeat(numBytes) { len = (len shl 8) or readByte() }
+        require(len >= 0) { "DER length overflows Int" }
+      }
+      require(len <= buf.size - pos) { "DER length $len runs past the end of the buffer" }
+      val tlv = Tlv(buf, tag, pos, len)
+      pos += len
+      return tlv
+    }
+
+    private fun readByte(): Int {
+      require(pos < buf.size) { "truncated DER" }
+      return buf[pos++].toInt() and 0xFF
+    }
+  }
+
+  /** A parsed tag-length-value: the tag and a view of its content bytes. */
+  private class Tlv(
+    private val buf: ByteArray,
+    val tag: Int,
+    private val offset: Int,
+    private val length: Int,
+  ) {
+    fun content(): ByteArray = buf.copyOfRange(offset, offset + length)
+  }
+}

package/android/src/main/java/com/audiobrowser/tls/AiaChasingExtendedTrustManager.kt

@@ -0,0 +1,109 @@
+package com.audiobrowser.tls
+
+import java.net.Socket
+import java.security.cert.CertificateException
+import java.security.cert.X509Certificate
+import javax.net.ssl.SSLEngine
+import javax.net.ssl.X509ExtendedTrustManager
+import javax.net.ssl.X509TrustManager
+
+/**
+ * The [AiaChasingTrustManager] behaviour, as an [X509ExtendedTrustManager].
+ *
+ * The socket- and engine-aware overloads are the ones the platform actually calls, and they are not
+ * optional. Android's default trust manager is a `RootTrustManager`, which extends
+ * [X509ExtendedTrustManager] and whose two-argument `checkServerTrusted` throws unconditionally
+ * once the app declares any `<domain-config>` in its network security config:
+ * > Domain specific configurations require that hostname aware
+ * > checkServerTrusted(X509Certificate[], String, String) is used
+ *
+ * Wrapping it in a plain [X509TrustManager] hides those overloads, so conscrypt falls through to
+ * the two-argument form and *every* HTTPS connection in the process fails — and, because the
+ * wrapper treats a [CertificateException] as its cue to chase AIA, fails slowly. The socket
+ * overload is also where endpoint identification happens for a raw `SSLSocket` configured with
+ * `endpointIdentificationAlgorithm = "HTTPS"`; skipping it skips hostname verification.
+ *
+ * [X509ExtendedTrustManager] is API 24+, hence the split from [AiaChasingTrustManager] — see
+ * [AiaTls.trustManager], which picks by SDK level. Per-domain network security configs are
+ * themselves API 24+, so the plain variant on 23 loses nothing.
+ *
+ * @param delegate the wrapped trust manager, normally the platform default.
+ * @param fetch resolves a CA-Issuers URL to its candidate certificates.
+ */
+class AiaChasingExtendedTrustManager(
+  private val delegate: X509TrustManager,
+  private val fetch: (url: String) -> List<X509Certificate>,
+) : X509ExtendedTrustManager() {
+
+  /** The delegate's own extended overloads, when it has them. */
+  private val extended = delegate as? X509ExtendedTrustManager
+
+  override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) =
+    withAiaRetry(chain) { delegate.checkServerTrusted(it, authType) }
+
+  override fun checkServerTrusted(
+    chain: Array<X509Certificate>,
+    authType: String,
+    socket: Socket?,
+  ) =
+    withAiaRetry(chain) {
+      // A delegate without the extended overloads cannot be hostname-aware in the first place,
+      // so falling back to its two-argument form loses nothing it could have offered.
+      extended?.checkServerTrusted(it, authType, socket)
+        ?: delegate.checkServerTrusted(it, authType)
+    }
+
+  override fun checkServerTrusted(
+    chain: Array<X509Certificate>,
+    authType: String,
+    engine: SSLEngine?,
+  ) =
+    withAiaRetry(chain) {
+      extended?.checkServerTrusted(it, authType, engine)
+        ?: delegate.checkServerTrusted(it, authType)
+    }
+
+  // Client certificates are the app's own; there is nothing to chase.
+
+  override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) =
+    delegate.checkClientTrusted(chain, authType)
+
+  override fun checkClientTrusted(
+    chain: Array<X509Certificate>,
+    authType: String,
+    socket: Socket?,
+  ) {
+    extended?.checkClientTrusted(chain, authType, socket)
+      ?: delegate.checkClientTrusted(chain, authType)
+  }
+
+  override fun checkClientTrusted(
+    chain: Array<X509Certificate>,
+    authType: String,
+    engine: SSLEngine?,
+  ) {
+    extended?.checkClientTrusted(chain, authType, engine)
+      ?: delegate.checkClientTrusted(chain, authType)
+  }
+
+  override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers
+
+  /**
+   * Runs [check], and on rejection retries it once against the AIA-completed chain. The completed
+   * chain goes through the same [check], so trust is never weakened: whatever the delegate would
+   * have refused, it still refuses.
+   */
+  private inline fun withAiaRetry(
+    chain: Array<X509Certificate>,
+    check: (Array<X509Certificate>) -> Unit,
+  ) {
+    try {
+      check(chain)
+    } catch (original: CertificateException) {
+      val completed = AiaCertChaser.completeChain(chain.toList(), fetch = fetch)
+      // Nothing could be added — the original failure stands (don't re-check an unchanged chain).
+      if (completed.size == chain.size) throw original
+      check(completed.toTypedArray())
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/tls/AiaChasingTrustManager.kt

@@ -0,0 +1,37 @@
+package com.audiobrowser.tls
+
+import java.security.cert.CertificateException
+import java.security.cert.X509Certificate
+import javax.net.ssl.X509TrustManager
+
+/**
+ * An [X509TrustManager] that retries validation after filling in missing intermediate certificates
+ * via the leaf's Authority Information Access (AIA) "CA Issuers" pointer.
+ *
+ * Wraps a [delegate] (typically the platform default trust manager). On the happy path the delegate
+ * accepts the server-presented chain on the first try and this adds nothing. Only when the delegate
+ * rejects the chain does it attempt AIA chasing — and the *completed* chain is still validated by
+ * the same delegate against the system trust anchors, so trust can never be weakened: an untrusted
+ * root still fails. See [AiaCertChaser].
+ */
+class AiaChasingTrustManager(
+  private val delegate: X509TrustManager,
+  private val fetch: (url: String) -> List<X509Certificate>,
+) : X509TrustManager {
+
+  override fun checkServerTrusted(chain: Array<X509Certificate>, authType: String) {
+    try {
+      delegate.checkServerTrusted(chain, authType)
+    } catch (original: CertificateException) {
+      val completed = AiaCertChaser.completeChain(chain.toList(), fetch = fetch)
+      // Nothing could be added — the original failure stands (don't re-check an unchanged chain).
+      if (completed.size == chain.size) throw original
+      delegate.checkServerTrusted(completed.toTypedArray(), authType)
+    }
+  }
+
+  override fun checkClientTrusted(chain: Array<X509Certificate>, authType: String) =
+    delegate.checkClientTrusted(chain, authType)
+
+  override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers
+}

package/android/src/main/java/com/audiobrowser/tls/AiaTls.kt

@@ -0,0 +1,55 @@
+package com.audiobrowser.tls
+
+import android.os.Build
+import java.security.KeyStore
+import javax.net.ssl.SSLContext
+import javax.net.ssl.SSLSocketFactory
+import javax.net.ssl.TrustManagerFactory
+import javax.net.ssl.X509TrustManager
+
+/**
+ * Builds TLS components that recover from servers which omit intermediate CA certificates, by
+ * following the leaf's Authority Information Access (AIA) "CA Issuers" pointer — the behaviour
+ * Apple's Secure Transport has by default but Android's lacks.
+ *
+ * The returned components are side-effect-free: they wrap the platform default trust manager and
+ * only ever *add* a missing intermediate before re-validating against the same system trust
+ * anchors, so they cannot weaken trust. Installing them as a process default (e.g.
+ * `HttpsURLConnection.setDefaultSSLSocketFactory(AiaTls.socketFactory())`) is the caller's
+ * decision.
+ */
+object AiaTls {
+
+  /**
+   * An [SSLSocketFactory] whose handshake validation chases missing intermediates via AIA. Intended
+   * to be built once (e.g. installed as the process default at startup); each call gets its own
+   * fetched-intermediate cache.
+   */
+  fun socketFactory(): SSLSocketFactory =
+    SSLContext.getInstance("TLS").apply { init(null, arrayOf(trustManager()), null) }.socketFactory
+
+  /**
+   * An [X509TrustManager] wrapping the platform default with AIA intermediate chasing.
+   *
+   * On API 24+ this is an [X509ExtendedTrustManager]. That is not cosmetic: the platform's default
+   * trust manager rejects the two-argument `checkServerTrusted` outright once the app declares any
+   * `<domain-config>`, so a plain wrapper would break every HTTPS connection in the process. See
+   * [AiaChasingExtendedTrustManager].
+   */
+  fun trustManager(): X509TrustManager {
+    val fetcher = CachingCertificateFetcher()
+    val fetch = { url: String -> fetcher.fetch(url) }
+    val system = systemTrustManager()
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+      AiaChasingExtendedTrustManager(system, fetch)
+    } else {
+      AiaChasingTrustManager(system, fetch)
+    }
+  }
+
+  private fun systemTrustManager(): X509TrustManager {
+    val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+    factory.init(null as KeyStore?)
+    return factory.trustManagers.filterIsInstance<X509TrustManager>().first()
+  }
+}