Refactor Rabbit. Throwable inits. Test public methods

CryptoSwiftTests/Access.swift

@@ -159,11 +159,33 @@ class Access: XCTestCase {
     }
 
     func testAES() {
-        // TODO
+        do {
+            let aes = try AES(key: "secret0key000000", iv: "0123456789012345")
+            let _ = aes.makeEncryptor()
+            let _ = aes.makeDecryptor()
+            let enc = try aes.encrypt([1,2,3])
+            let _ = try aes.decrypt(enc)
+            
+            let _ = AES.Variant.aes128
+            let _ = AES.blockSize
+        } catch {
+            XCTFail(error.localizedDescription)
+        }
     }
 
     func testRabbit() {
-        // TODO
+        do {
+            let _ = try Rabbit(key: "123")
+            let rabbit = try Rabbit(key: [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+            let enc = rabbit.encrypt([1,2,3])
+            let _   = rabbit.decrypt(enc)
+
+            let _ = Rabbit.blockSize
+            let _ = Rabbit.keySize
+            let _ = Rabbit.ivSize
+        } catch {
+            XCTFail(error.localizedDescription)
+        }
     }
 
     func testChaCha20() {

CryptoSwiftTests/RabbitTests.swift

@@ -18,23 +18,23 @@ class RabbitTests: XCTestCase {
     override func tearDown() {
         super.tearDown()
     }
-    
+
     func testInitialization() {
         var key = Array<UInt8>(repeating: 0, count: Rabbit.keySize - 1)
         var iv: Array<UInt8>?
-        XCTAssertNil(Rabbit(key: key, iv: iv))
-        
+        XCTAssertThrowsError(try Rabbit(key: key, iv: iv))
+
         key = Array<UInt8>(repeating: 0, count: Rabbit.keySize + 1)
-        XCTAssertNil(Rabbit(key: key, iv: iv))
+        XCTAssertThrowsError(try Rabbit(key: key, iv: iv))
         
         key = Array<UInt8>(repeating: 0, count: Rabbit.keySize)
-        XCTAssertNotNil(Rabbit(key: key, iv: iv))
+        XCTAssertNotNil(try Rabbit(key: key, iv: iv))
         
         iv = Array<UInt8>(repeating: 0, count: Rabbit.ivSize - 1)
-        XCTAssertNil(Rabbit(key: key, iv: iv))
+        XCTAssertThrowsError(try Rabbit(key: key, iv: iv))
         
         iv = Array<UInt8>(repeating: 0, count: Rabbit.ivSize)
-        XCTAssertNotNil(Rabbit(key: key, iv: iv))
+        XCTAssertNotNil(try Rabbit(key: key, iv: iv))
     }
     
     func testRabbitWithoutIV() {
@@ -71,7 +71,7 @@ class RabbitTests: XCTestCase {
         
         let plainText = Array<UInt8>(repeating: 0, count: 48)
         for (key, expectedCipher) in cases {
-            let rabbit = Rabbit(key: key)!
+            let rabbit = try! Rabbit(key: key)
             let cipherText = rabbit.encrypt(plainText)
             XCTAssertEqual(cipherText, expectedCipher)
             XCTAssertEqual(rabbit.decrypt(cipherText), plainText)
@@ -110,7 +110,7 @@ class RabbitTests: XCTestCase {
         
         let plainText = Array<UInt8>(repeating: 0, count: 48)
         for (iv, expectedCipher) in cases {
-            let rabbit = Rabbit(key: key, iv: iv)!
+            let rabbit = try! Rabbit(key: key, iv: iv)
             let cipherText = rabbit.encrypt(plainText)
             XCTAssertEqual(cipherText, expectedCipher)
             XCTAssertEqual(rabbit.decrypt(cipherText), plainText)
@@ -122,9 +122,9 @@ class RabbitTests: XCTestCase {
         let iv: Array<UInt8> = Array<UInt8>(repeating: 0, count: Rabbit.ivSize)
         let message = Array<UInt8>(repeating: 7, count: (1024 * 1024) * 1)
         measureMetrics([XCTPerformanceMetric_WallClockTime], automaticallyStartMeasuring: true, for: { () -> Void in
-            let encrypted = Rabbit(key: key, iv: iv)?.encrypt(message)
+            let encrypted = try! Rabbit(key: key, iv: iv).encrypt(message)
             self.stopMeasuring()
-            XCTAssert(encrypted != nil, "not encrypted")
+            XCTAssert(!encrypted.isEmpty, "not encrypted")
         })
     }
 }

Sources/CryptoSwift/Foundation/Rabbit+Foundation.swift

@@ -9,20 +9,20 @@
 import Foundation
 
 extension Rabbit {
-    convenience public init?(key: String) {
+    convenience public init(key: String) throws {
         guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes else {
-            return nil
+            throw Error.invalidKeyOrInitializationVector
         }
-        self.init(key: kkey)
-        
+        try self.init(key: kkey)
     }
     
-    convenience public init?(key: String, iv: String) {
+    convenience public init(key: String, iv: String) throws {
         guard let kkey = key.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes,
-            let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes
-            else {
-                return nil
+              let iiv = iv.bridge().data(using: String.Encoding.utf8.rawValue, allowLossyConversion: false)?.bytes
+        else {
+            throw Error.invalidKeyOrInitializationVector
         }
-        self.init(key: kkey, iv: iiv)
+
+        try self.init(key: kkey, iv: iiv)
     }
 }

Sources/CryptoSwift/Rabbit.swift

@@ -9,7 +9,11 @@
 private typealias Key = SecureBytes
 
 final public class Rabbit: BlockCipher {
-    
+
+    public enum Error: Swift.Error {
+        case invalidKeyOrInitializationVector
+    }
+
     /// Size of IV in bytes
     public static let ivSize = 64 / 8
     
@@ -47,16 +51,16 @@ final public class Rabbit: BlockCipher {
     ]
     
     // MARK: - Initializers
-    convenience public init?(key:Array<UInt8>) {
-        self.init(key: key, iv: nil)
+    convenience public init(key:Array<UInt8>) throws {
+        try self.init(key: key, iv: nil)
     }
     
-    public init?(key:Array<UInt8>, iv:Array<UInt8>?) {
+    public init(key:Array<UInt8>, iv:Array<UInt8>?) throws {
         self.key = Key(bytes: key)
         self.iv = iv
         
         guard key.count == Rabbit.keySize && (iv == nil || iv!.count == Rabbit.ivSize) else {
-            return nil
+            throw Error.invalidKeyOrInitializationVector
         }
     }