2018-05-11 17:31:49 +02:00
|
|
|
|
// Converse.js
|
|
|
|
|
// http://conversejs.org
|
|
|
|
|
//
|
|
|
|
|
// Copyright (c) 2013-2018, the Converse.js developers
|
|
|
|
|
// Licensed under the Mozilla Public License (MPLv2)
|
|
|
|
|
|
2018-05-20 10:16:18 +02:00
|
|
|
|
/* global libsignal, ArrayBuffer, parseInt */
|
2018-05-12 23:26:14 +02:00
|
|
|
|
|
2018-05-11 17:31:49 +02:00
|
|
|
|
(function (root, factory) {
|
|
|
|
|
define([
|
|
|
|
|
"converse-core",
|
2018-06-30 23:03:36 +02:00
|
|
|
|
"templates/toolbar_omemo.html"
|
2018-05-11 17:31:49 +02:00
|
|
|
|
], factory);
|
2018-05-12 19:37:44 +02:00
|
|
|
|
}(this, function (converse, tpl_toolbar_omemo) {
|
2018-05-11 17:31:49 +02:00
|
|
|
|
|
2018-05-15 19:34:24 +02:00
|
|
|
|
const { Backbone, Promise, Strophe, moment, sizzle, $iq, $msg, _, b64_sha1 } = converse.env;
|
2018-05-12 23:26:14 +02:00
|
|
|
|
const u = converse.env.utils;
|
2018-05-11 17:31:49 +02:00
|
|
|
|
|
|
|
|
|
Strophe.addNamespace('OMEMO', "eu.siacs.conversations.axolotl");
|
|
|
|
|
Strophe.addNamespace('OMEMO_DEVICELIST', Strophe.NS.OMEMO+".devicelist");
|
|
|
|
|
Strophe.addNamespace('OMEMO_VERIFICATION', Strophe.NS.OMEMO+".verification");
|
|
|
|
|
Strophe.addNamespace('OMEMO_WHITELISTED', Strophe.NS.OMEMO+".whitelisted");
|
2018-05-12 23:26:14 +02:00
|
|
|
|
Strophe.addNamespace('OMEMO_BUNDLES', Strophe.NS.OMEMO+".bundles");
|
2018-05-11 17:31:49 +02:00
|
|
|
|
|
|
|
|
|
const UNDECIDED = 0;
|
|
|
|
|
const TRUSTED = 1;
|
|
|
|
|
const UNTRUSTED = -1;
|
|
|
|
|
|
2018-05-12 19:37:44 +02:00
|
|
|
|
|
2018-05-12 11:42:58 +02:00
|
|
|
|
function getDevicesForContact (_converse, jid) {
|
2018-05-11 22:05:45 +02:00
|
|
|
|
return new Promise((resolve, reject) => {
|
2018-05-12 11:42:58 +02:00
|
|
|
|
_converse.api.waitUntil('OMEMOInitialized').then(() => {
|
2018-05-12 19:37:44 +02:00
|
|
|
|
let devicelist = _converse.devicelists.get(jid);
|
|
|
|
|
if (_.isNil(devicelist)) {
|
|
|
|
|
devicelist = _converse.devicelists.create({'jid': jid});
|
|
|
|
|
}
|
|
|
|
|
devicelist.fetchDevices().then(() => resolve(devicelist.devices));
|
|
|
|
|
|
2018-05-12 11:42:58 +02:00
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function contactHasOMEMOSupport (_converse, jid) {
|
2018-05-12 23:26:14 +02:00
|
|
|
|
/* Checks whether the contact advertises any OMEMO-compatible devices. */
|
2018-05-12 11:42:58 +02:00
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
getDevicesForContact(_converse, jid).then((devices) => {
|
|
|
|
|
resolve(devices.length > 0)
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
2018-05-11 22:05:45 +02:00
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-20 10:16:18 +02:00
|
|
|
|
function parseBundle (bundle_el) {
|
|
|
|
|
/* Given an XML element representing a user's OMEMO bundle, parse it
|
|
|
|
|
* and return a map.
|
|
|
|
|
*/
|
|
|
|
|
const signed_prekey_public_el = bundle_el.querySelector('signedPreKeyPublic'),
|
2018-05-20 15:10:37 +02:00
|
|
|
|
signed_prekey_signature_el = bundle_el.querySelector('signedPreKeySignature'),
|
|
|
|
|
identity_key_el = bundle_el.querySelector('identityKey');
|
2018-05-20 10:16:18 +02:00
|
|
|
|
|
|
|
|
|
const prekeys = _.map(
|
2018-05-20 15:10:37 +02:00
|
|
|
|
sizzle(`prekeys > preKeyPublic`, bundle_el),
|
2018-05-20 10:16:18 +02:00
|
|
|
|
(el) => {
|
|
|
|
|
return {
|
2018-05-20 15:10:37 +02:00
|
|
|
|
'id': parseInt(el.getAttribute('preKeyId'), 10),
|
|
|
|
|
'key': el.textContent
|
2018-05-20 10:16:18 +02:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return {
|
2018-05-20 15:10:37 +02:00
|
|
|
|
'identity_key': parseInt(bundle_el.querySelector('identityKey').textContent, 10),
|
2018-05-20 10:16:18 +02:00
|
|
|
|
'signed_prekey': {
|
|
|
|
|
'id': parseInt(signed_prekey_public_el.getAttribute('signedPreKeyId'), 10),
|
2018-05-20 15:10:37 +02:00
|
|
|
|
'public_key': signed_prekey_public_el.textContent,
|
|
|
|
|
'signature': signed_prekey_signature_el.textContent
|
2018-05-20 10:16:18 +02:00
|
|
|
|
},
|
|
|
|
|
'prekeys': prekeys
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-11 22:05:45 +02:00
|
|
|
|
|
2018-05-11 17:31:49 +02:00
|
|
|
|
converse.plugins.add('converse-omemo', {
|
|
|
|
|
|
2018-05-11 22:05:45 +02:00
|
|
|
|
enabled (_converse) {
|
|
|
|
|
return !_.isNil(window.libsignal);
|
|
|
|
|
},
|
|
|
|
|
|
2018-05-12 23:26:14 +02:00
|
|
|
|
dependencies: ["converse-chatview"],
|
|
|
|
|
|
2018-05-11 17:31:49 +02:00
|
|
|
|
overrides: {
|
2018-05-15 17:27:07 +02:00
|
|
|
|
|
|
|
|
|
ChatBox: {
|
2018-05-15 19:34:24 +02:00
|
|
|
|
|
2018-05-20 15:10:37 +02:00
|
|
|
|
getBundlesAndBuildSessions () {
|
2018-05-19 09:37:22 +02:00
|
|
|
|
const { _converse } = this.__super__;
|
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
getDevicesForContact(this.get('jid'))
|
2018-05-20 10:16:18 +02:00
|
|
|
|
.then((devices) => {
|
2018-05-20 15:10:37 +02:00
|
|
|
|
const promises = _.map(devices, (device) => device.getBundle());
|
|
|
|
|
Promise.all(promises).then(() => {
|
2018-05-20 10:16:18 +02:00
|
|
|
|
this.buildSessions(devices)
|
2018-05-20 15:10:37 +02:00
|
|
|
|
.then(() => resolve(devices))
|
2018-05-20 10:16:18 +02:00
|
|
|
|
.catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
2018-05-19 09:37:22 +02:00
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
},
|
2018-05-15 19:34:24 +02:00
|
|
|
|
|
2018-05-20 10:16:18 +02:00
|
|
|
|
buildSessions (devices) {
|
2018-05-19 09:37:22 +02:00
|
|
|
|
const { _converse } = this.__super__,
|
|
|
|
|
device_id = _converse.omemo_store.get('device_id');
|
|
|
|
|
|
2018-05-20 10:16:18 +02:00
|
|
|
|
return Promise.all(_.map(devices, (device) => {
|
|
|
|
|
const recipient_id = device['id'];
|
2018-05-20 15:10:37 +02:00
|
|
|
|
const address = new libsignal.SignalProtocolAddress(parseInt(recipient_id, 10), device_id);
|
2018-05-19 09:37:22 +02:00
|
|
|
|
const sessionBuilder = new libsignal.SessionBuilder(_converse.omemo_store, address);
|
|
|
|
|
return sessionBuilder.processPreKey({
|
|
|
|
|
'registrationId': _converse.omemo_store.get('registration_id'),
|
|
|
|
|
'identityKey': _converse.omemo_store.get('identity_keypair'),
|
|
|
|
|
'signedPreKey': {
|
|
|
|
|
'keyId': '', // <Number>,
|
|
|
|
|
'publicKey': '', // <ArrayBuffer>,
|
|
|
|
|
'signature': '', // <ArrayBuffer>
|
|
|
|
|
},
|
|
|
|
|
'preKey': {
|
|
|
|
|
'keyId': '', // <Number>,
|
|
|
|
|
'publicKey': '', // <ArrayBuffer>
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}));
|
2018-05-15 19:34:24 +02:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
encryptMessage (message) {
|
|
|
|
|
// TODO:
|
|
|
|
|
// const { _converse } = this.__super__;
|
|
|
|
|
// const plaintext = message.get('message');
|
2018-05-19 09:37:22 +02:00
|
|
|
|
// const address = new libsignal.SignalProtocolAddress(recipientId, deviceId);
|
2018-05-15 19:34:24 +02:00
|
|
|
|
// return new Promise((resolve, reject) => {
|
|
|
|
|
// var sessionCipher = new window.libsignal.SessionCipher(_converse.omemo_store, address);
|
|
|
|
|
// sessionCipher.encrypt(plaintext).then((ciphertext) => {});
|
|
|
|
|
// });
|
|
|
|
|
},
|
2018-05-15 17:27:07 +02:00
|
|
|
|
|
2018-05-19 09:37:22 +02:00
|
|
|
|
createOMEMOMessageStanza (message, bundles) {
|
2018-05-15 17:27:07 +02:00
|
|
|
|
const { _converse } = this.__super__;
|
2018-05-19 09:37:22 +02:00
|
|
|
|
const body = "This is an OMEMO encrypted message which your client doesn’t seem to support. "+
|
2018-05-15 19:34:24 +02:00
|
|
|
|
"Find more information on https://conversations.im/omemo";
|
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
this.encryptMessage(message).then((payload) => {
|
|
|
|
|
const stanza = $msg({
|
|
|
|
|
'from': _converse.connection.jid,
|
|
|
|
|
'to': this.get('jid'),
|
|
|
|
|
'type': this.get('message_type'),
|
|
|
|
|
'id': message.get('msgid')
|
|
|
|
|
}).c('body').t(body).up()
|
2018-05-19 09:37:22 +02:00
|
|
|
|
.c('encrypted').t(payload)
|
|
|
|
|
.c('header').t(payload).up()
|
|
|
|
|
|
|
|
|
|
_.forEach(bundles, (bundle) => {
|
|
|
|
|
const prekey = bundle.prekeys[Math.random(bundle.prekeys.length)].textContent;
|
|
|
|
|
stanza('key', {'rid': bundle.identity_key}).t(prekey).up()
|
|
|
|
|
});
|
2018-05-15 19:34:24 +02:00
|
|
|
|
// TODO: set storage hint urn:xmpp:hints
|
|
|
|
|
resolve(stanza);
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
});
|
2018-05-15 17:27:07 +02:00
|
|
|
|
},
|
|
|
|
|
|
2018-05-15 19:34:24 +02:00
|
|
|
|
createMessageStanza (message) {
|
2018-05-15 17:27:07 +02:00
|
|
|
|
if (this.get('omemo_active')) {
|
2018-05-20 15:10:37 +02:00
|
|
|
|
return this.getBundlesAndBuildSessions()
|
2018-05-20 10:16:18 +02:00
|
|
|
|
.then((bundles) => this.createOMEMOMessageStanza(message, bundles));
|
2018-05-15 17:27:07 +02:00
|
|
|
|
} else {
|
2018-05-15 19:34:24 +02:00
|
|
|
|
return Promise.resolve(this.__super__.createMessageStanza.apply(this, arguments));
|
2018-05-15 17:27:07 +02:00
|
|
|
|
}
|
2018-05-15 19:34:24 +02:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
sendMessageStanza (message) {
|
|
|
|
|
const { _converse } = this.__super__;
|
|
|
|
|
|
|
|
|
|
// TODO: merge this back into converse-chatboxes
|
|
|
|
|
this.createMessageStanza(message).then((stanza) => {
|
|
|
|
|
_converse.connection.send(stanza);
|
|
|
|
|
if (_converse.forward_messages) {
|
|
|
|
|
// Forward the message, so that other connected resources are also aware of it.
|
|
|
|
|
_converse.connection.send(
|
|
|
|
|
$msg({
|
|
|
|
|
'to': _converse.bare_jid,
|
|
|
|
|
'type': this.get('message_type'),
|
|
|
|
|
'id': message.get('msgid')
|
|
|
|
|
}).c('forwarded', {'xmlns': Strophe.NS.FORWARD})
|
|
|
|
|
.c('delay', {
|
|
|
|
|
'xmns': Strophe.NS.DELAY,
|
|
|
|
|
'stamp': moment().format()
|
|
|
|
|
}).up()
|
|
|
|
|
.cnode(stanza.tree())
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
},
|
2018-05-15 17:27:07 +02:00
|
|
|
|
},
|
|
|
|
|
|
2018-05-11 17:31:49 +02:00
|
|
|
|
ChatBoxView: {
|
2018-05-12 19:37:44 +02:00
|
|
|
|
events: {
|
2018-05-12 23:26:14 +02:00
|
|
|
|
'click .toggle-omemo': 'toggleOMEMO'
|
2018-05-12 19:37:44 +02:00
|
|
|
|
},
|
|
|
|
|
|
2018-05-15 16:37:25 +02:00
|
|
|
|
renderOMEMOToolbarButton () {
|
|
|
|
|
const { _converse } = this.__super__,
|
|
|
|
|
{ __ } = _converse;
|
|
|
|
|
contactHasOMEMOSupport(_converse, this.model.get('jid')).then((support) => {
|
|
|
|
|
if (support) {
|
|
|
|
|
const icon = this.el.querySelector('.toggle-omemo'),
|
|
|
|
|
html = tpl_toolbar_omemo(_.extend(this.model.toJSON(), {'__': __}));
|
|
|
|
|
if (icon) {
|
|
|
|
|
icon.outerHTML = html;
|
|
|
|
|
} else {
|
|
|
|
|
this.el.querySelector('.chat-toolbar').insertAdjacentHTML('beforeend', html);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
},
|
|
|
|
|
|
2018-05-12 19:37:44 +02:00
|
|
|
|
toggleOMEMO (ev) {
|
|
|
|
|
ev.preventDefault();
|
2018-05-13 15:46:37 +02:00
|
|
|
|
this.model.save({'omemo_active': !this.model.get('omemo_active')});
|
2018-05-15 16:37:25 +02:00
|
|
|
|
this.renderOMEMOToolbarButton();
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
initialize () {
|
|
|
|
|
/* The initialize function gets called as soon as the plugin is
|
|
|
|
|
* loaded by Converse.js's plugin machinery.
|
|
|
|
|
*/
|
|
|
|
|
const { _converse } = this;
|
|
|
|
|
|
2018-05-11 22:05:45 +02:00
|
|
|
|
_converse.api.promises.add(['OMEMOInitialized']);
|
|
|
|
|
|
2018-05-15 19:34:24 +02:00
|
|
|
|
|
|
|
|
|
function generateDeviceID () {
|
|
|
|
|
/* Generates a device ID, making sure that it's unique */
|
|
|
|
|
const existing_ids = _converse.devicelists.get(_converse.bare_jid).devices.pluck('id');
|
|
|
|
|
let device_id = libsignal.KeyHelper.generateRegistrationId();
|
|
|
|
|
let i = 0;
|
|
|
|
|
while (_.includes(existing_ids, device_id)) {
|
|
|
|
|
device_id = libsignal.KeyHelper.generateRegistrationId();
|
|
|
|
|
i++;
|
|
|
|
|
if (i == 10) {
|
|
|
|
|
throw new Error("Unable to generate a unique device ID");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return device_id;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-05-12 23:26:14 +02:00
|
|
|
|
function generateBundle () {
|
2018-05-15 19:34:24 +02:00
|
|
|
|
/* The first thing that needs to happen if a client wants to
|
|
|
|
|
* start using OMEMO is they need to generate an IdentityKey
|
|
|
|
|
* and a Device ID. The IdentityKey is a Curve25519 [6]
|
|
|
|
|
* public/private Key pair. The Device ID is a randomly
|
|
|
|
|
* generated integer between 1 and 2^31 - 1.
|
|
|
|
|
*/
|
2018-05-12 23:26:14 +02:00
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
libsignal.KeyHelper.generateIdentityKeyPair().then((identity_keypair) => {
|
|
|
|
|
const data = {
|
2018-05-15 19:34:24 +02:00
|
|
|
|
'device_id': generateDeviceID(),
|
|
|
|
|
'identity_keypair': identity_keypair,
|
2018-05-12 23:26:14 +02:00
|
|
|
|
'prekeys': {}
|
|
|
|
|
};
|
|
|
|
|
const signed_prekey_id = '0';
|
|
|
|
|
libsignal.KeyHelper.generateSignedPreKey(identity_keypair, signed_prekey_id)
|
|
|
|
|
.then((signed_prekey) => {
|
|
|
|
|
data['signed_prekey'] = signed_prekey;
|
|
|
|
|
const key_promises = _.map(_.range(0, 100), (id) => libsignal.KeyHelper.generatePreKey(id));
|
|
|
|
|
Promise.all(key_promises).then((keys) => {
|
|
|
|
|
data['prekeys'] = keys;
|
|
|
|
|
resolve(data)
|
|
|
|
|
});
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
});
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
}
|
2018-05-11 22:05:45 +02:00
|
|
|
|
|
2018-05-12 23:26:14 +02:00
|
|
|
|
|
|
|
|
|
_converse.OMEMOStore = Backbone.Model.extend({
|
2018-05-11 17:31:49 +02:00
|
|
|
|
|
2018-05-15 19:34:24 +02:00
|
|
|
|
Direction: {
|
|
|
|
|
SENDING: 1,
|
|
|
|
|
RECEIVING: 2,
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
getIdentityKeyPair () {
|
|
|
|
|
return Promise.resolve(this.get('identity_keypair'));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
getLocalRegistrationId () {
|
|
|
|
|
return Promise.resolve(this.get('device_id'));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
isTrustedIdentity (identifier, identity_key, direction) {
|
|
|
|
|
if (_.isNil(identifier)) {
|
|
|
|
|
throw new Error("Can't check identity key for invalid key");
|
|
|
|
|
}
|
|
|
|
|
if (!(identity_key instanceof ArrayBuffer)) {
|
|
|
|
|
throw new Error("Expected identity_key to be an ArrayBuffer");
|
|
|
|
|
}
|
|
|
|
|
const trusted = this.get('identity_key'+identifier);
|
|
|
|
|
if (trusted === undefined) {
|
|
|
|
|
return Promise.resolve(true);
|
|
|
|
|
}
|
2018-05-20 10:16:18 +02:00
|
|
|
|
return Promise.resolve(u.arrayBufferToString(identity_key) === u.arrayBufferToString(trusted));
|
2018-05-15 19:34:24 +02:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
loadIdentityKey (identifier) {
|
|
|
|
|
if (_.isNil(identifier)) {
|
|
|
|
|
throw new Error("Can't load identity_key for invalid identifier");
|
|
|
|
|
}
|
|
|
|
|
return Promise.resolve(this.get('identity_key'+identifier));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
saveIdentity (identifier, identity_key) {
|
|
|
|
|
if (_.isNil(identifier)) {
|
|
|
|
|
throw new Error("Can't save identity_key for invalid identifier");
|
|
|
|
|
}
|
|
|
|
|
const address = new libsignal.SignalProtocolAddress.fromString(identifier),
|
|
|
|
|
existing = this.get('identity_key'+address.getName());
|
|
|
|
|
this.save('identity_key'+address.getName(), identity_key)
|
2018-05-20 10:16:18 +02:00
|
|
|
|
if (existing && u.arrayBufferToString(identity_key) !== u.arrayBufferToString(existing)) {
|
2018-05-15 19:34:24 +02:00
|
|
|
|
return Promise.resolve(true);
|
|
|
|
|
} else {
|
|
|
|
|
return Promise.resolve(false);
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
loadPreKey (keyId) {
|
|
|
|
|
let res = this.get('25519KeypreKey'+keyId);
|
|
|
|
|
if (_.isUndefined(res)) {
|
|
|
|
|
res = {'pubKey': res.pubKey, 'privKey': res.privKey};
|
|
|
|
|
}
|
|
|
|
|
return Promise.resolve(res);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
storePreKey (keyId, keyPair) {
|
|
|
|
|
return Promise.resolve(this.save('25519KeypreKey'+keyId, keyPair));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
removePreKey (keyId) {
|
|
|
|
|
return Promise.resolve(this.unset('25519KeypreKey'+keyId));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
loadSignedPreKey (keyId) {
|
|
|
|
|
let res = this.get('25519KeysignedKey'+keyId);
|
|
|
|
|
if (res !== undefined) {
|
|
|
|
|
res = {'pubKey': res.pubKey, 'privKey': res.privKey};
|
|
|
|
|
}
|
|
|
|
|
return Promise.resolve(res);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
storeSignedPreKey (keyId, keyPair) {
|
|
|
|
|
return Promise.resolve(this.save('25519KeysignedKey'+keyId, keyPair));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
removeSignedPreKey (keyId) {
|
|
|
|
|
return Promise.resolve(this.unset('25519KeysignedKey'+keyId));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
loadSession (identifier) {
|
|
|
|
|
return Promise.resolve(this.get('session'+identifier));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
storeSession (identifier, record) {
|
|
|
|
|
return Promise.resolve(this.save('session'+identifier, record));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
removeSession (identifier) {
|
|
|
|
|
return Promise.resolve(this.unset('session'+identifier));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
removeAllSessions (identifier) {
|
|
|
|
|
const keys = _.filter(_.keys(this.attributes), (key) => {
|
|
|
|
|
if (key.startsWith('session'+identifier)) {
|
|
|
|
|
return key;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
const attrs = {};
|
|
|
|
|
_.forEach(keys, (key) => {attrs[key] = undefined});
|
|
|
|
|
this.save(attrs);
|
|
|
|
|
return Promise.resolve();
|
|
|
|
|
},
|
|
|
|
|
|
2018-05-11 17:31:49 +02:00
|
|
|
|
fetchSession () {
|
2018-05-12 23:26:14 +02:00
|
|
|
|
if (_.isUndefined(this._setup_promise)) {
|
|
|
|
|
this._setup_promise = new Promise((resolve, reject) => {
|
|
|
|
|
this.fetch({
|
|
|
|
|
'success': () => {
|
|
|
|
|
if (!_converse.omemo_store.get('device_id')) {
|
|
|
|
|
generateBundle()
|
|
|
|
|
.then((data) => {
|
2018-05-20 10:16:18 +02:00
|
|
|
|
// TODO: should storeSession be used here?
|
2018-05-12 23:26:14 +02:00
|
|
|
|
_converse.omemo_store.save(data);
|
|
|
|
|
resolve();
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
|
|
|
|
} else {
|
2018-05-11 17:31:49 +02:00
|
|
|
|
resolve();
|
2018-05-12 23:26:14 +02:00
|
|
|
|
}
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
2018-05-12 23:26:14 +02:00
|
|
|
|
});
|
2018-05-11 17:31:49 +02:00
|
|
|
|
});
|
2018-05-12 23:26:14 +02:00
|
|
|
|
}
|
|
|
|
|
return this._setup_promise;
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
_converse.Device = Backbone.Model.extend({
|
|
|
|
|
defaults: {
|
|
|
|
|
'active': true,
|
|
|
|
|
'trusted': UNDECIDED
|
2018-05-20 15:10:37 +02:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
fetchBundleFromServer () {
|
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
const stanza = $iq({
|
|
|
|
|
'type': 'get',
|
|
|
|
|
'from': _converse.bare_jid,
|
|
|
|
|
'to': this.get('jid')
|
|
|
|
|
}).c('pubsub', {'xmlns': Strophe.NS.PUBSUB})
|
|
|
|
|
.c('items', {'xmlns': `${Strophe.NS.OMEMO_BUNDLES}:${this.get('id')}`});
|
|
|
|
|
_converse.connection.sendIQ(
|
|
|
|
|
stanza,
|
|
|
|
|
(iq) => {
|
|
|
|
|
const publish_el = sizzle(`items[node="${Strophe.NS.OMEMO_BUNDLES}:${this.get('id')}"]`, stanza).pop();
|
|
|
|
|
const bundle_el = sizzle(`bundle[xmlns="${Strophe.NS.OMEMO}"]`, publish_el).pop();
|
|
|
|
|
this.save(parseBundle(bundle_el));
|
|
|
|
|
resolve();
|
|
|
|
|
},
|
|
|
|
|
reject,
|
|
|
|
|
_converse.IQ_TIMEOUT
|
|
|
|
|
);
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
getBundle () {
|
|
|
|
|
/* Fetch and save the bundle information associated with
|
|
|
|
|
* this device, if the information is not at hand already.
|
|
|
|
|
*/
|
|
|
|
|
if (this.get('bundle')) {
|
|
|
|
|
return Promise.resolve(this.get('bundle').toJSON());
|
|
|
|
|
} else {
|
|
|
|
|
return this.fetchBundleFromServer();
|
|
|
|
|
}
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
_converse.Devices = Backbone.Collection.extend({
|
|
|
|
|
model: _converse.Device,
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
_converse.DeviceList = Backbone.Model.extend({
|
|
|
|
|
idAttribute: 'jid',
|
|
|
|
|
|
|
|
|
|
initialize () {
|
|
|
|
|
this.devices = new _converse.Devices();
|
2018-05-12 11:42:58 +02:00
|
|
|
|
this.devices.browserStorage = new Backbone.BrowserStorage.session(
|
|
|
|
|
b64_sha1(`converse.devicelist-${_converse.bare_jid}-${this.get('jid')}`)
|
|
|
|
|
);
|
2018-05-12 12:39:28 +02:00
|
|
|
|
this.fetchDevices();
|
2018-05-11 17:31:49 +02:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
fetchDevices () {
|
2018-05-12 12:39:28 +02:00
|
|
|
|
if (_.isUndefined(this._devices_promise)) {
|
|
|
|
|
this._devices_promise = new Promise((resolve, reject) => {
|
|
|
|
|
this.devices.fetch({
|
|
|
|
|
'success': (collection) => {
|
|
|
|
|
if (collection.length === 0) {
|
|
|
|
|
this.fetchDevicesFromServer().then(resolve).catch(reject);
|
|
|
|
|
} else {
|
|
|
|
|
resolve();
|
|
|
|
|
}
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
2018-05-12 12:39:28 +02:00
|
|
|
|
});
|
2018-05-11 17:31:49 +02:00
|
|
|
|
});
|
2018-05-12 12:39:28 +02:00
|
|
|
|
}
|
|
|
|
|
return this._devices_promise;
|
2018-05-11 17:31:49 +02:00
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
fetchDevicesFromServer () {
|
2018-05-12 19:37:44 +02:00
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
const stanza = $iq({
|
|
|
|
|
'type': 'get',
|
|
|
|
|
'from': _converse.bare_jid,
|
|
|
|
|
'to': this.get('jid')
|
|
|
|
|
}).c('query', {
|
|
|
|
|
'xmlns': Strophe.NS.DISCO_ITEMS,
|
|
|
|
|
'node': Strophe.NS.OMEMO_DEVICELIST
|
|
|
|
|
});
|
|
|
|
|
_converse.connection.sendIQ(
|
|
|
|
|
stanza,
|
|
|
|
|
(iq) => {
|
|
|
|
|
_.forEach(
|
|
|
|
|
iq.querySelectorAll('device'),
|
|
|
|
|
(dev) => this.devices.create({'id': dev.getAttribute('id')})
|
|
|
|
|
);
|
|
|
|
|
resolve();
|
|
|
|
|
},
|
|
|
|
|
reject,
|
|
|
|
|
_converse.IQ_TIMEOUT);
|
|
|
|
|
});
|
2018-05-13 14:12:53 +02:00
|
|
|
|
},
|
|
|
|
|
|
2018-05-13 16:04:52 +02:00
|
|
|
|
addDeviceToList (device_id) {
|
2018-05-13 14:12:53 +02:00
|
|
|
|
/* Add this device to our list of devices stored on the
|
|
|
|
|
* server.
|
|
|
|
|
* https://xmpp.org/extensions/xep-0384.html#usecases-announcing
|
|
|
|
|
*/
|
2018-05-13 16:04:52 +02:00
|
|
|
|
this.devices.create({'id': device_id});
|
2018-05-13 14:12:53 +02:00
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
const stanza = $iq({
|
|
|
|
|
'from': _converse.bare_jid,
|
|
|
|
|
'type': 'set'
|
|
|
|
|
}).c('pubsub', {'xmlns': Strophe.NS.PUBSUB})
|
2018-05-20 13:41:16 +02:00
|
|
|
|
.c('publish', {'node': Strophe.NS.OMEMO_DEVICELIST})
|
2018-05-13 14:12:53 +02:00
|
|
|
|
.c('item')
|
|
|
|
|
.c('list', {'xmlns': Strophe.NS.OMEMO}).up()
|
|
|
|
|
|
2018-05-20 13:41:16 +02:00
|
|
|
|
_.each(this.devices.where({'active': true}), (device) => {
|
2018-05-13 14:12:53 +02:00
|
|
|
|
stanza.c('device', {'id': device.get('id')}).up();
|
|
|
|
|
});
|
|
|
|
|
_converse.connection.sendIQ(stanza, resolve, reject, _converse.IQ_TIMEOUT);
|
|
|
|
|
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
_converse.DeviceLists = Backbone.Collection.extend({
|
|
|
|
|
model: _converse.DeviceList,
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function publishBundle () {
|
2018-05-12 23:26:14 +02:00
|
|
|
|
const store = _converse.omemo_store,
|
2018-05-15 19:34:24 +02:00
|
|
|
|
signed_prekey = store.get('signed_prekey'),
|
2018-05-20 10:16:18 +02:00
|
|
|
|
identity_key = u.arrayBufferToBase64(store.get('identity_keypair').pubKey);
|
2018-05-15 19:34:24 +02:00
|
|
|
|
|
2018-05-12 23:26:14 +02:00
|
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
|
const stanza = $iq({
|
|
|
|
|
'from': _converse.bare_jid,
|
|
|
|
|
'type': 'set'
|
|
|
|
|
}).c('pubsub', {'xmlns': Strophe.NS.PUBSUB})
|
|
|
|
|
.c('publish', {'node': `${Strophe.NS.OMEMO_BUNDLES}:${store.get('device_id')}`})
|
|
|
|
|
.c('item')
|
|
|
|
|
.c('bundle', {'xmlns': Strophe.NS.OMEMO})
|
|
|
|
|
.c('signedPreKeyPublic', {'signedPreKeyId': signed_prekey.keyId})
|
2018-05-20 10:16:18 +02:00
|
|
|
|
.t(u.arrayBufferToBase64(signed_prekey.keyPair.pubKey)).up()
|
2018-05-15 19:34:24 +02:00
|
|
|
|
.c('signedPreKeySignature').up() // TODO
|
|
|
|
|
.c('identityKey').t(identity_key).up()
|
2018-05-12 23:26:14 +02:00
|
|
|
|
.c('prekeys');
|
|
|
|
|
_.forEach(
|
|
|
|
|
store.get('prekeys'),
|
|
|
|
|
(prekey) => {
|
|
|
|
|
stanza.c('preKeyPublic', {'preKeyId': prekey.keyId})
|
2018-05-20 10:16:18 +02:00
|
|
|
|
.t(u.arrayBufferToBase64(prekey.keyPair.pubKey)).up();
|
2018-05-12 23:26:14 +02:00
|
|
|
|
});
|
|
|
|
|
_converse.connection.sendIQ(stanza, resolve, reject, _converse.IQ_TIMEOUT);
|
|
|
|
|
});
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function fetchDeviceLists () {
|
|
|
|
|
return new Promise((resolve, reject) => _converse.devicelists.fetch({'success': resolve}));
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-13 14:12:53 +02:00
|
|
|
|
function fetchOwnDevices () {
|
2018-05-12 11:42:58 +02:00
|
|
|
|
return new Promise((resolve, reject) => {
|
2018-05-12 23:26:14 +02:00
|
|
|
|
fetchDeviceLists().then(() => {
|
|
|
|
|
let own_devicelist = _converse.devicelists.get(_converse.bare_jid);
|
|
|
|
|
if (_.isNil(own_devicelist)) {
|
|
|
|
|
own_devicelist = _converse.devicelists.create({'jid': _converse.bare_jid});
|
|
|
|
|
}
|
|
|
|
|
own_devicelist.fetchDevices().then(resolve).catch(reject);
|
|
|
|
|
});
|
2018-05-12 11:42:58 +02:00
|
|
|
|
});
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-13 14:12:53 +02:00
|
|
|
|
function updateOwnDeviceList () {
|
|
|
|
|
/* If our own device is not on the list, add it.
|
|
|
|
|
* Also, deduplicate devices if necessary.
|
|
|
|
|
*/
|
2018-05-20 13:41:16 +02:00
|
|
|
|
const devicelist = _converse.devicelists.get(_converse.bare_jid),
|
|
|
|
|
device_id = _converse.omemo_store.get('device_id'),
|
|
|
|
|
own_device = devicelist.devices.findWhere({'id': device_id});
|
|
|
|
|
|
|
|
|
|
if (!own_device) {
|
|
|
|
|
return devicelist.addDeviceToList(device_id);
|
|
|
|
|
} else if (!own_device.get('active')) {
|
|
|
|
|
own_device.set('active', true, {'silent': true});
|
|
|
|
|
return devicelist.addDeviceToList(device_id);
|
|
|
|
|
} else {
|
|
|
|
|
return Promise.resolve();
|
|
|
|
|
}
|
2018-05-13 14:12:53 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-20 10:16:18 +02:00
|
|
|
|
|
|
|
|
|
function updateBundleFromStanza (stanza) {
|
2018-05-20 15:10:37 +02:00
|
|
|
|
const items_el = sizzle(`items`, stanza).pop();
|
|
|
|
|
if (!items_el || !items_el.getAttribute('node').startsWith(Strophe.NS.OMEMO_BUNDLES)) {
|
2018-05-20 13:41:16 +02:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
const device_id = items_el.getAttribute('node').split(':')[1],
|
2018-05-20 15:10:37 +02:00
|
|
|
|
jid = stanza.getAttribute('from'),
|
|
|
|
|
bundle_el = sizzle(`item > bundle`, items_el).pop(),
|
|
|
|
|
devicelist = _converse.devicelists.get(jid) || _converse.devicelists.create({'jid': jid}),
|
|
|
|
|
device = devicelist.devices.get(device_id) || devicelist.devices.create({'id': device_id});
|
2018-05-20 13:41:16 +02:00
|
|
|
|
device.save({'bundle': parseBundle(bundle_el)});
|
2018-05-20 10:16:18 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-11 17:31:49 +02:00
|
|
|
|
function updateDevicesFromStanza (stanza) {
|
2018-05-20 13:41:16 +02:00
|
|
|
|
const items_el = sizzle(`items[node="${Strophe.NS.OMEMO_DEVICELIST}"]`, stanza).pop();
|
|
|
|
|
if (!items_el) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2018-05-11 17:31:49 +02:00
|
|
|
|
const device_ids = _.map(
|
2018-05-20 13:41:16 +02:00
|
|
|
|
sizzle(`item list[xmlns="${Strophe.NS.OMEMO}"] device`, items_el),
|
|
|
|
|
(device) => device.getAttribute('id')
|
|
|
|
|
);
|
|
|
|
|
const jid = stanza.getAttribute('from'),
|
|
|
|
|
devicelist = _converse.devicelists.get(jid) || _converse.devicelists.create({'jid': jid}),
|
|
|
|
|
devices = devicelist.devices,
|
|
|
|
|
removed_ids = _.difference(devices.pluck('id'), device_ids);
|
2018-05-11 17:31:49 +02:00
|
|
|
|
|
2018-05-20 13:41:16 +02:00
|
|
|
|
_.forEach(removed_ids, (removed_id) => devices.get(removed_id).set('active', false));
|
2018-05-11 17:31:49 +02:00
|
|
|
|
_.forEach(device_ids, (device_id) => {
|
2018-05-20 13:41:16 +02:00
|
|
|
|
const dev = devices.get(device_id);
|
2018-05-11 17:31:49 +02:00
|
|
|
|
if (dev) {
|
|
|
|
|
dev.save({'active': true});
|
|
|
|
|
} else {
|
2018-05-20 13:41:16 +02:00
|
|
|
|
devices.create({'id': device_id})
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
});
|
2018-05-20 13:41:16 +02:00
|
|
|
|
// Make sure our own device is on the list (i.e. if it was
|
|
|
|
|
// removed, add it again.
|
|
|
|
|
updateOwnDeviceList();
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function registerPEPPushHandler () {
|
|
|
|
|
// Add a handler for devices pushed from other connected clients
|
|
|
|
|
_converse.connection.addHandler((message) => {
|
|
|
|
|
if (message.querySelector('event[xmlns="'+Strophe.NS.PUBSUB+'#event"]')) {
|
2018-05-13 13:11:11 +02:00
|
|
|
|
updateDevicesFromStanza(message);
|
2018-05-20 10:16:18 +02:00
|
|
|
|
updateBundleFromStanza(message);
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
2018-05-20 13:41:16 +02:00
|
|
|
|
return true;
|
|
|
|
|
}, null, 'message', 'headline');
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-12 23:26:14 +02:00
|
|
|
|
function restoreOMEMOSession () {
|
2018-05-13 16:04:52 +02:00
|
|
|
|
if (_.isUndefined(_converse.omemo_store)) {
|
|
|
|
|
_converse.omemo_store = new _converse.OMEMOStore();
|
2018-05-20 10:16:18 +02:00
|
|
|
|
_converse.omemo_store.browserStorage = new Backbone.BrowserStorage[_converse.storage](
|
2018-05-13 16:04:52 +02:00
|
|
|
|
b64_sha1(`converse.omemosession-${_converse.bare_jid}`)
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
return _converse.omemo_store.fetchSession();
|
2018-05-12 23:26:14 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-05-13 13:11:11 +02:00
|
|
|
|
function initOMEMO() {
|
2018-05-11 17:31:49 +02:00
|
|
|
|
_converse.devicelists = new _converse.DeviceLists();
|
2018-05-20 10:16:18 +02:00
|
|
|
|
_converse.devicelists.browserStorage = new Backbone.BrowserStorage[_converse.storage](
|
2018-05-11 17:31:49 +02:00
|
|
|
|
b64_sha1(`converse.devicelists-${_converse.bare_jid}`)
|
|
|
|
|
);
|
2018-05-13 16:04:52 +02:00
|
|
|
|
fetchOwnDevices()
|
2018-05-20 13:41:16 +02:00
|
|
|
|
.then(() => restoreOMEMOSession())
|
2018-05-13 13:11:11 +02:00
|
|
|
|
.then(() => updateOwnDeviceList())
|
2018-05-13 16:04:52 +02:00
|
|
|
|
.then(() => publishBundle())
|
2018-05-13 13:11:11 +02:00
|
|
|
|
.then(() => _converse.emit('OMEMOInitialized'))
|
|
|
|
|
.catch(_.partial(_converse.log, _, Strophe.LogLevel.ERROR));
|
2018-05-11 17:31:49 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_converse.api.listen.on('afterTearDown', () => _converse.devices.reset());
|
2018-05-13 13:11:11 +02:00
|
|
|
|
_converse.api.listen.on('connected', registerPEPPushHandler);
|
2018-05-15 16:37:25 +02:00
|
|
|
|
_converse.api.listen.on('renderToolbar', (view) => view.renderOMEMOToolbarButton());
|
2018-05-13 13:11:11 +02:00
|
|
|
|
_converse.api.listen.on('statusInitialized', initOMEMO);
|
2018-05-11 17:31:49 +02:00
|
|
|
|
_converse.api.listen.on('addClientFeatures',
|
|
|
|
|
() => _converse.api.disco.own.features.add(Strophe.NS.OMEMO_DEVICELIST+"notify"));
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}));
|