Formatting changes for consistency. No functional changes.

Author: Bill Abt

Sources/Crypto.swift

@@ -116,9 +116,11 @@ extension String: CryptoDigest {
     /// - Returns: A hex string of the calculated digest
     ///
     public func digest(using algorithm: Digest.Algorithm) -> String {
+		
         // This force unwrap may look scary but for CommonCrypto this cannot fail.
         // The API allows for optionals to support the OpenSSL implementation which can.
 		let result = (Digest(using: algorithm).update(string: self as String)?.final())!
 		return CryptoUtils.hexString(from: result)
+		
     }
 }

Sources/HMAC.swift

@@ -105,6 +105,7 @@ public class HMAC : Updateable {
 					return EVP_sha512()
 				}
 			}
+		
 		#endif
 
         ///
@@ -147,16 +148,21 @@ public class HMAC : Updateable {
 				case .sha512:
 					return Int(SHA512_DIGEST_LENGTH)
 				}
+			
 			#endif
 
         }
     }
 
 	/// Context
 	#if os(OSX)
+	
     	typealias Context = UnsafeMutablePointer<CCHmacContext>
+	
 	#elseif os(Linux)
+	
 		typealias Context = UnsafeMutablePointer<HMAC_CTX>
+	
 	#endif
 
     /// Status of the calculation

Sources/Status.swift

@@ -63,23 +63,23 @@ public enum Status: CCCryptorStatus, ErrorProtocol, CustomStringConvertible {
 
         switch self {
 
-        case success:
+        case .success:
 			return CCCryptorStatus(kCCSuccess)
-        case paramError:
+        case .paramError:
 			return CCCryptorStatus(kCCParamError)
-        case bufferTooSmall:
+        case .bufferTooSmall:
    			return CCCryptorStatus(kCCBufferTooSmall)
-        case memoryFailure:
+        case .memoryFailure:
 			return CCCryptorStatus(kCCMemoryFailure)
-        case alignmentError:
+        case .alignmentError:
    			return CCCryptorStatus(kCCAlignmentError)
-        case decodeError:
+        case .decodeError:
 			return CCCryptorStatus(kCCDecodeError)
-        case unimplemented:
+        case .unimplemented:
 			return CCCryptorStatus(kCCUnimplemented)
-        case overflow:
+        case .overflow:
 			return CCCryptorStatus(kCCOverflow)
-        case rngFailure:
+        case .rngFailure:
 			return CCCryptorStatus(kCCRNGFailure)
         }
     }
@@ -212,14 +212,14 @@ public enum Status: ErrorProtocol, CustomStringConvertible {
 
 //	MARK: Operators
 
-func == (left: Status, right: Status) -> Bool {
+func == (lhs: Status, rhs: Status) -> Bool {
 
-	return left.code == right.code
+	return lhs.code == rhs.code
 }
 
-func != (left: Status, right: Status) -> Bool {
+func != (lhs: Status, rhs: Status) -> Bool {
 
-	return left.code != right.code
+	return lhs.code != rhs.code
 }
 
 #endif

Sources/StreamCryptor.swift

@@ -213,46 +213,46 @@ public class StreamCryptor {
 
 		#if os(OSX)
 
-        /// Advanced Encryption Standard
-		/// - Note: aes and aes128 are equivalent.
-        case aes, aes128, aes192, aes256
-		
-        /// Data Encryption Standard
-        case des
-		
-        /// Triple des
-        case tripleDes
-		
-        /// cast
-        case cast
-		
-        /// rc2
-        case rc2
-		
-        /// blowfish
-        case blowfish
+			/// Advanced Encryption Standard
+			/// - Note: aes and aes128 are equivalent.
+			case aes, aes128, aes192, aes256
+			
+			/// Data Encryption Standard
+			case des
+			
+			/// Triple des
+			case tripleDes
+			
+			/// cast
+			case cast
+			
+			/// rc2
+			case rc2
+			
+			/// blowfish
+			case blowfish
 
 		#elseif os(Linux)
 
-		/// Advanced Encryption Standard
-		/// - Note: aes and aes128 are equivalent.
-		case aes, aes128, aes192, aes256
-		
-		/// Data Encryption Standard
-		case des
-		
-		/// Triple des
-		case tripleDes
-		
-		/// cast
-		case cast
-		
-		/// rc2
-		case rc2
-		
-		/// blowfish
-		case blowfish
-		
+			/// Advanced Encryption Standard
+			/// - Note: aes and aes128 are equivalent.
+			case aes, aes128, aes192, aes256
+			
+			/// Data Encryption Standard
+			case des
+			
+			/// Triple des
+			case tripleDes
+			
+			/// cast
+			case cast
+			
+			/// rc2
+			case rc2
+			
+			/// blowfish
+			case blowfish
+			
 		#endif
 
         /// Blocksize, in bytes, of algorithm.
@@ -312,99 +312,99 @@ public class StreamCryptor {
 
 		#if os(OSX)
 
-        /// Native, CommonCrypto constant for algorithm.
-		func nativeValue() -> CCAlgorithm {
-			
-            switch self {
-				
-			case .aes, .aes128, .aes192, .aes256:
-				return CCAlgorithm(kCCAlgorithmAES)
-				
-            case .des:
-				return CCAlgorithm(kCCAlgorithmDES)
-				
-            case .tripleDes:
-				return CCAlgorithm(kCCAlgorithm3DES)
-				
-            case .cast:
-				return CCAlgorithm(kCCAlgorithmCAST)
-				
-            case .rc2:
-				return CCAlgorithm(kCCAlgorithmRC2)
+			/// Native, CommonCrypto constant for algorithm.
+			func nativeValue() -> CCAlgorithm {
 
-            case .blowfish:
-				return CCAlgorithm(kCCAlgorithmBlowfish)
-            }
-        }
-		
-		#elseif os(Linux)
-		
-		/// Native, OpenSSL function for algorithm.
-		func nativeValue(options: Options) -> UnsafePointer<EVP_CIPHER> {
-			
-			if options == .pkcs7Padding || options == .none {
-			
 				switch self {
 
-				case .aes, .aes128:
-					return EVP_aes_128_cbc()
-		
-				case .aes192:
-					return EVP_aes_192_cbc()
-		
-				case .aes256:
-					return EVP_aes_256_cbc()
+				case .aes, .aes128, .aes192, .aes256:
+					return CCAlgorithm(kCCAlgorithmAES)
 
 				case .des:
-					return EVP_des_cbc()
+					return CCAlgorithm(kCCAlgorithmDES)
 
 				case .tripleDes:
-					return EVP_des_ede3_cbc()
+					return CCAlgorithm(kCCAlgorithm3DES)
 
 				case .cast:
-					return EVP_cast5_cbc()
+					return CCAlgorithm(kCCAlgorithmCAST)
 
 				case .rc2:
-					return EVP_rc2_cbc()
+					return CCAlgorithm(kCCAlgorithmRC2)
 
 				case .blowfish:
-					return EVP_bf_cbc()
+					return CCAlgorithm(kCCAlgorithmBlowfish)
 				}
 			}
 
-			if options == .ecbMode {
-				
-				switch self {
-					
-				case .aes, .aes128:
-					return EVP_aes_128_ecb()
-		
-				case .aes192:
-					return EVP_aes_192_ecb()
+		#elseif os(Linux)
 
-				case .aes256:
-					return EVP_aes_256_ecb()
-					
-				case .des:
-					return EVP_des_ecb()
-					
-				case .tripleDes:
-					return EVP_des_ede3_ecb()
-					
-				case .cast:
-					return EVP_cast5_ecb()
-					
-				case .rc2:
-					return EVP_rc2_ecb()
+			/// Native, OpenSSL function for algorithm.
+			func nativeValue(options: Options) -> UnsafePointer<EVP_CIPHER> {
+				
+				if options == .pkcs7Padding || options == .none {
+				
+					switch self {
+						
+					case .aes, .aes128:
+						return EVP_aes_128_cbc()
+			
+					case .aes192:
+						return EVP_aes_192_cbc()
+			
+					case .aes256:
+						return EVP_aes_256_cbc()
+						
+					case .des:
+						return EVP_des_cbc()
+						
+					case .tripleDes:
+						return EVP_des_ede3_cbc()
+						
+					case .cast:
+						return EVP_cast5_cbc()
+						
+					case .rc2:
+						return EVP_rc2_cbc()
+						
+					case .blowfish:
+						return EVP_bf_cbc()
+					}
+				}
+				
+				if options == .ecbMode {
 
-				case .blowfish:
-					return EVP_bf_ecb()
+					switch self {
+						
+					case .aes, .aes128:
+						return EVP_aes_128_ecb()
+			
+					case .aes192:
+						return EVP_aes_192_ecb()
+			
+					case .aes256:
+						return EVP_aes_256_ecb()
+						
+					case .des:
+						return EVP_des_ecb()
+						
+					case .tripleDes:
+						return EVP_des_ede3_ecb()
+						
+					case .cast:
+						return EVP_cast5_ecb()
+						
+					case .rc2:
+						return EVP_rc2_ecb()
+						
+					case .blowfish:
+						return EVP_bf_ecb()
+					}
 				}
+			
+				fatalError("Unsupported options and/or algorithm.")
 			}
-		
-			fatalError("Unsupported options and/or algorithm.")
-		}
-		
+			
 		#endif
 
 		///