¿Cómo hash NSString con SHA1 en Swift?

Question

En el objetivo-c se ve así:

#include <sys/xattr.h>

@implementation NSString (reverse)

-(NSString*)sha1
{
    NSData *data = [self dataUsingEncoding:NSUTF8StringEncoding];
    uint8_t digest[CC_SHA1_DIGEST_LENGTH];
    CC_SHA1(data.bytes, (int)data.length, digest);
    NSMutableString *output = [NSMutableString stringWithCapacity:CC_SHA1_DIGEST_LENGTH * 2];
    for (int i = 0; i < CC_SHA1_DIGEST_LENGTH; i++)
        [output appendFormat:@"%02x", digest[i]];
    return output;
}

@end

Necesito algo como esto con Swift, ¿es posible?

Por favor, muestre un ejemplo de trabajo.

Answer 1

Con CryptoKit agregado en iOS13, ahora tenemos la API nativa de Swift:

import Foundation
import CryptoKit

// CryptoKit.Digest utils
extension Digest {
    var bytes: [UInt8] { Array(makeIterator()) }
    var data: Data { Data(bytes) }

    var hexStr: String {
        bytes.map { String(format: "%02X", $0) }.joined()
    }
}

func example() {
    guard let data = "hello world".data(using: .utf8) else { return }
    let digest = Insecure.SHA1.hash(data: data)
    print(digest.data) // 20 bytes
    print(digest.hexStr) // 2AAE6C35C94FCFB415DBE95F408B9CE91EE846ED
}

Answer 2

Para obtener el resultado como NSData , siempre que haya incluido <CommonCrypto/CommonCrypto.h> en su encabezado de puente:

extension NSData {

    func sha1() -> NSData? {
        let len = Int(CC_SHA1_DIGEST_LENGTH)
        let digest = UnsafeMutablePointer<UInt8>.alloc(len)
        CC_SHA1(bytes, CC_LONG(length), digest)
        return NSData(bytesNoCopy: UnsafeMutablePointer<Void>(digest), length: len)
    }
}

También utiliza la asignación de puntero adecuada. Invocarlo así:

myString.dataUsingEncoding(NSUTF8StringEncoding)?.sha1()

Si necesita una representación hexadecimal de NSData un vistazo a mi otra answer .

Answer 3

Podemos extraer la lógica para encriptar cadenas usando sha1 para tres pasos:

1. Convertir cadena a objeto de datos
2. Cifrar datos usando la función SHA1 a Datos
3. Convertir objeto de datos a cadena hexadecimal

En mi humilde opinión es mucho más legible y esta versión no requiere NSData.

    extension String {

        var sha1: String {
            guard let data = data(using: .utf8, allowLossyConversion: false) else {
                // Here you can just return empty string or execute fatalError with some description that this specific string can not be converted to data
            }
            return data.digestSHA1.hexString
        }

    }

    fileprivate extension Data {

        var digestSHA1: Data {
            var bytes: [UInt8] = Array(repeating: 0, count: Int(CC_SHA1_DIGEST_LENGTH))

            withUnsafeBytes {
                _ = CC_SHA1($0, CC_LONG(count), &bytes)
            }

            return Data(bytes: bytes)
        }

        var hexString: String {
            return map { String(format: "%02x", UInt8($0)) }.joined()
        }

    }

Answer 4

Sí, es posible, copie esta clase en su proyecto. https://github.com/idrougge/sha1-swift

Y será fácil como:

 SHA1.hexString(from: "myPhrase" )!

Probado para swift 3 y swift 4.

Answer 5

Sí, es posible: hacer que el código de Objective-C sea accesible desde Swift

Ver documentation .

Evitaría reescribirlo rápidamente si no obtiene ningún beneficio (como el uso de funciones específicas de swift).

Además, en un proyecto en el que estoy trabajando, utilicé un código de Objective-C similar al tuyo para manejar hashes. Al principio comencé a escribirlo rápidamente, luego me di cuenta de que era más fácil y mejor reutilizar el viejo obj-c.

Answer 6

Su código de Objective-C (usando una categoría NSString ) se puede traducir directamente a Swift (usando una extensión de String ).

Primero tienes que crear un "encabezado de puente" y agregar

#import <CommonCrypto/CommonCrypto.h>

Entonces:

extension String {
    func sha1() -> String {
        let data = self.dataUsingEncoding(NSUTF8StringEncoding)!
        var digest = [UInt8](count:Int(CC_SHA1_DIGEST_LENGTH), repeatedValue: 0)
        CC_SHA1(data.bytes, CC_LONG(data.length), &digest)
        let output = NSMutableString(capacity: Int(CC_SHA1_DIGEST_LENGTH))
        for byte in digest {
            output.appendFormat("%02x", byte)
        }
        return output as String
    }
}

println("Hello World".sha1())

Esto se puede escribir un poco más corto y más rápido como

extension String {
    func sha1() -> String {
        let data = self.dataUsingEncoding(NSUTF8StringEncoding)!
        var digest = [UInt8](count:Int(CC_SHA1_DIGEST_LENGTH), repeatedValue: 0)
        CC_SHA1(data.bytes, CC_LONG(data.length), &digest)
        let hexBytes = map(digest) { String(format: "%02hhx", $0) }
        return "".join(hexBytes)
    }
}

Actualización para Swift 2:

extension String {
    func sha1() -> String {
        let data = self.dataUsingEncoding(NSUTF8StringEncoding)!
        var digest = [UInt8](count:Int(CC_SHA1_DIGEST_LENGTH), repeatedValue: 0)
        CC_SHA1(data.bytes, CC_LONG(data.length), &digest)
        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joinWithSeparator("")
    }
}

Para devolver una cadena codificada Base-64 en lugar de una cadena codificada hexadecimal, simplemente reemplace

        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joinWithSeparator("")

con

        return NSData(bytes: digest, length: digest.count).base64EncodedStringWithOptions([])

Actualización para Swift 3:

extension String {
    func sha1() -> String {
        let data = self.data(using: String.Encoding.utf8)!
        var digest = [UInt8](repeating: 0, count:Int(CC_SHA1_DIGEST_LENGTH))
        data.withUnsafeBytes { 
            _ = CC_SHA1($0, CC_LONG(data.count), &digest)
        }
        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joined()
    }
}

Para devolver una cadena codificada Base-64 en lugar de una cadena codificada hexadecimal, simplemente reemplace

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

por

        return Data(bytes: digest).base64EncodedString()

Actualización para Swift 4:

El archivo de encabezado de puente ya no es necesario, uno puede import CommonCrypto en import CommonCrypto lugar:

import CommonCrypto

extension String {
    func sha1() -> String {
        let data = Data(self.utf8)
        var digest = [UInt8](repeating: 0, count:Int(CC_SHA1_DIGEST_LENGTH))
        data.withUnsafeBytes { 
            _ = CC_SHA1($0, CC_LONG(data.count), &digest)
        }
        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joined()
    }
}

Actualización para Swift 5:

El método Data.withUnsafeBytes() ahora llama al cierre con un UnsafeRawBufferPointer a, y baseAddress se usa para pasar la dirección inicial a la función C:

import CommonCrypto

extension String {
    func sha1() -> String {
        let data = Data(self.utf8)
        var digest = [UInt8](repeating: 0, count:Int(CC_SHA1_DIGEST_LENGTH))
        data.withUnsafeBytes { 
            _ = CC_SHA1($0.baseAddress, CC_LONG(data.count), &digest)
        }
        let hexBytes = digest.map { String(format: "%02hhx", $0) }
        return hexBytes.joined()
    }
}

Answer 7

Una versión para Swift 5 que usa CryptoKit en iOS 13 y de lo contrario recurre a CommonCrypto:

import CommonCrypto
import CryptoKit
import Foundation

private func hexString(_ iterator: Array<UInt8>.Iterator) -> String {
    return iterator.map { String(format: "%02x", $0) }.joined()
}

extension Data {

    public var sha1: String {
        if #available(iOS 13.0, *) {
            return hexString(Insecure.SHA1.hash(data: self).makeIterator())
        } else {
            var digest = [UInt8](repeating: 0, count: Int(CC_SHA1_DIGEST_LENGTH))
            self.withUnsafeBytes { bytes in
                _ = CC_SHA1(bytes.baseAddress, CC_LONG(self.count), &digest)
            }
            return hexString(digest.makeIterator())
        }
    }

}

Uso:

let string = "The quick brown fox jumps over the lazy dog"
let hexDigest = string.data(using: .ascii)!.sha1
assert(hexDigest == "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12")

También disponible a través del administrador de paquetes Swift:
https://github.com/ralfebert/TinyHashes