CryptorModule

Sources/PubNub/Errors/ErrorDescription.swift

@@ -294,11 +294,11 @@ extension PubNubError.Reason: CustomStringConvertible, LocalizedError {
       return "The Content-Length was incorrect for the content being uploaded"
     case .serviceNotEnabled:
       return "The PubNub Service that you're attempting to use has not be enabled for your keyset."
-    case .encryptionError:
+    case .encryptionFailure:
       return "Failure to perform encryption"
-    case .decryptionError:
+    case .decryptionFailure:
       return "Failure to perform decryption"
-    case .unknownCryptorError:
+    case .unknownCryptorFailure:
       return "Unknown Cryptor error"
     }
   }

Sources/PubNub/Errors/PubNubError.swift

@@ -105,9 +105,9 @@ public struct PubNubError: Error {
 
     // Crypto
     case missingCryptoKey
-    case encryptionError
-    case decryptionError
-    case unknownCryptorError
+    case encryptionFailure
+    case decryptionFailure
+    case unknownCryptorFailure
 
     // Request Processing
     case requestMutatorFailure
@@ -235,7 +235,7 @@ public struct PubNubError: Error {
         return .streamFailure
       case .fileTooLarge, .fileMissingAtPath, .fileAccessDenied, .fileContentLength:
         return .fileManagement
-      case .encryptionError, .decryptionError, .unknownCryptorError:
+      case .encryptionFailure, .decryptionFailure, .unknownCryptorFailure:
         return .crypto
       }
     }

Sources/PubNub/Extensions/URLRequest+PubNub.swift

@@ -76,8 +76,8 @@ public extension URLRequest {
     if let cryptorModule = cryptorModule {
       switch cryptorModule.encrypt(stream: contentStream, contentLength: content.contentLength) {
       case .success(let encryptingResult):
-        finalStream = encryptingResult.stream
-        contentLength = prefixData.count + encryptingResult.contentLength + postfixData.count
+        finalStream = encryptingResult
+        contentLength = prefixData.count + encryptingResult.length + postfixData.count
       case .failure(let encryptionError):
         throw encryptionError
       }      

Sources/PubNub/Helpers/Crypto/CryptoError.swift

@@ -28,6 +28,54 @@
 import CommonCrypto
 import Foundation
 
+/// Object capable of encryption/decryption
+///
+/// - Warning: This struct is deprecated. Use ``CryptorModule`` instead.
+public struct Crypto: Hashable {
+  /// The key used when encrypting/decrypting
+  public let key: Data
+  /// The String Encoding strategy to be used by default
+  public let defaultStringEncoding: String.Encoding
+  /// Whether random initialization vector should be used
+  public let randomizeIV: Bool
+
+  // Keeps originally provided input by the user
+  internal let keyString: String
+
+  public init?(key: String, withRandomIV: Bool = true, encoding: String.Encoding = .utf8) {
+    guard let data = key.data(using: encoding), let keyData = SHA256.hash(data: data) else {
+      PubNub.log.error("Crypto failed to `init` while converting `String` key to `Data`"); return nil
+    }
+
+    let keySize = keyData.count
+    let keySizeRange = (kCCKeySizeAES128 ... kCCKeySizeAES256)
+
+    if keySizeRange.contains(keyData.count) {
+      PubNub.log.error("Key size not valid for algorithm: \(keySize) not in \(keySizeRange)")
+    }
+
+    self.key = keyData
+    self.keyString = key
+    self.defaultStringEncoding = encoding
+    self.randomizeIV = withRandomIV
+  }
+
+  enum SHA256 {
+    static func hash(data: Data) -> Data? {
+      var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+      data.withUnsafeBytes {
+        _ = CC_SHA256($0.baseAddress, CC_LONG(data.count), &hash)
+      }
+      return hexFrom(Data(hash)).lowercased(with: .current).data(using: .utf8)
+    }
+
+    static func hexFrom(_ data: Data) -> String {
+      let midpoint = data.count / 2
+      return data[..<midpoint].map { String(format: "%02lX", UInt($0)) }.joined()
+    }
+  }
+}
+
 /// An Error returned from a `Crypto` function
 public enum CryptoError: CCCryptorStatus, Error, LocalizedError {
   /// Insufficent buffer provided for specified operation.