Skip to content

armgit / xtool

Public Imported from GitHub
0

Cross-platform Xcode replacement. Build and deploy iOS apps with SwiftPM on Linux, Windows, macOS.

more native crypto

Kabir Oberai044b1ef824e1
diff --git a/Supersign/Package.swift b/Supersign/Package.swift
index bf055ef..0f6de3c 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 5379569..3a91e87 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) }
+ mutating func add(data: Data) {
+ withUnsafeBytes(of: UInt32(data.count)) {
+ digest.update(bufferPointer: $0)
+ }
+ digest.update(data: data)
}
- 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) }
+ 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<SHA256>.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<SHA256>.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 ea45e14..590819d 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 }