added omemo2
iOS CI / Build and Test SwiftUI App (push) Canceled after 0s
Build Unsigned iOS and macOS Apps / Build Unsigned iOS IPA (push) Canceled after 0s
Build Unsigned iOS and macOS Apps / Build macOS ZIP (push) Canceled after 0s

This commit is contained in:
wt committed 2026-08-30 05:40:44 +07:00
1 parent 97e8f4bab6
commit 7db327c588
36 files changed
+5042 -114

No files matched your search

@@ -0,0 +1,40 @@
//
// Identity.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
public class Identity {
public let address: SignalAddress;
public let status: IdentityStatus;
public let fingerprint: String;
public let key: Data;
public let own: Bool;
public init(address: SignalAddress, status: IdentityStatus, fingerprint: String, key: Data, own: Bool) {
self.address = address;
self.status = status;
self.fingerprint = fingerprint;
self.key = key;
self.own = own;
}
}
@@ -0,0 +1,108 @@
//
// IdentityStatus.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
public enum IdentityStatus: Int {
case compromisedActive = -2
case compromisedInactive = -1
case undecidedActive = 0
case undecidedInactive = 1
case trustedActive = 2
case trustedInactive = 3
case verifiedActive = 4
case verifiedInactive = 5
public var trust: Trust {
switch self {
case .compromisedActive, .compromisedInactive:
return .compromised;
case .undecidedActive, .undecidedInactive:
return .undecided;
case .trustedActive, .trustedInactive:
return .trusted;
case .verifiedActive, .verifiedInactive:
return .verified;
}
}
public var isActive: Bool {
switch self {
case .compromisedActive, .undecidedActive, .trustedActive, .verifiedActive:
return true;
case .compromisedInactive, .undecidedInactive, .trustedInactive, .verifiedInactive:
return false;
}
}
public func toActive() -> IdentityStatus {
guard !self.isActive else {
return self;
}
return make(active: true, trust: self.trust);
}
public func toInactive() -> IdentityStatus {
guard self.isActive else {
return self;
}
return make(active: false, trust: self.trust);
}
public func toTrust(_ trust: Trust) -> IdentityStatus {
return make(active: isActive, trust: trust);
}
public func make(active: Bool, trust: Trust) -> IdentityStatus {
if active {
switch trust {
case .compromised:
return .compromisedActive;
case .undecided:
return .undecidedActive;
case .trusted:
return .trustedActive;
case .verified:
return .verifiedActive;
}
} else {
switch trust {
case .compromised:
return .compromisedInactive;
case .undecided:
return .undecidedInactive;
case .trusted:
return .trustedInactive;
case .verified:
return .verifiedInactive;
}
}
}
}
public enum Trust {
case compromised
case undecided
case trusted
case verified
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,82 @@
//
// SignalAddress.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
open class SignalAddress: Hashable, CustomStringConvertible {
public static func == (lhs: SignalAddress, rhs: SignalAddress) -> Bool {
return lhs.name == rhs.name && lhs.deviceId == rhs.deviceId;
}
public func hash(into hasher: inout Hasher) {
hasher.combine(name);
hasher.combine(deviceId);
}
public let name: String;
public let deviceId: Int32;
fileprivate let nameBytes: UnsafeMutablePointer<Int8>;
public let address: UnsafeMutablePointer<signal_protocol_address>;
public var description: String {
return "(name: \(name), deviceId: \(deviceId) or \(UInt32(bitPattern: deviceId))";
}
public init(name: String, deviceId: Int32) {
self.name = name;
self.deviceId = deviceId;
let rawPointer = malloc(MemoryLayout<signal_protocol_address>.size)!.assumingMemoryBound(to: signal_protocol_address.self);
rawPointer.pointee.device_id = deviceId;
let tmp = self.name.utf8CString;
self.nameBytes = tmp.withUnsafeBytes { (inBuf) -> UnsafeMutablePointer<Int8> in
let outBuf = malloc(tmp.count)!.assumingMemoryBound(to: Int8.self);
memcpy(outBuf, inBuf.baseAddress!, tmp.count);
return outBuf;
}
rawPointer.pointee.name = UnsafePointer(nameBytes);
self.address = rawPointer;
}
deinit {
free(address);
free(nameBytes);
}
public convenience init?(from: UnsafePointer<signal_protocol_address>?) {
guard let namePtr = from?.pointee.name, let name = String(validatingUTF8: namePtr), let deviceId = from?.pointee.device_id else {
return nil;
}
self.init(name: name, deviceId: deviceId);
}
public convenience init?(from: UnsafePointer<signal_protocol_address?>?) {
guard var addr = from?.pointee else {
return nil;
}
self.init(from: &addr);
}
}
@@ -0,0 +1,238 @@
//
// SignalContext.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
open class SignalContext {
public fileprivate(set) var globalContext: OpaquePointer?;
fileprivate let provider: SignalCryptoProvider = SignalCryptoProvider();
fileprivate let lock: NSRecursiveLock = NSRecursiveLock();
public let storage: SignalStorage;
public init?(withStorage: SignalStorage) {
self.storage = withStorage;
guard signal_context_create(&globalContext, SignalContext.bridge(self)) == 0 else {
return nil;
}
var provider = self.provider.provider;
signal_context_set_crypto_provider(globalContext, &provider)
signal_context_set_locking_functions(globalContext, signalLock, signalUnlock)
signal_context_set_log_function(globalContext, signalLog);
self.storage.setup(withContext: self);
}
open func generateRegistrationId() -> UInt32 {
var regId: UInt32 = 0;
let res = signal_protocol_key_helper_generate_registration_id(&regId, 1, self.globalContext!);
guard res >= 0 else {
return 0;
}
return regId;
}
open func generatePreKeys(withStartingPreKeyId preKeyId: UInt32, count: UInt32) -> [SignalPreKey] {
var head: OpaquePointer? = nil;
guard signal_protocol_key_helper_generate_pre_keys(&head, preKeyId, count, globalContext) >= 0 && head != nil else {
return [];
}
var keys: [SignalPreKey] = [];
while (head != nil) {
if let pre_key = signal_protocol_key_helper_key_list_element(head) {
keys.append(SignalPreKey(fromPreKey: pre_key));
}
head = signal_protocol_key_helper_key_list_next(head);
}
return keys;
}
open func generateSignedPreKey(withIdentity identity: SignalIdentityKeyPairProtocol, signedPreKeyId: UInt32, timestamp: Date = Date()) -> SignalSignedPreKey? {
guard let keyPair = identity.keyPairPointer else {
return nil;
}
var signed_pre_key: OpaquePointer?;
guard signal_protocol_key_helper_generate_signed_pre_key(&signed_pre_key, keyPair, signedPreKeyId, UInt64(timestamp.timeIntervalSince1970) * 1000, globalContext) >= 0 && signed_pre_key != nil else {
return nil;
}
return SignalSignedPreKey(fromSignedPreKey: signed_pre_key!);
}
static func bridge<T : AnyObject>(_ obj : T) -> UnsafeMutableRawPointer {
return Unmanaged.passUnretained(obj).toOpaque();
}
static func bridge<T : AnyObject>(_ ptr : UnsafeMutableRawPointer) -> T {
return Unmanaged<T>.fromOpaque(ptr).takeUnretainedValue();
}
static func bridge(fromPointer ptr : UnsafeMutableRawPointer) -> AnyObject {
return Unmanaged.fromOpaque(ptr).takeUnretainedValue();
}
}
fileprivate func signalLock(_ userData: UnsafeMutableRawPointer?) {
let ctx: SignalContext = SignalContext.bridge(userData!);
ctx.lock.lock();
}
fileprivate func signalUnlock(_ userData: UnsafeMutableRawPointer?) {
let ctx: SignalContext = SignalContext.bridge(userData!);
ctx.lock.unlock();
}
fileprivate func signalLog(level: CInt, message: UnsafePointer<Int8>?, len: Int, userData: UnsafeMutableRawPointer?) {
print("SignalProtocol:", level, String(validatingUTF8: message!) as Any);
}
open class SignalSignedPreKey {
fileprivate let signedPreKey: OpaquePointer;
public var preKeyId: UInt32 {
return session_signed_pre_key_get_id(signedPreKey);
}
public var timestamp: Date {
return Date(timeIntervalSince1970: TimeInterval(session_signed_pre_key_get_timestamp(signedPreKey) / 1000));
}
public var signature: Data {
let sigBytes = session_signed_pre_key_get_signature(signedPreKey);
let sigLen = session_signed_pre_key_get_signature_len(signedPreKey);
return Data(bytes: sigBytes!, count: sigLen);
}
public var serializedData: Data? {
var buf: OpaquePointer?;
guard session_signed_pre_key_serialize(&buf, signedPreKey) == 0 && buf != nil else {
return nil;
}
defer {
signal_buffer_free(buf);
}
return Data(bytes: signal_buffer_data(buf), count: signal_buffer_len(buf));
}
public var publicKeyData: Data? {
guard let keyPair = session_signed_pre_key_get_key_pair(signedPreKey) else {
return nil;
}
guard let publicKey = ec_key_pair_get_public(keyPair) else {
return nil;
}
var buf: OpaquePointer?;
guard ec_public_key_serialize(&buf, publicKey) >= 0 && buf != nil else {
return nil;
}
defer {
signal_buffer_free(buf);
}
return Data(bytes: signal_buffer_data(buf), count: signal_buffer_len(buf));
}
public init(fromSignedPreKey: OpaquePointer) {
self.signedPreKey = fromSignedPreKey;
signal_type_ref(signedPreKey);
}
public convenience init?(fromSerializedData: Data) {
guard let preKey: OpaquePointer = fromSerializedData.withUnsafeBytes({ (bytes) -> OpaquePointer? in
var tmp: OpaquePointer?;
guard session_signed_pre_key_deserialize(&tmp, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), fromSerializedData.count, nil) >= 0 else {
return nil;
}
return tmp;
}) else {
return nil;
}
self.init(fromSignedPreKey: preKey);
}
deinit {
signal_type_unref(signedPreKey);
}
}
open class SignalPreKey {
fileprivate let preKey: OpaquePointer;
public var preKeyId: UInt32 {
return session_pre_key_get_id(preKey);
}
public var serializedData: Data? {
var buf: OpaquePointer?;
guard session_pre_key_serialize(&buf, preKey) == 0 && buf != nil else {
return nil;
}
defer {
signal_buffer_free(buf);
}
return Data(bytes: signal_buffer_data(buf), count: signal_buffer_len(buf));
}
public var serializedPublicKey: Data? {
let keyPair = session_signed_pre_key_get_key_pair(preKey);
var buf: OpaquePointer?;
guard ec_public_key_serialize(&buf, ec_key_pair_get_public(keyPair)) >= 0 else {
return nil;
}
defer {
signal_buffer_free(buf);
}
return Data(bytes: signal_buffer_data(buf), count: signal_buffer_len(buf));
}
public init(fromPreKey: OpaquePointer) {
self.preKey = fromPreKey;
signal_type_ref(self.preKey);
}
public convenience init?(fromSerializedData: Data) {
guard let preKey: OpaquePointer = fromSerializedData.withUnsafeBytes({ (bytes) -> OpaquePointer? in
var tmp: OpaquePointer?;
guard session_pre_key_deserialize(&tmp, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), fromSerializedData.count, nil) >= 0 else {
return nil;
}
return tmp;
}) else {
return nil;
}
self.init(fromPreKey: preKey);
}
deinit {
signal_type_unref(preKey);
}
}
@@ -0,0 +1,175 @@
//
// SignalCryptoProvider.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import CommonCrypto
import libsignal
public class SignalCryptoProvider {
public fileprivate(set) var provider: signal_crypto_provider;
init() {
provider = signal_crypto_provider();
provider.random_func = random_func;
provider.hmac_sha256_init_func = hmac_sha256_init_func;
provider.hmac_sha256_update_func = hmac_sha256_update_func;
provider.hmac_sha256_final_func = hmac_sha256_final_func;
provider.hmac_sha256_cleanup_func = hmac_sha256_cleanup_func;
provider.sha512_digest_init_func = sha512_digest_init_func;
provider.sha512_digest_update_func = sha512_digest_update_func;
provider.sha512_digest_final_func = sha512_digest_final_func;
provider.sha512_digest_cleanup_func = sha512_digest_cleanup_func;
provider.encrypt_func = encrypt_func;
provider.decrypt_func = decrypt_func;
provider.user_data = SignalContext.bridge(self);
}
}
fileprivate func random_func(data: UnsafeMutablePointer<UInt8>?, len: Int, ctx: UnsafeMutableRawPointer?) -> CInt {
guard CCRandomGenerateBytes(data, len) == kCCSuccess else {
return SG_ERR_INVAL;
}
return SG_SUCCESS;
}
fileprivate func hmac_sha256_init_func(hmacCtx: UnsafeMutablePointer<UnsafeMutableRawPointer?>?, key: UnsafePointer<UInt8>?, keyLen: Int, ctx: UnsafeMutableRawPointer?) -> CInt {
guard hmacCtx != nil && key != nil else {
return SG_ERR_INVAL;
}
guard let ctx: UnsafeMutablePointer<CCHmacContext> = malloc(MemoryLayout<CCHmacContext>.size)?.assumingMemoryBound(to: CCHmacContext.self) else {
return SG_ERR_NOMEM;
}
CCHmacInit(ctx, CCHmacAlgorithm(kCCHmacAlgSHA256), key, keyLen);
hmacCtx!.initialize(to: ctx);
return SG_SUCCESS;
}
fileprivate func hmac_sha256_update_func(hmacCtx: UnsafeMutableRawPointer?, data: UnsafePointer<UInt8>?, dataLen: Int, ctx: UnsafeMutableRawPointer?) -> CInt {
guard hmacCtx != nil && data != nil else {
return SG_ERR_INVAL;
}
CCHmacUpdate(hmacCtx?.assumingMemoryBound(to: CCHmacContext.self), data!, dataLen);
return SG_SUCCESS;
}
fileprivate func hmac_sha256_final_func(hmacCtx: UnsafeMutableRawPointer?, output: UnsafeMutablePointer<OpaquePointer?>?, ctx: UnsafeMutableRawPointer?) -> CInt {
guard hmacCtx != nil && output != nil else {
return SG_ERR_INVAL;
}
let length = Int(CC_SHA256_DIGEST_LENGTH);
var data = Data(capacity: length);
data.withUnsafeMutableBytes({ (ptr: UnsafeMutableRawBufferPointer) -> Void in
CCHmacFinal(hmacCtx?.assumingMemoryBound(to: CCHmacContext.self), ptr.baseAddress)
return;
});
output!.initialize(to: data.withUnsafeBytes({ (ptr: UnsafeRawBufferPointer) -> OpaquePointer in
return signal_buffer_create(ptr.baseAddress?.assumingMemoryBound(to: UInt8.self), length);
}));
return SG_SUCCESS;
}
fileprivate func hmac_sha256_cleanup_func(hmacCtx: UnsafeMutableRawPointer?, ctx: UnsafeMutableRawPointer?) {
guard hmacCtx != nil else {
return;
}
free(hmacCtx!);
}
fileprivate func sha512_digest_init_func(digestCtx: UnsafeMutablePointer<UnsafeMutableRawPointer?>?, ctx: UnsafeMutableRawPointer?) -> CInt {
guard digestCtx != nil else {
return SG_ERR_INVAL;
}
guard let ctx: UnsafeMutablePointer<CC_SHA512_CTX> = malloc(MemoryLayout<CC_SHA1_CTX>.size)?.assumingMemoryBound(to: CC_SHA512_CTX.self) else {
return SG_ERR_NOMEM;
}
CC_SHA512_Init(ctx);
digestCtx!.initialize(to: ctx);
return SG_SUCCESS;
}
fileprivate func sha512_digest_update_func(digestCtx: UnsafeMutableRawPointer?, data: UnsafePointer<UInt8>?, dataLen: Int, ctx: UnsafeMutableRawPointer?) -> CInt {
guard digestCtx != nil && data != nil else {
return SG_ERR_INVAL;
}
CC_SHA512_Update(digestCtx!.assumingMemoryBound(to: CC_SHA512_CTX.self), data, UInt32(dataLen));
return SG_SUCCESS;
}
fileprivate func sha512_digest_final_func(digestCtx: UnsafeMutableRawPointer?, output: UnsafeMutablePointer<OpaquePointer?>?, ctx: UnsafeMutableRawPointer?) -> CInt {
guard digestCtx != nil && output != nil else {
return SG_ERR_INVAL;
}
let length = Int(CC_SHA512_DIGEST_LENGTH);
var data = Data(capacity: length);
data.withUnsafeMutableBytes({ (ptr: UnsafeMutableRawBufferPointer) -> Void in
CC_SHA512_Final(ptr.baseAddress?.assumingMemoryBound(to: UInt8.self), digestCtx?.assumingMemoryBound(to: CC_SHA512_CTX.self))
return;
});
output!.initialize(to: data.withUnsafeBytes({ (ptr: UnsafeRawBufferPointer) -> OpaquePointer in
return signal_buffer_create(ptr.baseAddress?.assumingMemoryBound(to: UInt8.self), length);
}));
return SG_SUCCESS;
}
fileprivate func sha512_digest_cleanup_func(digestCtx: UnsafeMutableRawPointer?, ctx: UnsafeMutableRawPointer?) {
guard digestCtx != nil else {
return;
}
free(digestCtx!);
}
fileprivate func encrypt_func(output: UnsafeMutablePointer<OpaquePointer?>?, cipher: CInt, key: UnsafePointer<UInt8>?, keyLen: Int, iv: UnsafePointer<UInt8>?, ivLen: Int, plaintext: UnsafePointer<UInt8>?, plaintextLen: Int, ctx: UnsafeMutableRawPointer?) -> CInt {
guard cipher == SG_CIPHER_AES_CBC_PKCS5 else {
return SG_ERR_INVAL;
}
var outLen: Int = 0;
var bytes = Array(repeating: UInt8(0), count: kCCBlockSizeAES128 + plaintextLen);
let result = CCCrypt(CCOperation(kCCEncrypt), CCAlgorithm(kCCAlgorithmAES), CCOptions(kCCOptionPKCS7Padding), key, keyLen, iv, plaintext, plaintextLen, &bytes, bytes.count, &outLen);
guard result == kCCSuccess else {
return SG_ERR_UNKNOWN;
}
output?.initialize(to: signal_buffer_create(&bytes, outLen));
return SG_SUCCESS;
}
fileprivate func decrypt_func(output: UnsafeMutablePointer<OpaquePointer?>?, cipher: CInt, key: UnsafePointer<UInt8>?, keyLen: Int, iv: UnsafePointer<UInt8>?, ivLen: Int, ciphertext: UnsafePointer<UInt8>?, ciphertextLen: Int, ctx: UnsafeMutableRawPointer?) -> CInt {
guard cipher == SG_CIPHER_AES_CBC_PKCS5 else {
return SG_ERR_INVAL;
}
var outLen: Int = 0;
var bytes = Array(repeating: UInt8(0), count: ciphertextLen + kCCBlockSizeAES128);
guard CCCrypt(CCOperation(kCCDecrypt), CCAlgorithm(kCCAlgorithmAES), CCOptions(kCCOptionPKCS7Padding), key, keyLen, iv, ciphertext, ciphertextLen, &bytes, bytes.count, &outLen) == kCCSuccess else {
return SG_ERR_UNKNOWN;
}
output?.initialize(to: signal_buffer_create(&bytes, outLen));
return SG_SUCCESS;
}
@@ -0,0 +1,54 @@
//
// SignalError.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
public enum SignalError: Int, Error {
// custom error code, not from libsignal but required for internal use to mark that message was not encrypted
case notEncrypted = -100000;
case noDestination = -100001;
case noMemory = -12;
case invalidArgument = -22;
case unknown = -1000;
case duplicateMessage = -1001;
case invalidKey = -1002;
case invalidKeyId = -1003;
case invalidMac = -1004;
case invalidMessage = -1005;
case invalidVersion = -1006;
case legacyMessage = -1007;
case noSession = -1008;
case staleKeyExchange = -1009;
case unstrustedIdentity = -1010;
case signatureVerificationFailed = -1011;
case invalidProtoBuf = -1100;
case fpInvalidVersion = -1200;
case fpIdentityMismatch = -1201;
public static func from(code: Int32) -> SignalError? {
guard code < 0 else {
return nil;
}
return SignalError(rawValue: Int(code)) ?? .unknown;
}
}
@@ -0,0 +1,75 @@
//
// SignalIdentityKey.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
open class SignalIdentityKey: SignalIdentityKeyProtocol {
public static func publicKey(from publicKey: Data) -> OpaquePointer? {
return publicKey.withUnsafeBytes({ (bytes) -> OpaquePointer? in
var tmp: OpaquePointer?;
guard curve_decode_point(&tmp, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), publicKey.count, nil) >= 0 else {
return nil;
}
return tmp;
});
}
public let publicKeyPointer: OpaquePointer;
fileprivate var _publicKey: Data?;
public var publicKey: Data? {
if _publicKey == nil {
var buffer: OpaquePointer?;
guard ec_public_key_serialize(&buffer, publicKeyPointer) == 0 && buffer != nil else {
return nil;
}
_publicKey = Data(bytes: signal_buffer_data(buffer), count: signal_buffer_len(buffer));
signal_buffer_bzero_free(buffer);
}
return _publicKey;
}
public convenience init?(publicKey: Data?) {
guard publicKey != nil else {
return nil;
}
guard let publicKeyPointer = SignalIdentityKey.publicKey(from: publicKey!) else {
return nil;
}
self.init(publicKeyPointer: publicKeyPointer);
}
public init(publicKeyPointer: OpaquePointer) {
self.publicKeyPointer = publicKeyPointer;
signal_type_ref(self.publicKeyPointer);
}
deinit {
signal_type_unref(publicKeyPointer);
}
open func serialized() -> Data {
return publicKey!;
}
}
@@ -0,0 +1,133 @@
//
// SignalIdentityKeyPair.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
open class SignalIdentityKeyPair: SignalIdentityKey, SignalIdentityKeyPairProtocol {
public let privateKeyPointer: OpaquePointer;
fileprivate var _keyPairPointer: OpaquePointer?;
public var keyPairPointer: OpaquePointer? {
if _keyPairPointer == nil {
ec_key_pair_create(&_keyPairPointer, publicKeyPointer, privateKeyPointer);
}
return _keyPairPointer;
}
fileprivate var _privateKey: Data?;
public var privateKey: Data? {
if _privateKey == nil {
var buffer: OpaquePointer?;
guard ec_private_key_serialize(&buffer, privateKeyPointer) == 0 && buffer != nil else {
return nil;
}
_privateKey = Data(bytes: signal_buffer_data(buffer), count: signal_buffer_len(buffer));
signal_buffer_bzero_free(buffer);
}
return _privateKey;
}
public var keyPair: Data? {
guard let keyPairPointer = self.keyPairPointer else {
return nil;
}
var buffer: OpaquePointer?;
guard ratchet_identity_key_pair_serialize(&buffer, keyPairPointer) == 0 && buffer != nil else {
return nil;
}
defer {
signal_buffer_bzero_free(buffer);
}
return Data(bytes: signal_buffer_data(buffer), count: signal_buffer_len(buffer));
}
public init?(publicKey: Data?, privateKey: Data?) {
guard publicKey != nil && privateKey != nil else {
return nil;
}
guard let privateKeyPointer = privateKey!.withUnsafeBytes({ (bytes) -> OpaquePointer? in
var tmp: OpaquePointer?;
guard curve_decode_private_point(&tmp, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), privateKey!.count, nil) >= 0 else {
return nil;
}
return tmp;
}) else {
return nil;
}
guard let publicKeyPointer = publicKey!.withUnsafeBytes({ (bytes) -> OpaquePointer? in
var tmp: OpaquePointer?;
guard curve_decode_point(&tmp, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), publicKey!.count, nil) >= 0 else {
return nil;
}
return tmp;
}) else {
return nil;
}
self.privateKeyPointer = privateKeyPointer;
signal_type_ref(self.privateKeyPointer);
super.init(publicKeyPointer: publicKeyPointer);
}
public init(withKeyPair keyPair: OpaquePointer) {
privateKeyPointer = ratchet_identity_key_pair_get_private(keyPair);
signal_type_ref(self.privateKeyPointer);
super.init(publicKeyPointer: ratchet_identity_key_pair_get_public(keyPair));
}
public convenience init?(fromKeyPairData data: Data) {
guard let keyPair = data.withUnsafeBytes({ (bytes) -> OpaquePointer? in
var tmp: OpaquePointer?;
guard ratchet_identity_key_pair_deserialize(&tmp, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), data.count, nil) >= 0 && tmp != nil else {
return nil;
}
return tmp;
}) else {
return nil;
}
self.init(withKeyPair: keyPair);
}
deinit {
signal_type_unref(privateKeyPointer);
if keyPairPointer != nil {
signal_type_unref(keyPairPointer);
_keyPairPointer = nil;
}
}
public static func generateKeyPair(context: SignalContext) -> SignalIdentityKeyPair? {
var keyPair: OpaquePointer? = nil;
let result = signal_protocol_key_helper_generate_identity_key_pair(&keyPair, context.globalContext);
guard result >= 0 && keyPair != nil else {
return nil;
}
return SignalIdentityKeyPair(withKeyPair: keyPair!);
}
override open func serialized() -> Data {
return keyPair!;
}
}
@@ -0,0 +1,87 @@
//
// SignalPreKeyBundle.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
public class SignalPreKeyBundle {
let bundle: OpaquePointer;
public convenience init?(registrationId: UInt32, deviceId: Int32, preKey: OMEMOModule.OMEMOPreKey, bundle: OMEMOModule.OMEMOBundle) {
self.init(
registrationId: registrationId,
deviceId: deviceId,
preKeyId: preKey.preKeyId,
preKeyPublic: preKey.data,
signedPreKeyId: bundle.signedPreKeyId,
signedPreKeyPublic: bundle.signedPreKeyPublic,
signedPreKeySignature: bundle.signature,
identityKey: bundle.identityKey
)
}
/// Raw-data initializer added by Luma so an OMEMO 2 bundle (the
/// `urn:xmpp:omemo:2` format) can be turned into a Signal prekey bundle
/// without routing through the legacy bundle types.
public init?(
registrationId: UInt32,
deviceId: Int32,
preKeyId: UInt32,
preKeyPublic: Data,
signedPreKeyId: UInt32,
signedPreKeyPublic: Data,
signedPreKeySignature: Data,
identityKey: Data
) {
guard let preKeyPublicKey = SignalIdentityKey.publicKey(from: preKeyPublic) else {
return nil;
}
guard let signedPreKeyPublicKey = SignalIdentityKey.publicKey(from: signedPreKeyPublic) else {
signal_type_unref(preKeyPublicKey);
return nil;
}
guard let identityKeyKey = SignalIdentityKey.publicKey(from: identityKey) else {
signal_type_unref(preKeyPublicKey);
signal_type_unref(signedPreKeyPublicKey);
return nil;
}
var bundlePtr: OpaquePointer?;
guard signedPreKeySignature.withUnsafeBytes({ (bytes) -> Bool in
let result = session_pre_key_bundle_create(&bundlePtr, registrationId, deviceId, preKeyId, preKeyPublicKey, signedPreKeyId, signedPreKeyPublicKey, bytes.baseAddress?.assumingMemoryBound(to: UInt8.self), signedPreKeySignature.count, identityKeyKey);
signal_type_unref(preKeyPublicKey);
signal_type_unref(signedPreKeyPublicKey);
signal_type_unref(identityKeyKey);
return result >= 0;
}) else {
return nil;
}
self.bundle = bundlePtr!;
}
deinit {
signal_type_unref(bundle);
}
}
@@ -0,0 +1,51 @@
//
// SignalSessioBuilder.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
open class SignalSessionBuilder {
fileprivate let builder: OpaquePointer;
fileprivate let address: SignalAddress;
fileprivate let context: SignalContext;
public init?(withAddress addr: SignalAddress, andContext ctx: SignalContext) {
var builder: OpaquePointer?;
guard session_builder_create(&builder, ctx.storage.storeContext!, addr.address, ctx.globalContext) >= 0 && builder != nil else {
return nil;
}
self.address = addr;
self.context = ctx;
self.builder = builder!;
}
deinit {
session_builder_free(builder);
}
public func processPreKeyBundle(bundle: SignalPreKeyBundle) -> Bool {
guard session_builder_process_pre_key_bundle(builder, bundle.bundle) >= 0 else {
return false;
}
return true;
}
}
@@ -0,0 +1,142 @@
//
// SignalSessionCipher.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
open class SignalSessionCipher {
fileprivate var cipher: OpaquePointer;
fileprivate let context: SignalContext;
fileprivate let address: SignalAddress;
public init?(withAddress address: SignalAddress, andContext context: SignalContext) {
var cipher: OpaquePointer?;
self.address = address;
guard session_cipher_create(&cipher, context.storage.storeContext, self.address.address, context.globalContext) >= 0 && cipher != nil else {
return nil;
}
self.context = context;
self.cipher = cipher!;
}
deinit {
session_cipher_free(cipher);
}
public func encrypt(data: Data) -> Result<Key,SignalError> {
var message: OpaquePointer?;
let error = data.withUnsafeBytes({ (bytes) -> SignalError? in
return SignalError.from(code : session_cipher_encrypt(cipher, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), data.count, &message));
})
guard error == nil && message != nil else {
return .failure(error ?? .unknown);
}
let serialized = ciphertext_message_get_serialized(message);
let result = Data(bytes: signal_buffer_data(serialized), count: signal_buffer_len(serialized));
defer {
signal_type_unref(message);
}
return .success(Key(key: result, deviceId: address.deviceId, prekey: ciphertext_message_get_type(message) == CIPHERTEXT_PREKEY_TYPE));
}
public func decrypt(key: Key) -> Result<Data, SignalError> {
if key.prekey {
return decryptPreKeyMessage(key: key);
} else {
return decryptSignalMessage(key: key);
}
}
fileprivate func decryptPreKeyMessage(key: Key) -> Result<Data,SignalError> {
let result = key.key.withUnsafeBytes({ (bytes) -> Result<OpaquePointer, SignalError> in
var output: OpaquePointer?;
var preKeySignalMessage: OpaquePointer?;
var error = SignalError.from(code: pre_key_signal_message_deserialize(&preKeySignalMessage, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), key.key.count, self.context.globalContext));
guard error == nil && preKeySignalMessage != nil else {
return .failure(error ?? .unknown);
}
defer {
signal_type_unref(preKeySignalMessage);
}
error = SignalError.from(code: session_cipher_decrypt_pre_key_signal_message(cipher, preKeySignalMessage, nil, &output));
guard error == nil && output != nil else {
return .failure(error ?? .unknown);
}
return .success(output!);
})
switch result {
case .failure(let error):
return .failure(error);
case .success(let preKeySignalMessage):
defer {
signal_buffer_free(preKeySignalMessage);
}
return .success(Data(bytes: signal_buffer_data(preKeySignalMessage), count: signal_buffer_len(preKeySignalMessage)));
}
}
fileprivate func decryptSignalMessage(key: Key) -> Result<Data, SignalError> {
let result = key.key.withUnsafeBytes({ (bytes) -> Result<OpaquePointer,SignalError> in
var output: OpaquePointer?;
var signalMessage: OpaquePointer?;
var error = SignalError.from(code: signal_message_deserialize(&signalMessage, bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), key.key.count, self.context.globalContext));
guard error == nil && signalMessage != nil else {
return .failure(error ?? .unknown);
}
defer {
signal_type_unref(signalMessage);
}
error = SignalError.from(code: session_cipher_decrypt_signal_message(cipher, signalMessage, nil, &output));
guard error == nil && output != nil else {
return .failure(error ?? .unknown);
}
return .success(output!);
});
switch result {
case .failure(let error):
return .failure(error);
case .success(let signalMessage):
defer {
signal_buffer_free(signalMessage);
}
return .success(Data(bytes: signal_buffer_data(signalMessage), count: signal_buffer_len(signalMessage)));
}
}
open class Key {
public let key: Data;
public let deviceId: Int32;
public let prekey: Bool;
public init(key: Data, deviceId: Int32, prekey: Bool) {
self.key = key;
self.deviceId = deviceId;
self.prekey = prekey;
}
}
}
@@ -0,0 +1,396 @@
//
// SignalStorage.swift
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
import Foundation
import libsignal
open class SignalStorage {
public let sessionStore: SignalSessionStoreProtocol;
public let preKeyStore: SignalPreKeyStoreProtocol;
public let signedPreKeyStore: SignalSignedPreKeyStoreProtocol;
public let identityKeyStore: SignalIdentityKeyStoreProtocol;
public let senderKeyStore: SignalSenderKeyStoreProtocol;
fileprivate(set) var storeContext: OpaquePointer?;
public init(sessionStore: SignalSessionStoreProtocol, preKeyStore: SignalPreKeyStoreProtocol, signedPreKeyStore: SignalSignedPreKeyStoreProtocol, identityKeyStore: SignalIdentityKeyStoreProtocol, senderKeyStore: SignalSenderKeyStoreProtocol) {
self.sessionStore = sessionStore;
self.preKeyStore = preKeyStore;
self.signedPreKeyStore = signedPreKeyStore;
self.identityKeyStore = identityKeyStore;
self.senderKeyStore = senderKeyStore;
}
deinit {
if storeContext != nil {
signal_protocol_store_context_destroy(storeContext);
}
storeContext = nil;
}
open func setup(withContext context: SignalContext) {
signal_protocol_store_context_create(&storeContext, context.globalContext);
var sessionStoreCallbacks = signal_protocol_session_store();
sessionStoreCallbacks.load_session_func = load_session_func;
sessionStoreCallbacks.get_sub_device_sessions_func = get_sub_device_sessions_func;
sessionStoreCallbacks.store_session_func = store_session_func;
sessionStoreCallbacks.contains_session_func = contains_session_func;
sessionStoreCallbacks.delete_session_func = delete_session_func;
sessionStoreCallbacks.delete_all_sessions_func = delete_all_sessions_func;
sessionStoreCallbacks.destroy_func = destroy_func;
sessionStoreCallbacks.user_data = SignalContext.bridge(self.sessionStore as AnyObject);
signal_protocol_store_context_set_session_store(storeContext, &sessionStoreCallbacks);
var preKeyStoreCallbacks = signal_protocol_pre_key_store();
preKeyStoreCallbacks.load_pre_key = load_pre_key;
preKeyStoreCallbacks.store_pre_key = store_pre_key;
preKeyStoreCallbacks.contains_pre_key = contains_pre_key;
preKeyStoreCallbacks.remove_pre_key = remove_pre_key;
preKeyStoreCallbacks.destroy_func = destroy_func;
preKeyStoreCallbacks.user_data = SignalContext.bridge(self.preKeyStore as AnyObject);
signal_protocol_store_context_set_pre_key_store(storeContext, &preKeyStoreCallbacks);
var signedPreKeyStoreCallbacks = signal_protocol_signed_pre_key_store();
signedPreKeyStoreCallbacks.load_signed_pre_key = load_signed_pre_key;
signedPreKeyStoreCallbacks.store_signed_pre_key = store_signed_pre_key;
signedPreKeyStoreCallbacks.contains_signed_pre_key = contains_signed_pre_key;
signedPreKeyStoreCallbacks.remove_signed_pre_key = remove_signed_pre_key;
signedPreKeyStoreCallbacks.destroy_func = destroy_func;
signedPreKeyStoreCallbacks.user_data = SignalContext.bridge(self.signedPreKeyStore as AnyObject);
signal_protocol_store_context_set_signed_pre_key_store(storeContext, &signedPreKeyStoreCallbacks);
var identityKeyStoreCallbacks = signal_protocol_identity_key_store();
identityKeyStoreCallbacks.get_identity_key_pair = get_identity_key_pair;
identityKeyStoreCallbacks.get_local_registration_id = get_local_registration_id;
identityKeyStoreCallbacks.save_identity = save_identity;
identityKeyStoreCallbacks.is_trusted_identity = is_trusted_identity;
identityKeyStoreCallbacks.destroy_func = destroy_func;
identityKeyStoreCallbacks.user_data = SignalContext.bridge(self.identityKeyStore as AnyObject);
signal_protocol_store_context_set_identity_key_store(storeContext, &identityKeyStoreCallbacks);
var senderKeyStoreCallbacks = signal_protocol_sender_key_store();
senderKeyStoreCallbacks.store_sender_key = store_sender_key;
senderKeyStoreCallbacks.load_sender_key = load_sender_key;
senderKeyStoreCallbacks.destroy_func = destroy_func;
identityKeyStoreCallbacks.user_data = SignalContext.bridge(self.senderKeyStore as AnyObject);
signal_protocol_store_context_set_sender_key_store(storeContext, &senderKeyStoreCallbacks);
}
open func regenerateKeys(wipe: Bool = false) -> Bool {
return false;
};
}
public protocol SignalSessionStoreProtocol: AnyObject {
func sessionRecord(forAddress address: SignalAddress) -> Data?;
func allDevices(for: String, activeAndTrusted: Bool) -> [Int32];
func storeSessionRecord(_ data: Data, forAddress: SignalAddress) -> Bool;
func containsSessionRecord(forAddress: SignalAddress) -> Bool;
func deleteSessionRecord(forAddress: SignalAddress) -> Bool;
func deleteAllSessions(for: String) -> Bool;
}
public protocol SignalPreKeyStoreProtocol: AnyObject {
func currentPreKeyId() -> UInt32;
func loadPreKey(withId: UInt32) -> Data?;
func storePreKey(_ data: Data, withId: UInt32) -> Bool;
func containsPreKey(withId: UInt32) -> Bool;
func deletePreKey(withId: UInt32) -> Bool;
func flushDeletedPreKeys() -> Bool;
}
public protocol SignalSignedPreKeyStoreProtocol: AnyObject {
func countSignedPreKeys() -> Int;
func loadSignedPreKey(withId: UInt32) -> Data?;
func storeSignedPreKey(_ data: Data, withId: UInt32) -> Bool;
func containsSignedPreKey(withId: UInt32) -> Bool;
func deleteSignedPreKey(withId: UInt32) -> Bool;
}
public protocol SignalIdentityKeyStoreProtocol: AnyObject {
func keyPair() -> SignalIdentityKeyPairProtocol?;
func localRegistrationId() -> UInt32;
func save(identity: SignalAddress, key: SignalIdentityKeyProtocol?) -> Bool;
func isTrusted(identity: SignalAddress, key: SignalIdentityKeyProtocol?) -> Bool;
func save(identity: SignalAddress, publicKeyData: Data?) -> Bool;
func isTrusted(identity: SignalAddress, publicKeyData: Data?) -> Bool;
func setStatus(_ status: IdentityStatus, forIdentity: SignalAddress) -> Bool;
func setStatus(active: Bool, forIdentity: SignalAddress) -> Bool;
func identities(forName: String) -> [Identity];
func identityFingerprint(forAddress address: SignalAddress) -> String?
}
public protocol SignalIdentityKeyProtocol: AnyObject {
var publicKeyPointer: OpaquePointer { get }
var publicKey: Data? { get }
func serialized() -> Data;
}
public protocol SignalIdentityKeyPairProtocol: SignalIdentityKeyProtocol {
var keyPairPointer: OpaquePointer? { get }
var keyPair: Data? { get }
var privateKeyPointer: OpaquePointer { get }
var privateKey: Data? { get }
}
public protocol SignalSenderKeyStoreProtocol: AnyObject {
func storeSenderKey(_ key: Data, address: SignalAddress?, groupId: String?) -> Bool;
func loadSenderKey(forAddress: SignalAddress?, groupId: String?) -> Data?;
}
fileprivate func load_session_func(record: UnsafeMutablePointer<OpaquePointer?>?, userRecord: UnsafeMutablePointer<OpaquePointer?>?, address: UnsafePointer<signal_protocol_address>?, userData: UnsafeMutableRawPointer?) -> CInt {
let sessionStore: SignalSessionStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSessionStoreProtocol;
guard let addr = SignalAddress(from: address) else {
return -1;
}
guard let data = sessionStore.sessionRecord(forAddress: addr) else {
return 0;
}
data.withUnsafeBytes({ (ptr: UnsafeRawBufferPointer) -> Void in
record?.initialize(to: signal_buffer_create(ptr.baseAddress!.assumingMemoryBound(to: UInt8.self), data.count));
})
return 1;
}
fileprivate func get_sub_device_sessions_func(sessions: UnsafeMutablePointer<OpaquePointer?>?, name namePtr: UnsafePointer<Int8>?, nameLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let sessionStore: SignalSessionStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSessionStoreProtocol;
guard let name = String(validatingUTF8: namePtr!) else {
return -1;
}
let devices = sessionStore.allDevices(for: name, activeAndTrusted: false);
guard let list = signal_int_list_alloc() else {
return -1;
}
devices.forEach { device in
signal_int_list_push_back(list, device);
}
return CInt(devices.count);
}
fileprivate func store_session_func(address: UnsafePointer<signal_protocol_address>?, record: UnsafeMutablePointer<UInt8>?, recordLen: Int, userRecord: UnsafeMutablePointer<UInt8>?, userRecordLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let sessionStore: SignalSessionStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSessionStoreProtocol;
guard let addr = SignalAddress(from: address) else {
return -1;
}
let data = Data(bytes: record!, count: recordLen);
return sessionStore.storeSessionRecord(data, forAddress: addr) ? 0 : -1;
}
fileprivate func contains_session_func(address: UnsafePointer<signal_protocol_address>?, userData: UnsafeMutableRawPointer?) -> CInt {
let sessionStore: SignalSessionStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSessionStoreProtocol;
guard let addr = SignalAddress(from: address) else {
return -1;
}
return sessionStore.containsSessionRecord(forAddress: addr) ? 1 : 0;
}
fileprivate func delete_session_func(address: UnsafePointer<signal_protocol_address>?, userData: UnsafeMutableRawPointer?) -> CInt {
let sessionStore: SignalSessionStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSessionStoreProtocol;
guard let addr = SignalAddress(from: address) else {
return -1;
}
return sessionStore.deleteSessionRecord(forAddress: addr) ? 1 : 0;
}
fileprivate func delete_all_sessions_func(name namePtr: UnsafePointer<Int8>?, nameLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let sessionStore: SignalSessionStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSessionStoreProtocol;
guard let name = String(validatingUTF8: namePtr!) else {
return -1;
}
return sessionStore.deleteAllSessions(for: name) ? 1 : 0;
}
fileprivate func destroy_func(userData: UnsafeMutableRawPointer?) {
}
fileprivate func load_pre_key(record: UnsafeMutablePointer<OpaquePointer?>?, preKeyId: UInt32, userData: UnsafeMutableRawPointer?) -> CInt {
let preKeyStore: SignalPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalPreKeyStoreProtocol;
guard let preKey = preKeyStore.loadPreKey(withId: preKeyId) else {
return SG_ERR_INVALID_KEY_ID;
}
preKey.withUnsafeBytes({ (bytes: UnsafeRawBufferPointer)->Void in
let buffer = signal_buffer_create(bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), preKey.count);
record?.initialize(to: buffer);
})
return SG_SUCCESS;
}
fileprivate func store_pre_key(preKeyId: UInt32, record: UnsafeMutablePointer<UInt8>?, recordLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let preKeyStore: SignalPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalPreKeyStoreProtocol;
let data = Data(bytes: record!, count: recordLen);
return preKeyStore.storePreKey(data, withId: preKeyId) ? 0 : -1;
}
fileprivate func contains_pre_key(preKeyId: UInt32, userData: UnsafeMutableRawPointer?) -> CInt {
let preKeyStore: SignalPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalPreKeyStoreProtocol;
return preKeyStore.containsPreKey(withId: preKeyId) ? 1 : 0;
}
fileprivate func remove_pre_key(preKeyId: UInt32, userData: UnsafeMutableRawPointer?) -> CInt {
let preKeyStore: SignalPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalPreKeyStoreProtocol;
return preKeyStore.deletePreKey(withId: preKeyId) ? 0 : -1;
}
fileprivate func load_signed_pre_key(record: UnsafeMutablePointer<OpaquePointer?>?, signedPreKeyId: UInt32, userData: UnsafeMutableRawPointer?) -> CInt {
let signedPreKeyStore: SignalSignedPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSignedPreKeyStoreProtocol;
guard let preKey = signedPreKeyStore.loadSignedPreKey(withId: signedPreKeyId) else {
return SG_ERR_INVALID_KEY_ID;
}
preKey.withUnsafeBytes({ (bytes: UnsafeRawBufferPointer)->Void in
let buffer = signal_buffer_create(bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), preKey.count);
record?.initialize(to: buffer);
})
return SG_SUCCESS;
}
fileprivate func store_signed_pre_key(signedPreKeyId: UInt32, record: UnsafeMutablePointer<UInt8>?, recordLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let signedPreKeyStore: SignalSignedPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSignedPreKeyStoreProtocol;
let data = Data(bytes: record!, count: recordLen);
return signedPreKeyStore.storeSignedPreKey(data, withId: signedPreKeyId) ? 0 : -1;
}
fileprivate func contains_signed_pre_key(signedPreKeyId: UInt32, userData: UnsafeMutableRawPointer?) -> CInt {
let signedPreKeyStore: SignalSignedPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSignedPreKeyStoreProtocol;
return signedPreKeyStore.containsSignedPreKey(withId: signedPreKeyId) ? 1 : 0;
}
fileprivate func remove_signed_pre_key(signedPreKeyId: UInt32, userData: UnsafeMutableRawPointer?) -> CInt {
let signedPreKeyStore: SignalSignedPreKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSignedPreKeyStoreProtocol;
return signedPreKeyStore.deleteSignedPreKey(withId: signedPreKeyId) ? 0 : -1;
}
fileprivate func get_identity_key_pair(publicData: UnsafeMutablePointer<OpaquePointer?>?, privateData: UnsafeMutablePointer<OpaquePointer?>?, userData: UnsafeMutableRawPointer?) -> CInt {
let identityKeyStore: SignalIdentityKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalIdentityKeyStoreProtocol;
guard let keyPair = identityKeyStore.keyPair() else {
return -1;
}
if let publicKey = keyPair.publicKey {
publicKey.withUnsafeBytes { (bytes: UnsafeRawBufferPointer) -> Void in
let buffer = signal_buffer_create(bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), publicKey.count);
publicData?.initialize(to: buffer);
}
}
if let privateKey = keyPair.privateKey {
privateKey.withUnsafeBytes { (bytes: UnsafeRawBufferPointer) -> Void in
let buffer = signal_buffer_create(bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), privateKey.count);
privateData?.initialize(to: buffer);
}
}
return 0;
}
fileprivate func get_local_registration_id(userData: UnsafeMutableRawPointer?, registrationId: UnsafeMutablePointer<UInt32>?) -> CInt {
let identityKeyStore: SignalIdentityKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalIdentityKeyStoreProtocol;
let regId = identityKeyStore.localRegistrationId();
if regId > 0 {
registrationId?.initialize(to: regId);
return 0;
} else {
return -1;
}
}
fileprivate func save_identity(address: UnsafePointer<signal_protocol_address>?, keyData: UnsafeMutablePointer<UInt8>?, keyLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let identityKeyStore: SignalIdentityKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalIdentityKeyStoreProtocol;
guard let addr = SignalAddress(from: address) else {
return -1;
}
return identityKeyStore.save(identity: addr, publicKeyData: keyData == nil ? nil : Data(bytes: keyData!, count: keyLen)) ? 0 : -1;
}
fileprivate func is_trusted_identity(address: UnsafePointer<signal_protocol_address>?, keyData: UnsafeMutablePointer<UInt8>?, keyLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let identityKeyStore: SignalIdentityKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalIdentityKeyStoreProtocol;
guard let addr = SignalAddress(from: address) else {
return -1;
}
return identityKeyStore.isTrusted(identity: addr, publicKeyData: Data(bytes: keyData!, count: keyLen)) ? 1 : 0;
}
fileprivate func store_sender_key(senderKeyName: UnsafePointer<signal_protocol_sender_key_name>?, record: UnsafeMutablePointer<UInt8>?, recordLen: Int, userRecord: UnsafeMutablePointer<UInt8>?, userRecordLen: Int, userData: UnsafeMutableRawPointer?) -> CInt {
let senderKeyStore: SignalSenderKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSenderKeyStoreProtocol;
var sender = senderKeyName?.pointee.sender;
let groupId = senderKeyName?.pointee.group_id;
let group = groupId != nil ? String(validatingUTF8: groupId!) : nil;
let addr = SignalAddress(from: &sender)
let key = Data(bytes: record!, count: recordLen);
return senderKeyStore.storeSenderKey(key, address: addr, groupId: group) ? 0 : -1;
}
fileprivate func load_sender_key(record: UnsafeMutablePointer<OpaquePointer?>?, userRecord: UnsafeMutablePointer<OpaquePointer?>?, senderKeyName: UnsafePointer<signal_protocol_sender_key_name>?, userData: UnsafeMutableRawPointer?) -> CInt {
let senderKeyStore: SignalSenderKeyStoreProtocol = SignalContext.bridge(fromPointer: userData!) as! SignalSenderKeyStoreProtocol;
var sender = senderKeyName?.pointee.sender;
let groupId = senderKeyName?.pointee.group_id;
let group = groupId != nil ? String(validatingUTF8: groupId!) : nil;
let addr = SignalAddress(from: &sender)
if let key = senderKeyStore.loadSenderKey(forAddress: addr, groupId: group) {
key.withUnsafeBytes({ (bytes: UnsafeRawBufferPointer) -> Void in
let buffer = signal_buffer_create(bytes.baseAddress!.assumingMemoryBound(to: UInt8.self), key.count);
record?.initialize(to: buffer);
});
return 1;
} else {
return 0;
}
}
@@ -0,0 +1,37 @@
//
// TigaseSwift_OMEMO.h
//
// TigaseSwift OMEMO
// Copyright (C) 2019 "Tigase, Inc." <office@tigase.com>
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. Look for COPYING file in the top folder.
// If not, see https://www.gnu.org/licenses/.
//
//
#import "protocol.h"
#import "signal_protocol.h"
#import "key_helper.h"
#import "session_builder.h"
#import "session_cipher.h"
//! Project version number for TigaseSwift_OMEMO.
//FOUNDATION_EXPORT double TigaseSwift_OMEMOVersionNumber;
//! Project version string for TigaseSwift_OMEMO.
//FOUNDATION_EXPORT const unsigned char TigaseSwift_OMEMOVersionString[];
// In this header, you should import all the public headers of your framework using statements like #import <TigaseSwift_OMEMO/PublicHeader.h>