Update Hashing to support HMACs, update names in fs2.hashing to be clearer, introduce Digest type

core/js/src/main/scala/fs2/hash.scala

@@ -52,9 +52,9 @@ object hash {
         val h = Hash.unsafe[SyncIO](algorithm)
         source.chunks
           .fold(h) { (h, c) =>
-            h.addChunk(c).unsafeRunSync()
+            h.update(c).unsafeRunSync()
             h
           }
-          .flatMap(h => Stream.chunk(h.computeAndReset.unsafeRunSync()))
+          .flatMap(h => Stream.chunk(h.digest.unsafeRunSync().bytes))
       }
 }

core/js/src/main/scala/fs2/hashing/HashCompanionPlatform.scala

@@ -35,36 +35,70 @@ trait HashCompanionPlatform {
   private[fs2] def apply[F[_]: Sync](algorithm: HashAlgorithm): Resource[F, Hash[F]] =
     Resource.eval(Sync[F].delay(unsafe(algorithm)))
 
+  private[hashing] def hmac[F[_]: Sync](
+      algorithm: HashAlgorithm,
+      key: Chunk[Byte]
+  ): Resource[F, Hash[F]] =
+    Resource.eval(Sync[F].delay(unsafeHmac(algorithm, key)))
+
   private[fs2] def unsafe[F[_]: Sync](algorithm: HashAlgorithm): Hash[F] =
     new Hash[F] {
       private def newHash() = JsHash.createHash(toAlgorithmString(algorithm))
       private var h = newHash()
 
-      def addChunk(bytes: Chunk[Byte]): F[Unit] =
-        Sync[F].delay(unsafeAddChunk(bytes))
+      def update(bytes: Chunk[Byte]): F[Unit] =
+        Sync[F].delay(unsafeUpdate(bytes))
 
-      def computeAndReset: F[Chunk[Byte]] =
-        Sync[F].delay(unsafeComputeAndReset())
+      def digest: F[Digest] =
+        Sync[F].delay(unsafeDigest())
 
-      def unsafeAddChunk(chunk: Chunk[Byte]): Unit =
+      def unsafeUpdate(chunk: Chunk[Byte]): Unit =
         h.update(chunk.toUint8Array)
 
-      def unsafeComputeAndReset(): Chunk[Byte] = {
-        val result = Chunk.uint8Array(h.digest())
+      def unsafeDigest(): Digest = {
+        val result = Digest(Chunk.uint8Array(h.digest()))
         h = newHash()
         result
       }
     }
 
-  private def toAlgorithmString(algorithm: HashAlgorithm): String =
+  private[hashing] def toAlgorithmString(algorithm: HashAlgorithm): String =
     algorithm match {
       case HashAlgorithm.MD5         => "MD5"
       case HashAlgorithm.SHA1        => "SHA1"
+      case HashAlgorithm.SHA224      => "SHA224"
       case HashAlgorithm.SHA256      => "SHA256"
       case HashAlgorithm.SHA384      => "SHA384"
       case HashAlgorithm.SHA512      => "SHA512"
+      case HashAlgorithm.SHA512_224  => "SHA512-224"
+      case HashAlgorithm.SHA512_256  => "SHA512-256"
+      case HashAlgorithm.SHA3_224    => "SHA3-224"
+      case HashAlgorithm.SHA3_256    => "SHA3-256"
+      case HashAlgorithm.SHA3_384    => "SHA3-384"
+      case HashAlgorithm.SHA3_512    => "SHA3-512"
       case HashAlgorithm.Named(name) => name
     }
+
+  private[fs2] def unsafeHmac[F[_]: Sync](algorithm: HashAlgorithm, key: Chunk[Byte]): Hash[F] =
+    new Hash[F] {
+      private def newHash() = JsHash.createHmac(toAlgorithmString(algorithm), key.toUint8Array)
+      private var h = newHash()
+
+      def update(bytes: Chunk[Byte]): F[Unit] =
+        Sync[F].delay(unsafeUpdate(bytes))
+
+      def digest: F[Digest] =
+        Sync[F].delay(unsafeDigest())
+
+      def unsafeUpdate(chunk: Chunk[Byte]): Unit =
+        h.update(chunk.toUint8Array)
+
+      def unsafeDigest(): Digest = {
+        val result = Digest(Chunk.uint8Array(h.digest()))
+        h = newHash()
+        result
+      }
+    }
 }
 
 private[hashing] object JsHash {
@@ -74,6 +108,11 @@ private[hashing] object JsHash {
   @nowarn212("cat=unused")
   private[fs2] def createHash(algorithm: String): Hash = js.native
 
+  @js.native
+  @JSImport("crypto", "createHmac")
+  @nowarn212("cat=unused")
+  private[fs2] def createHmac(algorithm: String, key: Uint8Array): Hash = js.native
+
   @js.native
   @nowarn212("cat=unused")
   private[fs2] trait Hash extends js.Object {

core/js/src/test/scala/fs2/hashing/HashingSuitePlatform.scala

@@ -25,9 +25,15 @@ package hashing
 import scodec.bits.ByteVector
 
 trait HashingSuitePlatform {
-  def digest(algo: String, str: String): Chunk[Byte] = {
-    val hash = JsHash.createHash(algo.replace("-", ""))
+  def digest(algo: HashAlgorithm, str: String): Digest = {
+    val hash = JsHash.createHash(Hash.toAlgorithmString(algo))
     hash.update(ByteVector.view(str.getBytes).toUint8Array)
-    Chunk.uint8Array(hash.digest())
+    Digest(Chunk.uint8Array(hash.digest()))
+  }
+
+  def hmac(algo: HashAlgorithm, key: Chunk[Byte], str: String): Digest = {
+    val hash = JsHash.createHmac(Hash.toAlgorithmString(algo), key.toUint8Array)
+    hash.update(ByteVector.view(str.getBytes).toUint8Array)
+    Digest(Chunk.uint8Array(hash.digest()))
   }
 }

core/jvm/src/main/scala/fs2/hashing/HashCompanionPlatform.scala

@@ -25,39 +25,98 @@ package hashing
 import cats.effect.{Resource, Sync}
 
 import java.security.MessageDigest
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
 
 private[hashing] trait HashCompanionPlatform {
 
   private[hashing] def apply[F[_]: Sync](algorithm: HashAlgorithm): Resource[F, Hash[F]] =
     Resource.eval(Sync[F].delay(unsafe(algorithm)))
 
+  private[hashing] def hmac[F[_]: Sync](
+      algorithm: HashAlgorithm,
+      key: Chunk[Byte]
+  ): Resource[F, Hash[F]] =
+    Resource.eval(Sync[F].delay(unsafeHmac(algorithm, key)))
+
   private[hashing] def unsafe[F[_]: Sync](algorithm: HashAlgorithm): Hash[F] =
     unsafeFromMessageDigest(MessageDigest.getInstance(toAlgorithmString(algorithm)))
 
-  private def toAlgorithmString(algorithm: HashAlgorithm): String =
+  private[hashing] def toAlgorithmString(algorithm: HashAlgorithm): String =
     algorithm match {
       case HashAlgorithm.MD5         => "MD5"
       case HashAlgorithm.SHA1        => "SHA-1"
+      case HashAlgorithm.SHA224      => "SHA-224"
       case HashAlgorithm.SHA256      => "SHA-256"
       case HashAlgorithm.SHA384      => "SHA-384"
       case HashAlgorithm.SHA512      => "SHA-512"
+      case HashAlgorithm.SHA512_224  => "SHA-512/224"
+      case HashAlgorithm.SHA512_256  => "SHA-512/256"
+      case HashAlgorithm.SHA3_224    => "SHA3-224"
+      case HashAlgorithm.SHA3_256    => "SHA3-256"
+      case HashAlgorithm.SHA3_384    => "SHA3-384"
+      case HashAlgorithm.SHA3_512    => "SHA3-512"
+      case HashAlgorithm.Named(name) => name
+    }
+
+  private[hashing] def unsafeHmac[F[_]: Sync](
+      algorithm: HashAlgorithm,
+      key: Chunk[Byte]
+  ): Hash[F] = {
+    val name = toMacAlgorithmString(algorithm)
+    val mac = Mac.getInstance(name)
+    mac.init(new SecretKeySpec(key.toArray, name))
+    unsafeFromMac(mac)
+  }
+
+  private[hashing] def toMacAlgorithmString(algorithm: HashAlgorithm): String =
+    algorithm match {
+      case HashAlgorithm.MD5         => "HmacMD5"
+      case HashAlgorithm.SHA1        => "HmacSHA1"
+      case HashAlgorithm.SHA224      => "HmacSHA224"
+      case HashAlgorithm.SHA256      => "HmacSHA256"
+      case HashAlgorithm.SHA384      => "HmacSHA384"
+      case HashAlgorithm.SHA512      => "HmacSHA512"
+      case HashAlgorithm.SHA512_224  => "HmacSHA512/224"
+      case HashAlgorithm.SHA512_256  => "HmacSHA512/256"
+      case HashAlgorithm.SHA3_224    => "HmacSHA3-224"
+      case HashAlgorithm.SHA3_256    => "HmacSHA3-256"
+      case HashAlgorithm.SHA3_384    => "HmacSHA3-384"
+      case HashAlgorithm.SHA3_512    => "HmacSHA3-512"
       case HashAlgorithm.Named(name) => name
     }
 
   def unsafeFromMessageDigest[F[_]: Sync](d: MessageDigest): Hash[F] =
     new Hash[F] {
-      def addChunk(bytes: Chunk[Byte]): F[Unit] =
-        Sync[F].delay(unsafeAddChunk(bytes))
+      def update(bytes: Chunk[Byte]): F[Unit] =
+        Sync[F].delay(unsafeUpdate(bytes))
+
+      def digest: F[Digest] =
+        Sync[F].delay(unsafeDigest())
+
+      def unsafeUpdate(chunk: Chunk[Byte]): Unit = {
+        val slice = chunk.toArraySlice
+        d.update(slice.values, slice.offset, slice.size)
+      }
+
+      def unsafeDigest(): Digest =
+        Digest(Chunk.array(d.digest()))
+    }
+
+  def unsafeFromMac[F[_]: Sync](d: Mac): Hash[F] =
+    new Hash[F] {
+      def update(bytes: Chunk[Byte]): F[Unit] =
+        Sync[F].delay(unsafeUpdate(bytes))
 
-      def computeAndReset: F[Chunk[Byte]] =
-        Sync[F].delay(unsafeComputeAndReset())
+      def digest: F[Digest] =
+        Sync[F].delay(unsafeDigest())
 
-      def unsafeAddChunk(chunk: Chunk[Byte]): Unit = {
+      def unsafeUpdate(chunk: Chunk[Byte]): Unit = {
         val slice = chunk.toArraySlice
         d.update(slice.values, slice.offset, slice.size)
       }
 
-      def unsafeComputeAndReset(): Chunk[Byte] =
-        Chunk.array(d.digest())
+      def unsafeDigest(): Digest =
+        Digest(Chunk.array(d.doFinal()))
     }
 }

core/jvm/src/test/scala/fs2/hashing/HashingSuitePlatform.scala

@@ -20,10 +20,22 @@
  */
 
 package fs2
+package hashing
 
 import java.security.MessageDigest
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
 
 trait HashingSuitePlatform {
-  def digest(algo: String, str: String): Chunk[Byte] =
-    Chunk.array(MessageDigest.getInstance(algo).digest(str.getBytes))
+  def digest(algo: HashAlgorithm, str: String): Digest =
+    Digest(
+      Chunk.array(MessageDigest.getInstance(Hash.toAlgorithmString(algo)).digest(str.getBytes))
+    )
+
+  def hmac(algo: HashAlgorithm, key: Chunk[Byte], str: String): Digest = {
+    val name = Hash.toMacAlgorithmString(algo)
+    val m = Mac.getInstance(name)
+    m.init(new SecretKeySpec(key.toArray, name))
+    Digest(Chunk.array(m.doFinal(str.getBytes)))
+  }
 }

core/native/src/main/scala/fs2/hash.scala

@@ -50,6 +50,6 @@ object hash {
       algorithm: HashAlgorithm
   )(implicit F: Sync[F]): Pipe[F, Byte, Byte] = {
     val h = Hashing.forSync[F]
-    h.hashWith(h.create(algorithm))
+    s => h.hashWith(h.hash(algorithm))(s).map(_.bytes).unchunks
   }
 }