anotherim/anotherim-desktop
2
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Enable encryption in MUCs

Browse source
This commit is contained in:
Samuel Hand 2018-07-11 18:17:57 +01:00
parent 62ad56af21
commit 74c48e6567
3 changed files with 113 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
plugins/omemo/src/encrypt_state.vala
View file

@ -7,7 +7,7 @@ public class EncryptState {
public int other_lost { get; internal set; } public int other_lost { get; internal set; }
public int other_unknown { get; internal set; } public int other_unknown { get; internal set; }
public int other_failure { get; internal set; } public int other_failure { get; internal set; }
public bool other_list { get; internal set; } public int other_waiting_lists { get; internal set; }
public int own_devices { get; internal set; } public int own_devices { get; internal set; }
public int own_success { get; internal set; } public int own_success { get; internal set; }
@ -17,8 +17,8 @@ public class EncryptState {
public bool own_list { get; internal set; } public bool own_list { get; internal set; }
public string to_string() { public string to_string() {
return @"EncryptState (encrypted=$encrypted, other=(devices=$other_devices, success=$other_success, lost=$other_lost, unknown=$other_unknown, failure=$other_failure, list=$other_list), own=(devices=$own_devices, success=$own_success, lost=$own_lost, unknown=$own_unknown, failure=$own_failure, list=$own_list))"; return @"EncryptState (encrypted=$encrypted, other=(devices=$other_devices, success=$other_success, lost=$other_lost, unknown=$other_unknown, failure=$other_failure, waiting_lists=$other_waiting_lists, own=(devices=$own_devices, success=$own_success, lost=$own_lost, unknown=$own_unknown, failure=$own_failure, list=$own_list))";
} }
} }
} }

57
plugins/omemo/src/manager.vala
View file

@ -21,7 +21,7 @@ public class Manager : StreamInteractionModule, Object {
public int waiting_other_sessions { get; set; } public int waiting_other_sessions { get; set; }
public int waiting_own_sessions { get; set; } public int waiting_own_sessions { get; set; }
public bool waiting_own_devicelist { get; set; } public bool waiting_own_devicelist { get; set; }
public bool waiting_other_devicelist { get; set; } public int waiting_other_devicelists { get; set; }
public bool force_next_attempt { get; set; } public bool force_next_attempt { get; set; }
public bool will_send_now { get; private set; } public bool will_send_now { get; private set; }
public bool active_send_attempt { get; set; } public bool active_send_attempt { get; set; }
@ -37,12 +37,12 @@ public class Manager : StreamInteractionModule, Object {
this.waiting_other_sessions = new_try.other_unknown; this.waiting_other_sessions = new_try.other_unknown;
this.waiting_own_sessions = new_try.own_unknown; this.waiting_own_sessions = new_try.own_unknown;
this.waiting_own_devicelist = !new_try.own_list; this.waiting_own_devicelist = !new_try.own_list;
this.waiting_other_devicelist = !new_try.other_list; this.waiting_other_devicelists = new_try.other_waiting_lists;
this.active_send_attempt = false; this.active_send_attempt = false;
will_send_now = false; will_send_now = false;
if (new_try.other_failure > 0 || (new_try.other_lost == new_try.other_devices && new_try.other_devices > 0)) { if (new_try.other_failure > 0 || (new_try.other_lost == new_try.other_devices && new_try.other_devices > 0)) {
msg.marked = Entities.Message.Marked.WONTSEND; msg.marked = Entities.Message.Marked.WONTSEND;
} else if (new_try.other_unknown > 0 || new_try.own_unknown > 0 || !new_try.other_list || !new_try.own_list || new_try.own_devices == 0) { } else if (new_try.other_unknown > 0 || new_try.own_unknown > 0 || new_try.other_waiting_lists > 0 || !new_try.own_list || new_try.own_devices == 0) {
msg.marked = Entities.Message.Marked.UNSENT; msg.marked = Entities.Message.Marked.UNSENT;
} else if (!new_try.encrypted) { } else if (!new_try.encrypted) {
msg.marked = Entities.Message.Marked.WONTSEND; msg.marked = Entities.Message.Marked.WONTSEND;
@ -52,11 +52,11 @@ public class Manager : StreamInteractionModule, Object {
} }
public bool should_retry_now() { public bool should_retry_now() {
return !waiting_own_devicelist && !waiting_other_devicelist && waiting_other_sessions <= 0 && waiting_own_sessions <= 0 && !active_send_attempt; return !waiting_own_devicelist && waiting_other_devicelists <= 0 && waiting_other_sessions <= 0 && waiting_own_sessions <= 0 && !active_send_attempt;
} }
public string to_string() { public string to_string() {
return @"MessageState (waiting=(others=$waiting_other_sessions, own=$waiting_own_sessions, other_list=$waiting_other_devicelist, own_list=$waiting_own_devicelist))"; return @"MessageState (waiting=(others=$waiting_other_sessions, own=$waiting_own_sessions, other_lists=$waiting_other_devicelists, own_list=$waiting_own_devicelist))";
} }
} }
@ -85,6 +85,21 @@ public class Manager : StreamInteractionModule, Object {
} }
} }
private Gee.List<Jid> get_occupants(Jid muc, Account account){
Gee.List<Jid> occupants = new ArrayList<Jid>(Jid.equals_bare_func);
Gee.List<Jid>? occupant_jids = stream_interactor.get_module(MucManager.IDENTITY).get_other_occupants(muc, account);
if(occupant_jids == null) {
return occupants;
}
foreach (Jid occupant in occupant_jids) {
Jid? occupant_jid = stream_interactor.get_module(MucManager.IDENTITY).get_real_jid(occupant, account);
if(occupant_jid != null){
occupants.add(occupant_jid.bare_jid);
}
}
return occupants;
}
private void on_pre_message_send(Entities.Message message, Xmpp.MessageStanza message_stanza, Conversation conversation) { private void on_pre_message_send(Entities.Message message, Xmpp.MessageStanza message_stanza, Conversation conversation) {
if (message.encryption == Encryption.OMEMO) { if (message.encryption == Encryption.OMEMO) {
XmppStream? stream = stream_interactor.get_stream(conversation.account); XmppStream? stream = stream_interactor.get_stream(conversation.account);
@ -107,7 +122,19 @@ public class Manager : StreamInteractionModule, Object {
} }
} }
EncryptState enc_state = module.encrypt(message_stanza, conversation.account.bare_jid); Gee.List<Jid> recipients;
if (message_stanza.type_ == MessageStanza.TYPE_GROUPCHAT) {
recipients = get_occupants((!)message.to.bare_jid, conversation.account);
if (recipients.size == 0) {
message.marked = Entities.Message.Marked.WONTSEND;
return;
}
} else {
recipients = new ArrayList<Jid>(Jid.equals_bare_func);
recipients.add(message_stanza.to);
}
EncryptState enc_state = module.encrypt(message_stanza, conversation.account.bare_jid, recipients);
MessageState state; MessageState state;
lock (message_states) { lock (message_states) {
if (message_states.has_key(message)) { if (message_states.has_key(message)) {
@ -135,7 +162,7 @@ public class Manager : StreamInteractionModule, Object {
if (state.waiting_other_sessions > 0 && message.counterpart != null) { if (state.waiting_other_sessions > 0 && message.counterpart != null) {
module.fetch_bundles((!)stream, ((!)message.counterpart).bare_jid); module.fetch_bundles((!)stream, ((!)message.counterpart).bare_jid);
} }
if (state.waiting_other_devicelist && message.counterpart != null) { if (state.waiting_other_devicelists > 0 && message.counterpart != null) {
module.request_user_devicelist((!)stream, ((!)message.counterpart).bare_jid); module.request_user_devicelist((!)stream, ((!)message.counterpart).bare_jid);
} }
} }
@ -159,11 +186,12 @@ public class Manager : StreamInteractionModule, Object {
lock (message_states) { lock (message_states) {
foreach (Entities.Message msg in message_states.keys) { foreach (Entities.Message msg in message_states.keys) {
if (!msg.account.equals(account)) continue; if (!msg.account.equals(account)) continue;
Gee.List<Jid> occupants = get_occupants(msg.counterpart.bare_jid, account);
MessageState state = message_states[msg]; MessageState state = message_states[msg];
if (account.bare_jid.equals(jid)) { if (account.bare_jid.equals(jid)) {
state.waiting_own_devicelist = false; state.waiting_own_devicelist = false;
} else if (msg.counterpart != null && msg.counterpart.equals_bare(jid)) { } else if (msg.counterpart != null && (msg.counterpart.equals_bare(jid) || occupants.contains(jid))) {
state.waiting_other_devicelist = false; state.waiting_other_devicelists--;
} }
if (state.should_retry_now()) { if (state.should_retry_now()) {
send_now.add(msg); send_now.add(msg);
@ -187,6 +215,7 @@ public class Manager : StreamInteractionModule, Object {
if (module == null) { if (module == null) {
return; return;
} }
ArrayList<int32> device_list = module.get_device_list(jid); ArrayList<int32> device_list = module.get_device_list(jid);
db.identity_meta.insert_device_list(account.id, jid.bare_jid.to_string(), device_list); db.identity_meta.insert_device_list(account.id, jid.bare_jid.to_string(), device_list);
int inc = 0; int inc = 0;
@ -229,20 +258,23 @@ public class Manager : StreamInteractionModule, Object {
HashSet<Entities.Message> send_now = new HashSet<Entities.Message>(); HashSet<Entities.Message> send_now = new HashSet<Entities.Message>();
lock (message_states) { lock (message_states) {
foreach (Entities.Message msg in message_states.keys) { foreach (Entities.Message msg in message_states.keys) {
bool session_created = true; bool session_created = true;
if (!msg.account.equals(account)) continue; if (!msg.account.equals(account)) continue;
Gee.List<Jid> occupants = get_occupants(msg.counterpart.bare_jid, account);
MessageState state = message_states[msg]; MessageState state = message_states[msg];
if (trusted != Database.IdentityMetaTable.TrustLevel.TRUSTED && trusted != Database.IdentityMetaTable.TrustLevel.VERIFIED) { if (trusted != Database.IdentityMetaTable.TrustLevel.TRUSTED && trusted != Database.IdentityMetaTable.TrustLevel.VERIFIED) {
module.untrust_device(jid, device_id); module.untrust_device(jid, device_id);
} else { } else {
if(account.bare_jid.equals(jid) || (msg.counterpart != null && msg.counterpart.equals_bare(jid))) { if(account.bare_jid.equals(jid) || (msg.counterpart != null && (msg.counterpart.equals_bare(jid) || occupants.contains(jid)))) {
session_created = module.start_session(stream, jid, device_id, bundle); session_created = module.start_session(stream, jid, device_id, bundle);
} }
} }
if (account.bare_jid.equals(jid) && session_created) { if (account.bare_jid.equals(jid) && session_created) {
state.waiting_own_sessions--; state.waiting_own_sessions--;
} else if (msg.counterpart != null && msg.counterpart.equals_bare(jid) && session_created) { } else if (msg.counterpart != null && (msg.counterpart.equals_bare(jid) || occupants.contains(jid)) && session_created) {
state.waiting_other_sessions--; state.waiting_other_sessions--;
} }
if (state.should_retry_now()){ if (state.should_retry_now()){
@ -303,7 +335,8 @@ public class Manager : StreamInteractionModule, Object {
if (stream == null) return false; if (stream == null) return false;
StreamModule? module = ((!)stream).get_module(StreamModule.IDENTITY); StreamModule? module = ((!)stream).get_module(StreamModule.IDENTITY);
if (module == null) return false; if (module == null) return false;
return ((!)module).is_known_address(conversation.counterpart.bare_jid); //return ((!)module).is_known_address(conversation.counterpart.bare_jid);
return true;
} }
public static void start(StreamInteractor stream_interactor, Database db) { public static void start(StreamInteractor stream_interactor, Database db) {

97
plugins/omemo/src/stream_module.vala
View file

@ -21,23 +21,35 @@ public class StreamModule : XmppStreamModule {
private ConcurrentSet<Jid> active_devicelist_requests = new ConcurrentSet<Jid>(); private ConcurrentSet<Jid> active_devicelist_requests = new ConcurrentSet<Jid>();
private Map<Jid, ArrayList<int32>> device_lists = new HashMap<Jid, ArrayList<int32>>(Jid.hash_bare_func, Jid.equals_bare_func); private Map<Jid, ArrayList<int32>> device_lists = new HashMap<Jid, ArrayList<int32>>(Jid.hash_bare_func, Jid.equals_bare_func);
private Map<Jid, ArrayList<int32>> ignored_devices = new HashMap<Jid, ArrayList<int32>>(Jid.hash_bare_func, Jid.equals_bare_func); private Map<Jid, ArrayList<int32>> ignored_devices = new HashMap<Jid, ArrayList<int32>>(Jid.hash_bare_func, Jid.equals_bare_func);
private Map<Jid, Gee.List<Jid>> occupants = new HashMap<Jid, ArrayList<Jid>>(Jid.hash_bare_func, Jid.equals_bare_func);
private ReceivedPipelineListener received_pipeline_listener; private ReceivedPipelineListener received_pipeline_listener;
public signal void store_created(Store store); public signal void store_created(Store store);
public signal void device_list_loaded(Jid jid); public signal void device_list_loaded(Jid jid);
public signal void bundle_fetched(Jid jid, int device_id, Bundle bundle); public signal void bundle_fetched(Jid jid, int device_id, Bundle bundle);
public EncryptState encrypt(MessageStanza message, Jid self_jid) { public EncryptState encrypt(MessageStanza message, Jid self_jid, Gee.List<Jid> recipients) {
EncryptState status = new EncryptState(); EncryptState status = new EncryptState();
if (!Plugin.ensure_context()) return status; if (!Plugin.ensure_context()) return status;
if (message.to == null) return status; if (message.to == null) return status;
if(message.type_ == MessageStanza.TYPE_GROUPCHAT) {
occupants[message.to] = recipients;
}
try { try {
if (!device_lists.has_key(self_jid)) return status; if (!device_lists.has_key(self_jid)) return status;
status.own_list = true; status.own_list = true;
status.own_devices = device_lists.get(self_jid).size; status.own_devices = device_lists.get(self_jid).size;
if (!device_lists.has_key(message.to)) return status; status.other_waiting_lists = 0;
status.other_list = true; status.other_devices = 0;
status.other_devices = device_lists.get(message.to).size; foreach (Jid recipient in recipients) {
if (!device_lists.has_key(recipient)) {
status.other_waiting_lists++;
return status;
}
status.other_devices += device_lists.get(recipient).size;
}
if (status.own_devices == 0 || status.other_devices == 0) return status; if (status.own_devices == 0 || status.other_devices == 0) return status;
uint8[] key = new uint8[16]; uint8[] key = new uint8[16];
@ -57,19 +69,22 @@ public class StreamModule : XmppStreamModule {
.put_node(new StanzaNode.text(Base64.encode(ciphertext)))); .put_node(new StanzaNode.text(Base64.encode(ciphertext))));
Address address = new Address(message.to.bare_jid.to_string(), 0); Address address = new Address(message.to.bare_jid.to_string(), 0);
foreach(int32 device_id in device_lists[message.to]) { foreach (Jid recipient in recipients) {
if (is_ignored_device(message.to, device_id)) { foreach(int32 device_id in device_lists[recipient]) {
status.other_lost++; if (is_ignored_device(recipient, device_id)) {
continue; status.other_lost++;
} continue;
try { }
address.device_id = (int) device_id; try {
StanzaNode key_node = create_encrypted_key(key, address); address.name = recipient.bare_jid.to_string();
header.put_node(key_node); address.device_id = (int) device_id;
status.other_success++; StanzaNode key_node = create_encrypted_key(key, address);
} catch (Error e) { header.put_node(key_node);
if (e.code == ErrorCode.UNKNOWN) status.other_unknown++; status.other_success++;
else status.other_failure++; } catch (Error e) {
if (e.code == ErrorCode.UNKNOWN) status.other_unknown++;
else status.other_failure++;
}
} }
} }
address.name = self_jid.bare_jid.to_string(); address.name = self_jid.bare_jid.to_string();
@ -147,9 +162,18 @@ public class StreamModule : XmppStreamModule {
} }
public void request_user_devicelist(XmppStream stream, Jid jid) { public void request_user_devicelist(XmppStream stream, Jid jid) {
if (active_devicelist_requests.add(jid)) { Gee.List<Jid> recipients;
if (Plugin.DEBUG) print(@"OMEMO: requesting device list for $jid\n"); if (occupants.contains(jid)) {
stream.get_module(Pubsub.Module.IDENTITY).request(stream, jid, NODE_DEVICELIST, (stream, jid, id, node) => on_devicelist(stream, jid, id, node)); recipients = occupants.get(jid);
} else {
recipients = new ArrayList<Jid>(Jid.equals_bare_func);
recipients.add(jid);
}
foreach (Jid recipient in recipients) {
if (active_devicelist_requests.add(recipient)) {
if (Plugin.DEBUG) print(@"OMEMO: requesting device list for $jid\n");
stream.get_module(Pubsub.Module.IDENTITY).request(stream, recipient, NODE_DEVICELIST, (stream, jid, id, node) => on_devicelist(stream, jid, id, node));
}
} }
} }
@ -184,23 +208,32 @@ public class StreamModule : XmppStreamModule {
} }
public void fetch_bundles(XmppStream stream, Jid jid) { public void fetch_bundles(XmppStream stream, Jid jid) {
if (!device_lists.has_key(jid)) { Gee.List<Jid> recipients;
return; if (occupants.contains(jid)) {
recipients = occupants.get(jid);
} else {
recipients = new ArrayList<Jid>(Jid.equals_bare_func);
recipients.add(jid);
} }
Address address = new Address(jid.bare_jid.to_string(), 0); foreach (Jid recipient in recipients) {
foreach(int32 device_id in device_lists[jid]) { if (!device_lists.has_key(recipient)) {
if (!is_ignored_device(jid, device_id)) { return;
address.device_id = device_id; }
try { Address address = new Address(recipient.bare_jid.to_string(), 0);
if (!store.contains_session(address)) { foreach(int32 device_id in device_lists[recipient]) {
fetch_bundle(stream, jid, device_id); if (!is_ignored_device(recipient, device_id)) {
address.device_id = device_id;
try {
if (!store.contains_session(address)) {
fetch_bundle(stream, recipient, device_id);
}
} catch (Error e) {
// Ignore
} }
} catch (Error e) {
// Ignore
} }
} }
address.device_id = 0;
} }
address.device_id = 0;
} }
public void fetch_bundle(XmppStream stream, Jid jid, int device_id) { public void fetch_bundle(XmppStream stream, Jid jid, int device_id) {