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

Now we've got everything prettified!

Browse source
This commit is contained in:
Scott Nonnenberg 2018-05-02 09:51:22 -07:00
parent 754d65ae2e
commit a0ed993b42
30 changed files with 3562 additions and 2873 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.prettierignore
View file

@ -18,6 +18,8 @@ ts/**/*.js
components/* components/*
dist/* dist/*
libtextsecure/libsignal-protocol.js libtextsecure/libsignal-protocol.js
test/fixtures.js
test/blanket_mocha.js
/**/*.json /**/*.json
/**/*.css /**/*.css

117
libtextsecure/ProvisioningCipher.js
View file

@ -1,68 +1,85 @@
(function() { (function() {
'use strict'; 'use strict';
function ProvisioningCipher() {} function ProvisioningCipher() {}
ProvisioningCipher.prototype = { ProvisioningCipher.prototype = {
decrypt: function(provisionEnvelope) { decrypt: function(provisionEnvelope) {
var masterEphemeral = provisionEnvelope.publicKey.toArrayBuffer(); var masterEphemeral = provisionEnvelope.publicKey.toArrayBuffer();
var message = provisionEnvelope.body.toArrayBuffer(); var message = provisionEnvelope.body.toArrayBuffer();
if (new Uint8Array(message)[0] != 1) { if (new Uint8Array(message)[0] != 1) {
throw new Error("Bad version number on ProvisioningMessage"); throw new Error('Bad version number on ProvisioningMessage');
} }
var iv = message.slice(1, 16 + 1); var iv = message.slice(1, 16 + 1);
var mac = message.slice(message.byteLength - 32, message.byteLength); var mac = message.slice(message.byteLength - 32, message.byteLength);
var ivAndCiphertext = message.slice(0, message.byteLength - 32); var ivAndCiphertext = message.slice(0, message.byteLength - 32);
var ciphertext = message.slice(16 + 1, message.byteLength - 32); var ciphertext = message.slice(16 + 1, message.byteLength - 32);
return libsignal.Curve.async.calculateAgreement( return libsignal.Curve.async
masterEphemeral, this.keyPair.privKey .calculateAgreement(masterEphemeral, this.keyPair.privKey)
).then(function(ecRes) { .then(function(ecRes) {
return libsignal.HKDF.deriveSecrets( return libsignal.HKDF.deriveSecrets(
ecRes, new ArrayBuffer(32), "TextSecure Provisioning Message" ecRes,
); new ArrayBuffer(32),
}).then(function(keys) { 'TextSecure Provisioning Message'
return libsignal.crypto.verifyMAC(ivAndCiphertext, keys[1], mac, 32).then(function() { );
return libsignal.crypto.decrypt(keys[0], ciphertext, iv); })
.then(function(keys) {
return libsignal.crypto
.verifyMAC(ivAndCiphertext, keys[1], mac, 32)
.then(function() {
return libsignal.crypto.decrypt(keys[0], ciphertext, iv);
}); });
}).then(function(plaintext) { })
var provisionMessage = textsecure.protobuf.ProvisionMessage.decode(plaintext); .then(function(plaintext) {
var privKey = provisionMessage.identityKeyPrivate.toArrayBuffer(); var provisionMessage = textsecure.protobuf.ProvisionMessage.decode(
plaintext
);
var privKey = provisionMessage.identityKeyPrivate.toArrayBuffer();
return libsignal.Curve.async.createKeyPair(privKey).then(function(keyPair) { return libsignal.Curve.async
var ret = { .createKeyPair(privKey)
identityKeyPair : keyPair, .then(function(keyPair) {
number : provisionMessage.number, var ret = {
provisioningCode : provisionMessage.provisioningCode, identityKeyPair: keyPair,
userAgent : provisionMessage.userAgent, number: provisionMessage.number,
readReceipts : provisionMessage.readReceipts provisioningCode: provisionMessage.provisioningCode,
}; userAgent: provisionMessage.userAgent,
if (provisionMessage.profileKey) { readReceipts: provisionMessage.readReceipts,
ret.profileKey = provisionMessage.profileKey.toArrayBuffer(); };
} if (provisionMessage.profileKey) {
return ret; ret.profileKey = provisionMessage.profileKey.toArrayBuffer();
}
return ret;
}); });
}); });
}, },
getPublicKey: function() { getPublicKey: function() {
return Promise.resolve().then(function() { return Promise.resolve()
if (!this.keyPair) { .then(
return libsignal.Curve.async.generateKeyPair().then(function(keyPair) { function() {
if (!this.keyPair) {
return libsignal.Curve.async.generateKeyPair().then(
function(keyPair) {
this.keyPair = keyPair; this.keyPair = keyPair;
}.bind(this)); }.bind(this)
} );
}.bind(this)).then(function() { }
return this.keyPair.pubKey; }.bind(this)
}.bind(this)); )
} .then(
}; function() {
return this.keyPair.pubKey;
}.bind(this)
);
},
};
libsignal.ProvisioningCipher = function() { libsignal.ProvisioningCipher = function() {
var cipher = new ProvisioningCipher(); var cipher = new ProvisioningCipher();
this.decrypt = cipher.decrypt.bind(cipher); this.decrypt = cipher.decrypt.bind(cipher);
this.getPublicKey = cipher.getPublicKey.bind(cipher); this.getPublicKey = cipher.getPublicKey.bind(cipher);
}; };
})(); })();

469
libtextsecure/message_receiver.js
View file

@ -122,9 +122,10 @@ MessageReceiver.prototype.extend({
this.onEmpty(); this.onEmpty();
} }
// possible 403 or network issue. Make an request to confirm // possible 403 or network issue. Make an request to confirm
return this.server.getDevices(this.number) return this.server
.getDevices(this.number)
.then(this.connect.bind(this)) // No HTTP error? Reconnect .then(this.connect.bind(this)) // No HTTP error? Reconnect
.catch((e) => { .catch(e => {
const event = new Event('error'); const event = new Event('error');
event.error = e; event.error = e;
return this.dispatchAndWait(event); return this.dispatchAndWait(event);
@ -146,35 +147,41 @@ MessageReceiver.prototype.extend({
return; return;
} }
const promise = textsecure.crypto.decryptWebsocketMessage( const promise = textsecure.crypto
request.body, .decryptWebsocketMessage(request.body, this.signalingKey)
this.signalingKey .then(plaintext => {
).then((plaintext) => { const envelope = textsecure.protobuf.Envelope.decode(plaintext);
const envelope = textsecure.protobuf.Envelope.decode(plaintext); // After this point, decoding errors are not the server's
// After this point, decoding errors are not the server's // fault, and we should handle them gracefully and tell the
// fault, and we should handle them gracefully and tell the // user they received an invalid message
// user they received an invalid message
if (this.isBlocked(envelope.source)) { if (this.isBlocked(envelope.source)) {
return request.respond(200, 'OK'); return request.respond(200, 'OK');
} }
return this.addToCache(envelope, plaintext).then(() => { return this.addToCache(envelope, plaintext).then(
request.respond(200, 'OK'); () => {
this.queueEnvelope(envelope); request.respond(200, 'OK');
}, (error) => { this.queueEnvelope(envelope);
console.log( },
'handleRequest error trying to add message to cache:', error => {
error && error.stack ? error.stack : error console.log(
'handleRequest error trying to add message to cache:',
error && error.stack ? error.stack : error
);
}
); );
})
.catch(e => {
request.respond(500, 'Bad encrypted websocket message');
console.log(
'Error handling incoming message:',
e && e.stack ? e.stack : e
);
const ev = new Event('error');
ev.error = e;
return this.dispatchAndWait(ev);
}); });
}).catch((e) => {
request.respond(500, 'Bad encrypted websocket message');
console.log('Error handling incoming message:', e && e.stack ? e.stack : e);
const ev = new Event('error');
ev.error = e;
return this.dispatchAndWait(ev);
});
this.incoming.push(promise); this.incoming.push(promise);
}, },
@ -203,7 +210,7 @@ MessageReceiver.prototype.extend({
this.incoming = []; this.incoming = [];
const dispatchEmpty = () => { const dispatchEmpty = () => {
console.log('MessageReceiver: emitting \'empty\' event'); console.log("MessageReceiver: emitting 'empty' event");
const ev = new Event('empty'); const ev = new Event('empty');
return this.dispatchAndWait(ev); return this.dispatchAndWait(ev);
}; };
@ -224,9 +231,10 @@ MessageReceiver.prototype.extend({
const { incoming } = this; const { incoming } = this;
this.incoming = []; this.incoming = [];
const queueDispatch = () => this.addToQueue(() => { const queueDispatch = () =>
console.log('drained'); this.addToQueue(() => {
}); console.log('drained');
});
// This promise will resolve when there are no more messages to be processed. // This promise will resolve when there are no more messages to be processed.
return Promise.all(incoming).then(queueDispatch, queueDispatch); return Promise.all(incoming).then(queueDispatch, queueDispatch);
@ -241,7 +249,7 @@ MessageReceiver.prototype.extend({
this.dispatchEvent(ev); this.dispatchEvent(ev);
}, },
queueAllCached() { queueAllCached() {
return this.getAllFromCache().then((items) => { return this.getAllFromCache().then(items => {
for (let i = 0, max = items.length; i < max; i += 1) { for (let i = 0, max = items.length; i < max; i += 1) {
this.queueCached(items[i]); this.queueCached(items[i]);
} }
@ -273,7 +281,9 @@ MessageReceiver.prototype.extend({
} }
}, },
getEnvelopeId(envelope) { getEnvelopeId(envelope) {
return `${envelope.source}.${envelope.sourceDevice} ${envelope.timestamp.toNumber()}`; return `${envelope.source}.${
envelope.sourceDevice
} ${envelope.timestamp.toNumber()}`;
}, },
stringToArrayBuffer(string) { stringToArrayBuffer(string) {
// eslint-disable-next-line new-cap // eslint-disable-next-line new-cap
@ -281,23 +291,28 @@ MessageReceiver.prototype.extend({
}, },
getAllFromCache() { getAllFromCache() {
console.log('getAllFromCache'); console.log('getAllFromCache');
return textsecure.storage.unprocessed.getAll().then((items) => { return textsecure.storage.unprocessed.getAll().then(items => {
console.log('getAllFromCache loaded', items.length, 'saved envelopes'); console.log('getAllFromCache loaded', items.length, 'saved envelopes');
return Promise.all(_.map(items, (item) => { return Promise.all(
const attempts = 1 + (item.attempts || 0); _.map(items, item => {
if (attempts >= 5) { const attempts = 1 + (item.attempts || 0);
console.log('getAllFromCache final attempt for envelope', item.id); if (attempts >= 5) {
return textsecure.storage.unprocessed.remove(item.id); console.log('getAllFromCache final attempt for envelope', item.id);
return textsecure.storage.unprocessed.remove(item.id);
}
return textsecure.storage.unprocessed.update(item.id, { attempts });
})
).then(
() => items,
error => {
console.log(
'getAllFromCache error updating items after load:',
error && error.stack ? error.stack : error
);
return items;
} }
return textsecure.storage.unprocessed.update(item.id, { attempts }); );
})).then(() => items, (error) => {
console.log(
'getAllFromCache error updating items after load:',
error && error.stack ? error.stack : error
);
return items;
});
}); });
}, },
addToCache(envelope, plaintext) { addToCache(envelope, plaintext) {
@ -332,7 +347,7 @@ MessageReceiver.prototype.extend({
); );
const promise = this.addToQueue(taskWithTimeout); const promise = this.addToQueue(taskWithTimeout);
return promise.catch((error) => { return promise.catch(error => {
console.log( console.log(
'queueDecryptedEnvelope error handling envelope', 'queueDecryptedEnvelope error handling envelope',
id, id,
@ -346,10 +361,13 @@ MessageReceiver.prototype.extend({
console.log('queueing envelope', id); console.log('queueing envelope', id);
const task = this.handleEnvelope.bind(this, envelope); const task = this.handleEnvelope.bind(this, envelope);
const taskWithTimeout = textsecure.createTaskWithTimeout(task, `queueEnvelope ${id}`); const taskWithTimeout = textsecure.createTaskWithTimeout(
task,
`queueEnvelope ${id}`
);
const promise = this.addToQueue(taskWithTimeout); const promise = this.addToQueue(taskWithTimeout);
return promise.catch((error) => { return promise.catch(error => {
console.log( console.log(
'queueEnvelope error handling envelope', 'queueEnvelope error handling envelope',
id, id,
@ -448,46 +466,56 @@ MessageReceiver.prototype.extend({
switch (envelope.type) { switch (envelope.type) {
case textsecure.protobuf.Envelope.Type.CIPHERTEXT: case textsecure.protobuf.Envelope.Type.CIPHERTEXT:
console.log('message from', this.getEnvelopeId(envelope)); console.log('message from', this.getEnvelopeId(envelope));
promise = sessionCipher.decryptWhisperMessage(ciphertext).then(this.unpad); promise = sessionCipher
.decryptWhisperMessage(ciphertext)
.then(this.unpad);
break; break;
case textsecure.protobuf.Envelope.Type.PREKEY_BUNDLE: case textsecure.protobuf.Envelope.Type.PREKEY_BUNDLE:
console.log('prekey message from', this.getEnvelopeId(envelope)); console.log('prekey message from', this.getEnvelopeId(envelope));
promise = this.decryptPreKeyWhisperMessage(ciphertext, sessionCipher, address); promise = this.decryptPreKeyWhisperMessage(
ciphertext,
sessionCipher,
address
);
break; break;
default: default:
promise = Promise.reject(new Error('Unknown message type')); promise = Promise.reject(new Error('Unknown message type'));
} }
return promise.then(plaintext => this.updateCache( return promise
envelope, .then(plaintext =>
plaintext this.updateCache(envelope, plaintext).then(
).then(() => plaintext, (error) => { () => plaintext,
console.log( error => {
'decrypt failed to save decrypted message contents to cache:', console.log(
error && error.stack ? error.stack : error 'decrypt failed to save decrypted message contents to cache:',
); error && error.stack ? error.stack : error
return plaintext; );
})).catch((error) => { return plaintext;
let errorToThrow = error; }
)
)
.catch(error => {
let errorToThrow = error;
if (error.message === 'Unknown identity key') { if (error.message === 'Unknown identity key') {
// create an error that the UI will pick up and ask the // create an error that the UI will pick up and ask the
// user if they want to re-negotiate // user if they want to re-negotiate
const buffer = dcodeIO.ByteBuffer.wrap(ciphertext); const buffer = dcodeIO.ByteBuffer.wrap(ciphertext);
errorToThrow = new textsecure.IncomingIdentityKeyError( errorToThrow = new textsecure.IncomingIdentityKeyError(
address.toString(), address.toString(),
buffer.toArrayBuffer(), buffer.toArrayBuffer(),
error.identityKey error.identityKey
); );
} }
const ev = new Event('error'); const ev = new Event('error');
ev.error = errorToThrow; ev.error = errorToThrow;
ev.proto = envelope; ev.proto = envelope;
ev.confirm = this.removeFromCache.bind(this, envelope); ev.confirm = this.removeFromCache.bind(this, envelope);
const returnError = () => Promise.reject(errorToThrow); const returnError = () => Promise.reject(errorToThrow);
return this.dispatchAndWait(ev).then(returnError, returnError); return this.dispatchAndWait(ev).then(returnError, returnError);
}); });
}, },
async decryptPreKeyWhisperMessage(ciphertext, sessionCipher, address) { async decryptPreKeyWhisperMessage(ciphertext, sessionCipher, address) {
const padded = await sessionCipher.decryptPreKeyWhisperMessage(ciphertext); const padded = await sessionCipher.decryptPreKeyWhisperMessage(ciphertext);
@ -508,30 +536,34 @@ MessageReceiver.prototype.extend({
throw e; throw e;
} }
}, },
handleSentMessage(envelope, destination, timestamp, msg, expirationStartTimestamp) { handleSentMessage(
envelope,
destination,
timestamp,
msg,
expirationStartTimestamp
) {
let p = Promise.resolve(); let p = Promise.resolve();
// eslint-disable-next-line no-bitwise // eslint-disable-next-line no-bitwise
if (msg.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION) { if (msg.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION) {
p = this.handleEndSession(destination); p = this.handleEndSession(destination);
} }
return p.then(() => this.processDecrypted( return p.then(() =>
envelope, this.processDecrypted(envelope, msg, this.number).then(message => {
msg, const ev = new Event('sent');
this.number ev.confirm = this.removeFromCache.bind(this, envelope);
).then((message) => { ev.data = {
const ev = new Event('sent'); destination,
ev.confirm = this.removeFromCache.bind(this, envelope); timestamp: timestamp.toNumber(),
ev.data = { device: envelope.sourceDevice,
destination, message,
timestamp: timestamp.toNumber(), };
device: envelope.sourceDevice, if (expirationStartTimestamp) {
message, ev.data.expirationStartTimestamp = expirationStartTimestamp.toNumber();
}; }
if (expirationStartTimestamp) { return this.dispatchAndWait(ev);
ev.data.expirationStartTimestamp = expirationStartTimestamp.toNumber(); })
} );
return this.dispatchAndWait(ev);
}));
}, },
handleDataMessage(envelope, msg) { handleDataMessage(envelope, msg) {
console.log('data message from', this.getEnvelopeId(envelope)); console.log('data message from', this.getEnvelopeId(envelope));
@ -540,38 +572,34 @@ MessageReceiver.prototype.extend({
if (msg.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION) { if (msg.flags & textsecure.protobuf.DataMessage.Flags.END_SESSION) {
p = this.handleEndSession(envelope.source); p = this.handleEndSession(envelope.source);
} }
return p.then(() => this.processDecrypted( return p.then(() =>
envelope, this.processDecrypted(envelope, msg, envelope.source).then(message => {
msg, const ev = new Event('message');
envelope.source ev.confirm = this.removeFromCache.bind(this, envelope);
).then((message) => { ev.data = {
const ev = new Event('message'); source: envelope.source,
ev.confirm = this.removeFromCache.bind(this, envelope); sourceDevice: envelope.sourceDevice,
ev.data = { timestamp: envelope.timestamp.toNumber(),
source: envelope.source, receivedAt: envelope.receivedAt,
sourceDevice: envelope.sourceDevice, message,
timestamp: envelope.timestamp.toNumber(), };
receivedAt: envelope.receivedAt, return this.dispatchAndWait(ev);
message, })
}; );
return this.dispatchAndWait(ev);
}));
}, },
handleLegacyMessage(envelope) { handleLegacyMessage(envelope) {
return this.decrypt( return this.decrypt(envelope, envelope.legacyMessage).then(plaintext =>
envelope, this.innerHandleLegacyMessage(envelope, plaintext)
envelope.legacyMessage );
).then(plaintext => this.innerHandleLegacyMessage(envelope, plaintext));
}, },
innerHandleLegacyMessage(envelope, plaintext) { innerHandleLegacyMessage(envelope, plaintext) {
const message = textsecure.protobuf.DataMessage.decode(plaintext); const message = textsecure.protobuf.DataMessage.decode(plaintext);
return this.handleDataMessage(envelope, message); return this.handleDataMessage(envelope, message);
}, },
handleContentMessage(envelope) { handleContentMessage(envelope) {
return this.decrypt( return this.decrypt(envelope, envelope.content).then(plaintext =>
envelope, this.innerHandleContentMessage(envelope, plaintext)
envelope.content );
).then(plaintext => this.innerHandleContentMessage(envelope, plaintext));
}, },
innerHandleContentMessage(envelope, plaintext) { innerHandleContentMessage(envelope, plaintext) {
const content = textsecure.protobuf.Content.decode(plaintext); const content = textsecure.protobuf.Content.decode(plaintext);
@ -595,7 +623,9 @@ MessageReceiver.prototype.extend({
}, },
handleReceiptMessage(envelope, receiptMessage) { handleReceiptMessage(envelope, receiptMessage) {
const results = []; const results = [];
if (receiptMessage.type === textsecure.protobuf.ReceiptMessage.Type.DELIVERY) { if (
receiptMessage.type === textsecure.protobuf.ReceiptMessage.Type.DELIVERY
) {
for (let i = 0; i < receiptMessage.timestamp.length; i += 1) { for (let i = 0; i < receiptMessage.timestamp.length; i += 1) {
const ev = new Event('delivery'); const ev = new Event('delivery');
ev.confirm = this.removeFromCache.bind(this, envelope); ev.confirm = this.removeFromCache.bind(this, envelope);
@ -606,7 +636,9 @@ MessageReceiver.prototype.extend({
}; };
results.push(this.dispatchAndWait(ev)); results.push(this.dispatchAndWait(ev));
} }
} else if (receiptMessage.type === textsecure.protobuf.ReceiptMessage.Type.READ) { } else if (
receiptMessage.type === textsecure.protobuf.ReceiptMessage.Type.READ
) {
for (let i = 0; i < receiptMessage.timestamp.length; i += 1) { for (let i = 0; i < receiptMessage.timestamp.length; i += 1) {
const ev = new Event('read'); const ev = new Event('read');
ev.confirm = this.removeFromCache.bind(this, envelope); ev.confirm = this.removeFromCache.bind(this, envelope);
@ -734,12 +766,13 @@ MessageReceiver.prototype.extend({
let groupDetails = groupBuffer.next(); let groupDetails = groupBuffer.next();
const promises = []; const promises = [];
while (groupDetails !== undefined) { while (groupDetails !== undefined) {
const getGroupDetails = (details) => { const getGroupDetails = details => {
// eslint-disable-next-line no-param-reassign // eslint-disable-next-line no-param-reassign
details.id = details.id.toBinary(); details.id = details.id.toBinary();
if (details.active) { if (details.active) {
return textsecure.storage.groups.getGroup(details.id) return textsecure.storage.groups
.then((existingGroup) => { .getGroup(details.id)
.then(existingGroup => {
if (existingGroup === undefined) { if (existingGroup === undefined) {
return textsecure.storage.groups.createNewGroup( return textsecure.storage.groups.createNewGroup(
details.members, details.members,
@ -750,19 +783,22 @@ MessageReceiver.prototype.extend({
details.id, details.id,
details.members details.members
); );
}).then(() => details); })
.then(() => details);
} }
return Promise.resolve(details); return Promise.resolve(details);
}; };
const promise = getGroupDetails(groupDetails).then((details) => { const promise = getGroupDetails(groupDetails)
const ev = new Event('group'); .then(details => {
ev.confirm = this.removeFromCache.bind(this, envelope); const ev = new Event('group');
ev.groupDetails = details; ev.confirm = this.removeFromCache.bind(this, envelope);
return this.dispatchAndWait(ev); ev.groupDetails = details;
}).catch((e) => { return this.dispatchAndWait(ev);
console.log('error processing group', e); })
}); .catch(e => {
console.log('error processing group', e);
});
groupDetails = groupBuffer.next(); groupDetails = groupBuffer.next();
promises.push(promise); promises.push(promise);
} }
@ -803,7 +839,8 @@ MessageReceiver.prototype.extend({
attachment.data = data; attachment.data = data;
} }
return this.server.getAttachment(attachment.id) return this.server
.getAttachment(attachment.id)
.then(decryptAttachment) .then(decryptAttachment)
.then(updateAttachment); .then(updateAttachment);
}, },
@ -825,8 +862,14 @@ MessageReceiver.prototype.extend({
// It's most likely that dataMessage will be populated, so we look at it in detail // It's most likely that dataMessage will be populated, so we look at it in detail
const data = content.dataMessage; const data = content.dataMessage;
if (data && !data.attachments.length && !data.body && !data.expireTimer && if (
!data.flags && !data.group) { data &&
!data.attachments.length &&
!data.body &&
!data.expireTimer &&
!data.flags &&
!data.group
) {
return false; return false;
} }
@ -857,7 +900,7 @@ MessageReceiver.prototype.extend({
ciphertext, ciphertext,
sessionCipher, sessionCipher,
address address
).then((plaintext) => { ).then(plaintext => {
const envelope = { const envelope = {
source: number, source: number,
sourceDevice: device, sourceDevice: device,
@ -901,16 +944,18 @@ MessageReceiver.prototype.extend({
console.log('got end session'); console.log('got end session');
const deviceIds = await textsecure.storage.protocol.getDeviceIds(number); const deviceIds = await textsecure.storage.protocol.getDeviceIds(number);
return Promise.all(deviceIds.map((deviceId) => { return Promise.all(
const address = new libsignal.SignalProtocolAddress(number, deviceId); deviceIds.map(deviceId => {
const sessionCipher = new libsignal.SessionCipher( const address = new libsignal.SignalProtocolAddress(number, deviceId);
textsecure.storage.protocol, const sessionCipher = new libsignal.SessionCipher(
address textsecure.storage.protocol,
); address
);
console.log('deleting sessions for', address.toString()); console.log('deleting sessions for', address.toString());
return sessionCipher.deleteAllSessionsForDevice(); return sessionCipher.deleteAllSessionsForDevice();
})); })
);
}, },
processDecrypted(envelope, decrypted, source) { processDecrypted(envelope, decrypted, source) {
/* eslint-disable no-bitwise, no-param-reassign */ /* eslint-disable no-bitwise, no-param-reassign */
@ -928,7 +973,6 @@ MessageReceiver.prototype.extend({
decrypted.expireTimer = 0; decrypted.expireTimer = 0;
} }
if (decrypted.flags & FLAGS.END_SESSION) { if (decrypted.flags & FLAGS.END_SESSION) {
decrypted.body = null; decrypted.body = null;
decrypted.attachments = []; decrypted.attachments = [];
@ -949,7 +993,9 @@ MessageReceiver.prototype.extend({
if (decrypted.group !== null) { if (decrypted.group !== null) {
decrypted.group.id = decrypted.group.id.toBinary(); decrypted.group.id = decrypted.group.id.toBinary();
if (decrypted.group.type === textsecure.protobuf.GroupContext.Type.UPDATE) { if (
decrypted.group.type === textsecure.protobuf.GroupContext.Type.UPDATE
) {
if (decrypted.group.avatar !== null) { if (decrypted.group.avatar !== null) {
promises.push(this.handleAttachment(decrypted.group.avatar)); promises.push(this.handleAttachment(decrypted.group.avatar));
} }
@ -957,49 +1003,61 @@ MessageReceiver.prototype.extend({
const storageGroups = textsecure.storage.groups; const storageGroups = textsecure.storage.groups;
promises.push(storageGroups.getNumbers(decrypted.group.id).then((existingGroup) => { promises.push(
if (existingGroup === undefined) { storageGroups.getNumbers(decrypted.group.id).then(existingGroup => {
if (decrypted.group.type !== textsecure.protobuf.GroupContext.Type.UPDATE) { if (existingGroup === undefined) {
decrypted.group.members = [source]; if (
console.log('Got message for unknown group'); decrypted.group.type !==
} textsecure.protobuf.GroupContext.Type.UPDATE
return textsecure.storage.groups.createNewGroup( ) {
decrypted.group.members, decrypted.group.members = [source];
decrypted.group.id console.log('Got message for unknown group');
);
}
const fromIndex = existingGroup.indexOf(source);
if (fromIndex < 0) {
// TODO: This could be indication of a race...
console.log('Sender was not a member of the group they were sending from');
}
switch (decrypted.group.type) {
case textsecure.protobuf.GroupContext.Type.UPDATE:
decrypted.body = null;
decrypted.attachments = [];
return textsecure.storage.groups.updateNumbers(
decrypted.group.id,
decrypted.group.members
);
case textsecure.protobuf.GroupContext.Type.QUIT:
decrypted.body = null;
decrypted.attachments = [];
if (source === this.number) {
return textsecure.storage.groups.deleteGroup(decrypted.group.id);
} }
return textsecure.storage.groups.removeNumber(decrypted.group.id, source); return textsecure.storage.groups.createNewGroup(
case textsecure.protobuf.GroupContext.Type.DELIVER: decrypted.group.members,
decrypted.group.name = null; decrypted.group.id
decrypted.group.members = []; );
decrypted.group.avatar = null; }
return Promise.resolve(); const fromIndex = existingGroup.indexOf(source);
default:
this.removeFromCache(envelope); if (fromIndex < 0) {
throw new Error('Unknown group message type'); // TODO: This could be indication of a race...
} console.log(
})); 'Sender was not a member of the group they were sending from'
);
}
switch (decrypted.group.type) {
case textsecure.protobuf.GroupContext.Type.UPDATE:
decrypted.body = null;
decrypted.attachments = [];
return textsecure.storage.groups.updateNumbers(
decrypted.group.id,
decrypted.group.members
);
case textsecure.protobuf.GroupContext.Type.QUIT:
decrypted.body = null;
decrypted.attachments = [];
if (source === this.number) {
return textsecure.storage.groups.deleteGroup(
decrypted.group.id
);
}
return textsecure.storage.groups.removeNumber(
decrypted.group.id,
source
);
case textsecure.protobuf.GroupContext.Type.DELIVER:
decrypted.group.name = null;
decrypted.group.members = [];
decrypted.group.avatar = null;
return Promise.resolve();
default:
this.removeFromCache(envelope);
throw new Error('Unknown group message type');
}
})
);
} }
for (let i = 0, max = decrypted.attachments.length; i < max; i += 1) { for (let i = 0, max = decrypted.attachments.length; i < max; i += 1) {
@ -1021,12 +1079,14 @@ MessageReceiver.prototype.extend({
if (thumbnail) { if (thumbnail) {
// We don't want the failure of a thumbnail download to fail the handling of // We don't want the failure of a thumbnail download to fail the handling of
// this message entirely, like we do for full attachments. // this message entirely, like we do for full attachments.
promises.push(this.handleAttachment(thumbnail).catch((error) => { promises.push(
console.log( this.handleAttachment(thumbnail).catch(error => {
'Problem loading thumbnail for quote', console.log(
error && error.stack ? error.stack : error 'Problem loading thumbnail for quote',
); error && error.stack ? error.stack : error
})); );
})
);
} }
} }
} }
@ -1052,8 +1112,12 @@ textsecure.MessageReceiver = function MessageReceiverWrapper(
signalingKey, signalingKey,
options options
); );
this.addEventListener = messageReceiver.addEventListener.bind(messageReceiver); this.addEventListener = messageReceiver.addEventListener.bind(
this.removeEventListener = messageReceiver.removeEventListener.bind(messageReceiver); messageReceiver
);
this.removeEventListener = messageReceiver.removeEventListener.bind(
messageReceiver
);
this.getStatus = messageReceiver.getStatus.bind(messageReceiver); this.getStatus = messageReceiver.getStatus.bind(messageReceiver);
this.close = messageReceiver.close.bind(messageReceiver); this.close = messageReceiver.close.bind(messageReceiver);
messageReceiver.connect(); messageReceiver.connect();
@ -1067,4 +1131,3 @@ textsecure.MessageReceiver = function MessageReceiverWrapper(
textsecure.MessageReceiver.prototype = { textsecure.MessageReceiver.prototype = {
constructor: textsecure.MessageReceiver, constructor: textsecure.MessageReceiver,
}; };

581
libtextsecure/outgoing_message.js
View file

@ -1,241 +1,352 @@
function OutgoingMessage(server, timestamp, numbers, message, silent, callback) { function OutgoingMessage(
if (message instanceof textsecure.protobuf.DataMessage) { server,
var content = new textsecure.protobuf.Content(); timestamp,
content.dataMessage = message; numbers,
message = content; message,
} silent,
this.server = server; callback
this.timestamp = timestamp; ) {
this.numbers = numbers; if (message instanceof textsecure.protobuf.DataMessage) {
this.message = message; // ContentMessage proto var content = new textsecure.protobuf.Content();
this.callback = callback; content.dataMessage = message;
this.silent = silent; message = content;
}
this.server = server;
this.timestamp = timestamp;
this.numbers = numbers;
this.message = message; // ContentMessage proto
this.callback = callback;
this.silent = silent;
this.numbersCompleted = 0; this.numbersCompleted = 0;
this.errors = []; this.errors = [];
this.successfulNumbers = []; this.successfulNumbers = [];
} }
OutgoingMessage.prototype = { OutgoingMessage.prototype = {
constructor: OutgoingMessage, constructor: OutgoingMessage,
numberCompleted: function() { numberCompleted: function() {
this.numbersCompleted++; this.numbersCompleted++;
if (this.numbersCompleted >= this.numbers.length) { if (this.numbersCompleted >= this.numbers.length) {
this.callback({successfulNumbers: this.successfulNumbers, errors: this.errors}); this.callback({
} successfulNumbers: this.successfulNumbers,
}, errors: this.errors,
registerError: function(number, reason, error) { });
if (!error || error.name === 'HTTPError' && error.code !== 404) {
error = new textsecure.OutgoingMessageError(number, this.message.toArrayBuffer(), this.timestamp, error);
}
error.number = number;
error.reason = reason;
this.errors[this.errors.length] = error;
this.numberCompleted();
},
reloadDevicesAndSend: function(number, recurse) {
return function() {
return textsecure.storage.protocol.getDeviceIds(number).then(function(deviceIds) {
if (deviceIds.length == 0) {
return this.registerError(number, "Got empty device list when loading device keys", null);
}
return this.doSendMessage(number, deviceIds, recurse);
}.bind(this));
}.bind(this);
},
getKeysForNumber: function(number, updateDevices) {
var handleResult = function(response) {
return Promise.all(response.devices.map(function(device) {
device.identityKey = response.identityKey;
if (updateDevices === undefined || updateDevices.indexOf(device.deviceId) > -1) {
var address = new libsignal.SignalProtocolAddress(number, device.deviceId);
var builder = new libsignal.SessionBuilder(textsecure.storage.protocol, address);
if (device.registrationId === 0) {
console.log("device registrationId 0!");
}
return builder.processPreKey(device).catch(function(error) {
if (error.message === "Identity key changed") {
error.timestamp = this.timestamp;
error.originalMessage = this.message.toArrayBuffer();
error.identityKey = device.identityKey;
}
throw error;
}.bind(this));
}
}.bind(this)));
}.bind(this);
if (updateDevices === undefined) {
return this.server.getKeysForNumber(number).then(handleResult);
} else {
var promise = Promise.resolve();
updateDevices.forEach(function(device) {
promise = promise.then(function() {
return this.server.getKeysForNumber(number, device).then(handleResult).catch(function(e) {
if (e.name === 'HTTPError' && e.code === 404) {
if (device !== 1) {
return this.removeDeviceIdsForNumber(number, [device]);
} else {
throw new textsecure.UnregisteredUserError(number, e);
}
} else {
throw e;
}
}.bind(this));
}.bind(this));
}.bind(this));
return promise;
}
},
transmitMessage: function(number, jsonData, timestamp) {
return this.server.sendMessages(number, jsonData, timestamp, this.silent).catch(function(e) {
if (e.name === 'HTTPError' && (e.code !== 409 && e.code !== 410)) {
// 409 and 410 should bubble and be handled by doSendMessage
// 404 should throw UnregisteredUserError
// all other network errors can be retried later.
if (e.code === 404) {
throw new textsecure.UnregisteredUserError(number, e);
}
throw new textsecure.SendMessageNetworkError(number, jsonData, e, timestamp);
}
throw e;
});
},
getPaddedMessageLength: function(messageLength) {
var messageLengthWithTerminator = messageLength + 1;
var messagePartCount = Math.floor(messageLengthWithTerminator / 160);
if (messageLengthWithTerminator % 160 !== 0) {
messagePartCount++;
}
return messagePartCount * 160;
},
getPlaintext: function() {
if (!this.plaintext) {
var messageBuffer = this.message.toArrayBuffer();
this.plaintext = new Uint8Array(
this.getPaddedMessageLength(messageBuffer.byteLength + 1) - 1
);
this.plaintext.set(new Uint8Array(messageBuffer));
this.plaintext[messageBuffer.byteLength] = 0x80;
}
return this.plaintext;
},
doSendMessage: function(number, deviceIds, recurse) {
var ciphers = {};
var plaintext = this.getPlaintext();
return Promise.all(deviceIds.map(function(deviceId) {
var address = new libsignal.SignalProtocolAddress(number, deviceId);
var ourNumber = textsecure.storage.user.getNumber();
var options = {};
// No limit on message keys if we're communicating with our other devices
if (ourNumber === number) {
options.messageKeysLimit = false;
}
var sessionCipher = new libsignal.SessionCipher(textsecure.storage.protocol, address, options);
ciphers[address.getDeviceId()] = sessionCipher;
return sessionCipher.encrypt(plaintext).then(function(ciphertext) {
return {
type : ciphertext.type,
destinationDeviceId : address.getDeviceId(),
destinationRegistrationId : ciphertext.registrationId,
content : btoa(ciphertext.body)
};
});
}.bind(this))).then(function(jsonData) {
return this.transmitMessage(number, jsonData, this.timestamp).then(function() {
this.successfulNumbers[this.successfulNumbers.length] = number;
this.numberCompleted();
}.bind(this));
}.bind(this)).catch(function(error) {
if (error instanceof Error && error.name == "HTTPError" && (error.code == 410 || error.code == 409)) {
if (!recurse)
return this.registerError(number, "Hit retry limit attempting to reload device list", error);
var p;
if (error.code == 409) {
p = this.removeDeviceIdsForNumber(number, error.response.extraDevices);
} else {
p = Promise.all(error.response.staleDevices.map(function(deviceId) {
return ciphers[deviceId].closeOpenSessionForDevice();
}));
}
return p.then(function() {
var resetDevices = ((error.code == 410) ? error.response.staleDevices : error.response.missingDevices);
return this.getKeysForNumber(number, resetDevices)
.then(this.reloadDevicesAndSend(number, error.code == 409));
}.bind(this));
} else if (error.message === "Identity key changed") {
error.timestamp = this.timestamp;
error.originalMessage = this.message.toArrayBuffer();
console.log('Got "key changed" error from encrypt - no identityKey for application layer', number, deviceIds)
throw error;
} else {
this.registerError(number, "Failed to create or send message", error);
}
}.bind(this));
},
getStaleDeviceIdsForNumber: function(number) {
return textsecure.storage.protocol.getDeviceIds(number).then(function(deviceIds) {
if (deviceIds.length === 0) {
return [1];
}
var updateDevices = [];
return Promise.all(deviceIds.map(function(deviceId) {
var address = new libsignal.SignalProtocolAddress(number, deviceId);
var sessionCipher = new libsignal.SessionCipher(textsecure.storage.protocol, address);
return sessionCipher.hasOpenSession().then(function(hasSession) {
if (!hasSession) {
updateDevices.push(deviceId);
}
});
})).then(function() {
return updateDevices;
});
});
},
removeDeviceIdsForNumber: function(number, deviceIdsToRemove) {
var promise = Promise.resolve();
for (var j in deviceIdsToRemove) {
promise = promise.then(function() {
var encodedNumber = number + "." + deviceIdsToRemove[j];
return textsecure.storage.protocol.removeSession(encodedNumber);
});
}
return promise;
},
sendToNumber: function(number) {
return this.getStaleDeviceIdsForNumber(number).then(function(updateDevices) {
return this.getKeysForNumber(number, updateDevices)
.then(this.reloadDevicesAndSend(number, true))
.catch(function(error) {
if (error.message === "Identity key changed") {
error = new textsecure.OutgoingIdentityKeyError(
number, error.originalMessage, error.timestamp, error.identityKey
);
this.registerError(number, "Identity key changed", error);
} else {
this.registerError(
number, "Failed to retrieve new device keys for number " + number, error
);
}
}.bind(this));
}.bind(this));
} }
},
registerError: function(number, reason, error) {
if (!error || (error.name === 'HTTPError' && error.code !== 404)) {
error = new textsecure.OutgoingMessageError(
number,
this.message.toArrayBuffer(),
this.timestamp,
error
);
}
error.number = number;
error.reason = reason;
this.errors[this.errors.length] = error;
this.numberCompleted();
},
reloadDevicesAndSend: function(number, recurse) {
return function() {
return textsecure.storage.protocol.getDeviceIds(number).then(
function(deviceIds) {
if (deviceIds.length == 0) {
return this.registerError(
number,
'Got empty device list when loading device keys',
null
);
}
return this.doSendMessage(number, deviceIds, recurse);
}.bind(this)
);
}.bind(this);
},
getKeysForNumber: function(number, updateDevices) {
var handleResult = function(response) {
return Promise.all(
response.devices.map(
function(device) {
device.identityKey = response.identityKey;
if (
updateDevices === undefined ||
updateDevices.indexOf(device.deviceId) > -1
) {
var address = new libsignal.SignalProtocolAddress(
number,
device.deviceId
);
var builder = new libsignal.SessionBuilder(
textsecure.storage.protocol,
address
);
if (device.registrationId === 0) {
console.log('device registrationId 0!');
}
return builder.processPreKey(device).catch(
function(error) {
if (error.message === 'Identity key changed') {
error.timestamp = this.timestamp;
error.originalMessage = this.message.toArrayBuffer();
error.identityKey = device.identityKey;
}
throw error;
}.bind(this)
);
}
}.bind(this)
)
);
}.bind(this);
if (updateDevices === undefined) {
return this.server.getKeysForNumber(number).then(handleResult);
} else {
var promise = Promise.resolve();
updateDevices.forEach(
function(device) {
promise = promise.then(
function() {
return this.server
.getKeysForNumber(number, device)
.then(handleResult)
.catch(
function(e) {
if (e.name === 'HTTPError' && e.code === 404) {
if (device !== 1) {
return this.removeDeviceIdsForNumber(number, [device]);
} else {
throw new textsecure.UnregisteredUserError(number, e);
}
} else {
throw e;
}
}.bind(this)
);
}.bind(this)
);
}.bind(this)
);
return promise;
}
},
transmitMessage: function(number, jsonData, timestamp) {
return this.server
.sendMessages(number, jsonData, timestamp, this.silent)
.catch(function(e) {
if (e.name === 'HTTPError' && (e.code !== 409 && e.code !== 410)) {
// 409 and 410 should bubble and be handled by doSendMessage
// 404 should throw UnregisteredUserError
// all other network errors can be retried later.
if (e.code === 404) {
throw new textsecure.UnregisteredUserError(number, e);
}
throw new textsecure.SendMessageNetworkError(
number,
jsonData,
e,
timestamp
);
}
throw e;
});
},
getPaddedMessageLength: function(messageLength) {
var messageLengthWithTerminator = messageLength + 1;
var messagePartCount = Math.floor(messageLengthWithTerminator / 160);
if (messageLengthWithTerminator % 160 !== 0) {
messagePartCount++;
}
return messagePartCount * 160;
},
getPlaintext: function() {
if (!this.plaintext) {
var messageBuffer = this.message.toArrayBuffer();
this.plaintext = new Uint8Array(
this.getPaddedMessageLength(messageBuffer.byteLength + 1) - 1
);
this.plaintext.set(new Uint8Array(messageBuffer));
this.plaintext[messageBuffer.byteLength] = 0x80;
}
return this.plaintext;
},
doSendMessage: function(number, deviceIds, recurse) {
var ciphers = {};
var plaintext = this.getPlaintext();
return Promise.all(
deviceIds.map(
function(deviceId) {
var address = new libsignal.SignalProtocolAddress(number, deviceId);
var ourNumber = textsecure.storage.user.getNumber();
var options = {};
// No limit on message keys if we're communicating with our other devices
if (ourNumber === number) {
options.messageKeysLimit = false;
}
var sessionCipher = new libsignal.SessionCipher(
textsecure.storage.protocol,
address,
options
);
ciphers[address.getDeviceId()] = sessionCipher;
return sessionCipher.encrypt(plaintext).then(function(ciphertext) {
return {
type: ciphertext.type,
destinationDeviceId: address.getDeviceId(),
destinationRegistrationId: ciphertext.registrationId,
content: btoa(ciphertext.body),
};
});
}.bind(this)
)
)
.then(
function(jsonData) {
return this.transmitMessage(number, jsonData, this.timestamp).then(
function() {
this.successfulNumbers[this.successfulNumbers.length] = number;
this.numberCompleted();
}.bind(this)
);
}.bind(this)
)
.catch(
function(error) {
if (
error instanceof Error &&
error.name == 'HTTPError' &&
(error.code == 410 || error.code == 409)
) {
if (!recurse)
return this.registerError(
number,
'Hit retry limit attempting to reload device list',
error
);
var p;
if (error.code == 409) {
p = this.removeDeviceIdsForNumber(
number,
error.response.extraDevices
);
} else {
p = Promise.all(
error.response.staleDevices.map(function(deviceId) {
return ciphers[deviceId].closeOpenSessionForDevice();
})
);
}
return p.then(
function() {
var resetDevices =
error.code == 410
? error.response.staleDevices
: error.response.missingDevices;
return this.getKeysForNumber(number, resetDevices).then(
this.reloadDevicesAndSend(number, error.code == 409)
);
}.bind(this)
);
} else if (error.message === 'Identity key changed') {
error.timestamp = this.timestamp;
error.originalMessage = this.message.toArrayBuffer();
console.log(
'Got "key changed" error from encrypt - no identityKey for application layer',
number,
deviceIds
);
throw error;
} else {
this.registerError(
number,
'Failed to create or send message',
error
);
}
}.bind(this)
);
},
getStaleDeviceIdsForNumber: function(number) {
return textsecure.storage.protocol
.getDeviceIds(number)
.then(function(deviceIds) {
if (deviceIds.length === 0) {
return [1];
}
var updateDevices = [];
return Promise.all(
deviceIds.map(function(deviceId) {
var address = new libsignal.SignalProtocolAddress(number, deviceId);
var sessionCipher = new libsignal.SessionCipher(
textsecure.storage.protocol,
address
);
return sessionCipher.hasOpenSession().then(function(hasSession) {
if (!hasSession) {
updateDevices.push(deviceId);
}
});
})
).then(function() {
return updateDevices;
});
});
},
removeDeviceIdsForNumber: function(number, deviceIdsToRemove) {
var promise = Promise.resolve();
for (var j in deviceIdsToRemove) {
promise = promise.then(function() {
var encodedNumber = number + '.' + deviceIdsToRemove[j];
return textsecure.storage.protocol.removeSession(encodedNumber);
});
}
return promise;
},
sendToNumber: function(number) {
return this.getStaleDeviceIdsForNumber(number).then(
function(updateDevices) {
return this.getKeysForNumber(number, updateDevices)
.then(this.reloadDevicesAndSend(number, true))
.catch(
function(error) {
if (error.message === 'Identity key changed') {
error = new textsecure.OutgoingIdentityKeyError(
number,
error.originalMessage,
error.timestamp,
error.identityKey
);
this.registerError(number, 'Identity key changed', error);
} else {
this.registerError(
number,
'Failed to retrieve new device keys for number ' + number,
error
);
}
}.bind(this)
);
}.bind(this)
);
},
}; };

65
libtextsecure/protobufs.js
View file

@ -1,29 +1,42 @@
;(function() { (function() {
'use strict'; 'use strict';
window.textsecure = window.textsecure || {}; window.textsecure = window.textsecure || {};
window.textsecure.protobuf = {}; window.textsecure.protobuf = {};
function loadProtoBufs(filename) { function loadProtoBufs(filename) {
return dcodeIO.ProtoBuf.loadProtoFile({root: window.PROTO_ROOT, file: filename}, function(error, result) { return dcodeIO.ProtoBuf.loadProtoFile(
if (error) { { root: window.PROTO_ROOT, file: filename },
var text = 'Error loading protos from ' + filename + ' (root: ' + window.PROTO_ROOT + ') ' function(error, result) {
+ (error && error.stack ? error.stack : error); if (error) {
console.log(text); var text =
throw error; 'Error loading protos from ' +
} filename +
var protos = result.build('signalservice'); ' (root: ' +
if (!protos) { window.PROTO_ROOT +
var text = 'Error loading protos from ' + filename + ' (root: ' + window.PROTO_ROOT + ')'; ') ' +
console.log(text); (error && error.stack ? error.stack : error);
throw new Error(text); console.log(text);
} throw error;
for (var protoName in protos) { }
textsecure.protobuf[protoName] = protos[protoName]; var protos = result.build('signalservice');
} if (!protos) {
}); var text =
}; 'Error loading protos from ' +
filename +
' (root: ' +
window.PROTO_ROOT +
')';
console.log(text);
throw new Error(text);
}
for (var protoName in protos) {
textsecure.protobuf[protoName] = protos[protoName];
}
}
);
}
loadProtoBufs('SignalService.proto'); loadProtoBufs('SignalService.proto');
loadProtoBufs('SubProtocol.proto'); loadProtoBufs('SubProtocol.proto');
loadProtoBufs('DeviceMessages.proto'); loadProtoBufs('DeviceMessages.proto');
})(); })();

16
libtextsecure/protocol_wrapper.js
View file

@ -1,11 +1,11 @@
;(function() { (function() {
'use strict'; 'use strict';
window.textsecure = window.textsecure || {}; window.textsecure = window.textsecure || {};
window.textsecure.storage = window.textsecure.storage || {}; window.textsecure.storage = window.textsecure.storage || {};
textsecure.storage.protocol = new SignalProtocolStore(); textsecure.storage.protocol = new SignalProtocolStore();
textsecure.ProvisioningCipher = libsignal.ProvisioningCipher; textsecure.ProvisioningCipher = libsignal.ProvisioningCipher;
textsecure.startWorker = libsignal.worker.startWorker; textsecure.startWorker = libsignal.worker.startWorker;
textsecure.stopWorker = libsignal.worker.stopWorker; textsecure.stopWorker = libsignal.worker.stopWorker;
})(); })();

1680
libtextsecure/sendmessage.js
View file

File diff suppressed because it is too large Load diff

70
libtextsecure/storage.js
View file

@ -1,46 +1,42 @@
'use strict'; 'use strict';
;(function() { (function() {
/************************************************
*** Utilities to store data in local storage ***
************************************************/
window.textsecure = window.textsecure || {};
window.textsecure.storage = window.textsecure.storage || {};
/************************************************ // Overrideable storage implementation
*** Utilities to store data in local storage *** window.textsecure.storage.impl = window.textsecure.storage.impl || {
************************************************/ /*****************************
window.textsecure = window.textsecure || {}; *** Base Storage Routines ***
window.textsecure.storage = window.textsecure.storage || {}; *****************************/
put: function(key, value) {
if (value === undefined) throw new Error('Tried to store undefined');
localStorage.setItem('' + key, textsecure.utils.jsonThing(value));
},
// Overrideable storage implementation get: function(key, defaultValue) {
window.textsecure.storage.impl = window.textsecure.storage.impl || { var value = localStorage.getItem('' + key);
/***************************** if (value === null) return defaultValue;
*** Base Storage Routines *** return JSON.parse(value);
*****************************/ },
put: function(key, value) {
if (value === undefined)
throw new Error("Tried to store undefined");
localStorage.setItem("" + key, textsecure.utils.jsonThing(value));
},
get: function(key, defaultValue) { remove: function(key) {
var value = localStorage.getItem("" + key); localStorage.removeItem('' + key);
if (value === null) },
return defaultValue; };
return JSON.parse(value);
},
remove: function(key) { window.textsecure.storage.put = function(key, value) {
localStorage.removeItem("" + key); return textsecure.storage.impl.put(key, value);
}, };
};
window.textsecure.storage.put = function(key, value) { window.textsecure.storage.get = function(key, defaultValue) {
return textsecure.storage.impl.put(key, value); return textsecure.storage.impl.get(key, defaultValue);
}; };
window.textsecure.storage.get = function(key, defaultValue) { window.textsecure.storage.remove = function(key) {
return textsecure.storage.impl.get(key, defaultValue); return textsecure.storage.impl.remove(key);
}; };
window.textsecure.storage.remove = function(key) {
return textsecure.storage.impl.remove(key);
};
})(); })();

298
libtextsecure/storage/groups.js
View file

@ -1,144 +1,164 @@
;(function() { (function() {
'use strict'; 'use strict';
/********************* /*********************
*** Group Storage *** *** Group Storage ***
*********************/ *********************/
window.textsecure = window.textsecure || {}; window.textsecure = window.textsecure || {};
window.textsecure.storage = window.textsecure.storage || {}; window.textsecure.storage = window.textsecure.storage || {};
// create a random group id that we haven't seen before. // create a random group id that we haven't seen before.
function generateNewGroupId() { function generateNewGroupId() {
var groupId = getString(libsignal.crypto.getRandomBytes(16)); var groupId = getString(libsignal.crypto.getRandomBytes(16));
return textsecure.storage.protocol.getGroup(groupId).then(function(group) { return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined) { if (group === undefined) {
return groupId; return groupId;
} else { } else {
console.warn('group id collision'); // probably a bad sign. console.warn('group id collision'); // probably a bad sign.
return generateNewGroupId(); return generateNewGroupId();
} }
}); });
} }
window.textsecure.storage.groups = { window.textsecure.storage.groups = {
createNewGroup: function(numbers, groupId) { createNewGroup: function(numbers, groupId) {
var groupId = groupId; var groupId = groupId;
return new Promise(function(resolve) { return new Promise(function(resolve) {
if (groupId !== undefined) { if (groupId !== undefined) {
resolve(textsecure.storage.protocol.getGroup(groupId).then(function(group) { resolve(
if (group !== undefined) { textsecure.storage.protocol.getGroup(groupId).then(function(group) {
throw new Error("Tried to recreate group"); if (group !== undefined) {
} throw new Error('Tried to recreate group');
})); }
} else { })
resolve(generateNewGroupId().then(function(newGroupId) { );
groupId = newGroupId; } else {
})); resolve(
} generateNewGroupId().then(function(newGroupId) {
}).then(function() { groupId = newGroupId;
var me = textsecure.storage.user.getNumber(); })
var haveMe = false; );
var finalNumbers = [];
for (var i in numbers) {
var number = numbers[i];
if (!textsecure.utils.isNumberSane(number))
throw new Error("Invalid number in group");
if (number == me)
haveMe = true;
if (finalNumbers.indexOf(number) < 0)
finalNumbers.push(number);
}
if (!haveMe)
finalNumbers.push(me);
var groupObject = {numbers: finalNumbers, numberRegistrationIds: {}};
for (var i in finalNumbers)
groupObject.numberRegistrationIds[finalNumbers[i]] = {};
return textsecure.storage.protocol.putGroup(groupId, groupObject).then(function() {
return {id: groupId, numbers: finalNumbers};
});
});
},
getNumbers: function(groupId) {
return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined)
return undefined;
return group.numbers;
});
},
removeNumber: function(groupId, number) {
return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined)
return undefined;
var me = textsecure.storage.user.getNumber();
if (number == me)
throw new Error("Cannot remove ourselves from a group, leave the group instead");
var i = group.numbers.indexOf(number);
if (i > -1) {
group.numbers.splice(i, 1);
delete group.numberRegistrationIds[number];
return textsecure.storage.protocol.putGroup(groupId, group).then(function() {
return group.numbers;
});
}
return group.numbers;
});
},
addNumbers: function(groupId, numbers) {
return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined)
return undefined;
for (var i in numbers) {
var number = numbers[i];
if (!textsecure.utils.isNumberSane(number))
throw new Error("Invalid number in set to add to group");
if (group.numbers.indexOf(number) < 0) {
group.numbers.push(number);
group.numberRegistrationIds[number] = {};
}
}
return textsecure.storage.protocol.putGroup(groupId, group).then(function() {
return group.numbers;
});
});
},
deleteGroup: function(groupId) {
return textsecure.storage.protocol.removeGroup(groupId);
},
getGroup: function(groupId) {
return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined)
return undefined;
return { id: groupId, numbers: group.numbers };
});
},
updateNumbers: function(groupId, numbers) {
return textsecure.storage.protocol.getGroup(groupId).then(function(group) {
if (group === undefined)
throw new Error("Tried to update numbers for unknown group");
if (numbers.filter(textsecure.utils.isNumberSane).length < numbers.length)
throw new Error("Invalid number in new group members");
var added = numbers.filter(function(number) { return group.numbers.indexOf(number) < 0; });
return textsecure.storage.groups.addNumbers(groupId, added);
});
} }
}; }).then(function() {
var me = textsecure.storage.user.getNumber();
var haveMe = false;
var finalNumbers = [];
for (var i in numbers) {
var number = numbers[i];
if (!textsecure.utils.isNumberSane(number))
throw new Error('Invalid number in group');
if (number == me) haveMe = true;
if (finalNumbers.indexOf(number) < 0) finalNumbers.push(number);
}
if (!haveMe) finalNumbers.push(me);
var groupObject = { numbers: finalNumbers, numberRegistrationIds: {} };
for (var i in finalNumbers)
groupObject.numberRegistrationIds[finalNumbers[i]] = {};
return textsecure.storage.protocol
.putGroup(groupId, groupObject)
.then(function() {
return { id: groupId, numbers: finalNumbers };
});
});
},
getNumbers: function(groupId) {
return textsecure.storage.protocol
.getGroup(groupId)
.then(function(group) {
if (group === undefined) return undefined;
return group.numbers;
});
},
removeNumber: function(groupId, number) {
return textsecure.storage.protocol
.getGroup(groupId)
.then(function(group) {
if (group === undefined) return undefined;
var me = textsecure.storage.user.getNumber();
if (number == me)
throw new Error(
'Cannot remove ourselves from a group, leave the group instead'
);
var i = group.numbers.indexOf(number);
if (i > -1) {
group.numbers.splice(i, 1);
delete group.numberRegistrationIds[number];
return textsecure.storage.protocol
.putGroup(groupId, group)
.then(function() {
return group.numbers;
});
}
return group.numbers;
});
},
addNumbers: function(groupId, numbers) {
return textsecure.storage.protocol
.getGroup(groupId)
.then(function(group) {
if (group === undefined) return undefined;
for (var i in numbers) {
var number = numbers[i];
if (!textsecure.utils.isNumberSane(number))
throw new Error('Invalid number in set to add to group');
if (group.numbers.indexOf(number) < 0) {
group.numbers.push(number);
group.numberRegistrationIds[number] = {};
}
}
return textsecure.storage.protocol
.putGroup(groupId, group)
.then(function() {
return group.numbers;
});
});
},
deleteGroup: function(groupId) {
return textsecure.storage.protocol.removeGroup(groupId);
},
getGroup: function(groupId) {
return textsecure.storage.protocol
.getGroup(groupId)
.then(function(group) {
if (group === undefined) return undefined;
return { id: groupId, numbers: group.numbers };
});
},
updateNumbers: function(groupId, numbers) {
return textsecure.storage.protocol
.getGroup(groupId)
.then(function(group) {
if (group === undefined)
throw new Error('Tried to update numbers for unknown group');
if (
numbers.filter(textsecure.utils.isNumberSane).length <
numbers.length
)
throw new Error('Invalid number in new group members');
var added = numbers.filter(function(number) {
return group.numbers.indexOf(number) < 0;
});
return textsecure.storage.groups.addNumbers(groupId, added);
});
},
};
})(); })();

42
libtextsecure/storage/unprocessed.js
View file

@ -1,24 +1,24 @@
;(function() { (function() {
'use strict'; 'use strict';
/***************************************** /*****************************************
*** Not-yet-processed message storage *** *** Not-yet-processed message storage ***
*****************************************/ *****************************************/
window.textsecure = window.textsecure || {}; window.textsecure = window.textsecure || {};
window.textsecure.storage = window.textsecure.storage || {}; window.textsecure.storage = window.textsecure.storage || {};
window.textsecure.storage.unprocessed = { window.textsecure.storage.unprocessed = {
getAll: function() { getAll: function() {
return textsecure.storage.protocol.getAllUnprocessed(); return textsecure.storage.protocol.getAllUnprocessed();
}, },
add: function(data) { add: function(data) {
return textsecure.storage.protocol.addUnprocessed(data); return textsecure.storage.protocol.addUnprocessed(data);
}, },
update: function(id, updates) { update: function(id, updates) {
return textsecure.storage.protocol.updateUnprocessed(id, updates); return textsecure.storage.protocol.updateUnprocessed(id, updates);
}, },
remove: function(id) { remove: function(id) {
return textsecure.storage.protocol.removeUnprocessed(id); return textsecure.storage.protocol.removeUnprocessed(id);
}, },
}; };
})(); })();

56
libtextsecure/storage/user.js
View file

@ -1,36 +1,34 @@
'use strict'; 'use strict';
;(function() { (function() {
/********************************************* /*********************************************
*** Utilities to store data about the user *** *** Utilities to store data about the user ***
**********************************************/ **********************************************/
window.textsecure = window.textsecure || {}; window.textsecure = window.textsecure || {};
window.textsecure.storage = window.textsecure.storage || {}; window.textsecure.storage = window.textsecure.storage || {};
window.textsecure.storage.user = { window.textsecure.storage.user = {
setNumberAndDeviceId: function(number, deviceId, deviceName) { setNumberAndDeviceId: function(number, deviceId, deviceName) {
textsecure.storage.put("number_id", number + "." + deviceId); textsecure.storage.put('number_id', number + '.' + deviceId);
if (deviceName) { if (deviceName) {
textsecure.storage.put("device_name", deviceName); textsecure.storage.put('device_name', deviceName);
} }
}, },
getNumber: function(key, defaultValue) { getNumber: function(key, defaultValue) {
var number_id = textsecure.storage.get("number_id"); var number_id = textsecure.storage.get('number_id');
if (number_id === undefined) if (number_id === undefined) return undefined;
return undefined; return textsecure.utils.unencodeNumber(number_id)[0];
return textsecure.utils.unencodeNumber(number_id)[0]; },
},
getDeviceId: function(key) { getDeviceId: function(key) {
var number_id = textsecure.storage.get("number_id"); var number_id = textsecure.storage.get('number_id');
if (number_id === undefined) if (number_id === undefined) return undefined;
return undefined; return textsecure.utils.unencodeNumber(number_id)[1];
return textsecure.utils.unencodeNumber(number_id)[1]; },
},
getDeviceName: function(key) { getDeviceName: function(key) {
return textsecure.storage.get("device_name"); return textsecure.storage.get('device_name');
} },
}; };
})(); })();

151
libtextsecure/stringview.js
View file

@ -1,82 +1,93 @@
;(function() { (function() {
"use strict"; 'use strict';
window.StringView = { window.StringView = {
/*
/*
* These functions from the Mozilla Developer Network * These functions from the Mozilla Developer Network
* and have been placed in the public domain. * and have been placed in the public domain.
* https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding * https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding
* https://developer.mozilla.org/en-US/docs/MDN/About#Copyrights_and_licenses * https://developer.mozilla.org/en-US/docs/MDN/About#Copyrights_and_licenses
*/ */
b64ToUint6: function(nChr) { b64ToUint6: function(nChr) {
return nChr > 64 && nChr < 91 ? return nChr > 64 && nChr < 91
nChr - 65 ? nChr - 65
: nChr > 96 && nChr < 123 ? : nChr > 96 && nChr < 123
nChr - 71 ? nChr - 71
: nChr > 47 && nChr < 58 ? : nChr > 47 && nChr < 58
nChr + 4 ? nChr + 4
: nChr === 43 ? : nChr === 43
62 ? 62
: nChr === 47 ? : nChr === 47
63 ? 63
: : 0;
0; },
},
base64ToBytes: function(sBase64, nBlocksSize) { base64ToBytes: function(sBase64, nBlocksSize) {
var var sB64Enc = sBase64.replace(/[^A-Za-z0-9\+\/]/g, ''),
sB64Enc = sBase64.replace(/[^A-Za-z0-9\+\/]/g, ""), nInLen = sB64Enc.length, nInLen = sB64Enc.length,
nOutLen = nBlocksSize ? Math.ceil((nInLen * 3 + 1 >> 2) / nBlocksSize) * nBlocksSize : nInLen * 3 + 1 >> 2; nOutLen = nBlocksSize
var aBBytes = new ArrayBuffer(nOutLen); ? Math.ceil(((nInLen * 3 + 1) >> 2) / nBlocksSize) * nBlocksSize
var taBytes = new Uint8Array(aBBytes); : (nInLen * 3 + 1) >> 2;
var aBBytes = new ArrayBuffer(nOutLen);
var taBytes = new Uint8Array(aBBytes);
for (var nMod3, nMod4, nUint24 = 0, nOutIdx = 0, nInIdx = 0; nInIdx < nInLen; nInIdx++) { for (
nMod4 = nInIdx & 3; var nMod3, nMod4, nUint24 = 0, nOutIdx = 0, nInIdx = 0;
nUint24 |= StringView.b64ToUint6(sB64Enc.charCodeAt(nInIdx)) << 18 - 6 * nMod4; nInIdx < nInLen;
if (nMod4 === 3 || nInLen - nInIdx === 1) { nInIdx++
for (nMod3 = 0; nMod3 < 3 && nOutIdx < nOutLen; nMod3++, nOutIdx++) { ) {
taBytes[nOutIdx] = nUint24 >>> (16 >>> nMod3 & 24) & 255; nMod4 = nInIdx & 3;
} nUint24 |=
nUint24 = 0; StringView.b64ToUint6(sB64Enc.charCodeAt(nInIdx)) << (18 - 6 * nMod4);
if (nMod4 === 3 || nInLen - nInIdx === 1) {
for (nMod3 = 0; nMod3 < 3 && nOutIdx < nOutLen; nMod3++, nOutIdx++) {
taBytes[nOutIdx] = (nUint24 >>> ((16 >>> nMod3) & 24)) & 255;
} }
nUint24 = 0;
} }
return aBBytes;
},
uint6ToB64: function(nUint6) {
return nUint6 < 26 ?
nUint6 + 65
: nUint6 < 52 ?
nUint6 + 71
: nUint6 < 62 ?
nUint6 - 4
: nUint6 === 62 ?
43
: nUint6 === 63 ?
47
:
65;
},
bytesToBase64: function(aBytes) {
var nMod3, sB64Enc = "";
for (var nLen = aBytes.length, nUint24 = 0, nIdx = 0; nIdx < nLen; nIdx++) {
nMod3 = nIdx % 3;
if (nIdx > 0 && (nIdx * 4 / 3) % 76 === 0) { sB64Enc += "\r\n"; }
nUint24 |= aBytes[nIdx] << (16 >>> nMod3 & 24);
if (nMod3 === 2 || aBytes.length - nIdx === 1) {
sB64Enc += String.fromCharCode(
StringView.uint6ToB64(nUint24 >>> 18 & 63),
StringView.uint6ToB64(nUint24 >>> 12 & 63),
StringView.uint6ToB64(nUint24 >>> 6 & 63),
StringView.uint6ToB64(nUint24 & 63)
);
nUint24 = 0;
}
}
return sB64Enc.replace(/A(?=A$|$)/g, "=");
} }
}; return aBBytes;
}()); },
uint6ToB64: function(nUint6) {
return nUint6 < 26
? nUint6 + 65
: nUint6 < 52
? nUint6 + 71
: nUint6 < 62
? nUint6 - 4
: nUint6 === 62
? 43
: nUint6 === 63
? 47
: 65;
},
bytesToBase64: function(aBytes) {
var nMod3,
sB64Enc = '';
for (
var nLen = aBytes.length, nUint24 = 0, nIdx = 0;
nIdx < nLen;
nIdx++
) {
nMod3 = nIdx % 3;
if (nIdx > 0 && (nIdx * 4 / 3) % 76 === 0) {
sB64Enc += '\r\n';
}
nUint24 |= aBytes[nIdx] << ((16 >>> nMod3) & 24);
if (nMod3 === 2 || aBytes.length - nIdx === 1) {
sB64Enc += String.fromCharCode(
StringView.uint6ToB64((nUint24 >>> 18) & 63),
StringView.uint6ToB64((nUint24 >>> 12) & 63),
StringView.uint6ToB64((nUint24 >>> 6) & 63),
StringView.uint6ToB64(nUint24 & 63)
);
nUint24 = 0;
}
}
return sB64Enc.replace(/A(?=A$|$)/g, '=');
},
};
})();

142
libtextsecure/sync_request.js
View file

@ -1,74 +1,82 @@
;(function () { (function() {
'use strict'; 'use strict';
window.textsecure = window.textsecure || {}; window.textsecure = window.textsecure || {};
function SyncRequest(sender, receiver) { function SyncRequest(sender, receiver) {
if (!(sender instanceof textsecure.MessageSender) || !(receiver instanceof textsecure.MessageReceiver)) { if (
throw new Error('Tried to construct a SyncRequest without MessageSender and MessageReceiver'); !(sender instanceof textsecure.MessageSender) ||
} !(receiver instanceof textsecure.MessageReceiver)
this.receiver = receiver; ) {
throw new Error(
this.oncontact = this.onContactSyncComplete.bind(this); 'Tried to construct a SyncRequest without MessageSender and MessageReceiver'
receiver.addEventListener('contactsync', this.oncontact); );
this.ongroup = this.onGroupSyncComplete.bind(this);
receiver.addEventListener('groupsync', this.ongroup);
console.log('SyncRequest created. Sending contact sync message...');
sender.sendRequestContactSyncMessage().then(function() {
console.log('SyncRequest now sending group sync messsage...');
return sender.sendRequestGroupSyncMessage();
}).catch(function(error) {
console.log(
'SyncRequest error:',
error && error.stack ? error.stack : error
);
});
this.timeout = setTimeout(this.onTimeout.bind(this), 60000);
} }
this.receiver = receiver;
SyncRequest.prototype = new textsecure.EventTarget(); this.oncontact = this.onContactSyncComplete.bind(this);
SyncRequest.prototype.extend({ receiver.addEventListener('contactsync', this.oncontact);
constructor: SyncRequest,
onContactSyncComplete: function() {
this.contactSync = true;
this.update();
},
onGroupSyncComplete: function() {
this.groupSync = true;
this.update();
},
update: function() {
if (this.contactSync && this.groupSync) {
this.dispatchEvent(new Event('success'));
this.cleanup();
}
},
onTimeout: function() {
if (this.contactSync || this.groupSync) {
this.dispatchEvent(new Event('success'));
} else {
this.dispatchEvent(new Event('timeout'));
}
this.cleanup();
},
cleanup: function() {
clearTimeout(this.timeout);
this.receiver.removeEventListener('contactsync', this.oncontact);
this.receiver.removeEventListener('groupSync', this.ongroup);
delete this.listeners;
}
});
textsecure.SyncRequest = function(sender, receiver) { this.ongroup = this.onGroupSyncComplete.bind(this);
var syncRequest = new SyncRequest(sender, receiver); receiver.addEventListener('groupsync', this.ongroup);
this.addEventListener = syncRequest.addEventListener.bind(syncRequest);
this.removeEventListener = syncRequest.removeEventListener.bind(syncRequest);
};
textsecure.SyncRequest.prototype = { console.log('SyncRequest created. Sending contact sync message...');
constructor: textsecure.SyncRequest sender
}; .sendRequestContactSyncMessage()
.then(function() {
console.log('SyncRequest now sending group sync messsage...');
return sender.sendRequestGroupSyncMessage();
})
.catch(function(error) {
console.log(
'SyncRequest error:',
error && error.stack ? error.stack : error
);
});
this.timeout = setTimeout(this.onTimeout.bind(this), 60000);
}
SyncRequest.prototype = new textsecure.EventTarget();
SyncRequest.prototype.extend({
constructor: SyncRequest,
onContactSyncComplete: function() {
this.contactSync = true;
this.update();
},
onGroupSyncComplete: function() {
this.groupSync = true;
this.update();
},
update: function() {
if (this.contactSync && this.groupSync) {
this.dispatchEvent(new Event('success'));
this.cleanup();
}
},
onTimeout: function() {
if (this.contactSync || this.groupSync) {
this.dispatchEvent(new Event('success'));
} else {
this.dispatchEvent(new Event('timeout'));
}
this.cleanup();
},
cleanup: function() {
clearTimeout(this.timeout);
this.receiver.removeEventListener('contactsync', this.oncontact);
this.receiver.removeEventListener('groupSync', this.ongroup);
delete this.listeners;
},
});
}()); textsecure.SyncRequest = function(sender, receiver) {
var syncRequest = new SyncRequest(sender, receiver);
this.addEventListener = syncRequest.addEventListener.bind(syncRequest);
this.removeEventListener = syncRequest.removeEventListener.bind(
syncRequest
);
};
textsecure.SyncRequest.prototype = {
constructor: textsecure.SyncRequest,
};
})();

126
libtextsecure/task_with_timeout.js
View file

@ -1,68 +1,70 @@
(function () { (function() {
window.textsecure = window.textsecure || {}; window.textsecure = window.textsecure || {};
window.textsecure.createTaskWithTimeout = function(task, id, options) { window.textsecure.createTaskWithTimeout = function(task, id, options) {
options = options || {}; options = options || {};
options.timeout = options.timeout || (1000 * 60 * 2); // two minutes options.timeout = options.timeout || 1000 * 60 * 2; // two minutes
var errorForStack = new Error('for stack'); var errorForStack = new Error('for stack');
return function() { return function() {
return new Promise(function(resolve, reject) { return new Promise(function(resolve, reject) {
var complete = false; var complete = false;
var timer = setTimeout(function() { var timer = setTimeout(
if (!complete) { function() {
var message = if (!complete) {
(id || '') var message =
+ ' task did not complete in time. Calling stack: ' (id || '') +
+ errorForStack.stack; ' task did not complete in time. Calling stack: ' +
errorForStack.stack;
console.log(message); console.log(message);
return reject(new Error(message)); return reject(new Error(message));
} }
}.bind(this), options.timeout); }.bind(this),
var clearTimer = function() { options.timeout
try { );
var localTimer = timer; var clearTimer = function() {
if (localTimer) { try {
timer = null; var localTimer = timer;
clearTimeout(localTimer); if (localTimer) {
} timer = null;
} clearTimeout(localTimer);
catch (error) { }
console.log( } catch (error) {
id || '', console.log(
'task ran into problem canceling timer. Calling stack:', id || '',
errorForStack.stack 'task ran into problem canceling timer. Calling stack:',
); errorForStack.stack
} );
}; }
var success = function(result) {
clearTimer();
complete = true;
return resolve(result);
};
var failure = function(error) {
clearTimer();
complete = true;
return reject(error);
};
var promise;
try {
promise = task();
} catch(error) {
clearTimer();
throw error;
}
if (!promise || !promise.then) {
clearTimer();
complete = true;
return resolve(promise);
}
return promise.then(success, failure);
});
}; };
var success = function(result) {
clearTimer();
complete = true;
return resolve(result);
};
var failure = function(error) {
clearTimer();
complete = true;
return reject(error);
};
var promise;
try {
promise = task();
} catch (error) {
clearTimer();
throw error;
}
if (!promise || !promise.then) {
clearTimer();
complete = true;
return resolve(promise);
}
return promise.then(success, failure);
});
}; };
};
})(); })();

14
libtextsecure/test/_test.js
View file

@ -1,4 +1,4 @@
mocha.setup("bdd"); mocha.setup('bdd');
window.assert = chai.assert; window.assert = chai.assert;
window.PROTO_ROOT = '../../protos'; window.PROTO_ROOT = '../../protos';
@ -27,7 +27,7 @@ window.PROTO_ROOT = '../../protos';
result: false, result: false,
message: err.message, message: err.message,
stack: err.stack, stack: err.stack,
titles: flattenTitles(test) titles: flattenTitles(test),
}); });
}); });
@ -37,21 +37,21 @@ window.PROTO_ROOT = '../../protos';
SauceReporter.prototype = OriginalReporter.prototype; SauceReporter.prototype = OriginalReporter.prototype;
mocha.reporter(SauceReporter); mocha.reporter(SauceReporter);
}()); })();
/* /*
* global helpers for tests * global helpers for tests
*/ */
function assertEqualArrayBuffers(ab1, ab2) { function assertEqualArrayBuffers(ab1, ab2) {
assert.deepEqual(new Uint8Array(ab1), new Uint8Array(ab2)); assert.deepEqual(new Uint8Array(ab1), new Uint8Array(ab2));
}; }
function hexToArrayBuffer(str) { function hexToArrayBuffer(str) {
var ret = new ArrayBuffer(str.length / 2); var ret = new ArrayBuffer(str.length / 2);
var array = new Uint8Array(ret); var array = new Uint8Array(ret);
for (var i = 0; i < str.length/2; i++) for (var i = 0; i < str.length / 2; i++)
array[i] = parseInt(str.substr(i*2, 2), 16); array[i] = parseInt(str.substr(i * 2, 2), 16);
return ret; return ret;
}; }
window.MockSocket.prototype.addEventListener = function() {}; window.MockSocket.prototype.addEventListener = function() {};

146
libtextsecure/test/account_manager_test.js
View file

@ -1,6 +1,6 @@
'use strict'; 'use strict';
describe("AccountManager", function() { describe('AccountManager', function() {
let accountManager; let accountManager;
let originalServer; let originalServer;
@ -35,19 +35,23 @@ describe("AccountManager", function() {
it('keeps three confirmed keys even if over a week old', function() { it('keeps three confirmed keys even if over a week old', function() {
const now = Date.now(); const now = Date.now();
signedPreKeys = [{ signedPreKeys = [
keyId: 1, {
created_at: now - DAY * 21, keyId: 1,
confirmed: true, created_at: now - DAY * 21,
}, { confirmed: true,
keyId: 2, },
created_at: now - DAY * 14, {
confirmed: true, keyId: 2,
}, { created_at: now - DAY * 14,
keyId: 3, confirmed: true,
created_at: now - DAY * 18, },
confirmed: true, {
}]; keyId: 3,
created_at: now - DAY * 18,
confirmed: true,
},
];
// should be no calls to store.removeSignedPreKey, would cause crash // should be no calls to store.removeSignedPreKey, would cause crash
return accountManager.cleanSignedPreKeys(); return accountManager.cleanSignedPreKeys();
@ -55,27 +59,33 @@ describe("AccountManager", function() {
it('eliminates confirmed keys over a week old, if more than three', function() { it('eliminates confirmed keys over a week old, if more than three', function() {
const now = Date.now(); const now = Date.now();
signedPreKeys = [{ signedPreKeys = [
keyId: 1, {
created_at: now - DAY * 21, keyId: 1,
confirmed: true, created_at: now - DAY * 21,
}, { confirmed: true,
keyId: 2, },
created_at: now - DAY * 14, {
confirmed: true, keyId: 2,
}, { created_at: now - DAY * 14,
keyId: 3, confirmed: true,
created_at: now - DAY * 4, },
confirmed: true, {
}, { keyId: 3,
keyId: 4, created_at: now - DAY * 4,
created_at: now - DAY * 18, confirmed: true,
confirmed: true, },
}, { {
keyId: 5, keyId: 4,
created_at: now - DAY, created_at: now - DAY * 18,
confirmed: true, confirmed: true,
}]; },
{
keyId: 5,
created_at: now - DAY,
confirmed: true,
},
];
let count = 0; let count = 0;
window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) { window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) {
@ -93,19 +103,24 @@ describe("AccountManager", function() {
it('keeps at least three unconfirmed keys if no confirmed', function() { it('keeps at least three unconfirmed keys if no confirmed', function() {
const now = Date.now(); const now = Date.now();
signedPreKeys = [{ signedPreKeys = [
keyId: 1, {
created_at: now - DAY * 14, keyId: 1,
}, { created_at: now - DAY * 14,
keyId: 2, },
created_at: now - DAY * 21, {
}, { keyId: 2,
keyId: 3, created_at: now - DAY * 21,
created_at: now - DAY * 18, },
}, { {
keyId: 4, keyId: 3,
created_at: now - DAY created_at: now - DAY * 18,
}]; },
{
keyId: 4,
created_at: now - DAY,
},
];
let count = 0; let count = 0;
window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) { window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) {
@ -123,21 +138,26 @@ describe("AccountManager", function() {
it('if some confirmed keys, keeps unconfirmed to addd up to three total', function() { it('if some confirmed keys, keeps unconfirmed to addd up to three total', function() {
const now = Date.now(); const now = Date.now();
signedPreKeys = [{ signedPreKeys = [
keyId: 1, {
created_at: now - DAY * 21, keyId: 1,
confirmed: true, created_at: now - DAY * 21,
}, { confirmed: true,
keyId: 2, },
created_at: now - DAY * 14, {
confirmed: true, keyId: 2,
}, { created_at: now - DAY * 14,
keyId: 3, confirmed: true,
created_at: now - DAY * 12, },
}, { {
keyId: 4, keyId: 3,
created_at: now - DAY * 8, created_at: now - DAY * 12,
}]; },
{
keyId: 4,
created_at: now - DAY * 8,
},
];
let count = 0; let count = 0;
window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) { window.textsecure.storage.protocol.removeSignedPreKey = function(keyId) {

45
libtextsecure/test/contacts_parser_test.js
View file

@ -1,19 +1,19 @@
'use strict'; 'use strict';
describe("ContactBuffer", function() { describe('ContactBuffer', function() {
function getTestBuffer() { function getTestBuffer() {
var buffer = new dcodeIO.ByteBuffer(); var buffer = new dcodeIO.ByteBuffer();
var avatarBuffer = new dcodeIO.ByteBuffer(); var avatarBuffer = new dcodeIO.ByteBuffer();
var avatarLen = 255; var avatarLen = 255;
for (var i=0; i < avatarLen; ++i) { for (var i = 0; i < avatarLen; ++i) {
avatarBuffer.writeUint8(i); avatarBuffer.writeUint8(i);
} }
avatarBuffer.limit = avatarBuffer.offset; avatarBuffer.limit = avatarBuffer.offset;
avatarBuffer.offset = 0; avatarBuffer.offset = 0;
var contactInfo = new textsecure.protobuf.ContactDetails({ var contactInfo = new textsecure.protobuf.ContactDetails({
name: "Zero Cool", name: 'Zero Cool',
number: "+10000000000", number: '+10000000000',
avatar: { contentType: "image/jpeg", length: avatarLen } avatar: { contentType: 'image/jpeg', length: avatarLen },
}); });
var contactInfoBuffer = contactInfo.encode().toArrayBuffer(); var contactInfoBuffer = contactInfo.encode().toArrayBuffer();
@ -28,21 +28,21 @@ describe("ContactBuffer", function() {
return buffer.toArrayBuffer(); return buffer.toArrayBuffer();
} }
it("parses an array buffer of contacts", function() { it('parses an array buffer of contacts', function() {
var arrayBuffer = getTestBuffer(); var arrayBuffer = getTestBuffer();
var contactBuffer = new ContactBuffer(arrayBuffer); var contactBuffer = new ContactBuffer(arrayBuffer);
var contact = contactBuffer.next(); var contact = contactBuffer.next();
var count = 0; var count = 0;
while (contact !== undefined) { while (contact !== undefined) {
count++; count++;
assert.strictEqual(contact.name, "Zero Cool"); assert.strictEqual(contact.name, 'Zero Cool');
assert.strictEqual(contact.number, "+10000000000"); assert.strictEqual(contact.number, '+10000000000');
assert.strictEqual(contact.avatar.contentType, "image/jpeg"); assert.strictEqual(contact.avatar.contentType, 'image/jpeg');
assert.strictEqual(contact.avatar.length, 255); assert.strictEqual(contact.avatar.length, 255);
assert.strictEqual(contact.avatar.data.byteLength, 255); assert.strictEqual(contact.avatar.data.byteLength, 255);
var avatarBytes = new Uint8Array(contact.avatar.data); var avatarBytes = new Uint8Array(contact.avatar.data);
for (var j=0; j < 255; ++j) { for (var j = 0; j < 255; ++j) {
assert.strictEqual(avatarBytes[j],j); assert.strictEqual(avatarBytes[j], j);
} }
contact = contactBuffer.next(); contact = contactBuffer.next();
} }
@ -50,21 +50,21 @@ describe("ContactBuffer", function() {
}); });
}); });
describe("GroupBuffer", function() { describe('GroupBuffer', function() {
function getTestBuffer() { function getTestBuffer() {
var buffer = new dcodeIO.ByteBuffer(); var buffer = new dcodeIO.ByteBuffer();
var avatarBuffer = new dcodeIO.ByteBuffer(); var avatarBuffer = new dcodeIO.ByteBuffer();
var avatarLen = 255; var avatarLen = 255;
for (var i=0; i < avatarLen; ++i) { for (var i = 0; i < avatarLen; ++i) {
avatarBuffer.writeUint8(i); avatarBuffer.writeUint8(i);
} }
avatarBuffer.limit = avatarBuffer.offset; avatarBuffer.limit = avatarBuffer.offset;
avatarBuffer.offset = 0; avatarBuffer.offset = 0;
var groupInfo = new textsecure.protobuf.GroupDetails({ var groupInfo = new textsecure.protobuf.GroupDetails({
id: new Uint8Array([1, 3, 3, 7]).buffer, id: new Uint8Array([1, 3, 3, 7]).buffer,
name: "Hackers", name: 'Hackers',
members: ['cereal', 'burn', 'phreak', 'joey'], members: ['cereal', 'burn', 'phreak', 'joey'],
avatar: { contentType: "image/jpeg", length: avatarLen } avatar: { contentType: 'image/jpeg', length: avatarLen },
}); });
var groupInfoBuffer = groupInfo.encode().toArrayBuffer(); var groupInfoBuffer = groupInfo.encode().toArrayBuffer();
@ -79,22 +79,25 @@ describe("GroupBuffer", function() {
return buffer.toArrayBuffer(); return buffer.toArrayBuffer();
} }
it("parses an array buffer of groups", function() { it('parses an array buffer of groups', function() {
var arrayBuffer = getTestBuffer(); var arrayBuffer = getTestBuffer();
var groupBuffer = new GroupBuffer(arrayBuffer); var groupBuffer = new GroupBuffer(arrayBuffer);
var group = groupBuffer.next(); var group = groupBuffer.next();
var count = 0; var count = 0;
while (group !== undefined) { while (group !== undefined) {
count++; count++;
assert.strictEqual(group.name, "Hackers"); assert.strictEqual(group.name, 'Hackers');
assertEqualArrayBuffers(group.id.toArrayBuffer(), new Uint8Array([1,3,3,7]).buffer); assertEqualArrayBuffers(
group.id.toArrayBuffer(),
new Uint8Array([1, 3, 3, 7]).buffer
);
assert.sameMembers(group.members, ['cereal', 'burn', 'phreak', 'joey']); assert.sameMembers(group.members, ['cereal', 'burn', 'phreak', 'joey']);
assert.strictEqual(group.avatar.contentType, "image/jpeg"); assert.strictEqual(group.avatar.contentType, 'image/jpeg');
assert.strictEqual(group.avatar.length, 255); assert.strictEqual(group.avatar.length, 255);
assert.strictEqual(group.avatar.data.byteLength, 255); assert.strictEqual(group.avatar.data.byteLength, 255);
var avatarBytes = new Uint8Array(group.avatar.data); var avatarBytes = new Uint8Array(group.avatar.data);
for (var j=0; j < 255; ++j) { for (var j = 0; j < 255; ++j) {
assert.strictEqual(avatarBytes[j],j); assert.strictEqual(avatarBytes[j], j);
} }
group = groupBuffer.next(); group = groupBuffer.next();
} }

64
libtextsecure/test/crypto_test.js
View file

@ -6,24 +6,38 @@ describe('encrypting and decrypting profile data', function() {
var buffer = dcodeIO.ByteBuffer.wrap(name).toArrayBuffer(); var buffer = dcodeIO.ByteBuffer.wrap(name).toArrayBuffer();
var key = libsignal.crypto.getRandomBytes(32); var key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfileName(buffer, key).then(function(encrypted) { return textsecure.crypto
assert(encrypted.byteLength === NAME_PADDED_LENGTH + 16 + 12); .encryptProfileName(buffer, key)
return textsecure.crypto.decryptProfileName(encrypted, key).then(function(decrypted) { .then(function(encrypted) {
assert.strictEqual(dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'), 'Alice'); assert(encrypted.byteLength === NAME_PADDED_LENGTH + 16 + 12);
return textsecure.crypto
.decryptProfileName(encrypted, key)
.then(function(decrypted) {
assert.strictEqual(
dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'),
'Alice'
);
});
}); });
});
}); });
it('works for empty string', function() { it('works for empty string', function() {
var name = dcodeIO.ByteBuffer.wrap('').toArrayBuffer(); var name = dcodeIO.ByteBuffer.wrap('').toArrayBuffer();
var key = libsignal.crypto.getRandomBytes(32); var key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfileName(name.buffer, key).then(function(encrypted) { return textsecure.crypto
assert(encrypted.byteLength === NAME_PADDED_LENGTH + 16 + 12); .encryptProfileName(name.buffer, key)
return textsecure.crypto.decryptProfileName(encrypted, key).then(function(decrypted) { .then(function(encrypted) {
assert.strictEqual(decrypted.byteLength, 0); assert(encrypted.byteLength === NAME_PADDED_LENGTH + 16 + 12);
assert.strictEqual(dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'), ''); return textsecure.crypto
.decryptProfileName(encrypted, key)
.then(function(decrypted) {
assert.strictEqual(decrypted.byteLength, 0);
assert.strictEqual(
dcodeIO.ByteBuffer.wrap(decrypted).toString('utf8'),
''
);
});
}); });
});
}); });
}); });
describe('encrypting and decrypting profile avatars', function() { describe('encrypting and decrypting profile avatars', function() {
@ -31,24 +45,32 @@ describe('encrypting and decrypting profile data', function() {
var buffer = dcodeIO.ByteBuffer.wrap('This is an avatar').toArrayBuffer(); var buffer = dcodeIO.ByteBuffer.wrap('This is an avatar').toArrayBuffer();
var key = libsignal.crypto.getRandomBytes(32); var key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfile(buffer, key).then(function(encrypted) { return textsecure.crypto
assert(encrypted.byteLength === buffer.byteLength + 16 + 12); .encryptProfile(buffer, key)
return textsecure.crypto.decryptProfile(encrypted, key).then(function(decrypted) { .then(function(encrypted) {
assertEqualArrayBuffers(buffer, decrypted) assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
return textsecure.crypto
.decryptProfile(encrypted, key)
.then(function(decrypted) {
assertEqualArrayBuffers(buffer, decrypted);
});
}); });
});
}); });
it('throws when decrypting with the wrong key', function() { it('throws when decrypting with the wrong key', function() {
var buffer = dcodeIO.ByteBuffer.wrap('This is an avatar').toArrayBuffer(); var buffer = dcodeIO.ByteBuffer.wrap('This is an avatar').toArrayBuffer();
var key = libsignal.crypto.getRandomBytes(32); var key = libsignal.crypto.getRandomBytes(32);
var bad_key = libsignal.crypto.getRandomBytes(32); var bad_key = libsignal.crypto.getRandomBytes(32);
return textsecure.crypto.encryptProfile(buffer, key).then(function(encrypted) { return textsecure.crypto
assert(encrypted.byteLength === buffer.byteLength + 16 + 12); .encryptProfile(buffer, key)
return textsecure.crypto.decryptProfile(encrypted, bad_key).catch(function(error) { .then(function(encrypted) {
assert.strictEqual(error.name, 'ProfileDecryptError'); assert(encrypted.byteLength === buffer.byteLength + 16 + 12);
return textsecure.crypto
.decryptProfile(encrypted, bad_key)
.catch(function(error) {
assert.strictEqual(error.name, 'ProfileDecryptError');
});
}); });
});
}); });
}); });
}); });

39
libtextsecure/test/fake_api.js
View file

@ -1,26 +1,29 @@
var getKeysForNumberMap = {}; var getKeysForNumberMap = {};
TextSecureServer.getKeysForNumber = function(number, deviceId) { TextSecureServer.getKeysForNumber = function(number, deviceId) {
var res = getKeysForNumberMap[number]; var res = getKeysForNumberMap[number];
if (res !== undefined) { if (res !== undefined) {
delete getKeysForNumberMap[number]; delete getKeysForNumberMap[number];
return Promise.resolve(res); return Promise.resolve(res);
} else } else throw new Error('getKeysForNumber of unknown/used number');
throw new Error("getKeysForNumber of unknown/used number");
}; };
var messagesSentMap = {}; var messagesSentMap = {};
TextSecureServer.sendMessages = function(destination, messageArray) { TextSecureServer.sendMessages = function(destination, messageArray) {
for (i in messageArray) { for (i in messageArray) {
var msg = messageArray[i]; var msg = messageArray[i];
if ((msg.type != 1 && msg.type != 3) || if (
msg.destinationDeviceId === undefined || (msg.type != 1 && msg.type != 3) ||
msg.destinationRegistrationId === undefined || msg.destinationDeviceId === undefined ||
msg.body === undefined || msg.destinationRegistrationId === undefined ||
msg.timestamp == undefined || msg.body === undefined ||
msg.relay !== undefined || msg.timestamp == undefined ||
msg.destination !== undefined) msg.relay !== undefined ||
throw new Error("Invalid message"); msg.destination !== undefined
)
throw new Error('Invalid message');
messagesSentMap[destination + "." + messageArray[i].destinationDeviceId] = msg; messagesSentMap[
} destination + '.' + messageArray[i].destinationDeviceId
] = msg;
}
}; };

321
libtextsecure/test/generate_keys_test.js
View file

@ -1,163 +1,190 @@
'use strict'; 'use strict';
describe("Key generation", function() { describe('Key generation', function() {
var count = 10; var count = 10;
this.timeout(count*2000); this.timeout(count * 2000);
function validateStoredKeyPair(keyPair) { function validateStoredKeyPair(keyPair) {
/* Ensure the keypair matches the format used internally by libsignal-protocol */ /* Ensure the keypair matches the format used internally by libsignal-protocol */
assert.isObject(keyPair, 'Stored keyPair is not an object'); assert.isObject(keyPair, 'Stored keyPair is not an object');
assert.instanceOf(keyPair.pubKey, ArrayBuffer); assert.instanceOf(keyPair.pubKey, ArrayBuffer);
assert.instanceOf(keyPair.privKey, ArrayBuffer); assert.instanceOf(keyPair.privKey, ArrayBuffer);
assert.strictEqual(keyPair.pubKey.byteLength, 33); assert.strictEqual(keyPair.pubKey.byteLength, 33);
assert.strictEqual(new Uint8Array(keyPair.pubKey)[0], 5); assert.strictEqual(new Uint8Array(keyPair.pubKey)[0], 5);
assert.strictEqual(keyPair.privKey.byteLength, 32); assert.strictEqual(keyPair.privKey.byteLength, 32);
} }
function itStoresPreKey(keyId) { function itStoresPreKey(keyId) {
it('prekey ' + keyId + ' is valid', function(done) { it('prekey ' + keyId + ' is valid', function(done) {
return textsecure.storage.protocol.loadPreKey(keyId).then(function(keyPair) { return textsecure.storage.protocol
validateStoredKeyPair(keyPair); .loadPreKey(keyId)
}).then(done,done); .then(function(keyPair) {
}); validateStoredKeyPair(keyPair);
} })
function itStoresSignedPreKey(keyId) { .then(done, done);
it('signed prekey ' + keyId + ' is valid', function(done) {
return textsecure.storage.protocol.loadSignedPreKey(keyId).then(function(keyPair) {
validateStoredKeyPair(keyPair);
}).then(done,done);
});
}
function validateResultKey(resultKey) {
return textsecure.storage.protocol.loadPreKey(resultKey.keyId).then(function(keyPair) {
assertEqualArrayBuffers(resultKey.publicKey, keyPair.pubKey);
});
}
function validateResultSignedKey(resultSignedKey) {
return textsecure.storage.protocol.loadSignedPreKey(resultSignedKey.keyId).then(function(keyPair) {
assertEqualArrayBuffers(resultSignedKey.publicKey, keyPair.pubKey);
});
}
before(function(done) {
localStorage.clear();
libsignal.KeyHelper.generateIdentityKeyPair().then(function(keyPair) {
return textsecure.storage.protocol.put('identityKey', keyPair);
}).then(done, done);
}); });
}
function itStoresSignedPreKey(keyId) {
it('signed prekey ' + keyId + ' is valid', function(done) {
return textsecure.storage.protocol
.loadSignedPreKey(keyId)
.then(function(keyPair) {
validateStoredKeyPair(keyPair);
})
.then(done, done);
});
}
function validateResultKey(resultKey) {
return textsecure.storage.protocol
.loadPreKey(resultKey.keyId)
.then(function(keyPair) {
assertEqualArrayBuffers(resultKey.publicKey, keyPair.pubKey);
});
}
function validateResultSignedKey(resultSignedKey) {
return textsecure.storage.protocol
.loadSignedPreKey(resultSignedKey.keyId)
.then(function(keyPair) {
assertEqualArrayBuffers(resultSignedKey.publicKey, keyPair.pubKey);
});
}
describe('the first time', function() { before(function(done) {
var result; localStorage.clear();
/* result should have this format libsignal.KeyHelper.generateIdentityKeyPair()
.then(function(keyPair) {
return textsecure.storage.protocol.put('identityKey', keyPair);
})
.then(done, done);
});
describe('the first time', function() {
var result;
/* result should have this format
* { * {
* preKeys: [ { keyId, publicKey }, ... ], * preKeys: [ { keyId, publicKey }, ... ],
* signedPreKey: { keyId, publicKey, signature }, * signedPreKey: { keyId, publicKey, signature },
* identityKey: <ArrayBuffer> * identityKey: <ArrayBuffer>
* } * }
*/ */
before(function(done) { before(function(done) {
var accountManager = new textsecure.AccountManager(''); var accountManager = new textsecure.AccountManager('');
accountManager.generateKeys(count).then(function(res) { accountManager
result = res; .generateKeys(count)
}).then(done,done); .then(function(res) {
}); result = res;
for (var i = 1; i <= count; i++) { })
itStoresPreKey(i); .then(done, done);
} });
itStoresSignedPreKey(1); for (var i = 1; i <= count; i++) {
itStoresPreKey(i);
}
itStoresSignedPreKey(1);
it('result contains ' + count + ' preKeys', function() { it('result contains ' + count + ' preKeys', function() {
assert.isArray(result.preKeys); assert.isArray(result.preKeys);
assert.lengthOf(result.preKeys, count); assert.lengthOf(result.preKeys, count);
for (var i = 0; i < count; i++) { for (var i = 0; i < count; i++) {
assert.isObject(result.preKeys[i]); assert.isObject(result.preKeys[i]);
} }
});
it('result contains the correct keyIds', function() {
for (var i = 0; i < count; i++) {
assert.strictEqual(result.preKeys[i].keyId, i+1);
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey)).then(function() {
done();
}).catch(done);
});
it('returns a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 1);
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
validateResultSignedKey(result.signedPreKey).then(done,done);
});
}); });
describe('the second time', function() { it('result contains the correct keyIds', function() {
var result; for (var i = 0; i < count; i++) {
before(function(done) { assert.strictEqual(result.preKeys[i].keyId, i + 1);
var accountManager = new textsecure.AccountManager(''); }
accountManager.generateKeys(count).then(function(res) {
result = res;
}).then(done,done);
});
for (var i = 1; i <= 2*count; i++) {
itStoresPreKey(i);
}
itStoresSignedPreKey(1);
itStoresSignedPreKey(2);
it('result contains ' + count + ' preKeys', function() {
assert.isArray(result.preKeys);
assert.lengthOf(result.preKeys, count);
for (var i = 0; i < count; i++) {
assert.isObject(result.preKeys[i]);
}
});
it('result contains the correct keyIds', function() {
for (var i = 1; i <= count; i++) {
assert.strictEqual(result.preKeys[i-1].keyId, i+count);
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey)).then(function() {
done();
}).catch(done);
});
it('returns a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 2);
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
validateResultSignedKey(result.signedPreKey).then(done,done);
});
}); });
describe('the third time', function() { it('result contains the correct public keys', function(done) {
var result; Promise.all(result.preKeys.map(validateResultKey))
before(function(done) { .then(function() {
var accountManager = new textsecure.AccountManager(''); done();
accountManager.generateKeys(count).then(function(res) { })
result = res; .catch(done);
}).then(done,done);
});
for (var i = 1; i <= 3*count; i++) {
itStoresPreKey(i);
}
itStoresSignedPreKey(2);
itStoresSignedPreKey(3);
it('result contains ' + count + ' preKeys', function() {
assert.isArray(result.preKeys);
assert.lengthOf(result.preKeys, count);
for (var i = 0; i < count; i++) {
assert.isObject(result.preKeys[i]);
}
});
it('result contains the correct keyIds', function() {
for (var i = 1; i <= count; i++) {
assert.strictEqual(result.preKeys[i-1].keyId, i+2*count);
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey)).then(function() {
done();
}).catch(done);
});
it('result contains a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 3);
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
validateResultSignedKey(result.signedPreKey).then(done,done);
});
}); });
it('returns a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 1);
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
validateResultSignedKey(result.signedPreKey).then(done, done);
});
});
describe('the second time', function() {
var result;
before(function(done) {
var accountManager = new textsecure.AccountManager('');
accountManager
.generateKeys(count)
.then(function(res) {
result = res;
})
.then(done, done);
});
for (var i = 1; i <= 2 * count; i++) {
itStoresPreKey(i);
}
itStoresSignedPreKey(1);
itStoresSignedPreKey(2);
it('result contains ' + count + ' preKeys', function() {
assert.isArray(result.preKeys);
assert.lengthOf(result.preKeys, count);
for (var i = 0; i < count; i++) {
assert.isObject(result.preKeys[i]);
}
});
it('result contains the correct keyIds', function() {
for (var i = 1; i <= count; i++) {
assert.strictEqual(result.preKeys[i - 1].keyId, i + count);
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey))
.then(function() {
done();
})
.catch(done);
});
it('returns a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 2);
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
validateResultSignedKey(result.signedPreKey).then(done, done);
});
});
describe('the third time', function() {
var result;
before(function(done) {
var accountManager = new textsecure.AccountManager('');
accountManager
.generateKeys(count)
.then(function(res) {
result = res;
})
.then(done, done);
});
for (var i = 1; i <= 3 * count; i++) {
itStoresPreKey(i);
}
itStoresSignedPreKey(2);
itStoresSignedPreKey(3);
it('result contains ' + count + ' preKeys', function() {
assert.isArray(result.preKeys);
assert.lengthOf(result.preKeys, count);
for (var i = 0; i < count; i++) {
assert.isObject(result.preKeys[i]);
}
});
it('result contains the correct keyIds', function() {
for (var i = 1; i <= count; i++) {
assert.strictEqual(result.preKeys[i - 1].keyId, i + 2 * count);
}
});
it('result contains the correct public keys', function(done) {
Promise.all(result.preKeys.map(validateResultKey))
.then(function() {
done();
})
.catch(done);
});
it('result contains a signed prekey', function(done) {
assert.strictEqual(result.signedPreKey.keyId, 3);
assert.instanceOf(result.signedPreKey.signature, ArrayBuffer);
validateResultSignedKey(result.signedPreKey).then(done, done);
});
});
}); });

48
libtextsecure/test/helpers_test.js
View file

@ -1,30 +1,32 @@
'use strict'; 'use strict';
describe("Helpers", function() { describe('Helpers', function() {
describe("ArrayBuffer->String conversion", function() { describe('ArrayBuffer->String conversion', function() {
it('works', function() { it('works', function() {
var b = new ArrayBuffer(3); var b = new ArrayBuffer(3);
var a = new Uint8Array(b); var a = new Uint8Array(b);
a[0] = 0; a[0] = 0;
a[1] = 255; a[1] = 255;
a[2] = 128; a[2] = 128;
assert.equal(getString(b), "\x00\xff\x80"); assert.equal(getString(b), '\x00\xff\x80');
}); });
}); });
describe("stringToArrayBuffer", function() { describe('stringToArrayBuffer', function() {
it('returns ArrayBuffer when passed string', function() { it('returns ArrayBuffer when passed string', function() {
var StaticArrayBufferProto = new ArrayBuffer().__proto__; var StaticArrayBufferProto = new ArrayBuffer().__proto__;
var anArrayBuffer = new ArrayBuffer(1); var anArrayBuffer = new ArrayBuffer(1);
var typedArray = new Uint8Array(anArrayBuffer); var typedArray = new Uint8Array(anArrayBuffer);
typedArray[0] = 'a'.charCodeAt(0); typedArray[0] = 'a'.charCodeAt(0);
assertEqualArrayBuffers(stringToArrayBuffer('a'), anArrayBuffer); assertEqualArrayBuffers(stringToArrayBuffer('a'), anArrayBuffer);
}); });
it('throws an error when passed a non string', function() { it('throws an error when passed a non string', function() {
var notStringable = [{}, undefined, null, new ArrayBuffer()]; var notStringable = [{}, undefined, null, new ArrayBuffer()];
notStringable.forEach(function(notString) { notStringable.forEach(function(notString) {
assert.throw(function() { stringToArrayBuffer(notString) }, Error); assert.throw(function() {
}); stringToArrayBuffer(notString);
}, Error);
}); });
});
}); });
}); });

309
libtextsecure/test/in_memory_signal_protocol_store.js
View file

@ -1,145 +1,184 @@
function SignalProtocolStore() { function SignalProtocolStore() {
this.store = {}; this.store = {};
} }
SignalProtocolStore.prototype = { SignalProtocolStore.prototype = {
Direction: { SENDING: 1, RECEIVING: 2}, Direction: { SENDING: 1, RECEIVING: 2 },
getIdentityKeyPair: function() { getIdentityKeyPair: function() {
return Promise.resolve(this.get('identityKey')); return Promise.resolve(this.get('identityKey'));
}, },
getLocalRegistrationId: function() { getLocalRegistrationId: function() {
return Promise.resolve(this.get('registrationId')); return Promise.resolve(this.get('registrationId'));
}, },
put: function(key, value) { put: function(key, value) {
if (key === undefined || value === undefined || key === null || value === null) if (
throw new Error("Tried to store undefined/null"); key === undefined ||
this.store[key] = value; value === undefined ||
}, key === null ||
get: function(key, defaultValue) { value === null
if (key === null || key === undefined) )
throw new Error("Tried to get value for undefined/null key"); throw new Error('Tried to store undefined/null');
if (key in this.store) { this.store[key] = value;
return this.store[key]; },
} else { get: function(key, defaultValue) {
return defaultValue; if (key === null || key === undefined)
} throw new Error('Tried to get value for undefined/null key');
}, if (key in this.store) {
remove: function(key) { return this.store[key];
if (key === null || key === undefined) } else {
throw new Error("Tried to remove value for undefined/null key"); return defaultValue;
delete this.store[key]; }
}, },
remove: function(key) {
if (key === null || key === undefined)
throw new Error('Tried to remove value for undefined/null key');
delete this.store[key];
},
isTrustedIdentity: function(identifier, identityKey) { isTrustedIdentity: function(identifier, identityKey) {
if (identifier === null || identifier === undefined) { if (identifier === null || identifier === undefined) {
throw new error("tried to check identity key for undefined/null key"); throw new error('tried to check identity key for undefined/null key');
} }
if (!(identityKey instanceof ArrayBuffer)) { if (!(identityKey instanceof ArrayBuffer)) {
throw new error("Expected identityKey to be an ArrayBuffer"); throw new error('Expected identityKey to be an ArrayBuffer');
} }
var trusted = this.get('identityKey' + identifier); var trusted = this.get('identityKey' + identifier);
if (trusted === undefined) { if (trusted === undefined) {
return Promise.resolve(true); return Promise.resolve(true);
} }
return Promise.resolve(identityKey === trusted); return Promise.resolve(identityKey === trusted);
}, },
loadIdentityKey: function(identifier) { loadIdentityKey: function(identifier) {
if (identifier === null || identifier === undefined) if (identifier === null || identifier === undefined)
throw new Error("Tried to get identity key for undefined/null key"); throw new Error('Tried to get identity key for undefined/null key');
return new Promise(function(resolve) { return new Promise(
resolve(this.get('identityKey' + identifier)); function(resolve) {
}.bind(this)); resolve(this.get('identityKey' + identifier));
}, }.bind(this)
saveIdentity: function(identifier, identityKey) { );
if (identifier === null || identifier === undefined) },
throw new Error("Tried to put identity key for undefined/null key"); saveIdentity: function(identifier, identityKey) {
return new Promise(function(resolve) { if (identifier === null || identifier === undefined)
var existing = this.get('identityKey' + identifier); throw new Error('Tried to put identity key for undefined/null key');
this.put('identityKey' + identifier, identityKey); return new Promise(
if (existing && existing !== identityKey) { function(resolve) {
resolve(true); var existing = this.get('identityKey' + identifier);
} else { this.put('identityKey' + identifier, identityKey);
resolve(false); if (existing && existing !== identityKey) {
} resolve(true);
}.bind(this)); } else {
}, resolve(false);
/* Returns a prekeypair object or undefined */
loadPreKey: function(keyId) {
return new Promise(function(resolve) {
var res = this.get('25519KeypreKey' + keyId);
resolve(res);
}.bind(this));
},
storePreKey: function(keyId, keyPair) {
return new Promise(function(resolve) {
resolve(this.put('25519KeypreKey' + keyId, keyPair));
}.bind(this));
},
removePreKey: function(keyId) {
return new Promise(function(resolve) {
resolve(this.remove('25519KeypreKey' + keyId));
}.bind(this));
},
/* Returns a signed keypair object or undefined */
loadSignedPreKey: function(keyId) {
return new Promise(function(resolve) {
var res = this.get('25519KeysignedKey' + keyId);
resolve(res);
}.bind(this));
},
loadSignedPreKeys: function() {
return new Promise(function(resolve) {
var res = [];
for (var i in this.store) {
if (i.startsWith('25519KeysignedKey')) {
res.push(this.store[i]);
}
}
resolve(res);
}.bind(this));
},
storeSignedPreKey: function(keyId, keyPair) {
return new Promise(function(resolve) {
resolve(this.put('25519KeysignedKey' + keyId, keyPair));
}.bind(this));
},
removeSignedPreKey: function(keyId) {
return new Promise(function(resolve) {
resolve(this.remove('25519KeysignedKey' + keyId));
}.bind(this));
},
loadSession: function(identifier) {
return new Promise(function(resolve) {
resolve(this.get('session' + identifier));
}.bind(this));
},
storeSession: function(identifier, record) {
return new Promise(function(resolve) {
resolve(this.put('session' + identifier, record));
}.bind(this));
},
removeAllSessions: function(identifier) {
return new Promise(function(resolve) {
for (key in this.store) {
if (key.match(RegExp('^session' + identifier.replace('\+','\\\+') + '.+'))) {
delete this.store[key];
} }
} }.bind(this)
resolve(); );
}.bind(this)); },
/* Returns a prekeypair object or undefined */
loadPreKey: function(keyId) {
return new Promise(
function(resolve) {
var res = this.get('25519KeypreKey' + keyId);
resolve(res);
}.bind(this)
);
},
storePreKey: function(keyId, keyPair) {
return new Promise(
function(resolve) {
resolve(this.put('25519KeypreKey' + keyId, keyPair));
}.bind(this)
);
},
removePreKey: function(keyId) {
return new Promise(
function(resolve) {
resolve(this.remove('25519KeypreKey' + keyId));
}.bind(this)
);
},
/* Returns a signed keypair object or undefined */
loadSignedPreKey: function(keyId) {
return new Promise(
function(resolve) {
var res = this.get('25519KeysignedKey' + keyId);
resolve(res);
}.bind(this)
);
},
loadSignedPreKeys: function() {
return new Promise(
function(resolve) {
var res = [];
for (var i in this.store) {
if (i.startsWith('25519KeysignedKey')) {
res.push(this.store[i]);
}
}
resolve(res);
}.bind(this)
);
},
storeSignedPreKey: function(keyId, keyPair) {
return new Promise(
function(resolve) {
resolve(this.put('25519KeysignedKey' + keyId, keyPair));
}.bind(this)
);
},
removeSignedPreKey: function(keyId) {
return new Promise(
function(resolve) {
resolve(this.remove('25519KeysignedKey' + keyId));
}.bind(this)
);
},
loadSession: function(identifier) {
return new Promise(
function(resolve) {
resolve(this.get('session' + identifier));
}.bind(this)
);
},
storeSession: function(identifier, record) {
return new Promise(
function(resolve) {
resolve(this.put('session' + identifier, record));
}.bind(this)
);
},
removeAllSessions: function(identifier) {
return new Promise(
function(resolve) {
for (key in this.store) {
if (
key.match(
RegExp('^session' + identifier.replace('+', '\\+') + '.+')
)
) {
delete this.store[key];
}
}
resolve();
}.bind(this)
);
}, },
getDeviceIds: function(identifier) { getDeviceIds: function(identifier) {
return new Promise(function(resolve) { return new Promise(
var deviceIds = []; function(resolve) {
for (key in this.store) { var deviceIds = [];
if (key.match(RegExp('^session' + identifier.replace('\+','\\\+') + '.+'))) { for (key in this.store) {
deviceIds.push(parseInt(key.split('.')[1])); if (
key.match(
RegExp('^session' + identifier.replace('+', '\\+') + '.+')
)
) {
deviceIds.push(parseInt(key.split('.')[1]));
}
} }
} resolve(deviceIds);
resolve(deviceIds); }.bind(this)
}.bind(this)); );
} },
}; };

148
libtextsecure/test/message_receiver_test.js
View file

@ -1,71 +1,99 @@
describe('MessageReceiver', function() { describe('MessageReceiver', function() {
textsecure.storage.impl = new SignalProtocolStore(); textsecure.storage.impl = new SignalProtocolStore();
var WebSocket = window.WebSocket; var WebSocket = window.WebSocket;
var number = '+19999999999'; var number = '+19999999999';
var deviceId = 1; var deviceId = 1;
var signalingKey = libsignal.crypto.getRandomBytes(32 + 20); var signalingKey = libsignal.crypto.getRandomBytes(32 + 20);
before(function() { before(function() {
window.WebSocket = MockSocket; window.WebSocket = MockSocket;
textsecure.storage.user.setNumberAndDeviceId(number, deviceId, 'name'); textsecure.storage.user.setNumberAndDeviceId(number, deviceId, 'name');
textsecure.storage.put("password", "password"); textsecure.storage.put('password', 'password');
textsecure.storage.put("signaling_key", signalingKey); textsecure.storage.put('signaling_key', signalingKey);
});
after(function() {
window.WebSocket = WebSocket;
});
describe('connecting', function() {
var blob = null;
var attrs = {
type: textsecure.protobuf.Envelope.Type.CIPHERTEXT,
source: number,
sourceDevice: deviceId,
timestamp: Date.now(),
};
var websocketmessage = new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
request: { verb: 'PUT', path: '/messages' },
}); });
after (function() { window.WebSocket = WebSocket; });
describe('connecting', function() { before(function(done) {
var blob = null; var signal = new textsecure.protobuf.Envelope(attrs).toArrayBuffer();
var attrs = { var data = new textsecure.protobuf.DataMessage({ body: 'hello' });
type: textsecure.protobuf.Envelope.Type.CIPHERTEXT,
source: number,
sourceDevice: deviceId,
timestamp: Date.now(),
};
var websocketmessage = new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
request: { verb: 'PUT', path: '/messages' }
});
before(function(done) { var signaling_key = signalingKey;
var signal = new textsecure.protobuf.Envelope(attrs).toArrayBuffer(); var aes_key = signaling_key.slice(0, 32);
var data = new textsecure.protobuf.DataMessage({ body: 'hello' }); var mac_key = signaling_key.slice(32, 32 + 20);
var signaling_key = signalingKey; window.crypto.subtle
var aes_key = signaling_key.slice(0, 32); .importKey('raw', aes_key, { name: 'AES-CBC' }, false, ['encrypt'])
var mac_key = signaling_key.slice(32, 32 + 20); .then(function(key) {
var iv = libsignal.crypto.getRandomBytes(16);
window.crypto.subtle.importKey('raw', aes_key, {name: 'AES-CBC'}, false, ['encrypt']).then(function(key) { window.crypto.subtle
var iv = libsignal.crypto.getRandomBytes(16); .encrypt({ name: 'AES-CBC', iv: new Uint8Array(iv) }, key, signal)
window.crypto.subtle.encrypt({name: 'AES-CBC', iv: new Uint8Array(iv)}, key, signal).then(function(ciphertext) { .then(function(ciphertext) {
window.crypto.subtle.importKey('raw', mac_key, {name: 'HMAC', hash: {name: 'SHA-256'}}, false, ['sign']).then(function(key) { window.crypto.subtle
window.crypto.subtle.sign( {name: 'HMAC', hash: 'SHA-256'}, key, signal).then(function(mac) { .importKey(
var version = new Uint8Array([1]); 'raw',
var message = dcodeIO.ByteBuffer.concat([version, iv, ciphertext, mac ]); mac_key,
websocketmessage.request.body = message.toArrayBuffer(); { name: 'HMAC', hash: { name: 'SHA-256' } },
console.log(new Uint8Array(message.toArrayBuffer())); false,
done(); ['sign']
}); )
.then(function(key) {
window.crypto.subtle
.sign({ name: 'HMAC', hash: 'SHA-256' }, key, signal)
.then(function(mac) {
var version = new Uint8Array([1]);
var message = dcodeIO.ByteBuffer.concat([
version,
iv,
ciphertext,
mac,
]);
websocketmessage.request.body = message.toArrayBuffer();
console.log(new Uint8Array(message.toArrayBuffer()));
done();
}); });
}); });
}); });
}); });
it('connects', function(done) {
var mockServer = new MockServer('ws://localhost:8080/v1/websocket/?login='+ encodeURIComponent(number) +'.1&password=password');
mockServer.on('connection', function(server) {
server.send(new Blob([ websocketmessage.toArrayBuffer() ]));
});
window.addEventListener('textsecure:message', function(ev) {
var signal = ev.proto;
for (var key in attrs) {
assert.strictEqual(attrs[key], signal[key]);
}
assert.strictEqual(signal.message.body, 'hello');
server.close();
done();
});
var messageReceiver = new textsecure.MessageReceiver('ws://localhost:8080', window);
});
}); });
it('connects', function(done) {
var mockServer = new MockServer(
'ws://localhost:8080/v1/websocket/?login=' +
encodeURIComponent(number) +
'.1&password=password'
);
mockServer.on('connection', function(server) {
server.send(new Blob([websocketmessage.toArrayBuffer()]));
});
window.addEventListener('textsecure:message', function(ev) {
var signal = ev.proto;
for (var key in attrs) {
assert.strictEqual(attrs[key], signal[key]);
}
assert.strictEqual(signal.message.body, 'hello');
server.close();
done();
});
var messageReceiver = new textsecure.MessageReceiver(
'ws://localhost:8080',
window
);
});
});
}); });

56
libtextsecure/test/protocol_test.js
View file

@ -1,32 +1,38 @@
'use strict'; 'use strict';
describe('Protocol', function() { describe('Protocol', function() {
describe('Unencrypted PushMessageProto "decrypt"', function() {
//exclusive
it('works', function(done) {
localStorage.clear();
describe('Unencrypted PushMessageProto "decrypt"', function() { var text_message = new textsecure.protobuf.DataMessage();
//exclusive text_message.body = 'Hi Mom';
it('works', function(done) { var server_message = {
localStorage.clear(); type: 4, // unencrypted
source: '+19999999999',
timestamp: 42,
message: text_message.encode(),
};
var text_message = new textsecure.protobuf.DataMessage(); return textsecure.protocol_wrapper
text_message.body = "Hi Mom"; .handleEncryptedMessage(
var server_message = { server_message.source,
type: 4, // unencrypted server_message.source_device,
source: "+19999999999", server_message.type,
timestamp: 42, server_message.message
message: text_message.encode() )
}; .then(function(message) {
assert.equal(message.body, text_message.body);
return textsecure.protocol_wrapper.handleEncryptedMessage( assert.equal(
server_message.source, message.attachments.length,
server_message.source_device, text_message.attachments.length
server_message.type, );
server_message.message assert.equal(text_message.attachments.length, 0);
).then(function(message) { })
assert.equal(message.body, text_message.body); .then(done)
assert.equal(message.attachments.length, text_message.attachments.length); .catch(done);
assert.equal(text_message.attachments.length, 0);
}).then(done).catch(done);
});
}); });
});
// TODO: Use fake_api's hiding of api.sendMessage to test sendmessage.js' maze // TODO: Use fake_api's hiding of api.sendMessage to test sendmessage.js' maze
}); });

60
libtextsecure/test/protocol_wrapper_test.js
View file

@ -1,32 +1,40 @@
'use strict'; 'use strict';
describe('Protocol Wrapper', function() { describe('Protocol Wrapper', function() {
var store = textsecure.storage.protocol; var store = textsecure.storage.protocol;
var identifier = '+5558675309'; var identifier = '+5558675309';
var another_identifier = '+5555590210'; var another_identifier = '+5555590210';
var prekeys, identityKey, testKey; var prekeys, identityKey, testKey;
this.timeout(5000); this.timeout(5000);
before(function(done) { before(function(done) {
localStorage.clear(); localStorage.clear();
libsignal.KeyHelper.generateIdentityKeyPair().then(function(identityKey) { libsignal.KeyHelper.generateIdentityKeyPair()
return textsecure.storage.protocol.saveIdentity(identifier, identityKey); .then(function(identityKey) {
}).then(function() { return textsecure.storage.protocol.saveIdentity(
done(); identifier,
}); identityKey
}); );
describe('processPreKey', function() { })
it('rejects if the identity key changes', function(done) { .then(function() {
var address = new libsignal.SignalProtocolAddress(identifier, 1); done();
var builder = new libsignal.SessionBuilder(store, address); });
return builder.processPreKey({ });
identityKey: textsecure.crypto.getRandomBytes(33), describe('processPreKey', function() {
encodedNumber: address.toString() it('rejects if the identity key changes', function(done) {
}).then(function() { var address = new libsignal.SignalProtocolAddress(identifier, 1);
done(new Error('Allowed to overwrite identity key')); var builder = new libsignal.SessionBuilder(store, address);
}).catch(function(e) { return builder
assert.strictEqual(e.message, 'Identity key changed'); .processPreKey({
done(); identityKey: textsecure.crypto.getRandomBytes(33),
}); encodedNumber: address.toString(),
})
.then(function() {
done(new Error('Allowed to overwrite identity key'));
})
.catch(function(e) {
assert.strictEqual(e.message, 'Identity key changed');
done();
}); });
}); });
});
}); });

328
libtextsecure/test/storage_test.js
View file

@ -1,158 +1,200 @@
'use strict'; 'use strict';
describe("SignalProtocolStore", function() { describe('SignalProtocolStore', function() {
before(function() { localStorage.clear(); }); before(function() {
var store = textsecure.storage.protocol; localStorage.clear();
var identifier = '+5558675309'; });
var another_identifier = '+5555590210'; var store = textsecure.storage.protocol;
var identityKey = { var identifier = '+5558675309';
pubKey: libsignal.crypto.getRandomBytes(33), var another_identifier = '+5555590210';
privKey: libsignal.crypto.getRandomBytes(32), var identityKey = {
}; pubKey: libsignal.crypto.getRandomBytes(33),
var testKey = { privKey: libsignal.crypto.getRandomBytes(32),
pubKey: libsignal.crypto.getRandomBytes(33), };
privKey: libsignal.crypto.getRandomBytes(32), var testKey = {
}; pubKey: libsignal.crypto.getRandomBytes(33),
it('retrieves my registration id', function(done) { privKey: libsignal.crypto.getRandomBytes(32),
store.put('registrationId', 1337); };
store.getLocalRegistrationId().then(function(reg) { it('retrieves my registration id', function(done) {
assert.strictEqual(reg, 1337); store.put('registrationId', 1337);
}).then(done, done); store
}); .getLocalRegistrationId()
it('retrieves my identity key', function(done) { .then(function(reg) {
store.put('identityKey', identityKey); assert.strictEqual(reg, 1337);
store.getIdentityKeyPair().then(function(key) { })
assertEqualArrayBuffers(key.pubKey, identityKey.pubKey); .then(done, done);
assertEqualArrayBuffers(key.privKey, identityKey.privKey); });
}).then(done,done); it('retrieves my identity key', function(done) {
}); store.put('identityKey', identityKey);
it('stores identity keys', function(done) { store
store.saveIdentity(identifier, testKey.pubKey).then(function() { .getIdentityKeyPair()
return store.loadIdentityKey(identifier).then(function(key) { .then(function(key) {
assertEqualArrayBuffers(key, testKey.pubKey); assertEqualArrayBuffers(key.pubKey, identityKey.pubKey);
}); assertEqualArrayBuffers(key.privKey, identityKey.privKey);
}).then(done,done); })
}); .then(done, done);
it('returns whether a key is trusted', function(done) { });
var newIdentity = libsignal.crypto.getRandomBytes(33); it('stores identity keys', function(done) {
store.saveIdentity(identifier, testKey.pubKey).then(function() { store
store.isTrustedIdentity(identifier, newIdentity).then(function(trusted) { .saveIdentity(identifier, testKey.pubKey)
if (trusted) { .then(function() {
done(new Error('Allowed to overwrite identity key')); return store.loadIdentityKey(identifier).then(function(key) {
} else { assertEqualArrayBuffers(key, testKey.pubKey);
done();
}
}).catch(done);
}); });
})
.then(done, done);
});
it('returns whether a key is trusted', function(done) {
var newIdentity = libsignal.crypto.getRandomBytes(33);
store.saveIdentity(identifier, testKey.pubKey).then(function() {
store
.isTrustedIdentity(identifier, newIdentity)
.then(function(trusted) {
if (trusted) {
done(new Error('Allowed to overwrite identity key'));
} else {
done();
}
})
.catch(done);
}); });
it('returns whether a key is untrusted', function(done) { });
var newIdentity = libsignal.crypto.getRandomBytes(33); it('returns whether a key is untrusted', function(done) {
store.saveIdentity(identifier, testKey.pubKey).then(function() { var newIdentity = libsignal.crypto.getRandomBytes(33);
store.isTrustedIdentity(identifier, testKey.pubKey).then(function(trusted) { store.saveIdentity(identifier, testKey.pubKey).then(function() {
if (trusted) { store
done(); .isTrustedIdentity(identifier, testKey.pubKey)
} else { .then(function(trusted) {
done(new Error('Allowed to overwrite identity key')); if (trusted) {
} done();
}).catch(done); } else {
done(new Error('Allowed to overwrite identity key'));
}
})
.catch(done);
});
});
it('stores prekeys', function(done) {
store
.storePreKey(1, testKey)
.then(function() {
return store.loadPreKey(1).then(function(key) {
assertEqualArrayBuffers(key.pubKey, testKey.pubKey);
assertEqualArrayBuffers(key.privKey, testKey.privKey);
}); });
})
.then(done, done);
});
it('deletes prekeys', function(done) {
before(function(done) {
store.storePreKey(2, testKey).then(done);
}); });
it('stores prekeys', function(done) { store
store.storePreKey(1, testKey).then(function() { .removePreKey(2, testKey)
return store.loadPreKey(1).then(function(key) { .then(function() {
assertEqualArrayBuffers(key.pubKey, testKey.pubKey); return store.loadPreKey(2).then(function(key) {
assertEqualArrayBuffers(key.privKey, testKey.privKey); assert.isUndefined(key);
});
}).then(done,done);
});
it('deletes prekeys', function(done) {
before(function(done) {
store.storePreKey(2, testKey).then(done);
}); });
store.removePreKey(2, testKey).then(function() { })
return store.loadPreKey(2).then(function(key) { .then(done, done);
assert.isUndefined(key); });
}); it('stores signed prekeys', function(done) {
}).then(done,done); store
}); .storeSignedPreKey(3, testKey)
it('stores signed prekeys', function(done) { .then(function() {
store.storeSignedPreKey(3, testKey).then(function() { return store.loadSignedPreKey(3).then(function(key) {
return store.loadSignedPreKey(3).then(function(key) { assertEqualArrayBuffers(key.pubKey, testKey.pubKey);
assertEqualArrayBuffers(key.pubKey, testKey.pubKey); assertEqualArrayBuffers(key.privKey, testKey.privKey);
assertEqualArrayBuffers(key.privKey, testKey.privKey);
});
}).then(done,done);
});
it('deletes signed prekeys', function(done) {
before(function(done) {
store.storeSignedPreKey(4, testKey).then(done);
}); });
store.removeSignedPreKey(4, testKey).then(function() { })
return store.loadSignedPreKey(4).then(function(key) { .then(done, done);
assert.isUndefined(key); });
}); it('deletes signed prekeys', function(done) {
}).then(done,done); before(function(done) {
store.storeSignedPreKey(4, testKey).then(done);
}); });
it('stores sessions', function(done) { store
var testRecord = "an opaque string"; .removeSignedPreKey(4, testKey)
var devices = [1, 2, 3].map(function(deviceId) { .then(function() {
return [identifier, deviceId].join('.'); return store.loadSignedPreKey(4).then(function(key) {
assert.isUndefined(key);
}); });
var promise = Promise.resolve(); })
devices.forEach(function(encodedNumber) { .then(done, done);
promise = promise.then(function() { });
return store.storeSession(encodedNumber, testRecord + encodedNumber) it('stores sessions', function(done) {
}); var testRecord = 'an opaque string';
}); var devices = [1, 2, 3].map(function(deviceId) {
promise.then(function() { return [identifier, deviceId].join('.');
return Promise.all(devices.map(store.loadSession.bind(store))).then(function(records) {
for (var i in records) {
assert.strictEqual(records[i], testRecord + devices[i]);
};
});
}).then(done,done);
}); });
it('removes all sessions for a number', function(done) { var promise = Promise.resolve();
var testRecord = "an opaque string"; devices.forEach(function(encodedNumber) {
var devices = [1, 2, 3].map(function(deviceId) { promise = promise.then(function() {
return [identifier, deviceId].join('.'); return store.storeSession(encodedNumber, testRecord + encodedNumber);
}); });
var promise = Promise.resolve();
devices.forEach(function(encodedNumber) {
promise = promise.then(function() {
return store.storeSession(encodedNumber, testRecord + encodedNumber)
});
});
promise.then(function() {
return store.removeAllSessions(identifier).then(function(record) {
return Promise.all(devices.map(store.loadSession.bind(store))).then(function(records) {
for (var i in records) {
assert.isUndefined(records[i]);
};
});
});
}).then(done,done);
}); });
it('returns deviceIds for a number', function(done) { promise
var testRecord = "an opaque string"; .then(function() {
var devices = [1, 2, 3].map(function(deviceId) { return Promise.all(devices.map(store.loadSession.bind(store))).then(
return [identifier, deviceId].join('.'); function(records) {
}); for (var i in records) {
var promise = Promise.resolve(); assert.strictEqual(records[i], testRecord + devices[i]);
devices.forEach(function(encodedNumber) { }
promise = promise.then(function() { }
return store.storeSession(encodedNumber, testRecord + encodedNumber) );
}); })
}); .then(done, done);
promise.then(function() { });
return store.getDeviceIds(identifier).then(function(deviceIds) { it('removes all sessions for a number', function(done) {
assert.sameMembers(deviceIds, [1, 2, 3]); var testRecord = 'an opaque string';
}); var devices = [1, 2, 3].map(function(deviceId) {
}).then(done,done); return [identifier, deviceId].join('.');
}); });
it('returns empty array for a number with no device ids', function(done) { var promise = Promise.resolve();
return store.getDeviceIds('foo').then(function(deviceIds) { devices.forEach(function(encodedNumber) {
assert.sameMembers(deviceIds,[]); promise = promise.then(function() {
}).then(done,done); return store.storeSession(encodedNumber, testRecord + encodedNumber);
});
}); });
promise
.then(function() {
return store.removeAllSessions(identifier).then(function(record) {
return Promise.all(devices.map(store.loadSession.bind(store))).then(
function(records) {
for (var i in records) {
assert.isUndefined(records[i]);
}
}
);
});
})
.then(done, done);
});
it('returns deviceIds for a number', function(done) {
var testRecord = 'an opaque string';
var devices = [1, 2, 3].map(function(deviceId) {
return [identifier, deviceId].join('.');
});
var promise = Promise.resolve();
devices.forEach(function(encodedNumber) {
promise = promise.then(function() {
return store.storeSession(encodedNumber, testRecord + encodedNumber);
});
});
promise
.then(function() {
return store.getDeviceIds(identifier).then(function(deviceIds) {
assert.sameMembers(deviceIds, [1, 2, 3]);
});
})
.then(done, done);
});
it('returns empty array for a number with no device ids', function(done) {
return store
.getDeviceIds('foo')
.then(function(deviceIds) {
assert.sameMembers(deviceIds, []);
})
.then(done, done);
});
}); });

132
libtextsecure/test/task_with_timeout_test.js
View file

@ -1,74 +1,80 @@
'use strict'; 'use strict';
describe('createTaskWithTimeout', function() { describe('createTaskWithTimeout', function() {
it('resolves when promise resolves', function() { it('resolves when promise resolves', function() {
var task = function() { var task = function() {
return Promise.resolve('hi!'); return Promise.resolve('hi!');
}; };
var taskWithTimeout = textsecure.createTaskWithTimeout(task); var taskWithTimeout = textsecure.createTaskWithTimeout(task);
return taskWithTimeout().then(function(result) { return taskWithTimeout().then(function(result) {
assert.strictEqual(result, 'hi!') assert.strictEqual(result, 'hi!');
});
}); });
it('flows error from promise back', function() { });
var error = new Error('original'); it('flows error from promise back', function() {
var task = function() { var error = new Error('original');
return Promise.reject(error); var task = function() {
}; return Promise.reject(error);
var taskWithTimeout = textsecure.createTaskWithTimeout(task); };
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
return taskWithTimeout().catch(function(flowedError) { return taskWithTimeout().catch(function(flowedError) {
assert.strictEqual(error, flowedError); assert.strictEqual(error, flowedError);
}); });
});
it('rejects if promise takes too long (this one logs error to console)', function() {
var error = new Error('original');
var complete = false;
var task = function() {
return new Promise(function(resolve) {
setTimeout(function() {
complete = true;
resolve();
}, 3000);
});
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
timeout: 10,
}); });
it('rejects if promise takes too long (this one logs error to console)', function() {
var error = new Error('original');
var complete = false;
var task = function() {
return new Promise(function(resolve) {
setTimeout(function() {
complete = true;
resolve();
}, 3000);
});
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
timeout: 10
});
return taskWithTimeout().then(function() { return taskWithTimeout().then(
throw new Error('it was not supposed to resolve!'); function() {
}, function() { throw new Error('it was not supposed to resolve!');
assert.strictEqual(complete, false); },
}); function() {
assert.strictEqual(complete, false);
}
);
});
it('resolves if task returns something falsey', function() {
var task = function() {};
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
return taskWithTimeout();
});
it('resolves if task returns a non-promise', function() {
var task = function() {
return 'hi!';
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
return taskWithTimeout().then(function(result) {
assert.strictEqual(result, 'hi!');
}); });
it('resolves if task returns something falsey', function() { });
var task = function() {}; it('rejects if task throws (and does not log about taking too long)', function() {
var taskWithTimeout = textsecure.createTaskWithTimeout(task); var error = new Error('Task is throwing!');
return taskWithTimeout(); var task = function() {
}); throw error;
it('resolves if task returns a non-promise', function() { };
var task = function() { var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
return 'hi!'; timeout: 10,
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task);
return taskWithTimeout().then(function(result) {
assert.strictEqual(result, 'hi!')
});
});
it('rejects if task throws (and does not log about taking too long)', function() {
var error = new Error('Task is throwing!');
var task = function() {
throw error;
};
var taskWithTimeout = textsecure.createTaskWithTimeout(task, this.name, {
timeout: 10
});
return taskWithTimeout().then(function(result) {
throw new Error('Overall task should reject!')
}, function(flowedError) {
assert.strictEqual(flowedError, error);
});
}); });
return taskWithTimeout().then(
function(result) {
throw new Error('Overall task should reject!');
},
function(flowedError) {
assert.strictEqual(flowedError, error);
}
);
});
}); });

367
libtextsecure/test/websocket-resources_test.js
View file

@ -1,173 +1,210 @@
;(function() { (function() {
'use strict'; 'use strict';
describe('WebSocket-Resource', function() { describe('WebSocket-Resource', function() {
describe('requests and responses', function () { describe('requests and responses', function() {
it('receives requests and sends responses', function(done) { it('receives requests and sends responses', function(done) {
// mock socket // mock socket
var request_id = '1'; var request_id = '1';
var socket = { var socket = {
send: function(data) { send: function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data); var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(message.type, textsecure.protobuf.WebSocketMessage.Type.RESPONSE); assert.strictEqual(
assert.strictEqual(message.response.message, 'OK'); message.type,
assert.strictEqual(message.response.status, 200); textsecure.protobuf.WebSocketMessage.Type.RESPONSE
assert.strictEqual(message.response.id.toString(), request_id); );
done(); assert.strictEqual(message.response.message, 'OK');
}, assert.strictEqual(message.response.status, 200);
addEventListener: function() {}, assert.strictEqual(message.response.id.toString(), request_id);
}; done();
},
addEventListener: function() {},
};
// actual test // actual test
var resource = new WebSocketResource(socket, { var resource = new WebSocketResource(socket, {
handleRequest: function (request) { handleRequest: function(request) {
assert.strictEqual(request.verb, 'PUT'); assert.strictEqual(request.verb, 'PUT');
assert.strictEqual(request.path, '/some/path'); assert.strictEqual(request.path, '/some/path');
assertEqualArrayBuffers(request.body.toArrayBuffer(), new Uint8Array([1,2,3]).buffer); assertEqualArrayBuffers(
request.respond(200, 'OK'); request.body.toArrayBuffer(),
} new Uint8Array([1, 2, 3]).buffer
}); );
request.respond(200, 'OK');
// mock socket request },
socket.onmessage({
data: new Blob([
new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
request: {
id: request_id,
verb: 'PUT',
path: '/some/path',
body: new Uint8Array([1,2,3]).buffer
}
}).encode().toArrayBuffer()
])
});
});
it('sends requests and receives responses', function(done) {
// mock socket and request handler
var request_id;
var socket = {
send: function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(message.type, textsecure.protobuf.WebSocketMessage.Type.REQUEST);
assert.strictEqual(message.request.verb, 'PUT');
assert.strictEqual(message.request.path, '/some/path');
assertEqualArrayBuffers(message.request.body.toArrayBuffer(), new Uint8Array([1,2,3]).buffer);
request_id = message.request.id;
},
addEventListener: function() {},
};
// actual test
var resource = new WebSocketResource(socket);
resource.sendRequest({
verb: 'PUT',
path: '/some/path',
body: new Uint8Array([1,2,3]).buffer,
error: done,
success: function(message, status, request) {
assert.strictEqual(message, 'OK');
assert.strictEqual(status, 200);
done();
}
});
// mock socket response
socket.onmessage({
data: new Blob([
new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.RESPONSE,
response: { id: request_id, message: 'OK', status: 200 }
}).encode().toArrayBuffer()
])
});
});
}); });
describe('close', function() { // mock socket request
before(function() { window.WebSocket = MockSocket; }); socket.onmessage({
after (function() { window.WebSocket = WebSocket; }); data: new Blob([
it('closes the connection', function(done) { new textsecure.protobuf.WebSocketMessage({
var mockServer = new MockServer('ws://localhost:8081'); type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
mockServer.on('connection', function(server) { request: {
server.on('close', done); id: request_id,
}); verb: 'PUT',
var resource = new WebSocketResource(new WebSocket('ws://localhost:8081')); path: '/some/path',
resource.close(); body: new Uint8Array([1, 2, 3]).buffer,
}); },
})
.encode()
.toArrayBuffer(),
]),
});
});
it('sends requests and receives responses', function(done) {
// mock socket and request handler
var request_id;
var socket = {
send: function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(
message.type,
textsecure.protobuf.WebSocketMessage.Type.REQUEST
);
assert.strictEqual(message.request.verb, 'PUT');
assert.strictEqual(message.request.path, '/some/path');
assertEqualArrayBuffers(
message.request.body.toArrayBuffer(),
new Uint8Array([1, 2, 3]).buffer
);
request_id = message.request.id;
},
addEventListener: function() {},
};
// actual test
var resource = new WebSocketResource(socket);
resource.sendRequest({
verb: 'PUT',
path: '/some/path',
body: new Uint8Array([1, 2, 3]).buffer,
error: done,
success: function(message, status, request) {
assert.strictEqual(message, 'OK');
assert.strictEqual(status, 200);
done();
},
}); });
describe.skip('with a keepalive config', function() { // mock socket response
before(function() { window.WebSocket = MockSocket; }); socket.onmessage({
after (function() { window.WebSocket = WebSocket; }); data: new Blob([
this.timeout(60000); new textsecure.protobuf.WebSocketMessage({
it('sends keepalives once a minute', function(done) { type: textsecure.protobuf.WebSocketMessage.Type.RESPONSE,
var mockServer = new MockServer('ws://localhost:8081'); response: { id: request_id, message: 'OK', status: 200 },
mockServer.on('connection', function(server) { })
server.on('message', function(data) { .encode()
var message = textsecure.protobuf.WebSocketMessage.decode(data); .toArrayBuffer(),
assert.strictEqual(message.type, textsecure.protobuf.WebSocketMessage.Type.REQUEST); ]),
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/v1/keepalive');
server.close();
done();
});
});
new WebSocketResource(new WebSocket('ws://localhost:8081'), {
keepalive: { path: '/v1/keepalive' }
});
});
it('uses / as a default path', function(done) {
var mockServer = new MockServer('ws://localhost:8081');
mockServer.on('connection', function(server) {
server.on('message', function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(message.type, textsecure.protobuf.WebSocketMessage.Type.REQUEST);
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/');
server.close();
done();
});
});
new WebSocketResource(new WebSocket('ws://localhost:8081'), {
keepalive: true
});
});
it('optionally disconnects if no response', function(done) {
this.timeout(65000);
var mockServer = new MockServer('ws://localhost:8081');
var socket = new WebSocket('ws://localhost:8081');
mockServer.on('connection', function(server) {
server.on('close', done);
});
new WebSocketResource(socket, { keepalive: true });
});
it('allows resetting the keepalive timer', function(done) {
this.timeout(65000);
var mockServer = new MockServer('ws://localhost:8081');
var socket = new WebSocket('ws://localhost:8081');
var startTime = Date.now();
mockServer.on('connection', function(server) {
server.on('message', function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(message.type, textsecure.protobuf.WebSocketMessage.Type.REQUEST);
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/');
assert(Date.now() > startTime + 60000, 'keepalive time should be longer than a minute');
server.close();
done();
});
});
var resource = new WebSocketResource(socket, { keepalive: true });
setTimeout(function() {
resource.resetKeepAliveTimer()
}, 5000);
});
}); });
});
}); });
}());
describe('close', function() {
before(function() {
window.WebSocket = MockSocket;
});
after(function() {
window.WebSocket = WebSocket;
});
it('closes the connection', function(done) {
var mockServer = new MockServer('ws://localhost:8081');
mockServer.on('connection', function(server) {
server.on('close', done);
});
var resource = new WebSocketResource(
new WebSocket('ws://localhost:8081')
);
resource.close();
});
});
describe.skip('with a keepalive config', function() {
before(function() {
window.WebSocket = MockSocket;
});
after(function() {
window.WebSocket = WebSocket;
});
this.timeout(60000);
it('sends keepalives once a minute', function(done) {
var mockServer = new MockServer('ws://localhost:8081');
mockServer.on('connection', function(server) {
server.on('message', function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(
message.type,
textsecure.protobuf.WebSocketMessage.Type.REQUEST
);
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/v1/keepalive');
server.close();
done();
});
});
new WebSocketResource(new WebSocket('ws://localhost:8081'), {
keepalive: { path: '/v1/keepalive' },
});
});
it('uses / as a default path', function(done) {
var mockServer = new MockServer('ws://localhost:8081');
mockServer.on('connection', function(server) {
server.on('message', function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(
message.type,
textsecure.protobuf.WebSocketMessage.Type.REQUEST
);
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/');
server.close();
done();
});
});
new WebSocketResource(new WebSocket('ws://localhost:8081'), {
keepalive: true,
});
});
it('optionally disconnects if no response', function(done) {
this.timeout(65000);
var mockServer = new MockServer('ws://localhost:8081');
var socket = new WebSocket('ws://localhost:8081');
mockServer.on('connection', function(server) {
server.on('close', done);
});
new WebSocketResource(socket, { keepalive: true });
});
it('allows resetting the keepalive timer', function(done) {
this.timeout(65000);
var mockServer = new MockServer('ws://localhost:8081');
var socket = new WebSocket('ws://localhost:8081');
var startTime = Date.now();
mockServer.on('connection', function(server) {
server.on('message', function(data) {
var message = textsecure.protobuf.WebSocketMessage.decode(data);
assert.strictEqual(
message.type,
textsecure.protobuf.WebSocketMessage.Type.REQUEST
);
assert.strictEqual(message.request.verb, 'GET');
assert.strictEqual(message.request.path, '/');
assert(
Date.now() > startTime + 60000,
'keepalive time should be longer than a minute'
);
server.close();
done();
});
});
var resource = new WebSocketResource(socket, { keepalive: true });
setTimeout(function() {
resource.resetKeepAliveTimer();
}, 5000);
});
});
});
})();

110
libtextsecure/test/websocket_test.js
View file

@ -1,62 +1,64 @@
describe('TextSecureWebSocket', function() { describe('TextSecureWebSocket', function() {
var RealWebSocket = window.WebSocket; var RealWebSocket = window.WebSocket;
before(function() { window.WebSocket = MockSocket; }); before(function() {
after (function() { window.WebSocket = RealWebSocket; }); window.WebSocket = MockSocket;
it('connects and disconnects', function(done) { });
var mockServer = new MockServer('ws://localhost:8080'); after(function() {
mockServer.on('connection', function(server) { window.WebSocket = RealWebSocket;
socket.close(); });
server.close(); it('connects and disconnects', function(done) {
done(); var mockServer = new MockServer('ws://localhost:8080');
}); mockServer.on('connection', function(server) {
var socket = new TextSecureWebSocket('ws://localhost:8080'); socket.close();
server.close();
done();
}); });
var socket = new TextSecureWebSocket('ws://localhost:8080');
});
it('sends and receives', function(done) { it('sends and receives', function(done) {
var mockServer = new MockServer('ws://localhost:8080'); var mockServer = new MockServer('ws://localhost:8080');
mockServer.on('connection', function(server) { mockServer.on('connection', function(server) {
server.on('message', function(data) { server.on('message', function(data) {
server.send('ack'); server.send('ack');
server.close(); server.close();
}); });
});
var socket = new TextSecureWebSocket('ws://localhost:8080');
socket.onmessage = function(response) {
assert.strictEqual(response.data, 'ack');
socket.close();
done();
};
socket.send('syn');
}); });
var socket = new TextSecureWebSocket('ws://localhost:8080');
socket.onmessage = function(response) {
assert.strictEqual(response.data, 'ack');
socket.close();
done();
};
socket.send('syn');
});
it('exposes the socket status', function(done) { it('exposes the socket status', function(done) {
var mockServer = new MockServer('ws://localhost:8082'); var mockServer = new MockServer('ws://localhost:8082');
mockServer.on('connection', function(server) { mockServer.on('connection', function(server) {
assert.strictEqual(socket.getStatus(), WebSocket.OPEN); assert.strictEqual(socket.getStatus(), WebSocket.OPEN);
server.close(); server.close();
socket.close(); socket.close();
});
var socket = new TextSecureWebSocket('ws://localhost:8082');
socket.onclose = function() {
assert.strictEqual(socket.getStatus(), WebSocket.CLOSING);
done();
};
});
it('reconnects', function(done) {
this.timeout(60000);
var mockServer = new MockServer('ws://localhost:8082');
var socket = new TextSecureWebSocket('ws://localhost:8082');
socket.onclose = function() {
var mockServer = new MockServer('ws://localhost:8082');
mockServer.on('connection', function(server) {
socket.close();
server.close();
done();
});
};
mockServer.close();
}); });
var socket = new TextSecureWebSocket('ws://localhost:8082');
socket.onclose = function() {
assert.strictEqual(socket.getStatus(), WebSocket.CLOSING);
done();
};
});
it('reconnects', function(done) {
this.timeout(60000);
var mockServer = new MockServer('ws://localhost:8082');
var socket = new TextSecureWebSocket('ws://localhost:8082');
socket.onclose = function() {
var mockServer = new MockServer('ws://localhost:8082');
mockServer.on('connection', function(server) {
socket.close();
server.close();
done();
});
};
mockServer.close();
});
}); });

433
libtextsecure/websocket-resources.js
View file

@ -1,7 +1,7 @@
;(function(){ (function() {
'use strict'; 'use strict';
/* /*
* WebSocket-Resources * WebSocket-Resources
* *
* Create a request-response interface over websockets using the * Create a request-response interface over websockets using the
@ -23,212 +23,233 @@
* *
*/ */
var Request = function(options) { var Request = function(options) {
this.verb = options.verb || options.type; this.verb = options.verb || options.type;
this.path = options.path || options.url; this.path = options.path || options.url;
this.body = options.body || options.data; this.body = options.body || options.data;
this.success = options.success; this.success = options.success;
this.error = options.error; this.error = options.error;
this.id = options.id; this.id = options.id;
if (this.id === undefined) { if (this.id === undefined) {
var bits = new Uint32Array(2); var bits = new Uint32Array(2);
window.crypto.getRandomValues(bits); window.crypto.getRandomValues(bits);
this.id = dcodeIO.Long.fromBits(bits[0], bits[1], true); this.id = dcodeIO.Long.fromBits(bits[0], bits[1], true);
}
if (this.body === undefined) {
this.body = null;
}
};
var IncomingWebSocketRequest = function(options) {
var request = new Request(options);
var socket = options.socket;
this.verb = request.verb;
this.path = request.path;
this.body = request.body;
this.respond = function(status, message) {
socket.send(
new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.RESPONSE,
response: { id: request.id, message: message, status: status }
}).encode().toArrayBuffer()
);
};
};
var outgoing = {};
var OutgoingWebSocketRequest = function(options, socket) {
var request = new Request(options);
outgoing[request.id] = request;
socket.send(
new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
request: {
verb : request.verb,
path : request.path,
body : request.body,
id : request.id
}
}).encode().toArrayBuffer()
);
};
window.WebSocketResource = function(socket, opts) {
opts = opts || {};
var handleRequest = opts.handleRequest;
if (typeof handleRequest !== 'function') {
handleRequest = function(request) {
request.respond(404, 'Not found');
};
}
this.sendRequest = function(options) {
return new OutgoingWebSocketRequest(options, socket);
};
socket.onmessage = function(socketMessage) {
var blob = socketMessage.data;
var handleArrayBuffer = function(buffer) {
var message = textsecure.protobuf.WebSocketMessage.decode(buffer);
if (message.type === textsecure.protobuf.WebSocketMessage.Type.REQUEST ) {
handleRequest(
new IncomingWebSocketRequest({
verb : message.request.verb,
path : message.request.path,
body : message.request.body,
id : message.request.id,
socket : socket
})
);
}
else if (message.type === textsecure.protobuf.WebSocketMessage.Type.RESPONSE ) {
var response = message.response;
var request = outgoing[response.id];
if (request) {
request.response = response;
var callback = request.error;
if (response.status >= 200 && response.status < 300) {
callback = request.success;
}
if (typeof callback === 'function') {
callback(response.message, response.status, request);
}
} else {
throw 'Received response for unknown request ' + message.response.id;
}
}
};
if (blob instanceof ArrayBuffer) {
handleArrayBuffer(blob);
} else {
var reader = new FileReader();
reader.onload = function() {
handleArrayBuffer(reader.result);
};
reader.readAsArrayBuffer(blob);
}
};
if (opts.keepalive) {
this.keepalive = new KeepAlive(this, {
path : opts.keepalive.path,
disconnect : opts.keepalive.disconnect
});
var resetKeepAliveTimer = this.keepalive.reset.bind(this.keepalive);
socket.addEventListener('open', resetKeepAliveTimer);
socket.addEventListener('message', resetKeepAliveTimer);
socket.addEventListener('close', this.keepalive.stop.bind(this.keepalive));
}
socket.addEventListener('close', function() {
this.closed = true;
}.bind(this))
this.close = function(code, reason) {
if (this.closed) {
return;
}
console.log('WebSocketResource.close()');
if (!code) {
code = 3000;
}
if (this.keepalive) {
this.keepalive.stop();
}
socket.close(code, reason);
socket.onmessage = null;
// On linux the socket can wait a long time to emit its close event if we've
// lost the internet connection. On the order of minutes. This speeds that
// process up.
setTimeout(function() {
if (this.closed) {
return;
}
this.closed = true;
console.log('Dispatching our own socket close event');
var ev = new Event('close');
ev.code = code;
ev.reason = reason;
this.dispatchEvent(ev);
}.bind(this), 1000);
};
};
window.WebSocketResource.prototype = new textsecure.EventTarget();
function KeepAlive(websocketResource, opts) {
if (websocketResource instanceof WebSocketResource) {
opts = opts || {};
this.path = opts.path;
if (this.path === undefined) {
this.path = '/';
}
this.disconnect = opts.disconnect;
if (this.disconnect === undefined) {
this.disconnect = true;
}
this.wsr = websocketResource;
} else {
throw new TypeError('KeepAlive expected a WebSocketResource');
}
} }
KeepAlive.prototype = { if (this.body === undefined) {
constructor: KeepAlive, this.body = null;
stop: function() { }
clearTimeout(this.keepAliveTimer); };
clearTimeout(this.disconnectTimer);
}, var IncomingWebSocketRequest = function(options) {
reset: function() { var request = new Request(options);
clearTimeout(this.keepAliveTimer); var socket = options.socket;
clearTimeout(this.disconnectTimer);
this.keepAliveTimer = setTimeout(function() { this.verb = request.verb;
if (this.disconnect) { this.path = request.path;
// automatically disconnect if server doesn't ack this.body = request.body;
this.disconnectTimer = setTimeout(function() {
clearTimeout(this.keepAliveTimer); this.respond = function(status, message) {
this.wsr.close(3001, 'No response to keepalive request'); socket.send(
}.bind(this), 1000); new textsecure.protobuf.WebSocketMessage({
} else { type: textsecure.protobuf.WebSocketMessage.Type.RESPONSE,
this.reset(); response: { id: request.id, message: message, status: status },
} })
console.log('Sending a keepalive message'); .encode()
this.wsr.sendRequest({ .toArrayBuffer()
verb: 'GET', );
path: this.path, };
success: this.reset.bind(this) };
});
}.bind(this), 55000); var outgoing = {};
var OutgoingWebSocketRequest = function(options, socket) {
var request = new Request(options);
outgoing[request.id] = request;
socket.send(
new textsecure.protobuf.WebSocketMessage({
type: textsecure.protobuf.WebSocketMessage.Type.REQUEST,
request: {
verb: request.verb,
path: request.path,
body: request.body,
id: request.id,
}, },
})
.encode()
.toArrayBuffer()
);
};
window.WebSocketResource = function(socket, opts) {
opts = opts || {};
var handleRequest = opts.handleRequest;
if (typeof handleRequest !== 'function') {
handleRequest = function(request) {
request.respond(404, 'Not found');
};
}
this.sendRequest = function(options) {
return new OutgoingWebSocketRequest(options, socket);
}; };
}()); socket.onmessage = function(socketMessage) {
var blob = socketMessage.data;
var handleArrayBuffer = function(buffer) {
var message = textsecure.protobuf.WebSocketMessage.decode(buffer);
if (
message.type === textsecure.protobuf.WebSocketMessage.Type.REQUEST
) {
handleRequest(
new IncomingWebSocketRequest({
verb: message.request.verb,
path: message.request.path,
body: message.request.body,
id: message.request.id,
socket: socket,
})
);
} else if (
message.type === textsecure.protobuf.WebSocketMessage.Type.RESPONSE
) {
var response = message.response;
var request = outgoing[response.id];
if (request) {
request.response = response;
var callback = request.error;
if (response.status >= 200 && response.status < 300) {
callback = request.success;
}
if (typeof callback === 'function') {
callback(response.message, response.status, request);
}
} else {
throw 'Received response for unknown request ' +
message.response.id;
}
}
};
if (blob instanceof ArrayBuffer) {
handleArrayBuffer(blob);
} else {
var reader = new FileReader();
reader.onload = function() {
handleArrayBuffer(reader.result);
};
reader.readAsArrayBuffer(blob);
}
};
if (opts.keepalive) {
this.keepalive = new KeepAlive(this, {
path: opts.keepalive.path,
disconnect: opts.keepalive.disconnect,
});
var resetKeepAliveTimer = this.keepalive.reset.bind(this.keepalive);
socket.addEventListener('open', resetKeepAliveTimer);
socket.addEventListener('message', resetKeepAliveTimer);
socket.addEventListener(
'close',
this.keepalive.stop.bind(this.keepalive)
);
}
socket.addEventListener(
'close',
function() {
this.closed = true;
}.bind(this)
);
this.close = function(code, reason) {
if (this.closed) {
return;
}
console.log('WebSocketResource.close()');
if (!code) {
code = 3000;
}
if (this.keepalive) {
this.keepalive.stop();
}
socket.close(code, reason);
socket.onmessage = null;
// On linux the socket can wait a long time to emit its close event if we've
// lost the internet connection. On the order of minutes. This speeds that
// process up.
setTimeout(
function() {
if (this.closed) {
return;
}
this.closed = true;
console.log('Dispatching our own socket close event');
var ev = new Event('close');
ev.code = code;
ev.reason = reason;
this.dispatchEvent(ev);
}.bind(this),
1000
);
};
};
window.WebSocketResource.prototype = new textsecure.EventTarget();
function KeepAlive(websocketResource, opts) {
if (websocketResource instanceof WebSocketResource) {
opts = opts || {};
this.path = opts.path;
if (this.path === undefined) {
this.path = '/';
}
this.disconnect = opts.disconnect;
if (this.disconnect === undefined) {
this.disconnect = true;
}
this.wsr = websocketResource;
} else {
throw new TypeError('KeepAlive expected a WebSocketResource');
}
}
KeepAlive.prototype = {
constructor: KeepAlive,
stop: function() {
clearTimeout(this.keepAliveTimer);
clearTimeout(this.disconnectTimer);
},
reset: function() {
clearTimeout(this.keepAliveTimer);
clearTimeout(this.disconnectTimer);
this.keepAliveTimer = setTimeout(
function() {
if (this.disconnect) {
// automatically disconnect if server doesn't ack
this.disconnectTimer = setTimeout(
function() {
clearTimeout(this.keepAliveTimer);
this.wsr.close(3001, 'No response to keepalive request');
}.bind(this),
1000
);
} else {
this.reset();
}
console.log('Sending a keepalive message');
this.wsr.sendRequest({
verb: 'GET',
path: this.path,
success: this.reset.bind(this),
});
}.bind(this),
55000
);
},
};
})();