Implemented block hashing

Author: catap

CHANGELOG.md

@@ -3,6 +3,7 @@
 All notable changes to this project will be documented in this file.
 
 ## [unreleased]
+- Implemented block hashing.
 
 ## [1.0.0] - 2021-07-11
 - The first public release as dedicated project.

README.md

@@ -29,11 +29,39 @@ The latest version is ![maven-central]
 API is pretty simple and quite limited :)
 ```
 scala> import ky.korins.sha._
+import ky.korins.sha._
 
 scala> Sha2_256.hash("abc".getBytes())
 val res1: Array[Byte] = Array(-70, 120, 22, -65, -113, 1, -49, -22, 65, 65, 64, -34, 93, -82, 34, 35, -80, 3, 97, -93, -106, 23, 122, -100, -76, 16, -1, 97, -14, 0, 21, -83)
 
 scala> 
 ```
 
+You may also create a new object from specified hash to `update` it, and at some
+point `finish` it like this:
+```
+scala> import ky.korins.sha._
+import ky.korins.sha._
+
+scala> val sha1 = new Sha1()
+val sha1: ky.korins.sha.Sha1 = ky.korins.sha.Sha1@1224e1b6
+
+scala> sha1.update("abc".getBytes(), 0, 2)
+
+scala> sha1.update("abc".getBytes(), 2, 1)
+
+scala> val hashed = new Array[Byte](20)
+val hashed: Array[Byte] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+scala> sha1.finish(hashed, 0)
+
+scala> hashed
+val res3: Array[Byte] = Array(-87, -103, 62, 54, 71, 6, -127, 106, -70, 62, 37, 113, 120, 80, -62, 108, -100, -48, -40, -99)
+
+scala> 
+```
+
+All these objects aren't thread safe. After `finish` it should be treated as
+broken.
+
 [maven-central]: https://img.shields.io/maven-central/v/ky.korins/sha_2.13?style=flat-square

shared/src/main/scala/ky/korins/sha/Hash.scala

@@ -0,0 +1,91 @@
+/*
+ * scala-sha - Secure Hash Algorithms family for scala, scala-js and scala-native.
+ *
+ * Written in 2020, 2021 by Kirill A. Korinsky <[email protected]>
+ *
+ * This work is released into the public domain with CC0 1.0.
+ */
+
+package ky.korins.sha
+
+trait Hash {
+  def update(bytes: Array[Byte], off: Int, len: Int): Unit
+
+  def finish(hashed: Array[Byte], off: Int): Unit
+
+  def finish(hashed: Array[Byte], off: Int, len: Int): Unit
+}
+
+private[sha] trait BlockedHash[T <: Array[_]] extends Hash {
+
+  protected val words: T
+  protected val block: Array[Byte]
+  private var blockPos = 0
+
+  protected var messageLen = 0
+
+  protected def finishBlock(block: Array[Byte], off: Int): Unit
+
+  def update(bytes: Array[Byte], off: Int, len: Int): Unit = {
+    var rem = len
+    var pos = off
+    if (blockPos > 0) {
+      val use = math.min(block.length - blockPos, rem)
+      System.arraycopy(bytes, pos, block, blockPos, use)
+      rem -= use
+      pos += use
+      blockPos += use
+    }
+    if (blockPos == block.length) {
+      finishBlock(block, 0)
+      blockPos = 0
+    }
+    while (rem >= block.length) {
+      finishBlock(bytes, pos)
+      pos += block.length
+      rem -= block.length
+    }
+    if (rem > 0) {
+      System.arraycopy(bytes, pos, block, 0, rem)
+      blockPos = rem
+    }
+    messageLen += len
+  }
+
+  final def finish(hashed: Array[Byte], off: Int, len: Int): Unit =
+    throw new NotImplementedError("XOF doesn't defined")
+
+  protected def padding_32bit(messageLen: Int): Array[Byte] = {
+    val tailLength = messageLen & 0x3f
+    val padLength = if (tailLength < 56) 64 - tailLength else 128 - tailLength
+
+    val padded = new Array[Byte](padLength)
+    padded(0) = 0x80.toByte
+
+    val lengthInBits = messageLen.toLong * 8
+    var i = 0
+    while (i < 8) {
+      padded(padded.length - 1 - i) = ((lengthInBits >>> (8 * i)) & 0xff).toByte
+      i += 1
+    }
+
+    padded
+  }
+
+  protected def padding_64bit(messageLen: Int): Array[Byte] = {
+    val tailLength = messageLen & 0x7f
+    val padLength = if (tailLength < 112) 128 - tailLength else 256 - tailLength
+
+    val padded = new Array[Byte](padLength)
+    padded(0) = 0x80.toByte
+
+    val lengthInBits = messageLen.toLong * 8
+    var i = 0
+    while (i < 8) {
+      padded(padded.length - 1 - i) = ((lengthInBits >>> (8 * i)) & 0xff).toByte
+      i += 1
+    }
+
+    padded
+  }
+}

shared/src/main/scala/ky/korins/sha/Paddings.scala

@@ -9,109 +9,23 @@
 package ky.korins.sha
 
 /**
- * Quite ugly but fast enough implementation of SHA-0
- *
  * Keep in mind that SHA-0 is broken and I implemented it just for fun :)
+ *
+ * This implementation also isn't thread safe.
  */
-object Sha0 {
-  def hash(message: Array[Byte]): Array[Byte] = {
-    import java.lang.Integer.rotateLeft
-
-    var H0 = 0x67452301
-    var H1 = 0xefcdab89
-    var H2 = 0x98badcfe
-    var H3 = 0x10325476
-    var H4 = 0xc3d2e1f0
-
-    val words = new Array[Int](80)
-    val block = new Array[Byte](64)
-    var padded = new Array[Byte](message.length + 64 - (message.length % 64))
-    val hashed = new Array[Byte](20)
-
-    padded = Paddings.padding_32(message)
-    val blocks = padded.length / 64
-
-    var i = 0
-    while (i < blocks) {
-      System.arraycopy(padded, 64 * i, block, 0, 64)
-      var j = 0
-      while (j < 16) {
-        words(j) = 0
-        var k = 0
-        while (k < 4) {
-          words(j) |= ((block(j * 4 + k) & 0x000000ff) << (24 - k * 8))
-          k += 1
-        }
-        j += 1
-      }
-
-      while (j < 80) {
-        words(j) = words(j - 3) ^ words(j - 8) ^ words(j - 14) ^ words(j - 16)
-        j += 1
-      }
-
-      var A = H0
-      var B = H1
-      var C = H2
-      var D = H3
-      var E = H4
-      var F = 0
-      var G = 0
-      j = 0
-      while (j < 80) {
-        if (j < 20) {
-          F = (B & C) | (~B & D)
-          G = 0x5a827999
-        } else if (19 < j && j < 40) {
-          F = B ^ C ^ D
-          G = 0x6ed9eba1
-        } else if (39 < j && j < 60) {
-          F = (B & C) | (B & D) | (C & D)
-          G = 0x8f1bbcdc
-        } else {
-          F = B ^ C ^ D
-          G = 0xca62c1d6
-        }
-
-        val temp = rotateLeft(A, 5) + F + E + G + words(j)
-
-        E = D
-        D = C
-        C = rotateLeft(B, 30)
-        B = A
-        A = temp
-        j += 1
-      }
-
-      H0 += A
-      H1 += B
-      H2 += C
-      H3 += D
-      H4 += E
-      i += 1
-    }
+class Sha0 extends Sha1 {
+  override protected def processBlockWord(j: Int): Int =
+    words(j - 3) ^ words(j - 8) ^ words(j - 14) ^ words(j - 16)
+}
 
-    hashed(0) = ((H0 >>> 24) & 0xff).toByte
-    hashed(1) = ((H0 >>> 16) & 0xff).toByte
-    hashed(2) = ((H0 >>> 8) & 0xff).toByte
-    hashed(3) = (H0 & 0xff).toByte
-    hashed(4) = ((H1 >>> 24) & 0xff).toByte
-    hashed(5) = ((H1 >>> 16) & 0xff).toByte
-    hashed(6) = ((H1 >>> 8) & 0xff).toByte
-    hashed(7) = (H1 & 0xff).toByte
-    hashed(8) = ((H2 >>> 24) & 0xff).toByte
-    hashed(9) = ((H2 >>> 16) & 0xff).toByte
-    hashed(10) = ((H2 >>> 8) & 0xff).toByte
-    hashed(11) = (H2 & 0xff).toByte
-    hashed(12) = ((H3 >>> 24) & 0xff).toByte
-    hashed(13) = ((H3 >>> 16) & 0xff).toByte
-    hashed(14) = ((H3 >>> 8) & 0xff).toByte
-    hashed(15) = (H3 & 0xff).toByte
-    hashed(16) = ((H4 >>> 24) & 0xff).toByte
-    hashed(17) = ((H4 >>> 16) & 0xff).toByte
-    hashed(18) = ((H4 >>> 8) & 0xff).toByte
-    hashed(19) = (H4 & 0xff).toByte
+object Sha0 {
+  val HASH_SIZE: Int = Sha1.HASH_SIZE
 
+  def hash(message: Array[Byte]): Array[Byte] = {
+    val sha0 = new Sha0()
+    sha0.update(message, 0, message.length)
+    val hashed = new Array[Byte](HASH_SIZE)
+    sha0.finish(hashed, 0)
     hashed
   }
 }