enum Hash -> struct Hash. crc extracted to static methods of class CRC. Result of CRC is always integer.

CryptoSwiftTests/HashTests.swift

@@ -21,12 +21,12 @@ final class CryptoSwiftTests: XCTestCase {
     
     func testMD5_data() {
         let data = [0x31, 0x32, 0x33] as Array<UInt8> // "1", "2", "3"
-        XCTAssertEqual(Hash.md5(data).calculate(), [0x20,0x2c,0xb9,0x62,0xac,0x59,0x07,0x5b,0x96,0x4b,0x07,0x15,0x2d,0x23,0x4b,0x70], "MD5 calculation failed");
+        XCTAssertEqual(Hash.md5(data), [0x20,0x2c,0xb9,0x62,0xac,0x59,0x07,0x5b,0x96,0x4b,0x07,0x15,0x2d,0x23,0x4b,0x70], "MD5 calculation failed");
     }
 
     func testMD5_emptyString() {
         let data:Data = "".data(using: String.Encoding.utf8, allowLossyConversion: false)!
-        XCTAssertEqual(Hash.md5(data.bytes).calculate(), [0xd4,0x1d,0x8c,0xd9,0x8f,0x00,0xb2,0x04,0xe9,0x80,0x09,0x98,0xec,0xf8,0x42,0x7e], "MD5 calculation failed")
+        XCTAssertEqual(Hash.md5(data.bytes), [0xd4,0x1d,0x8c,0xd9,0x8f,0x00,0xb2,0x04,0xe9,0x80,0x09,0x98,0xec,0xf8,0x42,0x7e], "MD5 calculation failed")
     }
 
     func testMD5_string() {
@@ -44,7 +44,7 @@ final class CryptoSwiftTests: XCTestCase {
         self.measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: false, for: { () -> Void in
             let arr = Array<UInt8>(repeating: 200, count: 1024 * 1024)
             self.startMeasuring()
-            _ = Hash.md5(arr).calculate()
+            _ = Hash.md5(arr)
             self.stopMeasuring()
         })
     }
@@ -131,7 +131,7 @@ final class CryptoSwiftTests: XCTestCase {
     }
     
     func testCRC16() {
-        let result = CRC().crc16([49,50,51,52,53,54,55,56,57] as Array<UInt8>)
+        let result = CRC.crc16([49,50,51,52,53,54,55,56,57] as Array<UInt8>)
         XCTAssert(result == 0xBB3D, "CRC16 failed")
     }
     

README.md

@@ -178,11 +178,11 @@ let bytes = "string".utf8.map({$0})
 
 Hashing a data or array of bytes (aka `Array<UInt8>`)
 ```swift
-/* Hash enum usage */
+/* Hash struct usage */
 let input:Array<UInt8> = [49, 50, 51]
 
 let output = input.md5()
-// alternatively: let output = CryptoSwift.Hash.md5(input).calculate()
+// alternatively: let output = CryptoSwift.Hash.md5(input)
 
 print(output.toHexString())
 ```

Sources/CryptoSwift/CRC.swift

@@ -6,8 +6,7 @@
 //  Copyright (c) 2014 Marcin Krzyzanowski. All rights reserved.
 //
 
-final class CRC {
-    
+public final class CRC {
     private static let table32:Array<UInt32> = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
         0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
         0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
@@ -95,3 +94,14 @@ final class CRC {
         return crc
     }
 }
+
+//MARK: Public interface
+public extension CRC {
+    static func crc32(_ message:Array<UInt8>, seed: UInt32? = nil, reflect : Bool = true) -> UInt32 {
+        return CRC().crc32(message, seed: seed, reflect: reflect)
+    }
+
+    static func crc16(_ message:Array<UInt8>, seed: UInt16? = nil) -> UInt16 {
+        return CRC().crc16(message, seed: seed)
+    }
+}

Sources/CryptoSwift/CSArrayType+Extensions.swift

@@ -24,35 +24,35 @@ public extension CSArrayType where Iterator.Element == UInt8 {
 
 public extension CSArrayType where Iterator.Element == UInt8 {
     public func md5() -> [Iterator.Element] {
-        return Hash.md5(cs_arrayValue()).calculate()
+        return Hash.md5(cs_arrayValue())
     }
     
     public func sha1() -> [Iterator.Element] {
-        return Hash.sha1(cs_arrayValue()).calculate()
+        return Hash.sha1(cs_arrayValue())
     }
     
     public func sha224() -> [Iterator.Element] {
-        return Hash.sha224(cs_arrayValue()).calculate()
+        return Hash.sha224(cs_arrayValue())
     }
     
     public func sha256() -> [Iterator.Element] {
-        return Hash.sha256(cs_arrayValue()).calculate()
+        return Hash.sha256(cs_arrayValue())
     }
     
     public func sha384() -> [Iterator.Element] {
-        return Hash.sha384(cs_arrayValue()).calculate()
+        return Hash.sha384(cs_arrayValue())
     }
     
     public func sha512() -> [Iterator.Element] {
-        return Hash.sha512(cs_arrayValue()).calculate()
+        return Hash.sha512(cs_arrayValue())
     }
     
-    public func crc32(seed: UInt32? = nil, reflect : Bool = true) -> [Iterator.Element] {
-        return Hash.crc32(cs_arrayValue(), seed: seed, reflect: reflect).calculate()
+    public func crc32(seed: UInt32? = nil, reflect : Bool = true) -> UInt32 {
+        return CRC.crc32(cs_arrayValue(), seed: seed, reflect: reflect)
     }
     
-    public func crc16(seed: UInt16? = nil) -> [Iterator.Element] {
-        return Hash.crc16(cs_arrayValue(), seed: seed).calculate()
+    public func crc16(seed: UInt16? = nil) -> UInt16 {
+        return CRC.crc16(cs_arrayValue(), seed: seed)
     }
     
     public func encrypt(cipher: Cipher) throws -> [Iterator.Element] {

Sources/CryptoSwift/Foundation/Data+Extension.swift

@@ -31,43 +31,43 @@ extension Data {
     }
     
     public func md5() -> Data {
-        let result = Hash.md5(self.bytes).calculate()
+        let result = Hash.md5(self.bytes)
         return Data(bytes: result)
     }
 
     public func sha1() -> Data? {
-        let result = Hash.sha1(self.bytes).calculate()
+        let result = Hash.sha1(self.bytes)
         return Data(bytes: result)
     }
 
     public func sha224() -> Data? {
-        let result = Hash.sha224(self.bytes).calculate()
+        let result = Hash.sha224(self.bytes)
         return Data(bytes: result)
     }
 
     public func sha256() -> Data? {
-        let result = Hash.sha256(self.bytes).calculate()
+        let result = Hash.sha256(self.bytes)
         return Data(bytes: result)
     }
 
     public func sha384() -> Data? {
-        let result = Hash.sha384(self.bytes).calculate()
+        let result = Hash.sha384(self.bytes)
         return Data(bytes: result)
     }
 
     public func sha512() -> Data? {
-        let result = Hash.sha512(self.bytes).calculate()
+        let result = Hash.sha512(self.bytes)
         return Data(bytes: result)
     }
 
     public func crc32(seed: UInt32? = nil, reflect : Bool = true) -> Data? {
-        let result = Hash.crc32(self.bytes, seed: seed, reflect: reflect).calculate()
-        return Data(bytes: result)
+        let result = CRC.crc32(self.bytes, seed: seed, reflect: reflect)
+        return Data(bytes: result.bytes())
     }
 
     public func crc16(seed: UInt16? = nil) -> Data? {
-        let result = Hash.crc16(self.bytes, seed: seed).calculate()
-        return Data(bytes: result)
+        let result = CRC.crc16(self.bytes, seed: seed)
+        return Data(bytes: result.bytes())
     }
 
     public func encrypt(cipher: Cipher) throws -> Data {

Sources/CryptoSwift/HMAC.swift

@@ -29,15 +29,15 @@ final public class HMAC {
         func calculateHash(_ bytes:Array<UInt8>) -> Array<UInt8>? {
             switch (self) {
             case .sha1:
-                return Hash.sha1(bytes).calculate()
+                return Hash.sha1(bytes)
             case .sha256:
-                return Hash.sha256(bytes).calculate()
+                return Hash.sha256(bytes)
             case .sha384:
-                return Hash.sha384(bytes).calculate()
+                return Hash.sha384(bytes)
             case .sha512:
-                return Hash.sha512(bytes).calculate()
+                return Hash.sha512(bytes)
             case .md5:
-                return Hash.md5(bytes).calculate()
+                return Hash.md5(bytes)
             }
         }
         

Sources/CryptoSwift/Hash.swift

@@ -1,36 +1,33 @@
 //
-//  CryptoHash.swift
+//  Hash.swift
 //  CryptoSwift
 //
 //  Created by Marcin Krzyzanowski on 07/08/14.
 //  Copyright (c) 2014 Marcin Krzyzanowski. All rights reserved.
 //
 
-public enum Hash {
-    case md5(Array<UInt8>)
-    case sha1(Array<UInt8>)
-    case sha224(Array<UInt8>), sha256(Array<UInt8>), sha384(Array<UInt8>), sha512(Array<UInt8>)
-    case crc32(Array<UInt8>, seed: UInt32?, reflect: Bool)
-    case crc16(Array<UInt8>, seed: UInt16?)
-    
-    public func calculate() -> Array<UInt8> {
-        switch self {
-        case .md5(let bytes):
-            return MD5(bytes).calculate()
-        case .sha1(let bytes):
-            return SHA1(bytes).calculate()
-        case .sha224(let bytes):
-            return SHA2(bytes, variant: .sha224).calculate32()
-        case .sha256(let bytes):
-            return SHA2(bytes, variant: .sha256).calculate32()
-        case .sha384(let bytes):
-            return SHA2(bytes, variant: .sha384).calculate64()
-        case .sha512(let bytes):
-            return SHA2(bytes, variant: .sha512).calculate64()
-        case .crc32(let bytes, let seed, let reflect):
-            return CRC().crc32(bytes, seed: seed, reflect: reflect).bytes()
-        case .crc16(let bytes, let seed):
-            return UInt32(CRC().crc16(bytes, seed: seed)).bytes(totalBytes: 2)
-        }
+public struct Hash {
+    public static func md5(_ bytes: Array<UInt8>) -> Array<UInt8> {
+        return MD5(bytes).calculate()
+    }
+
+    public static func sha1(_ bytes: Array<UInt8>) -> Array<UInt8> {
+        return SHA1(bytes).calculate()
+    }
+
+    public static func sha224(_ bytes: Array<UInt8>) -> Array<UInt8> {
+        return SHA2(bytes, variant: .sha224).calculate32()
+    }
+
+    public static func sha256(_ bytes: Array<UInt8>) -> Array<UInt8> {
+        return SHA2(bytes, variant: .sha256).calculate32()
+    }
+
+    public static func sha384(_ bytes: Array<UInt8>) -> Array<UInt8> {
+        return SHA2(bytes, variant: .sha384).calculate64()
+    }
+
+    public static func sha512(_ bytes: Array<UInt8>) -> Array<UInt8> {
+        return SHA2(bytes, variant: .sha512).calculate64()
     }
 }

Sources/CryptoSwift/PKCS5/PBKDF1.swift

@@ -35,9 +35,9 @@ public extension PKCS5 {
             fileprivate func calculateHash(_ bytes:Array<UInt8>) -> Array<UInt8>? {
                 switch (self) {
                 case .sha1:
-                    return Hash.sha1(bytes).calculate()
+                    return Hash.sha1(bytes)
                 case .md5:
-                    return Hash.md5(bytes).calculate()
+                    return Hash.md5(bytes)
                 }
             }
         }

Sources/CryptoSwift/String+Extension.swift

@@ -34,11 +34,11 @@ extension String {
     }
 
     public func crc32(seed: UInt32? = nil, reflect : Bool = true) -> String {
-        return self.utf8.lazy.map({ $0 as UInt8 }).crc32(seed: seed, reflect: reflect).toHexString()
+        return self.utf8.lazy.map({ $0 as UInt8 }).crc32(seed: seed, reflect: reflect).bytes().toHexString()
     }
 
     public func crc16(seed: UInt16? = nil) -> String {
-        return self.utf8.lazy.map({ $0 as UInt8 }).crc16(seed: seed).toHexString()
+        return self.utf8.lazy.map({ $0 as UInt8 }).crc16(seed: seed).bytes().toHexString()
     }
 
     public func encrypt(cipher: Cipher) throws -> Array<UInt8> {