refactor hash functions

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

@@ -11,7 +11,14 @@ object `SHA-256` : HashFunction() {
     override val block: Int
         get() = 64
 
-    private val k = uintArrayOf(
+    private val initial = uintArrayOf(
+        0x6a09e667U, 0xbb67ae85U,
+        0x3c6ef372U, 0xa54ff53aU,
+        0x510e527fU, 0x9b05688cU,
+        0x1f83d9abU, 0x5be0cd19U,
+    )
+
+    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,
@@ -25,25 +32,20 @@ object `SHA-256` : HashFunction() {
     override fun hash(
         value: UByteArray,
     ): UByteArray {
-        var h0 = 0x6a09e667U
-        var h1 = 0xbb67ae85U
-        var h2 = 0x3c6ef372U
-        var h3 = 0xa54ff53aU
-        var h4 = 0x510e527fU
-        var h5 = 0x9b05688cU
-        var h6 = 0x1f83d9abU
-        var h7 = 0x5be0cd19U
-        val ml = value.size.toULong() * 8UL
+        val h = initial.copyOf()
+        val l = value.size.toULong() * 8UL
 
+        // padding
         val paddedValue = buildList {
             addAll(value)
             add(0x80U)
             while (size % 64 != 56) {
                 add(0x00U)
             }
-            addAll(ml.toUByteArray())
+            addAll(l.toUByteArray())
         }
 
+        // process
         val chunks = paddedValue
             .chunked(64) { it.toUByteArray() }
         for (chunk in chunks) {
@@ -54,54 +56,39 @@ object `SHA-256` : HashFunction() {
                     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)
                 }
-            }
-
-            var a = h0
-            var b = h1
-            var c = h2
-            var d = h3
-            var e = h4
-            var f = h5
-            var g = h6
-            var h = h7
-
-            for (i in 0..<64) {
-                val s0 = a.rotateRight(2) xor a.rotateRight(13) xor a.rotateRight(22)
-                val s1 = e.rotateRight(6) xor e.rotateRight(11) xor e.rotateRight(25)
-                val ch = (e and f) xor (e.inv() and g)
-                val temp1 = h + s1 + ch + k[i] + w[i]
-                val maj = (a and b) xor (a and c) xor (b and c)
-                val temp2 = s0 + maj
-
-                h = g
-                g = f
-                f = e
-                e = d + temp1
-                d = c
-                c = b
-                b = a
-                a = temp1 + temp2
-            }
-
-            h0 += a
-            h1 += b
-            h2 += c
-            h3 += d
-            h4 += e
-            h5 += f
-            h6 += g
-            h7 += h
+            }.toUIntArray()
+            process(h, w)
         }
 
-        return ubyteArrayOf(
-            *h0.toUByteArray(),
-            *h1.toUByteArray(),
-            *h2.toUByteArray(),
-            *h3.toUByteArray(),
-            *h4.toUByteArray(),
-            *h5.toUByteArray(),
-            *h6.toUByteArray(),
-            *h7.toUByteArray(),
-        )
+        return h.toUByteArray()
+    }
+
+    private fun process(
+        h: UIntArray,
+        w: UIntArray,
+    ) {
+        val v = h.copyOf()
+
+        for (i in 0..<64) {
+            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]
+        }
     }
 }