From 044b1ef824e114f2bd3c386fdf30fc51b5b7f459 Mon Sep 17 00:00:00 2001 From: Kabir Oberai Date: Tue, 12 Nov 2024 04:20:19 -0500 Subject: [PATCH] more native crypto --- Supersign/Package.swift | 3 + .../GrandSlam/Crypto/SRPClient.swift | 99 ++++++++++++------- .../GrandSlamAuthenticateOperation.swift | 30 ++++-- 3 files changed, 85 insertions(+), 47 deletions(-) diff --git a/Supersign/Package.swift b/Supersign/Package.swift index bf055ef1..0f6de3ce 100644 --- a/Supersign/Package.swift +++ b/Supersign/Package.swift @@ -36,6 +36,7 @@ let package = Package( .package(url: "https://github.com/swift-server/async-http-client.git", from: "1.23.0"), .package(url: "https://github.com/vapor/websocket-kit.git", from: "2.15.0"), .package(url: "https://github.com/apple/swift-certificates", from: "1.0.0"), + .package(url: "https://github.com/apple/swift-crypto", from: "3.9.1"), ], targets: [ .target( @@ -55,6 +56,8 @@ let package = Package( .product(name: "SignerSupport", package: "SuperchargeCore"), .product(name: "ProtoCodable", package: "SuperchargeCore"), .product(name: "Superutils", package: "SuperchargeCore"), + .product(name: "Crypto", package: "swift-crypto"), + .product(name: "_CryptoExtras", package: "swift-crypto"), .product(name: "X509", package: "swift-certificates"), .product( name: "AsyncHTTPClient", diff --git a/Supersign/Sources/Supersign/GrandSlam/Crypto/SRPClient.swift b/Supersign/Sources/Supersign/GrandSlam/Crypto/SRPClient.swift index 53795690..3a91e87e 100644 --- a/Supersign/Sources/Supersign/GrandSlam/Crypto/SRPClient.swift +++ b/Supersign/Sources/Supersign/GrandSlam/Crypto/SRPClient.swift @@ -8,27 +8,57 @@ import Foundation import CSupersign +import Crypto -final class SRPClient { +struct SRPClient: ~Copyable { + + enum Errors: Error { + case notProcessed + } let raw = srp_client_create() deinit { srp_client_free(raw) } + private var digest = SHA256() + private var hamk: SymmetricKey? + private var clientKey: SymmetricKey? + // MARK: - Encryption & decryption - func add(string: String) { - srp_client_add_string(raw, string) + mutating func add(string: String) { + var copy = string + copy.withUTF8 { digest.update(bufferPointer: UnsafeRawBufferPointer($0)) } } - func add(data: Data) { - data.withUnsafeBytes { srp_client_add_data(raw, $0.baseAddress, $0.count) } - } - - func decrypt(cbc: Data) -> Data? { - cbc.withUnsafeBytes { buf in - guard let base = buf.baseAddress else { return nil } - return Data { srp_client_decrypt_cbc(raw, base, buf.count, &$0) } + mutating func add(data: Data) { + withUnsafeBytes(of: UInt32(data.count)) { + digest.update(bufferPointer: $0) } + digest.update(data: data) + } + + func decrypt(cbc: Data) throws -> Data { + let key = try sessionKey(name: "extra data key:") + let iv = try sessionKey(name: "extra data iv:").withUnsafeBytes { + try AES._CBC.IV(ivBytes: $0.prefix(16)) + } + return try AES._CBC.decrypt(cbc, using: key, iv: iv) + } + + private func sessionKey(name: String) throws -> SymmetricKey { + guard let clientKey else { throw Errors.notProcessed } + return SymmetricKey(data: HMAC.authenticationCode(for: Data(name.utf8), using: clientKey)) + } + + func verify(negProto: Data) -> Bool { + let hash = Data(digest.finalize()) + guard let key = try? sessionKey(name: "HMAC key:") else { return false } + let mac = SymmetricKey(data: HMAC.authenticationCode(for: hash, using: key)) + return SymmetricKey(data: negProto) == mac + } + + func verify(hamk: Data) -> Bool { + SymmetricKey(data: hamk) == self.hamk } // MARK: - SRP @@ -37,44 +67,37 @@ final class SRPClient { Data { srp_client_copy_public_key(raw, &$0) } } - func processChallenge( + mutating func processChallenge( withUsername username: String, - password: String, + passkey: Data, salt: Data, - iterations: Int, - serverPublicKey key: Data, - isS2K: Bool + serverPublicKey key: Data ) -> Data? { - salt.withUnsafeBytes { saltBuf in - key.withUnsafeBytes { keyBuf in - Data { + var outResponse: UnsafeMutableRawPointer? + var outHAMK: UnsafeMutableRawPointer? + var outClientKey: UnsafeMutableRawPointer? + let outLen = passkey.withUnsafeBytes { passkeyBuf in + salt.withUnsafeBytes { saltBuf in + key.withUnsafeBytes { keyBuf in srp_client_process_challenge( raw, - username, password, + username, + passkeyBuf.baseAddress!, passkeyBuf.count, saltBuf.baseAddress, saltBuf.count, - .init(iterations), keyBuf.baseAddress, keyBuf.count, - isS2K, - &$0 + &outHAMK, + &outClientKey, + &outResponse ) } } } - } - - func verify(hamk: Data) -> Bool { - hamk.withUnsafeBytes { - // a hash has to be non-zero sized, so a nil baseAddress is invalid - guard let base = $0.baseAddress else { return false } - return srp_client_verify_session_HAMK(raw, base, $0.count) - } - } - - func verify(negProto: Data) -> Bool { - negProto.withUnsafeBytes { - guard let base = $0.baseAddress else { return false } - return srp_client_verify_neg_proto(raw, base, $0.count) - } + guard outLen > 0, let outResponse, let outHAMK, let outClientKey else { return nil } + hamk = SymmetricKey(data: UnsafeRawBufferPointer(start: outHAMK, count: outLen)) + free(outHAMK) + clientKey = SymmetricKey(data: UnsafeRawBufferPointer(start: outClientKey, count: outLen)) + free(outClientKey) + return Data(bytesNoCopy: outResponse, count: outLen, deallocator: .free) } } diff --git a/Supersign/Sources/Supersign/GrandSlam/Operations/GrandSlamAuthenticateOperation.swift b/Supersign/Sources/Supersign/GrandSlam/Operations/GrandSlamAuthenticateOperation.swift index ea45e146..590819df 100644 --- a/Supersign/Sources/Supersign/GrandSlam/Operations/GrandSlamAuthenticateOperation.swift +++ b/Supersign/Sources/Supersign/GrandSlam/Operations/GrandSlamAuthenticateOperation.swift @@ -7,6 +7,8 @@ // import Foundation +import Crypto +import _CryptoExtras class GrandSlamAuthenticateOperation { @@ -91,15 +93,13 @@ class GrandSlamAuthenticateOperation { srpClient.add(string: "|") srpClient.add(data: completeResponse.encryptedResponse) srpClient.add(string: "|") - completeResponse.sc.map(srpClient.add(data:)) + completeResponse.sc.map { srpClient.add(data: $0) } srpClient.add(string: "|") guard srpClient.verify(hamk: completeResponse.hamk) && srpClient.verify(negProto: completeResponse.negProto) else { throw Error.internalError } - guard let rawLoginResponse = srpClient.decrypt(cbc: completeResponse.encryptedResponse) else { - throw Error.internalError - } + let rawLoginResponse = try srpClient.decrypt(cbc: completeResponse.encryptedResponse) let response = try decoder.decode(Response.self, from: rawLoginResponse) @@ -120,17 +120,29 @@ class GrandSlamAuthenticateOperation { private func authenticateStage2( initResponse: GrandSlamAuthInitRequest.Decoder.Value ) async throws -> GrandSlamLoginData { - let isS2K = initResponse.selectedProtocol == .s2k srpClient.add(string: "|") srpClient.add(string: initResponse.selectedProtocol.rawValue) + let hashedPassword = Data(SHA256.hash(data: Data(password.utf8))) + let pbkdfInput = switch initResponse.selectedProtocol { + case .s2k: + hashedPassword + case .s2k_fo: + Data(hashedPassword.map { String(format: "%02hhx", $0) }.joined(separator: "").utf8) + } + let passkey = try KDF.Insecure.PBKDF2.deriveKey( + from: pbkdfInput, + salt: initResponse.salt, + using: .sha256, + outputByteCount: SHA256.byteCount, + unsafeUncheckedRounds: initResponse.iterations + ) + let mDataRaw = srpClient.processChallenge( withUsername: username, - password: password, + passkey: passkey.withUnsafeBytes { Data($0) }, salt: initResponse.salt, - iterations: initResponse.iterations, - serverPublicKey: initResponse.serverPublicKey, - isS2K: isS2K + serverPublicKey: initResponse.serverPublicKey ) guard let m1Data = mDataRaw else { throw Error.internalError }