Create a CountingInputStream utility to avoid duplication

Prevent INT overflow in BlossomUploader.kt
Connection Cleanup in ImageDownloader.kt
Added try-finally in Sha256Hasher.jvmAndroid.kt

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/sha256/CountingInputStream.jvmAndroid.kt

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2025 Vitor Pamplona
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+ * Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package com.vitorpamplona.quartz.utils.sha256
+
+import java.io.FilterInputStream
+import java.io.InputStream
+
+class CountingInputStream(
+    inputStream: InputStream,
+) : FilterInputStream(inputStream) {
+    var bytesRead: Long = 0
+        private set
+
+    override fun read(): Int {
+        val byte = super.read()
+        if (byte != -1) bytesRead++
+        return byte
+    }
+
+    override fun read(
+        b: ByteArray,
+        off: Int,
+        len: Int,
+    ): Int {
+        val count = super.read(b, off, len)
+        if (count > 0) bytesRead += count
+        return count
+    }
+
+    override fun skip(n: Long): Long {
+        val skipped = super.skip(n)
+        bytesRead += skipped
+        return skipped
+    }
+}

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/sha256/Sha256.jvmAndroid.kt

@@ -27,15 +27,19 @@ val pool = Sha256Pool(5) // max parallel operations
 actual fun sha256(data: ByteArray) = pool.hash(data)
 
 /**
- * Calculate SHA256 hash by streaming the input in chunks.
- * This avoids loading the entire input into memory at once.
- * Useful for hashing large files without running out of memory.
+ * Calculate SHA256 hash while counting bytes read from the stream.
+ * Returns both the hash and the number of bytes processed.
+ * This is more efficient than reading the stream twice.
  *
  * @param inputStream The input stream to hash
  * @param bufferSize Size of chunks to read (default 8KB)
- * @return SHA256 hash bytes
+ * @return Pair of (hash bytes, bytes read count)
  */
-fun sha256Stream(
+fun sha256StreamWithCount(
     inputStream: InputStream,
     bufferSize: Int = 8192,
-) = pool.hashStream(inputStream, bufferSize)
+): Pair<ByteArray, Long> {
+    val countingStream = CountingInputStream(inputStream)
+    val hash = pool.hashStream(countingStream, bufferSize)
+    return Pair(hash, countingStream.bytesRead)
+}

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/sha256/Sha256Hasher.jvmAndroid.kt

@@ -45,12 +45,17 @@ class Sha256Hasher {
         bufferSize: Int = 8192,
     ): ByteArray {
         val buffer = ByteArray(bufferSize)
-        var bytesRead: Int
+        try {
+            var bytesRead: Int
 
-        while (inputStream.read(buffer).also { bytesRead = it } != -1) {
-            digest.update(buffer, 0, bytesRead)
+            while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+                digest.update(buffer, 0, bytesRead)
+            }
+
+            return digest.digest()
+        } finally {
+            // Always reset digest to prevent contaminating the pool on exceptions
+            digest.reset()
         }
-
-        return digest.digest().also { digest.reset() }
     }
 }