104 lines
4.4 KiB
Swift
104 lines
4.4 KiB
Swift
import Foundation
|
|
import CryptoKit
|
|
|
|
final class Client {
|
|
|
|
init() {}
|
|
|
|
func send(_ message: Message, to url: String, port: UInt16, through route: TransmissionType, using keys: KeySet) async -> ServerResponse {
|
|
let sentTime = Date.now
|
|
let signedMessage = message.authenticate(using: keys.remote)
|
|
let response: Message
|
|
switch route {
|
|
case .throughServer:
|
|
response = await send(signedMessage, toServerUrl: url, authenticateWith: keys.server, verifyUsing: keys.device)
|
|
|
|
case .overLocalWifi:
|
|
response = await send(signedMessage, toLocalDevice: url, port: port, verifyUsing: keys.device)
|
|
}
|
|
let receivedTime = Date.now
|
|
// Create best guess for creation of challenge.
|
|
let roundTripTime = receivedTime.timeIntervalSince(sentTime)
|
|
let serverChallenge = ServerChallenge(
|
|
creationDate: sentTime.addingTimeInterval(roundTripTime / 2),
|
|
message: response)
|
|
|
|
// Validate message content
|
|
guard response.result == .messageAccepted else {
|
|
print("Failure: \(response)")
|
|
return (response, nil)
|
|
}
|
|
|
|
guard response.clientChallenge == message.clientChallenge else {
|
|
print("Invalid client challenge: \(response)")
|
|
return (response.with(result: .invalidClientChallengeFromDevice), nil)
|
|
}
|
|
return (response, serverChallenge)
|
|
}
|
|
|
|
private func send(_ message: SignedMessage, toLocalDevice host: String, port: UInt16, verifyUsing deviceKey: SymmetricKey) async -> Message {
|
|
let client = UDPClient(host: host, port: port)
|
|
let response: Data? = await withCheckedContinuation { continuation in
|
|
client.begin()
|
|
client.send(message: message.encoded) { res in
|
|
continuation.resume(returning: res)
|
|
}
|
|
}
|
|
guard let data = response else {
|
|
return message.message.with(result: .deviceNotConnected)
|
|
}
|
|
return decode(data, inResponseTo: message.message, verifyUsing: deviceKey)
|
|
}
|
|
|
|
private func send(_ message: SignedMessage, toServerUrl server: String, authenticateWith authToken: Data, verifyUsing deviceKey: SymmetricKey) async -> Message {
|
|
guard let url = URL(string: server)?.appendingPathComponent(SesameRoute.postMessage.rawValue) else {
|
|
return message.message.with(result: .serverUrlInvalid)
|
|
}
|
|
|
|
var request = URLRequest(url: url)
|
|
request.httpBody = message.encoded
|
|
request.httpMethod = "POST"
|
|
request.timeoutInterval = 10
|
|
request.addValue(authToken.hexEncoded, forHTTPHeaderField: SesameHeader.authenticationHeader)
|
|
return await perform(request, inResponseTo: message.message, verifyUsing: deviceKey)
|
|
}
|
|
|
|
private func perform(_ request: URLRequest, inResponseTo message: Message, verifyUsing deviceKey: SymmetricKey) async -> Message {
|
|
let (response, responseData) = await fulfill(request)
|
|
guard response == .messageAccepted, let data = responseData else {
|
|
return message.with(result: response)
|
|
}
|
|
return decode(data, inResponseTo: message, verifyUsing: deviceKey)
|
|
}
|
|
|
|
private func decode(_ data: Data, inResponseTo message: Message, verifyUsing deviceKey: SymmetricKey) -> Message {
|
|
guard data.count == SignedMessage.size else {
|
|
print("[WARN] Received message with \(data.count) bytes (\(Array(data)))")
|
|
return message.with(result: .invalidMessageSizeFromDevice)
|
|
}
|
|
let decodedMessage: SignedMessage
|
|
do {
|
|
decodedMessage = try SignedMessage(decodeFrom: data)
|
|
} catch {
|
|
return message.with(result: error as! MessageResult)
|
|
}
|
|
guard decodedMessage.isValid(using: deviceKey) else {
|
|
return message.with(result: .invalidSignatureFromDevice)
|
|
}
|
|
return decodedMessage.message
|
|
}
|
|
|
|
private func fulfill(_ request: URLRequest) async -> (response: MessageResult, data: Data?) {
|
|
do {
|
|
let (data, response) = try await URLSession.shared.data(for: request)
|
|
guard let code = (response as? HTTPURLResponse)?.statusCode else {
|
|
return (.unexpectedUrlResponseType, nil)
|
|
}
|
|
return (.init(httpCode: code), data)
|
|
} catch {
|
|
print("Request failed: \(error)")
|
|
return (.deviceTimedOut, nil)
|
|
}
|
|
}
|
|
}
|