SHA256 em rápida

Eu quero usar sha256 no meu projeto, mas eu tive alguns problemas reescrevendo o código objC para código rápido. Ajude-me, por favor. Eu usei esta resposta: Como posso calcular um hash SHA-2 (idealmente SHA 256 ou SHA 512) no iOS?

Aqui está meu código

var hash : [CUnsignedChar] CC_SHA256(data.bytes, data.length, hash) var res : NSData = NSData.dataWithBytes(hash, length: CC_SHA256_DIGEST_LENGTH) 

isso me dá um erro porque swift não pode converter Int para CC_LONG , por exemplo.

Você tem que converter explicitamente entre Int e CC_LONG , porque Swift não faz conversões implícitas, como em (Objective-) C.

Você também precisa definir o hash como uma matriz do tamanho necessário.

 func sha256(data : NSData) -> NSData { var hash = [UInt8](count: Int(CC_SHA256_DIGEST_LENGTH), repeatedValue: 0) CC_SHA256(data.bytes, CC_LONG(data.length), &hash) let res = NSData(bytes: hash, length: Int(CC_SHA256_DIGEST_LENGTH)) return res } 

Como alternativa, você pode usar NSMutableData para alocar o buffer necessário:

 func sha256(data : NSData) -> NSData { let res = NSMutableData(length: Int(CC_SHA256_DIGEST_LENGTH)) CC_SHA256(data.bytes, CC_LONG(data.length), UnsafeMutablePointer(res.mutableBytes)) return res } 

Atualização para o Swift 3:

 func sha256(data : Data) -> Data { var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH)) data.withUnsafeBytes { _ = CC_SHA256($0, CC_LONG(data.count), &hash) } return Data(bytes: hash) } 

A resposta principal não funcionou para mim. Eu encontrei algo na web e mudei um pouco e agora funciona: D. É para o Swift 3 e 4.

Coloque esta extensão em algum lugar do seu projeto e use-a em uma string como esta: mystring.sha256 ()

 extension String { func sha256() -> String{ if let stringData = self.data(using: String.Encoding.utf8) { return hexStringFromData(input: digest(input: stringData as NSData)) } return "" } private func digest(input : NSData) -> NSData { let digestLength = Int(CC_SHA256_DIGEST_LENGTH) var hash = [UInt8](repeating: 0, count: digestLength) CC_SHA256(input.bytes, UInt32(input.length), &hash) return NSData(bytes: hash, length: digestLength) } private func hexStringFromData(input: NSData) -> String { var bytes = [UInt8](repeating: 0, count: input.length) input.getBytes(&bytes, length: input.length) var hexString = "" for byte in bytes { hexString += String(format:"%02x", UInt8(byte)) } return hexString } } 

A propósito, você precisa de um Bridging Header que importe o CommonCrypto. Se você não tiver um, siga estas etapas:

  1. Criar novo arquivo -> arquivo de header -> Salvar como BridgingHeader
  2. Em Configurações de compilation -> Cabeçalho de ponte Objective-C -> adicionar ProjectName/BridgingHeader.h
  3. Coloque #import no seu arquivo de header

Funções que dão o SHA de NSData & String (Swift 3):

 func sha256(_ data: Data) -> Data? { guard let res = NSMutableData(length: Int(CC_SHA256_DIGEST_LENGTH)) else { return nil } CC_SHA256((data as NSData).bytes, CC_LONG(data.count), res.mutableBytes.assumingMemoryBound(to: UInt8.self)) return res as Data } func sha256(_ str: String) -> String? { guard let data = str.data(using: String.Encoding.utf8), let shaData = sha256(data) else { return nil } let rc = shaData.base64EncodedString(options: []) return rc } 

Inclua no seu header de ponte:

 #import "CommonCrypto/CommonCrypto.h" 

Aqui está um método que usa a API de transformações de segurança CoreFoundation, então você não precisa nem mesmo se vincular ao CommonCrypto. Por alguma razão, em 10.10 / Xcode 7, linkar para CommmonCrypto com Swift é drama, então usei isso.

Esse método lê a partir de um NSInputStream , que você pode obter de um arquivo, ou pode criar um que leia um NSData ou pode criar streams de leitor / gravador vinculados para um processo em buffer.

 // digestType is from SecDigestTransform and would be kSecDigestSHA2, etc func digestForStream(stream : NSInputStream, digestType type : CFStringRef, length : Int) throws -> NSData { let transform = SecTransformCreateGroupTransform().takeRetainedValue() let readXform = SecTransformCreateReadTransformWithReadStream(stream as CFReadStreamRef).takeRetainedValue() var error : Unmanaged? = nil let digestXform : SecTransformRef = try { let d = SecDigestTransformCreate(type, length, &error) if d == nil { throw error!.takeUnretainedValue() } else { return d.takeRetainedValue() } }() SecTransformConnectTransforms(readXform, kSecTransformOutputAttributeName, digestXform, kSecTransformInputAttributeName, transform, &error) if let e = error { throw e.takeUnretainedValue() } if let output = SecTransformExecute(transform, &error) as? NSData { return output } else { throw error!.takeUnretainedValue() } } 

Aqui está a minha function simples de 3 linhas Swift 4 para isso usando a API Security Transforms, que faz parte do Foundation no macOS. (Infelizmente os programadores iOS não podem usar essa técnica.)

 import Foundation extension Data { public func sha256Hash() -> Data { let transform = SecDigestTransformCreate(kSecDigestSHA2, 256, nil) SecTransformSetAttribute(transform, kSecTransformInputAttributeName, self as CFTypeRef, nil) return SecTransformExecute(transform, nil) as! Data } } 

Eu prefiro usar:

 extension String { var sha256:String? { guard let stringData = self.data(using: String.Encoding.utf8) else { return nil } return digest(input: stringData as NSData).base64EncodedString(options: []) } private func digest(input : NSData) -> NSData { let digestLength = Int(CC_SHA256_DIGEST_LENGTH) var hash = [UInt8](repeating: 0, count: digestLength) CC_SHA256(input.bytes, UInt32(input.length), &hash) return NSData(bytes: hash, length: digestLength) } } 

A cadeia hasded é codificada em base64.