477 lines
17 KiB
Swift
477 lines
17 KiB
Swift
import Foundation
|
|
import GRDB
|
|
import Martin
|
|
import MartinOMEMO
|
|
|
|
final class ClientMartinOMEMO {
|
|
let credentials: Credentials
|
|
|
|
private let queue = DispatchQueue(label: "SignalPreKeyRemovalQueue")
|
|
private var preKeysMarkedForRemoval: [UInt32] = []
|
|
|
|
init(_ credentials: Credentials) {
|
|
self.credentials = credentials
|
|
_ = regenerateKeys(wipe: false)
|
|
print("ClientMartinOMEMO init")
|
|
}
|
|
|
|
deinit {
|
|
print("ClientMartinOMEMO deinit")
|
|
}
|
|
|
|
var signal: (SignalStorage, SignalContext) {
|
|
let signalStorage = SignalStorage(sessionStore: self, preKeyStore: self, signedPreKeyStore: self, identityKeyStore: self, senderKeyStore: self)
|
|
// swiftlint:disable:next force_unwrapping
|
|
let signalContext = SignalContext(withStorage: signalStorage)!
|
|
signalStorage.setup(withContext: signalContext)
|
|
return (signalStorage, signalContext)
|
|
}
|
|
|
|
private func regenerateKeys(wipe: Bool = false) -> Bool {
|
|
if wipe {
|
|
OMEMOSession.wipe(account: credentials.bareJid)
|
|
OMEMOPreKey.wipe(account: credentials.bareJid)
|
|
OMEMOSignedPreKey.wipe(account: credentials.bareJid)
|
|
OMEMOIdentity.wipe(account: credentials.bareJid)
|
|
}
|
|
|
|
let hasKeyPair = keyPair() != nil
|
|
if wipe || localRegistrationId() == 0 || !hasKeyPair {
|
|
// let regId: UInt32 = signalContext.generateRegistrationId()
|
|
// AccountSettings.omemoRegistrationId(for: context!.sessionObject.userBareJid!, value: regId)
|
|
//
|
|
// let keyPair = SignalIdentityKeyPair.generateKeyPair(context: signalContext)
|
|
// if !identityKeyStore.save(identity: SignalAddress(name: context!.sessionObject.userBareJid!.stringValue, deviceId: Int32(identityKeyStore.localRegistrationId())), key: keyPair) {}
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
|
|
// MARK: - Session
|
|
extension ClientMartinOMEMO: SignalSessionStoreProtocol {
|
|
func sessionRecord(forAddress address: MartinOMEMO.SignalAddress) -> Data? {
|
|
if let key = OMEMOSession.keyFor(account: credentials.bareJid, name: address.name, deviceId: address.deviceId) {
|
|
return Data(base64Encoded: key)
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func allDevices(for name: String, activeAndTrusted: Bool) -> [Int32] {
|
|
activeAndTrusted ?
|
|
OMEMOSession.trustedDevicesIdsFor(account: credentials.bareJid, name: name) :
|
|
OMEMOSession.devicesIdsFor(account: credentials.bareJid, name: name)
|
|
}
|
|
|
|
func storeSessionRecord(_ data: Data, forAddress: MartinOMEMO.SignalAddress) -> Bool {
|
|
do {
|
|
try Database.shared.dbQueue.write { db in
|
|
try OMEMOSession(
|
|
account: credentials.bareJid,
|
|
name: forAddress.name,
|
|
deviceId: Int(forAddress.deviceId),
|
|
key: data.base64EncodedString()
|
|
)
|
|
.insert(db)
|
|
}
|
|
return true
|
|
} catch {
|
|
logIt(.error, "Error storing session info: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func containsSessionRecord(forAddress: MartinOMEMO.SignalAddress) -> Bool {
|
|
OMEMOSession.keyFor(account: credentials.bareJid, name: forAddress.name, deviceId: forAddress.deviceId) != nil
|
|
}
|
|
|
|
func deleteSessionRecord(forAddress: MartinOMEMO.SignalAddress) -> Bool {
|
|
do {
|
|
_ = try Database.shared.dbQueue.write { db in
|
|
try OMEMOSession
|
|
.filter(Column("account") == credentials.bareJid)
|
|
.filter(Column("name") == forAddress.name)
|
|
.filter(Column("deviceId") == forAddress.deviceId)
|
|
.deleteAll(db)
|
|
}
|
|
return true
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func deleteAllSessions(for name: String) -> Bool {
|
|
do {
|
|
_ = try Database.shared.dbQueue.write { db in
|
|
try OMEMOSession
|
|
.filter(Column("account") == credentials.bareJid)
|
|
.filter(Column("name") == name)
|
|
.deleteAll(db)
|
|
}
|
|
return true
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func sessionsWipe() {
|
|
do {
|
|
_ = try Database.shared.dbQueue.write { db in
|
|
try OMEMOSession
|
|
.filter(Column("account") == credentials.bareJid)
|
|
.deleteAll(db)
|
|
}
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Identity
|
|
extension ClientMartinOMEMO: SignalIdentityKeyStoreProtocol {
|
|
func keyPair() -> (any MartinOMEMO.SignalIdentityKeyPairProtocol)? {
|
|
// guard let deviceId = localRegistrationId(forAccount: account) else {
|
|
// return nil
|
|
// }
|
|
//
|
|
// guard
|
|
// let data = try! Database.main.reader({ database in
|
|
// try database.select(query: .omemoKeyPairForAccount, params: ["account": account, "name": account.stringValue, "deviceId": deviceId]).mapFirst { $0.data(for: "key") }
|
|
// })
|
|
// else {
|
|
// return nil
|
|
// }
|
|
//
|
|
// return SignalIdentityKeyPair(fromKeyPairData: data)
|
|
nil
|
|
}
|
|
|
|
func localRegistrationId() -> UInt32 {
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
0
|
|
}
|
|
|
|
func save(identity: MartinOMEMO.SignalAddress, key: (any MartinOMEMO.SignalIdentityKeyProtocol)?) -> Bool {
|
|
print(identity, key)
|
|
return false
|
|
}
|
|
|
|
func save(identity: MartinOMEMO.SignalAddress, publicKeyData: Data?) -> Bool {
|
|
print(identity, publicKeyData)
|
|
return false
|
|
}
|
|
|
|
func isTrusted(identity _: MartinOMEMO.SignalAddress, key _: (any MartinOMEMO.SignalIdentityKeyProtocol)?) -> Bool {
|
|
true
|
|
}
|
|
|
|
func isTrusted(identity _: MartinOMEMO.SignalAddress, publicKeyData _: Data?) -> Bool {
|
|
true
|
|
}
|
|
|
|
func setStatus(_ status: MartinOMEMO.IdentityStatus, forIdentity: MartinOMEMO.SignalAddress) -> Bool {
|
|
print(status, forIdentity)
|
|
return false
|
|
}
|
|
|
|
func setStatus(active: Bool, forIdentity: MartinOMEMO.SignalAddress) -> Bool {
|
|
print(active, forIdentity)
|
|
return false
|
|
}
|
|
|
|
func identities(forName name: String) -> [MartinOMEMO.Identity] {
|
|
do {
|
|
return try Database.shared.dbQueue.read { db in
|
|
try Row.fetchAll(
|
|
db,
|
|
sql: "SELECT * FROM omemo_identities WHERE account = :account AND name = :name",
|
|
arguments: ["account": credentials.bareJid, "name": name]
|
|
)
|
|
}.compactMap { row in
|
|
guard
|
|
let fingerprint = row["fingerprint"] as? String,
|
|
let statusInt = row["status"] as? Int,
|
|
let status = MartinOMEMO.IdentityStatus(rawValue: statusInt),
|
|
let deviceId = row["device_id"] as? Int32,
|
|
let own = row["own"] as? Int,
|
|
let key = row["key"] as? Data
|
|
else {
|
|
return nil
|
|
}
|
|
return MartinOMEMO.Identity(address: MartinOMEMO.SignalAddress(name: name, deviceId: deviceId), status: status, fingerprint: fingerprint, key: key, own: own > 0)
|
|
}
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return []
|
|
}
|
|
}
|
|
|
|
func identityFingerprint(forAddress address: MartinOMEMO.SignalAddress) -> String? {
|
|
do {
|
|
let data = try Database.shared.dbQueue.read { db in
|
|
try Row.fetchOne(
|
|
db,
|
|
sql: "SELECT fingerprint FROM omemo_identities WHERE account = :account AND name = :name AND device_id = :deviceId",
|
|
arguments: ["account": credentials.bareJid, "name": address.name, "deviceId": address.deviceId]
|
|
)
|
|
}
|
|
return data?["fingerprint"]
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - PreKey
|
|
extension ClientMartinOMEMO: SignalPreKeyStoreProtocol {
|
|
func currentPreKeyId() -> UInt32 {
|
|
do {
|
|
let data = try Database.shared.dbQueue.read { db in
|
|
try Row.fetchOne(
|
|
db,
|
|
sql: "SELECT max(id) FROM omemo_pre_keys WHERE account = :account",
|
|
arguments: ["account": credentials.bareJid]
|
|
)
|
|
}
|
|
return data?["id"] ?? 0
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func loadPreKey(withId: UInt32) -> Data? {
|
|
do {
|
|
let data = try Database.shared.dbQueue.read { db in
|
|
try Row.fetchOne(
|
|
db,
|
|
sql: "SELECT key FROM omemo_pre_keys WHERE account = :account AND id = :id",
|
|
arguments: ["account": credentials.bareJid, "id": withId]
|
|
)
|
|
}
|
|
return data?["key"]
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func storePreKey(_ data: Data, withId: UInt32) -> Bool {
|
|
do {
|
|
try Database.shared.dbQueue.write { db in
|
|
try db.execute(
|
|
sql: "INSERT INTO omemo_pre_keys (account, id, key) VALUES (:account, :id, :key)",
|
|
arguments: ["account": credentials.bareJid, "id": withId, "key": data]
|
|
)
|
|
}
|
|
return true
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func containsPreKey(withId: UInt32) -> Bool {
|
|
do {
|
|
let rec = try Database.shared.dbQueue.read { db in
|
|
try Row.fetchOne(
|
|
db,
|
|
sql: "SELECT key FROM omemo_pre_keys WHERE account = :account AND id = :id",
|
|
arguments: ["account": credentials.bareJid, "id": withId]
|
|
)
|
|
}
|
|
return rec != nil
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func deletePreKey(withId: UInt32) -> Bool {
|
|
queue.async {
|
|
print("queueing prekey with id \(withId) for removal..")
|
|
self.preKeysMarkedForRemoval.append(withId)
|
|
}
|
|
return true
|
|
}
|
|
|
|
// TODO: Check logic of this function carefully!!!
|
|
func flushDeletedPreKeys() -> Bool {
|
|
false
|
|
// !queue.sync { () -> [UInt32] in
|
|
// defer {
|
|
// preKeysMarkedForRemoval.removeAll()
|
|
// }
|
|
// print("removing queued prekeys: \(preKeysMarkedForRemoval)")
|
|
// do {
|
|
// Database.shared.dbQueue.write { db in
|
|
// try db.execute(
|
|
// sql: "DETLETE FROM omemo_pre_keys WHERE account = :account AND id IN (:ids)",
|
|
// arguments: ["account": credentials.bareJid, "ids": preKeysMarkedForRemoval]
|
|
// )
|
|
// }
|
|
// } catch {
|
|
// logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
// return [0]
|
|
// }
|
|
//
|
|
// // return preKeysMarkedForRemoval.filter { id in DBOMEMOStore.instance.deletePreKey(forAccount: context!.sessionObject.userBareJid!, withId: id) }
|
|
// }.isEmpty
|
|
//
|
|
//
|
|
//
|
|
// do {
|
|
// try Database.shared.dbQueue.write { db in
|
|
// try db.execute(
|
|
// sql: """
|
|
// DELETE FROM omemo_pre_keys
|
|
// WHERE account = :account
|
|
// AND id IN (
|
|
// SELECT id
|
|
// FROM omemo_pre_keys
|
|
// WHERE account = :account
|
|
// AND id NOT IN (
|
|
// SELECT id
|
|
// FROM omemo_pre_keys
|
|
// WHERE account = :account
|
|
// ORDER BY id DESC
|
|
// LIMIT 100)
|
|
// )
|
|
// """,
|
|
// arguments: ["account": credentials.bareJid]
|
|
// )
|
|
// }
|
|
// return true
|
|
// } catch {
|
|
// logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
// return false
|
|
// }
|
|
}
|
|
|
|
func preKeysWipe() {
|
|
do {
|
|
try Database.shared.dbQueue.write { db in
|
|
try db.execute(
|
|
sql: "DELETE FROM omemo_pre_keys WHERE account = :account",
|
|
arguments: ["account": credentials.bareJid]
|
|
)
|
|
}
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - SignedPreKey
|
|
extension ClientMartinOMEMO: SignalSignedPreKeyStoreProtocol {
|
|
func countSignedPreKeys() -> Int {
|
|
do {
|
|
let data = try Database.shared.dbQueue.read { db in
|
|
try Row.fetchOne(
|
|
db,
|
|
sql: "SELECT count(1) FROM omemo_signed_pre_keys WHERE account = :account",
|
|
arguments: ["account": credentials.bareJid]
|
|
)
|
|
}
|
|
return data?["count(1)"] ?? 0
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func loadSignedPreKey(withId: UInt32) -> Data? {
|
|
do {
|
|
let data = try Database.shared.dbQueue.read { db in
|
|
try Row.fetchOne(
|
|
db,
|
|
sql: "SELECT key FROM omemo_signed_pre_keys WHERE account = :account AND id = :id",
|
|
arguments: ["account": credentials.bareJid, "id": withId]
|
|
)
|
|
}
|
|
return data?["key"]
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func storeSignedPreKey(_ data: Data, withId: UInt32) -> Bool {
|
|
do {
|
|
try Database.shared.dbQueue.write { db in
|
|
try db.execute(
|
|
sql: "INSERT INTO omemo_signed_pre_keys (account, id, key) VALUES (:account, :id, :key)",
|
|
arguments: ["account": credentials.bareJid, "id": withId, "key": data]
|
|
)
|
|
}
|
|
return true
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func containsSignedPreKey(withId: UInt32) -> Bool {
|
|
do {
|
|
let rec = try Database.shared.dbQueue.read { db in
|
|
try Row.fetchOne(
|
|
db,
|
|
sql: "SELECT key FROM omemo_signed_pre_keys WHERE account = :account AND id = :id",
|
|
arguments: ["account": credentials.bareJid, "id": withId]
|
|
)
|
|
}
|
|
return rec != nil
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func deleteSignedPreKey(withId: UInt32) -> Bool {
|
|
do {
|
|
try Database.shared.dbQueue.write { db in
|
|
try db.execute(
|
|
sql: "DELETE FROM omemo_signed_pre_keys WHERE account = :account AND id = :id",
|
|
arguments: ["account": credentials.bareJid, "id": withId]
|
|
)
|
|
}
|
|
return true
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
return false
|
|
}
|
|
}
|
|
|
|
func wipeSignedPreKeys() {
|
|
do {
|
|
try Database.shared.dbQueue.write { db in
|
|
try db.execute(
|
|
sql: "DELETE FROM omemo_signed_pre_keys WHERE account = :account",
|
|
arguments: ["account": credentials.bareJid]
|
|
)
|
|
}
|
|
} catch {
|
|
logIt(.error, "Error fetching chats: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - SenderKey
|
|
extension ClientMartinOMEMO: SignalSenderKeyStoreProtocol {
|
|
func storeSenderKey(_: Data, address _: MartinOMEMO.SignalAddress?, groupId _: String?) -> Bool {
|
|
false
|
|
}
|
|
|
|
func loadSenderKey(forAddress _: MartinOMEMO.SignalAddress?, groupId _: String?) -> Data? {
|
|
nil
|
|
}
|
|
}
|