Как я могу преобразовать строку в хеш MD5 в iOS с помощью Swift?


111

Я хочу преобразовать строку типа «abc» в хеш MD5. Я хочу сделать это в iOS и Swift. Я пробовал использовать приведенные ниже решения, но они не помогли мне:

Импорт CommonCrypto в Swift framework

Как использовать метод CC_MD5 на быстром языке.

http://iosdeveloperzone.com/2014/10/03/using-commoncrypto-in-swift/

Чтобы быть более ясным, я хочу добиться вывода в Swift, аналогичного выводу этого кода PHP:

$str = "Hello";

echo md5($str);

Выход: 8b1a9953c4611296a827abf8c47804d7


5
Что не так с ссылками, которые вы дали?
jtbandes

2
Ссылки, которые вы дали, должны работать. Вы можете описать, в чем именно ваша проблема? Вы также можете включить стороннюю библиотеку, чтобы делать то, что вы хотите, т.е. github.com/krzyzanowskim/CryptoSwift
Эрик Аморде,

1
Как я уже упоминал, я новичок в быстром программировании, я был сбит с толку, чтобы правильно его реализовать. Я включал этот файл (#import <CommonCrypto / CommonCrypto.h>) в файл быстрого контроллера. Но спасибо за ваши ответы, теперь это решено ответом г-на Зафа, приведенным ниже.
user3606682

Если вам нужна домашняя реализация на Swift, тогда github.com/onmyway133/SwiftHash
onmyway133 02

Ответы:


178

Есть два шага:
1. Создать данные md5 из строки
2. Преобразовать данные md5 в шестнадцатеричную строку.

Swift 2.0:

func md5(string string: String) -> String {
    var digest = [UInt8](count: Int(CC_MD5_DIGEST_LENGTH), repeatedValue: 0)
    if let data = string.dataUsingEncoding(NSUTF8StringEncoding) {
        CC_MD5(data.bytes, CC_LONG(data.length), &digest)
    }

    var digestHex = ""
    for index in 0..<Int(CC_MD5_DIGEST_LENGTH) {
        digestHex += String(format: "%02x", digest[index])
    }

    return digestHex
}

//Test:
let digest = md5(string:"Hello")
print("digest: \(digest)")

Вывод:

дайджест: 8b1a9953c4611296a827abf8c47804d7

Swift 3.0:

func MD5(string: String) -> Data {
    let messageData = string.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
}

//Test:
let md5Data = MD5(string:"Hello")

let md5Hex =  md5Data.map { String(format: "%02hhx", $0) }.joined()
print("md5Hex: \(md5Hex)")

let md5Base64 = md5Data.base64EncodedString()
print("md5Base64: \(md5Base64)")

Вывод:

md5Hex: 8b1a9953c4611296a827abf8c47804d7
md5Base64: ixqZU8RhEpaoJ6v4xHgE1w ==

Swift 5.0:

import Foundation
import var CommonCrypto.CC_MD5_DIGEST_LENGTH
import func CommonCrypto.CC_MD5
import typealias CommonCrypto.CC_LONG

func MD5(string: String) -> Data {
        let length = Int(CC_MD5_DIGEST_LENGTH)
        let messageData = string.data(using:.utf8)!
        var digestData = Data(count: length)

        _ = digestData.withUnsafeMutableBytes { digestBytes -> UInt8 in
            messageData.withUnsafeBytes { messageBytes -> UInt8 in
                if let messageBytesBaseAddress = messageBytes.baseAddress, let digestBytesBlindMemory = digestBytes.bindMemory(to: UInt8.self).baseAddress {
                    let messageLength = CC_LONG(messageData.count)
                    CC_MD5(messageBytesBaseAddress, messageLength, digestBytesBlindMemory)
                }
                return 0
            }
        }
        return digestData
    }

//Test:
let md5Data = MD5(string:"Hello")

let md5Hex =  md5Data.map { String(format: "%02hhx", $0) }.joined()
print("md5Hex: \(md5Hex)")

let md5Base64 = md5Data.base64EncodedString()
print("md5Base64: \(md5Base64)")

Вывод:

md5Hex: 8b1a9953c4611296a827abf8c47804d7
md5Base64: ixqZU8RhEpaoJ6v4xHgE1w ==

Примечания:
#import <CommonCrypto/CommonCrypto.h>необходимо добавить в файл Bridging-Header

О том, как создать Bridging-Header, см. Этот ответ SO .

В общем, MD5 не следует использовать для новой работы, SHA256 - это лучшая практика.

Пример из раздела устаревшей документации:

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

Эти функции будут хешировать ввод строки или данных с помощью одного из восьми алгоритмов криптографического хеширования.

Параметр name указывает имя хэш-функции в виде строки.
Поддерживаемые функции: MD2, MD4, MD5, SHA1, SHA224, SHA256, SHA384 и SHA512 a В этом примере требуется Common Crypto.
Необходимо иметь заголовок моста для проекта:
#import <CommonCrypto/CommonCrypto.h>
Добавить безопасность. .framework к проекту.



Эта функция принимает хеш-имя и строку для хеширования и возвращает данные:

name: имя хеш-функции в виде строки  
строка: строка для хеширования  
возвращает: результат хеширования в виде данных  
func hash(name:String, string:String) -> Data? {
    let data = string.data(using:.utf8)!
    return hash(name:name, data:data)
}

Примеры:

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)")

Вывод:

clearString: clearData0123456
clearData: <636c6561 72446174 61303132 33343536>

hashSHA256: <aabc766b 6b357564 e41f4f91 2d494bcc bfa16924 b574abbd ba9e3e9d a0c8920a>
hashMD5: <4df665f7 b94aea69 695b0e7b baf9e9d6>

3
Спасибо, alottt @zaph, я боролся за это более 2 дней. Получил решение с вашим ответом выше :) И да, я получаю старые данные из Интернета, где используется MD5, поэтому я вынужден использовать MD5. Но еще раз спасибо за ответ и предложение использовать SHA256 :)
user3606682

String(data: digestData, encoding: String.Encoding.utf8)throwsfatal error: unexpectedly found nil while unwrapping an Optional value
Siddharth

@Siddharth В комментарии недостаточно информации, непонятно что digestData. Если это хеш-данные, скорее всего, это UTF-8 (или любая строковая кодировка от тонкой до несуществующей.
zaph

1
Вот как вы можете это улучшить: импортируйте только необходимые символы, а не весь CommonCrypto, потому что в противном случае это немного накладные расходы: import var CommonCrypto.CC_MD5_DIGEST_LENGTH import func CommonCrypto.CC_MD5 import typealias CommonCrypto.CC_LONG
Игорь Васильев

2
@zaph, возможно, вы захотите добавить решение iOS 13 CryptoKit к своему ответу, который я подробно описал в своем ответе ниже: stackoverflow.com/a/56578995/368085
mluisbrown

40

После прочтения других ответов здесь (и необходимости поддержки других типов хешей) я написал расширение String, которое обрабатывает несколько типов хешей и типов вывода.

ПРИМЕЧАНИЕ: CommonCrypto включен в Xcode 10, поэтому вы можете просто import CommonCryptoне возиться с заголовком моста, если у вас установлена ​​последняя версия Xcode ... В противном случае необходим заголовок моста.


ОБНОВЛЕНИЕ: оба Swift 4 и 5 используют один и тот же файл String + Crypto.swift, указанный ниже.

Существует отдельный файл Data + Crypto.swift для Swift 5 (см. Ниже), так как api для withUnsafeMutableBytes и withUnsafeBytes изменен между Swift 4 и 5.


String + Crypto.swift - (для Swift 4 и 5)

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)
    } 
}

SWIFT 5 - Данные + 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(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))

        _ = digest.withUnsafeMutableBytes{ digestBytes -> UInt8 in
            self.withUnsafeBytes { messageBytes -> UInt8 in
                if let mb = messageBytes.baseAddress, let db = digestBytes.bindMemory(to: UInt8.self).baseAddress {
                    let length = CC_LONG(self.count)
                    switch type {
                    case .md5: CC_MD5(mb, length, db)
                    case .sha1: CC_SHA1(mb, length, db)
                    case .sha224: CC_SHA224(mb, length, db)
                    case .sha256: CC_SHA256(mb, length, db)
                    case .sha384: CC_SHA384(mb, length, db)
                    case .sha512: CC_SHA512(mb, length, db)
                    }
                }
                return 0
            }
        }

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

SWIFT 4 - Данные + 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", $0) }.joined()
        case .base64: return digest.base64EncodedString()
        }
    }
}

Изменить: поскольку хеширование фактически происходит с данными, я разделил алгоритм хеширования на расширение данных. Это позволяет использовать тот же алгоритм для хеш-операций закрепления SSL-сертификатов.

Вот краткий пример того, как вы можете использовать его для операции 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
}

вернуться к исходному ответу

Я тестировал алгоритмы хеширования, используя это:

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)")
}

и это напечатанные результаты:

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

40

Начиная с iOS 13, Apple добавила CryptoKitфреймворк, поэтому вам больше не нужно импортировать CommonCrypto или иметь дело с его C API:

import Foundation
import CryptoKit

func MD5(string: String) -> String {
    let digest = Insecure.MD5.hash(data: string.data(using: .utf8) ?? Data())

    return digest.map {
        String(format: "%02hhx", $0)
    }.joined()
}


3
Также стоит отметить, что это позволяет избежать предупреждения о том, что MD5 теперь небезопасен. Вам не нужно реализовывать CommonCrypto в Objective-C, чтобы у вас была поддержка прагм для отключения предупреждения. Это удобно, если вы работаете в среде, в которой особое внимание уделяется работе с предупреждениями.
marcus.ramsden

28

SWIFT 3версия 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
}

Исходная ссылка с http://iosdeveloperzone.com


23

Swift 4. *, обновление Xcode 10:

В Xcode 10 вам не нужно использовать Bridging-Header Anymore, вы можете напрямую импортировать, используя

import CommonCrypto

А затем напишите метод примерно так:

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])
        }
    }

Использование :

MD5("This is my string")

Вывод:

c2a9ce57e8df081b4baad80d81868bbb

ваше решение отлично работает. Можем ли мы добавить значение SALT с помощью этого шифрования MD5? Я хочу добавить при шифровании строки. Вы можете предоставить полную ссылку для использования?
Пунита

Я не уверен, чего вы пытаетесь достичь. Используйте «AES128», если хотите настраиваемое шифрование с засаливанием. если вас беспокоит безопасность, проверьте это: stackoverflow.com/a/15775071/3118377 .
Invictus Cody

Спасибо, Invictus Cody, я объединил SALT со String и могу получить MD5.
Пунита

Прекрасно работает. Но как преобразовать его обратно в String?
DocAsh59,

1
Swift 5: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: .utf8) { _ = d.withUnsafeBytes { body -> String in CC_MD5(body.baseAddress, CC_LONG(d.count), &digest) return "" } } return (0..<length).reduce("") { $0 + String(format: "%02x", digest[$1]) } }
Jim B

17

Я выпустил чистую реализацию Swift , которая не зависит от CommonCrypto или чего-либо еще. Он доступен по лицензии MIT.

Код состоит из одного быстрого файла, который вы можете просто добавить в свой проект. Если вы предпочитаете, вы также можете использовать содержащийся проект Xcode с целями фреймворка и модульного тестирования.

Использовать просто:

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

печатает: md5: 9e107d9d372bb6826bd81d3542a419d6

Файл swift содержит документацию и другие примеры.


4
Требуется Swift 4, который не упоминается здесь или в файле ReadMe Github. Использование не следует рассматривать без данных о производительности, представленных в сравнении с Common Crypto. Примечание: Common Crypto сертифицирован FIPS 140, SwiftDigest - нет. Вот ключевой вопрос: чем это лучше, чем Common Crypto для реализации?
Надежнее

1
@zaph Основная цель - иметь реализацию md5, не зависящую от CommonCrypto. Это полезно в ситуациях, когда CommonCrypto недоступен - например, для целей платформы Swift или на платформах сторонних производителей.
Николай Рухе

4
@zaph Я согласен с тем, что к реализации, связанной с безопасностью, нельзя относиться легкомысленно. Но у MD5 есть и другие применения, кроме безопасности - или, скорее, безопасность - это то, где MD5 работает хуже всего. Алгоритмы хеширования используются для идентификации, сортировки, хранения словарей, обнаружения ошибок и других причин. MD5 особенно полезен из-за его повсеместного распространения. Итак, хотя я согласен с парой ваших комментариев, я не согласен с сутью. Я считаю, что ваша точка зрения и аргументы слишком узкие; он не охватывает всю тему.
Николай Рухе

2
Кроме того, я только что протестировал, и моя реализация быстрее, чем CommonCrypto для больших сообщений :)
Николай Рухе

2
Мне нравится эта реализация. Большое спасибо @NikolaiRuhe! Мне удалось легко преобразовать его в совместимость с Swift 3. Я также добавил несколько удобных методов, включая вычисление дайджеста содержимого файла с учетом URL-адреса и получение кодировки base64 (полезно, среди прочего, для Content-MD5). @Siddharth - единственный файл, который вам нужен, - это MD5Digest.swift.
biomiker

10

Здесь всего два примечания:

Использование Crypto - слишком много накладных расходов для достижения этой цели.

Общепринятый ответ прекрасен! Тем не менее, я просто хотел поделиться подходом кода Swift ier с использованием Swift 2.2 .

Имейте в виду, что вам все еще нужно #import <CommonCrypto/CommonCrypto.h>в файле заголовка моста

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("") { $0 + String(format: "%02x", digest[$1]) }
    }
}

7

Swift 5 ответ как расширение String (на основе отличного ответа Invictus Cody ):

import CommonCrypto

extension String {
    var md5Value: String {
        let length = Int(CC_MD5_DIGEST_LENGTH)
        var digest = [UInt8](repeating: 0, count: length)

        if let d = self.data(using: .utf8) {
            _ = d.withUnsafeBytes { body -> String in
                CC_MD5(body.baseAddress, CC_LONG(d.count), &digest)

                return ""
            }
        }

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

Использование:

print("test".md5Value) /*098f6bcd4621d373cade4e832627b4f6*/

6

Вот расширение, основанное на ответе 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", $0) }.joined()
        }
    }
}

Полностью совместим с swift 3.0. Вам все еще нужно #import <CommonCrypto/CommonCrypto.h>в файле Bridging-Header


3

В быстром программировании лучше сделать строковую функцию, чтобы ее было легко использовать. Здесь я делаю расширение String, используя одно из приведенных выше решений. Спасибо @wajih

import Foundation
import CommonCrypto

extension String {

func md5() -> 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, self, CC_LONG(self.lengthOfBytes(using: String.Encoding.utf8)))
    CC_MD5_Final(&digest, context)
    context.deallocate()
    var hexString = ""
    for byte in digest {
        hexString += String(format:"%02x", byte)
    }

    return hexString
}
}

использование

let md5String = "abc".md5()

1

Для этого я использовал Карфаген и Кирпто.

  1. Установите Carthage, если вы еще этого не сделали

  2. Установите Crypto в свой проект

  3. выполнить 'обновление перевозки'

  4. Если вы запускаете из командной строки, добавьте фреймворк в быстрый файл

    #!/usr/bin/env xcrun swift -F Carthage/Build/Mac
  5. Добавьте импорт Crypto в свой быстрый файл.

  6. тогда это просто работает!

    print( "convert this".MD5 )

Использование полноценной криптографической библиотеки, когда нужна только одна функция, - это немного излишне
Марк Бурк

Приношу извинения за комментарий старого потока ... Возможно, но общие библиотеки (предположительно) всегда в курсе изменений платформы, что дает общие результаты и минимизирует фрагментацию, и никому не нужно постоянно изобретать колеса или использовать кучу интернет-ресурсов. нашел код, который может быть или не быть надежным, быстрым или основанным на стандартах. Я полностью за минимизацию зависимостей, но в чем-то вроде этого я сначала смотрю на параметры ОС, затем на общие языковые параметры, а затем на сторонние стандартные параметры, и в результате получаются одноразовые или «библиотека этого парня довольно хорошая» варианты последние. *
пожимает

1

MD5 - это алгоритм хеширования, нет необходимости использовать для этого громоздкую библиотеку CommonCrypto (и получить отказ от обзора Apple), просто используйте любую библиотеку хеширования md5.

Одна из таких библиотек, которые я использую, - SwiftHash , чистая быстрая реализация MD5 (на основе http://pajhome.org.uk/crypt/md5/md5.html )


1

Основываясь на решении Коди , у меня есть идея, что мы должны уточнить, каков результат MD5, потому что мы можем использовать результат как шестнадцатеричную строку или строку Base64.

func md5(_ string: String) -> [UInt8] {
    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 digest
}

Приведенная выше функция фактически возвращает a [UInt8], и на основе этого результата мы можем получить любую форму строки, например, hex, base64.

Если в качестве окончательного результата требуется шестнадцатеричная строка (как задается вопросом), мы можем продолжать использовать остальную часть решения Коди

extension String {
    var md5Hex: String {
        let length = Int(CC_MD5_DIGEST_LENGTH)
        return (0..<length).reduce("") {
            $0 + String(format: "%02x", digest[$1])
        }
    }
}

Если в качестве окончательного результата требуется строка Base64

extension String {
    var md5Base64: String {
        let md5edData = Data(bytes: md5(self))
        return md5edData.base64EncodedString()
    }
}

1

Ответ для Swift 5 с правильным управлением памятью и без Stringкласса внутри метода:

typealias CBridgeCryptoMethodType = (UnsafeRawPointer?,
                                 UInt32,
                                 UnsafeMutablePointer<UInt8>?)
-> UnsafeMutablePointer<UInt8>?

private enum HashType {

    // MARK: - Cases

    case md5
    case sha1
    case sha224
    case sha256
    case sha384
    case sha512
}

extension Data {
    var hexString: String {
        let localHexString = reduce("", { previous, current in
            return previous + String(format: "%02X", current)
        })
        return localHexString
    }
    var md5: Data {
        return hashed(for: .md5)
    }
    var sha1: Data {
        return hashed(for: .sha1)
    }
    var sha224: Data {
        return hashed(for: .sha224)
    }
    var sha256: Data {
        return hashed(for: .sha256)
    }
    var sha384: Data {
        return hashed(for: .sha384)
    }
    var sha512: Data {
        return hashed(for: .sha512)
    }

    private func hashed(for hashType: HashType) -> Data {
        return withUnsafeBytes { (rawBytesPointer: UnsafeRawBufferPointer) -> Data in
            guard let bytes = rawBytesPointer.baseAddress?.assumingMemoryBound(to: Float.self) else {
                return Data()
            }
            let hashMethod: CBridgeCryptoMethodType
            let digestLength: Int
            switch hashType {
            case .md5:
                hashMethod = CC_MD5
                digestLength = Int(CC_MD5_DIGEST_LENGTH)
            case .sha1:
                hashMethod = CC_SHA1
                digestLength = Int(CC_SHA1_DIGEST_LENGTH)
            case .sha224:
                hashMethod = CC_SHA224
                digestLength = Int(CC_SHA224_DIGEST_LENGTH)
            case .sha256:
                hashMethod = CC_SHA256
                digestLength = Int(CC_SHA256_DIGEST_LENGTH)
            case .sha384:
                hashMethod = CC_SHA384
                digestLength = Int(CC_SHA384_DIGEST_LENGTH)
            case .sha512:
                hashMethod = CC_SHA512
                digestLength = Int(CC_SHA512_DIGEST_LENGTH)
            }
            let result = UnsafeMutablePointer<UInt8>.allocate(capacity: digestLength)
            _ = hashMethod(bytes, CC_LONG(count), result)
            let md5Data = Data(bytes: result, count: digestLength)
            result.deallocate()
            return md5Data
        }
    }
}

пример

let str = "The most secure string ever"
print("md5", str.data(using: .utf8)?.md5.hexString)
print("sha1", str.data(using: .utf8)?.sha1.hexString)
print("sha224", str.data(using: .utf8)?.sha224.hexString)
print("sha256", str.data(using: .utf8)?.sha256.hexString)
print("sha384", str.data(using: .utf8)?.sha384.hexString)
print("sha512", str.data(using: .utf8)?.sha512.hexString)

Полученные результаты:

md5 Необязательно ("671C121427F12FBBA66CEE71C44CB62C")

sha1 Необязательно ("A6A40B223AE634CFC8C191DDE024BF0ACA56D7FA")

sha224 Необязательно ("334370E82F2F5ECF5B2CA0910C6176D94CBA12FD6F518A7AB8D12ADE")

sha256 Необязательно ("8CF5ED971D6EE2579B1BDEFD4921415AC03DA45B49B89665B3DF197287EFC89D")

sha384 Необязательно ("04BB3551CBD60035BA7E0BAA141AEACE1EF5E17317A8FD108DA12A7A8E98C245E14F92CC1A241C732209EAC9D600602E")

sha512 Дополнительно ("1D595EAFEB2162672830885D336F75FD481548AC463BE16A8D98DB33637213F1AEB36FA4977B9C23A82A4FAB8A70C06AFC64C610D3CB1FE77A609DC8EE86AA68)"



0

мои два цента (если вам нужно быстро md5 для Data / NSData, например, вы загрузили или прочитали двоичный файл для диска или netwkork)

(бесстыдно из «Swift 5 ответ как расширение String (на основе великого ответа Invictus Cody»)):

extension Data {
    var md5Value: String {
        let length = Int(CC_MD5_DIGEST_LENGTH)
        var digest = [UInt8](repeating: 0, count: length)

        _ = self.withUnsafeBytes { body -> String in
            CC_MD5(body.baseAddress, CC_LONG(self.count), &digest)
            return ""
        }


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

тест:

print("test".data.md5Value) /*098f6bcd4621d373cade4e832627b4f6*/
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.