implement optimizations

src/commonMain/kotlin/com/infendro/hash/sha2/SHA-224.kt

@@ -1,7 +1,6 @@
 package com.infendro.hash.sha2
 
-import com.infendro.bytearray.toUByteArray
-import com.infendro.bytearray.toUIntArray
+import com.infendro.bytes.intarray.copyInto
 import com.infendro.hash.HashFunction
 
 object `SHA-224` : HashFunction {
@@ -16,81 +15,17 @@ object `SHA-224` : HashFunction {
         0x3070dd17U, 0xf70e5939U,
         0xffc00b31U, 0x68581511U,
         0x64f98fa7U, 0xbefa4fa4U,
-    )
+    ).asIntArray()
 
-    private val c = uintArrayOf(
-        0x428a2f98U, 0x71374491U, 0xb5c0fbcfU, 0xe9b5dba5U, 0x3956c25bU, 0x59f111f1U, 0x923f82a4U, 0xab1c5ed5U,
-        0xd807aa98U, 0x12835b01U, 0x243185beU, 0x550c7dc3U, 0x72be5d74U, 0x80deb1feU, 0x9bdc06a7U, 0xc19bf174U,
-        0xe49b69c1U, 0xefbe4786U, 0x0fc19dc6U, 0x240ca1ccU, 0x2de92c6fU, 0x4a7484aaU, 0x5cb0a9dcU, 0x76f988daU,
-        0x983e5152U, 0xa831c66dU, 0xb00327c8U, 0xbf597fc7U, 0xc6e00bf3U, 0xd5a79147U, 0x06ca6351U, 0x14292967U,
-        0x27b70a85U, 0x2e1b2138U, 0x4d2c6dfcU, 0x53380d13U, 0x650a7354U, 0x766a0abbU, 0x81c2c92eU, 0x92722c85U,
-        0xa2bfe8a1U, 0xa81a664bU, 0xc24b8b70U, 0xc76c51a3U, 0xd192e819U, 0xd6990624U, 0xf40e3585U, 0x106aa070U,
-        0x19a4c116U, 0x1e376c08U, 0x2748774cU, 0x34b0bcb5U, 0x391c0cb3U, 0x4ed8aa4aU, 0x5b9cca4fU, 0x682e6ff3U,
-        0x748f82eeU, 0x78a5636fU, 0x84c87814U, 0x8cc70208U, 0x90befffaU, 0xa4506cebU, 0xbef9a3f7U, 0xc67178f2U,
-    )
-
-    override fun hash(
-        value: UByteArray,
-    ): UByteArray {
+    override fun hashInto(value: ByteArray, destination: ByteArray) {
+        val input = `SHA-256`.pad(value)
         val h = initial.copyOf()
+        val w = IntArray(64)
+        val v = IntArray(8)
 
-        val blocks = pad(value)
-            .chunked(64) { it.toUByteArray() }
-        for (block in blocks) {
-            process(h, block)
-        }
-
-        return h.sliceArray(0..6).toUByteArray()
-    }
-
-    private fun pad(
-        value: UByteArray,
-    ): UByteArray {
-        val l = value.size.toULong() * 8UL
-        return buildList {
-            addAll(value)
-            add(0x80U)
-            while (size % 64 != 56) {
-                add(0x00U)
-            }
-            addAll(l.toUByteArray())
-        }.toUByteArray()
-    }
-
-    private fun process(
-        h: UIntArray,
-        block: UByteArray,
-    ) {
-        val w = buildList {
-            addAll(block.toUIntArray())
-            for (i in 16..63) {
-                val s0 = get(i - 15).rotateRight(7) xor get(i - 15).rotateRight(18) xor (get(i - 15) shr 3)
-                val s1 = get(i - 2).rotateRight(17) xor get(i - 2).rotateRight(19) xor (get(i - 2) shr 10)
-                add(get(i - 16) + s0 + get(i - 7) + s1)
-            }
-        }.toUIntArray()
-        val v = h.copyOf()
-
-        repeat(64) { i ->
-            val s0 = v[0].rotateRight(2) xor v[0].rotateRight(13) xor v[0].rotateRight(22)
-            val s1 = v[4].rotateRight(6) xor v[4].rotateRight(11) xor v[4].rotateRight(25)
-            val ch = (v[4] and v[5]) xor (v[4].inv() and v[6])
-            val temp1 = v[7] + s1 + ch + this.c[i] + w[i]
-            val maj = (v[0] and v[1]) xor (v[0] and v[2]) xor (v[1] and v[2])
-            val temp2 = s0 + maj
-
-            v[7] = v[6]
-            v[6] = v[5]
-            v[5] = v[4]
-            v[4] = v[3] + temp1
-            v[3] = v[2]
-            v[2] = v[1]
-            v[1] = v[0]
-            v[0] = temp1 + temp2
-        }
-
-        for (i in 0..7) {
-            h[i] += v[i]
+        for (i in input.indices step block) {
+            `SHA-256`.process(h, input, i, w, v)
         }
+        h.copyInto(destination, endIndex = 7)
     }
 }