Merge pull request #24 from hartbit/hash-algorithm

Introduce a new HashAlgorithm protocol and make SHA256 conform to it

Author: aciidgh

Sources/TSCBasic/CMakeLists.txt

@@ -9,12 +9,12 @@
 add_library(TSCBasic
   Await.swift
   ByteString.swift
+  CStringArray.swift
   CacheableSequence.swift
   CodableResult.swift
   CollectionAlgorithms.swift
   CollectionExtensions.swift
   Condition.swift
-  CStringArray.swift
   DeltaAlgorithm.swift
   DiagnosticsEngine.swift
   DictionaryExtensions.swift
@@ -23,12 +23,12 @@ add_library(TSCBasic
   FileInfo.swift
   FileSystem.swift
   GraphAlgorithms.swift
+  HashAlgorithms.swift
   JSON.swift
   JSONMapper.swift
   KeyedPair.swift
   LazyCache.swift
   Lock.swift
-  misc.swift
   OSLog.swift
   ObjectIdentifierProtocol.swift
   OrderedDictionary.swift
@@ -41,14 +41,14 @@ add_library(TSCBasic
   ProcessSet.swift
   RegEx.swift
   Result.swift
-  SHA256.swift
   SortedArray.swift
   StringConversions.swift
   SynchronizedQueue.swift
   TemporaryFile.swift
   TerminalController.swift
   Thread.swift
-  Tuple.swift)
+  Tuple.swift
+  misc.swift)
 target_link_libraries(TSCBasic PUBLIC
   TSCLibc)
 if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)

Sources/TSCBasic/SHA256.swift renamed to Sources/TSCBasic/HashAlgorithms.swift

@@ -8,15 +8,31 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
+public protocol HashAlgorithm {
+
+    /// Hashes the input bytes, returning the digest.
+    ///
+    /// - Parameters:
+    ///   - bytes: The input bytes.
+    /// - Returns: The output digest.
+    func hash(_ bytes: ByteString) -> ByteString
+}
+
+extension HashAlgorithm {
+    public func hash(_ string: String) -> ByteString {
+        hash(ByteString([UInt8](string.utf8)))
+    }
+}
+
 /// SHA-256 implementation from Secure Hash Algorithm 2 (SHA-2) set of
 /// cryptographic hash functions (FIPS PUB 180-2).
-public final class SHA256 {
+public struct SHA256: HashAlgorithm {
 
     /// The length of the output digest (in bits).
-    let digestLength = 256
+    private static let digestLength = 256
 
     /// The size of each blocks (in bits).
-    let blockBitSize = 512
+    private static let blockBitSize = 512
 
     /// The initial hash value.
     private static let initalHashValue: [UInt32] = [
@@ -35,60 +51,28 @@ public final class SHA256 {
         0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
     ]
 
-    /// The hash that is being computed.
-    private var hash = SHA256.initalHashValue
-
-    /// The input that was provided. It will be padded when computing the digest.
-    private var input: [UInt8]
-
-    /// The result, once computed.
-    private var result: [UInt8]?
-
-    public init(_ input: [UInt8]) {
-        self.input = input
+    public init() {
     }
 
-    public init(_ bytes: ByteString) {
-        self.input = bytes.contents
-    }
-
-    public init(_ string: String) {
-        self.input = [UInt8](string.utf8)
-    }
-
-    /// Returns the digest as hexadecimal string.
-    public func digestString() -> String {
-        return digest().reduce("") {
-            var str = String($1, radix: 16)
-            // The above method does not do zero padding.
-            if str.count == 1 {
-                str = "0" + str
-            }
-            return $0 + str
-        }
-    }
-
-    /// Returns the digest.
-    public func digest() -> [UInt8] {
-
-        // If we already have the result, we're done.
-        if let result = self.result {
-            return result
-        }
+    public func hash(_ bytes: ByteString) -> ByteString {
+        var input = bytes.contents
 
         // Pad the input.
         pad(&input)
 
         // Break the input into N 512-bit blocks.
-        let messageBlocks = input.blocks(size: blockBitSize / 8)
+        let messageBlocks = input.blocks(size: SHA256.blockBitSize / 8)
+
+        /// The hash that is being computed.
+        var hash = SHA256.initalHashValue
 
         // Process each block.
         for block in messageBlocks {
-            process(block)
+            process(block, hash: &hash)
         }
 
         // Finally, compute the result.
-        var result = [UInt8](repeating: 0, count: digestLength / 8)
+        var result = [UInt8](repeating: 0, count: SHA256.digestLength / 8)
         for (idx, element) in hash.enumerated() {
             let pos = idx * 4
             result[pos + 0] = UInt8((element >> 24) & 0xff)
@@ -97,12 +81,11 @@ public final class SHA256 {
             result[pos + 3] = UInt8(element & 0xff)
         }
 
-        self.result = result
-        return result
+        return ByteString(result)
     }
 
     /// Process and compute hash from a block.
-    private func process(_ block: ArraySlice<UInt8>) {
+    private func process(_ block: ArraySlice<UInt8>, hash: inout [UInt32]) {
 
         // Compute message schedule.
         var W = [UInt32](repeating: 0, count: SHA256.konstants.count)

Tests/TSCBasicPerformanceTests/SHA256PerfTests.swift

@@ -15,14 +15,15 @@ import TSCTestSupport
 
 class SHA256PerfTests: XCTestCasePerf {
     func test20MBDigest_X1000() {
+        let sha256 = SHA256()
         let byte = "f"
         let stream = BufferedOutputByteStream()
         for _ in 0..<20000 {
             stream <<< byte
         }
         measure {
             for _ in 0..<1000 {
-                XCTAssertEqual(SHA256(stream.bytes).digestString(), "23d00697ba26b4140869bab958431251e7e41982794d41b605b6a1d5dee56abf")
+                XCTAssertEqual(sha256.hash(stream.bytes).hexadecimalRepresentation, "23d00697ba26b4140869bab958431251e7e41982794d41b605b6a1d5dee56abf")
             }
         }
     }

Tests/TSCBasicTests/SHA256Tests.swift

@@ -15,6 +15,7 @@ import TSCBasic
 class SHA256Tests: XCTestCase {
 
     func testBasics() throws {
+        let sha256 = SHA256()
         let knownHashes = [
             "": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
             "The quick brown fox jumps over the lazy dog": "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592",
@@ -25,7 +26,7 @@ class SHA256Tests: XCTestCase {
 
         // Test known hashes.
         for (input, hash) in knownHashes {
-            XCTAssertEqual(SHA256(input).digestString(), hash, "Incorrect value for \(input)")
+            XCTAssertEqual(sha256.hash(ByteString(input)).hexadecimalRepresentation, hash, "Incorrect value for \(input)")
         }
 
         // Test a big input.
@@ -34,12 +35,12 @@ class SHA256Tests: XCTestCase {
         for _ in 0..<20000 {
             stream <<< byte
         }
-        XCTAssertEqual(SHA256(stream.bytes).digestString(), "23d00697ba26b4140869bab958431251e7e41982794d41b605b6a1d5dee56abf")
+        XCTAssertEqual(sha256.hash(stream.bytes).hexadecimalRepresentation, "23d00697ba26b4140869bab958431251e7e41982794d41b605b6a1d5dee56abf")
     }
 
     func testLargeData() {
         let data: [UInt8] = (0..<1788).map { _ in 0x03 }
-        let digest = SHA256(data).digestString()
+        let digest = SHA256().hash(ByteString(data)).hexadecimalRepresentation
         XCTAssertEqual(digest, "907422e2f24d749d0add2b504ccae8ad1aa392477591905880fb2dc494e33d63")
     }
 }