Swift 3 faire sha1, sha256 et md5 fonctions

Vous feriez mieux d'utiliser Swift Data dans Swift 3.

Données

Et lorsque l'on travaille avec Data, vous devez utiliser withUnsafeBytes(_:) ou withUnsafeMutableBytes(_:), où vous avez été en utilisant bytes ou mutableBytes respectivement.

withUnsafeBytes(_:)

withUnsafeMutableBytes(_:)

extension Data {
func hexString() -> String {
let string = self.map{Int($0).hexString()}.joined()
return string
}
func MD5() -> Data {
var result = Data(count: Int(CC_MD5_DIGEST_LENGTH))
_ = result.withUnsafeMutableBytes {resultPtr in
self.withUnsafeBytes {(bytes: UnsafePointer<UInt8>) in
CC_MD5(bytes, CC_LONG(count), resultPtr)
}
}
return result
}
/*
... nearly the same for `SHA1` and `SHA256`.
*/
}
extension String {
func hexString() -> String {
return self.data(using: .utf8)!.hexString()
}
func MD5() -> String {
return self.data(using: .utf8)!.MD5().hexString()
}
/*
... nearly the same for `SHA1` and `SHA256`.
*/
}

Je préfère faire les propriétés calculées que l'absence de méthodes argument (pour relativement légères tâches). Vous avez besoin pour réparer toutes les parties à les utiliser, mais vous pouvez écrire quelque chose comme ceci:

extension Int {
var hexString: String {
return ...
}
}
extension Data {
var hexString: String {
let string = self.map{Int($0).hexString}.joined()
return string
}
var MD5: Data {
var result = Data(count: Int(CC_MD5_DIGEST_LENGTH))
_ = result.withUnsafeMutableBytes {resultPtr in
self.withUnsafeBytes {(bytes: UnsafePointer<UInt8>) in
CC_MD5(bytes, CC_LONG(count), resultPtr)
}
}
return result
}
/*
... nearly the same for `SHA1` and `SHA256`.
*/
}
extension String {
var hexString: String {
return self.data(using: .utf8)!.hexString
}
var MD5: String {
return self.data(using: .utf8)!.MD5.hexString
}
/*
... nearly the same for `SHA1` and `SHA256`.
*/
}

---

Il peut y avoir plus rapidement un correctif pour votre code à l'aide de NSData, mais je vous recommande de vous déplacer à Data dans Swift 3.

Je trouve que la plupart de la réponse ok, mais si nous devons avoir une vraie solution universelle, je pense que nous avons besoin de monter d'un niveau.

CC_LONG est juste un UInt32 et ne soutiendra pas vraiment de grandes structures de données.

C'est ma solution dans Swift 3:

- Nous d'abord de créer une fondation qui œuvre avec Data:

struct Sha256 {
let context = UnsafeMutablePointer<CC_SHA256_CTX>.allocate(capacity:1)
init() {
CC_SHA256_Init(context)
}
func update(data: Data) {
data.withUnsafeBytes { (bytes: UnsafePointer<Int8>) -> Void in
let end = bytes.advanced(by: data.count)
for f in sequence(first: bytes, next: { $0.advanced(by: Int(CC_LONG.max)) }).prefix(while: { (current) -> Bool in current < end})  {
_ = CC_SHA256_Update(context, f, CC_LONG(Swift.min(f.distance(to: end), Int(CC_LONG.max))))
}
}
}
func final() -> Data {
var digest = [UInt8](repeating: 0, count:Int(CC_SHA256_DIGEST_LENGTH))
CC_SHA256_Final(&digest, context)
return Data(bytes: digest)
}
}

Pour des raisons de commodité, nous faire une extension de Données:

extension Data {
func sha256() -> Data {
let s = Sha256()
s.update(data: self)
return s.final()
}
}

Et dernière extension de Chaîne:

extension String {
func sha256() -> Data {
return self.data(using: .utf8)!.sha256()
}
}

Si nécessaire, convertir le résultat de Data de chaîne hexadécimale ou autre chose selon votre cas d'utilisation.

Cette solution peut être utilisée pour Sha512, MD5 etc. pour obtenir de vrais solutions universelles avec Apple CommonCrypto qui sont faciles à étendre à plusieurs cas d'utilisation.