How to use CC_MD5 method in swift language

Question

in Objective-C, we can hash a string like this:

const char *cStr = [someString UTF8String];
unsigned char result[16];
CC_MD5( cStr, strlen(cStr), result );
md5String = [NSString stringWithFormat:
        @"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
        result[0], result[1], result[2], result[3],
        result[4], result[5], result[6], result[7],
        result[8], result[9], result[10], result[11],
        result[12], result[13], result[14], result[15]
        ];

But CC_MD5 doesn't work in Swift. How do we deal with this?

Answer 1

This is what I came up with. It's an extension to String. Don't forget to add #import <CommonCrypto/CommonCrypto.h> to the ObjC-Swift bridging header that Xcode creates.

extension String  {
    var md5: String! {
        let str = self.cStringUsingEncoding(NSUTF8StringEncoding)
        let strLen = CC_LONG(self.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
        let digestLen = Int(CC_MD5_DIGEST_LENGTH)
        let result = UnsafeMutablePointer<CUnsignedChar>.alloc(digestLen)

        CC_MD5(str!, strLen, result)

        let hash = NSMutableString()
        for i in 0..<digestLen {
            hash.appendFormat("%02x", result[i])
        }

        result.dealloc(digestLen)

        return String(format: hash as String)
    }
 }

Answer 2

Here's my version in Swift 3.0, I believe it to be safer and faster than the other answers here.

A bridging header with #import <CommonCrypto/CommonCrypto.h> is required.

func MD5(_ string: String) -> String? {
    let length = Int(CC_MD5_DIGEST_LENGTH)
    var digest = [UInt8](repeating: 0, count: length)

    if let d = string.data(using: String.Encoding.utf8) {
        _ = d.withUnsafeBytes { (body: UnsafePointer<UInt8>) in
            CC_MD5(body, CC_LONG(d.count), &digest)
        }
    }

    return (0..<length).reduce("") {
        $0 + String(format: "%02x", digest[$1])
    }
}

Answer 3

I did pure Swift implementation of MD5 as part of CryptoSwift project.

I could copy code here but it uses extensions that are part of this project so it may be useless for copy&paste usage. However you can take a look there and use it.

Answer 4

So here is the Solution and I know It will save your time 100%

BridgingHeader - > Used to Expose Objective-c code to a Swift Project

CommonCrypto - > is the file needed to use md5 hash

Since Common Crypto is a Objective-c file, you need to use BridgingHeader to use method needed for hashing

---

(e.g)

extension String {
func md5() -> String! {
    let str = self.cStringUsingEncoding(NSUTF8StringEncoding)
    let strLen = CUnsignedInt(self.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
    let digestLen = Int(CC_MD5_DIGEST_LENGTH)
    let result = UnsafeMutablePointer<CUnsignedChar>.alloc(digestLen)
    CC_MD5(str!, strLen, result)
    var hash = NSMutableString()
    for i in 0..<digestLen {
        hash.appendFormat("%02x", result[i])
    }
    result.destroy()
    return String(format: hash as String)
}

}

How to add Common Crypto into a Swift Project??

This link will teach you how (STEP by STEP).

I recommend using Bridging Header

*************Updated Swift 3****************

extension String {
func toMD5()  -> String {

        if let messageData = self.data(using:String.Encoding.utf8) {
            var digestData = Data(count: Int(CC_MD5_DIGEST_LENGTH))

            _ = digestData.withUnsafeMutableBytes {digestBytes in
                messageData.withUnsafeBytes {messageBytes in
                    CC_MD5(messageBytes, CC_LONG((messageData.count)), digestBytes)
                }
            }
            return digestData.hexString()
        }

        return self
    }
}


extension Data {

    func hexString() -> String {
        let string = self.map{ String($0, radix:16) }.joined()
        return string
    }

}

How to use?

let stringConvertedToMD5 = "foo".toMD5()

Answer 5

evntually if you want calculate MD5 out of NSData, take a look at this:

func md5() -> NSData {
    var ctx = UnsafePointer<CC_MD5_CTX>.alloc(sizeof(CC_MD5_CTX))
    CC_MD5_Init(ctx);

    CC_MD5_Update(ctx, self.bytes, UInt32(self.length));
    let length = Int(CC_MD5_DIGEST_LENGTH) * sizeof(Byte)
    var output = UnsafePointer<Byte>.alloc(length)
    CC_MD5_Final(output, ctx);

    let outData = NSData(bytes: output, length: Int(CC_MD5_DIGEST_LENGTH))
    output.destroy()
    ctx.destroy()

    //withUnsafePointer
    return outData;
}

to get idea.

Answer 6

Xcode 6 beta 5 now uses an UnsafeMutablePointer in place of an UnsafePointer. String conversion also requires the format: argument label.

extension String {
    func md5() -> String! {
        let str = self.cStringUsingEncoding(NSUTF8StringEncoding)
        let strLen = CUnsignedInt(self.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))
        let digestLen = Int(CC_MD5_DIGEST_LENGTH)
        let result = UnsafeMutablePointer<CUnsignedChar>.alloc(digestLen)
        CC_MD5(str!, strLen, result)
        var hash = NSMutableString()
        for i in 0..<digestLen {
            hash.appendFormat("%02x", result[i])
        }
        result.destroy()
        return String(format: hash)
    }
}

Answer 7

Need import #import <CommonCrypto/CommonCrypto.h> into Bridging Header

I am calculating MD5 hash, but using only the first 16 byte I am using

class func hash(data: NSData) -> String {

    let data2 = NSMutableData(length: Int(CC_MD5_DIGEST_LENGTH))!
    CC_MD5(data.bytes, CC_LONG(data.length), UnsafeMutablePointer<UInt8>(data2.mutableBytes))
    let data3 =  UnsafePointer<CUnsignedChar>(data2.bytes)

    var hash = ""
    for (var i = 0; i < 16; ++i) {

        hash +=  String(format: "%02X", data3[i])
    }

    return hash
}

Answer 8

For cases where a bridging header isn't an option (eg, in a shell script), you can use the command line tool /sbin/md5 via NSTask:

import Foundation

func md5hash(string: String) -> String
{
  let t = NSTask()
  t.launchPath = "/sbin/md5"
  t.arguments = ["-q", "-s", string]
  t.standardOutput = NSPipe()

  t.launch()

  let outData = t.standardOutput.fileHandleForReading.readDataToEndOfFile()
  var outBytes = [UInt8](count:outData.length, repeatedValue:0)
  outData.getBytes(&outBytes, length: outData.length)

  var outString = String(bytes: outBytes, encoding: NSASCIIStringEncoding)

  assert(outString != nil, "failed to md5 input string")

  return outString!.stringByTrimmingCharactersInSet(NSCharacterSet.newlineCharacterSet())
}

Usage:

let md5 = md5hash("hello world")

// 5eb63bbbe01eeed093cb22bb8f5acdc3

Answer 9

Here are some changes I had to make to this code to get it working in Swift 5:

func md5(inString: String) -> String! {
    let str = inString.cString(using: String.Encoding.utf8)
    let strLen = CUnsignedInt(inString.lengthOfBytes(using: String.Encoding.utf8))
    let digestLen = Int(CC_MD5_DIGEST_LENGTH)
    let result = UnsafeMutablePointer<CUnsignedChar>.allocate(capacity: digestLen)
    CC_MD5(str!, strLen, result)
    var hash = NSMutableString()
    for i in 0..<digestLen {
        hash.appendFormat("%02x", result[i])
    }
    result.deallocate()
    return String(format: hash as String)
}

Answer 10

Updated for contemporary Swift syntax (Swift 5.6 at the time of writing):

• StringProtocol extension (so can be used on strings or substrings).
• Allow caller to specify encoding, but default to UTF8.
• Move actual MD5/SHA256 calculation into Data extension.
• Use UnsafeRawBufferPointer rendition (rather than deprecated UnsafePointer rendition) of withUnsafeBytes and withMutableUnsafeBytes.
• Add @availability warning for md5 that Apple has added to CC_MD5, to make sure that developers understand that this is not cryptographically sound.

Thus:

extension StringProtocol {
    @available(iOS, deprecated: 13.0, message: "This function is cryptographically broken and should not be used in security contexts. Clients should migrate to SHA256 (or stronger).")
    func md5String(encoding: String.Encoding = .utf8) -> String? {
        data(using: encoding)?.md5.hexadecimal
    }

    @available(iOS, deprecated: 13.0, message: "This function is cryptographically broken and should not be used in security contexts. Clients should migrate to SHA256 (or stronger).")
    func md5(encoding: String.Encoding = .utf8) -> Data? {
        data(using: encoding)?.md5
    }

    func sha256String(encoding: String.Encoding = .utf8) -> String? {
        data(using: encoding)?.sha256.hexadecimal
    }

    func sha256(encoding: String.Encoding = .utf8) -> Data? {
        data(using: encoding)?.sha256
    }
}

extension Data {
    var hexadecimal: String {
        map { String(format: "%02x", $0) }
            .joined()
    }

    @available(iOS, deprecated: 13.0, message: "This function is cryptographically broken and should not be used in security contexts. Clients should migrate to SHA256 (or stronger).")
    var md5: Data {
        withUnsafeBytes { dataBuffer in
            var digest = Data(count: Int(CC_MD5_DIGEST_LENGTH))
            digest.withUnsafeMutableBytes { digestBuffer in
                _ = CC_MD5(dataBuffer.baseAddress, CC_LONG(dataBuffer.count), digestBuffer.baseAddress)
            }
            return digest
        }
    }

    var sha256: Data {
        withUnsafeBytes { dataBuffer in
            var digest = Data(count: Int(CC_SHA256_DIGEST_LENGTH))
            digest.withUnsafeMutableBytes { digestBuffer in
                _ = CC_SHA256(dataBuffer.baseAddress, CC_LONG(dataBuffer.count), digestBuffer.baseAddress)
            }
            return digest
        }
    }
}

Used as follows:

let string = "Hello, World"

guard let result1 = string.md5String() else { return }
// 82bb413746aee42f89dea2b59614f9ef

guard let result2 = string.sha256String() else { return }
// 03675ac53ff9cd1535ccc7dfcdfa2c458c5218371f418dc136f2d19ac1fbe8a5