[SWIFT]AES 128/192/256::iv 암호화 MD5/SHA/CRC

Key 길이에 따라 암호화 종류가 결정된다. AES256 사용하고 싶다면 Key의 길이가 32bytes 사용.

- 16 bytes (AES-128)

- 24 bytes (AES-192)

- 32 bytes (AES-256)

import UIKit
import CryptoSwift

/// Pod : https://github.com/krzyzanowskim/CryptoSwift

public struct Random {
    #if os(Linux)
    static var initialized = false
    #endif
    
    public static func generate(_ upperBound: Int) -> Int {
        #if os(Linux)
        if !Random.initialized {
            srandom(UInt32(time(nil)))
            Random.initialized = true
        }
        return Int(random() % upperBound)
        #else
        return Int(arc4random_uniform(UInt32(upperBound)))
        #endif
    }
}

class APICrypt {
    
    public class func randomText(_ length: Int, justLowerCase: Bool = false, whitespace: Bool = false) -> String {
        var chars = [UInt8]()
        
        while chars.count < length {
            let char = CharType.random(justLowerCase, whitespace).randomCharacter()
            if char == 32 && (chars.last ?? 0) == char {
                // do not allow two consecutive spaces
                continue
            }
            chars.append(char)
        }
        return String(bytes: chars, encoding: .ascii)!
    }
    
    
    fileprivate enum CharType: Int {
        case LowerCase, UpperCase, Digit, Space
        
        func randomCharacter() -> UInt8 {
            switch self {
            case .LowerCase:
                return UInt8(Random.generate(26)) + 97
            case .UpperCase:
                return UInt8(Random.generate(26)) + 65
            case .Digit:
                return UInt8(Random.generate(10)) + 48
            case .Space:
                return 32
            }
        }
        
        static func random(_ justLowerCase: Bool, _ allowWhitespace: Bool) -> CharType {
            if justLowerCase {
                return .LowerCase
            } else {
                return CharType(rawValue: Int(Random.generate(allowWhitespace ? 4 : 3)))!
            }
        }
    }
    
    
    // API String Data AES256 Random iv Encode (AES256::iv)
    static func apiStringToBase64Encode(apiKey: String, stringValue: String) -> String {
        
        let iv = randomText(16)
        
        guard let encryptString = AES256Encrypt(value: stringValue, key: apiKey, iv: iv) else {
            return ""
        }
        
        let encodeData = "\(encryptString)::\(iv)".toBase64URL()
        
        return encodeData
    }
    
    // API String Data AES256 Random iv Decode (AES256::iv)
    static func apiStringToBase64Decode(apiKey: String, stringValue: String) -> String {
        
        
        guard let value = stringValue.fromBase64URL() else {
            return ""
        }
        
        let encryptArray = value.arrayBySplit(splitter: "::")
        
        guard let decryptString = AES256Decrypt(value: encryptArray[0], key: apiKey, iv: encryptArray[1]) else {
            return ""
        }
        
        return decryptString
    }
    
    static private func AES256Encrypt(value: String, key: String, iv: String) -> String? {
        
        do {
            //            let encryptString = AES256CBC.encryptString(stringValue, password: API.apiKey, iv: iv)
            
            let aes = try AES(key: key, iv: iv)//, padding: .pkcs7)
            
            let data = Array(value.utf8)
            
            let ciphertext = try aes.encrypt(data)
            
            guard let encryptText = ciphertext.toBase64() else {
                return nil
            }
            
            //            log(direction: .ETC, ofType: self, datas: ciphertext)
            return encryptText
        } catch {
            return nil
        }
    }
    
    static private func AES256Decrypt(value: String, key: String, iv: String) -> String? {
        
        do {
            
            // let aes256cbc = AES256CBC.decryptString(value, password: key, iv: iv)
            
            let aes = try AES(key: key, iv: iv)
            guard let data = Data(base64Encoded: value)?.bytes else {
                return nil
            }
            
            let ciphertext = try aes.decrypt(data)
            //            log(direction: .ETC, ofType: self, datas: ciphertext)
            return String(bytes: ciphertext, encoding: .utf8)
        }catch {
            return nil
        }
    }
}

 

Encrypt 

static func generateEncryptData(_ params: Dictionary<String, Any>?) -> Data? {
        
        let parameters = NSMutableDictionary()
        //        parameters["test_mode"] = API_MODE
        parameters["user_key"] = UserData.userKey.isEmpty == true ? "0" : UserData.userKey
        parameters["version"] = appVersion() ?? "1.0.0"
        parameters["platform"] = "I"
        parameters["store_type"] = STORE_TYPE
        parameters["lang_cd"] = UserData.deviceLocale.settingLanguageCode
        parameters["country_cd"] = UserData.deviceLocale.deviceRegionCode
        parameters["timestamp"] = Int(GlobalInterface.getTimeStamp())
        
        if let p = params {
            parameters.addEntries(from: p)
        }
        
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted)
            // here "jsonData" is the dictionary encoded in JSON data
            guard let jsonString = String(data: jsonData, encoding: .utf8) else {
                return nil
            }
            
            let encrypt_str = APICrypt.apiStringToBase64Encode(apiKey: API.apiKey, stringValue: jsonString)
            let params = "params=\(encrypt_str)"
            
            log(direction: .SEND, ofType: self, datas: "API Params : \(jsonString)", "API Params Encrypt : \(params)")
            
            return params.data(using: .utf8)
            
        } catch let error {
            log(direction: .ERROR, ofType: self, datas: error)
        }
        
        return nil
    }
    
    static func generateEncryptDic(_ params: Dictionary<String, Any>?) -> Dictionary<String, String>? {
        
        let parameters = NSMutableDictionary()
        //        parameters["test_mode"] = API_MODE
        parameters["user_key"] = UserData.userKey.isEmpty == true ? "0" : UserData.userKey
        parameters["version"] = appVersion() ?? "1.0.0"
        parameters["platform"] = "I"
        parameters["store_type"] = STORE_TYPE
        parameters["lang_cd"] = UserData.deviceLocale.settingLanguageCode
        parameters["country_cd"] = UserData.deviceLocale.deviceRegionCode
        parameters["timestamp"] = Int(GlobalInterface.getTimeStamp())
        
        if let p = params {
            parameters.addEntries(from: p)
        }
        
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: parameters, options: .prettyPrinted)
            // here "jsonData" is the dictionary encoded in JSON data
            guard let jsonString = String(data: jsonData, encoding: .utf8) else {
                return nil
            }
            
            let encrypt_str = APICrypt.apiStringToBase64Encode(apiKey: API.apiKey, stringValue: jsonString)
            //            let params = "params=\(encrypt_str)"
            let params = ["params":"\(encrypt_str)"]
            
            //            log(direction: .SEND, ofType: self, datas: "API Params : \(jsonString)", "API Params Encrypt : \(params)")
            
            return params//params.data(using: .utf8)
            
        } catch let error {
            log(direction: .ERROR, ofType: self, datas: error)
        }
        
        return nil
    }

Decrypt

let tokenkey = APICrypt.apiStringToBase64Decode(apiKey: API.apiKey, stringValue: token)

 

MD5 / SHA / CRC

let clearString = "clearData0123456"
let clearData   = clearString.data(using:.utf8)!

///////////////////////
//MD5 해시
clearString.md5()
clearData.md5()

///////////////////////
//SHA 해시
// String -> Hash String
clearString.sha1()
clearString.sha224()
clearString.sha256()
clearString.sha384()
clearString.sha512()

// Data -> Hash Data
clearData.sha1()
clearData.sha224()
clearData.sha256()
clearData.sha384()
clearData.sha512()

///////////////////////
//CRC 
// String -> CRC String
clearString.crc16()
clearString.crc32()
clearString.crc32c()
        
// Data -> CRC Data
clearData.crc16()
clearData.crc32()
clearData.crc32c()