oxen-io
/
session-ios
mirror of https://github.com/oxen-io/session-ios.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Added logic to update cached expiry after config TTL extension 

Updated the UpdateExpiryResponse signature verification logic
Another couple of accessibility label/id tweaks
This commit is contained in:
Morgan Pretty 2023-03-16 14:50:14 +11:00
parent 15a0eccaf2
commit 1c7eaed8b6
4 changed files with 69 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Session/Conversations/Settings/ThreadSettingsViewModel.swift
View File

@ -306,6 +306,10 @@ class ThreadSettingsViewModel: SessionTableViewModel<ThreadSettingsViewModel.Nav
bottom: Values.largeSpacing
),
backgroundStyle: .noBackground
),
accessibility: SessionCell.Accessibility(
identifier: "Session ID",
label: threadViewModel.id
)
)
)

3
Session/Settings/SettingsViewModel.swift
View File

@ -302,7 +302,8 @@ class SettingsViewModel: SessionTableViewModel<SettingsViewModel.NavButton, Sett
backgroundStyle: .noBackground
),
accessibility: SessionCell.Accessibility(
label: "Session ID"
identifier: "Session ID",
label: profile.id
)
),
SessionCell.Info(

41
SessionSnodeKit/Models/UpdateExpiryResponse.swift
View File

@ -12,10 +12,12 @@ public extension UpdateExpiryResponse {
class SwarmItem: SnodeSwarmItem {
private enum CodingKeys: String, CodingKey {
case updated
case unchanged
case expiry
}
public let updated: [String]
public let unchanged: [String: UInt64]
public let expiry: UInt64?
// MARK: - Initialization
@ -24,6 +26,7 @@ public extension UpdateExpiryResponse {
let container: KeyedDecodingContainer<CodingKeys> = try decoder.container(keyedBy: CodingKeys.self)
updated = ((try? container.decode([String].self, forKey: .updated)) ?? [])
unchanged = ((try? container.decode([String: UInt64].self, forKey: .unchanged)) ?? [:])
expiry = try? container.decode(UInt64.self, forKey: .expiry)
try super.init(from: decoder)
@ -35,7 +38,7 @@ public extension UpdateExpiryResponse {
extension UpdateExpiryResponse: ValidatableResponse {
typealias ValidationData = [String]
typealias ValidationResponse = (hashes: [String], expiry: UInt64)
typealias ValidationResponse = [(hash: String, expiry: UInt64)]
/// All responses in the swarm must be valid
internal static var requiredSuccessfulResponses: Int { -1 }
@ -44,14 +47,15 @@ extension UpdateExpiryResponse: ValidatableResponse {
sodium: Sodium,
userX25519PublicKey: String,
validationData: [String]
) throws -> [String: (hashes: [String], expiry: UInt64)] {
let validationMap: [String: (hashes: [String], expiry: UInt64)] = try swarm.reduce(into: [:]) { result, next in
) throws -> [String: [(hash: String, expiry: UInt64)]] {
let validationMap: [String: [(hash: String, expiry: UInt64)]] = try swarm.reduce(into: [:]) { result, next in
guard
!next.value.failed,
let appliedExpiry: UInt64 = next.value.expiry,
let signatureBase64: String = next.value.signatureBase64,
let encodedSignature: Data = Data(base64Encoded: signatureBase64)
else {
result[next.key] = ([], 0)
result[next.key] = []
if let reason: String = next.value.reason, let statusCode: Int = next.value.code {
SNLog("Couldn't update expiry from: \(next.key) due to error: \(reason) (\(statusCode)).")
@ -63,13 +67,24 @@ extension UpdateExpiryResponse: ValidatableResponse {
}
/// Signature of
/// `( PUBKEY_HEX || EXPIRY || RMSG[0] || ... || RMSG[N] || UMSG[0] || ... || UMSG[M] )`
/// where RMSG are the requested expiry hashes and UMSG are the actual updated hashes. The signature uses
/// the node's ed25519 pubkey.
/// `( PUBKEY_HEX || EXPIRY || RMSGs... || UMSGs... || CMSG_EXPs... )`
/// where RMSGs are the requested expiry hashes, UMSGs are the actual updated hashes, and
/// CMSG_EXPs are (HASH || EXPIRY) values, ascii-sorted by hash, for the unchanged message
/// hashes included in the "unchanged" field. The signature uses the node's ed25519 pubkey.
///
/// **Note:** If `updated` is empty then the `expiry` value will match the value that was
/// included in the original request
let verificationBytes: [UInt8] = userX25519PublicKey.bytes
.appending(contentsOf: "\(String(describing: next.value.expiry))".data(using: .ascii)?.bytes)
.appending(contentsOf: "\(appliedExpiry)".data(using: .ascii)?.bytes)
.appending(contentsOf: validationData.joined().bytes)
.appending(contentsOf: next.value.updated.joined().bytes)
.appending(contentsOf: next.value.updated.sorted().joined().bytes)
.appending(contentsOf: next.value.unchanged
.sorted(by: { lhs, rhs in lhs.key < rhs.key })
.reduce(into: [UInt8]()) { result, nextUnchanged in
result.append(contentsOf: nextUnchanged.key.bytes)
result.append(contentsOf: "\(nextUnchanged.value)".data(using: .ascii)?.bytes ?? [])
}
)
let isValid: Bool = sodium.sign.verify(
message: verificationBytes,
publicKey: Data(hex: next.key).bytes,
@ -79,11 +94,9 @@ extension UpdateExpiryResponse: ValidatableResponse {
// If the update signature is invalid then we want to fail here
guard isValid else { throw SnodeAPIError.signatureVerificationFailed }
// If we didn't get an `expiry` value from the snode then don't bother adding it to the result
// as it's not valid data
guard let expiry: UInt64 = next.value.expiry else { return }
result[next.key] = (hashes: next.value.updated, expiry: expiry)
result[next.key] = next.value.updated
.map { ($0, appliedExpiry) }
.appending(contentsOf: next.value.unchanged.map { ($0.key, $0.value) })
}
return try Self.validated(map: validationMap, totalResponseCount: swarm.count)

40
SessionSnodeKit/Networking/SnodeAPI.swift
View File

@ -409,10 +409,42 @@ public final class SnodeAPI {
using: dependencies
)
.decoded(as: responseTypes, using: dependencies)
.map { batchResponse -> [SnodeAPI.Namespace: (info: ResponseInfoType, data: (messages: [SnodeReceivedMessage], lastHash: String?)?)] in
.map { (batchResponse: HTTP.BatchResponse) -> [SnodeAPI.Namespace: (info: ResponseInfoType, data: (messages: [SnodeReceivedMessage], lastHash: String?)?)] in
let messageResponses: [HTTP.BatchSubResponse<GetMessagesResponse>] = batchResponse.responses
.compactMap { $0 as? HTTP.BatchSubResponse<GetMessagesResponse> }
/// Since we have extended the TTL for a number of messages we need to make sure we update the local
/// `SnodeReceivedMessageInfo.expirationDateMs` values so we don't end up deleting them
/// incorrectly before they actually expire on the swarm
if
!refreshingConfigHashes.isEmpty,
let refreshTTLSubReponse: HTTP.BatchSubResponse<UpdateExpiryResponse> = batchResponse
.responses
.first(where: { $0 is HTTP.BatchSubResponse<UpdateExpiryResponse> })
.asType(HTTP.BatchSubResponse<UpdateExpiryResponse>.self),
let refreshTTLResponse: UpdateExpiryResponse = refreshTTLSubReponse.body,
let validResults: [String: [(hash: String, expiry: UInt64)]] = try? refreshTTLResponse.validResultMap(
sodium: sodium.wrappedValue,
userX25519PublicKey: getUserHexEncodedPublicKey(),
validationData: refreshingConfigHashes
),
let groupedExpiryResult: [UInt64: [String]] = validResults[snode.ed25519PublicKey]?
.grouped(by: \.expiry)
.mapValues({ groupedResults in groupedResults.map { $0.hash } })
{
Storage.shared.writeAsync { db in
try groupedExpiryResult.forEach { updatedExpiry, hashes in
try SnodeReceivedMessageInfo
.filter(hashes.contains(SnodeReceivedMessageInfo.Columns.hash))
.updateAll(
db,
SnodeReceivedMessageInfo.Columns.expirationDateMs
.set(to: updatedExpiry)
)
}
}
}
return zip(namespaces, messageResponses)
.reduce(into: [:]) { result, next in
guard let messageResponse: GetMessagesResponse = next.1.body else { return }
@ -720,7 +752,7 @@ public final class SnodeAPI {
serverHashes: [String],
updatedExpiryMs: UInt64,
using dependencies: SSKDependencies = SSKDependencies()
) -> AnyPublisher<[String: (hashes: [String], expiry: UInt64)], Error> {
) -> AnyPublisher<[String: [(hash: String, expiry: UInt64)]], Error> {
guard let userED25519KeyPair = Identity.fetchUserEd25519KeyPair() else {
return Fail(error: SnodeAPIError.noKeyPair)
.eraseToAnyPublisher()
@ -728,7 +760,7 @@ public final class SnodeAPI {
return getSwarm(for: publicKey)
.subscribe(on: Threading.workQueue)
.tryFlatMap { swarm -> AnyPublisher<[String: (hashes: [String], expiry: UInt64)], Error> in
.tryFlatMap { swarm -> AnyPublisher<[String: [(hash: String, expiry: UInt64)]], Error> in
guard let snode: Snode = swarm.randomElement() else { throw SnodeAPIError.generic }
return SnodeAPI
@ -749,7 +781,7 @@ public final class SnodeAPI {
using: dependencies
)
.decoded(as: UpdateExpiryResponse.self, using: dependencies)
.tryMap { _, response -> [String: (hashes: [String], expiry: UInt64)] in
.tryMap { _, response -> [String: [(hash: String, expiry: UInt64)]] in
try response.validResultMap(
sodium: sodium.wrappedValue,
userX25519PublicKey: getUserHexEncodedPublicKey(),