Swift – Hash string with SHA512 in Swift

encoding, hash, sha512, swift

Anyone knows how to reproduce PHP hashing method hash(‘SHA512’, $value, true) in swift ? I tried to use CommonCrypto C library with this code :

extension String {    func digest(length:Int32, gen:(data: UnsafePointer<Void>, len: CC_LONG, md: UnsafeMutablePointer<UInt8>) -> UnsafeMutablePointer<UInt8>) -> String {        var cStr = [UInt8](self.utf8)        var result = [UInt8](count:Int(length), repeatedValue:0)        gen(data: &cStr, len: CC_LONG(cStr.count), md: &result)        let output = NSMutableString(capacity:Int(length))        for r in result {            output.appendFormat("%02x", r)        }        return String(output)    }}

and used it like this :

var digest = salted.digest(CC_SHA512_DIGEST_LENGTH, gen: {(data, len, md) in CC_SHA512(data,len,md)})

But I don't get the right output

EDIT :

I have some PHP code :

echo base64_encode(hash('sha512', '8yOrBmkd', true)); // output: rlltLWeWaQCrfNTYMa0CcIs0mfLoHGAynrd+d8H65+rGAzHS/BSWsumwSmcxF9aAG9TIzXx+HOjArPyLL3herg==

And I want my swift code to output the same. The Base64 encoding is ok :

let utf8str = input.dataUsingEncoding(NSUTF8StringEncoding)!.base64EncodedStringWithOptions(NSDataBase64EncodingOptions(rawValue: 0))                let base64Encoded = utf8str!.base64EncodedStringWithOptions(NSDataBase64EncodingOptions(rawValue: 0))                print("Encoded:  \(base64Encoded)")

But the hashing part return an output the same value as this PHP code :

echo base64_encode(hash('sha512', '8yOrBmkd', false)); // output: YWU1OTZkMmQ2Nzk2NjkwMGFiN2NkNGQ4MzFhZDAyNzA4YjM0OTlmMmU4MWM2MDMyOWViNzdlNzdjMWZhZTdlYWM2MDMzMWQyZmMxNDk2YjJlOWIwNGE2NzMxMTdkNjgwMWJkNGM4Y2Q3YzdlMWNlOGMwYWNmYzhiMmY3ODVlYWU=

Best Solution

Swift 3 implementatiomn at bottom.

The code does not need to be so complex or an extension:

func sha512Hex(string string: String) -> String {    var digest = [UInt8](count: Int(CC_SHA512_DIGEST_LENGTH), repeatedValue: 0)    if let data = string.dataUsingEncoding(NSUTF8StringEncoding) {        CC_SHA512(data.bytes, CC_LONG(data.length), &digest)    }    var digestHex = ""    for index in 0..<Int(CC_SHA512_DIGEST_LENGTH) {        digestHex += String(format: "%02x", digest[index])    }    return digestHex}

//Test:

let hexDigest = sha512Hex(string:"8yOrBmkd")print("hexDigest:\n\(hexDigest)")

Output:

hexDigest: ae596d2d67966900ab7cd4d831ad02708b3499f2e81c60329eb77e77c1fae7eac60331d2fc1496b2e9b04a673117d6801bd4c8cd7c7e1ce8c0acfc8b2f785eae

Just returing the byte array:

func sha512(string string: String) -> [UInt8] {    var digest = [UInt8](count: Int(CC_SHA512_DIGEST_LENGTH), repeatedValue: 0)    let data = string.dataUsingEncoding(NSUTF8StringEncoding)!    CC_SHA512(data.bytes, CC_LONG(data.length), &digest)    return digest}

//Test:

let digestRaw = sha512(string:"8yOrBmkd")print("decimal array:\n\(digestRaw)")print("hexadecimal:\n\(NSData(bytes:digestRaw, length:digestRaw.count).description)")

Output:

decimal array: [174, 89, 109, 45, 103, 150, 105, 0, 171, 124, 212, 216, 49, 173, 2, 112, 139, 52, 153, 242, 232, 28, 96, 50, 158, 183, 126, 119, 193, 250, 231, 234, 198, 3, 49, 210, 252, 20, 150, 178, 233, 176, 74, 103, 49, 23, 214, 128, 27, 212, 200, 205, 124, 126, 28, 232, 192, 172, 252, 139, 47, 120, 94, 174]

hexadecimal:
ae596d2d67966900ab7cd4d831ad02708b3499f2e81c60329eb77e77c1fae7eac60331d2fc1496b2e9b04a673117d6801bd4c8cd7c7e1ce8c0acfc8b2f785eae

Base64 output:

func sha512Base64(string string: String) -> String {    let digest = NSMutableData(length: Int(CC_SHA512_DIGEST_LENGTH))!    if let data = string.dataUsingEncoding(NSUTF8StringEncoding) {        CC_SHA512(data.bytes, CC_LONG(data.length), UnsafeMutablePointer<UInt8>(digest.mutableBytes))    }    return digest.base64EncodedStringWithOptions(NSDataBase64EncodingOptions([]))}

//Test:

let digestBase64 = sha512Base64(string:"8yOrBmkd")print("Base64:\n\(digestBase64)")

Output:

Base64:rlltLWeWaQCrfNTYMa0CcIs0mfLoHGAynrd+d8H65+rGAzHS/BSWsumwSmcxF9aAG9TIzXx+HOjArPyLL3herg==

Swift 3

func hashSHA512(data:Data) -> String? {    var hashData = Data(count: Int(CC_SHA512_DIGEST_LENGTH))    _ = hashData.withUnsafeMutableBytes {digestBytes in        data.withUnsafeBytes {messageBytes in            CC_SHA512(messageBytes, CC_LONG(data.count), digestBytes)        }    }    // For hexadecimal output:    return hashData.map { String(format: "%02hhx", $0) }.joined()    // For Base64 output use this instead of the above:    // return data.base64EncodedString()}

Swift – Hash string with SHA512 in Swift

HMAC with MD5, SHA1, SHA224, SHA256, SHA384, SHA512 (Swift 3+)

These functions will hash either String or Data input with one of eight cryptographic hash algorithms.

The name parameter specifies the hash function name as a StringSupported functions are MD5, SHA1, SHA224, SHA256, SHA384 and SHA512

This example requires Common Crypto
It is necessary to have a bridging header to the project:
#import <CommonCrypto/CommonCrypto.h>
Add the Security.framework to the project.

These functions takes a hash name, message to be hashed, a key and return a digest:


hashName: name of a hash function as String  message:  message as Data  key:      key as Data  returns:  digest as Data  
func hmac(hashName:String, message:Data, key:Data) -> Data? {    let algos = ["SHA1":   (kCCHmacAlgSHA1,   CC_SHA1_DIGEST_LENGTH),                 "MD5":    (kCCHmacAlgMD5,    CC_MD5_DIGEST_LENGTH),                 "SHA224": (kCCHmacAlgSHA224, CC_SHA224_DIGEST_LENGTH),                 "SHA256": (kCCHmacAlgSHA256, CC_SHA256_DIGEST_LENGTH),                 "SHA384": (kCCHmacAlgSHA384, CC_SHA384_DIGEST_LENGTH),                 "SHA512": (kCCHmacAlgSHA512, CC_SHA512_DIGEST_LENGTH)]    guard let (hashAlgorithm, length) = algos[hashName]  else { return nil }    var macData = Data(count: Int(length))    macData.withUnsafeMutableBytes {macBytes in        message.withUnsafeBytes {messageBytes in            key.withUnsafeBytes {keyBytes in                CCHmac(CCHmacAlgorithm(hashAlgorithm),                       keyBytes,     key.count,                       messageBytes, message.count,                       macBytes)            }        }    }    return macData

}

hashName: name of a hash function as Stringmessage:  message as Stringkey:      key as Stringreturns:  digest as Data
func hmac(hashName:String, message:String, key:String) -> Data? {    let messageData = message.data(using:.utf8)!    let keyData = key.data(using:.utf8)!    return hmac(hashName:hashName, message:messageData, key:keyData)}

hashName: name of a hash function as String  message:  message as String  key:      key as Data  returns:  digest as Data  
func hmac(hashName:String, message:String, key:Data) -> Data? {    let messageData = message.data(using:.utf8)!    return hmac(hashName:hashName, message:messageData, key:key)}

// Examples

let clearString = "clearData0123456"let keyString   = "keyData8901234562"let clearData   = clearString.data(using:.utf8)!let keyData     = keyString.data(using:.utf8)!print("clearString: \(clearString)")print("keyString:   \(keyString)")print("clearData: \(clearData as NSData)")print("keyData:   \(keyData as NSData)")let hmacData1 = hmac(hashName:"SHA1", message:clearData, key:keyData)print("hmacData1: \(hmacData1! as NSData)")let hmacData2 = hmac(hashName:"SHA1", message:clearString, key:keyString)print("hmacData2: \(hmacData2! as NSData)")let hmacData3 = hmac(hashName:"SHA1", message:clearString, key:keyData)print("hmacData3: \(hmacData3! as NSData)")

Output:

clearString: clearData0123456keyString:   keyData8901234562clearData: <636c6561 72446174 61303132 33343536>keyData:   <6b657944 61746138 39303132 33343536 32>hmacData1: <bb358f41 79b68c08 8e93191a da7dabbc 138f2ae6>hmacData2: <bb358f41 79b68c08 8e93191a da7dabbc 138f2ae6>hmacData3: <bb358f41 79b68c08 8e93191a da7dabbc 138f2ae6>

MD2, MD4, MD5, SHA1, SHA224, SHA256, SHA384, SHA512 (Swift 3+)

These functions will hash either String or Data input with one of eight cryptographic hash algorithms.

The name parameter specifies the hash function name as a String
Supported functions are MD2, MD4, MD5, SHA1, SHA224, SHA256, SHA384 and SHA512aThis example requires Common Crypto
It is necessary to have a bridging header to the project:
#import <CommonCrypto/CommonCrypto.h>
Add the Security.framework to the project.



This function takes a hash name and String to be hashed and returns a Data:

name: A name of a hash function as a String  string: The String to be hashed  returns: the hashed result as Data  
func hash(name:String, string:String) -> Data? {    let data = string.data(using:.utf8)!    return hash(name:name, data:data)}

Examples:

let clearString = "clearData0123456"let clearData   = clearString.data(using:.utf8)!print("clearString: \(clearString)")print("clearData: \(clearData as NSData)")let hashSHA256 = hash(name:"SHA256", string:clearString)print("hashSHA256: \(hashSHA256! as NSData)")let hashMD5 = hash(name:"MD5", data:clearData)print("hashMD5: \(hashMD5! as NSData)")

Output:

clearString: clearData0123456clearData: <636c6561 72446174 61303132 33343536>hashSHA256: <aabc766b 6b357564 e41f4f91 2d494bcc bfa16924 b574abbd ba9e3e9d a0c8920a>hashMD5: <4df665f7 b94aea69 695b0e7b baf9e9d6>