Swiftを使用してiOSで文字列をMD5ハッシュに変換するにはどうすればよいですか？
「abc」などの文字列をMD5ハッシュに変換したい。 iOSとSwiftでこれを行いたいです。私は以下のソリューションを使用しようとしましたが、彼らは私のために働いていませんでした：
SwiftフレームワークへのCommonCryptoのインポート
http://iosdeveloperzone.com/2014/10/03/using-commoncrypto-in-Swift/
より明確にするために、このSwiftコードの出力に似たPHPの出力を達成したいと思います。
$str = "Hello";
echo md5($str);
出力：8b1a9953c4611296a827abf8c47804d7
2つのステップがあります。
1。文字列からMD5データを作成する
2。 md5データを16進文字列に変換します
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ファイルに追加する必要があります
ブリッジングヘッダーの作成方法については、 this SO answer を参照してください。
一般に、MD5は新しい作業には使用しないでください。SHA256は現在のベストプラクティスです。
非推奨のドキュメントセクションの例：
MD2、MD4、MD5、SHA1、SHA224、SHA256、SHA384、SHA512（Swift 3 +）
これらの関数は、8つの暗号化ハッシュアルゴリズムのいずれかで文字列またはデータ入力のいずれかをハッシュします。
Nameパラメーターは、ハッシュ関数名を文字列として指定します
サポートされる機能は、MD2、MD4、MD5、SHA1、SHA224、SHA256、SHA384、およびSHA512です。この例では、共通暗号が必要です。
プロジェクトへのブリッジングヘッダーが必要です。#import <CommonCrypto/CommonCrypto.h>
プロジェクトにSecurity.frameworkを追加します。
この関数は、ハッシュされるハッシュ名とストリングを受け取り、データを返します。
name：文字列としてのハッシュ関数の名前 string：ハッシュされる文字列 returns：ハッシュ結果をデータとして
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>
Swift 3md5 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 からの元のリンク
ここの他の回答を読んだ後（および他のハッシュタイプもサポートする必要がある）、複数のハッシュタイプと出力タイプを処理するString拡張機能を作成しました。
注：CommonCryptoはXcode 10に含まれているため、最新のXcodeバージョンがインストールされている場合は、ブリッジヘッダーを台無しにすることなく、単にimport CommonCryptoを実行できます。それ以外の場合は、ブリッジヘッダーが必要です。
更新：Swift 4および5の両方で、以下の同じString + Crypto.Swiftファイルが使用されます。
Swift 5（以下を参照）の個別のData + Crypto.Swiftファイルは、Swift 4と5の間で変更された 'withUnsafeMutableBytes'と 'withUnsafeBytes'のAPIとしてあります。
文字列+ Crypto.SwiftSwift 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-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(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-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", $0) }.joined()
case .base64: return digest.base64EncodedString()
}
}
}
編集：ハッシュは実際にデータで発生するため、ハッシュアルゴリズムをデータ拡張に分割しました。これにより、同じアルゴリズムをSSL証明書の固定ハッシュ操作にも使用できます。
SSL Pinning操作に使用する方法の簡単な例を次に示します：
// 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
Swift 4. *、Xcode 10アップデート：
Xcode 10では、Bridging-Headerもう使用する必要はありません。
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
CommonCryptoなどに依存しない pure Swift implementation をリリースしました。 MITライセンスで利用可能です。
コードは single Swift file で構成され、プロジェクトにドロップできます。必要に応じて、フレームワークと単体テストのターゲットで含まれているXcodeプロジェクトを使用することもできます。
使い方は簡単です：
let input = "The quick brown fox jumps over the lazy dog"
let digest = input.utf8.md5
print("md5: \(digest)")
プリント：md5: 9e107d9d372bb6826bd81d3542a419d6
Swiftファイルには、ドキュメントとその他の例が含まれています。
ここに2つのメモがあります。
Cryptoを使用すると、これを実現するにはオーバーヘッドが大きすぎます。
受け入れられた答え は完璧です！それにもかかわらず、Swiftierを使用したコードアプローチSwift 2.2.
Bridging-Headerファイルでまだ#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]) }
}
}
これは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と完全な互換性があります。Bridging-Headerファイルには#import <CommonCrypto/CommonCrypto.h>が必要です
Swift 5文字列拡張としての回答（ 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*/
CarthageとCyrptoを使用してこれを行いました。
「cartage update」を実行します
コマンドラインから実行している場合は、Swiftファイルにフレームワークを追加します
#!/usr/bin/env xcrun Swift -F Carthage/Build/Macインポート暗号をSwiftファイルに追加します。
それはちょうどうまくいきます！
print( "convert this".MD5 )
IOS 13（2019年9月にリリースのみ）の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()
}
MD5はハッシュアルゴリズムです。このためにかさばるCommonCryptoライブラリを使用する必要はなく（Appleレビューで拒否されます）、md5ハッシュライブラリを使用するだけです。
私が使用するそのようなライブラリの1つは SwiftHash で、MD5の純粋なSwift実装です（ http://pajhome.org.uk/crypt/md5/md5に基づいています）。 html ）
Swiftプログラミングでは、文字列関数を作成する方が良いため、使用は簡単です。ここでは、上記のソリューションのいずれかを使用して文字列拡張機能を作成しています。ありがとう@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()
私の2セント（Data/NSDataのmd5がすぐに必要な場合、たとえば、ディスクまたはnetwkorkのバイナリをダウンロードまたは読み取る場合）
（「Invictus Codyの素晴らしい答えに基づいた文字列拡張としてのSwift 5の答え」から恥知らず））：
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*/
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 Optional（ "671C121427F12FBBA66CEE71C44CB62C"）
sha1オプション（「A6A40B223AE634CFC8C191DDE024BF0ACA56D7FA」）
sha224オプション（ "334370E82F2F5ECF5B2CA0910C6176D94CBA12FD6F518A7AB8D12ADE"）
sha256オプション（ "8CF5ED971D6EE2579B1BDEFD4921415AC03DA45B49B89665B3DF197287EFC89D"）
sha384オプション（ "04BB3551CBD60035BA7E0BAA141AEACE1EF5E17317A8FD108DA12A7A8E98C245E14F92CC1A241C732209EAC9D600602E"）
sha512オプション（ "1D595EAFEB2162672830885D336F75FD481548AC463BE16A8D98DB33637213F1AEB36FA4977B9C23A82A4FAB8A70C06AFC64C610D3CB1FE77A609DC8EE86AA68"）
Codyの解 に基づいて、MD5の結果が何であるかを明確にする必要があるという考えがあります。これは、結果を16進数文字列または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
}
上記の関数は実際に[UInt8]を返し、この結果に基づいて、hex、base64などの任意の形式の文字列を取得できます。
最終的な結果として16進文字列が必要な場合（質問に答える場合）、 Codyの解 の残りの部分を使用し続けることができます。
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()
}
}