SWIFT 3 version de md5 function :

func md5(_ string: String) -> String {

    let context = UnsafeMutablePointer<CC_MD5_CTX>.allocate(capacity: 1)
    var digest = Array<UInt8>(repeating:0, count:Int(CC_MD5_DIGEST_LENGTH))
    CC_MD5_Init(context)
    CC_MD5_Update(context, string, CC_LONG(string.lengthOfBytes(using: String.Encoding.utf8)))
    CC_MD5_Final(&digest, context)
    context.deallocate(capacity: 1)
    var hexString = ""
    for byte in digest {
        hexString += String(format:"%02x", byte)
    }

    return hexString
}

lien Original de http://iosdeveloperzone.com

j'ai publié un pure Swift implementation qui ne dépend pas de CommonCrypto ou autre chose. C'est disponible sous licence MIT.

le code se compose d'un fichier swift simple que vous pouvez simplement déposer dans votre projet. Si vous préférez, vous pouvez également utiliser le projet Xcode contenu avec le cadre et les cibles de test de l'unité.

c'est simple à utiliser:

let input = "The quick brown fox jumps over the lazy dog"
let digest = input.utf8.md5
print("md5: \(digest)")

: md5: 9e107d9d372bb6826bd81d3542a419d6

le fichier swift contient de la documentation et d'autres exemples.

juste deux notes ici:

utiliser Crypto est trop de frais généraux pour atteindre précisément cela.

Le accepté de répondre est parfait! Néanmoins, je voulais juste partager une approche Swift ier code utilisant Swift 2.2 .

s'il vous plaît gardez à l'esprit que vous avez encore à #import <CommonCrypto/CommonCrypto.h> dans votre de Transition-en-Tête fichier

struct MD5Digester {
    // return MD5 digest of string provided
    static func digest(string: String) -> String? {

        guard let data = string.dataUsingEncoding(NSUTF8StringEncoding) else { return nil }

        var digest = [UInt8](count: Int(CC_MD5_DIGEST_LENGTH), repeatedValue: 0)

        CC_MD5(data.bytes, CC_LONG(data.length), &digest)

        return (0..<Int(CC_MD5_DIGEST_LENGTH)).reduce("") { "151900920" + String(format: "%02x", digest[]) }
    }
}

voici une extension basée sur la réponse de zaph

extension String{
    var MD5:String {
        get{
            let messageData = self.data(using:.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.map { String(format: "%02hhx", "151900920") }.joined()
        }
    }
}

entièrement compatible avec swift 3.0.vous avez encore à #import <CommonCrypto/CommonCrypto.h> dans votre fichier D'en-tête de Pont

après avoir lu les autres réponses ici (et avoir besoin de supporter d'autres types de hachage aussi bien) j'ai écrit une extension de chaîne qui gère plusieurs types de hachage et des types de sortie.

NOTE: CommonCrypto est inclus dans Xcode 10, donc vous pouvez simplement import CommonCrypto sans avoir à envoyer un en-tête de pont si vous avez la dernière version Xcode installée... Sinon, un en-tête de pont est nécessaire.

SWIFT 4+

String+Crypto.swift

import Foundation
import CommonCrypto

// Defines types of hash string outputs available
public enum HashOutputType {
    // standard hex string output
    case hex
    // base 64 encoded string output
    case base64
}

// Defines types of hash algorithms available
public enum HashType {
    case md5
    case sha1
    case sha224
    case sha256
    case sha384
    case sha512

    var length: Int32 {
        switch self {
        case .md5: return CC_MD5_DIGEST_LENGTH
        case .sha1: return CC_SHA1_DIGEST_LENGTH
        case .sha224: return CC_SHA224_DIGEST_LENGTH
        case .sha256: return CC_SHA256_DIGEST_LENGTH
        case .sha384: return CC_SHA384_DIGEST_LENGTH
        case .sha512: return CC_SHA512_DIGEST_LENGTH
        }
    }
}

public extension String {

    /// Hashing algorithm for hashing a string instance.
    ///
    /// - Parameters:
    ///   - type: The type of hash to use.
    ///   - output: The type of output desired, defaults to .hex.
    /// - Returns: The requested hash output or nil if failure.
    public func hashed(_ type: HashType, output: HashOutputType = .hex) -> String? {

        // convert string to utf8 encoded data
        guard let message = data(using: .utf8) else { return nil }
        return message.hashed(type, output: output)
}

Data+Crypto.swift

import Foundation
import CommonCrypto 

extension Data {

    /// Hashing algorithm that prepends an RSA2048ASN1Header to the beginning of the data being hashed.
    ///
    /// - Parameters:
    ///   - type: The type of hash algorithm to use for the hashing operation.
    ///   - output: The type of output string desired.
    /// - Returns: A hash string using the specified hashing algorithm, or nil.
    public func hashWithRSA2048Asn1Header(_ type: HashType, output: HashOutputType = .hex) -> String? {

        let rsa2048Asn1Header:[UInt8] = [
            0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
            0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00
        ]

        var headerData = Data(bytes: rsa2048Asn1Header)
        headerData.append(self)

        return hashed(type, output: output)
    }

    /// Hashing algorithm for hashing a Data instance.
    ///
    /// - Parameters:
    ///   - type: The type of hash to use.
    ///   - output: The type of hash output desired, defaults to .hex.
    ///   - Returns: The requested hash output or nil if failure.
    public func hashed(_ type: HashType, output: HashOutputType = .hex) -> String? {

        // setup data variable to hold hashed value
        var digest = Data(count: Int(type.length))

        // generate hash using specified hash type
        _ = digest.withUnsafeMutableBytes { (digestBytes: UnsafeMutablePointer<UInt8>) in
            self.withUnsafeBytes { (messageBytes: UnsafePointer<UInt8>) in
                let length = CC_LONG(self.count)
                switch type {
                case .md5: CC_MD5(messageBytes, length, digestBytes)
                case .sha1: CC_SHA1(messageBytes, length, digestBytes)
                case .sha224: CC_SHA224(messageBytes, length, digestBytes)
                case .sha256: CC_SHA256(messageBytes, length, digestBytes)
                case .sha384: CC_SHA384(messageBytes, length, digestBytes)
                case .sha512: CC_SHA512(messageBytes, length, digestBytes)
                }
            }
        }

        // return the value based on the specified output type.
        switch output {
        case .hex: return digest.map { String(format: "%02hhx", "151910920") }.joined()
        case .base64: return digest.base64EncodedString()
        }
    }
}

Edit: puisque le hachage se produit réellement sur les données, j'ai divisé l'algorithme de hachage en une extension de données. Cela permet d'utiliser le même algorithme pour les opérations de pointage de certificats SSL.

Voici un court exemple de comment vous pourriez l'utiliser pour un Opération de rodage SSL:

// Certificate pinning - get certificate as data
let data: Data = SecCertificateCopyData(serverCertificate) as Data

// compare hash of server certificate with local (expected) hash value
guard let serverHash = data.hashWithRSA2048Asn1Header(.sha256, output: .base64), serverHash == storedHash else {
    print("SSL PINNING: Server certificate hash does not match specified hash value.")
    return false
}

retour à la réponse originale

j'ai testé les algorithmes de hachage en utilisant ceci:

let value = "This is my string"

if let md5 = value.hashed(.md5) {
    print("md5: \(md5)")
}
if let sha1 = value.hashed(.sha1) {
    print("sha1: \(sha1)")
}
if let sha224 = value.hashed(.sha224) {
    print("sha224: \(sha224)")
}
if let sha256 = value.hashed(.sha256) {
    print("sha256: \(sha256)")
}
if let sha384 = value.hashed(.sha384) {
    print("sha384: \(sha384)")
}
if let sha512 = value.hashed(.sha512) {
    print("sha512: \(sha512)")
}

et voici les résultats imprimés:

md5: c2a9ce57e8df081b4baad80d81868bbb
sha1: 37fb219bf98bee51d2fdc3ba6d866c97f06c8223
sha224: f88e2f20aa89fb4dffb6bdc62d7bd75e1ba02574fae4a437c3bf49c7
sha256: 9da6c02379110815278b615f015f0b254fd3d5a691c9d8abf8141655982c046b
sha384: d9d7fc8aefe7f8f0a969b132a59070836397147338e454acc6e65ca616099d03a61fcf9cc8c4d45a2623145ebd398450
sha512: 349cc35836ba85915ace9d7f895b712fe018452bb4b20ff257257e12adeb1e83ad780c6568a12d03f5b2cb1e3da23b8b7ced9012a188ef3855e0a8f3db211883

J'ai utilisé Carthage et Cyrpto pour faire ça.

1. installer Carthage si vous ne L'avez pas déjà fait

2. installez Crypto dans votre projet

3. exécuter "de cartage la mise à jour"

4. si vous utilisez la ligne de commande ajouter dans le cadre dans le swift dossier

   #!/usr/bin/env xcrun swift -F Carthage/Build/Mac
   

5. ajouter Import Crypto à votre fichier swift.

6. alors ça marche!

   print( "convert this".MD5 )
   

MD5 est un algorithme de hachage, pas besoin d'utiliser la volumineuse Bibliothèque CommonCrypto pour cela (et être rejeté par Apple review), il suffit d'utiliser n'importe quelle bibliothèque de hachage md5.

L'une de ces bibliothèques que j'utilise est SwiftHash , une pure implémentation swift de MD5 (basée sur http://pajhome.org.uk/crypt/md5/md5.html )

j'ai trouvé cette bibliothèque qui semble fonctionner assez bien.

https://github.com/onmyway133/SwiftHash

MD5("string")