Je suis en train d'utiliser CommonCrypto aux mots de passe de hachage à l'aide PBKDF2 à Swift 2 en raison de sa haute performance et aussi parce qu'elle est open sourceComment utiliser CommonCrypto pour PBKDF2 à Swift 2
je l'ai déjà réussi à CommonCrypto travaillant dans Swift en utilisant des cartes de modules, mais quelqu'un peut-il me dire le code pour le hachage avec PBKDF2 dans Swift 2 en utilisant CommonCrypto
Toute aide est très appréciée :) Merci!
func pbkdf2(hash :CCPBKDFAlgorithm, password: String, salt: [UInt8], keyCount: Int, rounds: UInt32!) -> [UInt8]! {
let derivedKey = [UInt8](count:keyCount, repeatedValue:0)
let passwordData = password.dataUsingEncoding(NSUTF8StringEncoding)!
let derivationStatus = CCKeyDerivationPBKDF(
CCPBKDFAlgorithm(kCCPBKDF2),
UnsafePointer<Int8>(passwordData.bytes), passwordData.length,
UnsafePointer<UInt8>(salt), salt.count,
CCPseudoRandomAlgorithm(hash),
rounds,
UnsafeMutablePointer<UInt8>(derivedKey),
derivedKey.count)
if (derivationStatus != 0) {
print("Error: \(derivationStatus)")
return nil;
}
return derivedKey
}
hash est le type de hachage telle que kCCPRFHmacAlgSHA1, kCCPRFHmacAlgSHA256, kCCPRFHmacAlgSHA512.
Mot de passe Basé Dérivation Key 2 (Swift 3+)
Mot de passe Dérivation clé base peut être utilisé aussi bien pour obtenir une clé de chiffrement de texte de mot de passe et enregistrer un mot de passe à des fins d'authentification.
Il existe plusieurs algorithmes de hachage pouvant être utilisés, notamment SHA1, SHA256 et SHA512, qui sont fournis par cet exemple de code. Le paramètre rounds est utilisé pour ralentir le calcul de sorte qu'un attaquant doive passer beaucoup de temps à chaque tentative. Les valeurs de retard typiques tombent entre 100 ms et 500 ms, des valeurs plus courtes peuvent être utilisées si les performances sont inacceptables.
Cet exemple nécessite commune Crypto
Il est nécessaire d'avoir un en-tête de transition du projet:
#import <CommonCrypto/CommonCrypto.h>
Ajouter le Security.framework au projet.
Paramètres:
password password String
salt salt Data
keyByteCount number of key bytes to generate
rounds Iteration rounds
returns Derived key
func pbkdf2SHA1(password: String, salt: Data, keyByteCount: Int, rounds: Int) -> Data? {
return pbkdf2(hash:CCPBKDFAlgorithm(kCCPRFHmacAlgSHA1), password:password, salt:salt, keyByteCount:keyByteCount, rounds:rounds)
}
func pbkdf2SHA256(password: String, salt: Data, keyByteCount: Int, rounds: Int) -> Data? {
return pbkdf2(hash:CCPBKDFAlgorithm(kCCPRFHmacAlgSHA256), password:password, salt:salt, keyByteCount:keyByteCount, rounds:rounds)
}
func pbkdf2SHA512(password: String, salt: Data, keyByteCount: Int, rounds: Int) -> Data? {
return pbkdf2(hash:CCPBKDFAlgorithm(kCCPRFHmacAlgSHA512), password:password, salt:salt, keyByteCount:keyByteCount, rounds:rounds)
}
func pbkdf2(hash :CCPBKDFAlgorithm, password: String, salt: Data, keyByteCount: Int, rounds: Int) -> Data? {
let passwordData = password.data(using:String.Encoding.utf8)!
var derivedKeyData = Data(repeating:0, count:keyByteCount)
let derivationStatus = derivedKeyData.withUnsafeMutableBytes {derivedKeyBytes in
salt.withUnsafeBytes { saltBytes in
CCKeyDerivationPBKDF(
CCPBKDFAlgorithm(kCCPBKDF2),
password, passwordData.count,
saltBytes, salt.count,
hash,
UInt32(rounds),
derivedKeyBytes, derivedKeyData.count)
}
}
if (derivationStatus != 0) {
print("Error: \(derivationStatus)")
return nil;
}
return derivedKeyData
}
Exemple d'utilisation:
let password = "password"
//let salt = "saltData".data(using: String.Encoding.utf8)!
let salt = Data(bytes: [0x73, 0x61, 0x6c, 0x74, 0x44, 0x61, 0x74, 0x61])
let keyByteCount = 16
let rounds = 100000
let derivedKey = pbkdf2SHA1(password:password, salt:salt, keyByteCount:keyByteCount, rounds:rounds)
print("derivedKey (SHA1): \(derivedKey! as NSData)")
Résultat:
derivedKey (SHA1): <6b9d4fa3 0385d128 f6d196ee 3f1d6dbf>
Mot de passe Sur la base d'étalonnage de Dérivation clé
Cet exemple nécessite commune Crypto Il est nécessaire d'avoir un en-tête de transition du projet:
#import <CommonCrypto/CommonCrypto.h>
Ajouter le Security.framework au projet.
Déterminer le nombre de PRF arrondit à utiliser pour un retard spécifique sur la plate-forme actuelle.
Plusieurs paramètres ont par défaut des valeurs représentatives qui ne devraient pas affecter matériellement le nombre de tours.
password Sample password.
salt Sample salt.
msec Targeted duration we want to achieve for a key derivation.
returns The number of iterations to use for the desired processing time.
Mot de passe basé sur une clé Dérivation d'étalonnage (Swift 3)
func pbkdf2SHA1Calibrate(password: String, salt: Data, msec: Int) -> UInt32 {
let actualRoundCount: UInt32 = CCCalibratePBKDF(
CCPBKDFAlgorithm(kCCPBKDF2),
password.utf8.count,
salt.count,
CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA1),
kCCKeySizeAES256,
UInt32(msec));
return actualRoundCount
}
Exemple d'utilisation:
let saltData = Data(bytes: [0x73, 0x61, 0x6c, 0x74, 0x44, 0x61, 0x74, 0x61])
let passwordString = "password"
let delayMsec = 100
let rounds = pbkdf2SHA1Calibrate(password:passwordString, salt:saltData, msec:delayMsec)
print("For \(delayMsec) msec delay, rounds: \(rounds)")
Résultat:
For 100 msec delay, rounds: 93457
Mot de passe basé sur une clé Dérivation d'étalonnage (Swift 2,3)
func pbkdf2SHA1Calibrate(password:String, salt:[UInt8], msec:Int) -> UInt32 {
let actualRoundCount: UInt32 = CCCalibratePBKDF(
CCPBKDFAlgorithm(kCCPBKDF2),
password.utf8.count,
salt.count,
CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA1),
kCCKeySizeAES256,
UInt32(msec));
return actualRoundCount
}
Exemple d'utilisation:
let saltData = [UInt8]([0x73, 0x61, 0x6c, 0x74, 0x44, 0x61, 0x74, 0x61])
let passwordString = "password"
let delayMsec = 100
let rounds = pbkdf2SHA1Calibrate(passwordString, salt:saltData, msec:delayMsec)
print("For \(delayMsec) msec delay, rounds: \(rounds)")