added omemo2
This commit is contained in:
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(®Id, 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>
|
||||
|
||||
|
||||
Reference in new issue
Block a user