Início / coding / Perguntas / 78791000
Accepted
Andrew_STOP_RU_WAR_IN_UA
Asked: 2024-07-25 07:52:25 +0800 CST

Como gerar SymmetricKey a partir de senha

  • 772

Eu tenho o seguinte código:

public extension SymmetricKey {
    init?(base64Encoded base64EncodedKeyString: String) {
        guard let keyData = Data(base64Encoded: base64EncodedKeyString) else { return nil }
        self.init(data: keyData)
    }
    
    var base64: String {
        self.withUnsafeBytes { body in
            Data(body).base64EncodedString()
        }
    }
    
    init?(pass: String) {
        guard let passHash = passToHash(pass: pass) else { return nil }
        
        self.init(base64Encoded: passHash)
    }
}

fileprivate func passToHash(pass: String) -> String? {
    guard let passData = pass.data(using: .utf8) else { return nil }
    let hashed = SHA256.hash(data: passData)
    return hashed.compactMap { String(format: "%02x", $0) }.joined()
}

o problema é que se eu tentar usar SymmetricKeyverei erro:

A operação não pôde ser concluída. (CryptoKit.CryptoKitError erro 1.)

Este erro significa tamanho de chave incorreto.

Se eu tentar comparar SymmetricKeyos gerados da maneira padrão e do meu init personalizado, verei a diferença:

5994471abb01112afcc18159f6cc74b4f511b99806da59b3caf5a9c173cacfc5 //from password
cfyk1v2dRIlVKHlpy8qBH71v4BXGSUHPUS3wLn1gzj0= //.bits256

insira a descrição da imagem aqui

O que estou fazendo de errado? Por que os hashes parecem diferentes?

swift

1 respostas

  1. Best Answer

    Primeiro, esta é uma função de derivação de chave muito insegura. Nenhum esquema sério de criptografia deveria usar isso. Para criar uma chave a partir de uma senha, você deve usar uma PBKDF (função de derivação de chave baseada em senha), como PBKDF2.

    Para fins de compatibilidade, pode ser necessário implementar esse esquema quebrado, então vou me aprofundar nisso aqui.

    As chaves são fundamentalmente dados. Você criou uma String codificada em hexadecimal e depois a codificou em Base64. Isso torna os dados resultantes duas vezes maiores do que deveriam. O que você quis dizer foi isso:

    public extension SymmetricKey {
    var base64: String {
        self.withUnsafeBytes { body in
            Data(body).base64EncodedString()
        }
    }

    // Never do this. This is incredibly insecure
    init(pass: String) {
        // This is a completely broken KDF.
        let hash = SHA256.hash(data: Data(pass.utf8)).withUnsafeBytes { ptr in
            Data(ptr)
        }
        self.init(data: hash)
    }
}

let key1 = SymmetricKey(size: .bits256).base64
// ZHpD7LwSwhOT0msWf0XOJItqUezMSLwdxcLloSMSMHs
let key2 = SymmetricKey(pass: "12345").base64
// WZRHGrsBESr8wYFZ9sx0tPURuZgG2lmzyvWpwXPKz8U

// key2 is very easy to brute-force compared to proper AES-256

    Infelizmente, o CryptoKit da Apple não inclui nenhum PBKDF adequado. É uma estrutura muito limitada que fornece primitivas apenas para alguns casos de uso muito específicos. Algumas estruturas populares que fornecem as ferramentas necessárias são CryptoSwift e IDZSwiftCommonCrypto . A abordagem mais geral é usar o CommonCryptor da Apple, mas não é particularmente divertido no Swift.

    Aqui está um exemplo, no entanto.

    public extension SymmetricKey {
    var base64: String {
        self.withUnsafeBytes { body in
            Data(body).base64EncodedString()
        }
    }

    init(password: String, salt: Data) {
        self.init(data: Self.makeKey(forPassword: password, withSalt: salt))
    }

    private static func makeKey(forPassword password: String, withSalt salt: Data) -> Data {

        let passwordArray = password.utf8.map(Int8.init)
        let saltArray = Array(salt)
        let keySize = 32

        var derivedKey = Array<UInt8>(repeating: 0, count: keySize)

        // All the crazy casting because CommonCryptor hates Swift
        let algorithm    = CCPBKDFAlgorithm(kCCPBKDF2)
        let prf          = CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA1)
        let pbkdf2Rounds = UInt32(10000)

        let result = CCCryptorStatus(
            CCKeyDerivationPBKDF(
                algorithm,
                passwordArray, passwordArray.count,
                saltArray,     saltArray.count,
                prf,           pbkdf2Rounds,
                &derivedKey,   keySize)
        )
        guard result == CCCryptorStatus(kCCSuccess) else {
            fatalError("SECURITY FAILURE: Could not derive secure password (\(result))")
        }
        return Data(derivedKey)
    }
}

    Chamar isso requer passar um sal. A escolha do sal depende um pouco do seu caso de uso. Uma situação comum é usar um salt aleatório (digamos, 16 bytes) para cada criptografia e, em seguida, passar o salt junto com os dados criptografados para que o receptor possa descriptografá-los. Aqui está uma maneira de criar esse tipo de dados aleatórios:

    func makeSalt(length: Int) -> Data {
    var data = Data(count: length)
    data.withUnsafeMutableBytes {
        SecRandomCopyBytes(kSecRandomDefault, length, $0.baseAddress!)
    }
    return data
}

    Você também pode obter funções que fazem essas coisas nas estruturas mencionadas. Muito pouco sobre como fazer criptografia em Swift é divertido.

    • 1

relate perguntas